public static int GetDayTerrestrialIndex(int solarYear, int solarMonth, int solarDay) { var julianDateNumber = JulianDateConverter.UniversalDateToJulianDayNumber(solarYear, solarMonth, solarDay); return((julianDateNumber + 1) % 12); }
public static int GetDayCelestialStemIndex(int solarYear, int solarMonth, int solarDay) { var julianDateNumber = JulianDateConverter.UniversalDateToJulianDayNumber(solarYear, solarMonth, solarDay); return((julianDateNumber + 9) % 10); }
private void InitLeapYear(int k, float timeZone) { int numberOfMonths = 14; Months = new Tuple <int, DateTime, bool> [numberOfMonths]; DateTime[] newMoons = new DateTime[numberOfMonths]; int[] majorTermAtMonthBeginnings = new int[numberOfMonths]; // get all the new moons, local date newMoons[0] = _month11LastYear; newMoons[numberOfMonths - 1] = _month11ThisYear; for (int i = 1; i < numberOfMonths - 1; i++) { newMoons[i] = JulianDateConverter.JulianDateToUniversalDateTime(Moon.GetNewMoon(k + i)).AddHours(timeZone).Date; } // determine leap month bool found = false; majorTermAtMonthBeginnings[0] = (int)(Sun.GetSunLongitudeAtJulianDate( newMoons[0].AddHours(-timeZone).UniversalDateTimeToJulianDate()) * 6 / Math.PI); for (int i = 0; i < numberOfMonths - 1; i++) { // If major term at the beginning of this month is same as // major term at the beginning of next month, i.e. this month // does not have major term, this month is leap month. // // Note that only the first month which does not have major term // is leap month (as a Lunar year has maximum one leap month). if (found) { Months[i] = new Tuple <int, DateTime, bool>(MonthIdxToMonthNumber((i - 1 + 11) % 12), newMoons[i], false); continue; } double julianDateAtNextMonthBeginning = newMoons[i + 1].AddHours(-timeZone).UniversalDateTimeToJulianDate(); majorTermAtMonthBeginnings[i + 1] = (int)(Sun. GetSunLongitudeAtJulianDate(julianDateAtNextMonthBeginning) * 6 / Math.PI); // In this algorithm, comparisons will happen with updated element only. // Yet be careful: initial value of elements of an int array are zeros. // This may confuse the debugging process! if (majorTermAtMonthBeginnings[i] == majorTermAtMonthBeginnings[i + 1]) { found = true; LeapMonthIndex = i; Months[i] = new Tuple <int, DateTime, bool>(MonthIdxToMonthNumber((i - 1 + 11) % 12), newMoons[i], true); } else { Months[i] = new Tuple <int, DateTime, bool>(MonthIdxToMonthNumber((i + 11) % 12), newMoons[i], false); } } Months[numberOfMonths - 1] = new Tuple <int, DateTime, bool>(11, newMoons[13], false); }
public void CalculateGregorianDate_Test() { Assert.All("julian-date-test-data.csv".ReadRecords <JD_DateTest>(), record => { var date = JulianDateConverter.CalculateGregorianDate(record.jd, record.outsetDate, record.outsetJD); Assert.Equal(date, record.date); }); }
public void CalculateJulianDate_Test() { Assert.All("julian-date-test-data2.csv".ReadRecords <JD_SimpleDateTest>(), record => { var jd = JulianDateConverter.CalculateJulianDate(record.date); Assert.Equal(jd, record.jd); }); }
public void UniversalDateToJulianDayNumberTest() { Assert.AreEqual(0, JulianDateConverter.UniversalDateToJulianDayNumber(-4712, 1, 1), 0.0000001); DateTime date = new DateTime(2000, 1, 1); Assert.AreEqual(2451545, date.UniversalDateToJulianDayNumber(), 0.0000001, String.Format("Input date: {0}", date)); Assert.AreEqual(2299160, JulianDateConverter.UniversalDateToJulianDayNumber(1582, 10, 4), 0.0000001); Assert.AreEqual(2299161, JulianDateConverter.UniversalDateToJulianDayNumber(1582, 10, 15), 0.0000001); }
public void GetSunLongitudeAtJulianDateTest() { Assert.AreEqual(4.986246180809974, Sun.GetSunLongitudeAtJulianDate(2451550.2083333335), 1E-10); //Assert.AreEqual(269.1290096900839, // Astronomy.GetSunLongitudeAtJulianDate( // Astronomy.UniversalDateTimeToJulianDate(new DateTime(2000, 12, 21).AddHours(-7))).ToDegrees(), // 1E-10); Assert.AreEqual(268.5546509479341, Sun.GetSunLongitudeAtJulianDate( JulianDateConverter.UniversalDateTimeToJulianDate(new DateTime(1990, 12, 21).AddHours(-7))).ToDegrees(), 1E-10); }
public void JulianDayNumberToUniversalDateTimeTest() { DateTime dateTime1 = new DateTime(2000, 1, 1, 6, 15, 11); DateTime dateTime2 = new DateTime(2000, 1, 1, 16, 15, 11); Assert.AreEqual(dateTime1, JulianDateConverter.JulianDateToUniversalDateTime(dateTime1.UniversalDateTimeToJulianDate())); Assert.AreEqual(dateTime2, JulianDateConverter.JulianDateToUniversalDateTime(dateTime2.UniversalDateTimeToJulianDate())); //dateTime1 = new DateTime(1582, 10, 15, 6, 15, 11); //dateTime2 = new DateTime(1582, 10, 4, 16, 15, 11); //Assert.AreEqual(dateTime1, Astronomy.JulianDateToUniversalDateTime(dateTime1.UniversalDateTimeToJulianDate())); //Assert.AreEqual(dateTime2, Astronomy.JulianDateToUniversalDateTime(dateTime2.UniversalDateTimeToJulianDate())); }
public void GetNewMoonInJulianDateTest() { //int k = 1236; double jd = Moon.GetNewMoon(1236); TimeSpan diff = (new DateTime(1999, 12, 7, 22, 32, 42)) - JulianDateConverter.JulianDateToUniversalDateTime(jd); Assert.AreEqual(2451520.4393767994, jd, 1E-10); int tollerance = 500;// milliseconds bool isPassed = (diff < TimeSpan.FromMilliseconds(tollerance)) && (diff > -TimeSpan.FromMilliseconds(tollerance)); Assert.IsTrue(isPassed, String.Format("There wwas a difference of {0} between expected and retured value.", diff)); }
private void InitNonLeapYear(int k, float timeZone) { int numberOfMonths = 13; Months = new Tuple <int, DateTime, bool> [numberOfMonths]; Months[0] = new Tuple <int, DateTime, bool>(11, _month11LastYear, false); Months[numberOfMonths - 1] = new Tuple <int, DateTime, bool>(11, _month11ThisYear, false); for (int i = 1; i < numberOfMonths - 1; i++) { var newMoon = JulianDateConverter.JulianDateToUniversalDateTime(Moon.GetNewMoon(k + i)).AddHours(timeZone).Date; Months[i] = new Tuple <int, DateTime, bool>(MonthIdxToMonthNumber((i + 11) % 12), newMoon, false); } LeapMonthIndex = -1; }
public void JulianDayNumberToUniversalDateTest() { int[] results = JulianDateConverter.JulianDayNumberToUniversalDate(0); Assert.AreEqual(-4712, results[0]); Assert.AreEqual(1, results[1]); Assert.AreEqual(1, results[2]); results = JulianDateConverter.JulianDayNumberToUniversalDate(2299160); Assert.AreEqual(1582, results[0]); Assert.AreEqual(10, results[1]); Assert.AreEqual(4, results[2]); results = JulianDateConverter.JulianDayNumberToUniversalDate(2299161); Assert.AreEqual(1582, results[0]); Assert.AreEqual(10, results[1]); Assert.AreEqual(15, results[2]); }
internal static LuniSolarDate <T> CalculateLuniSolarDateFromSolarDate(int year, int month, int day) { // Sample case 1: Solar date 24/05/2000 --- Lunar date 21/04/2000 // previousNewMoon = 04/05/2000 // lunarYear = previousNewMoon.Year = 2000 // newMoon11Before = 08/12/1999 // newMoon11After = 26/11/2000 // (04/05/2000 - 08/12/1999) / 29 = 148 days / 29 // = 5.10x // -------------------------------------------------------------- // Sample case 2: Solar date 01/01/2014 --- Lunar date 01/12/2013 // previousNewMoon = 01/01/2014 // previousNewMoon.Year = 2014 // lunarYear = 2013 // newMoon11Before = 03/12/2013 // newMoon11After = 26/11/2000 // (01/01/2014 - 03/12/2013) / 29 = 29 days / 29 // = 1 // -------------------------------------------------------------- // Sample case 3: Solar date 22/12/2033 --- Lunar date 01/11i/2033 // previousNewMoon = 22/12/2033 // lunarYear = previousNewMoon.Year = 2033 // newMoon11Before = 03/12/2032 // newMoon11After = 22/11/2033 var timeZone = ILocalInfoProvider.GetLocalInfoProvider <T>().TimeZone; int lunarYear; int lunarMonth; int lunarDay; bool isLeapMonth = false; var thisDay = new DateTime(year, month, day); var k = (int)((thisDay.AddHours(-timeZone).UniversalDateTimeToJulianDate() - 2415021.076998695) / Constants.SynodicMonth + 0.5); var previousNewMoon = JulianDateConverter.JulianDateToUniversalDateTime(Moon.GetNewMoon(k)).AddHours(timeZone).Date; while (previousNewMoon > thisDay) { previousNewMoon = JulianDateConverter.JulianDateToUniversalDateTime(Moon.GetNewMoon(--k)).AddHours(timeZone).Date; } // "previous, this/current" and "next" are not used to avoid ambiguity. var newMoon11Before = Moon.GetNewMoon11(previousNewMoon.Year - 1, timeZone).Date; var newMoon11After = Moon.GetNewMoon11(previousNewMoon.Year, timeZone).Date; // correcting for such cases as case 3 if (newMoon11After < previousNewMoon) { newMoon11Before = newMoon11After; newMoon11After = Moon.GetNewMoon11(previousNewMoon.Year + 1, timeZone).Date; } var isLeapYear = (newMoon11After - newMoon11Before).TotalDays > 365.0; var monthsFromNewMoon11Before = (int)((previousNewMoon - newMoon11Before).TotalDays / 29); /* Note: * monthsFromNewMoon11Before = 0: lunar month = 11, lunar year = previous year * monthsFromNewMoon11Before = 1: lunar month = 12, lunar year = previous year * monthsFromNewMoon11Before = 2: lunar month = 1, lunar year = this year * monthsFromNewMoon11Before = 3: lunar month = 2, lunar year = this year * and so on */ // month 11 and 12 belong to lunar year of the previous year. if (monthsFromNewMoon11Before < 2) { lunarYear = newMoon11After.Year - 1; lunarMonth = 11 + monthsFromNewMoon11Before; } else { lunarYear = newMoon11After.Year; lunarMonth = monthsFromNewMoon11Before - 1; } // correcting month number if this lunar year is leap year if (isLeapYear) { var leapMonthIndex = LuniSolarCalendar <VietnameseLocalInfoProvider> .GetLunarYear(newMoon11After.Year).LeapMonthIndex; if (monthsFromNewMoon11Before >= leapMonthIndex) { lunarMonth--; if (monthsFromNewMoon11Before == leapMonthIndex) { isLeapMonth = true; } } } lunarDay = (int)(thisDay - previousNewMoon).TotalDays + 1; return(new LuniSolarDate <T>(lunarYear, lunarMonth, isLeapMonth, lunarDay, thisDay)); }