// Token: 0x06002FB1 RID: 12209 RVA: 0x000B6BEC File Offset: 0x000B4DEC
private static double Nutation(double julianCenturies)
{
double degree = CalendricalCalculationsHelper.PolynomialSum(CalendricalCalculationsHelper.CoefficientsA, julianCenturies);
double degree2 = CalendricalCalculationsHelper.PolynomialSum(CalendricalCalculationsHelper.CoefficientsB, julianCenturies);
return(-0.004778 * CalendricalCalculationsHelper.SinOfDegree(degree) - 0.0003667 * CalendricalCalculationsHelper.SinOfDegree(degree2));
}
// Token: 0x06002FB4 RID: 12212 RVA: 0x000B6CA0 File Offset: 0x000B4EA0
private static double EstimatePrior(double longitude, double time)
{
double num = time - 1.0145616361111112 * CalendricalCalculationsHelper.AsSeason(CalendricalCalculationsHelper.InitLongitude(CalendricalCalculationsHelper.Compute(time) - longitude));
double num2 = CalendricalCalculationsHelper.InitLongitude(CalendricalCalculationsHelper.Compute(num) - longitude);
return(Math.Min(time, num - 1.0145616361111112 * num2));
}
// Token: 0x06002F7C RID: 12156 RVA: 0x000B5B8C File Offset: 0x000B3D8C
internal int GetDatePart(long ticks, int part)
{
PersianCalendar.CheckTicksRange(ticks);
long num = ticks / 864000000000L + 1L;
long num2 = CalendricalCalculationsHelper.PersianNewYearOnOrBefore(num);
int num3 = (int)Math.Floor((double)(num2 - PersianCalendar.PersianEpoch) / 365.242189 + 0.5) + 1;
if (part == 0)
{
return(num3);
}
int num4 = (int)(num - CalendricalCalculationsHelper.GetNumberOfDays(this.ToDateTime(num3, 1, 1, 0, 0, 0, 0, 1)));
if (part == 1)
{
return(num4);
}
int num5 = PersianCalendar.MonthFromOrdinalDay(num4);
if (part == 2)
{
return(num5);
}
int result = num4 - PersianCalendar.DaysInPreviousMonths(num5);
if (part == 3)
{
return(result);
}
throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_DateTimeParsing"));
}
// Exactly the same as GetDatePart, except computing all of
// year/month/day rather than just one of them. Used when all three
// are needed rather than redoing the computations for each.
internal void GetDate(long ticks, out int year, out int month, out int day)
{
CheckTicksRange(ticks);
// Get the absolute date. The absolute date is the number of days from January 1st, 1 A.D.
// 1/1/0001 is absolute date 1.
long numDays = ticks / GregorianCalendar.TicksPerDay + 1;
// Calculate the appromixate Persian Year.
long yearStart = CalendricalCalculationsHelper.PersianNewYearOnOrBefore(numDays);
year = (int)(Math.Floor(((yearStart - s_persianEpoch) / CalendricalCalculationsHelper.MeanTropicalYearInDays) + 0.5)) + 1;
Debug.Assert(year >= 1);
// Calculate the Persian Month.
int ordinalDay = (int)(numDays - CalendricalCalculationsHelper.GetNumberOfDays(this.ToDateTime(year, 1, 1, 0, 0, 0, 0, 1)));
month = MonthFromOrdinalDay(ordinalDay);
Debug.Assert(ordinalDay >= 1);
Debug.Assert(month >= 1 && month <= 12);
day = ordinalDay - DaysInPreviousMonths(month);
Debug.Assert(1 <= day);
Debug.Assert(day <= 31);
}
// Token: 0x06002FA8 RID: 12200 RVA: 0x000B6422 File Offset: 0x000B4622
private static double CopySign(double value, double sign)
{
if (CalendricalCalculationsHelper.IsNegative(value) != CalendricalCalculationsHelper.IsNegative(sign))
{
return(-value);
}
return(value);
}
// Token: 0x06002FB2 RID: 12210 RVA: 0x000B6C34 File Offset: 0x000B4E34
public static double Compute(double time)
{
double num = CalendricalCalculationsHelper.JulianCenturies(time);
double num2 = 282.7771834 + 36000.76953744 * num + 5.729577951308232E-06 * CalendricalCalculationsHelper.SumLongSequenceOfPeriodicTerms(num);
double longitude = num2 + CalendricalCalculationsHelper.Aberration(num) + CalendricalCalculationsHelper.Nutation(num);
return(CalendricalCalculationsHelper.InitLongitude(longitude));
}
// Token: 0x06002F9F RID: 12191 RVA: 0x000B624C File Offset: 0x000B444C
private static double DefaultEphemerisCorrection(int gregorianYear)
{
long numberOfDays = CalendricalCalculationsHelper.GetNumberOfDays(new DateTime(gregorianYear, 1, 1));
double num = (double)(numberOfDays - CalendricalCalculationsHelper.StartOf1810);
double x = 0.5 + num;
return((Math.Pow(x, 2.0) / 41048480.0 - 15.0) / 86400.0);
}
// Token: 0x06002F9B RID: 12187 RVA: 0x000B61A7 File Offset: 0x000B43A7
private static double NormalizeLongitude(double longitude)
{
longitude = CalendricalCalculationsHelper.Reminder(longitude, 360.0);
if (longitude < 0.0)
{
longitude += 360.0;
}
return(longitude);
}
// Token: 0x06002F75 RID: 12149 RVA: 0x000B59B8 File Offset: 0x000B3BB8
private long GetAbsoluteDatePersian(int year, int month, int day)
{
if (year >= 1 && year <= 9378 && month >= 1 && month <= 12)
{
int num = PersianCalendar.DaysInPreviousMonths(month) + day - 1;
int num2 = (int)(365.242189 * (double)(year - 1));
long num3 = CalendricalCalculationsHelper.PersianNewYearOnOrBefore(PersianCalendar.PersianEpoch + (long)num2 + 180L);
return(num3 + (long)num);
}
throw new ArgumentOutOfRangeException(null, Environment.GetResourceString("ArgumentOutOfRange_BadYearMonthDay"));
}
// Token: 0x06002FAF RID: 12207 RVA: 0x000B65E4 File Offset: 0x000B47E4
private static double SumLongSequenceOfPeriodicTerms(double julianCenturies)
{
double num = 0.0;
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 403406, 270.54861, 0.9287892);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 195207, 340.19128, 35999.1376958);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 119433, 63.91854, 35999.4089666);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 112392, 331.2622, 35998.7287385);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 3891, 317.843, 71998.20261);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 2819, 86.631, 71998.4403);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 1721, 240.052, 36000.35726);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 660, 310.26, 71997.4812);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 350, 247.23, 32964.4678);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 334, 260.87, -19.441);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 314, 297.82, 445267.1117);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 268, 343.14, 45036.884);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 242, 166.79, 3.1008);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 234, 81.53, 22518.4434);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 158, 3.5, -19.9739);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 132, 132.75, 65928.9345);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 129, 182.95, 9038.0293);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 114, 162.03, 3034.7684);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 99, 29.8, 33718.148);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 93, 266.4, 3034.448);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 86, 249.2, -2280.773);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 78, 157.6, 29929.992);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 72, 257.8, 31556.493);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 68, 185.1, 149.588);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 64, 69.9, 9037.75);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 46, 8.0, 107997.405);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 38, 197.1, -4444.176);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 37, 250.4, 151.771);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 32, 65.3, 67555.316);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 29, 162.7, 31556.08);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 28, 341.5, -4561.54);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 27, 291.6, 107996.706);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 27, 98.5, 1221.655);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 25, 146.7, 62894.167);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 24, 110.0, 31437.369);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 21, 5.2, 14578.298);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 21, 342.6, -31931.757);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 20, 230.9, 34777.243);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 18, 256.1, 1221.999);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 17, 45.3, 62894.511);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 14, 242.9, -4442.039);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 13, 115.2, 107997.909);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 13, 151.8, 119.066);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 13, 285.3, 16859.071);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 12, 53.3, -4.578);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 10, 126.6, 26895.292);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 10, 205.7, -39.127);
num += CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 10, 85.9, 12297.536);
return(num + CalendricalCalculationsHelper.PeriodicTerm(julianCenturies, 10, 146.1, 90073.778));
}
/*=================================GetAbsoluteDatePersian==========================
**Action: Gets the Absolute date for the given Persian date. The absolute date means
** the number of days from January 1st, 1 A.D.
**Returns:
**Arguments:
**Exceptions:
**============================================================================*/
private long GetAbsoluteDatePersian(int year, int month, int day)
{
if (year >= 1 && year <= MaxCalendarYear && month >= 1 && month <= 12)
{
int ordinalDay = DaysInPreviousMonths(month) + day - 1; // day is one based, make 0 based since this will be the number of days we add to beginning of year below
int approximateDaysFromEpochForYearStart = (int)(CalendricalCalculationsHelper.MeanTropicalYearInDays * (year - 1));
long yearStart = CalendricalCalculationsHelper.PersianNewYearOnOrBefore(PersianEpoch + approximateDaysFromEpochForYearStart + ApproximateHalfYear);
yearStart += ordinalDay;
return(yearStart);
}
throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_BadYearMonthDay);
}
internal int GetDatePart(long ticks, int part)
{
CheckTicksRange(ticks);
// Get the absolute date. The absolute date is the number of days from January 1st, 1 A.D.
// 1/1/0001 is absolute date 1.
long numDays = ticks / GregorianCalendar.TicksPerDay + 1;
// Calculate the appromixate Persian Year.
long yearStart = CalendricalCalculationsHelper.PersianNewYearOnOrBefore(numDays);
int y = (int)(Math.Floor(((yearStart - s_persianEpoch) / CalendricalCalculationsHelper.MeanTropicalYearInDays) + 0.5)) + 1;
Debug.Assert(y >= 1);
if (part == DatePartYear)
{
return(y);
}
// Calculate the Persian Month.
int ordinalDay = (int)(numDays - CalendricalCalculationsHelper.GetNumberOfDays(this.ToDateTime(y, 1, 1, 0, 0, 0, 0, 1)));
if (part == DatePartDayOfYear)
{
return(ordinalDay);
}
int m = MonthFromOrdinalDay(ordinalDay);
Debug.Assert(ordinalDay >= 1);
Debug.Assert(m >= 1 && m <= 12);
if (part == DatePartMonth)
{
return(m);
}
int d = ordinalDay - DaysInPreviousMonths(m);
Debug.Assert(1 <= d);
Debug.Assert(d <= 31);
// Calculate the Persian Day.
if (part == DatePartDay)
{
return(d);
}
// Incorrect part value.
throw new InvalidOperationException(SR.InvalidOperation_DateTimeParsing);
}
// Token: 0x06002FA9 RID: 12201 RVA: 0x000B6438 File Offset: 0x000B4638
private static double EquationOfTime(double time)
{
double num = CalendricalCalculationsHelper.JulianCenturies(time);
double num2 = CalendricalCalculationsHelper.PolynomialSum(CalendricalCalculationsHelper.LambdaCoefficients, num);
double num3 = CalendricalCalculationsHelper.PolynomialSum(CalendricalCalculationsHelper.AnomalyCoefficients, num);
double num4 = CalendricalCalculationsHelper.PolynomialSum(CalendricalCalculationsHelper.EccentricityCoefficients, num);
double num5 = CalendricalCalculationsHelper.Obliquity(num);
double num6 = CalendricalCalculationsHelper.TanOfDegree(num5 / 2.0);
double num7 = num6 * num6;
double num8 = num7 * CalendricalCalculationsHelper.SinOfDegree(2.0 * num2) - 2.0 * num4 * CalendricalCalculationsHelper.SinOfDegree(num3) + 4.0 * num4 * num7 * CalendricalCalculationsHelper.SinOfDegree(num3) * CalendricalCalculationsHelper.CosOfDegree(2.0 * num2) - 0.5 * Math.Pow(num7, 2.0) * CalendricalCalculationsHelper.SinOfDegree(4.0 * num2) - 1.25 * Math.Pow(num4, 2.0) * CalendricalCalculationsHelper.SinOfDegree(2.0 * num3);
double num9 = 6.283185307179586;
double num10 = num8 / num9;
return(CalendricalCalculationsHelper.CopySign(Math.Min(Math.Abs(num10), 0.5), num10));
}
// Token: 0x06002FA5 RID: 12197 RVA: 0x000B6358 File Offset: 0x000B4558
private static double EphemerisCorrection(double time)
{
int gregorianYear = CalendricalCalculationsHelper.GetGregorianYear(time);
CalendricalCalculationsHelper.EphemerisCorrectionAlgorithmMap[] ephemerisCorrectionTable = CalendricalCalculationsHelper.EphemerisCorrectionTable;
int i = 0;
while (i < ephemerisCorrectionTable.Length)
{
CalendricalCalculationsHelper.EphemerisCorrectionAlgorithmMap ephemerisCorrectionAlgorithmMap = ephemerisCorrectionTable[i];
if (ephemerisCorrectionAlgorithmMap._lowestYear <= gregorianYear)
{
switch (ephemerisCorrectionAlgorithmMap._algorithm)
{
case CalendricalCalculationsHelper.CorrectionAlgorithm.Default:
return(CalendricalCalculationsHelper.DefaultEphemerisCorrection(gregorianYear));
case CalendricalCalculationsHelper.CorrectionAlgorithm.Year1988to2019:
return(CalendricalCalculationsHelper.EphemerisCorrection1988to2019(gregorianYear));
case CalendricalCalculationsHelper.CorrectionAlgorithm.Year1900to1987:
return(CalendricalCalculationsHelper.EphemerisCorrection1900to1987(gregorianYear));
case CalendricalCalculationsHelper.CorrectionAlgorithm.Year1800to1899:
return(CalendricalCalculationsHelper.EphemerisCorrection1800to1899(gregorianYear));
case CalendricalCalculationsHelper.CorrectionAlgorithm.Year1700to1799:
return(CalendricalCalculationsHelper.EphemerisCorrection1700to1799(gregorianYear));
case CalendricalCalculationsHelper.CorrectionAlgorithm.Year1620to1699:
return(CalendricalCalculationsHelper.EphemerisCorrection1620to1699(gregorianYear));
default:
goto IL_7F;
}
}
else
{
i++;
}
}
IL_7F:
return(CalendricalCalculationsHelper.DefaultEphemerisCorrection(gregorianYear));
}
// Token: 0x06002FB5 RID: 12213 RVA: 0x000B6CF0 File Offset: 0x000B4EF0
internal static long PersianNewYearOnOrBefore(long numberOfDays)
{
double date = (double)numberOfDays;
double d = CalendricalCalculationsHelper.EstimatePrior(0.0, CalendricalCalculationsHelper.MiddayAtPersianObservationSite(date));
long num = (long)Math.Floor(d) - 1L;
long num2 = num + 3L;
long num3;
for (num3 = num; num3 != num2; num3 += 1L)
{
double time = CalendricalCalculationsHelper.MiddayAtPersianObservationSite((double)num3);
double num4 = CalendricalCalculationsHelper.Compute(time);
if (0.0 <= num4 && num4 <= 2.0)
{
break;
}
}
return(num3 - 1L);
}
// Token: 0x06002F9E RID: 12190 RVA: 0x000B621C File Offset: 0x000B441C
private static double CenturiesFrom1900(int gregorianYear)
{
long numberOfDays = CalendricalCalculationsHelper.GetNumberOfDays(new DateTime(gregorianYear, 7, 1));
return((double)(numberOfDays - CalendricalCalculationsHelper.StartOf1900Century) / 36525.0);
}
// Token: 0x06002FA4 RID: 12196 RVA: 0x000B632C File Offset: 0x000B452C
private static double EphemerisCorrection1620to1699(int gregorianYear)
{
double indeterminate = (double)(gregorianYear - 1600);
return(CalendricalCalculationsHelper.PolynomialSum(CalendricalCalculationsHelper.Coefficients1620to1699, indeterminate) / 86400.0);
}
// Token: 0x06002F97 RID: 12183 RVA: 0x000B6129 File Offset: 0x000B4329
private static double Obliquity(double julianCenturies)
{
return(CalendricalCalculationsHelper.PolynomialSum(CalendricalCalculationsHelper.Coefficients, julianCenturies));
}
// Token: 0x06002FAC RID: 12204 RVA: 0x000B65A0 File Offset: 0x000B47A0
private static double InitLongitude(double longitude)
{
return(CalendricalCalculationsHelper.NormalizeLongitude(longitude + 180.0) - 180.0);
}
// Token: 0x06002FA6 RID: 12198 RVA: 0x000B63EC File Offset: 0x000B45EC
public static double JulianCenturies(double moment)
{
double num = moment + CalendricalCalculationsHelper.EphemerisCorrection(moment);
return((num - 730120.5) / 36525.0);
}
// Token: 0x06002FB0 RID: 12208 RVA: 0x000B6BBC File Offset: 0x000B4DBC
private static double Aberration(double julianCenturies)
{
return(9.74E-05 * CalendricalCalculationsHelper.CosOfDegree(177.63 + 35999.01848 * julianCenturies) - 0.005575);
}
// Token: 0x06002FAA RID: 12202 RVA: 0x000B6568 File Offset: 0x000B4768
private static double AsLocalTime(double apparentMidday, double longitude)
{
double time = apparentMidday - CalendricalCalculationsHelper.AsDayFraction(longitude);
return(apparentMidday - CalendricalCalculationsHelper.EquationOfTime(time));
}
// Token: 0x06002F95 RID: 12181 RVA: 0x000B60FF File Offset: 0x000B42FF
private static double TanOfDegree(double degree)
{
return(Math.Tan(CalendricalCalculationsHelper.RadiansFromDegrees(degree)));
}
// Token: 0x06002FAD RID: 12205 RVA: 0x000B65BC File Offset: 0x000B47BC
public static double MiddayAtPersianObservationSite(double date)
{
return(CalendricalCalculationsHelper.Midday(date, CalendricalCalculationsHelper.InitLongitude(52.5)));
}
// Token: 0x06002FA2 RID: 12194 RVA: 0x000B62E0 File Offset: 0x000B44E0
private static double EphemerisCorrection1800to1899(int gregorianYear)
{
double indeterminate = CalendricalCalculationsHelper.CenturiesFrom1900(gregorianYear);
return(CalendricalCalculationsHelper.PolynomialSum(CalendricalCalculationsHelper.Coefficients1800to1899, indeterminate));
}
// Token: 0x06002FAE RID: 12206 RVA: 0x000B65D2 File Offset: 0x000B47D2
private static double PeriodicTerm(double julianCenturies, int x, double y, double z)
{
return((double)x * CalendricalCalculationsHelper.SinOfDegree(y + z * julianCenturies));
}
// Token: 0x06002FAB RID: 12203 RVA: 0x000B6586 File Offset: 0x000B4786
public static double Midday(double date, double longitude)
{
return(CalendricalCalculationsHelper.AsLocalTime(date + 0.5, longitude) - CalendricalCalculationsHelper.AsDayFraction(longitude));
}
