1 /* $selId: jewish.c,v 2.0 1995/10/24 01:13:06 lees Exp $
2 * Copyright 1993-1995, Scott E. Lee, all rights reserved.
3 * Permission granted to use, copy, modify, distribute and sell so long as
4 * the above copyright and this permission statement are retained in all
5 * copies. THERE IS NO WARRANTY - USE AT YOUR OWN RISK.
6 */
7
8 /**************************************************************************
9 *
10 * These are the externally visible components of this file:
11 *
12 * void
13 * SdnToJewish(
14 * long int sdn,
15 * int *pYear,
16 * int *pMonth,
17 * int *pDay);
18 *
19 * Convert a SDN to a Jewish calendar date. If the input SDN is before the
20 * first day of year 1, the three output values will all be set to zero,
21 * otherwise *pYear will be > 0; *pMonth will be in the range 1 to 13
22 * inclusive; *pDay will be in the range 1 to 30 inclusive. Note that Adar
23 * II is assigned the month number 7 and Elul is always 13.
24 *
25 * long int
26 * JewishToSdn(
27 * int year,
28 * int month,
29 * int day);
30 *
31 * Convert a Jewish calendar date to a SDN. Zero is returned when the
32 * input date is detected as invalid or out of the supported range. The
33 * return value will be > 0 for all valid, supported dates, but there are
34 * some invalid dates that will return a positive value. To verify that a
35 * date is valid, convert it to SDN and then back and compare with the
36 * original.
37 *
38 * char *JewishMonthName[14];
39 *
40 * Convert a Jewish month number (1 to 13) to the name of the Jewish month
41 * (null terminated). An index of zero will return a zero length string.
42 *
43 * VALID RANGE
44 *
45 * Although this software can handle dates all the way back to the year
46 * 1 (3761 B.C.), such use may not be meaningful.
47 *
48 * The Jewish calendar has been in use for several thousand years, but
49 * in the early days there was no formula to determine the start of a
50 * month. A new month was started when the new moon was first
51 * observed.
52 *
53 * It is not clear when the current rule based calendar replaced the
54 * observation based calendar. According to the book "Jewish Calendar
55 * Mystery Dispelled" by George Zinberg, the patriarch Hillel II
56 * published these rules in 358 A.D. But, according to The
57 * Encyclopedia Judaica, Hillel II may have only published the 19 year
58 * rule for determining the occurrence of leap years.
59 *
60 * I have yet to find a specific date when the current set of rules
61 * were known to be in use.
62 *
63 * CALENDAR OVERVIEW
64 *
65 * The Jewish calendar is based on lunar as well as solar cycles. A
66 * month always starts on or near a new moon and has either 29 or 30
67 * days (a lunar cycle is about 29 1/2 days). Twelve of these
68 * alternating 29-30 day months gives a year of 354 days, which is
69 * about 11 1/4 days short of a solar year.
70 *
71 * Since a month is defined to be a lunar cycle (new moon to new moon),
72 * this 11 1/4 day difference cannot be overcome by adding days to a
73 * month as with the Gregorian calendar, so an entire month is
74 * periodically added to the year, making some years 13 months long.
75 *
76 * For astronomical as well as ceremonial reasons, the start of a new
77 * year may be delayed until a day or two after the new moon causing
78 * years to vary in length. Leap years can be from 383 to 385 days and
79 * common years can be from 353 to 355 days. These are the months of
80 * the year and their possible lengths:
81 *
82 * COMMON YEAR LEAP YEAR
83 * 1 Tishri 30 30 30 30 30 30
84 * 2 Heshvan 29 29 30 29 29 30 (variable)
85 * 3 Kislev 29 30 30 29 30 30 (variable)
86 * 4 Tevet 29 29 29 29 29 29
87 * 5 Shevat 30 30 30 30 30 30
88 * 6 Adar I 29 29 29 30 30 30 (variable)
89 * 7 Adar II -- -- -- 29 29 29 (optional)
90 * 8 Nisan 30 30 30 30 30 30
91 * 9 Iyyar 29 29 29 29 29 29
92 * 10 Sivan 30 30 30 30 30 30
93 * 11 Tammuz 29 29 29 29 29 29
94 * 12 Av 30 30 30 30 30 30
95 * 13 Elul 29 29 29 29 29 29
96 * --- --- --- --- --- ---
97 * 353 354 355 383 384 385
98 *
99 * Note that the month names and other words that appear in this file
100 * have multiple possible spellings in the Roman character set. I have
101 * chosen to use the spellings found in the Encyclopedia Judaica.
102 *
103 * Adar II, the month added for leap years, is sometimes referred to as
104 * the 13th month, but I have chosen to assign it the number 7 to keep
105 * the months in chronological order. This may not be consistent with
106 * other numbering schemes.
107 *
108 * Leap years occur in a fixed pattern of 19 years called the metonic
109 * cycle. The 3rd, 6th, 8th, 11th, 14th, 17th and 19th years of this
110 * cycle are leap years. The first metonic cycle starts with Jewish
111 * year 1, or 3761/60 B.C. This is believed to be the year of
112 * creation.
113 *
114 * To construct the calendar for a year, you must first find the length
115 * of the year by determining the first day of the year (Tishri 1, or
116 * Rosh Ha-Shanah) and the first day of the following year. This
117 * selects one of the six possible month length configurations listed
118 * above.
119 *
120 * Finding the first day of the year is the most difficult part.
121 * Finding the date and time of the new moon (or molad) is the first
122 * step. For this purpose, the lunar cycle is assumed to be 29 days 12
123 * hours and 793 halakim. A halakim is 1/1080th of an hour or 3 1/3
124 * seconds. (This assumed value is only about 1/2 second less than the
125 * value used by modern astronomers -- not bad for a number that was
126 * determined so long ago.) The first molad of year 1 occurred on
127 * Sunday at 11:20:11 P.M. This would actually be Monday, because the
128 * Jewish day is considered to begin at sunset.
129 *
130 * Since sunset varies, the day is assumed to begin at 6:00 P.M. for
131 * calendar calculation purposes. So, the first molad was 5 hours 793
132 * halakim after the start of Tishri 1, 0001 (which was Monday
133 * September 7, 4761 B.C. by the Gregorian calendar). All subsequent
134 * molads can be calculated from this starting point by adding the
135 * length of a lunar cycle.
136 *
137 * Once the molad that starts a year is determined the actual start of
138 * the year (Tishri 1) can be determined. Tishri 1 will be the day of
139 * the molad unless it is delayed by one of the following four rules
140 * (called dehiyyot). Each rule can delay the start of the year by one
141 * day, and since rule #1 can combine with one of the other rules, it
142 * can be delayed as much as two days.
143 *
144 * 1. Tishri 1 must never be Sunday, Wednesday or Friday. (This
145 * is largely to prevent certain holidays from occurring on the
146 * day before or after the Sabbath.)
147 *
148 * 2. If the molad occurs on or after noon, Tishri 1 must be
149 * delayed.
150 *
151 * 3. If it is a common (not leap) year and the molad occurs on
152 * Tuesday at or after 3:11:20 A.M., Tishri 1 must be delayed.
153 *
154 * 4. If it is the year following a leap year and the molad occurs
155 * on Monday at or after 9:32:43 and 1/3 sec, Tishri 1 must be
156 * delayed.
157 *
158 * GLOSSARY
159 *
160 * dehiyyot The set of 4 rules that determine when the new year
161 * starts relative to the molad.
162 *
163 * halakim 1/1080th of an hour or 3 1/3 seconds.
164 *
165 * lunar cycle The period of time between mean conjunctions of the
166 * sun and moon (new moon to new moon). This is
167 * assumed to be 29 days 12 hours and 793 halakim for
168 * calendar purposes.
169 *
170 * metonic cycle A 19 year cycle which determines which years are
171 * leap years and which are common years. The 3rd,
172 * 6th, 8th, 11th, 14th, 17th and 19th years of this
173 * cycle are leap years.
174 *
175 * molad The date and time of the mean conjunction of the
176 * sun and moon (new moon). This is the approximate
177 * beginning of a month.
178 *
179 * Rosh Ha-Shanah The first day of the Jewish year (Tishri 1).
180 *
181 * Tishri The first month of the Jewish year.
182 *
183 * ALGORITHMS
184 *
185 * SERIAL DAY NUMBER TO JEWISH DATE
186 *
187 * The simplest approach would be to use the rules stated above to find
188 * the molad of Tishri before and after the given day number. Then use
189 * the molads to find Tishri 1 of the current and following years.
190 * From this the length of the year can be determined and thus the
191 * length of each month. But this method is used as a last resort.
192 *
193 * The first 59 days of the year are the same regardless of the length
194 * of the year. As a result, only the day number of the start of the
195 * year is required.
196 *
197 * Similarly, the last 6 months do not change from year to year. And
198 * since it can be determined whether the year is a leap year by simple
199 * division, the lengths of Adar I and II can be easily calculated. In
200 * fact, all dates after the 3rd month are consistent from year to year
201 * (once it is known whether it is a leap year).
202 *
203 * This means that if the given day number falls in the 3rd month or on
204 * the 30th day of the 2nd month the length of the year must be found,
205 * but in no other case.
206 *
207 * So, the approach used is to take the given day number and round it
208 * to the closest molad of Tishri (first new moon of the year). The
209 * rounding is not really to the *closest* molad, but is such that if
210 * the day number is before the middle of the 3rd month the molad at
211 * the start of the year is found, otherwise the molad at the end of
212 * the year is found.
213 *
214 * Only if the day number is actually found to be in the ambiguous
215 * period of 29 to 31 days is the other molad calculated.
216 *
217 * JEWISH DATE TO SERIAL DAY NUMBER
218 *
219 * The year number is used to find which 19 year metonic cycle contains
220 * the date and which year within the cycle (this is a division and
221 * modulus). This also determines whether it is a leap year.
222 *
223 * If the month is 1 or 2, the calculation is simple addition to the
224 * first of the year.
225 *
226 * If the month is 8 (Nisan) or greater, the calculation is simple
227 * subtraction from beginning of the following year.
228 *
229 * If the month is 4 to 7, it is considered whether it is a leap year
230 * and then simple subtraction from the beginning of the following year
231 * is used.
232 *
233 * Only if it is the 3rd month is both the start and end of the year
234 * required.
235 *
236 * TESTING
237 *
238 * This algorithm has been tested in two ways. First, 510 dates from a
239 * table in "Jewish Calendar Mystery Dispelled" were calculated and
240 * compared to the table. Second, the calculation algorithm described
241 * in "Jewish Calendar Mystery Dispelled" was coded and used to verify
242 * all dates from the year 1 (3761 B.C.) to the year 13760 (10000
243 * A.D.).
244 *
245 * The source code of the verification program is included in this
246 * package.
247 *
248 * REFERENCES
249 *
250 * The Encyclopedia Judaica, the entry for "Calendar"
251 *
252 * The Jewish Encyclopedia
253 *
254 * Jewish Calendar Mystery Dispelled by George Zinberg, Vantage Press,
255 * 1963
256 *
257 * The Comprehensive Hebrew Calendar by Arthur Spier, Behrman House
258 *
259 * The Book of Calendars [note that this work contains many typos]
260 *
261 **************************************************************************/
262
263 #if defined(PHP_WIN32) && _MSC_VER >= 1200
264 #pragma setlocale("english")
265 #endif
266
267 #include "sdncal.h"
268
269 #define HALAKIM_PER_HOUR 1080
270 #define HALAKIM_PER_DAY 25920
271 #define HALAKIM_PER_LUNAR_CYCLE ((29 * HALAKIM_PER_DAY) + 13753)
272 #define HALAKIM_PER_METONIC_CYCLE (HALAKIM_PER_LUNAR_CYCLE * (12 * 19 + 7))
273
274 #define JEWISH_SDN_OFFSET 347997
275 #define JEWISH_SDN_MAX 324542846L /* 12/13/887605, greater value raises interger overflow */
276 #define NEW_MOON_OF_CREATION 31524
277
278 #define SUNDAY 0
279 #define MONDAY 1
280 #define TUESDAY 2
281 #define WEDNESDAY 3
282 #define THURSDAY 4
283 #define FRIDAY 5
284 #define SATURDAY 6
285
286 #define NOON (18 * HALAKIM_PER_HOUR)
287 #define AM3_11_20 ((9 * HALAKIM_PER_HOUR) + 204)
288 #define AM9_32_43 ((15 * HALAKIM_PER_HOUR) + 589)
289
290 static int monthsPerYear[19] =
291 {
292 12, 12, 13, 12, 12, 13, 12, 13, 12, 12, 13, 12, 12, 13, 12, 12, 13, 12, 13
293 };
294
295 static int yearOffset[19] =
296 {
297 0, 12, 24, 37, 49, 61, 74, 86, 99, 111, 123,
298 136, 148, 160, 173, 185, 197, 210, 222
299 };
300
301 char *JewishMonthName[14] =
302 {
303 "",
304 "Tishri",
305 "Heshvan",
306 "Kislev",
307 "Tevet",
308 "Shevat",
309 "AdarI",
310 "AdarII",
311 "Nisan",
312 "Iyyar",
313 "Sivan",
314 "Tammuz",
315 "Av",
316 "Elul"
317 };
318
319 char *JewishMonthHebName[14] =
320 {
321 "",
322 "����",
323 "����",
324 "����",
325 "���",
326 "���",
327 "���",
328 "'��� �",
329 "����",
330 "����",
331 "����",
332 "����",
333 "��",
334 "����"
335 };
336
337 /************************************************************************
338 * Given the year within the 19 year metonic cycle and the time of a molad
339 * (new moon) which starts that year, this routine will calculate what day
340 * will be the actual start of the year (Tishri 1 or Rosh Ha-Shanah). This
341 * first day of the year will be the day of the molad unless one of 4 rules
342 * (called dehiyyot) delays it. These 4 rules can delay the start of the
343 * year by as much as 2 days.
344 */
Tishri1(int metonicYear,long int moladDay,long int moladHalakim)345 static long int Tishri1(
346 int metonicYear,
347 long int moladDay,
348 long int moladHalakim)
349 {
350 long int tishri1;
351 int dow;
352 int leapYear;
353 int lastWasLeapYear;
354
355 tishri1 = moladDay;
356 dow = tishri1 % 7;
357 leapYear = metonicYear == 2 || metonicYear == 5 || metonicYear == 7
358 || metonicYear == 10 || metonicYear == 13 || metonicYear == 16
359 || metonicYear == 18;
360 lastWasLeapYear = metonicYear == 3 || metonicYear == 6
361 || metonicYear == 8 || metonicYear == 11 || metonicYear == 14
362 || metonicYear == 17 || metonicYear == 0;
363
364 /* Apply rules 2, 3 and 4. */
365 if ((moladHalakim >= NOON) ||
366 ((!leapYear) && dow == TUESDAY && moladHalakim >= AM3_11_20) ||
367 (lastWasLeapYear && dow == MONDAY && moladHalakim >= AM9_32_43)) {
368 tishri1++;
369 dow++;
370 if (dow == 7) {
371 dow = 0;
372 }
373 }
374 /* Apply rule 1 after the others because it can cause an additional
375 * delay of one day. */
376 if (dow == WEDNESDAY || dow == FRIDAY || dow == SUNDAY) {
377 tishri1++;
378 }
379 return (tishri1);
380 }
381
382 /************************************************************************
383 * Given a metonic cycle number, calculate the date and time of the molad
384 * (new moon) that starts that cycle. Since the length of a metonic cycle
385 * is a constant, this is a simple calculation, except that it requires an
386 * intermediate value which is bigger that 32 bits. Because this
387 * intermediate value only needs 36 to 37 bits and the other numbers are
388 * constants, the process has been reduced to just a few steps.
389 */
MoladOfMetonicCycle(int metonicCycle,long int * pMoladDay,long int * pMoladHalakim)390 static void MoladOfMetonicCycle(
391 int metonicCycle,
392 long int *pMoladDay,
393 long int *pMoladHalakim)
394 {
395 register unsigned long int r1, r2, d1, d2;
396
397 /* Start with the time of the first molad after creation. */
398 r1 = NEW_MOON_OF_CREATION;
399
400 /* Calculate metonicCycle * HALAKIM_PER_METONIC_CYCLE. The upper 32
401 * bits of the result will be in r2 and the lower 16 bits will be
402 * in r1. */
403 r1 += metonicCycle * (HALAKIM_PER_METONIC_CYCLE & 0xFFFF);
404 r2 = r1 >> 16;
405 r2 += metonicCycle * ((HALAKIM_PER_METONIC_CYCLE >> 16) & 0xFFFF);
406
407 /* Calculate r2r1 / HALAKIM_PER_DAY. The remainder will be in r1, the
408 * upper 16 bits of the quotient will be in d2 and the lower 16 bits
409 * will be in d1. */
410 d2 = r2 / HALAKIM_PER_DAY;
411 r2 -= d2 * HALAKIM_PER_DAY;
412 r1 = (r2 << 16) | (r1 & 0xFFFF);
413 d1 = r1 / HALAKIM_PER_DAY;
414 r1 -= d1 * HALAKIM_PER_DAY;
415
416 *pMoladDay = (d2 << 16) | d1;
417 *pMoladHalakim = r1;
418 }
419
420 /************************************************************************
421 * Given a day number, find the molad of Tishri (the new moon at the start
422 * of a year) which is closest to that day number. It's not really the
423 * *closest* molad that we want here. If the input day is in the first two
424 * months, we want the molad at the start of the year. If the input day is
425 * in the fourth to last months, we want the molad at the end of the year.
426 * If the input day is in the third month, it doesn't matter which molad is
427 * returned, because both will be required. This type of "rounding" allows
428 * us to avoid calculating the length of the year in most cases.
429 */
FindTishriMolad(long int inputDay,int * pMetonicCycle,int * pMetonicYear,long int * pMoladDay,long int * pMoladHalakim)430 static void FindTishriMolad(
431 long int inputDay,
432 int *pMetonicCycle,
433 int *pMetonicYear,
434 long int *pMoladDay,
435 long int *pMoladHalakim)
436 {
437 long int moladDay;
438 long int moladHalakim;
439 int metonicCycle;
440 int metonicYear;
441
442 /* Estimate the metonic cycle number. Note that this may be an under
443 * estimate because there are 6939.6896 days in a metonic cycle not
444 * 6940, but it will never be an over estimate. The loop below will
445 * correct for any error in this estimate. */
446 metonicCycle = (inputDay + 310) / 6940;
447
448 /* Calculate the time of the starting molad for this metonic cycle. */
449 MoladOfMetonicCycle(metonicCycle, &moladDay, &moladHalakim);
450
451 /* If the above was an under estimate, increment the cycle number until
452 * the correct one is found. For modern dates this loop is about 98.6%
453 * likely to not execute, even once, because the above estimate is
454 * really quite close. */
455 while (moladDay < inputDay - 6940 + 310) {
456 metonicCycle++;
457 moladHalakim += HALAKIM_PER_METONIC_CYCLE;
458 moladDay += moladHalakim / HALAKIM_PER_DAY;
459 moladHalakim = moladHalakim % HALAKIM_PER_DAY;
460 }
461
462 /* Find the molad of Tishri closest to this date. */
463 for (metonicYear = 0; metonicYear < 18; metonicYear++) {
464 if (moladDay > inputDay - 74) {
465 break;
466 }
467 moladHalakim += HALAKIM_PER_LUNAR_CYCLE * monthsPerYear[metonicYear];
468 moladDay += moladHalakim / HALAKIM_PER_DAY;
469 moladHalakim = moladHalakim % HALAKIM_PER_DAY;
470 }
471
472 *pMetonicCycle = metonicCycle;
473 *pMetonicYear = metonicYear;
474 *pMoladDay = moladDay;
475 *pMoladHalakim = moladHalakim;
476 }
477
478 /************************************************************************
479 * Given a year, find the number of the first day of that year and the date
480 * and time of the starting molad.
481 */
FindStartOfYear(int year,int * pMetonicCycle,int * pMetonicYear,long int * pMoladDay,long int * pMoladHalakim,int * pTishri1)482 static void FindStartOfYear(
483 int year,
484 int *pMetonicCycle,
485 int *pMetonicYear,
486 long int *pMoladDay,
487 long int *pMoladHalakim,
488 int *pTishri1)
489 {
490 *pMetonicCycle = (year - 1) / 19;
491 *pMetonicYear = (year - 1) % 19;
492 MoladOfMetonicCycle(*pMetonicCycle, pMoladDay, pMoladHalakim);
493
494 *pMoladHalakim += HALAKIM_PER_LUNAR_CYCLE * yearOffset[*pMetonicYear];
495 *pMoladDay += *pMoladHalakim / HALAKIM_PER_DAY;
496 *pMoladHalakim = *pMoladHalakim % HALAKIM_PER_DAY;
497
498 *pTishri1 = Tishri1(*pMetonicYear, *pMoladDay, *pMoladHalakim);
499 }
500
501 /************************************************************************
502 * Given a serial day number (SDN), find the corresponding year, month and
503 * day in the Jewish calendar. The three output values will always be
504 * modified. If the input SDN is before the first day of year 1, they will
505 * all be set to zero, otherwise *pYear will be > 0; *pMonth will be in the
506 * range 1 to 13 inclusive; *pDay will be in the range 1 to 30 inclusive.
507 */
SdnToJewish(long int sdn,int * pYear,int * pMonth,int * pDay)508 void SdnToJewish(
509 long int sdn,
510 int *pYear,
511 int *pMonth,
512 int *pDay)
513 {
514 long int inputDay;
515 long int day;
516 long int halakim;
517 int metonicCycle;
518 int metonicYear;
519 int tishri1;
520 int tishri1After;
521 int yearLength;
522
523 if (sdn <= JEWISH_SDN_OFFSET || sdn > JEWISH_SDN_MAX) {
524 *pYear = 0;
525 *pMonth = 0;
526 *pDay = 0;
527 return;
528 }
529 inputDay = sdn - JEWISH_SDN_OFFSET;
530
531 FindTishriMolad(inputDay, &metonicCycle, &metonicYear, &day, &halakim);
532 tishri1 = Tishri1(metonicYear, day, halakim);
533
534 if (inputDay >= tishri1) {
535 /* It found Tishri 1 at the start of the year. */
536 *pYear = metonicCycle * 19 + metonicYear + 1;
537 if (inputDay < tishri1 + 59) {
538 if (inputDay < tishri1 + 30) {
539 *pMonth = 1;
540 *pDay = inputDay - tishri1 + 1;
541 } else {
542 *pMonth = 2;
543 *pDay = inputDay - tishri1 - 29;
544 }
545 return;
546 }
547 /* We need the length of the year to figure this out, so find
548 * Tishri 1 of the next year. */
549 halakim += HALAKIM_PER_LUNAR_CYCLE * monthsPerYear[metonicYear];
550 day += halakim / HALAKIM_PER_DAY;
551 halakim = halakim % HALAKIM_PER_DAY;
552 tishri1After = Tishri1((metonicYear + 1) % 19, day, halakim);
553 } else {
554 /* It found Tishri 1 at the end of the year. */
555 *pYear = metonicCycle * 19 + metonicYear;
556 if (inputDay >= tishri1 - 177) {
557 /* It is one of the last 6 months of the year. */
558 if (inputDay > tishri1 - 30) {
559 *pMonth = 13;
560 *pDay = inputDay - tishri1 + 30;
561 } else if (inputDay > tishri1 - 60) {
562 *pMonth = 12;
563 *pDay = inputDay - tishri1 + 60;
564 } else if (inputDay > tishri1 - 89) {
565 *pMonth = 11;
566 *pDay = inputDay - tishri1 + 89;
567 } else if (inputDay > tishri1 - 119) {
568 *pMonth = 10;
569 *pDay = inputDay - tishri1 + 119;
570 } else if (inputDay > tishri1 - 148) {
571 *pMonth = 9;
572 *pDay = inputDay - tishri1 + 148;
573 } else {
574 *pMonth = 8;
575 *pDay = inputDay - tishri1 + 178;
576 }
577 return;
578 } else {
579 if (monthsPerYear[(*pYear - 1) % 19] == 13) {
580 *pMonth = 7;
581 *pDay = inputDay - tishri1 + 207;
582 if (*pDay > 0)
583 return;
584 (*pMonth)--;
585 (*pDay) += 30;
586 if (*pDay > 0)
587 return;
588 (*pMonth)--;
589 (*pDay) += 30;
590 } else {
591 *pMonth = 6;
592 *pDay = inputDay - tishri1 + 207;
593 if (*pDay > 0)
594 return;
595 (*pMonth)--;
596 (*pDay) += 30;
597 }
598 if (*pDay > 0)
599 return;
600 (*pMonth)--;
601 (*pDay) += 29;
602 if (*pDay > 0)
603 return;
604
605 /* We need the length of the year to figure this out, so find
606 * Tishri 1 of this year. */
607 tishri1After = tishri1;
608 FindTishriMolad(day - 365,
609 &metonicCycle, &metonicYear, &day, &halakim);
610 tishri1 = Tishri1(metonicYear, day, halakim);
611 }
612 }
613
614 yearLength = tishri1After - tishri1;
615 day = inputDay - tishri1 - 29;
616 if (yearLength == 355 || yearLength == 385) {
617 /* Heshvan has 30 days */
618 if (day <= 30) {
619 *pMonth = 2;
620 *pDay = day;
621 return;
622 }
623 day -= 30;
624 } else {
625 /* Heshvan has 29 days */
626 if (day <= 29) {
627 *pMonth = 2;
628 *pDay = day;
629 return;
630 }
631 day -= 29;
632 }
633
634 /* It has to be Kislev. */
635 *pMonth = 3;
636 *pDay = day;
637 }
638
639 /************************************************************************
640 * Given a year, month and day in the Jewish calendar, find the
641 * corresponding serial day number (SDN). Zero is returned when the input
642 * date is detected as invalid. The return value will be > 0 for all valid
643 * dates, but there are some invalid dates that will return a positive
644 * value. To verify that a date is valid, convert it to SDN and then back
645 * and compare with the original.
646 */
JewishToSdn(int year,int month,int day)647 long int JewishToSdn(
648 int year,
649 int month,
650 int day)
651 {
652 long int sdn;
653 int metonicCycle;
654 int metonicYear;
655 int tishri1;
656 int tishri1After;
657 long int moladDay;
658 long int moladHalakim;
659 int yearLength;
660 int lengthOfAdarIAndII;
661
662 if (year <= 0 || day <= 0 || day > 30) {
663 return (0);
664 }
665 switch (month) {
666 case 1:
667 case 2:
668 /* It is Tishri or Heshvan - don't need the year length. */
669 FindStartOfYear(year, &metonicCycle, &metonicYear,
670 &moladDay, &moladHalakim, &tishri1);
671 if (month == 1) {
672 sdn = tishri1 + day - 1;
673 } else {
674 sdn = tishri1 + day + 29;
675 }
676 break;
677
678 case 3:
679 /* It is Kislev - must find the year length. */
680
681 /* Find the start of the year. */
682 FindStartOfYear(year, &metonicCycle, &metonicYear,
683 &moladDay, &moladHalakim, &tishri1);
684
685 /* Find the end of the year. */
686 moladHalakim += HALAKIM_PER_LUNAR_CYCLE * monthsPerYear[metonicYear];
687 moladDay += moladHalakim / HALAKIM_PER_DAY;
688 moladHalakim = moladHalakim % HALAKIM_PER_DAY;
689 tishri1After = Tishri1((metonicYear + 1) % 19, moladDay, moladHalakim);
690
691 yearLength = tishri1After - tishri1;
692
693 if (yearLength == 355 || yearLength == 385) {
694 sdn = tishri1 + day + 59;
695 } else {
696 sdn = tishri1 + day + 58;
697 }
698 break;
699
700 case 4:
701 case 5:
702 case 6:
703 /* It is Tevet, Shevat or Adar I - don't need the year length. */
704
705 FindStartOfYear(year + 1, &metonicCycle, &metonicYear,
706 &moladDay, &moladHalakim, &tishri1After);
707
708 if (monthsPerYear[(year - 1) % 19] == 12) {
709 lengthOfAdarIAndII = 29;
710 } else {
711 lengthOfAdarIAndII = 59;
712 }
713
714 if (month == 4) {
715 sdn = tishri1After + day - lengthOfAdarIAndII - 237;
716 } else if (month == 5) {
717 sdn = tishri1After + day - lengthOfAdarIAndII - 208;
718 } else {
719 sdn = tishri1After + day - lengthOfAdarIAndII - 178;
720 }
721 break;
722
723 default:
724 /* It is Adar II or later - don't need the year length. */
725 FindStartOfYear(year + 1, &metonicCycle, &metonicYear,
726 &moladDay, &moladHalakim, &tishri1After);
727
728 switch (month) {
729 case 7:
730 sdn = tishri1After + day - 207;
731 break;
732 case 8:
733 sdn = tishri1After + day - 178;
734 break;
735 case 9:
736 sdn = tishri1After + day - 148;
737 break;
738 case 10:
739 sdn = tishri1After + day - 119;
740 break;
741 case 11:
742 sdn = tishri1After + day - 89;
743 break;
744 case 12:
745 sdn = tishri1After + day - 60;
746 break;
747 case 13:
748 sdn = tishri1After + day - 30;
749 break;
750 default:
751 return (0);
752 }
753 }
754 return (sdn + JEWISH_SDN_OFFSET);
755 }
756
757 /*
758 * Local variables:
759 * tab-width: 4
760 * c-basic-offset: 4
761 * End:
762 * vim600: sw=4 ts=4 fdm=marker
763 * vim<600: sw=4 ts=4
764 */
765
