Berechnung des Oster-Sonntags-Datum | Schaltjahr Bestimmung

Einführung in den Algorithmus von C.F. Gauß

Das Osterfest (lateinisch »pascha«, von hebräisch »pessach«) ist der höchste christliche Feiertag im Jahr, an welchem der Auferstehung Jesu Christi in besonderer Weise gedacht wird. Nach altem Brauch fällt Ostern immer auf den Sonntag nach dem ersten Frühjahrsvollmond (nach gregorianischem Kalender frühestens der 22. März und spätestens der 25. April), was auf dem Konzil von Nizäa im Jahre 325 endgültig festgelegt wurde.

Daher wurden immer wieder Methoden gesucht, um den genauen Tag zu bestimmen. Hier wird dim folgenden er Algorithmus von Carl Friedrich Gauß vorgestellt.

Algorithmus von Carl Friedrich Gauß

Der Algorithmus von C.F. Gauß besteht aus einer Abfolge von Rechenschritten die im folgenden dargestellt sind: Ausgangspunkt ist immer eine Jahreszahl (hier als Variable Jahr bezeichnet), für die das Oster-Datum berechnet werden soll.

Schritt 1: Berechnung verschiedener Hilfszahlen

Für die späteren Berechnungen benötigt man verschiedene Hilfszahlen vor allem die Wertw M und N, die nach folgendem Algorithmus zu bestimmen sind:

// Bestimmung der Hilfszahlen
k = Jahreszahl ohne die letzten beiden Ziffern
p = Ganzzahliger Anteil (Modulo) (13 + 8k) : 25
q = Ganzzahliger Anteil der Division k : 4

M = Rest der Division von (15 - p + k - q) : 30
N = Rest der Divison von (4 + k - q) : 7

// zusätzlich werden folgende Werte benötigt
a = Rest der Division Jahr : 19
b = Rest der Division Jahr : 4
c = Rest der Division Jahr : 7
d = Rest der Division (19a + M) : 30
e = Rest der Division (2b + 4c + 6d + N) : 7

Schritt2: Berchnung des Osterdatums mit Hilfe der vorher bestimmten Hilfszahlen

Der Ostern-Sonntag ist dann am (22 + d + e)te März, sofern der Wert zwischen 1 und 31 liegt, sonst ist. Ist das nicht der Fall ist der Oster-Sonntag am (d + e -9)te April . Es gibt aber - wie oben beschrieben - einige Randbedingungen zusätzlich zu berücksichtigen:

Programmtechnische Umsetzung in Mathematica

(* Implementierung des Oster- Algorithmus nach C.F. Gauß *)

M=24; Nu=5;
For[Jahr = 1950, Jahr < 1980, Jahr++, a = Mod[Jahr, 19];
 b = Mod[Jahr, 4];
 c = Mod[Jahr, 7];
 d = Mod[(19*a + M), 30];
 e = Mod[(2 b + 4 c + 6 d + Nu), 7];

 Ostern1 = (22 + d + e);
 Ostern2 = (d + e - 9);

 If[(d == 29 && e == 6), Ostern2 = 19, Ostern2 = (d + e - 9)];
 If[(d == 28 && e == 6 && a > 10), Ostern2 = 18,
  Ostern2 = (d + e - 9)];

 If[(Ostern1 < 1 || Ostern1 <= 31), {Print[Jahr, " Ostern ist am ",
    Ostern1, ". März"]; Print[]}, Print["Ostern liegt im April"]];

 If[(Ostern2 >= 1 ), {Print[Jahr, " Ostern ist am ", Ostern2,
    ". April"]; Print[]}, {Print["Ostern liegt im März s.o."],
   Print[]}]]

>> Ausgabe:
1950 Ostern ist am 9. April

1951 Ostern ist am 25. März

1952 Ostern ist am 13. April

1953 Ostern ist am 5. April

1954 Ostern ist am 18. April
 :
 :
1976 Ostern ist am 18. April

1977 Ostern ist am 10. April

1978 Ostern ist am 26. März

1979 Ostern ist am 15. April

Das kurze Programm gibt die berechneten Oster-Sonntag Termine von 1950 bis 1980 aus. Es ist bewußt einfach gehalten, dass es problemlos, ohne tiefere Kentnisse der Wolfram-Languagge, in andere Sprachen übertragen werden kann.

Hier ein Beispiel in der populäreren Sprache Python:

print("Berechnung des Osterdatums")

Jahr = int ( input("Jahr eingeben: ") )  # Eingabe String in Ganzzahl wandeln

M = 24
N = 5

a = Jahr % 19
b = Jahr % 4
c = Jahr % 7
d = (19 * a + M) % 30
e = (2 * b + 4 * c + 6 * d + N) % 7

# Sonderfälle zuerst behandeln
if d == 29 and e == 6:
    tag = 19
    monat = "April"
elif d == 28 and e == 6 and a > 10:
    tag = 18
    monat = "April"
else:
    tag = 22 + d + e
    if tag <= 31:
        monat = "März"
    else:
        tag -= 31
        monat = "April"

print(f"Ostersonntag fällt im Jahr {Jahr} auf den {tag}. {monat}.")

Berechnung von Schaltjahren

Ein Jahr ist definiert als die Zeit, die die Erde für eine Umrundung der Sonne braucht. Ein Umlauf dauert genau 365 Tage, 5 Stunden, 48 Minuten und 45,252 Sekunden, also etwa um ¼ Tag länger als unser Kalenderjahr. Um diesen Unterschied auszugleichen wird alle 4 Jahre ein Schalttag, der 29. Februar, eingeschaltet. Damit die Rechnung noch genauer aufgeht, müssen über einen Zeitraum von 400 Jahren, jeweils drei Schaltjahre gestrichen werden. Dazu wurden die drei Schaltjahr-Regeln eingeführt.

Die drei Schaltjahr Regeln

Ein Jahr ist ein Schaltjahr, wenn die Jahreszahl restlos durch 4 teilbar ist. Ein Jahr ist kein Schaltjahr, wenn es durch 4 und 100 restlos teilbar ist. Ein Jahr ist ein Schaltjahr, wenn es sowohl durch 4, durch 100 und durch 400 teilbar ist. Folgende Funktion ergibt True wenn ein Jahr ein Schaltjahr ist:

  Clear[Jahr];
  Schaltjahr[Jahr_] :=
   If[(Mod[Jahr, 4] == 0 && Mod[Jahr, 100] != 0) || Mod[Jahr, 400] == 0,
     True, False]
  (*Aufruf: Schaltjahr[2000] True *)

Mit etwas mehr AUfwand lässt sich leicht eine Tabelle mit Jahreszahlen erstellen, in der die Schaltjahre farblich hervorgehoben werden

  ClearAll[SchaltjahrBlock]

  Schaltjahr[Jahr_Integer] :=
    Divisible[Jahr, 4] && (!Divisible[Jahr, 100] || Divisible[Jahr, 400])

  SchaltjahrBlock[start_, ende_, zeilenbreite_: 10] := Module[
    {jahre, formatiert},

    jahre = Range[start, ende];

    formatiert = Map[
      If[Schaltjahr[#], Style[#, Bold, Blue], Style[#, Gray]] &,
      jahre
    ];

    Grid[
      Partition[formatiert, zeilenbreite],
      Frame -> All,
      Spacings -> {1, 1},
      ItemSize -> All
    ]
  ]

  (* Anwendung *)
  SchaltjahrBlock[1900, 2100]

Als Ergebnis erhält man dann eine solche Tabelle: