public void Test_GK() { double jd; int year, month, day; const double needJD = 2448174.5; // 1990-10-10 [g], 1990-09-27 [j], 5751-07-21 [h] //for (int i = 0; i < 1000000; i++) { jd = CalendarConverter.gregorian_to_jd2(-4713, 11, 24); Assert.AreEqual(0.0, jd); jd = CalendarConverter.gregorian_to_jd(1990, 10, 10); Assert.AreEqual(needJD, jd); jd = CalendarConverter.julian_to_jd(1990, 09, 27); Assert.AreEqual(needJD, jd); jd = CalendarConverter.hebrew_to_jd(5751, 07, 21); Assert.AreEqual(needJD, jd); //} jd = CalendarConverter.gregorian_to_jd2(1990, 10, 10); CalendarConverter.jd_to_gregorian2((int)jd, out year, out month, out day); Assert.AreEqual(1990, year, "g2jd 1"); Assert.AreEqual(10, month, "g2jd 2"); Assert.AreEqual(10, day, "g2jd 3"); }
public void Test_Common() { DateTime gdt = new DateTime(1990, 10, 10); string s; double jd = CalendarConverter.gregorian_to_jd2(gdt.Year, gdt.Month, gdt.Day); Assert.AreEqual(2448175, jd); // jd = CalendarConverter.gregorian_to_jd2(-4713, 11, 24); Assert.AreEqual(0.0, jd); // jd = CalendarConverter.gregorian_to_jd(-4713, 11, 24); Assert.AreEqual(0.5, jd); // bad result! needs 0.0f! jd = CalendarConverter.gregorian_to_jd(gdt.Year, gdt.Month, gdt.Day); Assert.AreEqual(2448174.5, jd); // not checked! int year, month, day; CalendarConverter.jd_to_julian(jd, out year, out month, out day); s = d2s(day, CalendarData.ClassicMonths[month - 1], year, ""); Assert.AreEqual("27 September 1990, ", s); // + CalendarConverter.jd_to_hebrew(jd, out year, out month, out day); s = d2s(day, CalendarData.HebrewMonths[month - 1], year, CalendarData.HebrewWeekdays[CalendarConverter.jwday(jd)]); Assert.AreEqual("21 Tishri 5751, Dalet", s); // + CalendarConverter.jd_to_islamic(jd, out year, out month, out day); s = d2s(day, CalendarData.IslamicMonths[month - 1], year, CalendarData.IslamicWeekdays[CalendarConverter.jwday(jd)]); Assert.AreEqual("20 Rabi`al-Awwal 1411, Al-'arb`a'", s); // + CalendarConverter.jd_to_persian(jd, out year, out month, out day); s = d2s(day, CalendarData.PersianMonths[month - 1], year, CalendarData.PersianWeekdays[CalendarConverter.jwday(jd)]); Assert.AreEqual("18 Mehr 1369, Chaharshanbeh", s); // + CalendarConverter.jd_to_indian_civil(jd, out year, out month, out day); s = d2s(day, CalendarData.IndianCivilMonths[month - 1], year, CalendarData.IndianCivilWeekdays[CalendarConverter.jwday(jd)]); Assert.AreEqual("18 Asvina 1912, Budhavara", s); // + int major, cycle; CalendarConverter.jd_to_bahai(jd, out major, out cycle, out year, out month, out day); s = "major " + major.ToString() + ", cycle " + cycle.ToString() + ", "; s = s + d2s(day, CalendarData.BahaiMonths[month - 1], year, CalendarData.BahaiWeekdays[CalendarConverter.jwday(jd)]); Assert.AreEqual("major 1, cycle 8, 14 Mashíyyat 14, ‘Idál", s); // ??? }
public void Test_CP() { DateTime gdt = new DateTime(2016, 11, 28); string s; double jd; int year, month, day; jd = CalendarConverter.gregorian_to_jd2(gdt.Year, gdt.Month, gdt.Day); Assert.AreEqual(2457721, jd); // ok+ CalendarConverter.jd_to_julian2((int)jd, out year, out month, out day); s = d2s(day, CalendarData.ClassicMonths[month - 1], year, ""); Assert.AreEqual("15 November 2016, ", s); // ok+ CalendarConverter.jd_to_hebrew3((int)jd, out year, out month, out day); s = d2s(day, CalendarData.HebrewMonths[month - 1], year, ""); Assert.AreEqual("27 Heshvan 5777, ", s); // ok+ CalendarConverter.jd_to_islamic3((int)jd, out year, out month, out day); s = d2s(day, CalendarData.IslamicMonths[month - 1], year, ""); Assert.AreEqual("27 Safar 1438, ", s); // ok+ }
/// <summary> /// Calculates Julian day nubmer (JDN, https://en.wikipedia.org/wiki/Julian_day) using the specified date in /// the specified <paramref name="calendar"/>. /// Return value of this method ain't a usual JDN. See Returns section for more information. /// </summary> /// <param name="calendar">Source calendar. The <paramref name="year"/>, <paramref name="month"/> and /// <paramref name="day"/> are in this calendar.</param> /// <param name="year">Year number. Pass `UnknownYear` constant when year is unknown. /// This method DOES NOT check that `year` is inside a valid range. It's duty of a caller.</param> /// <param name="month">Month number. Pass `UnknownMonth` constant when month is unknown. /// This method DOES NOT check that `month` is inside a valid range. It's duty of a caller.</param> /// <param name="day">Day number. Pass `UnknownDay` constant when day is unknown. /// This method DOES NOT check that `day` is inside a valid range. It's duty of a caller.</param> /// <returns>Masked Julian day nubmer. See description of the <see cref="fValue"/> member for detailed /// information about masked JDN value. /// /// This method doesn't change the 27th and 28th bit ("date before" and "date after"). /// </returns> private static int CreateVal(UDNCalendarType calendar, int year, int month, int day) { int result = 0; /* * @ruslangaripov: * * The next conversation assume that `UnknownYear` member is 0. * * If all the `CalendarConverter::{calendar type}_to_jd` functions guarantee valid JDN for 0th year, we can * safely use the following code: * * int uYear = year; * * But if at least one of `CalendarConverter::{calendar type}_to_jd` functions fails on 0th year (read: * gives incorrect JDN) we HAVE TO use code like this: * * int uYear = (UnknownYear != year) ? year : 1; * * Here `1` is the first valid year for an algorithm that calculates JDN. I believe any such calculation * succeeds doing such calculation with 1st year. * * Wikipedia says that "For the year (Y) astronomical year numbering is used", and therefore I currently * stick with "0th year always valid for calculation JDN". And therefore, a * `CalendarConverter::{calendar type}_to_jd` succeeds with `UnknownYear`: * * int result = (int) (CalendarConverter::{calendar type}_to_jd(UnknownYear, uMonth, uDay)); * * `result` after the code from above is a valid JDN. */ int uYear = year; int uMonth = Math.Max(UnknownMonth + 1, month); int uDay = Math.Max(UnknownDay + 1, day); switch (calendar) { case UDNCalendarType.ctGregorian: result = CalendarConverter.gregorian_to_jd2(uYear, uMonth, uDay); // fixed break; case UDNCalendarType.ctJulian: result = CalendarConverter.julian_to_jd2(uYear, uMonth, uDay); // fixed break; case UDNCalendarType.ctHebrew: result = CalendarConverter.hebrew_to_jd3(uYear, uMonth, uDay); // fixed to the 3rd variant break; case UDNCalendarType.ctIslamic: result = CalendarConverter.islamic_to_jd3(uYear, uMonth, uDay); // fixed to the 3rd variant break; } if (UnknownYear == year) { result |= IgnoreYear; } if (UnknownMonth + 1 > month) { result |= IgnoreMonth; } if (UnknownDay + 1 > day) { result |= IgnoreDay; } return(result); }