Contributor: RUDOLF WEEBER
======================================
Datumsarithmetik mit den PC und Pascal
======================================
Dieser Informationstext soll allen Programmierern helfen, die mit
der Berechnung von Tagesdaten oder der Logik der kirchlichen Feier-
tage kaempfen. Diese Text kann frei verteilt werden, solange die
folgenden Informationen nicht daraus entfernt werden.
Copyright (c) 1992 fuer diese Zusammenstellung und den erlaeuternden
Text sowie evtl. erfolgte Korrekturen by Armin Hanisch (2:246/41)
Ich moechte allen danken, die durch ihre e-Mails und sonstige Bei-
traege, insbesondere der Veroeffentlichung von Sources diese Zu-
sammenstellung erst moeglich gemacht haben. Nach Informationsstand
des Autors haben alle Autoren diese Routinen als Public Domain frei-
gegeben. Ich uebernehme allerdings weder dafuer noch fuer die korekte
Berechnung irgendwelcher Daten eine Garantie. Ich habe allerdings
einige Stunden an Testarbeit investiert, die Daten stimmen!
Sources und Alogrithmen von folgenden Personen wurden ausgewertet,
zur Verfuegung gestellt und teilweise korrigert oder an einen fuer
diesen Text einheitlichen Stil bzw. Datentyp angepasst:
Armin Hanisch - Feiertagsberechnungen
Bernd Strehuber - Feiertagsberechnungen
Carley Phillips - Jul. Berechnungen
Jeff Duntemann - Wochentagsberechnung
Judson McClendon - Osterberechnung
Martin Austermeier - Tagesberechnungen
Paul Schlyter - Osterberechnung
Pit Biernath - Jul. Berechnungen
Scott Bussinger - Jul. Berechnungen
OSTERBERECHNUNGEN:
==================
Dieser Algorithmus basiert nicht auf der Berechnung von Gauss und
kommt ohne Ausnahmen aus (lt. Paul Schlyter). Werte ueber 31 be-
zeichnen den Tag im April-31, Werte darunter bezeichnen den Tag
im Maerz.
FUNCTION Easter(year : INTEGER) : INTEGER;
VAR a, b, c, d, e, f, g, h, i, k, l, m : INTEGER;
BEGIN
a := year MOD 19;
b := year DIV 100;
c := year MOD 100;
d := b DIV 4;
e := b MOD 4;
f := ( b + 8 ) DIV 25;
g := ( b - f + 1 ) DIV 3;
h := ( 19 * a + b - d - g + 15 ) MOD 30;
i := c DIV 4;
k := c MOD 4;
l := ( 32 + 2 * e + 2 * i - h - k ) MOD 7;
m := ( a + 11 * h + 22 * l ) DIV 451;
Easter := h + l - 7 * m + 22;
END{FUNC};
Eine weitere Moeglichkeit, Ostern sehr schnell zu berechnen, besteht
darin, den auf das juedische Passahfest folgenden Sonntag zu berechnen.
Der sog. Passah-Vollmond wird berechnet, in dem das Jahr durch 19 ge-
teilt wird und der Rest mit der folgenden Tabelle verglichen wird:
0: Apr 14 5: Apr 18 10: Mrz 25 15: Mrz 30
1: Apr 03 6: Apr 08 11: Apr 13 16: Apr 17
2: Mrz 23 7: Mrz 28 12: Apr 02 17: Apr 07
3: Apr 11 8: Apr 16 13: Mrz 22 18: Mrz 27
4: Mrz 31 9: Apr 05 14: Apr 10
Faellt dieses Datum auf einen Sonntag, ist Ostern der naechste Sonntag!
Beispiel: 1992 MOD 19 = 16, daraus folgt 17.04., der naechste Sonntag
ist dann der 19. April (Ostersonntag)
FEIERTAGE:
==========
Massgebend fuer die kirchlichen Feiertage ist sowohl das Osterdatum
als auch der 1. Advent, der Beginn des Krichenjahres. Wie man Ostern
berechnet, wurde oben erlaeutert. Hier nun also die Berechnungen der
restlichen Feiertage.
Aschermittwoch: 40 Tage vor dem Ostersonntag,
dann zurückgehen bis zum Mittwoch
Bsp.: result := GetOstern;
Dec(result,40);
WHILE DayOfWeek(result) <> 3 DO
Dec(result);
Palmsonntag: Der Sonntag vor dem Ostersonntag, die Berechnung
ist damit trivial.
Weisser Sonntag: Der Sonnrtag nach Ostern, ebenfalls simpel.
Christi Himmelfahrt: 39 Tage nach dem Ostersonntag oder anders gesagt,
der zweite Donnerstag vor Pfingsten.
Pfingsten: 49 Tage nach dem Ostersonntag.
Fronleichnam: 60 Tage nach dem Ostersonntag.
Maria Himmelfahrt: Fest am 15. August (nicht ueberall Feiertag!)
1. Advent: Vom 24.12. zurück bis zum nächsten Sonntag,
dann noch drei Wochen zurück.
Bsp.: result := MakeDate(24,12,year);
WHILE DayOfWeek(result) <> 0 DO
Dec(result);
Dec(result,21);
Buss- und Bettag: Der vorvorige Mittwoch vor dem 1. Advent, also
vom 1. Advent aus den Mittwoch suchen, dann noch
eine Woche zurück.
Bsp: <-- wie oben
WHILE DayOfWeek(result) <> 3 DO
Dec(result);
Dec(result,7);
Hl. drei Köinige: Fest am 06.01.
Allerheiligen: Fest am 01.11.
Tag der Arbeit: Fest am 01.05.
Tag der dt. Einheit: Fest am 03.10. Hier wird im Zuge von Sparmassnahmen
für die einzuführende Pflegeversicherung allerdings
überlegt, diesen Feiertag immer auf den ersten Sonn-
tag im Oktober zu legen, man sollte hier also die
politischen Nachrichten verfolgen!
DATUMSARITHMETIK:
=================
Berechnung eines Schaltjahres
-----------------------------
FUNCTION LeapYear(year : WORD) : BOOLEAN;
BEGIN
LeapYear := ((year MOD 4 = 0) AND (year MOD 100 <> 0))
OR (year MOD 400 = 0);
END;
Berechnung des Wochentages
--------------------------
FUNCTION DayOfWeek(Day,Month,Year: Integer): INTEGER;
VAR century,yr,dw: Integer;
BEGIN
IF Month < 3 THEN BEGIN
Inc(Month,10);
Dec(Year);
END{IF} ELSE
Dec(Month,2);
century := Year div 100;
yr := year mod 100;
dw := (((26*month-2) div 10)+day+yr+(yr div 4)
+(century div 4)-(2*century)) mod 7;
IF dw < 1 THEN Inc(dw,7);
DayOfWeek:=dw;
END{FUNC};
Als Ergebnis erhaelt man den Wochentag in folgender Reiehenfolge:
0=Sonntag, 1=Montag ..... 6=Samstag
Berechnung der Kalenderwoche
----------------------------
Die Woche 1 ist die Woche, die den ersten Donnerstag des Jahres
enthaelt, also mehr als die Haelfte diesem Jahr angehoert.
Ist der 01.01. ein Mo-Mi, dann liegt der 01.01. in der letzten
Woche des vergangenen Jahres. (DIN 1355)
FUNCTION WeekOfYear (Day,Month,Year:WORD) : WORD;
CONST
table1 : ARRAY [0..6] OF ShortInt = ( -1, 0, 1, 2, 3, -3, -2);
table2 : ARRAY [0..6] OF ShortInt = ( -4, 2, 1, 0, -1, -2, -3);
VAR
doy1 ,
doy2 : INTEGER;
BEGIN
doy1 := DayofYear (Day,Month,Year) + table1[DayOfWeek (1,1,Year)];
doy2 := DayofYear (Day,Month,Year) + table2[DayOfWeek(Day,Month,Year)];
IF doy1 <= 0 THEN WeekOfYear := WeekOfYear(31,12,Year-1)
ELSE IF doy2 >= DayofYear(31,12,Year) THEN WeekOfYear:=1
ELSE WeekOfYear := (doy1-1) DIV 7 + 1;
END;
Berechnung der Tage im Monat
----------------------------
FUNCTION DaysInMonth(month,year : WORD) : INTEGER;
VAR ly : BOOLEAN; { leap year? }
BEGIN
ly := ((year MOD 4 = 0) AND (year MOD 100 <> 0)) OR (year MOD 400 = 0);
IF (month IN [04,06,09,11]) THEN { even month }
DaysInMonth := 30
ELSE
IF month <> 2 THEN { rest except february }
DaysInMonth := 31
ELSE
IF ly THEN { leap year? }
DaysInMonth := 29
ELSE
DaysInMonth := 28;
END{FUNC};
Berechnung des Tages im Jahr
----------------------------
Diese Methode gilt fuer alle Jahre ab 1582, der Einführung des
gregorianischen Kalenders.
FUNCTION DayOfYear (day,month,year : WORD) : INTEGER;
VAR
i, tage : Integer;
BEGIN
tage := 0;
FOR i := 1 TO Pred(month) DO Inc (tage, DaysInMonth(i,year));
Inc (tage,day);
DayOfYear := tage;
END;
Eine andere Methode kommt ohne die Berechnung der Tage im Monat aus
und bezieht ebenfalls Schaltjahre ein. Der Gültigkeitsbereich dieses
Alogorithmus liegt von 1901 bis 2099.
FUNCTION DayNumber(Day,Month,Year : INTEGER ) : INTEGER;
VAR
term1 ,
term2 ,
term3 : INTEGER;
BEGIN
term1 := ( 275 * month ) div 9;
term2 := ( month + 9 ) div 12;
term3 := ( ( year mod 4 ) + 2 ) div 3;
DayNumber := term1 - term2 * ( 1 + term3 ) + day - 30;
END;
Um aus dem Tag im jahr wieder das Datum zu erhalten, kann die folgende
Routine verwendet werden:
FUNCTION YearDayToDMY(GYear,DayNumber : INTEGER; VAR Day,Month,Year : WORD);
CONST
MonthDays : Array [1..12] of integer=
(31,28,31,30,31,30,31,31,30,31,30,31);
VAR
I : integer;
done ,
ly : boolean;
BEGIN
I := 1;
done:=false;
ly := ((Gyear MOD 4 = 0) AND (Gyear MOD 100 <> 0))
OR (Gyear MOD 400 = 0);
IF ly THEN MonthDays[2] := 29; { correct for leap year february }
REPEAT
If DayNumber > MonthDays[i] THEN BEGIN
DayNumber := DayNumber - MonthDays[i];
Inc(i);
END{IF} ELSE BEGIN
year := GYear;
month := i;
day := DayNumber;
done := TRUE;
END{ELSE};
UNTIL (i > 12) OR done;
IF i > 12 THEN BEGIN
year:=GYear;
month:=12;
day:=31;
END{IF};
END;
Berechnung des julianischen Datums
----------------------------------
Diese Routinen dienen der Umwandlung des Datums in eine serielle
julianische Zahl im Bereich von 01.01.1900 bis zum 31.12.2078,
wobei 0 fuer den 01.01.1900 steht (uebringens: 1900 war kein Schalt-
jahr und der 01.01. war ein Montag).
FUNCTION DateOk(day,month,year : WORD) : BOOLEAN;
VAR
ly,ok : BOOLEAN;
maxday : WORD;
BEGIN
ok := (year >= 1900) AND (year <= 2078);
ly := ((year MOD 4 = 0) AND (year MOD 100 <> 0)) OR (year MOD 400 = 0);
IF ok THEN
ok := (month >= 01) AND (month <= 12);
IF ok THEN BEGIN
IF month IN [01,03,05,07,08,10,12] THEN
maxday := 31
ELSE
IF month <> 2 THEN
maxday := 30
ELSE
IF ly THEN
maxday := 29
ELSE
maxday := 28;
ok := (day >= 01) AND (day <= maxday);
END{IF};
DateOK := ok;
END{FUNC};
FUNCTION DMYtoDate(day,month,year : WORD) : WORD;
VAR
jul : Word;
BEGIN
IF NOT DateOK(day,month,year) THEN BEGIN
DMYToDate := $FFFF { signal an invalid date }
END{IF} ELSE BEGIN { convert back to DMY }
IF (Year = 1900) AND (Month < 3) THEN
IF Month = 1 THEN
jul := Pred(Day)
ELSE
jul := Day + 30
ELSE BEGIN
IF Month > 2 THEN
Dec (Month,3)
ELSE BEGIN
Inc (Month,9);
Dec (Year);
END{ELSE};
Dec(year,1900);
jul := ((1461 * LONGINT(Year)) div 4) +
((153 * Month+2) div 5) + Day + 58;
END{ELSE};
END{ELSE};
DMYToDate := jul;
END;
PROCEDURE DateToDMY(jul : WORD; VAR day,month,year: WORD);
VAR
LongTemp ,
Temp : LONGINT;
BEGIN
IF jul <= 58 THEN BEGIN
year := 1900;
IF jul <= 31 THEN BEGIN
month := 1;
day := Succ(jul);
END ELSE BEGIN
month := 2;
day := jul - 30;
END{ELSE}
END{IF} ELSE BEGIN
IF jul < $FF63 THEN BEGIN
LongTemp := (4 * LONGINT(jul-58)) - 1;
year := LongTemp DIV 1461;
temp := ((LongTemp MOD 1461) DIV 4) * 5 + 2;
month := temp DIV 153;
day := ((temp MOD 153) + 5) DIV 5;
Inc(year,1900);
IF month < 10 THEN
Inc(month,3)
ELSE BEGIN
Dec(month,9);
Inc(year);
END{ELSE};
END{IF} ELSE BEGIN { error in date range }
year := 0;
month := 0;
day := 0;
END{ELSE};
END{ELSE};
END;