EphemPedia

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
====== Datumseingabe ======

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

<WRAP center round info 100%>
Es ist zu beachten, dass es einen Unterschied in der Zählweise der Jahre gibt:
  * //Astronomische// Zählweise: Es gibt ein "Jahr 0", also einen Zeit//raum// 1.1.0000 bis 31.12.0000
  * //Historische// Zählweise: Auf das Jahr 1 v. Chr. folgt **direkt** das Jahr 1 n. Chr. Es gibt kein "Jahr 0".
</WRAP>

{{ :astronomisch_historisch_jahr_null-01.png |}}

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.

===== Schaltjahr =====

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 [[wichtige_konstanten#zeitmasse|siderischen Jahr und dem tropischen Jahr]] aufzufangen.

<WRAP center round box 100%>
==== Beispiel für JavaScript ====

Die Funktion ''isLeap'' übernimmt eine Jahreszahl und gibt bei einem Schaltjahr ''false'' zurück, bei einem Gemeinjahr hingegen ''true''. Der Parameter ist die Ganzahl des gegebenen Jahres $Y$.

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

===== Monatsname =====

Es wird ein Monat $M$ aus der Tabelle ausgewählt, der zwischen 1 und 12 liegt.
{{tablelayout?rowsHeaderSource=1&colwidth="130px,140px,170px"&float=center}}
^  Tabelle 1  |||
^  Nummer $M$  ^  Monatsname  ^  Monatslänge $N$  ^
|  1   |  Januar     |  31  |
|  2   |  Februar    |  28*  |
|  3   |  März       |  31  |
|  4   |  April      |  30  |
|  5   |  Mai        |  31  |
|  6   |  Juni       |  30  |
|  7   |  Juli       |  31  |
|  8   |  August     |  31  |
|  9   |  September  |  30  |
|  10  |  Oktober    |  31  |
|  11  |  November   |  30  |
|  12  |  Dezember   |  31  |

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

===== Wahl des Tages =====

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

===== Der Julianische Tag JD =====

Der [[julianischer Tag JD|Julianischer Tag JD]] wird aufgrund seines Umfangs in einem eigenen Kapitel behandelt.

===== Wochentage =====

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

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

{{tablelayout?rowsHeaderSource=1&colwidth="99px,150px"&float=center}}
^  Tabelle 2  ||
^  $wt$   ^ Wochentag   ^
|  0      | Sonntag     |
|  1      | Montag      |
|  2      | Dienstag    |
|  3      | Mittwoch    |
|  4      | Donnerstag  |
|  5      | Freitag     |
|  6      | Samstag     |
|  7 $\hat{=}$ 0  | Sonntag     |

Die Reduktionsfunktion ''red(...)'' und die Rundungsfunktion ''round(...)'' findet man im Kapitel [[mathematische_grundlagen#reduktions-_und_rundungsfunktion|Mathematische Grundlagen]].

Jean Meeus gibt in seinen [[literaturhinweise#buecher|Astronomical Algorithms]] folgende Vorgehensweise an, um den Wochentag zu ermitteln:

  * Man ermittelt den [[julianischer_tag_jd#berechnung_der_jd|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.

<WRAP center round box 100%>
==== Beispiel ====

{{:beispiel_calculator.png?nolink| }} **Man ermittle den Wochtag für den 15.4.2023.**

Der Julianische Tag für dieses Datum wurde bereits in [[:julianischer_tag_jd#beispiel_1|Beispiel 1]] ermittelt. Für 00:00 $UT$ lautet das Ergebnis $JD = 2460049.5$

Es ist nun

$$\frac{2460049.5 + 1.5}{7} = 351435,\;\text{Rest}\;6$$

und der 15.4.2023 ist daher ein Samstag.
</WRAP>

<WRAP center round tip 100%>
Der ganzzahlige Rest einer Division lässt sich in diversen Programmiersprachen mit der ''Modulo-Funktion'' ermitteln. Der Operator, auch genannt Restwert-Operator, kann sich dabei unterscheiden:

  * In Java/JavaScript ist der Operator das ''%'': $10\;\textsf{%}\;3 = 1$ (10:3 = 3, Rest 1)
  * In Python und PHP ist der Operator ebenfalls ''%''.

</WRAP>

{{anchor:tag_des_jahres}}

===== Tagesnummer des Jahres =====

Bei einigen astronomischen Berechnungen ist es notwendig, die Tagesnummer eines gegebenen Jahres zu ermitteln. Dabei ist zwischen Gemeinjahren und Schaltjahren zu unterscheiden. 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 [[#monatsname |Anzahl der Tage]] in jedem Monat. Der Tag $1$ jedes Monats entpricht der folgenden Tagesnummer:

{{tablelayout?rowsHeaderSource=1&colwidth="125px,60px,60px,60px,60px,60px,60px,60px,60px,60px,60px,60px,60px"&float=center}}
^  Tabelle 3  |||||||||||||
^             ^  Jan  ^  Feb  ^  Mär  ^  Apr  ^  Mai  ^  Jun  ^  Jul  ^  Aug  ^  Sep  ^  Okt  ^  Nov  ^  Dez  ^
| Gemeinjahr  |  0    |  31   |  59   |  90   |  120  |  151  |  181  |  212  |  243  |  273  |  304  |  334  |
| Schaltjahr  |  0    |  31   |  60   |  91   |  121  |  152  |  182  |  213  |  244  |  274  |  305  |  335  |

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.

<WRAP center round box 100%>
==== Beispiel für JavaScript ====

Folgender Beispielcode enthält die Funktion ''isLeap'', die ermittelt, ob ein Schaltjahr vorliegt oder nicht. Diese Funktion wurde bereits [[:datumseingabe#schaltjahr|weiter oben vorgestellt]].

<code>
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
</code>
</WRAP>

Einen eleganteren Weg zeigt [[:literaturhinweise#books_meeus|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.

<WRAP center round box 100%>
==== Beispiel für JavaScript ====

<code>
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
</code>
</WRAP>

{{anchor:dezimales_jahr}}

===== Jahr in dezimaler Darstellung =====

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|Mondphasen]] und der [[konstellationen_der_planeten#aspekte|Aspekte der Planeten]] von Nutzen.

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

  * $Y = $ Gegebene Jahreszahl, Ganzzahl
  * $Q = 0$ im Normaljahr und $Q = 1$ im Schaltjahr. $J$ ist dann das Jahr in Dezimalform.

<WRAP center round box 100%>
==== Beispiele für JavaScript ====

<code>
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

</code>
</WRAP>