XProfan

Italia

Michael
Wodrich

Leider ist in den beiden folgenden Funktionen noch der Wurm drin...
Kompilieren Markieren Separieren

Proc Date2Days

    Wandelt das Datum eine eine Anzahl von Tagen.
    Hiermit können Berechnungen leichter durchgeführt werden.
    Die Umkehrfunktion Days2Date() erstellt daraus wieder ein gültiges Datum.
    Parameters Date&
    Declare Century&,Year&,Month&,Day&
    Century& = @GetCentury(Date&)
    Year& = @GetYear(Date&)
    Month& = @GetMonth(Date&)
    Day& = @GetDay(Date&)

    If Month& > 2

        Sub Month&,3

    Else

        Add Month&,9

        If (Year&)

            Dec Year&

        Else

            Year& = 99
            Dec Century&

        EndIf

    EndIf

    Return @Int((146097 * Century&) / 4 + (1461 * Year&) / 4 + (153 * Month& + 2) / 5 + Day& + 1721119)

EndProc

Kompilieren Markieren Separieren

Proc Days2Date

    Wandelt eine Anzahl von Tagen in ein gültiges Datum um.
    Zusammen mit Date2Days() können so leichter Datumsberechnungen durchgeführt werden.
    Parameters Days&
    Declare Century&,Year&,Month&,Day&
    Days& = Days& - 1721119
    Century& = (4 * Days& - 1) / 146097
    Days& = 4 * Days& - 1 - 146097 * Century&
    Day& = Days& / 4
    Year& = (4 * Day& + 3) / 1461
    Day& = 4 * Day& + 3 - 1461 * Year&
    Day& = (Day& + 4) / 4
    Month& = (5 * Day& - 3) / 153
    Day& = 5 * Day& - 3 - 153 * Month&
    Day& = (Day& + 5) / 5

    If Month& < 10

        Add Month&,3

    Else

        Sub Month&,9
        Inc Year&

        If Year& > 99

            Year& = 0
            Inc Century&

        EndIf

    EndIf

    Return @MakeDate(Century&,Year&,Month&,Day&)

EndProc

Die Funktionen sollten auch Daten vor 1583 korrekt berechnen.

Auf den 4.10.1582 folgte durch die Kalenderreform der 15.10.1582, es wurden also 10 Tage gestrichen, um den Schaltjahr-Fehler wieder auszugleichen.

Aber genau hier corre das Hin- und zurückrechnen aus dem Ruder.

Denksportaufgabe?

MfG
Michael Wodrich

Programmieren, das spannendste Detektivspiel der Welt.

07.06.2004 ▲

Vollständiges Zitat

Absatzweise Citazione Zeilenweise Citazione

Michael
Wodrich

Hier der Original-Auszug.

Ich weiß die Quelle leider nicht mehr. Hatte ich mal aus dem Internet einfach in un Textdatei gegrabbt (leider nur diesen Teil):

Julianischer Tag
Es gäbe kein Jahr-2000-Problem, wenn alle Programmierer und Computerhersteller die Julianische Tageszahl
per das Datum verwendet hätten. Stattdessen wurde das Jahr als Zeichenkette (TTMMJJ) gespeichert und das
führte dazu, daß nach 99 das Jahr 00 kommt. Grund per die zweistellige Speicherung der Jahreszahl war der
Zwang zum Speichersparen. Auch hier liegt die Julianische Tageszahl vorne, sie hätte noch weniger Speicher
gebraucht.

Die Julianische Tageszahl - oder einfacher der Julianische Tag - ist eine fortlaufende Zählung der Tage,
beginnend mit dem Tag 0, der am 1. Januar 4713 v. Chr. (im proleptischen Julianischen Kalender) um 12 Uhr
Mittags begann. Dementsprechend beginnt ein neuer Julianischer Tag auch immer um 12 Uhr Mittags,
was ursprünglich per die europäische Astronomie den Vorteil besaß, daß alle Beobachtungen einer Nacht an einem
einzigen Julianischen Tag stattfanden.
Die Julianische Tageszählung läßt sich durch Anhängen des seit 12 Uhr Mittags verflossenen Tagesbruchteils leicht
zu einer genauen Zeitangabe erweitern. So bezeichnet JD 2451605 den Tag, der am 1. März 2000 um 12 Uhr beginnt,
während JD 2451605.25 den Zeitpunkt um 18 Uhr desselben Tages bestimmt.

Diese Erweiterung wird in vielen Quellen als Julianisches Datum bezeichnet.

Julianische Tage wurden früher in der Regel (sofern nichts anderes spezifiziert wurde) nach mittlerer Sonnenzeit
gezählt, heute nach UT.
Die Weltzeit oder Universal Time (UT) wurde 1926 als Ersatz per die Greenwich Mean Time (GMT) eingeführt.
Zur dieser Zeit waren mehrere, zum Teil deutlich unterschiedliche Bedeutungen von GMT im Gebrauch.

UT ist per meisten praktische Belange gleichzusetzen mit der mittleren Sonnenzeit bezogen auf den Nullmeridian
von Greenwich.
Alternativ wurden Angaben auch in Ephemeridenzeit gemacht, was durch die Bezeichnung JED oder JDE
gekennzeichnet wurde. Auch heute ist gelegentlich sinnvoll, Julianische Tage in einer anderen als der UT-Skala
anzugeben. Die verwendete Zeitskala ist dann an die Zeitangabe anzuhängen, z.B. als JD 2 451 545.0 TDT per
den 1.Januar 2000, 12 Uhr Mittags nach TDT-Zeit.

Häufig finden sich auch Zeitangaben in einem Modifizierten Julianischen Datumsformat (MJD).
Die gebräuchlichste Definition eines MJD folgt aus MJD = JD - 2400000.5 der Nullpunkt liegt daher
beim 17. November 1858 um 0 Uhr (!) Weltzeit.

Andere Definitionen existieren allerdings auch, so daß bei der Verwendung von Daten in MJD Vorsicht geboten ist.
Aus diesem Grunde wird MJD auch von der Internationalen Astronomischen Union nicht anerkannt.

Die Bedeutung der Julianischen Tagesangabe in der heutigen Astronomie liegt zum einen in der Möglichkeit einer
kompakten, eindeutigen Zeitangabe, zum anderen in der einfachen Angabe und Berechnung von Zeitdifferenzen,
Perioden usw.

Die Julianische Tageszählung wurde 1581 von dem französischen Gelehrten Joseph Justus Scaliger
(in seinem Werk Opus novum de emendatione temporum) eingeführt, um eine eindeutige Zeitzählung ohne negative
Jahreszahlen zu erhalten. Dazu mußte der Anfang der Zeitzählung genügend weit in der Vergangenheit in
vorhistorischen Zeiten liegen. Scaliger konstruierte zunächst eine 7980 Jahre währende Julianische Periode,
indem er folgende Zyklen kombinierte:

den 28jährigen Sonnenzyklus, in dem sich (im Julianischen Kalender) die Kalenderdaten auf denselben
Wochentagen wiederholen (im Gregorianischen Kalender wäre dieser Zyklus 400 Jahre lang);

den 19jährigen Metonischen Zyklus, in dem sich die Mondphasen und Finsternisse an nahezu denselben
Kalenderdaten wiederholen; und

den 15jährigen Indiktionszyklus, der im Römischen Reich zur Steuererhebung und Volkszählung verwendet wurde
und, beginnend mit dem 25.Dezember 312 n.Chr, zur fortlaufenden Datierung bis in die heutige Zeit diente.

Das letzte Jahr, in dem alle drei Zyklen gemeinsam einen neuen Durchlauf begannen, war 4713 v. Chr.
Den 1. Januar dieses Jahres legte Scaliger als Beginn seiner Zeitrechnung fest. Für die meisten Menschen
der damaligen Epoche war dieses Datum allerdings fiktiv, da nach ihrem Glauben die Welt erst wesentlich später
erschaffen wurde. Scaliger selbst datierte die Erschaffung der Erde auf das Jahr 3267 v.Chr.

Der Algorithmus stellt sich dann folgendermaßen dar:
Y = Jahr, M = Monat (Januar = 1, Februar = 2, etc.),
D = Tag (eventuell mit Tagesbruchteilen)

Ist M > 2 lasse Y und M unverändert.
Ist M = 1 oder M = 2 dann ist
Y = Y - 1
M = M + 13

Im Gregorianischen Kalender rechnet man weiter:
A = INT (Y/100)
B = 2 - A + INT (A/4)
Im Julianischen Kalender ist B = 0!

Das gesuchte JD ist dann:
JD = INT (365.25 * (Y + 4716))
+ INT (30.6001 * (M + 1)) + D
+ B - 1524.5

Das Programm zum Berechnen des Julianischen Datums stellt sich dann folgendermaßen dar.
Beachten Sie, daß wegen der Besonderheit des Julianischen Datums der Tag nicht als Integer,
sondern als Gleitpunktzahl dargestellt wird.
Im Programm ist noch ein zweites Unterprogramm enthalten, das den JD wieder in unser gewohntes Datumsformat,
das Gregorianische Datum, umrechnet:
Kompilieren Markieren Separieren

#include <stdio.h>
#include <stdlib.h>
struct datum

{

    double tag;
    int monat;
    int jahr;

};

double julian_day(double day, int month, int year);
struct datum gregorian_date(double jday);
int main(void)

{

    int tag, monat, jahr;
    double jd;
    struct datum dat;
    printf(Tag, Monat und Jahr eingeben: );
    scanf(%d %d %d,&tag, &monat, &jahr);
    jd = julian_day(1.0*tag, monat, jahr);
    printf(
    Julianischer Tag fuer den %d.%d.%d = %1.2f
    ,
    tag, monat, jahr, jd);
    dat = gregorian_date(jd);
    printf(
    Zurueckgerechnet: %1.0f.%d.%d
    , dat.tag, dat.monat, dat.jahr);
    return 0;

}

/* Julianischer Tag (>=1):
* Gegeben: tag, monat, jahr
*
* Die gregorianische Kalenderreform wird beruecksichtigt (der Tag, der
* auf den 4. Oktober 1582 folgt ist der 15. October 1582
* Tage nach dem 15. Oktober 1582 werden als Gregorianischer Kalender
* bezeichnet. Der Julianische Tag beginnt um 12 Uhr GMT (Mittag).
* Um beliebige Uhrzeiten beruecksichtigen zu koennen, werden die Tage
* nicht als Integer- sondern als Gleitpunktzahlen angegeben.
*/
double julian_day(double day, int month, int year)

{

    int atmp, btmp, monthp, yearp;
    double ctmp;

    if (month > 2)

        {

            monthp = month + 1;
            yearp = year;

        }

    else

        {

            monthp = month + 13;
            yearp = year - 1;

        }

        if ((year > 1582) || (year == 1582 && month >= 10)

            || (year == 1582 && month ==10 && day >= 15))

            {

                atmp = year / 100;
                btmp = 2 - atmp + (atmp / 4);

            }

        else

            btmp = 0;
            atmp = 365.25 * yearp;
            ctmp = atmp;
            atmp = 30.6001 * monthp;
            ctmp =  ctmp + atmp;
            return (ctmp + day + 1720994.5 + btmp);

        }

        /* gregorian_date: Umrechnung Julianischer Tag
        in (Tag, Monat, Jahr) */
        struct datum gregorian_date(double jday)

        {

            int atmp, btmp, ctmp, dtmp, etmp, gtmp, ztmp;
            double ftmp;
            struct datum dd;
            ztmp = jday + 0.5;
            ftmp = (jday + 0.5) - ztmp;

            if (ztmp >= 2299161)

                {

                    gtmp = (ztmp - 1867216.25) / 36524.25;
                    ctmp = gtmp / 4;
                    atmp = ztmp + 1 + gtmp - ctmp;

                }

            else

                atmp = ztmp;
                btmp = atmp + 1524;
                ctmp = (btmp - 122.1) / 365.25;
                dtmp = 365.25 * ctmp;
                etmp = ((btmp - dtmp) / 30.6001);
                ztmp = 30.6001 * etmp;
                dd.tag = btmp - dtmp - ztmp + ftmp;

                if (etmp > 13.5)

                    dd.monat = etmp - 13;

                else

                    dd.monat = etmp - 1;

                    if (dd.monat > 2.5)

                        dd.jahr = ctmp - 4716;

                    else

                        dd.jahr = ctmp - 4715;
                        return(class=s4 href='./../../funktionsreferenzen/xprofan/dd/'>dd);

                    }