/***************************************************************************
* Copyright (C) 2003 by Jonathan Singer *
* jsinger@leeta.net *
* Calendar routines from Hebrew Calendar by Frank Yellin *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
***************************************************************************/
#include "converter.h"
#include <klocale.h>
Converter::Converter()
{
}
Converter::~Converter()
{
}
long Converter::absolute_from_gregorian(int year, int month, int day)
{
int xyear, day_number;
xyear = year - 1;
day_number = day + 31 * (month - 1);
if (month > 2)
{
day_number -= (23 + (4 * month)) / 10;
if (gregorian_leap_year_p(year))
day_number++;
}
return day_number + /* the day number within the current year */
365L * xyear + /* days in prior years */
(xyear / 4) + /* Julian leap years */
(-(xyear / 100)) + /* deduct century years */
(xyear / 400); /* add Gregorian leap years */
}
/* Given a Hebrew date, calculate the number of days since
* January 0, 0001, Gregorian
*/
long Converter::absolute_from_hebrew(int year, int month, int day)
{
long sum = day + hebrew_elapsed_days(year) - 1373429L;
int i;
if (month < 7)
{
int months = hebrew_months_in_year(year);
for (i = 7; i <= months; ++i)
sum += hebrew_month_length(year, i);
for (i = 1; i < month; ++i)
sum += hebrew_month_length(year, i);
}
else
{
for (i = 7; i < month; ++i)
sum += hebrew_month_length(year, i);
}
return sum;
}
/* Given an absolute date, calculate the gregorian date */
void
Converter::gregorian_from_absolute(long date, int *yearp,
int *monthp, int *dayp)
{
int year, month, day;
for (year = date / 366;
date >= absolute_from_gregorian(year + 1, 1, 1); ++year) ;
for (month = 1;
(month <= 11)
&& (date >= absolute_from_gregorian(year, 1 + month, 1));
++month ) ;
day = 1 + date - absolute_from_gregorian(year, month, 1);
*yearp = year;
*monthp = month;
*dayp = day;
}
/* Given an absolute date, calculate the Hebrew date */
void
Converter::hebrew_from_absolute(long date, int *yearp, int *monthp,
int *dayp)
{
int year, month, day, gyear, gmonth, gday, months;
gregorian_from_absolute(date, &gyear, &gmonth, &gday);
year = gyear + 3760;
while (date >= absolute_from_hebrew(1 + year, 7, 1))
year++;
months = hebrew_months_in_year(year);
for (month = 7;
date > absolute_from_hebrew(year, month,
hebrew_month_length(year, month));
month = 1 + (month % months)) ;
day = 1 + date - absolute_from_hebrew(year, month, 1);
*yearp = year;
*monthp = month;
*dayp = day;
}
/* Number of months in a Hebrew year */
int Converter::hebrew_months_in_year(int year)
{
if (hebrew_leap_year_p(year))
return 13;
else
return 12;
}
enum
{ Nissan =
1, Iyar, Sivan, Tamuz, Ab, Elul, Tishrei, Cheshvan, Kislev, Tevet,
Shvat, Adar, AdarII, AdarI = 12
};
enum
{ January =
1, February, March, April, May, June, July, August, September,
October, November, December
};
/* Number of days in a Hebrew month */
int Converter::hebrew_month_length(int year, int month)
{
switch (month)
{
case Tishrei:
case Shvat:
case Nissan:
case Sivan:
case Ab:
return 30;
case Tevet:
case Iyar:
case Tamuz:
case Elul:
case AdarII:
return 29;
case Cheshvan:
// 29 days, unless it's a long year.
if ((hebrew_year_length(year) % 10) == 5)
return 30;
else
return 29;
case Kislev:
// 30 days, unless it's a short year.
if ((hebrew_year_length(year) % 10) == 3)
return 29;
else
return 30;
case Adar:
// Adar (non-leap year) has 29 days. Adar I has 30 days.
if (hebrew_leap_year_p(year))
return 30;
else
return 29;
default:
return 0;
}
}
/* Number of days in a Julian or gregorian month */
int
Converter::secular_month_length(int year,
int month /*, bool julianp */ )
{
switch (month)
{
case January:
case March:
case May:
case July:
case August:
case October:
case December:
return 31;
case April:
case June:
case September:
case November:
return 30;
case February:
if (gregorian_leap_year_p(year))
return 29;
else
return 28;
default:
return 0;
}
}
/* Is it a Leap year in the gregorian calendar */
bool Converter::gregorian_leap_year_p(int year)
{
if ((year % 4) != 0)
return 0;
if ((year % 400) == 0)
return 1;
if ((year % 100) == 0)
return 0;
return 1;
}
/* Is it a leap year in the Jewish Calendar */
bool Converter::hebrew_leap_year_p(int year)
{
switch (year % 19)
{
case 0:
case 3:
case 6:
case 8:
case 11:
case 14:
case 17:
return 1;
default:
return 0;
}
}
/* Return the number of days from 1 Tishrei 0001 to the beginning of the given year.
* Since this routine gets called frequently with the same year arguments, we cache
* the most recent values.
*/
#define MEMORY 5
long Converter::hebrew_elapsed_days(int year)
{
static int saved_year[MEMORY] = { -1, -1, -1, -1, -1 };
static long saved_value[MEMORY];
int i;
for (i = 0; i < MEMORY; ++i)
if (year == saved_year[i])
return saved_value[i];
for (i = 0; i < MEMORY-1; ++i) {
saved_year[i] = saved_year[1 + i];
saved_value[i] = saved_value[1 + i];
}
saved_year[MEMORY - 1] = year;
saved_value[MEMORY - 1] = hebrew_elapsed_days2(year);
return saved_value[MEMORY - 1];
}
long Converter::hebrew_elapsed_days2(int year)
{
long prev_year = year - 1;
long months_elapsed = 235L * (prev_year / 19) /* months in complete cycles so far */
+ 12L * (prev_year % 19) /* regular months in this cycle */
+ (((prev_year % 19) * 7 + 1) / 19); /* leap months this cycle */
long parts_elapsed = 5604 + 13753 * months_elapsed;
long day = 1 + 29 * months_elapsed + parts_elapsed / 25920;
long parts = parts_elapsed % 25920;
int weekday = (day % 7);
long alt_day = ((parts >= 19440)
|| (weekday == 2 && (parts >= 9924)
&& !hebrew_leap_year_p(year)) || (weekday == 1
&& (parts >=
16789)
&&
hebrew_leap_year_p
(prev_year)))
? day + 1 : day;
switch (alt_day % 7)
{
case 0:
case 3:
case 5:
return 1 + alt_day;
default:
return alt_day;
}
}
/* Number of days in the given Hebrew year */
int Converter::hebrew_year_length(int year)
{
return hebrew_elapsed_days(1 + year) - hebrew_elapsed_days(year);
}
/* Fill in the DateResult structure based on the given secular date */
void
Converter::SecularToHebrewConversion(int syear, int smonth,
int sday,
struct DateResult *result)
{
int hyear, hmonth, hday;
long absolute;
absolute = absolute_from_gregorian(syear, smonth, sday);
hebrew_from_absolute(absolute, &hyear, &hmonth, &hday);
result->year = hyear;
result->month = hmonth;
result->day = hday;
finish_up(absolute, hyear, hmonth, syear, smonth, result);
}
/* Fill in the DateResult structure based on the given Hebrew date */
void
Converter::HebrewToSecularConversion(int hyear, int hmonth,
int hday,
struct DateResult *result)
{
int syear, smonth, sday;
long absolute;
absolute = absolute_from_hebrew(hyear, hmonth, hday);
gregorian_from_absolute(absolute, &syear, &smonth, &sday);
result->year = hyear;
result->month = hmonth;
result->day = hday;
finish_up(absolute, hyear, hmonth, syear, smonth, result);
}
/* This is common code for filling up the DateResult structure */
void
Converter::finish_up(long absolute, int hyear, int hmonth,
int syear, int smonth,
struct DateResult *result)
{
result->hebrew_month_length = hebrew_month_length(hyear, hmonth);
result->secular_month_length = secular_month_length(syear, smonth);
result->hebrew_leap_year_p = hebrew_leap_year_p(hyear);
result->secular_leap_year_p = gregorian_leap_year_p(syear);
result->kvia = (hebrew_year_length(hyear) % 10) - 3;
// absolute is -1 on 1/1/0001 Julian
result->day_of_week = (7 + absolute) % 7;
result->hebrew_day_number =
absolute - absolute_from_hebrew(hyear, 7, 1) + 1;
}