كود PHP:
unit hdfPrayTimesUnit;
{------------------------------------------------------------------------------
Creation Date: 2009/08/16 (1388/05/25)
Author: Ebrahim Asadi
Version: 1.0.0
Description: Prayer Times Calculator. ThdfPrayTime is a class providing a set of
functions to calculate prayer times based on a variety of conventions usually
used in Muslim communities.
Notes:
It is based on Hamid Zarrabi-Zadeh PrayTimes library which is in JavaScript.
(http://tanzil.info/praytime).
History:
Date: [Fixed:, Added:, Changed:, Improved:, Removed:]
------------------------------------------------------------------------------}
interface
uses SysUtils, DateUtils, Math;
type
// Prayer Times Record
ThdfPrayerTimes = record
Fajr: Double;
Sunrise: Double;
Dhuhr: Double;
Asr: Double;
Sunset: Double;
Maghrib: Double;
Isha: Double;
end;
// Calc Method Parameters
ThdfMethodParamRecord = record
FajrAngle: Double;
MaghribSelector: Double; // (0 = angle; 1 = minutes after sunset)
MaghribParameterValue: Double; // (in angle or minutes)
IshaSelector: Double; // (0 = angle; 1 = minutes after maghrib)
IshaParameterValue: Double; // (in angle or minutes)
end;
// Sun Position Record
ThdfSunPosition = record
Declination: Double; // declination of the Sun
EquationOfTime: Double; // The Equation of Time
DistanceFromEarth: Double; // The distance of the Sun from the Earth, in astronomical units (AU)
end;
// Calculation Methods
ThdfCalculationMethod =
(
cmJafari, // Ithna Ashari
cmKarachi, // University of Islamic Sciences, Karachi
cmISNA, // Islamic Society of North America (ISNA)
cmMWL, // Muslim World League (MWL)
cmMakkah, // Umm al-Qura, Makkah
cmEgypt, // Egyptian General Authority of Survey
cmCustom, // Custom Setting
cmTehran // Institute of Geophysics, University of Tehran
);
// Juristic Methods
ThdfJuristicMethod =
(
jmShafii, // Shafii (standard)
jmHanafi // Hanafi
);
// Adjusting Methods for Higher Latitudes
ThdfAdjustingMethodForHigherLatitudes =
(
hlNone, // No adjustment
hlMidNight, // middle of night
hlOneSeventh, // 1/7th of night
hlAngleBased // angle/60th of night
);
// Time Formats
ThdfTimeFormat =
(
tfTime24, // 24-hour format
tfTime12, // 12-hour format
tfTime12NS, // 12-hour format with no suffix
tfFloat // floating point number
);
// ThdfPrayTimes class
ThdfPrayTimes = class
private
TimeFormat: ThdfTimeFormat; // time format
NumIterations: Integer; // number of iterations needed to compute times
InvalidTime: string;
JDate: Double; // Julian date
MethodParams: array[ThdfCalculationMethod] of ThdfMethodParamRecord;
FCalcMethod: ThdfCalculationMethod;
FAsrJuristic: ThdfJuristicMethod;
FAdjustHighLats: ThdfAdjustingMethodForHigherLatitudes;
FLatitude: Double;
FLongitude: Double;
FTimeZone: Double;
FDhuhrMinutes: Integer;
FDayLightSavingTime: Boolean;
function ComputeDayTimes(): ThdfPrayerTimes; // compute prayer times at given julian date
function ComputeTimes(Times: ThdfPrayerTimes): ThdfPrayerTimes; // compute prayer times at given julian date
function ComputeTime(G: Double; Time: Double): Double; // compute time for a given angle G
function DayPortion(Times: ThdfPrayerTimes): ThdfPrayerTimes; // convert hours to day portions
function SunDeclination(AJulianDate: Double): Double; // compute declination angle of sun
function ComputeMidDay(Time: Double): Double; // compute mid-day (Dhuhr, Zawal) time
function EquationOfTime(AJulianDate: Double): Double; // compute equation of time
function SunPosition(AJulianDate: Double): ThdfSunPosition; // compute declination angle of sun and equation of time
// and distance of the Sun from the Earth, in astronomical units (AU)
function AdjustTimes(Times: ThdfPrayerTimes): ThdfPrayerTimes; // adjust times in a prayer time array
function AdjustHighLatTimes(Times: ThdfPrayerTimes): ThdfPrayerTimes; // adjust Fajr, Isha and Maghrib for ********s in higher latitudes
function TimeDiff(Time1, Time2: Double): Double; // compute the difference between two times
function NightPortion(Angle: Double): Double; // the night portion used for adjusting times in higher latitudes
function ComputeAsr(Step: Integer; T: Double): Double; // compute the time of Asr
function TwoDigitsFormat(Num: Integer): string; // add a leading 0 if necessary
procedure SetCustomParams(Params: ThdfMethodParamRecord);
//---------------------- Trigonometric Functions -----------------------
function DSin(D: Double): Double; // degree sin
function DCos(D: Double): Double; // degree cos
function DTan(D: Double): Double; // degree tan
function DArcsin(X: Double): Double; // degree arcsin
function DArccos(X: Double): Double; // degree arccos
function DArctan2(Y, X: Double): Double; // degree arctan2
function DArccot(X: Double): Double; // degree arccot
function DegreeToRadian(D: Double): Double; // degree to radian
function RadianToDegree(R: Double): Double; // radian to degree
function FixHour(A: Double): Double; // range reduce hours to 0..23
function FixAngle(A: Double): Double; // range reduce angle in degrees.
procedure SetAdjustHighLats(const Value: ThdfAdjustingMethodForHigherLatitudes);
procedure SetAsrJuristic(const Value: ThdfJuristicMethod);
procedure SetCalcMethod(const Value: ThdfCalculationMethod);
procedure SetLatitude(const Value: Double);
procedure SetLongitude(const Value: Double);
procedure SetTimeZone(const Value: Double);
procedure SetDhuhrMinutes(const Value: Integer);
procedure SetDayLightSavingTime(const Value: Boolean);
public
constructor Create;
destructor Destroy; override;
function GetDatePrayerTimes(AYear, AMonth, ADay: Word; ALatitude, ALongitude, ATimeZone: Double): ThdfPrayerTimes;
function GetPrayerTimes(ADate, ALatitude, ALongitude, ATimeZone: Double): ThdfPrayerTimes;
procedure SetFajrAngle(Angle: Double);
procedure SetMaghribAngle(Angle: Double);
procedure SetIshaAngle(Angle: Double);
procedure SetMaghribMinutes(Minutes: Double); // minutes after sunset
procedure SetIshaMinutes(Minutes: Double); // minutes after maghrib
function FloatToTime12(Time: Double; NoSuffix: Boolean = False): string;
function FloatToTime24(Time: Double): string;
// caculation method
property CalcMethod: ThdfCalculationMethod read FCalcMethod write SetCalcMethod;
// Juristic method for Asr
property AsrJuristic: ThdfJuristicMethod read FAsrJuristic write SetAsrJuristic;
// adjusting method for higher latitudes
property AdjustHighLats: ThdfAdjustingMethodForHigherLatitudes read FAdjustHighLats write SetAdjustHighLats;
// latitude
property Latitude: Double read FLatitude write SetLatitude;
// longitude
property Longitude: Double read FLongitude write SetLongitude;
// time-zone
property TimeZone: Double read FTimeZone write SetTimeZone;
// minutes after mid-day for Dhuhr
property DhuhrMinutes: Integer read FDhuhrMinutes write SetDhuhrMinutes;
// Automatically add one hour to times for daylight saving times
property DayLightSavingTime: Boolean read FDayLightSavingTime write SetDayLightSavingTime;
end;
implementation
//******************************************************************************
{ ThdfPrayTime }
//******************************************************************************
function ThdfPrayTimes.adjustHighLatTimes(Times: ThdfPrayerTimes): ThdfPrayerTimes;
var
NightTime: Double;
FajrDiff: Double;
IshaAngle: Double;
IshaDiff: Double;
MaghribAngle: Double;
MaghribDiff: Double;
begin
NightTime := timeDiff(Times.Sunset, Times.Sunrise); // sunset to sunrise
// Adjust Fajr
FajrDiff := nightPortion(MethodParams[Self.calcMethod].FajrAngle) * NightTime;
if (IsNan(Times.Fajr) or (TimeDiff(Times.Fajr, Times.Sunrise) > FajrDiff)) then
begin
Times.Fajr := Times.Sunrise - FajrDiff;
end;
// Adjust Isha
if MethodParams[Self.calcMethod].IshaSelector = 0 then
begin
IshaAngle := MethodParams[Self.calcMethod].IshaParameterValue;
end
else
begin
IshaAngle := 18;
end;
IshaDiff := nightPortion(IshaAngle) * NightTime;
if (IsNan(Times.Isha) or (timeDiff(Times.Asr, Times.Isha) > IshaDiff)) then
begin
Times.Isha := Times.Asr + IshaDiff;
end;
// Adjust Maghrib
if MethodParams[Self.calcMethod].MaghribSelector = 0 then
begin
MaghribAngle := MethodParams[Self.calcMethod].MaghribParameterValue;
end
else
begin
MaghribAngle := 4;
end;
MaghribDiff := nightPortion(MaghribAngle) * NightTime;
if (IsNan(Times.Maghrib) or (timeDiff(Times.Asr, Times.Maghrib) > MaghribDiff)) then
begin
Times.Maghrib := Times.Asr + MaghribDiff;
end;
Result := Times;
end;
//******************************************************************************
function ThdfPrayTimes.adjustTimes(Times: ThdfPrayerTimes): ThdfPrayerTimes;
begin
Times.Fajr := Times.Fajr + Self.timeZone - (FLongitude / 15);
Times.Sunrise := Times.Sunrise + Self.timeZone - (FLongitude / 15);
Times.Dhuhr := Times.Dhuhr + Self.timeZone - (FLongitude / 15);
Times.Sunset := Times.Sunset + Self.timeZone - (FLongitude / 15);
Times.Asr := Times.Asr + Self.timeZone - (FLongitude / 15);
Times.Maghrib := Times.Maghrib + Self.timeZone - (FLongitude / 15);
Times.Isha := Times.Isha + Self.timeZone - (FLongitude / 15);
Times.Dhuhr := Times.Dhuhr + (FDhuhrMinutes / 60);
if MethodParams[Self.calcMethod].MaghribSelector = 1 then //maghrib
begin
Times.Maghrib := Times.Asr + (MethodParams[Self.calcMethod].MaghribParameterValue / 60);
end;
if MethodParams[Self.calcMethod].IshaSelector = 1 then //Isha
begin
Times.Isha := Times.Maghrib + (MethodParams[Self.calcMethod].IshaParameterValue / 60);
end;
if Self.adjustHighLats <> hlNone then
begin
Times := adjustHighLatTimes(Times);
end;
if FDayLightSavingTime then
begin
Times.Fajr := Times.Fajr + 1;
Times.Sunrise := Times.Sunrise + 1;
Times.Dhuhr := Times.Dhuhr + 1;
Times.Asr := Times.Asr + 1;
Times.Sunset := Times.Sunset + 1;
Times.Maghrib := Times.Maghrib + 1;
Times.Isha := Times.Isha + 1;
end;
Result := Times;
end;
//******************************************************************************
function ThdfPrayTimes.computeAsr(step: Integer; t: Double): Double;
var
D: Double;
G: Double;
begin
D := sunDeclination(Self.JDate + t);
G := - DArccot(step + Self.DTan(abs(FLatitude - D)));
Result := computeTime(G, t);
end;
//******************************************************************************
function ThdfPrayTimes.ComputeDayTimes: ThdfPrayerTimes;
var
Times: ThdfPrayerTimes;
I: Integer;
begin
//default Times
Times.Fajr := 5;
Times.Sunrise := 6;
Times.Dhuhr := 12;
Times.Asr := 13;
Times.Sunset := 18;
Times.Maghrib := 18;
Times.Isha := 18;
for I := 0 to Self.NumIterations - 1 do
begin
Times := computeTimes(Times);
end;
Times := adjustTimes(Times);
Result := Times;
end;
//******************************************************************************
function ThdfPrayTimes.ComputeMidDay(time: Double): Double;
var
T: Double;
begin
T := EquationOfTime(Self.JDate + time);
Result := FixHour(12 - T);
end;
//******************************************************************************
function ThdfPrayTimes.ComputeTime(G, Time: Double): Double;
var
D: Double;
Z: Double;
V: Double;
begin
D := SunDeclination(Self.JDate + Time);
Z := computeMidDay(Time);
V := 1/15 * DArccos((- DSin(G)- DSin(D)* DSin(FLatitude)) / (DCos(D)* DCos(FLatitude)));
if G > 90 then
begin
V := -V;
end;
Result := Z + V;
end;
//******************************************************************************
function ThdfPrayTimes.ComputeTimes(Times: ThdfPrayerTimes): ThdfPrayerTimes;
var
T: ThdfPrayerTimes;
Step: Integer;
begin
T := dayPortion(Times);
Result.Fajr := computeTime(180 - MethodParams[calcMethod].FajrAngle, T.Fajr);
Result.Sunrise := computeTime(180 - 0.833, T.Sunrise);
Result.Dhuhr := computeMidDay(T.Dhuhr);
Step := 1;
case AsrJuristic of
jmShafii: Step := 1;
jmHanafi: Step := 2;
end;
Result.Asr := computeAsr(Step, T.Asr);
Result.Sunset := computeTime(0.833, T.Sunset);;
Result.Maghrib := computeTime(MethodParams[calcMethod].MaghribParameterValue, T.Maghrib);
Result.Isha := computeTime(MethodParams[calcMethod].IshaParameterValue, T.Isha);
end;
//******************************************************************************
constructor ThdfPrayTimes.Create;
begin
calcMethod := cmJafari; // caculation method
asrJuristic := jmShafii; // Juristic method for Asr
adjustHighLats := hlMidNight; // adjusting method for higher latitudes
TimeFormat := tfTime24; // time format
dhuhrMinutes := 0; // minutes after mid-day for Dhuhr
NumIterations := 1; // number of iterations needed to compute Times
InvalidTime := '-----';
MethodParams[cmJafari].FajrAngle := 16;
MethodParams[cmJafari].MaghribSelector := 0;
MethodParams[cmJafari].MaghribParameterValue := 4;
MethodParams[cmJafari].IshaSelector := 0;
MethodParams[cmJafari].IshaParameterValue := 14;
MethodParams[cmKarachi].FajrAngle := 18;
MethodParams[cmKarachi].MaghribSelector := 1;
MethodParams[cmKarachi].MaghribParameterValue := 0;
MethodParams[cmKarachi].IshaSelector := 0;
MethodParams[cmKarachi].IshaParameterValue := 18;
MethodParams[cmISNA].FajrAngle := 15;
MethodParams[cmISNA].MaghribSelector := 1;
MethodParams[cmISNA].MaghribParameterValue := 0;
MethodParams[cmISNA].IshaSelector := 0;
MethodParams[cmISNA].IshaParameterValue := 15;
MethodParams[cmMWL].FajrAngle := 18;
MethodParams[cmMWL].MaghribSelector := 1;
MethodParams[cmMWL].MaghribParameterValue := 0;
MethodParams[cmMWL].IshaSelector := 0;
MethodParams[cmMWL].IshaParameterValue := 17;
MethodParams[cmMakkah].FajrAngle := 19;
MethodParams[cmMakkah].MaghribSelector := 1;
MethodParams[cmMakkah].MaghribParameterValue := 0;
MethodParams[cmMakkah].IshaSelector := 1;
MethodParams[cmMakkah].IshaParameterValue := 90;
MethodParams[cmEgypt].FajrAngle := 19.5;
MethodParams[cmEgypt].MaghribSelector := 1;
MethodParams[cmEgypt].MaghribParameterValue := 0;
MethodParams[cmEgypt].IshaSelector := 0;
MethodParams[cmEgypt].IshaParameterValue := 17.5;
MethodParams[cmTehran].FajrAngle := 17.7;
MethodParams[cmTehran].MaghribSelector := 0;
MethodParams[cmTehran].MaghribParameterValue := 4.5;
MethodParams[cmTehran].IshaSelector := 0;
MethodParams[cmTehran].IshaParameterValue := 15;
MethodParams[cmCustom].FajrAngle := 18;
MethodParams[cmCustom].MaghribSelector := 1;
MethodParams[cmCustom].MaghribParameterValue := 0;
MethodParams[cmCustom].IshaSelector := 0;
MethodParams[cmCustom].IshaParameterValue := 17;
end;
//******************************************************************************
function ThdfPrayTimes.DArccos(X: Double): Double;
begin
Result := RadianToDegree(ArcCos(X));
end;
//******************************************************************************
function ThdfPrayTimes.DArccot(X: Double): Double;
begin
Result := RadianToDegree(ArcTan(1/X));
end;
//******************************************************************************
function ThdfPrayTimes.DArcsin(X: Double): Double;
begin
Result := RadianToDegree(ArcSin(X));
end;
//******************************************************************************
function ThdfPrayTimes.DArctan2(Y, X: Double): Double;
begin
Result := RadianToDegree(ArcTan2(Y, X));
end;
//******************************************************************************
function ThdfPrayTimes.DayPortion(Times: ThdfPrayerTimes): ThdfPrayerTimes;
begin
Times.Fajr := Times.Fajr / 24;
Times.Sunrise := Times.Sunrise / 24;
Times.Dhuhr := Times.Dhuhr / 24;
Times.Asr := Times.Asr / 24;
Times.Sunset := Times.Sunset / 24;
Times.Maghrib := Times.Maghrib / 24;
Times.Isha := Times.Isha / 24;
Result := Times;
end;
//******************************************************************************
function ThdfPrayTimes.DCos(D: Double): Double;
begin
Result := Cos(DegreeToRadian(D));
end;
//******************************************************************************
destructor ThdfPrayTimes.Destroy;
begin
inherited;
end;
//******************************************************************************
function ThdfPrayTimes.DSin(D: Double): Double;
begin
Result := Sin(DegreeToRadian(D));
end;
//******************************************************************************
function ThdfPrayTimes.DTan(D: Double): Double;
begin
Result := Tan(DegreeToRadian(D));
end;
//******************************************************************************
function ThdfPrayTimes.DegreeToRadian(D: Double): Double;
begin
Result := (D * Pi) / 180.0;
end;
//******************************************************************************
function ThdfPrayTimes.EquationOfTime(AJulianDate: Double): Double;
begin
Result := sunPosition(AJulianDate).EquationOfTime;
end;
//******************************************************************************
function ThdfPrayTimes.FixAngle(A: Double): Double;
begin
A := A - 360.0 * (Floor(A / 360.0));
if A < 0 then
begin
A := A + 360.0;
end;
Result := A;
end;
//******************************************************************************
function ThdfPrayTimes.FixHour(A: Double): Double;
begin
A := A - 24.0 * (Floor(A / 24.0));
if A < 0 then
begin
A := A + 24.0;
end;
Result := A;
end;
//******************************************************************************
function ThdfPrayTimes.FloatToTime12(Time: Double; NoSuffix: Boolean): string;
var
Hours: Integer;
Minutes: Integer;
Seconds: Integer;
Suffix: string;
begin
if (IsNan(Time)) then
begin
Result := Self.InvalidTime;
Exit;
end;
Hours := Math.Floor(Time);
Minutes := Math.Floor((Time - Hours) * 60);
Seconds := Math.Floor((Time - Hours) * 3600 - Minutes * 60);
if Hours >= 12 then
begin
Suffix := ' PM';
end
else
begin
Suffix := ' PM';
end;
Hours := ((Hours + 12 - 1) mod 12) + 1;
Result := IntToStr(hours) + ':' + TwoDigitsFormat(Minutes) + ':' + TwoDigitsFormat(Seconds);
if not NoSuffix then
begin
Result := Result + Suffix;
end;
end;
//******************************************************************************
function ThdfPrayTimes.FloatToTime24(Time: Double): string;
var
Hours: Integer;
Minutes: Integer;
Seconds: Integer;
begin
if IsNan(Time) then
begin
Result := Self.InvalidTime;
Exit;
end;
Hours := Math.Floor(Time);
Minutes := Math.Floor((Time - Hours) * 60);
Seconds := Math.Floor((Time - Hours) * 3600 - Minutes * 60);
Result := twoDigitsFormat(Hours) + ':' + TwoDigitsFormat(Minutes) + ':' + TwoDigitsFormat(Seconds);
end;
//******************************************************************************
function ThdfPrayTimes.getDatePrayerTimes(AYear, AMonth, ADay: Word; ALatitude, ALongitude, ATimeZone: Double): ThdfPrayerTimes;
var
ADateTime: TDateTime;
begin
FLatitude := ALatitude;
FLongitude := ALongitude;
FTimeZone := ATimeZone;
ADateTime := EncodeDate(AYear, AMonth, ADay);
Self.JDate := DateTimeToJulianDate(ADateTime) - FLongitude / (15 * 24);
Result := computeDayTimes();
end;
//******************************************************************************
function ThdfPrayTimes.GetPrayerTimes(ADate, ALatitude, ALongitude, ATimeZone: Double): ThdfPrayerTimes;
var
Year: Word;
Month: Word;
Day: Word;
begin
DecodeDate(ADate, Year, Month, Day);
Result := getDatePrayerTimes(Year, Month, Day, ALatitude, ALongitude, ATimeZone);
end;
//******************************************************************************
function ThdfPrayTimes.nightPortion(Angle: Double): Double;
begin
Result := 0;
case Self.AdjustHighLats of
hlAngleBased:
begin
Result := 1/60 * Angle;
end;
hlMidNight:
begin
Result := 1/2;
end;
hlOneSeventh:
begin
Result := 1/7;
end;
end;
end;
//******************************************************************************
function ThdfPrayTimes.RadianToDegree(R: Double): Double;
begin
Result := (R * 180.0) / Pi;
end;
//******************************************************************************
procedure ThdfPrayTimes.SetAdjustHighLats(const Value: ThdfAdjustingMethodForHigherLatitudes);
begin
FAdjustHighLats := Value;
end;
//******************************************************************************
procedure ThdfPrayTimes.SetAsrJuristic(const Value: ThdfJuristicMethod);
begin
FAsrJuristic := Value;
end;
//******************************************************************************
procedure ThdfPrayTimes.SetCalcMethod(const Value: ThdfCalculationMethod);
begin
FCalcMethod := Value;
end;
//******************************************************************************
procedure ThdfPrayTimes.setCustomParams(Params: ThdfMethodParamRecord);
begin
if Params.FajrAngle = 0 then
begin
MethodParams[cmCustom].FajrAngle := MethodParams[calcMethod].FajrAngle;
end
else
begin
MethodParams[cmCustom].FajrAngle := Params.FajrAngle;
end;
if Params.MaghribSelector = 0 then
begin
MethodParams[cmCustom].MaghribSelector := MethodParams[calcMethod].MaghribSelector;
end
else
begin
MethodParams[cmCustom].MaghribSelector := Params.MaghribSelector;
end;
if Params.MaghribParameterValue = 0 then
begin
MethodParams[cmCustom].MaghribParameterValue := MethodParams[calcMethod].MaghribParameterValue;
end
else
begin
MethodParams[cmCustom].MaghribParameterValue := Params.MaghribParameterValue;
end;
if Params.IshaSelector = 0 then
begin
MethodParams[cmCustom].IshaSelector := MethodParams[calcMethod].IshaSelector;
end
else
begin
MethodParams[cmCustom].IshaSelector := Params.IshaSelector;
end;
if Params.IshaParameterValue = 0 then
begin
MethodParams[cmCustom].IshaParameterValue := MethodParams[calcMethod].IshaParameterValue;
end
else
begin
MethodParams[cmCustom].IshaParameterValue := Params.IshaParameterValue;
end;
calcMethod := cmCustom;
end;
//******************************************************************************
procedure ThdfPrayTimes.SetDayLightSavingTime(const Value: Boolean);
begin
FDayLightSavingTime := Value;
end;
//******************************************************************************
procedure ThdfPrayTimes.SetDhuhrMinutes(const Value: Integer);
begin
FDhuhrMinutes := Value;
end;
//******************************************************************************
procedure ThdfPrayTimes.SetFajrAngle(Angle: Double);
var
MethodParamRecord: ThdfMethodParamRecord;
begin
MethodParamRecord.FajrAngle := Angle;
MethodParamRecord.MaghribSelector := 0;
MethodParamRecord.MaghribParameterValue := 0;
MethodParamRecord.IshaSelector := 0;
MethodParamRecord.IshaParameterValue := 0;
SetCustomParams(MethodParamRecord);
end;
//******************************************************************************
procedure ThdfPrayTimes.SetIshaAngle(Angle: Double);
var
MethodParamRecord: ThdfMethodParamRecord;
begin
MethodParamRecord.FajrAngle := 0;
MethodParamRecord.MaghribSelector := 0;
MethodParamRecord.MaghribParameterValue := 0;
MethodParamRecord.IshaSelector := 0;
MethodParamRecord.IshaParameterValue := Angle;
SetCustomParams(MethodParamRecord);
end;
//******************************************************************************
procedure ThdfPrayTimes.SetIshaMinutes(Minutes: Double);
var
MethodParamRecord: ThdfMethodParamRecord;
begin
MethodParamRecord.FajrAngle := 0;
MethodParamRecord.MaghribSelector := 0;
MethodParamRecord.MaghribParameterValue := 0;
MethodParamRecord.IshaSelector := 1;
MethodParamRecord.IshaParameterValue := Minutes;
SetCustomParams(MethodParamRecord);
end;
//******************************************************************************
procedure ThdfPrayTimes.SetLatitude(const Value: Double);
begin
FLatitude := Value;
end;
//******************************************************************************
procedure ThdfPrayTimes.SetLongitude(const Value: Double);
begin
FLongitude := Value;
end;
//******************************************************************************
procedure ThdfPrayTimes.SetMaghribAngle(Angle: Double);
var
MethodParamRecord: ThdfMethodParamRecord;
begin
MethodParamRecord.FajrAngle := 0;
MethodParamRecord.MaghribSelector := 0;
MethodParamRecord.MaghribParameterValue := Angle;
MethodParamRecord.IshaSelector := 0;
MethodParamRecord.IshaParameterValue := 0;
SetCustomParams(MethodParamRecord);
end;
//******************************************************************************
procedure ThdfPrayTimes.SetMaghribMinutes(minutes: Double);
var
MethodParamRecord: ThdfMethodParamRecord;
begin
MethodParamRecord.FajrAngle := 0;
MethodParamRecord.MaghribSelector := 1;
MethodParamRecord.MaghribParameterValue := Minutes;
MethodParamRecord.IshaSelector := 0;
MethodParamRecord.IshaParameterValue := 0;
SetCustomParams(MethodParamRecord);
end;
//******************************************************************************
procedure ThdfPrayTimes.SetTimeZone(const Value: Double);
begin
FTimeZone := Value;
end;
//******************************************************************************
function ThdfPrayTimes.SunDeclination(AJulianDate: Double): Double;
begin
Result := SunPosition(AJulianDate).Declination;
end;
//******************************************************************************
function ThdfPrayTimes.SunPosition(AJulianDate: Double): ThdfSunPosition;
var
D: Double;
g: Double;
q: Double;
L: Double;
R: Double;
e: Double;
RA: Double;
EqT: Double;
Declination: Double;
begin
D := AJulianDate - 2451545.0; // jd is the given Julian date
g := FixAngle(357.529 + 0.98560028 * D);
q := FixAngle(280.459 + 0.98564736 * D);
L := FixAngle(q + 1.915 * DSin(g) + 0.020 * DSin(2 * g)); // L is an approximation to the Sun's geocentric
// apparent ecliptic longitude (adjusted for aberration)
R := 1.00014 - 0.01671 * DCos(g) - 0.00014 * DCos(2 * g); // The distance of the Sun from the Earth, in astronomical units (AU)
e := 23.439 - 0.00000036 * D; // mean obliquity of the ecliptic, in degrees
Declination := DArcsin(DSin(e) * DSin(L));
RA := DArctan2(DCos(e) * DSin(L), DCos(L)) / 15; // the Sun's right ascension
RA := FixHour(RA);
EqT := q/15 - RA; // The Equation of Time
Result.Declination := Declination;
Result.EquationOfTime := EqT;
Result.DistanceFromEarth := R;
end;
//******************************************************************************
function ThdfPrayTimes.timeDiff(Time1, Time2: Double): Double;
begin
Result := FixHour(Time2 - Time1);
end;
//******************************************************************************
function ThdfPrayTimes.TwoDigitsFormat(Num: Integer): string;
begin
Result := IntToStr(Num);
if Num < 10 then
begin
Result := '0' + Result;
end;
end;
//******************************************************************************
end.
( تقرير عن مشاركة سيئة )، و الموجودة أسفل كل مشاركة .
2013-08-01, 18:27
برنامج الأذان المعدل بالسي شارب
على اعتبارها لغة دخيلة على البرمجة.
العرض العادي
