Julianischer Tag (Julian Day, JD) und Modifizierter julianischer Tag (MJD)
|
Der Julianische Tag (JD) ist ein System zur gemeinsamen Darstellung
von Datum und Zeit in einer einzigen Gleitkomma-Zahl.
Dieses System verwendet als Einheit Tage (ebenso wie Y1900),
als Nullpunkt -4712-01-01.
JD wird immer in Weltzeit UTC angegeben und ist daher unabhängig
von Ort (Zeitzone) und Datum (Sommerzeit).
Mit JD kann man besonders gut über sehr lange Zeiträume hinweg rechnen.
|
In der Astronomie wird zur Angabe von Datum und Zeit häufig der
Julianische Tag (Julian Day, JD) verwendet.
In der Astro-Literatur und in Astro-Webs finden sie Algorithmen
(Rechen-Vorschriften) zur Berechnung des JD aus den Bestandteilen
(yy-mo-dd hh:mi:ss) und umgekehrt.
Der Modifizierte Julianische Tag (MJD) ist eine Praxis-freundliche Variante
von JD, die vorwiegend für neuere historische Daten verwendet wird.
|
Y1900
 JD
Für jedes Datum >= 1900-03-01 kann man den Julianischen Tag bequem aus dem
Y1900-Wert berechnen, der von allen gängigen Microsoft-Programmen geliefert wird.
Mit LibreOffice oder
OpenOffice kann man das Y1900-Datum
und damit auch die gezeigte Basic-Funktion bereits ab >= 1582-12-01 verwenden.
Für weiter zurückliegende Daten muss man den Algorithmus des nächsten
Absatzes verwenden.
Leider liefert keines der Standard Kalkulations-Programme die Weltzeit UTC.
Die Differenz beträgt in Mitteleuropa 1 Stunde (1/24 Tag),
bei Sommerzeit 2 Stunden.
|
Function y1900_to_jd(y1900)
y1900_to_jd = y1900 + 2415018.5
End Function
(Aktuelle Daten mit Taste F9)
| | A | B | C |
|---|
| 1 | | 2415018,5 | |
|---|
| 2 | Datum | JD |
|---|
| 3 |
=JETZT()-1/24 |
=A3+$B$1 |
=y1900_to_jd(A3) |
| 4 | =DATUM(1900;3;1) | =A4+$B$1 |
=y1900_to_jd(A4) |
| 5 | =DATUM(1582;12;1) | =A5+$B$1 |
=y1900_to_jd(A5) |
|
JD
Y1900
Aus dem Julianischen Tag JD kann man umgekehrt auch den Y1900-Wert
ab den gleichen Untergrenzen berechnen, wie oben angegeben.
|
Function jd_to_y1900(jd)
jd_to_y1900 = jd - 2415018.5
End Function
|
yyyy,mo,dd,hh_utc,mi,ss
JD
Dieses Beispiel berechnet den JD aus den Bestandteilen
Jahr, Monat, Tag, Stunden (Weltzeit UTC !), Minuten, Sekunden.
Der Algorithmus wurde aus verschiedenen Quellen entnommen und modifiziert.
Jahre "unserer Zeit" (Anno Domini, AD oder "current era" CE)
werden als positive Jahreszahlen eingegeben. Jahre "vor unserer Zeit"
(Before Christ, BC) werden als negative Jahreszahlen eingegeben.
Das Jahr yyyy=0 ist nicht zulässig.
Die Tages-Grenze von JD liegt bei 12:00 mittags - Um diese Zeit treten ganzzahlige
JD-Werte auf.
Für die Berechnung sind keine Grenzen gesetzt, d.h. es werden auch negative
JD berechnet - Man kann mit ihnen auch bequem rechnen, z.B. Differenzen bilden.
Die Hilfsfunktion symfloor() finden sie weiter unten.
Live-Test (hier mit Javascript berechnet)
JD(Heute) = 0
JD(Jetzt) = 0
|
Function jd( _
yyyy As Double, mo As Double, dd As Double, _
Optional hh As Double = 0, _
Optional mi As Double = 0, _
Optional ss As Double = 0) As Double
' Use UTC !
Dim gregdat, ja, ma, t As Double
gregdat = 588828
' year
If (yyyy<0) Then yyyy = yyyy + 1
' month
ma = 0
If (mo>2) Then
ma = mo + 1
Else
yyyy = yyyy - 1
ma = mo + 13
End If
' calculate jd
jd = Int(365.25 * yyyy) + Int(30.6001 * ma) + dd + 1720995
' correct greg
If ((dd+31*(mo+12*yyyy)) >= gregdat) Then
ja = symfloor(yyyy / 100)
jd = jd + 2 - ja + symfloor(ja / 4)
End If
' time
t = (hh + mi / 60 + ss / 3600) / 24
jd = jd - 0.5 + t
End Function
|
JD
yyyy,mm,dd,hh_utc,mi,ss
iso
Dieses Beispiel berechnet die ganzzahligen Datum und Zeit-Bestandteile aus einem JD.
Da eine Funktion nur einen einzigen Wert zurückgeben kann, wird hier ein Text (String)
nach ISO-Norm erstellt (Details dazu auf
dieser Seite unter ISO-8601).
Aus den Bestandteilen
yyyy...ss
könnte man mit den Basic Standard-Funktionen
DateSerial()
und TimeSerial()
auch eine Y1900-Variable berechnen, allerdings nur für einen sehr
kleinen Teil des (theoretisch unendlich) großen JD-Bereichs.
Die Beispiel-Funktion jd_to_iso() gibt UTC
(Weltzeit) als String nach dem Standard ISO-9601 zurück.
♦ Details zur Umrechnung auf
Lokalzeit auf dieser Seite unter
UTC, Zeitzonen, Sommerzeit.
|
Function jd_to_iso(jd) As String
Dim rest, y400, y100, y4, y1, mx As Double
Dim yyyy, mo, dd, hh, mi, ss As Double
Dim iso As String
' Schaltjahre
rest = jd + 32044
y400 = Int(rest / 146097)
rest = dmod(rest, 146097)
y100 = mymin(3, Int(rest / 36524))
rest = rest - 36524 * y100
y4 = Int(rest / 1461)
rest = dmod(rest, 1461)
y1 = mymin(3, Int(rest / 365))
rest = rest - 365 * y1
' Datum
yyyy = (y400 - 12) * 400 + y100 * 100 + y4 * 4 + y1
mx = Int((rest * 111 + 41) / 3395)
rest = rest - 30 * mx - Int((mx + 1) * 7 / 12) + 1
dd = Int(rest + 0.5)
mx = mx + 3
mo = ((mx + 11) Mod 12) + 1
yyyy = yyyy + Int(mx / 13)
' Zeit
rest = (rest - dd) * 24
hh = Int(rest)
rest = (rest - hh) * 60
mi = Int(rest)
rest = (rest - mi) * 60
ss = Round(rest)
hh = hh + 12
' String
jd_to_iso = ymdhms_to_iso(yyyy, mo, dd, hh, mi, ss)
End Function
|
Y1900
MJD
Y1900
Gültige Y1900-Werte und gültige MJD-Werte kann man direkt
umrechnen. Lediglich für außerhalb liegende Daten muss
man den Umweg über JD (nächster Absatz) wählen.
|
Function y1900_to_mjd(y1900)
y1900_to_mjd = y1900 + 15018
End Function
Function mjd_to_y1900(mjd)
mjd_to_y1900 = mjd - 15018
End Function
|
yyyy,mm,dd
MJD
Das Modifizierte Julianische Datum (MJD) ist eine Praxis-nahe Variante des JD.
Sie beschreibt ein Datum im Bereich 1858-11-17 .. 2132-08-31
mit einer 5stelligen ganzen Dezimalzahl.
MJD wird u.a. für neuere historische und für aktuelle Datum-Werte eingesetzt.
Das Funktionsbeispiel rechts berechnet den aktuellen MJD für heute.
|
Function mjd(yy, mo, dd)
mjd = jd(yy, mo, dd, 0, 0, 0) - 2400000.5
End Function
Live-Test (hier mit Javascript berechnet):
MJD(Heute) = 0
|
MJD
yyyy,mm,dd
iso
Da eine Funktion nur einen einzigen Wert zurückgeben kann, weren die
Datum-Bestandteile als Text (String) nach Standard
→ ISO-8601 verpackt.
|
Function mjd_to_iso(mjd)
Dim jd As Double
jd = mjd - 2400000.5
mjd_to_iso = jd_to_iso(jd)
End Function
|
Diese Hilfsfunktionen werden von den JD-Beispielen verwendet:
Private Function symfloor(x)
If (x < 0) Then
symfloor = -Int(-x)
Else
symfloor = Int(x)
End If
End Function
|
Private Function dmod(a, b)
dmod = a - Int(a / b) * b
End Function
Private Function mymin(a, b)
If (b < a) Then
mymin = b
Else
mymin = a
End If
End Function
|
|
♦ Details zum Thema
Datum und Zeit
und zu Funktionen ganzer Zahlen
(floor, modulo, ...)
|
Basic
Ausgewählte Links zum Thema 'Basic @ Datum & Zeit'
MS-Software kann aus unbekannten Gründen nicht mit negativen Y1900-Werten
rechnen. In 
Im internen Kalender von MS-Programmen ist seit vielen Jahren ein 
Die 
Verwenden sie es nur zum Lesen der Daten - Änderungen der Registry
können die Funktion von Programmen oder System beschädigen ! 