Wikipedia

Giorno giuliano

numero di giorni trascorsi dal mezzogiorno del lunedì 1º gennaio 4713 a.C.

Il giorno giuliano (Julian Day, JD) è il numero di giorni passati dal mezzogiorno del lunedì 1º gennaio 4713 a.C.[1] Il sistema dei giorni giuliani è stato progettato per fornire agli astronomi un singolo sistema di date che potesse essere usato per lavorare con differenti calendari, e per unificare differenti cronologie storiche, giacché esso non presenta la difficoltà di anni bisestili, cambi di calendario, eccetera.

La data giuliana è il giorno giuliano combinato con la frazione di giorno trascorso, a partire dal mezzogiorno del tempo universale (precedentemente chiamato GMT, Greenwich Mean Time). La frazione è trovata dividendo il tempo, espresso in ore, per 24 (ponendo 00:00 uguale a mezzogiorno, e 12:00 mezzanotte). L'espressione data giuliana è anche usata per riferirsi a una data del calendario giuliano, oppure a una data ordinale (l'anno e il numero del giorno dell'anno), perciò occorre fare attenzione a cosa ci si riferisce.

Gli astronomi utilizzano spesso un anno giuliano di esattamente 365,25 giorni per le effemeridi, per facilitare i conti, mentre per il calcolo di alcuni coefficienti usano il secolo giuliano, di esattamente 36525 giorni.

Storia

modifica
 
Giuseppe Scaligero

Il giorno giuliano è basato sul periodo giuliano proposto da Giuseppe Scaligero nel 1583, al tempo della riforma del calendario gregoriano. È un multiplo di tre cicli di calendario:

15 (ciclo dell'indizione) × 19 (ciclo metonico) × 28 (ciclo solare) = 7980 anni

La sua epoca (punto iniziale) è posta l'ultima volta che tutti questi tre cicli si trovavano assieme nel loro primo anno, e Scaligero la scelse perché era precedente a tutte le date storiche conosciute.

Nel suo libro Lineamenti di astronomia, pubblicato nel 1849, l'astronomo John Herschel raccomandò di utilizzare una versione dello schema di Scaligero per realizzare un sistema standard di date astronomiche, contando il "giorno del periodo giuliano". Questo sistema è diventato il sistema standard dei giorni giuliani. Il sistema ha il vantaggio di poter calcolare facilmente relazioni tra date lontane (per esempio nello studio di antichi scritti), e perché il punto iniziale a mezzogiorno fa cadere un'intera notte di osservazioni in un solo giorno giuliano, invece che in due.

Anche se molte fonti dicono che la parola giuliano si riferisce al padre di Scaligero, Giulio Cesare Scaligero, nell'introduzione del quinto libro del suo "Opus de emendatione temporis" ("Opera sulla correzione del tempo") Scaligero scrive: "Iulianum vocauimus: quia ad annum Iulianum dumtaxat accommodata est" che significa "Lo abbiamo chiamato Giuliano: poiché si conforma solamente all'anno Giuliano", intendendo il calendario giuliano introdotto da Gaio Giulio Cesare nel 46 a.C.

Calcolo

modifica

Conversione da data normale a data giuliana

modifica

Il seguente algoritmo è valido dal 4712 a.C. in poi; inoltre tiene conto della riforma gregoriana, tramite cui si passò direttamente dal 4 ottobre 1582 al 15 ottobre dello stesso anno. L'ora è da intendersi in formato 24h ed espresso in UT. 

inputs: dataAttuale, oraAttuale, reset(2415020.50);

// Estrazione Valori dalla data, per esempio, 12 febbraio 1980
anno = anno ( dataAttuale ); // 1980
mese = mese ( dataAttuale ); // 02
giorno = giorno ( dataAttuale ); // 12

// Estrazione Valori dall'ora, per esempio, 15:32.12
ore = ora ( oraAttuale ); // 15
minuti = minuti ( oraAttuale ); // 32
secondi = secondi ( oraAttuale ); // 12

if mese = 1 or mese = 2 then begin
  anno = anno - 1;
  mese = mese + 12;
end;

if dataAttuale < " 15 ottobre 1582 " then begin
  a = 0;
  b = 0;
end else begin
  a = ParteIntera( anno / 100 );
  b = 2 - a + ParteIntera( a / 4 );
end;

c = ParteIntera( 365.25 * anno );
d = ParteIntera( 30.6001 * ( mese + 1 ) );

// attualmente si riferisce all'inizio della giornata, in più viene sottratto
// un reset che permette di avere una migliore definizione della parte decimale
// (limiti rappresentativi dipendenti dalle strutture dati); il reset indicato
// si riferisce al 1º gennaio 1900, ma è una scelta mia arbitraria

dataGiuliana = b + c + d + giorno + 1720994.50 - reset;

// ora la definizione del punto della giornata dipende dall'utilizzo, e se ne sceglie
// solamente una delle seguenti

// 1. definizione all'ora (non mi interessano i minuti e i secondi)
offsetGiornata = ore / 24;

// 2. definizione al minuto (non mi interessano i secondi)
offsetGiornata = ( 60 * ore + minuti ) / 1440;

// 3. definizione al secondo
offsetGiornata = ( 3600 * ore + 60 * minuti + secondi ) / 86400;

// data giuliana completa
dataGiuliana = dataGiuliana + offsetGiornata;

Accenni matematici:

  1. ParteIntera(numero): restituisce la parte intera del numero (19.5 → 19)
  2. ParteDecimale(numero): restituisce la parte decimale del numero (19.5 → 0.5)
  3. Troncamento(numero,decimali): restituisce il numero con decimali pari a quelli voluti, senza arrotondare ([0.12345,3] → 0.123)
  4. Modulo(dividendo,divisore): restituisce il resto della divisione intera tra dividendo/divisore ([24,23] → 1)

Note: l'algoritmo richiede un certo livello di precisione nella parte decimale (es. 10 decimali con offset al minuto)

Conversione da data giuliana a data normale

modifica

Questo algoritmo serve per invertire il precedente; si noti che i decimali di troncamento (parametro) dipendono in particolare dalle variabili usate nell'implementazione, più sono i decimali e meglio è, ed in questo caso ne vengono utilizzati 9 poiché bastano. 

inputs: dataGiuliana, reset(2415020.50), decimaliTroncamento(9); 
 
// riaggiusto la mia data con il reset usato nella conversione
jd = dataGiuliana + reset;

i = ParteIntera( jd + 0.5 );
f = ParteDecimale( jd + 0.5 );

if i <= 2299160 then begin
  b = i;
end else begin
  a = ParteIntera( ( i - 1867216.25 ) / 36524.25 );
  b = i + 1 + a - ParteIntera( a / 4);
end;

c = b + 1524;
d = ParteIntera( ( c - 122.1 ) / 365.25 );
e = ParteIntera( 365.25 * d );
h = ParteIntera( ( c - e ) / 30.6001 );

giorno = c - e + f - parteIntera( 30.6001 * h );

if h < 14 then begin
  mese = h - 1;
end else begin
  mese = h - 13;
end;

if mese < 3 then begin
  anno = d - 4715;
end else begin
  anno = d - 4716;
end;

// a questo punto ho estratto la data normale
dataAttuale = creaData ( ParteIntera( anno ), ParteIntera( mese ), ParteIntera( giorno ) );

// ora estraggo l'ora dalla giornata, tenendo presente la rappresentazione usata in
// precedenza nella conversione, secondo le seguente modalità

// 1. definizione all'ora (non mi interessano i minuti e i secondi)
offsetGiornata = Tronca( ParteDecimale( dataGiuliana ) * 24, 0 );
ore = offsetGiornata;
minuti = 0;
secondi = 0;

// 2. definizione al minuto (non mi interessano i secondi)
offsetGiornata = Tronca( ParteDecimale( dataGiuliana ) * 1440, decimaliTroncamento );
ore = ParteIntera( offsetGiornata / 60 );
minuti = offsetGiornata - 60 * ore ; 
secondi = 0;

// 3. definizione al secondo
offsetGiornata = Tronca( ParteDecimale( dataGiuliana ) * 86400, decimaliTroncamento );
ore = ParteIntera( offsetGiornata / 3600 );
minuti = ParteIntera( ( offsetGiornata - 3600 * ore ) / 60 );
secondi = offsetGiornata - 3600 * ore - 60 * minuti;

// a questo punto ho estratto l'ora
oraAttuale = creaOra ( Modulo( ore, 24 ), Modulo( minuti, 60 ), Modulo( secondi, 60 ) );

Accenni matematici:

  1. ParteIntera(numero): restituisce la parte intera del numero (19.5 → 19)
  2. ParteDecimale(numero): restituisce la parte decimale del numero (19.5 → 0.5)
  3. Troncamento(numero,decimali): restituisce il numero con decimali pari a quelli voluti, senza arrotondare ([0.12345,3] → 0.123)
  4. Modulo(dividendo,divisore): restituisce il resto della divisione intera tra dividendo/divisore ([24,23] → 1)

Note: l'algoritmo richiede un certo livello di precisione nella parte decimale (es. 10 decimali con offset al minuto)

Calcolo del giorno della settimana

modifica 
// la data giuliana si intende riferita alla mezzanotte del giorno d'interesse
inputs: julian;

giornoSettimana = Mod( julian + 0.5 , 7);

Accenni matematici:

  1. Modulo(dividendo,divisore): restituisce il resto della divisione intera tra dividendo/divisore ([24,23] → 1)

Con giornoSettimana che assume i seguenti valori:

  1. il valore 0 indica il lunedì
  2. il valore 1 indica il martedì
  3. il valore 2 indica il mercoledì
  4. il valore 3 indica il giovedì
  5. il valore 4 indica il venerdì
  6. il valore 5 indica il sabato
  7. il valore 6 indica la domenica

Alternative

modifica
  • Il giorno giuliano eliocentrico (Heliocentric Julian Day, HJD) è identico al giorno giuliano, ma riferito al sistema di riferimento del Sole, e perciò può differire dal giorno giuliano normale fino a 8,3 minuti, cioè il tempo necessario alla luce per attraversare l'orbita della Terra. Il giorno giuliano è a volte chiamato giorno giuliano geocentrico per distinguerlo da quello eliocentrico.
  • Un'altra versione del giorno giuliano, introdotta da Peter Meyer, è il giorno giuliano cronologico, in cui il punto iniziale è posto alla mezzanotte del 1º gennaio 4713 a.C., ma nel fuso orario locale invece che UTC. La differenza tra mezzogiorno e mezzanotte significa che occorre aggiungere 0,5 al giorno giuliano per ottenere quello cronologico. Inoltre, utilizzare il fuso orario locale costringe a tener conto della differenza di ore tra il tempo universale e il fuso considerato, nonché dell'ora legale estiva, se applicabile. Gli utilizzatori del giorno giuliano cronologico chiamano l'altro giorno giuliano astronomico, per distinguerlo.

Poiché il punto di partenza è così lontano nel tempo, i numeri dei giorni giuliani possono essere molto grandi e difficili da maneggiare. A volte viene usato un punto di partenza più recente, per esempio semplicemente ignorando le cifre più significative, per poter entrare nella memoria limitata dei computer con una precisione sufficiente.

MJD = JD - 2400000,5
Lo spostamento di 0,5 significa che il MJD inizia e finisce alla mezzanotte del tempo universale, anziché a mezzogiorno. Il giorno MJD 1 coincide con il 18 novembre 1858.
  • Il giorno giuliano ridotto (RJD) è utilizzato anche dagli astronomi e conta i giorni dallo stesso inizio del MJD, ma a partire dal mezzogiorno UTC, ed è quindi definito come:
RJD = JD - 2400000
Il giorno RJD 1 inizia quindi a mezzogiorno del 17 novembre 1858 e finisce a mezzogiorno del 18.
  • Il giorno giuliano troncato (TJD) fu introdotto dalla NASA per il programma spaziale. Inizia il 24 maggio 1968. Poiché questo conteggio ha superato i numeri a quattro cifre il 10 ottobre 1995, alcuni adesso contano il TJD iniziando da quella data, per poter mantenere un numero a quattro cifre. Può essere definito come:
TJD = JD - 2440000,5
oppure come:
TJD = (JD - 0,5) mod 1000
  • Il giorno giuliano di Dublino è usato dai programmatori di computer, e conta i giorni a partire dal 1º gennaio 1900 (MJD 15020).

Altre epoche

modifica
  • 1º gennaio 1970 (MJD 40587): inizio dell'epoca Unix
  • 1º gennaio 2000 (MJD 51544)
  • 1º gennaio 1601 (lunedì) Data ANSI (JD 2305813,5): parte da 1 quindi Data ANSI = JD - 2305812,5 ed essendo sempre un numero intero si troncano i decimali.
  • 0 gennaio 1900 (MJD 15019): inizio del calendario di Microsoft Excel derivato dal giorno giuliano di Dublino (Dublin Julian Day) ma con inizio dalla mezzanotte.
    • il numero di un giorno fornito da Excel è = MJD - 15018 dal giovedì 1º marzo 1900 in poi, mentre è = MJD - 15019 dal 31 dicembre 1899 al 28 febbraio 1900, a causa di un bug nel software Lotus 1-2-3 che considerava bisestile il 1900, e che si volle intenzionalmente riprodurre in Excel per avere la retrocompatibilità[2]. Quindi Excel assegna il numero 0 al 31 dicembre 1899 (che però rappresenta come 00-gen-1900) e il numero 60 al 29 febbraio 1900, e poiché in modulo 7 assegna 1 alla domenica e 7=0 al sabato, considera il 1º gennaio 1900 come domenica, anziché lunedì (mentre dal 1º marzo 1900 riprende il conto corretto, infatti quel giorno è 61 che in modulo 7 fa 5, cioè giovedì).
  • 1º gennaio 1904, venerdì (MJD 16480) inizio del calendario di Excel per Macintosh; parte da 0, e quindi in modulo 7 assegna 1=sabato, 2=domenica, 3=lunedì...
  • 1º gennaio 1753 (JD 2361330,5): inizio del calendario di Microsoft SQL server
    • in questo caso si assegna lo zero al 1º gennaio 1900 (anziché assegnare 1 come in excel), quindi assegnando il numero -53690 all'inizio del calendario e 0 al 1º gennaio 1900. Perciò, il numero di un giorno fornito da Microsoft SQL Server = MJD - 15020 esteso anche ai negativi fino a -53690, ovvero = JD - 2415020,5 . Questa assegnazione si allinea all'uso del modulo 7 nella convenzione JD, quindi 1º gennaio 1900 ha il numero 0 che in modulo 7 è 0 cioè lunedì. La data del 1º gennaio 1753 è stata scelta per evitare incongruenze dovute al fatto che le varie colonie che poi avrebbero costituito i vari stati degli USA si adeguarono al calendario gregoriano seguendo la madrepatria, quindi in date diverse, dal 1582 al 1752.

Altri sistemi di conteggio dei giorni, chiamati anche date intere, includono la Data Liliana, il cui giorno 1 è il 15 ottobre 1582 (JD 2299161[3], giorno dell'adozione del calendario gregoriano); Rata Die, che conta dall'inizio dell'era Cristiana, il 1º gennaio dell'anno 1 (JD 1721425[3]).

Note

modifica
  1. ^ Si intende il 1º gennaio 4713 a.C. secondo il calendario giuliano, ossia quello valido per le date anteriori al 15 ottobre 1582. La data corrispondente usando retroattivamente il calendario gregoriano sarebbe il 24 novembre 4714 a.C.
  2. ^ https://support.microsoft.com/kb/214326
  3. ^ a b Dopo mezzogiorno.

Bibliografia

modifica
  • (EN) Gordon Moyer, "The Origin of the Julian Day System," Sky and Telescope, vol. 61, pp. 311–313 (April 1981).
  • (EN) Explanatory Supplement to the Astronomical Almanac, edited by P. Kenneth Seidelmann, published by University Science Books (August 1992), ISBN 0-935702-68-7

Voci correlate

modifica

Collegamenti esterni

modifica
  Portale Astronomia: accedi alle voci di Wikipedia che trattano di astronomia e astrofisica
Estratto da "https://it.wikipedia.org/w/index.php?title=Giorno_giuliano&oldid=141864704"