1Date::JD(3) User Contributed Perl Documentation Date::JD(3)
2
6 Date::JD - conversion between flavours of Julian Date
7
9 use Date::JD qw(jd_to_mjd mjd_to_cjdnf cjdn_to_rd);
10 $mjd = jd_to_mjd($jd);
12 ($cjdn, $cjdf) = mjd_to_cjdnf($mjd, $tz);
13 $rd = cjdn_to_rd($cjdn, $cjdf);
14 # and 509 other conversion functions
16
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 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 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 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 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 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 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 RJD (Reduced Julian Date)
76 days elapsed since 1858-11-16T12Z (JD 2400000.0). Rarely used.
77 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 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 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 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 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 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 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 For more background on these day count systems,
125 <http://en.wikipedia.org/wiki/Julian_Date> is a good starting place.
126 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 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 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 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
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 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 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 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 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 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 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 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 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 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 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 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 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 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
778 Date::ISO8601, Date::MSD, DateTime, Time::UTC
779
781 Andrew Main (Zefram) <zefram@fysh.org>
782
784 Copyright (C) 2006, 2007, 2009, 2010, 2011 Andrew Main (Zefram)
785 <zefram@fysh.org>
786
788 This module is free software; you can redistribute it and/or modify it
789 under the same terms as Perl itself.
790perl v5.12.3 2011-08-16 Date::JD(3)