Newsgroup: it.comp.lang.visual-basic
Titolo: [?] Ancora sulla data cd giuliana.

Qualcuno ricorda il film "Pronto? C'e` una certa Giuliana per te." Bene, non
c'entra col mio discorso. :-)
Ma e` da quando _MARVA_ ha postato con oggetto:
    "DATA IN FORMATO GIULIANO"
che mi domando perche' venga cosi` chiamato il formato data che _MARVA_ ci
ha illustrato nel suo post di risposta a se stesso/a:
    "99001 è il primo giorno del 99, 01/01/1999
    99032 è il 32esimo giorno del 99, 01/02/1999
    101032 è il 32esimo giorno del 01, 01/02/2001"
Supponevo fosse una svista o un malinteso ma ho invece indirettamente
ricevuto conferma di tale denominazione sfogliando il rinnovato Sito comune
di ICAA:
 
http://www.sitocomune.com
dove un articolo di Giacomo Siliotti nella sezione "General" e` appunto
intitolato:
    "Convertire una data in data giuliana." (1)
Perche' tale formato viene detto "data giuliana"?
----------
(1) Come alternativa alla funzione del Siliotti propongo:
Option Explicit
Public Function Gregor2Giuli( _
  ByVal aDate As Date _
) As Long
  '
  ' Chi e` Gregor?!?... E Giuli, allora?
  '
  Dim intYear As Integer
  intYear = Year(aDate)
  Gregor2Giuli _
    = (intYear - 1900) _
    & Format$( _
          DateDiff("d", DateSerial(intYear, 1, 0), aDate) _
        , "000")
End Function
--
Ciao.
Maurizio
--------
?SPQR(C)
 X
--------

 Perche' tale formato viene detto "data giuliana"?
ciao, vieni pure su it.scienza.astronomia
ten
--
P.S.: Per risposte private togliere 10 dall'indirizzo e-mail

 ciao, vieni pure su it.scienza.astronomia
Magari, signor tenente! E chi ce l'ha il tempo? Grazie pero` dell'invito e
di avermi indicato una direzione di ricerca. :-)
... ... ... ...
Leggo su:
    HERRMANN, Joachim "Atlante di astronomia". (Oscar Studio Mondadori)
"Per i calcoli astronomici e` spesso opportuno avere a disposizione una
numerazione continua dei giorni, quale e` quella dei _giorni giuliani_
(G.G.): lo zero di questa numerazione e` fissato all'1/1/4713 a.C., alle 12h
U.T.: l'1/1/1970 e` allora anche il G.G. 2.440.588 (alle 12h). E` da notare
che il cambio della data non avviene a mezzanotte, ma al mezzogiorno U.T."
Pertanto non ci siamo. In parte. Infatti la stessa data:
    1/1/1970
col sistema di cui si parlava, sarebbe rappresentata con:
    70001
Quindi questo sistema e` impropriamente detto giuliano per l'analogia con la
numerazione continua dei giorni in un intervallo di tempo dato.
Ma allora anche le date in Visual Basic potrebbero essere chiamate
"giuliane", visto che l'1/1/1970 in realta` e` memorizzato come:
    25569
Boh?!


Maurizio:
  ti allego due routines per la conversione da/a data Gregoriana a/da "Julian
Day Number".  Non mi ricordo piu' dove le ho scovate ma le uso per i calcoli
delle effemeridi del sorgere e del tramontare di Sole e Luna in un programma
di navigazione aerea (e per il calcolo delle fasi lunari): sembrano funzionare
abbastanza bene perche' i valori calcolati dal programma coincidono con
quelli degli almanacchi.
Ho pure un' altra versione che tiene anche conto della longitudine
Public Function Date2JDN(ByVal DDay#, ByVal MMonth&, ByVal YYear&) As Double
'
'
    Dim A&, B&, C&, E&, F&
'
    If MMonth < 3 Then
        YYear = YYear - 1
        MMonth = MMonth + 12
    End If
    A = Int(YYear / 100)
    B = Int(A / 4)
    C = 2 - A + B
    E = Int(365.25 * (YYear + 4716))
    F = Int(30.6001 * (MMonth + 1))
 
    Date2JDN = C + DDay + E + F - 1524.5
'
'
'
End Function
Public Function JDN2Date(ByVal JDN&, ByVal Frac#) As Date
'
'   INPUT: JDN = Julian Day Number
'   OUTPUT: Gregorian year, month, and day
'
    Dim A&, B&, C&, H&, Z&, R#, Jd#
    Dim DDay#, MMonth&, YYear&, DDate$
'
    Jd = CDbl(JDN) + Frac
'
    Z = Int(Jd - 1721118.5)
    R = Jd - 1721118.5 - Z
    H = 100 * Z - 25
    A = Int(H / 3652425)
    B = A - Int(A / 4)
    YYear = Int((100 * B + H) / 36525)
    C = B + Z - 365 * YYear - Int(YYear / 4)
    MMonth = Fix((5 * C + 456) / 153)
    DDay = C - Fix((153 * MMonth - 457) / 5) + R
    If MMonth > 12 Then
        YYear = YYear + 1
        MMonth = MMonth - 12
    End If
'
    DDate$ = Int(DDay) & "/" & (MMonth) & "/" & (YYear)
    JDN2Date = CDate(DDate$)
'
'
'
End Function
Ciao e se poi ti interessasero i dettagli, fatti sentire.
Franco

 Ciao e se poi ti interessasero i dettagli, fatti sentire.
Ti ringrazio.
La mia curiosita` in effetti riguardava l'uso del termine "giuliano" per
indicare una data nel formato YYNNN o YYYNNN, dove "NNN" sta per il numero
progressivo del giorno nell'anno. Per ora sono fermo alla deduzione che tale
formato venga cosi` definito per il solo fatto di rappresentare una data con
una numerazione progressiva, dove quindi "giuliano" starebbe, piu` o meno,
per "progressivo".
L'altra curiosita`, sottintesa, riguardava chi fosse tal Giulio o Giulia,
dato che escluderei si tratti di Caio Giulio Cesare in quanto non vedo
relazione tra questo modo di rappresentare una data e il "calendario
giuliano", che da lui prende il nome e che, se non sbaglio, conta gli anni
dalla fondazione di Roma, non dall'1/1/4713 a.C. come invece avviene nel
caso dei "giorni giuliani".


 caso dei "giorni giuliani".
la prima volta che l'hai chiesto ho fatto finta di niente.
ora ho chiesto ad altavista
"january 1st, 4713"
e m'ha sparato immantinente varie pagine. la prima:
http://serendipity.magnet.ch/hermetic/cal_stud/jdn.htm
ovverossia julian day numbers, di cui sotto metto l'incipit.
pero' poi non dirmi che salto di palinfraska :)
a prop di salti, al meeting ci sei ?
ci terrei.
(rima in vostro onore :)
          1.. Introduction
          2.. The Julian Period
          3.. Astronomical Julian Days
          4.. Chronological Julian Days
          5.. Modified Julian Day Number
          6.. Lilian Day Number
          7.. Conversion Algorithms
1. Introduction
Astronomers and chronologists use a system of numbering days called Julian
days or Julian day numbers. The temporal sequence of days is mapped onto the
sequence of integers, -2, -1, 0, 1, 2, 3, etc. This makes it easy to
determine the number of days between two dates (just subtract one Julian day
number from the other).
For example, a solar eclipse was seen at Nineveh on June 15, 763 B.C.
(Julian Calendar), according to the Assyrian chronicles in the British
Museum, and a lunar eclipse occurred there on April 14, 425 B.C. (Julian
Calendar). The Julian day numbers corresponding to these dates are 1,442,903
and 1,566,296 respectively. This makes it easy to calculate that the lunar
eclipse occurred exactly 123,393 days after the solar eclipse.
Generally speaking, an integer date is any system of assigning a one-to-one
correspondence between the usual sequence of days (and nights) and the
integers. Such systems differ only in the day chosen to correspond to day 0
or day 1. For example, in some applications NASA uses the Truncated Julian
Date, which is the number of days since midnight on 1968-05-24 (at which
time the Apollo missions to the Moon were underway). Other starting dates
popular with computer programmers are, or have been, 1601-01-01 (Gregorian),
1900-01-01, 1901-01-01 and 1980-01-01 (when time began according to IBM
PCs). The choice is usually a consequence of a trade-off concerning (i) the
temporal precision required (days to microseconds), (ii) the length of the
period of interest (a decade, a century, a millennium, etc.), (iii) the
number of bytes available for storing the date and (iv) the number of
characters required to display the date.
The system of Julian day numbers should not be confused with the simpler
system of "Julian dates" which associates a date with the number of days
elapsed since January 1st of the same year, according to which 2000-12-31 is
day 366 of the year 2000 (see the Day-in-Year Program).
[ 
http://serendipity.magnet.ch/hermetic/cal_sw/ordinal/ordinal.htm
 ]
2. The Julian Period
The Julian day number system is sometimes (erroneously) said to have been
invented by Joseph Justus Scaliger (born 1540-08-05 J in Agen, France, died
1609-01-21 J in Leiden, Holland), who during his life immersed himself in
Greek, Latin, Persian and Jewish literature, and who was one of the founders
of the science of chronology. Scaliger's invention was not the system of
Julian days, but rather the so-called Julian period.
[...]
Although Joseph Justus Scaliger was, as noted above, one of the founders of
the science of chronology, it seems he did not invent the Julian day number
system. Its inventor was the astronomer John W. F. Herschel. Lance Latham
writes:
"It remained, however, for the astronomer John F. Herschel to turn this idea
[of Scaliger's] into a complete time system, rather than a method of
relating years. In 1849, Herschel published Outlines of Astronomy and
explained the idea of extending Scaliger's concept to days."

alla hp c'e' anche un bel po' di sw per calendari.
http://hermetic.magnet.ch/index.html

 (rima in vostro onore :)
Mi piacerebbe moltissimo esserci ma da come stanno andando le mie cose e`
possibile che abbia qualche impedimento per cui preferisco non esprimermi,
per ora.
[...]
