Das Osterdatum und seine Berechnung

Im Jahr 325 wurde vom Konzil in Nicæa, das Konstantin der Große einberufen hatte, der Ostertermin verbindlich festgelegt, da bis dahin Christen verschiedener 'Kirchen' an unterschiedlichen Tagen feierten. Die Quartodecinianer etwa genau am Vollmondtag, die Ostkirche am jüdischen Pessach-Tag.

Das Konzil verfügte:

Ostern fällt immer auf einen Sonntag, und zwar denjenigen, der dem ersten Frühlingsvollmond folgt.

Laut christlicher Schriften ist der Auferstehungstag zwar genau ein Vollmondtag, doch wurde eine Regelung gesucht, die es auch möglichst verhindert, dass Ostern mit dem jüdischen Pessach-Festes zusammenfällt. Ein weiterer Vorteil für das Konzil: papsttreue christliche Gruppierungen waren leicht daran zu erkennen, dass sie die neue Vorschrift übernahmen.

So präzise diese Regelung scheint, so kompliziert ist sie im Detail. Der erste Vollmond nach der dem Winter folgenden Tag-und-Nacht-Gleiche ist kein Ereignis, das einem festen Kalendertag zugeordnet werden kann. Dieses Datum muss also von Astronomen für die Zukunft berechnet werden, um einen Kalender erstellen zu können.

Die vom Mönch Dionysius Exiguus um 525 berechneten Tabellen gehen von folgenden Annahmen aus:

Die Frühlings-Tag-und-Nacht-Gleiche fällt immer auf den 21. März.
regelmäßige Epakte (Mondphasen): alle 19 Jahre fällt der Vollmond auf den gleichen Tag des Sonnenjahres (mit Schalttag). (metonischer Zyklus)

Beide Annahmen sind freilich nur sehr grobe Schätzungen für die Realität, da der Frühlingsbeginn zwischen 19. und 21. März schwankt und der Mond keinen so regelmäßigen Umlauf zeigt.

Für die große Gregorianische Reform 1582 wurde vom Jesuitenmönch Christoph Clavius das Regelsystem erweitert, da ja bekanntlich die Berechnung der Schaltjahre geändert wurde. Interessanterweise war es gerade der Termin des Frühlingsbeginns, der die Abkehr vom julianischen Kalender nötig machte.

Die neue Regelung sollte möglichst der alten entsprechen, es gibt also zusätzliche Regeln für die vollen Jahrhunderte (die im alten Kalender stets Schaltjahre waren)
Der Mondzyklus wurde wiederum in einen 19-jährigen Metonischen Zyklus gebettet
Die alten Datumsgrenzen, wann Ostern frühestens und spätestens fallen kann, sollten weiterhin genauso gelten
Innerhalb eines 19-Jahr Zyklus darf sich der Osterterminzyklus nicht wiederholen - was eine weitere künstliche Verschiebung nötig machte.
Die Vermeidung des Zusammentreffens mit dem Pessach-Fest war immer noch von höchster Dringlichkeit.

So entstand die Regelung, die auch heute noch für die protestantische und katholische Kirche gilt.

Die orthodoxe Kirche (ausgenommen Finnland) hat übrigens die Gregorianische Osterdatums-Reform nicht mitgemacht und feiert demnach meist an einem anderen Tag Ostern als wir (2001 war eines der seltenen Jahre der Übereinstimmeung).

Es gibt auch gelegentlich Versuche zur Vereinheitlichung, da diese Diskrepanzen das Christentum aus der Sicht anderer Religionen nicht unbedingt sehr glaubhaft erscheinen lassen.

Ein recht vernünftiger Vorschlag, bei dem keine der beteiligten Gruppierungen ihr Gesicht verlieren würden wäre es, einfach das astronomisch korrekte Datum für den Frühlingsvollmond zu wählen und am Sonntag darauf zu feiern. Im letzten offiziellen Entwurf tauchte allerdings wiederum die Zusatzforderung der römischen Kirche auf, Ostern dürfe nicht mit dem Pessach-Fest zusammenfallen.

Konkrete Anstrengungen werden aber nicht unternommen, obwohl schon Papst Johannes der 23. feststellte, dass es auch kein religiöses Hindernis gäbe, Ostersonntag an einem kalendergebundenen Tag zu feiern (Etwa: der zweite Sonntag im April, ähnlich der Regelung für die Adventsonntage).

Man kann sich vorstellen, dass die Berechnung des tatsächlichen Ostersonntags eines Jahres mit den oben angeführten Regeln ziemlich kompliziert ist. Erst Gauss konnte eine Gruppe von Formeln aufstellen, die eine einfache Berechnung erlauben.

Berechnung des Osterdatums

Der Algorithmus von Gauss (1800 veröffentlicht)

zuerst bestimmt man die Kennzahlen M und N:

Jahr          M  N
1582-1699    22  2 
1700-1799    23  3 
1800-1899    23  4 
1900-2099    24  5 
2100-2199    24  6 
2200-2299    25  0 
2300-2399    26  1 
2400-2499    25  2

nun berechnet man für das Jahr J:

A = J mod 19 
B = J mod 4 
C = J mod 7 
D = (19A+M) mod 30 
E = 2B+4C+6D+N) mod 7 
 
Ostersonntag ist der (22+D+E).März oder (D+E-9).April 
 
Falls sich rechnerisch der 26. April ergibt, 
wird der 19. April gewählt.

Ergibt sich der 25. April und ist D=28 und A>10, 
so wird der 18. April gewählt.

Die Funktion mod bedeutet den Divisionsrest. 11 mod 4 ist also 3, da 11 durch 4 den Rest 3 ergibt.

Algorithmus von O'Beirne (1965)

Wenn man sich auf die Jahre 1900 bis 2099 beschränkt, kann eine einfachere Vorschrift gefunden werden.

N = J-1900
A = N mod 19
B = [(7A+1)/19]
M = (11A+4-B) mod 29
Q = [N/4]
W = (N+Q+31-M) mod 7
P = 25-M-W

Ostersonntag ist der P. April oder der (P+31). März

Die dabei verwendete Schreibweise [x] bedeutet den auf die nächste ganze Zahl abgerundeten Wert. Informatiker schreiben statt [N/4] auch gerne N div 4 und meinen die Ganzzahl-Division.

Hier eine Version für MSW-LOGO:

to ostern :jahr
   make "n :jahr-1900
   make "a remainder :n 19
   make "b int ((7*:a+1)/19)
   make "m remainder (11*:a+4-:b) 29
   make "q int (:n / 4)
   make "w remainder (:n+:q+31-:m) 7
   make "p 25-:m-:w

   ifelse :p > 0 [(pr :p [. April])] ~
                 [(pr :p+31 [. März])]
   
end

Der Algorithmus von Butcher:

Diese Formeln gelten für alle Jahre, solange die Kirche an dieser Berechnungsart festhalten wird. Er soll erstmals 1876 in 'Butchers Ecclesiastical Calendar' veröffentlicht worden sein. Die folgenden Programme gelten sowohl für den julianischen, als auch den gregorianischen Kalender.

Hier eine Java-Version für die Konsole:

// Berechnung des Osterdatums
// Aufruf z.B. java ostern 2002


public class ostern
{
	public static void main(String[] arguments) 
	{
		int jahr=0;
		
		// haben wir einen Wert bekommen?
		if (arguments.length==0) 
		{
			System.out.println("Jahreszahl angeben!");
			System.exit(1);
		} 
		
		// ist der übergebene Wert eine Zahl?
		try {
			jahr = Integer.parseInt(arguments[0]);
		}
		catch (java.lang.NumberFormatException e) {
			System.out.println(arguments[0]+
			          "ist doch keine Jahreszahl!");
			System.exit(2);
		}
		
		// alles ok, wir rechnen!
		osterdatum(jahr);
	}

	public static void osterdatum(int jahr)
	{
		int a,b,c,d,e,f,g,h,i,j,k,l;
		int x,mon,tag;
		
		if (jahr <= 1583) 
		{   // julianisch
			a = jahr%4;
			b = jahr%7;
			c = jahr%19;
			d = (19*c+15)%30;
			e = (2*a+4*b-d+34)%7;
			x = d+e+114;
			mon = x/31;
			tag = (x%31)+1;
		}	
		else
		{   // gregorianisch
	 		a = jahr%19;
			b = jahr/100;
			c = jahr%100;
			d = b/4;
			e = b%4;
			f = (b+8)/25;
			g = (b-f+1)/3;
			h = (19*a+b-d-g+15)%30;
			i = c/4;
			j = c%4;
			k = (32+2*e+2*i-h-j)%7;
			l = (a+11*h+22*k)/451;
			x = h+k-7*l+114;
			mon = x/31;
			tag = (x%31)+1;	
		}
		System.out.print("Ostersonntag "+jahr+": "+tag+".");
		if (mon==3) System.out.println("Maerz");
		else System.out.println("April");
	}

}

Und hier für experimentierfreudige Naturen eine Python-Version für die IDLE. Du kannst nach Lust und Laune die julianische (bis 1582) und gregorianische (ab 1583) Berechnungsmethode vergleichen.


def ostern_greg(jahr):
    a = jahr%19
    b,c = divmod(jahr,100)
    d,e = divmod(b,4)
    f = (b+8)/25
    g = (b-f+1)/3
    h = (19*a+b-d-g+15)%30
    i,k = divmod(c,4)
    l = (32+2*e+2*i-h-k)%7
    m = (a+11*h+22*l)/451
    mon,tag = divmod(h+l-7*m+114,31)
    return (mon,tag+1)


def ostern_jul(jahr):
    a = jahr%4
    b = jahr%7
    c = jahr%19
    d = (19*c+15)%30
    e = (2*a+4*b-d+34)%7
    mon,tag = divmod(d+e+114,31)
    return (mon,tag+1)

Literatur:

Eine Fundgrube zum Thema Kalenderberechnung:
Dershowitz, Reingold:
"Calendrical Calculations",
Cambridge University Press.