Im folgenden Text stehen die Größen $Y,M,D$ für die ganzzahligen Werte von Jahr, Monat und Tag.

Die astronomische Verwendung eines Jahres Null und negativer Jahre ist die einzige, die für arithmetische Zwecke geeignet ist. Dies lässt sich anhand folgender Beispiele zeigen:

• Den Historikern zufolge starb Julius Cäsar am 15. März 44 v.Chr. Am 14. März 24 n.Chr. kam es zu einer Mondfinsternis.
  Wie groß ist der zeitliche Abstand zwischen diesen beiden Ereignissen? Es sind nicht $44 + 24 = 68$ Jahre, wie man vielleicht meinen könnte. Die astronomische Zählung liefert die korrekte Lösung: Cäsar starb im Jahr $-43$, und das Zeitintervall wird durch die algebraische Regel korrekt angegeben:

$$24 - ( -43) = 24 + 43 = 67\;\textrm{Jahre}$$

• In der historischen Zählpraxis der Jahre existiert die Regel der Teilbarkeit durch 4, die die julianischen Schaltjahre definiert, nicht mehr. Diese Jahre sind tatsächlich 1, 5, 9, 13,… v.Chr. In der astronomischen Zählweise heißen diese Schaltjahre jedoch 0, –4, –8, –12 usw., und es gilt weiterhin die Regel der Teilbarkeit durch 4.

In der Kalenderrechnung, auch Computus („Rechnen mit Zeit“) genannt, wurde unter Julius Cäsar eine Schaltjahres-Regel eingeführt und von Augustus vollendet.

Die Regel lautet: Alle Jahre,

• die durch 4 und nicht durch 100 teilbar
• die durch 400 teilbar sind,

werden Schaltjahre genannt. Diese Jahre sind genau ein Tag länger als die Gemeinjahre. Der kürzeste Monat Februar erhält am Monatsende einen Tag mehr, um die Differenz zwischen dem siderischen Jahr und dem tropischen Jahr aufzufangen.

// Schaltjahr berechnen (ja/nein)
function isLeap(Y) {
  if(Y > 1582) {
    // Gregorianischer Kalender
    return ((Y % 4 == 0 && J % 100 != 0) || Y % 400 == 0) ? 1 : 0;
  }
  else {
    // Julianischer Kalender
    return (Y % 4 == 0) ? 1 : 0; 
  }
}

Es wird ein Monat $M$ aus der Tabelle ausgewählt, der zwischen 1 und 12 liegt.

Der mit dem * gekennzeichnete Monat ist der Schaltmonat. In einem Schaltjahr hat er dann 29 Tage.

Der Tag $D$ liegt zwischen 1 und der Länge des Monats $N$.

Der Julianischer Tag JD wird aufgrund seines Umfangs in einem eigenen Kapitel behandelt.

Der Julianische Tag wird auf Betrag zwischen 0 und 7 reduziert. Diesem Wert wird der Name eines Wochentags (Tabelle) zugeordnet.

\[\begin{align} \mathrm{wt} =&\;\mathrm{red}[{(\mathrm{round}(\mathrm{red}(JD,7) + 1),0),7}] \\ =&\; \mathrm{red}({JD + 1.5, 7}) + 1 \end{align}\tag{1}\]

Die Reduktionsfunktion red(…) und die Rundungsfunktion round(…) findet man im Kapitel Mathematische Grundlagen.

Jean Meeus gibt in seinen Astronomical Algorithms folgende Vorgehensweise an, um den Wochentag zu ermitteln:

• Man ermittelt den Julianischen Tag für 00:00 Uhr $UT$. Der Julianische Tag für 00:00 $UT$ liefert immer eine Zahl mit der Kommastelle $0.5$, die Addition von $1.5$ ergibt daher immer eine ganze Zahl.
• Dann addiert man $1.5$ zu diesem Wert und teilt das Ergebnis durch $7$.
• Der ganzzahlige Rest dieser Division ist 0, 1, 2, 3, 4, 5 oder 6, und entspricht dem Wochentag laut obiger Tabelle.

Die Tagesnummer $Z$ gibt die Summe der Tage vom Jahresbeginn bis zum gegegeben Tag des Jahres an.

$Z$ liegt zwischen 1 bis 365 (bzw. 366 in einem Schaltjahr). Es gilt:

$$Z = \sum_{M = 1}^{13} N\cdot(M - 1) + D\tag{2}$$

Dabei ist $N$ ist die Anzahl der Tage in jedem Monat. In einigen Fällen ist es notwendig, diese Tagesnummer eines gegebenen Jahres zu ermitteln. Dabei ist zwischen Gemeinjahren und Schaltjahren zu unterscheiden. Der Tag $1$ jedes Monats entpricht der folgenden Tagesnummer:

Die Tabelle beginnt die Zählung jeweils bei $0$, da der Tag $D$ des aktuellen Monats noch addiert wird:

• Der 16. Juni in einem Gemeinjahr ist der $151 + 16 = 167$. Tag des Jahres.
• Der 24. Oktober in einem Schaltjahr ist der $274 + 24 = 298$. Tag des Jahres.
• usw.

function getDayOfYear(Y, M, D) {
  const firsts = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
  if(isLeap(Y)) {
    // Für Schaltjahre: März bis Dezember um 1 erhöhen.
    let i = firsts.length;
    while(i-- > 2) {
      firsts[i] += 1;
    }
  }
  return firsts[M - 1] + D;
}
console.log(getDayOfYear(2023, 6, 16));  // => 167
console.log(getDayOfYear(2024, 10, 24)); // => 298
// Test für 1. März
console.log(getDayOfYear(2023, 3, 1));   // => 60
console.log(getDayOfYear(2024, 3, 1));   // => 61
// Test für 31. Dezember
console.log(getDayOfYear(2023, 12, 31)); // => 365
console.log(getDayOfYear(2024, 12, 31)); // => 366

Einen eleganteren Weg zeigt J. Meeus auf, die folgende Funktion ermittelt ebenfalls die Tagesnummer im Jahr. Die Parameter lauten wie in der obigen Funktion Y, M, D. Auch hier wird die Funktion isLeap verwendet.

function getDayOfYear(Y, M, D) {
  let k = isLeap(Y) ? 1 : 2;
  return Math.floor((275*M)/9) - k*(Math.floor((M + 9)/12)) + D - 30;
}
console.log(getDayOfYear(2023, 6, 16));   // => 167
console.log(getDayOfYear(2024, 10, 24));  // => 298

Mithilfe den beiden oben genannten Funktionen isLeap und getDayOfYear lässt sich ein beliebiges Datum nun als „dezimale Jahreszahl“ darstellen. Man ermittelt die Tagesnummer des Jahres und addiert dann den entsprechenden Bruchteil (Gemeinjahr/Schaltjahr) zum gegebenen Jahr (Integer!). Die dezimale Jahreszahl ist z.B. bei der Ermittlung der Mondphasen und der Aspekte der Planeten von Nutzen.

$$J = Y + \frac{Z}{365 + Q}\tag{3}$$

$Q = 0$ im Normaljahr und $Q = 1$ im Schaltjahr. $J$ ist dann das Jahr in Dezimalform.

function getDecimalYear(Y, M, D) {
  const days = isLeap(Y) ? 366 : 365;
  let doy = getDayOfYear(Y, M, D) - 1;
  return Y + (doy/days);
}
console.log(getDecimalYear(2023, 6, 16));   // => 2023.454794520548
console.log(getDecimalYear(2024, 10, 24));  // => 2024.811475409836
// 1. Januar 00:00 Uhr
console.log(getDecimalYear(2024, 1, 1));    // => 2024
// 31. Dezember 00:00 Uhr
console.log(getDecimalYear(2024, 12, 31));  // => 2024.9972677595629