Startseite Glossar Gästebuch Forum Impressum FAQ Inhalt

N A. B Zur Umrechnung von Kalenderdaten
Gliederung

Das Prinzip der Umrechnung

"Wenn jemand wissen will, wieviele arabische Jahre
in wievielen römischen Jahren enthalten sind,
dann soll er beide in Tage umrechnen
und ihr Verhältnis wird offenbar werden" [ 1 ]

Muhammad ibn Musa (780 - 850) war einer der bedeutendsten Mathematiker und Chronologen des islamischen Mittelalters. Bekannter wurde er unter seinem Beinamen al-Chorezmi, der Mann aus Chorezmien, jener alten Kulturlandschaft nördlich des Irans. Noch heute führen Informatiker seinen Namen fast täglich im Munde, gab seine Nisbe - sein Beinamen - doch die Vorlage für das Kunstwort Algorithmus.
Al-Chorezmi zeigt den wohl einzig vernünftigen Weg auf, wie man Daten verschiedener Kalendersysteme miteinander vergleichen und umrechnen kann: In jedem System muss man die Tage durchzählen, beginnend mit dem ersten Tag des ersten Monats des Jahres 1. Diese Tageszählungen lassen sich dann leicht miteinander in Relation setzen. Als Massstab bietet sich die von Scaliger erdachte "Julianische Periode" an. Die wohl besten Umrechnungstabellen, die Kalendariographischen und Chronologischen Tafeln von Robert Schram (Schram(1908)), folgen diesem Prinzip.

[1] Aus dem Kapitel 2 der Tafeln von Al-Chorezmi zitiert nach Zemanek (1990), S. 8. Diese Tafeln wurden herausgegeben und übersetzt von O. Neugebauer: "The Astronomical Tables of al-Khwarizmi" [Hist. Filos. Skr. Dan. Vid. Selsk 4, No. 2] Copenhagen 1961


voriger Absatz nächster Absatz Seitenanfang Seitenende

Scaliger und das julianische Datum

Joseph Justus Scaliger war eine schillernde Persönlichkeit. Geboren wurde er am 4. August 1540 in Agen (Südfrankreich) als Sohn des Philosophen und Naturwissenschaftlers Julius Cäsar Scaliger. Sein Vater gab vor, einem Adelsgeschlecht zu entstammen, eine Hochstapelei, die Joseph Scaliger in den wissenschaftlichen Auseinandersetzungen seiner letzten Lebensjahre sehr schadete.
Im Alter von elf Jahren begann Joseph Scaliger in Bordeaux sein Studium und erlernte neben der griechischen und lateinischen Sprache auch Hebräisch und Arabisch. Als dort die Pest ausbrach, kehrte er 1554 zu seinem Vater zurück, um sich intensiv mit Quellen in den genannten Sprachen zu beschäftigen. 1562 trat er zum Protestantismus über. In den folgenden Jahren reiste er als Begleiter des jungen französischen Adeligen Louis de Chastaigner de la Roche Pouay durch Italien, England und Schottland. Von 1570 bis 1572 studierte er in Valence Rechtswissenschaften. Nach einem kurzen Aufenthalt als Professor an der Akademie in Genf kehrte er nach Frankreich zurück, lebte die meiste Zeit in Agen und verfasste den Grossteil seiner Werke als freier Wissenschaftler, gefördert durch seinen Freund Chastaigner. 1593 nahm er einen Ruf nach Leiden an, wo er am 21./31. Januar 1609 verstarb. In seinem Hauptwerk "De emendatione temporum", das 1583 erschien, konnte er nur noch kurz auf die gregorianischen Kalenderreform eingehen, mit der er sich später noch sehr kritisch auseinandersetzte.[ 2 ]

Die julianische Periode

Scaliger gilt als der Begründer der wissenschaftlichen Chronologie im Abendland. Zahlreiche Quellen aus dem griechisch-römischen, dem babylonischen, ägyptischen, persischen und jüdischen Kulturkreis wertete er aus und brachte sie in eine systematische Ordnung. Unsterblich wurde er jedoch durch die Entwicklung der "Julianischen Periode". Scaliger entwickelte einen Zyklus 7980 Jahren, der sich ergibt aus dem Osterzyklus von 19 * 28 Jahren und dem Zyklus der römischen Indiktion von 15 Jahren. Ausgangspunkt dieser Zählung ist das Jahr 4713 vor der Zeitrechnung, das zurückgerechnet sowohl aus Ausgangspunkt der Osterrechnung wie auch der Indiktion angesehen werden kann. Die manchmal geäusserte Ansicht, Scaliger habe die Bezeichnung "Julianische Periode" zu Ehren seines Vaters Julius Cäsar gewählt, ist zwar recht rührend aber falsch. Scaliger selbst schreibt, der Name stamme davon, dass die Grundlage seines Systems der julianische Kalender bildet.[ 3 ]

Das astronomische Julianische Datum

Die Astronomen, als erster wohl Herrschel[ 4 ] , griffen Scalingers Idee auf und wandelten sie für ihre Zwecke ab. Sie führten eine kontinuierliche Tageszählung ein, beginnend mit Montag, dem 1. Januar 4713 a. Chr. n. 12 Uhr mittags, dem Julianischen Datum 0.00. Die Dezimalen geben die Uhrzeit an. Hierfür bürgerte sich die Bezeichnung "Julianisches Datum" (eng. Julian Date) ein. Die Tageszählung allein, also die Ganzzahl allein ohne Angabe der Uhrzeit, wird "Julian Day Number" zuweilen auch kurz "Julian Day" genannt. Datum und Zeit sind bei den Astronomen immer bezogen auf den Null-Meridian, welche Zeitskala [5 ] gewählt wird, hängt von den Umständen ab,

Das chronologische Julianische Datum

Bei den im Folgenden besprochenen Umrechnungen von Kalenderdaten wird das sogenannte "chronologische Julianische Datum" gebraucht, hier kurz JD genannt. Es ist wie die "Julian Day Number" der Astronomen eine kontinuierliche Tageszählung, also immer eine Ganzzahl (Integerzahl). Der 1. Januar 4713 a. Ch. n. (1. 1. -4712 astr. Zählung) erhält die Tagesziffer 1. Im Gegensatz zum astronomischen Julianischen Datum ist das Julianische Datum der Chronologie lediglich eine Bezugsgrösse zur Umrechnung verschiedener Kalendersysteme, somit nicht auf die Zeit des Nullmeridians bezogen.

Das Julianische Datum für einige wichtige Epochen
Kalender JD Jul./greg. Kalender
Jüdischer Kalender 347998 Montag, 07. 10. 3761 a. Chr. n.
Seleukidischer Kalender 1607739 Montag, 01. 10. 312 a. Chr. n.
Julianischer Kalender 1721424 Samstag, 01. 01. 1
Gregorianischer Kalender 1721426 Montag, 03. 01. 01
Iran: Yazdegard 1952063 Dienstag, 16. 06. 632
Iran: Dschelal ed-Din 2115236 Freitag, 15. 03. 1079
Islamischer Kalender 1948439 Donnerstag, 15. 07. 622
Islamischer Kalender 1948440 Freitag, 16. 07. 622
greg. Kalenderreform 2299161 Freitag, 5./15. 10. 1582

2 ] nach Zemanek (1990), S. 61 ff.
3 ] "Iulianum vocavimus, quia ad annum Iulianum duntaxat accommodata est." (De Emendatione Temporum, Ausgabe Paris 1583, 198). Zitiert nach Grafton (1993), Seite 250 ff.
4 ] Outlines of Astronomy, Philadelphia 1861, p. 530
5 ] siehe hierzu auch den Artikel Die Zeit]


voriger Absatz nächster Absatz Seitenanfang Seitenende

Die Berechnung der Tageszählung

Vorbemerkung:

Bei den Multiplikationen und Divisionen müssen die Ergebnisse immer abgerundet werden auf die nächstkleinere Ganzzahl. Es wird hier in Anlehnung an C++ und Java-Script diese Funktion als "floor" bezeichnet.

Also: floor (3.3) = 3; floor (-3.3) = -4.

Auch die Modulo-Division, d.h. die Berechnung des ganzzahligen Restes bei einer Division, muss modifiziert werden, damit immer ein ganzzahliger positiver Wert entsteht:

1 mod 19 = 1; 0 mod 19 = 0, -1 mod 19 = 18.

   function mod (n, d)
            {
             q = n % d;
             if (q<0) {q = d + q}
             return q
            }

Im folgenden bedeuten:
  TZ: Tageszählung im jeweiligen Stil, der 1.1.1 erhält TZ 1.
  JD: Julianisches Datum, wie oben beschrieben.
  getJDxxx(d, m, y): Berechnung von TZ und JD aus Tag, Monat und Jahr
  makeDatexxx(JD): Berechnung des Datums aus JD

Die Variable "Datum" ist zu definieren, z. B. in Java-Script:

     function Datum (Tag, Monat, Jahr)
              {
               this.Tag = Tag;
               this.Monat = Monat;
               this.Jahr = Jahr;
              }

Doch nun zur eigentlichen Kalenderrechnung.

Aus einem gegebenen Datum Tag, Monat, Jahr (d, m, y) die Tageszählung (TZ) zu berechnen ist grundsätzlich recht einfach. An diesem Tag sind vergangen (y - 1) Jahre, (m - 1) Monate und die Zahl der Tage:

       TZ =  (y - 1) * (Zahl der Tage im Jahr)
           + (m - 1) * (Zahl der Tage im Monat)
           + d 

Bei der Feststellung des Datums aus einer gegebenen Tageszählung geht man den umgekehrten Weg:

   (y - 1) = TZ / (Zahl der Tage im Jahr)
    Rest   = TZ - (y - 1) * (Zahl der Tage im Jahr)
   (m - 1) = Rest / (Zahl der Tage im Monat)
         d = Rest - (m-1) * (Zahl der Tage im Monat.  

Um bei jedem Kalenderstil immer (!) ein richtiges Ergebnis zu erlangen, muss man allerdings einige Feinheiten beachten, die im folgenden erläutert werden sollen.


voriger Absatz nächster Absatz Seitenanfang Seitenende

Der julianische Kalender

Der julianische Kalender ist recht regelmässig. Lediglich die Bestimmung der durchschnittlichen Dauer des Monats wirft Probleme auf. Diese kann man dadurch umgehen, dass man den Monatsanfang auf den 1. März verlegt. Die Monate März bis einschliesslich Januar haben im Schnitt 30.6 Tage, die Dauer des Februars spielt nun keine Rolle mehr, da er am Jahresende liegt. Zwischen 1. März und 31. Dezember liegen in jedem Jahr, gleichgültig ob Schalt- oder Gemeinjahr, 306 Tage. Diese muss man am Ende der Rechnung von dem Ergebnis wieder abziehen.

Die Formel lautet nun:
     function getJDjulianisch(d, m, y)
              {
               m -= 3;
               if (m<0) {m += 12; y--};
               TZ = floor (y * 365.25) + floor(m * 30.6 + 0.5) + d - 306;
               JD = TZ + 1721423;
              }

Die Berechnung des Datums aus dem JD erfolgt folgendermassen:

     function makeDatejulianisch(JD)
              {
               TZ = JD - 1721423 + 306;
               jahr = floor((tz - 0.2) / 365.25);
               rest = tz - floor(jahr * 365.25);
               monat = floor((rest - 0.5) / 30.6);
               tag = rest - floor(monat * 30.6 + 0.5);
               monat += 3;
               if (monat>12) {monat -=12; jahr++};
               Datum = new Datum (tag, monat, jahr)
              }


voriger Absatz nächster Absatz Seitenanfang Seitenende

Der gregorianische Kalender

Man berechne hier am besten zuerst die Differenz zwischen julianischen und gregorianischem Kalender zum gegebenen Zeitpunkt und nutze dann die Formeln für den julianischen Kalender:
     function GregDiffJahr(jahr)
              { differenz = floor(jahr / 100) - floor(jahr / 400) - 2;}
Diese Differenz gilt für Daten ab dem 1. März.

Das JD eines gregorianischen Datums berechnet sich nun folgendermassen:
     function getJDgregorianisch(d, m, y)
              {
               yy = y;
               if (m<3) {yy--}
               JD = getJDjulianisch(d, m, y) - GregDiffJahr(yy)
              }

Um die Differenz zwischen Julianisch und Gregorianischen Kalender für ein gegebenes JD feststellen zu können, gelten folgende Regeln:
Das JD für den 0.1.1 gregorianisch ist 1721425.
400 Jahre entsprechen 146097 Tage, 100 Jahre entsprechen 36524,25 Tage
daher gilt:
     function GregDiffTag(JD)
              {
               TZ = JD - 1721425 + 306
               diff = floor(tz / 36524.25) - floor(tz / 146097) - 2
              }

Das gregorianische Datum berechnet sich nun folgendermassen:
     function makeDateGreg(JD)
              {
               a = JD + GregDiffTag(JD)
               Datum = makeDateJul(a);
              }


voriger Absatz nächster Absatz Seitenanfang Seitenende

Der abendländische Kalender

Unter abendländischen Kalender wird hier die im Abendland übliche Datierung verstanden. Bis zu 4. Oktober findet der Julianische Kalender Anwendung, für die Zeit danach der Gregorianische. Die entsprechende Funktion zur Berechnung des julianischen Datums (nicht zu verwechseln mit dem julianischen Kalender) ist daher recht einfach:
     function getDayAbend(d, m, y)
              {
               JD = getDayJul(d, m, y);
               if(JD>2299170){JD = getDayGreg(d,m,y)}
              }

Nun kann es auch keine Schwierigkeiten mehr bereiten, aus dem Julianischen Datum das Kalenderdatum zu bestimmen:
     function makeDateAbend(JD)
              {
               if (JD<2299161){Datum = makeDateJul(jd);}
               else {Datum = makeDateGreg(jd);}
              }

Ermittlung der Tageszählung aus dem Datum und umgekehrt

In der Praxis wird es immer wieder vorkommen, dass jemand nicht Daten verschiedener Kalenderstile vergleichen will, sondern innerhalb des allgemein üblichen abendländischen Kalenders eine feste Tageszählung ermitteln möchte. Hierfür kann die Berechnung stark vereinfacht werden;

Berechnung von JD aus Tag, Monat, Jahr
Der Funktion "getJulianDay" werden die Variablen "Tag, Monat, Jahr" übergeben, sie gibt die Tageszählung "JD" zurück.
     function getJulianDay(d, m, y)
              {
               m-= 3;
               if(m<0){m+= 12; y--;}
               var JD = floor(y*365.25)+ floor(m*30.6 + 0.5)+ d + 1721117;
               if(JD>2299170){JD -= floor(y/100) - floor(y/400) - 2;}
               return JD;
              }

Berechnung von Tag, Monat, Jahr aus JD
Der Funktion "MakeDate" wird die Variable "JD" übergeben, sie gibt die das Datum "Tag, Monat, Jahr" zurück.
     function makeDate(jd)
              {
               var tz = jd - 1721117;
               if (jd>2299160)   {tz += floor((tz+2) / 36524.25) - floor((tz+2) / 146097) - 2 ;}
               var y  = floor((tz-0.2) / 365.25);
               var r  = tz - floor(y * 365.25);
               var m  = floor((r - 0.5) / 30.6);
               var d  = r - floor(m * 30.6 + 0.5);
               m+= 3;
               if(m>12) {m-= 12; y++}
               var x = new Datum(d, m, y);
               return x
              }

 Beispiel: So könnte dieser vereinfachte Rechner aussehen


voriger Absatz nächster Absatz Seitenanfang Seitenende

Weitere Kalenderstile nach Art des julianischen Kalenders

Es gab eine Reihe von Kalendern, die dem Prinzip des julianischen Kalenders folgten, sich aber in einigen Einzelheiten, insbesondere in der Epoche, von ihm unterschieden.
Als Beispiel soll die früher weit verbreitete seleukidische Zeitrechnung dienen. Das Jahr beginnt hier mit dem Monat Oktober, der Februar ist also der 5. Monat, der März der 6. Monat. Zwischen dem 1. März und dem Jahresanfang 1. Oktober liegen demzufolge 214 Tage. Schaltjahr sind jene Jahre, die bei einer Division durch 4 den Rest 3 ergeben.
Die oben beschriebenen Formeln für den julianischen Kalender sind also wie folgt zu modifizieren:
     function getJDseleukidisch (d, m, y)
              {
               m -= 6;
               if (m<0) {m += 12; y--};
               TZ = floor (y * 365.25 + 0.25) + floor(m * 30.6 + 0.5) + d - 214;
               JD = TZ + 1607738;
              }
     function makeDateseleukidisch(JD)
              {
               TZ = JD - 1607738 + 214;
               jahr = floor(tz - 0.2 - 0.25 / 365.25);
               rest = tz - floor(jahr * 365.25 + 0.25);
               monat = floor((rest - 0.5) / 30.6);
               tag = rest - floor(monat * 30.6 + 0.5);
               monat += 6;
               if (monat>12) {monat -=12; jahr++};
               Datum = new Datum (tag, monat, jahr)
              }


voriger Absatz nächster Absatz Seitenanfang Seitenende

Der islamische Kalender

Der zyklische islamische Kalender (siehe auch Die islamische Zeitrechnung) ist recht regelmässig. Die Monate sind haben abwechselnd 30 oder 29 Tage, der Schalttag liegt am Ende des Jahres, wirft also keine Probleme auf. Das Jahr hat eine Länge von 354 oder 355 Tagen, innerhalb eines 30 jährigen Zyklus gibt es 11 Schaltjahr. Die durchschnittliche Jahreslänge beträgt somit 354 + 11/30 Tage. Geschaltet wird immer dann, wenn der Rest am Jahresende grösser als 0.5 ist.
Von diesem zyklischen islamischen Kalender gibt es vier verschiedene Varianten. Zum einen kann man als Epoche den 15. Juni 622 (E15) oder auch den 16 Juni 622 (E16) nehmen. Zum anderen gibt es auch bei den Schaltjahren unterschiedliche Meinungen. Am Ende jeden 15. Zyklusjahres beträgt der Rest genau 0.5. Einige erklären daher jedes 15. Zyklusjahr zu einem Schaltjahr (S15), andere fügen den Schalttag erst am Ende des 16. Zyklusjahres (S16) ein. Durch eine kleine Modifizierung der Rundungsregel kann man diesen unterschiedlichen Regelungen Rechnung tragen.

Es empfiehlt sich, für alle Varianten des islamischen Kalenders eine Grundformel zur Umrechnung zu nehmen:
     function getJDIslam( d, m, y, a);       //a entscheidet über die Rundung)
              {
               tz = floor((y-1) * (354 + 11/30)  +  a) + floor((m - 1) * 29.5 + 0.5) + d;
               return tz;
              }

Nun kann von den verschiedenen Varianten aus auf diese Grundfunktion zurückgegriffen werden:
     function getJDIslamE16/S16(d, m, y)
              {
               TZ = getJDIslam(d, m, y, 0.49)
               JD = TZ + 1948439
              }

     function getJDIslamE15/S15(d, m, y)
              {
               TZ = getJDIslam(d, m, y, 0.51)
               JD = TZ + 1948438
              }

     function getJDIslamE15/S16(d, m, y)
              {
               TZ = getJDIslam(d, m, y, 0.49)
               JD = TZ + 1948438
              }

     function getJDIslamE16/S15(d, m, y)
              {
               TZ = getJDIslam(d, m, y, 0.51)
               JD = TZ + 1948439
              }

Die Berechnung des Datums aus dem JD bereitet nach dem bisher Gesagten sicher keine Schwierigkeiten:
     function makeDateIslam(tz, a)
              {
               jahr = floor((tz - a) / (354 + 11/30));
               rest = tz - floor(jahr * (354 + 11/30) + a);
               monat = floor((rest - 0.75) / 29.5);
               if(monat == 12){monat--}
               tag = rest - floor(monat * 29.5 + 0.5);
               monat ++;
               jahr++;
               Datum = new Datum (tag, monat, jahr);
               return Datum;
              }

     function makeDateIslamE16/S16(JD)
              {Datum = makeDateIslam(JD-1948439, 0.49)}

     function makeDateIslamE15/S15(JD)
              {Datum = makeDateIslam(JD-1948438, 0.51)}

     function makeDateIslamE15/S16(JD)
              {Datum = makeDateIslam(JD-1948438, 0.49)}

     function makeDateIslamE16/S15(JD)
              {Datum = makeDateIslam(JD-1948439, 0.51)}


voriger Absatz nächster Absatz Seitenanfang Seitenende

Der iranische Kalender

Sowohl der heutige iranische Kalender wie auch die von Sultan Dschelal ed-Din Malik Schah 1079 eingeführte Zeitrechnung beruhen auf astronomischen Berechnungen. Neujahr ist am Tag des Frühlingsbeginns, sofern dieses Ereignis auf oder nach 12.00 Uhr Mittags fällt. Nähere Einzelheiten sind an anderer Stelle beschrieben. (Siehe: Iranische Zeitrechnungen.)
Astronomisch berechnete Kalender haben einen Nachteil: häufig ist nicht nachzuvollziehen, wie die Berechnungen zustande gekommen sind. Aus diesem Grunde wurde dem hier verwendeten Umrechnungsprogramm ein fester Schaltzyklus zugrunde gelegt. Sehr genau ist ein Zyklus von 128 Jahren mit 31 Schaltjahren. Die Differenz zwischen diesem Kalenderjahr und dem durchschnittlichen Sonnenjahr beträgt weniger als eine Sekunde. Die Frage ist allerdings, mit welchen Jahr ein solcher Zyklus beginnen sollte. Hier wurde für den Kalender Dschelal ed-Din's ein anderer Weg gewählt als für den heutigen iranischen Kalender. Dies widerspricht zwar aller Theorie, der Verfasser ist jedoch der Meinung, so zu genaueren Ergebnissen zu kommen, ohne dies im Detail belegen zu können.

Die Berechnung des iranischen Kalenders dürfte nun keine Probleme mehr bereiten. Zuerst der Kalender Malik Schahs:
     function getDayIranDschel(d, m, y)
              {
               a = y + 110;                //legt Zyklusbeginn fest
               b = floor(a/128);           //Zahl der vollständig verstrichenen Zyklen
               c = mod(a, 128);            //Jahre im laufenden Zyklus
               tz = b * 46751;             // ein Zyklus hat 46751 Tage
               tz += floor(c * 365.2424);
               tz += (m-1) * 30 + d;
               JD = tz + 2074694;
              }

Nun der heutige iranische Kalender:
     function getDayIranNeu(d, m, y)
              {
               a = y + 37;
               b = floor(a/128);
               c = mod(a,128);
               tz = b * 46751;
               tz += floor(c * 365.2424);
               tz += (m-1) * 31 + d;
               if (m>7){tz = tz - m + 7;};
               JD = tz + 1934441;
              }

Auch die Rückberechnung des Datums aus dem julianischen Datum JD erfolgt nach altem Muster. Hier der Kalender Malik Schahs:
     function makeDateIranDschel(jd)
              {
               var tz = jd - 2074694;             //Beginn der Zeitrechnung
               var a  = floor(tz/46751);          //vollständig verstrichene Zyklen
               var r1 = tz - a*46751;             //Resttage im laufenden Zyklus
               var b  = floor((r1 - 0.0002) / 365.2424); //Jahre im lfd. Zyklus
               var y  = a * 128 + b - 110;        //verstrichene Jahre
               var r  = r1 - floor(b * 365.2424); //Resttage im lfd. Jahr
               var m = floor((r-0.5)/30);
               var d = r - (m*30);
               m++;
               var x = new Datum(d, m, y);
               return x;
              }

Abschliessend nun der heutige iranische Kalender:
     function makeDateIranNeu(jd)
              {
               var m, d;
               var tz = jd - 1934441;
               var a  = floor(tz/46751);
               var r1 = tz - a*46751;
               var b  = floor((r1 - 0.0002) / 365.2424);
               var y  = a * 128 + b - 38;
               var r  = r1 - floor(b * 365.2424);

               if (r<217)
                {
                 m = floor ((r -0.5) / 31);
                 d = r - (m * 31);
                 m++;
                }
               else
                {
                 r -= 216;
                 m = floor((r - 0.5) / 30);
                 d = r - (m *30);
                 m += 8;
                }
               y++;
               var x = new Datum(d, m, y);
               return x;
              }
     function makeDateIranNeu(jd)
              {
               var m, d;
               var tz = jd - 1934441;
               var a  = floor(tz/46751);
               var r1 = tz - a*46751;
               var b  = floor((r1 - 0.0002) / 365.2424);
               var y  = a * 128 + b - 38;
               var r  = r1 - floor(b * 365.2424);

               if (r<217)
                {
                 m = floor ((r -0.5) / 31);
                 d = r - (m * 31);
                 m++;
                }
               else
                {
                 r -= 216;
                 m = floor((r - 0.5) / 30);
                 d = r - (m *30);
                 m += 8;
                }
               y++;
               var x = new datum(d, m, y);
               return x;
              }


voriger Absatz nächster Absatz Seitenanfang Seitenende

Der jüdische Kalender

Der jüdische Kalender wird an anderer Stelle ausführlicher beschrieben (siehe: Der jüdische Kalender ), daher hier nur die wichtigsten Daten:

1 Tag hat 24 Stunden, der Tag beginnt am Vorabend um 18.00 Uhr unserer Zeit
1 Stunde hat 1080 chalakim, der Tag somit 25920 chalakim
1 Monat hat 29 Tage, 12 Stunden und 793 chalakim oder 29 Tage und 13753 chalakim
1 Gemeinjahr hat 12 Monate, ein Schaltjahr 13 Monate
1 Schaltzyklus von 19 Jahren hat 235 Monate oder 6939 Tage und 17875 chalakim
innerhalb eines 19 jährigen Zyklus sind die folgenden 7 Jahre Schaltjahre: 3, 6, 8, 11, 14, 17 und 19
Neujahr ist am Tag des Neumondes, sofern keiner der an anderer Stelle beschriebenen Ausnahmefälle eintritt
Ausgangspunkt ist der Neumond der Schöpfung, der fällt auf den 1. 1. des Jahres 1 um 5 Uhr 204 chalakim (gleich 5604 chalakim)..

Allein die Berechnung der Anzahl der Tage, die vor dem Beginn eines gegebenen Jahres liegen, ist recht aufwendig. Man sollte vermeiden, dass die Anzahl der Chalakim zu gross wird, denn man wird die Variable c, die für die Chalakim steht, als Ganzzahl definieren. Es empfiehlt sich daher, zuerst die Zahl der vergangen Zyklen, dann die Zahl der im laufenden Zyklus verflossenen Monate zu berechnen. Möchte man ganz sicher gehen, kann man auch die Stunden noch getrennt berechnen.

     function SchaltJud(y)
      { return (mod((1+7*y),19)) < 7 ? 1 : 0;}

     function MolTisch(y)
      {
        var p,q,m,tz,c, tag;
        y--;
        p = floor(y/19);                     // Anzahl der vergangenen Zyklen von 19 Jahren
        q = mod(y,19);                       // Anzahl der vergangenen Jahre im laufenden Zyklus
        m = 12 * q + floor(0.37 * q + 0.06); // Anzahl der Monate plus Schaltmonate im laufenden Zyklus
        c = p * 17875 + m*13753 + 5604;      // Anzahl der Chalakim
       tz = p * 6939 + m * 29                // vergangene Tage
       tz += floor(c / 25920);               // plus Tage aus den Chalakim
        c = mod(c, 25920);                   // restliche Chalakim
        if (c>19439) {tz++;}                 //Ausnahme Yach
        tag = mod(tz, 7);                    //Bestimmung des Wochentages
        if (tag == 2 || tag  == 4 || tag == 6) {tz++;  // Ausnahme Adu
        if (SchaltJud(y + 1) == 0 && tag == 1 && c>9923 && c<19440){tz +=2;} // Ausnahme Gatrad
        if (SchaltJud(y)  == 1 && tag == 0 && c>16788 && c<19440){tz++; }    // Ausnahme Bektupat
       return tz;
      }

Diese Berechnung muss nun zwei Mal durchgeführt werden, einmal für das laufende Jahr und einmal für das folgende Jahr. Zieht man die beiden Ergebnisse voneinander ab, hat man die Zahl der Tage des laufenden Jahres. Nun erst kann man an die Ermittlung der Zahl der Tage gehen, die im laufenden Jahr vor dem gegebenen Datum verflossen sind. Eine recht aufwendige Prozedur.

Gleiches gilt für die Ermittlung des Datums aus dem JD. Daher soll hier nicht mehr ausführlicher darauf eingegangen werden. Auf den Seiten mit den Kalenderrechnern ist der Quellcode ersichtlich. Weitere Auskünfte erteilen die Verfasser jederzeit gerne.


voriger Absatz nächster Absatz Seitenanfang Seitenende

Beispiel eines einfachen Kalender zur Umrechnung abendländischer Daten

Bereits weiter oben wurde beschrieben, wie die Berechnung des julianisch-gregorianischen Kalenders aussehen könnte. Hier soll nun noch einmal der Quellcode angezeigt werden:
   function floor(x)
   { return Math.floor(x)
   }

   function Datum(Tag, Monat, Jahr)
   {
    this.Tag = Tag;
    this.Monat = Monat;
    this.Jahr = Jahr;
    }

    // *****Berechnung von JD aus d, m, y*****

    function getJulianDay(d, m, y)
    {
    m-= 3;
    if(m<0){m+= 12; y--;}
    var JD = floor(y*365.25)+ floor(m*30.6 + 0.5)+ d + 1721117;
    if(JD>2299170){JD -= floor(y/100) - floor(y/400) - 2;}
    return JD;
    }

    // *****Berechnung von d, m, y aus JD*****

    function makeDate(jd)
    {
    var tz = jd - 1721117;
    if (jd>2299160) {tz += floor((tz+2) / 36524.25) - floor((tz+2) / 146097) - 2 ;}
    var y  = floor((tz-0.2) / 365.25);
    var r  = tz - floor(y * 365.25);
    var m  = floor((r - 0.5) / 30.6);
    var d  = r - floor(m * 30.6 + 0.5);
    m+= 3;
    if(m>12) {m-= 12; y++}
    var x = new Datum(d, m, y);
    return x
    }

 Beispiel: So könnte dieser vereinfachte Rechner aussehen

 Beispiel: 2. Version, berechnet die Differenz zwischen 2 Datumsangaben


voriger Absatz Seitenanfang

Startseite Glossar Gästebuch Forum Impressum FAQ Inhalt

© 2001 - 2006 Nikolaus A. Bär   e-mail zur E-mail Adresse