1. Un premier message
Le module lunaire Eagle s’est posé sur la mer de la Tranquillité, le 20 juillet 1969, à 20h 17mn 40s, en temps universel.
Il est (« maintenant ») 0 heure 15mn 00sec et nous sommes le 9 septembre 2019 en temps civil local, ... soit 22h 15mn 00sec du 8 septembre 2019 en temps universel.
Question : combien de jours (avec les décimales) se sont écoulés entre ces deux dates (et heures) ?
Pas facile de répondre : il y a des mois de 28, 29, 30, 31 jours... les années bissextiles... il va être facile de se tromper.
La longue (et instructive) page suivante contient un très grand nombre d’informations utiles https://fr.wikipedia.org/wiki/Jour_julien
Disons que, pour le moment, les vingt premières lignes suffiront.
Avant de se lancer dans des choses plus compliquées, essayons d’apporter une réponse à la question en utilisant ceci :
https://promenade.imcce.fr/fr/pages2/278.html
Pour la date et heure de « maintenant » entrons les valeurs dans les bonnes cases (voir image jointe) :
Réponse : jour julien : 2458735.4270833335
Utilisons la même page avec la date (et heure) d’atterrissage du module lunaire.
Réponse : jour julien : 2440423.345601852
Il reste maintenant à faire la différence entre 2458735.4270833335 et 2440423.345601852 soit 18312,0814814814 jours !!!
ou, plus simplement, 18312,08 jours.
Conclusion :
Sous réserve d’avoir accès, à chaque fois, au jour julien, la réponse peut être calculée à l’aide d’une simple soustraction.
À suivre...
(remarque : en divisant 18312 par 365, on obtient 50,169... années, ce qui est vraisemblable)
2. Second message
Le contenu du message, ainsi que l’application numérique qui en découle sont dans le PDF accessible à l’adresse :
http://lerautal.lautre.net/journal/AAI/calculs/jj01.pdf
Si le sujet vous intéresse, vous pouvez lire le message.
La suite est destinée aux personnes qui s’intéressent aux calculs et aux algorithmes... et qui disposent d’un minimum de temps libre.
Vous trouverez :
– l’algorithme permettant le calcul du jour julien, pour une date du calendrier grégorien.
– un exemple développé de calcul
– deux « exercices » permettant d’appliquer l’algorithme (et de vérifier que vous l’avez compris). Si vous effectuez les deux calculs vous pourrez déterminer la période de la comète de Halley.
Remarques.
Pas besoin de moyens techniques compliqués : les calculs peuvent être réalisés avec papier-crayon-gomme (et un peu de concentration).
Compléments
Rémi :
« Les dates Juliennes sont utilisées également dans les outils informatiques qui manipulent des dates. Entre autres les tableurs dont Microsoft Excel, mais pas que, stockent toutes les dates en dates Juliennes, les calculs sont ainsi facilités avec une référence unique. Les dates sont ensuite affichées selon un format choisi. »
Réponse d’Alain :
Les feuilles de calcul (tableurs) tels qu’Excel ou Calc (de LibreOffice) sont des outils dédiés au monde « moderne récent ».
On s’en rend compte, par exemple en lisant la page https://wiki.documentfoundation.org/FR/Calc:_Fonctions_date_heure dédiée à Calc
Beaucoup de choses pratiques dédiées à la vie en entreprise : par exemple
la fonction JOURS qui permet de calculer le nombre de jours compris entre deux dates
https://wiki.documentfoundation.org/FR/Calc:_fonction_JOURS
Derrière la réalisation de ce calcul... on utilise un système qui associe une date à un numéro de jour, comme on le fait avec les jours juliens, mais pas forcément avec la même amplitude de dates possibles.
J’ai eu un doute en me demandant si cela fonctionnerait avec des dates anciennes.
Par exemple : combien de jours écoulés depuis le sacre de Charlemagne ? ou depuis l’explosion de la supernova de Tycho Brahé (le 11 novembre 1572).
Et bien non.
En poursuivant la lecture de la page https://wiki.documentfoundation.org/FR/Calc:_Fonctions_date_heure jusqu’au chapitre « Années avant 1925 »
On y lit ceci :
« »« »« »« »« »« »
Cependant, les fonctions Calc ne doivent pas être utilisées avec des dates avant le 15 Octobre 1582 - par exemple JOUR(« 04/10/1582 ») renvoie 14 au lieu de 04. Il est donc nécessaire de prendre certaines précautions lors de l’interprétation de dates anciennes, même avec des dates aussi récentes que 1924, afin de s’assurer que la date est cohérente avec le pays ou la situation. Les dates très anciennes ne devraient pas être utilisées pour des événements dans la mesure où les systèmes calendaires étaient très incertains. « »« »« »« »« »« »« »"
Je ne sais si Excel souffre des mêmes restrictions.
Les tableurs sont des outils dédiés à des usages généralistes dans le monde moderne (ou prétendu tel).
Il n’est pas surprenant qu’ils souffrent de quelques insuffisances (éventuellement contournables par une utilisation « adaptée ») pour l’astronomie, qui, elle, considère les grands espaces et les grandes durées.
Intervention de Jean-Louis
Libre office, par exemple, utilise une méthode qui ressemble au jour Julien, mais ce n’est pas le jour julien. Je cite :
"LibreOffice internally handles a date/time value as a numerical value. If you assign the numbering format « Number » to a date or time value, it is converted to a number.
For example, 01/01/2000 12:00 PM, converts to 36526.5. The value preceding the decimal point corresponds to the date ; the value following the decimal point corresponds to the time. If you do not want to see this type of numerical date or time representation, change the number format (date or time) accordingly. To do this, select the cell containing the date or time value, call its context menu and select Format Cells. The Numbers tab page contains the functions for defining the number format.
« »« »
Jean-Louis attire l’attention sur un point essentiel : la définition du « jour zéro », c’est à dire le point de départ de la numérotation des jours.
Le jour zéro peut être paramétré en choisissant l’une de ces dates :
’12/30/1899’ (default)
’01/01/1900’ (used in former StarCalc 1.0)
’01/01/1904’ (used in Apple software)
Pour ce qui concerne l’informatique, (le système) ce n’est pas le jour Julien qui est utilisé , mais le temps UNIX :
Je cite « L’heure Unix ou heure Posix (aussi appelée Unix timestamp) est une mesure du temps basée sur le nombre de secondes écoulées depuis le 1er janvier 1970 00:00:00 UTC, hors secondes intercalaires. Elle est utilisée principalement dans les systèmes qui respectent la norme POSIX1, dont les systèmes de type Unix, d’où son nom. C’est la représentation POSIX du temps. »
Alain :
Les systèmes informatiques « du début » disposaient de peu de mémoire et les processeurs manipulaient des données de petite taille.
Les programmeurs, mais aussi leurs outils logiciels, étaient contraints par les limitations de leurs machines.
À cause de cela, mais aussi parce qu’une industrie en pleine gestation ne prenait pas suffisamment en compte le long terme, les dates étaient enregistrées dans un format court, ne couvrant qu’un nombre restreint de jours.
Il en a résulté ce qui s’est appelé le « bug de l’an 2000 ».
(Voir : https://fr.wikipedia.org/wiki/Passage_informatique_%C3%A0_l%27an_2000).
Rappelons aussi que l’informatique s’est développée dans le « Nouveau Monde » où la prise en compte du passé est différente de celle de « la Vieille Europe ».
3. Troisième message
Comme dans le précédent message sur le sujet, l’essentiel est contenu dans un document PDF accessible ici :
http://lerautal.lautre.net/journal/AAI/calculs/jj02.pdf
Pas d’exercice proposé : si vous suivez l’exemple, après avoir expérimenté les calculs sur le calendrier grégorien, vous serez capables de suivre la démarche.
Ceci étant, nous avons deux algorithmes, adaptés chacun à un calendrier spécifique... mais rien qui fonctionne dans tous les cas.
4. Quatrième message
Voici la dernière livraison du feuilleton « jour julien ».
L’essentiel du contenu est dans le PDF accessible ici :
http://lerautal.lautre.net/journal/AAI/calculs/jj03.pdf
Il contient :
– un algorithme de Jean MEEUS (ou cité par lui) qui « marche » à la fois pour le calendrier julien et pour le calendrier grégorien.
– un peu de code en langage Python qui permet de réaliser automatiquement les calculs.
Le code Python 3 est directement téléchargeable à cette adresse :
http://lerautal.lautre.net/journal/AAI/calculs/jj01.py
Il est volontairement « aéré » pour en simplifier la compréhension.
5. Cinquième message
Solution à l’exercice proposé.
1.
Les deux dates données sont le 28 juillet 2061 et le 9 février 1986.
Par commodité, et pour avoir des jours juliens entiers, on suppose qu’il est midi à chaque fois.
2.
Si l’on utilise le programme Python donné ce matin, la partie principale sera modifiée de la façon suivante :
# ~ ########### Partie principale ###########
jour, heure = "2061-07-28", "12:00:00.0"
JJ1 = jdMeeus(jour, heure)
print("Jour julien pour date : ", jour, " et ", heure, " heures : ",JJ1)
jour, heure = "1986-02-09", "12:00:00.0"
JJ2 = jdMeeus(jour, heure)
print("Jour julien pour date : ", jour, " et ", heure, " heures : ",JJ2)
dif = JJ1 - JJ2
print("différence : ", dif, " jours")
print("En années : {0:.3f} ".format(dif / 365.25))Listage des résultats obtenus.
Jour julien pour date : 2061-07-28 et 12:00:00.0 heures : 2474034.0
Jour julien pour date : 1986-02-09 et 12:00:00.0 heures : 2446471.0
différence : 27563.0 jours
En années : 75.463Remarque, si l’on ne tient pas compte de l’heure (la supposant égale à zéro), il faut retrancher 0.5 à chaque numéro de jour julien.
Soit 2474033.5 et 2446470.5
La différence ne change pas.
4.
Remarque sur le code Python :
print("En années : {0:.3f} ".format(dif / 365.25))le fait d’utiliser cette syntaxe, permet de limiter l’affichage à trois décimales.
5.
Maintenant que l’on a une période pour la comète : 27563 jours, en faisant l’hypothèse qu’elle a peu varié, on peut remonter le temps en enlevant successivement ce nombre de jours à la dernière observation sûre : celle de 1986 (jj : 2446471.0)...
et comparer avec la liste de passages supposés :
https://fr.wikipedia.org/wiki/1P/Halley
Remarquons aussi qu’il serait utile de disposer d’un outil qui, ayant un numéro de jour julien, donnerait l’année, le mois, le jour...
Cet outil existe : https://promenade.imcce.fr/fr/pages2/278.html
(voir dans le bas si vous entrez 2418908.0 et cliquez sur calcul inverse, l’écran affiche la date : 24 août 1910 à 12 heures
Cinq passages plus tôt, le JJ est 2281093.0
... et la date : 17 avril 1533...
La page https://fr.wikipedia.org/wiki/1P/Halley nous donne 1531.
On peut en déduire que la période de la comète varie au fil du temps.
Le calcul astronomique est un puissant outil d’investigation.
Compléments.
Jean-Louis
Je te joins une fonction javascript que j’avais écrite quand j’ai fait le calendrier lunaire qui est sur le site . Elle converti depuis le jour Julien vers le calendrier actuel. Mais je me suis empressé d’oublier comment j’avais fait .... JJ est le jour Julien...
function conversionDepuisJulien(JJ){
/* calculs approchés d'après les formules de Jean Meeus */
if ((JJ < 0) || ( JJ > Number.MAX_SAFE_INTEGER)){
var resultat =" " ;
alert("Jour incorrect");
}
else{
var z = Math.floor(JJ + 0.5);
var f = JJ + 0.5 - z;
if (z < 2299161){ var a = z ;}
else {
var alpha = Math.floor((z-1867216.25)/36524.25) ;
var a = z+1+alpha-Math.floor(alpha/4) ;
}
var b= a + 1524;
var c= Math.floor((b-122.1)/365.25) ;
var d = Math.floor(365.25*c) ;
var e = Math.floor((b-d)/30.6001) ;
var jourHeure = (b-d - Math.floor(30.6001*e) + f).toPrecision(4) ;
var jour = Math.floor(jourHeure)
var heure = Math.round((jourHeure - jour)*24)
if (e<14){var mois = e-1 ;}
else {var mois = e-13 ;}
if (mois>2){var annee = c-4716 ;}
else{var annee = c- 4715 ;}
var resultat = jour.toString() + "/" + mois.toString() + "/" + annee.toString() ;
}
return resultat ;6. Remarques
Le présent article n’épuise pas le sujet mais propose quelques liens aidant à la compréhension, ainsi que des éléments permettant de comprendre comment mettre en oeuvre un algorithme.
Les compléments introduits par les relecteurs-contributeurs apportent des pistes pour aller plus loin et donner une information plus exacte et de meilleure qualité.