1Date::JD(3)           User Contributed Perl Documentation          Date::JD(3)
2
3
4

NAME

6       Date::JD - conversion between flavours of Julian Date
7

SYNOPSIS

9               use Date::JD qw(jd_to_mjd mjd_to_cjdnf cjdn_to_rd);
10
11               $mjd = jd_to_mjd($jd);
12               ($cjdn, $cjdf) = mjd_to_cjdnf($mjd, $tz);
13               $rd = cjdn_to_rd($cjdn, $cjdf);
14
15               # and 509 other conversion functions
16

DESCRIPTION

18       For date and time calculations it is convenient to represent dates by a
19       simple linear count of days, rather than in a particular calendar.
20       This is such a good idea that it has been invented several times.  If
21       there were a single such linear count then it would be the obvious data
22       interchange format between calendar modules.  With several versions,
23       calendar modules can use such sensible data formats and still have
24       interoperability problems.  This module tackles that problem, by
25       performing conversions between different flavours of day count.  These
26       day count systems are generically known as "Julian Dates", after the
27       most venerable of them.
28
29       Among Julian Date systems there are also some non-trivial differences
30       of concept.  There are systems that count only complete days, and those
31       that count fractional days also.  There are some that are fixed to
32       Universal Time (time on the prime meridian), and others that are
33       interpreted according to a timezone.  Some consider the day to start at
34       noon and others at midnight, which is semantically significant for the
35       complete-day counts.  The functions of this module appropriately handle
36       the semantics of all the non-trivial conversions.
37
38       The day count systems supported by this module are Julian Date, Reduced
39       Julian Date, Modified Julian Date, Dublin Julian Date, Truncated Julian
40       Date, Chronological Julian Date, Rata Die, and Lilian Date, each in
41       both integral and fractional forms.
42
43   Flavours of day count
44       In the interests of orthogonality, all flavours of day count come in
45       both integral and fractional varieties.  Generally, there is a quantity
46       named "XYZD" ("XYZ Date") which is a real count of days since a
47       particular epoch (an integer plus a fraction) and a corresponding
48       quantity named "XYZDN" ("XYZ Day Number") which is a count of complete
49       days since the same epoch.  XYZDN is the integral part of XYZD.  There
50       is also a quantity named "XYZDF" ("XYZ Day Fraction") which is a count
51       of fractional days since the XYZDN changed (whether that is noon or
52       midnight).  XYZDF is the fractional part of XYZD, in the range [0, 1).
53
54       This quantity naming pattern is derived from JD (Julian Date) and JDN
55       (Julian Day Number) which have the described correspondence.  Most of
56       the other flavours of day count listed below conventionally come in
57       only one of the two varieties.  The "XYZDF" name type is a neologism.
58
59       All calendar dates given are in ISO 8601 form (Gregorian calendar with
60       astronomical year numbering).  An hour number is appended to each date,
61       separated by a "T"; hour 00 is midnight at the start of the day and
62       hour 12 is noon in the middle of the day.  An appended "Z" indicates
63       that the date is to be interpreted in Universal Time (the timezone of
64       the prime meridian), and so is absolute; where any other timezone is to
65       be used then this is explicitly noted.
66
67       JD (Julian Date)
68           days elapsed since -4713-11-24T12Z.  This epoch is the most recent
69           coincidence of the first year of the Metonic cycle, indiction
70           cycle, and day-of-week cycle, using the Julian calendar.  It was
71           correspondingly named after the Julian calendar, and thus after
72           Julius Caesar.  Some information can be found at
73           <http://en.wikipedia.org/wiki/Julian_day>.
74
75       RJD (Reduced Julian Date)
76           days elapsed since 1858-11-16T12Z (JD 2400000.0).  Rarely used.
77
78       MJD (Modified Julian Date)
79           days elapsed since 1858-11-17T00Z (JD 2400000.5).  This was
80           introduced by the Smithsonian Astrophysical Observatory in 1957,
81           and is recommended for general use by the International
82           Astronomical Union and other authorities.
83
84       DJD (Dublin Julian Date)
85           days elapsed since 1899-12-31T12Z (JD 2415020.0).  This was
86           invented by the International Astronomical Union, and the epoch in
87           Terrestrial Time is the J1900.0 epoch used in astronomy.  (Note:
88           not B1900.0, which is a few hours later.)  It is rarely used.
89
90       TJD (Truncated Julian Date)
91           days elapsed since 1968-05-24T00Z (JD 2440000.5).  This is
92           primarily used by NASA, who devised it during the Apollo era.
93           There is a rumour that it's defined cyclically, as (JD - 0.5) mod
94           10000, but see
95           <http://cossc.gsfc.nasa.gov/cossc/batse/hilev/TJD.TABLE>.
96
97       CJD (Chronological Julian Date)
98           days elapsed since -4713-11-24T00 in the timezone of interest.  CJD
99           = JD + 0.5 + Zoff, where Zoff is the timezone offset in fractional
100           days.  This was devised by Peter Meyer, and described in
101           <http://www.hermetic.ch/cal_stud/cjd.htm>.
102
103       RD (Rata Die)
104           days elapsed since 0000-12-31T00 in the timezone of interest (CJD
105           1721425.0).  This is defined in the book Calendrical Calculations.
106           Confusingly, in the book the integral form is also called "RD".
107           The integral form is called "RDN" by this module to avoid
108           confusion, reserving the name "RD" for the fractional form.  (The
109           book is best treated with caution due to the embarrassingly large
110           number of errors and instances of muddled thinking.)
111
112       LD (Lilian Date)
113           days elapsed since 1582-10-14T00 in the timezone of interest (CJD
114           2299160.0).  This epoch is the day before the day that the
115           Gregorian calendar first went into use.  It is named after Aloysius
116           Lilius, the inventor of the Gregorian calendar.
117
118       The interesting differences between these flavours are whether the day
119       starts at noon or at midnight, and whether they are absolute or
120       timezone-relative.  Three of the four combinations of these features
121       exist.  There is no convention for counting days from timezone-relative
122       noon that the author of this module is aware of.
123
124       For more background on these day count systems,
125       <http://en.wikipedia.org/wiki/Julian_Date> is a good starting place.
126
127   Meaning of the day
128       A day count has meaning only in the context of a particular definition
129       of "day".  There are two main flavours of day to consider: solar and
130       conventional.
131
132       A solar day is based on the apparent motion of Sol in the Terran sky
133       (and thus on the rotation and orbit of Terra).  The rotation of Terra
134       is not constant in time, so this type of day is really a measure of
135       angle, not of time.  This is how days have been counted since
136       antiquity, and is still (as of 2006) the basis of civil time.  There
137       are two subtypes of solar day: apparent and mean.  The apparent solar
138       day is based on the actual observable position of Sol in the sky from
139       day to day, whereas the mean solar day smooths this motion out, in
140       time, over the course of the year.  At the sub-second level there are
141       different types of smoothing that can be used (UT1, UT2, et al).
142
143       A conventional day is any type of day that is not based on Terran
144       rotation.  The astronomical Ephemeris Time, a time scale based on the
145       motion of bodies in the Solar system, has a time unit that it calls
146       "day" which is derived from astronomical observations.  The modern
147       relativistic coordinate time scales such as TT have a notional "day" of
148       exactly 86400 SI seconds.  The atomic time scale TAI also has a "day"
149       which is as close to 86400 SI seconds as can be achieved.  All of these
150       "days" are roughly the duration of one Sol-relative rotation of Terra
151       during the early nineteenth century, but are not otherwise related to
152       planetary rotation.
153
154       Each of the day count scales handled by this module can be used with
155       any of these types of day.  For a day number to be meaningful it is
156       necessary to be aware of which kind of day it is counting.  Conversion
157       between the different types of day is out of scope for this module.
158       (See Time::UTC for TAI/UTC conversion.)
159

FUNCTIONS

161       Day counts in this API may be native Perl numbers or "Math::BigRat"
162       objects.  Both are acceptable for all parameters, in any combination.
163       In all conversion functions, the result is of the same type as the
164       input, provided that the inputs are of consistent type.  If native Perl
165       numbers are supplied then the conversion is subject to floating point
166       rounding, and possible overflow if the numbers are extremely large.
167       The use of "Math::BigRat" is recommended to avoid these problems.  With
168       "Math::BigRat" the results are exact.
169
170       There are conversion functions between all pairs of day count systems.
171       This is a total of 512 conversion functions (including 32 identity
172       functions).
173
174       When converting between timezone-relative counts (CJD, RD, LD) and
175       absolute counts (JD, RJD, MJD, DJD, TJD), the timezone that is being
176       used must be specified.  It is given in a ZONE argument as a fractional
177       number of days offset from Universal Time.  For example, US Central
178       Standard Time, 6 hours behind UT, would be specified as a ZONE argument
179       of -0.25.  Beware of floating point rounding when the offset does not
180       have a terminating binary representation (e.g., US Eastern Standard
181       Time at -5/24); use of "Math::BigRat" avoids this problem.  A ZONE
182       parameter is not used when converting between absolute day counts
183       (e.g., between JD and MJD) or between timezone-relative counts (e.g.,
184       between CJD and LD).
185
186       jd_to_jd(JD)
187       jd_to_rjd(JD)
188       jd_to_mjd(JD)
189       jd_to_djd(JD)
190       jd_to_tjd(JD)
191       jd_to_cjd(JD, ZONE)
192       jd_to_rd(JD, ZONE)
193       jd_to_ld(JD, ZONE)
194       rjd_to_jd(RJD)
195       rjd_to_rjd(RJD)
196       rjd_to_mjd(RJD)
197       rjd_to_djd(RJD)
198       rjd_to_tjd(RJD)
199       rjd_to_cjd(RJD, ZONE)
200       rjd_to_rd(RJD, ZONE)
201       rjd_to_ld(RJD, ZONE)
202       mjd_to_jd(MJD)
203       mjd_to_rjd(MJD)
204       mjd_to_mjd(MJD)
205       mjd_to_djd(MJD)
206       mjd_to_tjd(MJD)
207       mjd_to_cjd(MJD, ZONE)
208       mjd_to_rd(MJD, ZONE)
209       mjd_to_ld(MJD, ZONE)
210       djd_to_jd(DJD)
211       djd_to_rjd(DJD)
212       djd_to_mjd(DJD)
213       djd_to_djd(DJD)
214       djd_to_tjd(DJD)
215       djd_to_cjd(DJD, ZONE)
216       djd_to_rd(DJD, ZONE)
217       djd_to_ld(DJD, ZONE)
218       tjd_to_jd(TJD)
219       tjd_to_rjd(TJD)
220       tjd_to_mjd(TJD)
221       tjd_to_djd(TJD)
222       tjd_to_tjd(TJD)
223       tjd_to_cjd(TJD, ZONE)
224       tjd_to_rd(TJD, ZONE)
225       tjd_to_ld(TJD, ZONE)
226       cjd_to_jd(CJD, ZONE)
227       cjd_to_rjd(CJD, ZONE)
228       cjd_to_mjd(CJD, ZONE)
229       cjd_to_djd(CJD, ZONE)
230       cjd_to_tjd(CJD, ZONE)
231       cjd_to_cjd(CJD)
232       cjd_to_rd(CJD)
233       cjd_to_ld(CJD)
234       rd_to_jd(RD, ZONE)
235       rd_to_rjd(RD, ZONE)
236       rd_to_mjd(RD, ZONE)
237       rd_to_djd(RD, ZONE)
238       rd_to_tjd(RD, ZONE)
239       rd_to_cjd(RD)
240       rd_to_rd(RD)
241       rd_to_ld(RD)
242       ld_to_jd(LD, ZONE)
243       ld_to_rjd(LD, ZONE)
244       ld_to_mjd(LD, ZONE)
245       ld_to_djd(LD, ZONE)
246       ld_to_tjd(LD, ZONE)
247       ld_to_cjd(LD)
248       ld_to_rd(LD)
249       ld_to_ld(LD)
250           These functions convert from one continuous day count to another.
251           This principally involve a change of epoch.  The input identifies a
252           point in time, as a continuous day count of input flavour.  The
253           function returns the same point in time, represented as a
254           continuous day count of output flavour.
255
256       jd_to_jdnn(JD)
257       jd_to_rjdnn(JD)
258       jd_to_mjdnn(JD)
259       jd_to_djdnn(JD)
260       jd_to_tjdnn(JD)
261       jd_to_cjdnn(JD, ZONE)
262       jd_to_rdnn(JD, ZONE)
263       jd_to_ldnn(JD, ZONE)
264       rjd_to_jdnn(RJD)
265       rjd_to_rjdnn(RJD)
266       rjd_to_mjdnn(RJD)
267       rjd_to_djdnn(RJD)
268       rjd_to_tjdnn(RJD)
269       rjd_to_cjdnn(RJD, ZONE)
270       rjd_to_rdnn(RJD, ZONE)
271       rjd_to_ldnn(RJD, ZONE)
272       mjd_to_jdnn(MJD)
273       mjd_to_rjdnn(MJD)
274       mjd_to_mjdnn(MJD)
275       mjd_to_djdnn(MJD)
276       mjd_to_tjdnn(MJD)
277       mjd_to_cjdnn(MJD, ZONE)
278       mjd_to_rdnn(MJD, ZONE)
279       mjd_to_ldnn(MJD, ZONE)
280       djd_to_jdnn(DJD)
281       djd_to_rjdnn(DJD)
282       djd_to_mjdnn(DJD)
283       djd_to_djdnn(DJD)
284       djd_to_tjdnn(DJD)
285       djd_to_cjdnn(DJD, ZONE)
286       djd_to_rdnn(DJD, ZONE)
287       djd_to_ldnn(DJD, ZONE)
288       tjd_to_jdnn(TJD)
289       tjd_to_rjdnn(TJD)
290       tjd_to_mjdnn(TJD)
291       tjd_to_djdnn(TJD)
292       tjd_to_tjdnn(TJD)
293       tjd_to_cjdnn(TJD, ZONE)
294       tjd_to_rdnn(TJD, ZONE)
295       tjd_to_ldnn(TJD, ZONE)
296       cjd_to_jdnn(CJD, ZONE)
297       cjd_to_rjdnn(CJD, ZONE)
298       cjd_to_mjdnn(CJD, ZONE)
299       cjd_to_djdnn(CJD, ZONE)
300       cjd_to_tjdnn(CJD, ZONE)
301       cjd_to_cjdnn(CJD)
302       cjd_to_rdnn(CJD)
303       cjd_to_ldnn(CJD)
304       rd_to_jdnn(RD, ZONE)
305       rd_to_rjdnn(RD, ZONE)
306       rd_to_mjdnn(RD, ZONE)
307       rd_to_djdnn(RD, ZONE)
308       rd_to_tjdnn(RD, ZONE)
309       rd_to_cjdnn(RD)
310       rd_to_rdnn(RD)
311       rd_to_ldnn(RD)
312       ld_to_jdnn(LD, ZONE)
313       ld_to_rjdnn(LD, ZONE)
314       ld_to_mjdnn(LD, ZONE)
315       ld_to_djdnn(LD, ZONE)
316       ld_to_tjdnn(LD, ZONE)
317       ld_to_cjdnn(LD)
318       ld_to_rdnn(LD)
319       ld_to_ldnn(LD)
320           These functions convert from a continuous day count to an integral
321           day count.  The input identifies a point in time, as a continuous
322           day count of input flavour.  The function returns the day number of
323           output flavour that applies at that instant.  The process throws
324           away information about the time of (output-flavour) day.
325
326       jd_to_jdnf(JD)
327       jd_to_rjdnf(JD)
328       jd_to_mjdnf(JD)
329       jd_to_djdnf(JD)
330       jd_to_tjdnf(JD)
331       jd_to_cjdnf(JD, ZONE)
332       jd_to_rdnf(JD, ZONE)
333       jd_to_ldnf(JD, ZONE)
334       rjd_to_jdnf(RJD)
335       rjd_to_rjdnf(RJD)
336       rjd_to_mjdnf(RJD)
337       rjd_to_djdnf(RJD)
338       rjd_to_tjdnf(RJD)
339       rjd_to_cjdnf(RJD, ZONE)
340       rjd_to_rdnf(RJD, ZONE)
341       rjd_to_ldnf(RJD, ZONE)
342       mjd_to_jdnf(MJD)
343       mjd_to_rjdnf(MJD)
344       mjd_to_mjdnf(MJD)
345       mjd_to_djdnf(MJD)
346       mjd_to_tjdnf(MJD)
347       mjd_to_cjdnf(MJD, ZONE)
348       mjd_to_rdnf(MJD, ZONE)
349       mjd_to_ldnf(MJD, ZONE)
350       djd_to_jdnf(DJD)
351       djd_to_rjdnf(DJD)
352       djd_to_mjdnf(DJD)
353       djd_to_djdnf(DJD)
354       djd_to_tjdnf(DJD)
355       djd_to_cjdnf(DJD, ZONE)
356       djd_to_rdnf(DJD, ZONE)
357       djd_to_ldnf(DJD, ZONE)
358       tjd_to_jdnf(TJD)
359       tjd_to_rjdnf(TJD)
360       tjd_to_mjdnf(TJD)
361       tjd_to_djdnf(TJD)
362       tjd_to_tjdnf(TJD)
363       tjd_to_cjdnf(TJD, ZONE)
364       tjd_to_rdnf(TJD, ZONE)
365       tjd_to_ldnf(TJD, ZONE)
366       cjd_to_jdnf(CJD, ZONE)
367       cjd_to_rjdnf(CJD, ZONE)
368       cjd_to_mjdnf(CJD, ZONE)
369       cjd_to_djdnf(CJD, ZONE)
370       cjd_to_tjdnf(CJD, ZONE)
371       cjd_to_cjdnf(CJD)
372       cjd_to_rdnf(CJD)
373       cjd_to_ldnf(CJD)
374       rd_to_jdnf(RD, ZONE)
375       rd_to_rjdnf(RD, ZONE)
376       rd_to_mjdnf(RD, ZONE)
377       rd_to_djdnf(RD, ZONE)
378       rd_to_tjdnf(RD, ZONE)
379       rd_to_cjdnf(RD)
380       rd_to_rdnf(RD)
381       rd_to_ldnf(RD)
382       ld_to_jdnf(LD, ZONE)
383       ld_to_rjdnf(LD, ZONE)
384       ld_to_mjdnf(LD, ZONE)
385       ld_to_djdnf(LD, ZONE)
386       ld_to_tjdnf(LD, ZONE)
387       ld_to_cjdnf(LD)
388       ld_to_rdnf(LD)
389       ld_to_ldnf(LD)
390           These functions convert from a continuous day count to an integral
391           day count with separate fraction.  The input identifies a point in
392           time, as a continuous day count of input flavour.  The function
393           returns a list of two items: the day number and fractional day of
394           output flavour, which together identify the same point in time as
395           the input.
396
397       jd_to_jdn(JD)
398       jd_to_rjdn(JD)
399       jd_to_mjdn(JD)
400       jd_to_djdn(JD)
401       jd_to_tjdn(JD)
402       jd_to_cjdn(JD, ZONE)
403       jd_to_rdn(JD, ZONE)
404       jd_to_ldn(JD, ZONE)
405       rjd_to_jdn(RJD)
406       rjd_to_rjdn(RJD)
407       rjd_to_mjdn(RJD)
408       rjd_to_djdn(RJD)
409       rjd_to_tjdn(RJD)
410       rjd_to_cjdn(RJD, ZONE)
411       rjd_to_rdn(RJD, ZONE)
412       rjd_to_ldn(RJD, ZONE)
413       mjd_to_jdn(MJD)
414       mjd_to_rjdn(MJD)
415       mjd_to_mjdn(MJD)
416       mjd_to_djdn(MJD)
417       mjd_to_tjdn(MJD)
418       mjd_to_cjdn(MJD, ZONE)
419       mjd_to_rdn(MJD, ZONE)
420       mjd_to_ldn(MJD, ZONE)
421       djd_to_jdn(DJD)
422       djd_to_rjdn(DJD)
423       djd_to_mjdn(DJD)
424       djd_to_djdn(DJD)
425       djd_to_tjdn(DJD)
426       djd_to_cjdn(DJD, ZONE)
427       djd_to_rdn(DJD, ZONE)
428       djd_to_ldn(DJD, ZONE)
429       tjd_to_jdn(TJD)
430       tjd_to_rjdn(TJD)
431       tjd_to_mjdn(TJD)
432       tjd_to_djdn(TJD)
433       tjd_to_tjdn(TJD)
434       tjd_to_cjdn(TJD, ZONE)
435       tjd_to_rdn(TJD, ZONE)
436       tjd_to_ldn(TJD, ZONE)
437       cjd_to_jdn(CJD, ZONE)
438       cjd_to_rjdn(CJD, ZONE)
439       cjd_to_mjdn(CJD, ZONE)
440       cjd_to_djdn(CJD, ZONE)
441       cjd_to_tjdn(CJD, ZONE)
442       cjd_to_cjdn(CJD)
443       cjd_to_rdn(CJD)
444       cjd_to_ldn(CJD)
445       rd_to_jdn(RD, ZONE)
446       rd_to_rjdn(RD, ZONE)
447       rd_to_mjdn(RD, ZONE)
448       rd_to_djdn(RD, ZONE)
449       rd_to_tjdn(RD, ZONE)
450       rd_to_cjdn(RD)
451       rd_to_rdn(RD)
452       rd_to_ldn(RD)
453       ld_to_jdn(LD, ZONE)
454       ld_to_rjdn(LD, ZONE)
455       ld_to_mjdn(LD, ZONE)
456       ld_to_djdn(LD, ZONE)
457       ld_to_tjdn(LD, ZONE)
458       ld_to_cjdn(LD)
459       ld_to_rdn(LD)
460       ld_to_ldn(LD)
461           These functions convert from a continuous day count to an integral
462           day count, possibly with separate fraction.  The input identifies a
463           point in time, as a continuous day count of input flavour.  If
464           called in scalar context, the function returns the day number of
465           output flavour that applies at that instant, throwing away
466           information about the time of (output-flavour) day.  If called in
467           list context, the function returns a list of two items: the day
468           number and fractional day of output flavour, which together
469           identify the same point in time as the input.
470
471           These functions are not recommended, because the context-sensitive
472           return convention makes their use error-prone.  They are retained
473           for backward compatibility.  You should prefer to use the more
474           specific functions shown above.
475
476       jdn_to_jd(JDN, JDF)
477       jdn_to_rjd(JDN, JDF)
478       jdn_to_mjd(JDN, JDF)
479       jdn_to_djd(JDN, JDF)
480       jdn_to_tjd(JDN, JDF)
481       jdn_to_cjd(JDN, JDF, ZONE)
482       jdn_to_rd(JDN, JDF, ZONE)
483       jdn_to_ld(JDN, JDF, ZONE)
484       rjdn_to_jd(RJDN, RJDF)
485       rjdn_to_rjd(RJDN, RJDF)
486       rjdn_to_mjd(RJDN, RJDF)
487       rjdn_to_djd(RJDN, RJDF)
488       rjdn_to_tjd(RJDN, RJDF)
489       rjdn_to_cjd(RJDN, RJDF, ZONE)
490       rjdn_to_rd(RJDN, RJDF, ZONE)
491       rjdn_to_ld(RJDN, RJDF, ZONE)
492       mjdn_to_jd(MJDN, MJDF)
493       mjdn_to_rjd(MJDN, MJDF)
494       mjdn_to_mjd(MJDN, MJDF)
495       mjdn_to_djd(MJDN, MJDF)
496       mjdn_to_tjd(MJDN, MJDF)
497       mjdn_to_cjd(MJDN, MJDF, ZONE)
498       mjdn_to_rd(MJDN, MJDF, ZONE)
499       mjdn_to_ld(MJDN, MJDF, ZONE)
500       djdn_to_jd(DJDN, DJDF)
501       djdn_to_rjd(DJDN, DJDF)
502       djdn_to_mjd(DJDN, DJDF)
503       djdn_to_djd(DJDN, DJDF)
504       djdn_to_tjd(DJDN, DJDF)
505       djdn_to_cjd(DJDN, DJDF, ZONE)
506       djdn_to_rd(DJDN, DJDF, ZONE)
507       djdn_to_ld(DJDN, DJDF, ZONE)
508       tjdn_to_jd(TJDN, TJDF)
509       tjdn_to_rjd(TJDN, TJDF)
510       tjdn_to_mjd(TJDN, TJDF)
511       tjdn_to_djd(TJDN, TJDF)
512       tjdn_to_tjd(TJDN, TJDF)
513       tjdn_to_cjd(TJDN, TJDF, ZONE)
514       tjdn_to_rd(TJDN, TJDF, ZONE)
515       tjdn_to_ld(TJDN, TJDF, ZONE)
516       cjdn_to_jd(CJDN, CJDF, ZONE)
517       cjdn_to_rjd(CJDN, CJDF, ZONE)
518       cjdn_to_mjd(CJDN, CJDF, ZONE)
519       cjdn_to_djd(CJDN, CJDF, ZONE)
520       cjdn_to_tjd(CJDN, CJDF, ZONE)
521       cjdn_to_cjd(CJDN, CJDF)
522       cjdn_to_rd(CJDN, CJDF)
523       cjdn_to_ld(CJDN, CJDF)
524       rdn_to_jd(RDN, RDF, ZONE)
525       rdn_to_rjd(RDN, RDF, ZONE)
526       rdn_to_mjd(RDN, RDF, ZONE)
527       rdn_to_djd(RDN, RDF, ZONE)
528       rdn_to_tjd(RDN, RDF, ZONE)
529       rdn_to_cjd(RDN, RDF)
530       rdn_to_rd(RDN, RDF)
531       rdn_to_ld(RDN, RDF)
532       ldn_to_jd(LDN, LDF, ZONE)
533       ldn_to_rjd(LDN, LDF, ZONE)
534       ldn_to_mjd(LDN, LDF, ZONE)
535       ldn_to_djd(LDN, LDF, ZONE)
536       ldn_to_tjd(LDN, LDF, ZONE)
537       ldn_to_cjd(LDN, LDF)
538       ldn_to_rd(LDN, LDF)
539       ldn_to_ld(LDN, LDF)
540           These functions convert from an integral day count with separate
541           fraction to a continuous day count.  The input identifies a point
542           in time, as an integral day number of input flavour plus day
543           fraction in the range [0, 1).  The function returns the same point
544           in time, represented as a continuous day count of output flavour.
545
546       jdn_to_jdnn(JDN[, JDF])
547       jdn_to_rjdnn(JDN[, JDF])
548       jdn_to_mjdnn(JDN, JDF)
549       jdn_to_djdnn(JDN[, JDF])
550       jdn_to_tjdnn(JDN, JDF)
551       jdn_to_cjdnn(JDN, JDF, ZONE)
552       jdn_to_rdnn(JDN, JDF, ZONE)
553       jdn_to_ldnn(JDN, JDF, ZONE)
554       rjdn_to_jdnn(RJDN[, RJDF])
555       rjdn_to_rjdnn(RJDN[, RJDF])
556       rjdn_to_mjdnn(RJDN, RJDF)
557       rjdn_to_djdnn(RJDN[, RJDF])
558       rjdn_to_tjdnn(RJDN, RJDF)
559       rjdn_to_cjdnn(RJDN, RJDF, ZONE)
560       rjdn_to_rdnn(RJDN, RJDF, ZONE)
561       rjdn_to_ldnn(RJDN, RJDF, ZONE)
562       mjdn_to_jdnn(MJDN, MJDF)
563       mjdn_to_rjdnn(MJDN, MJDF)
564       mjdn_to_mjdnn(MJDN[, MJDF])
565       mjdn_to_djdnn(MJDN, MJDF)
566       mjdn_to_tjdnn(MJDN[, MJDF])
567       mjdn_to_cjdnn(MJDN, MJDF, ZONE)
568       mjdn_to_rdnn(MJDN, MJDF, ZONE)
569       mjdn_to_ldnn(MJDN, MJDF, ZONE)
570       djdn_to_jdnn(DJDN[, DJDF])
571       djdn_to_rjdnn(DJDN[, DJDF])
572       djdn_to_mjdnn(DJDN, DJDF)
573       djdn_to_djdnn(DJDN[, DJDF])
574       djdn_to_tjdnn(DJDN, DJDF)
575       djdn_to_cjdnn(DJDN, DJDF, ZONE)
576       djdn_to_rdnn(DJDN, DJDF, ZONE)
577       djdn_to_ldnn(DJDN, DJDF, ZONE)
578       tjdn_to_jdnn(TJDN, TJDF)
579       tjdn_to_rjdnn(TJDN, TJDF)
580       tjdn_to_mjdnn(TJDN[, TJDF])
581       tjdn_to_djdnn(TJDN, TJDF)
582       tjdn_to_tjdnn(TJDN[, TJDF])
583       tjdn_to_cjdnn(TJDN, TJDF, ZONE)
584       tjdn_to_rdnn(TJDN, TJDF, ZONE)
585       tjdn_to_ldnn(TJDN, TJDF, ZONE)
586       cjdn_to_jdnn(CJDN, CJDF, ZONE)
587       cjdn_to_rjdnn(CJDN, CJDF, ZONE)
588       cjdn_to_mjdnn(CJDN, CJDF, ZONE)
589       cjdn_to_djdnn(CJDN, CJDF, ZONE)
590       cjdn_to_tjdnn(CJDN, CJDF, ZONE)
591       cjdn_to_cjdnn(CJDN[, CJDF])
592       cjdn_to_rdnn(CJDN[, CJDF])
593       cjdn_to_ldnn(CJDN[, CJDF])
594       rdn_to_jdnn(RDN, RDF, ZONE)
595       rdn_to_rjdnn(RDN, RDF, ZONE)
596       rdn_to_mjdnn(RDN, RDF, ZONE)
597       rdn_to_djdnn(RDN, RDF, ZONE)
598       rdn_to_tjdnn(RDN, RDF, ZONE)
599       rdn_to_cjdnn(RDN[, RDF])
600       rdn_to_rdnn(RDN[, RDF])
601       rdn_to_ldnn(RDN[, RDF])
602       ldn_to_jdnn(LDN, LDF, ZONE)
603       ldn_to_rjdnn(LDN, LDF, ZONE)
604       ldn_to_mjdnn(LDN, LDF, ZONE)
605       ldn_to_djdnn(LDN, LDF, ZONE)
606       ldn_to_tjdnn(LDN, LDF, ZONE)
607       ldn_to_cjdnn(LDN[, LDF])
608       ldn_to_rdnn(LDN[, LDF])
609       ldn_to_ldnn(LDN[, LDF])
610           These functions convert from an integral day count with separate
611           fraction to an integral day count.  The input identifies a point in
612           time, as an integral day number of input flavour plus day fraction
613           in the range [0, 1).  The function returns the day number of output
614           flavour that applies at that instant.  The process throws away
615           information about the time of (output-flavour) day.  If converting
616           between systems that delimit days identically (e.g., between JD and
617           RJD), the day fraction makes no difference and may be omitted from
618           the input.
619
620       jdn_to_jdnf(JDN, JDF)
621       jdn_to_rjdnf(JDN, JDF)
622       jdn_to_mjdnf(JDN, JDF)
623       jdn_to_djdnf(JDN, JDF)
624       jdn_to_tjdnf(JDN, JDF)
625       jdn_to_cjdnf(JDN, JDF, ZONE)
626       jdn_to_rdnf(JDN, JDF, ZONE)
627       jdn_to_ldnf(JDN, JDF, ZONE)
628       rjdn_to_jdnf(RJDN, RJDF)
629       rjdn_to_rjdnf(RJDN, RJDF)
630       rjdn_to_mjdnf(RJDN, RJDF)
631       rjdn_to_djdnf(RJDN, RJDF)
632       rjdn_to_tjdnf(RJDN, RJDF)
633       rjdn_to_cjdnf(RJDN, RJDF, ZONE)
634       rjdn_to_rdnf(RJDN, RJDF, ZONE)
635       rjdn_to_ldnf(RJDN, RJDF, ZONE)
636       mjdn_to_jdnf(MJDN, MJDF)
637       mjdn_to_rjdnf(MJDN, MJDF)
638       mjdn_to_mjdnf(MJDN, MJDF)
639       mjdn_to_djdnf(MJDN, MJDF)
640       mjdn_to_tjdnf(MJDN, MJDF)
641       mjdn_to_cjdnf(MJDN, MJDF, ZONE)
642       mjdn_to_rdnf(MJDN, MJDF, ZONE)
643       mjdn_to_ldnf(MJDN, MJDF, ZONE)
644       djdn_to_jdnf(DJDN, DJDF)
645       djdn_to_rjdnf(DJDN, DJDF)
646       djdn_to_mjdnf(DJDN, DJDF)
647       djdn_to_djdnf(DJDN, DJDF)
648       djdn_to_tjdnf(DJDN, DJDF)
649       djdn_to_cjdnf(DJDN, DJDF, ZONE)
650       djdn_to_rdnf(DJDN, DJDF, ZONE)
651       djdn_to_ldnf(DJDN, DJDF, ZONE)
652       tjdn_to_jdnf(TJDN, TJDF)
653       tjdn_to_rjdnf(TJDN, TJDF)
654       tjdn_to_mjdnf(TJDN, TJDF)
655       tjdn_to_djdnf(TJDN, TJDF)
656       tjdn_to_tjdnf(TJDN, TJDF)
657       tjdn_to_cjdnf(TJDN, TJDF, ZONE)
658       tjdn_to_rdnf(TJDN, TJDF, ZONE)
659       tjdn_to_ldnf(TJDN, TJDF, ZONE)
660       cjdn_to_jdnf(CJDN, CJDF, ZONE)
661       cjdn_to_rjdnf(CJDN, CJDF, ZONE)
662       cjdn_to_mjdnf(CJDN, CJDF, ZONE)
663       cjdn_to_djdnf(CJDN, CJDF, ZONE)
664       cjdn_to_tjdnf(CJDN, CJDF, ZONE)
665       cjdn_to_cjdnf(CJDN, CJDF)
666       cjdn_to_rdnf(CJDN, CJDF)
667       cjdn_to_ldnf(CJDN, CJDF)
668       rdn_to_jdnf(RDN, RDF, ZONE)
669       rdn_to_rjdnf(RDN, RDF, ZONE)
670       rdn_to_mjdnf(RDN, RDF, ZONE)
671       rdn_to_djdnf(RDN, RDF, ZONE)
672       rdn_to_tjdnf(RDN, RDF, ZONE)
673       rdn_to_cjdnf(RDN, RDF)
674       rdn_to_rdnf(RDN, RDF)
675       rdn_to_ldnf(RDN, RDF)
676       ldn_to_jdnf(LDN, LDF, ZONE)
677       ldn_to_rjdnf(LDN, LDF, ZONE)
678       ldn_to_mjdnf(LDN, LDF, ZONE)
679       ldn_to_djdnf(LDN, LDF, ZONE)
680       ldn_to_tjdnf(LDN, LDF, ZONE)
681       ldn_to_cjdnf(LDN, LDF)
682       ldn_to_rdnf(LDN, LDF)
683       ldn_to_ldnf(LDN, LDF)
684           These functions convert from one integral day count with separate
685           fraction to another.  The input identifies a point in time, as an
686           integral day number of input flavour plus day fraction in the range
687           [0, 1).  The function returns a list of two items: the day number
688           and fractional day of output flavour, which together identify the
689           same point in time as the input.
690
691       jdn_to_jdn(JDN[, JDF])
692       jdn_to_rjdn(JDN[, JDF])
693       jdn_to_mjdn(JDN, JDF)
694       jdn_to_djdn(JDN[, JDF])
695       jdn_to_tjdn(JDN, JDF)
696       jdn_to_cjdn(JDN, JDF, ZONE)
697       jdn_to_rdn(JDN, JDF, ZONE)
698       jdn_to_ldn(JDN, JDF, ZONE)
699       rjdn_to_jdn(RJDN[, RJDF])
700       rjdn_to_rjdn(RJDN[, RJDF])
701       rjdn_to_mjdn(RJDN, RJDF)
702       rjdn_to_djdn(RJDN[, RJDF])
703       rjdn_to_tjdn(RJDN, RJDF)
704       rjdn_to_cjdn(RJDN, RJDF, ZONE)
705       rjdn_to_rdn(RJDN, RJDF, ZONE)
706       rjdn_to_ldn(RJDN, RJDF, ZONE)
707       mjdn_to_jdn(MJDN, MJDF)
708       mjdn_to_rjdn(MJDN, MJDF)
709       mjdn_to_mjdn(MJDN[, MJDF])
710       mjdn_to_djdn(MJDN, MJDF)
711       mjdn_to_tjdn(MJDN[, MJDF])
712       mjdn_to_cjdn(MJDN, MJDF, ZONE)
713       mjdn_to_rdn(MJDN, MJDF, ZONE)
714       mjdn_to_ldn(MJDN, MJDF, ZONE)
715       djdn_to_jdn(DJDN[, DJDF])
716       djdn_to_rjdn(DJDN[, DJDF])
717       djdn_to_mjdn(DJDN, DJDF)
718       djdn_to_djdn(DJDN[, DJDF])
719       djdn_to_tjdn(DJDN, DJDF)
720       djdn_to_cjdn(DJDN, DJDF, ZONE)
721       djdn_to_rdn(DJDN, DJDF, ZONE)
722       djdn_to_ldn(DJDN, DJDF, ZONE)
723       tjdn_to_jdn(TJDN, TJDF)
724       tjdn_to_rjdn(TJDN, TJDF)
725       tjdn_to_mjdn(TJDN[, TJDF])
726       tjdn_to_djdn(TJDN, TJDF)
727       tjdn_to_tjdn(TJDN[, TJDF])
728       tjdn_to_cjdn(TJDN, TJDF, ZONE)
729       tjdn_to_rdn(TJDN, TJDF, ZONE)
730       tjdn_to_ldn(TJDN, TJDF, ZONE)
731       cjdn_to_jdn(CJDN, CJDF, ZONE)
732       cjdn_to_rjdn(CJDN, CJDF, ZONE)
733       cjdn_to_mjdn(CJDN, CJDF, ZONE)
734       cjdn_to_djdn(CJDN, CJDF, ZONE)
735       cjdn_to_tjdn(CJDN, CJDF, ZONE)
736       cjdn_to_cjdn(CJDN[, CJDF])
737       cjdn_to_rdn(CJDN[, CJDF])
738       cjdn_to_ldn(CJDN[, CJDF])
739       rdn_to_jdn(RDN, RDF, ZONE)
740       rdn_to_rjdn(RDN, RDF, ZONE)
741       rdn_to_mjdn(RDN, RDF, ZONE)
742       rdn_to_djdn(RDN, RDF, ZONE)
743       rdn_to_tjdn(RDN, RDF, ZONE)
744       rdn_to_cjdn(RDN[, RDF])
745       rdn_to_rdn(RDN[, RDF])
746       rdn_to_ldn(RDN[, RDF])
747       ldn_to_jdn(LDN, LDF, ZONE)
748       ldn_to_rjdn(LDN, LDF, ZONE)
749       ldn_to_mjdn(LDN, LDF, ZONE)
750       ldn_to_djdn(LDN, LDF, ZONE)
751       ldn_to_tjdn(LDN, LDF, ZONE)
752       ldn_to_cjdn(LDN[, LDF])
753       ldn_to_rdn(LDN[, LDF])
754       ldn_to_ldn(LDN[, LDF])
755           These functions convert from an integral day count with separate
756           fraction to an integral day count, possibly with separate fraction.
757           The input identifies a point in time, as an integral day number of
758           input flavour plus day fraction in the range [0, 1).  If called in
759           scalar context, the function returns the day number of output
760           flavour that applies at that instant, throwing away information
761           about the time of (output-flavour) day.  If called in list context,
762           the function returns a list of two items: the day number and
763           fractional day of output flavour, which together identify the same
764           point in time as the input.
765
766           If converting between systems that delimit days identically (e.g.,
767           between JD and RJD), the day fraction makes no difference to the
768           integral day number of the output, and may be omitted from the
769           input.  If the day fraction is extracted from the output when it
770           wasn't supplied as input, it will default to zero.
771
772           These functions are not recommended, because the context-sensitive
773           return convention makes their use error-prone.  They are retained
774           for backward compatibility.  You should prefer to use the more
775           specific functions shown above.
776

SEE ALSO

778       Date::ISO8601, Date::MSD, DateTime, Time::UTC
779

AUTHOR

781       Andrew Main (Zefram) <zefram@fysh.org>
782
784       Copyright (C) 2006, 2007, 2009, 2010, 2011 Andrew Main (Zefram)
785       <zefram@fysh.org>
786

LICENSE

788       This module is free software; you can redistribute it and/or modify it
789       under the same terms as Perl itself.
790
791
792
793perl v5.12.3                      2011-08-16                       Date::JD(3)
Impressum