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);
}
