Date::JD(3) User Contributed Perl Documentation Date::JD(3)NAMEDate::JD - conversion between flavours of Julian Date
SYNOPSIS
use Date::JD qw(jd_to_mjd mjd_to_cjdnf cjdn_to_rd);
$mjd = jd_to_mjd($jd);
($cjdn, $cjdf) = mjd_to_cjdnf($mjd, $tz);
$rd = cjdn_to_rd($cjdn, $cjdf);
# and 509 other conversion functions
DESCRIPTION
For date and time calculations it is convenient to represent dates by a
simple linear count of days, rather than in a particular calendar.
This is such a good idea that it has been invented several times. If
there were a single such linear count then it would be the obvious data
interchange format between calendar modules. With several versions,
calendar modules can use such sensible data formats and still have
interoperability problems. This module tackles that problem, by
performing conversions between different flavours of day count. These
day count systems are generically known as "Julian Dates", after the
most venerable of them.
Among Julian Date systems there are also some non-trivial differences
of concept. There are systems that count only complete days, and those
that count fractional days also. There are some that are fixed to
Universal Time (time on the prime meridian), and others that are
interpreted according to a timezone. Some consider the day to start at
noon and others at midnight, which is semantically significant for the
complete-day counts. The functions of this module appropriately handle
the semantics of all the non-trivial conversions.
The day count systems supported by this module are Julian Date, Reduced
Julian Date, Modified Julian Date, Dublin Julian Date, Truncated Julian
Date, Chronological Julian Date, Rata Die, and Lilian Date, each in
both integral and fractional forms.
Flavours of day count
In the interests of orthogonality, all flavours of day count come in
both integral and fractional varieties. Generally, there is a quantity
named "XYZD" ("XYZ Date") which is a real count of days since a
particular epoch (an integer plus a fraction) and a corresponding
quantity named "XYZDN" ("XYZ Day Number") which is a count of complete
days since the same epoch. XYZDN is the integral part of XYZD. There
is also a quantity named "XYZDF" ("XYZ Day Fraction") which is a count
of fractional days since the XYZDN changed (whether that is noon or
midnight). XYZDF is the fractional part of XYZD, in the range [0, 1).
This quantity naming pattern is derived from JD (Julian Date) and JDN
(Julian Day Number) which have the described correspondence. Most of
the other flavours of day count listed below conventionally come in
only one of the two varieties. The "XYZDF" name type is a neologism.
All calendar dates given are in ISO 8601 form (Gregorian calendar with
astronomical year numbering). An hour number is appended to each date,
separated by a "T"; hour 00 is midnight at the start of the day and
hour 12 is noon in the middle of the day. An appended "Z" indicates
that the date is to be interpreted in Universal Time (the timezone of
the prime meridian), and so is absolute; where any other timezone is to
be used then this is explicitly noted.
JD (Julian Date)
days elapsed since -4713-11-24T12Z. This epoch is the most recent
coincidence of the first year of the Metonic cycle, indiction
cycle, and day-of-week cycle, using the Julian calendar. It was
correspondingly named after the Julian calendar, and thus after
Julius Caesar. Some information can be found at
<http://en.wikipedia.org/wiki/Julian_day>.
RJD (Reduced Julian Date)
days elapsed since 1858-11-16T12Z (JD 2400000.0). Rarely used.
MJD (Modified Julian Date)
days elapsed since 1858-11-17T00Z (JD 2400000.5). This was
introduced by the Smithsonian Astrophysical Observatory in 1957,
and is recommended for general use by the International
Astronomical Union and other authorities.
DJD (Dublin Julian Date)
days elapsed since 1899-12-31T12Z (JD 2415020.0). This was
invented by the International Astronomical Union, and the epoch in
Terrestrial Time is the J1900.0 epoch used in astronomy. (Note:
not B1900.0, which is a few hours later.) It is rarely used.
TJD (Truncated Julian Date)
days elapsed since 1968-05-24T00Z (JD 2440000.5). This is
primarily used by NASA, who devised it during the Apollo era.
There is a rumour that it's defined cyclically, as (JD - 0.5) mod
10000, but see
<http://cossc.gsfc.nasa.gov/cossc/batse/hilev/TJD.TABLE>.
CJD (Chronological Julian Date)
days elapsed since -4713-11-24T00 in the timezone of interest. CJD
= JD + 0.5 + Zoff, where Zoff is the timezone offset in fractional
days. This was devised by Peter Meyer, and described in
<http://www.hermetic.ch/cal_stud/cjd.htm>.
RD (Rata Die)
days elapsed since 0000-12-31T00 in the timezone of interest (CJD
1721425.0). This is defined in the book Calendrical Calculations.
Confusingly, in the book the integral form is also called "RD".
The integral form is called "RDN" by this module to avoid
confusion, reserving the name "RD" for the fractional form. (The
book is best treated with caution due to the embarrassingly large
number of errors and instances of muddled thinking.)
LD (Lilian Date)
days elapsed since 1582-10-14T00 in the timezone of interest (CJD
2299160.0). This epoch is the day before the day that the
Gregorian calendar first went into use. It is named after Aloysius
Lilius, the inventor of the Gregorian calendar.
The interesting differences between these flavours are whether the day
starts at noon or at midnight, and whether they are absolute or
timezone-relative. Three of the four combinations of these features
exist. There is no convention for counting days from timezone-relative
noon that the author of this module is aware of.
For more background on these day count systems,
<http://en.wikipedia.org/wiki/Julian_Date> is a good starting place.
Meaning of the day
A day count has meaning only in the context of a particular definition
of "day". There are two main flavours of day to consider: solar and
conventional.
A solar day is based on the apparent motion of Sol in the Terran sky
(and thus on the rotation and orbit of Terra). The rotation of Terra
is not constant in time, so this type of day is really a measure of
angle, not of time. This is how days have been counted since
antiquity, and is still (as of 2006) the basis of civil time. There
are two subtypes of solar day: apparent and mean. The apparent solar
day is based on the actual observable position of Sol in the sky from
day to day, whereas the mean solar day smooths this motion out, in
time, over the course of the year. At the sub-second level there are
different types of smoothing that can be used (UT1, UT2, et al).
A conventional day is any type of day that is not based on Terran
rotation. The astronomical Ephemeris Time, a time scale based on the
motion of bodies in the Solar system, has a time unit that it calls
"day" which is derived from astronomical observations. The modern
relativistic coordinate time scales such as TT have a notional "day" of
exactly 86400 SI seconds. The atomic time scale TAI also has a "day"
which is as close to 86400 SI seconds as can be achieved. All of these
"days" are roughly the duration of one Sol-relative rotation of Terra
during the early nineteenth century, but are not otherwise related to
planetary rotation.
Each of the day count scales handled by this module can be used with
any of these types of day. For a day number to be meaningful it is
necessary to be aware of which kind of day it is counting. Conversion
between the different types of day is out of scope for this module.
(See Time::UTC for TAI/UTC conversion.)
FUNCTIONS
Day counts in this API may be native Perl numbers or "Math::BigRat"
objects. Both are acceptable for all parameters, in any combination.
In all conversion functions, the result is of the same type as the
input, provided that the inputs are of consistent type. If native Perl
numbers are supplied then the conversion is subject to floating point
rounding, and possible overflow if the numbers are extremely large.
The use of "Math::BigRat" is recommended to avoid these problems. With
"Math::BigRat" the results are exact.
There are conversion functions between all pairs of day count systems.
This is a total of 512 conversion functions (including 32 identity
functions).
When converting between timezone-relative counts (CJD, RD, LD) and
absolute counts (JD, RJD, MJD, DJD, TJD), the timezone that is being
used must be specified. It is given in a ZONE argument as a fractional
number of days offset from Universal Time. For example, US Central
Standard Time, 6 hours behind UT, would be specified as a ZONE argument
of -0.25. Beware of floating point rounding when the offset does not
have a terminating binary representation (e.g., US Eastern Standard
Time at -5/24); use of "Math::BigRat" avoids this problem. A ZONE
parameter is not used when converting between absolute day counts
(e.g., between JD and MJD) or between timezone-relative counts (e.g.,
between CJD and LD).
jd_to_jd(JD)jd_to_rjd(JD)jd_to_mjd(JD)jd_to_djd(JD)jd_to_tjd(JD)
jd_to_cjd(JD, ZONE)
jd_to_rd(JD, ZONE)
jd_to_ld(JD, ZONE)
rjd_to_jd(RJD)rjd_to_rjd(RJD)rjd_to_mjd(RJD)rjd_to_djd(RJD)rjd_to_tjd(RJD)
rjd_to_cjd(RJD, ZONE)
rjd_to_rd(RJD, ZONE)
rjd_to_ld(RJD, ZONE)
mjd_to_jd(MJD)mjd_to_rjd(MJD)mjd_to_mjd(MJD)mjd_to_djd(MJD)mjd_to_tjd(MJD)
mjd_to_cjd(MJD, ZONE)
mjd_to_rd(MJD, ZONE)
mjd_to_ld(MJD, ZONE)
djd_to_jd(DJD)djd_to_rjd(DJD)djd_to_mjd(DJD)djd_to_djd(DJD)djd_to_tjd(DJD)
djd_to_cjd(DJD, ZONE)
djd_to_rd(DJD, ZONE)
djd_to_ld(DJD, ZONE)
tjd_to_jd(TJD)tjd_to_rjd(TJD)tjd_to_mjd(TJD)tjd_to_djd(TJD)tjd_to_tjd(TJD)
tjd_to_cjd(TJD, ZONE)
tjd_to_rd(TJD, ZONE)
tjd_to_ld(TJD, ZONE)
cjd_to_jd(CJD, ZONE)
cjd_to_rjd(CJD, ZONE)
cjd_to_mjd(CJD, ZONE)
cjd_to_djd(CJD, ZONE)
cjd_to_tjd(CJD, ZONE)
cjd_to_cjd(CJD)cjd_to_rd(CJD)cjd_to_ld(CJD)
rd_to_jd(RD, ZONE)
rd_to_rjd(RD, ZONE)
rd_to_mjd(RD, ZONE)
rd_to_djd(RD, ZONE)
rd_to_tjd(RD, ZONE)
rd_to_cjd(RD)rd_to_rd(RD)rd_to_ld(RD)
ld_to_jd(LD, ZONE)
ld_to_rjd(LD, ZONE)
ld_to_mjd(LD, ZONE)
ld_to_djd(LD, ZONE)
ld_to_tjd(LD, ZONE)
ld_to_cjd(LD)ld_to_rd(LD)ld_to_ld(LD)
These functions convert from one continuous day count to another.
This principally involve a change of epoch. The input identifies a
point in time, as a continuous day count of input flavour. The
function returns the same point in time, represented as a
continuous day count of output flavour.
jd_to_jdnn(JD)jd_to_rjdnn(JD)jd_to_mjdnn(JD)jd_to_djdnn(JD)jd_to_tjdnn(JD)
jd_to_cjdnn(JD, ZONE)
jd_to_rdnn(JD, ZONE)
jd_to_ldnn(JD, ZONE)
rjd_to_jdnn(RJD)rjd_to_rjdnn(RJD)rjd_to_mjdnn(RJD)rjd_to_djdnn(RJD)rjd_to_tjdnn(RJD)
rjd_to_cjdnn(RJD, ZONE)
rjd_to_rdnn(RJD, ZONE)
rjd_to_ldnn(RJD, ZONE)
mjd_to_jdnn(MJD)mjd_to_rjdnn(MJD)mjd_to_mjdnn(MJD)mjd_to_djdnn(MJD)mjd_to_tjdnn(MJD)
mjd_to_cjdnn(MJD, ZONE)
mjd_to_rdnn(MJD, ZONE)
mjd_to_ldnn(MJD, ZONE)
djd_to_jdnn(DJD)djd_to_rjdnn(DJD)djd_to_mjdnn(DJD)djd_to_djdnn(DJD)djd_to_tjdnn(DJD)
djd_to_cjdnn(DJD, ZONE)
djd_to_rdnn(DJD, ZONE)
djd_to_ldnn(DJD, ZONE)
tjd_to_jdnn(TJD)tjd_to_rjdnn(TJD)tjd_to_mjdnn(TJD)tjd_to_djdnn(TJD)tjd_to_tjdnn(TJD)
tjd_to_cjdnn(TJD, ZONE)
tjd_to_rdnn(TJD, ZONE)
tjd_to_ldnn(TJD, ZONE)
cjd_to_jdnn(CJD, ZONE)
cjd_to_rjdnn(CJD, ZONE)
cjd_to_mjdnn(CJD, ZONE)
cjd_to_djdnn(CJD, ZONE)
cjd_to_tjdnn(CJD, ZONE)
cjd_to_cjdnn(CJD)cjd_to_rdnn(CJD)cjd_to_ldnn(CJD)
rd_to_jdnn(RD, ZONE)
rd_to_rjdnn(RD, ZONE)
rd_to_mjdnn(RD, ZONE)
rd_to_djdnn(RD, ZONE)
rd_to_tjdnn(RD, ZONE)
rd_to_cjdnn(RD)rd_to_rdnn(RD)rd_to_ldnn(RD)
ld_to_jdnn(LD, ZONE)
ld_to_rjdnn(LD, ZONE)
ld_to_mjdnn(LD, ZONE)
ld_to_djdnn(LD, ZONE)
ld_to_tjdnn(LD, ZONE)
ld_to_cjdnn(LD)ld_to_rdnn(LD)ld_to_ldnn(LD)
These functions convert from a continuous day count to an integral
day count. The input identifies a point in time, as a continuous
day count of input flavour. The function returns the day number of
output flavour that applies at that instant. The process throws
away information about the time of (output-flavour) day.
jd_to_jdnf(JD)jd_to_rjdnf(JD)jd_to_mjdnf(JD)jd_to_djdnf(JD)jd_to_tjdnf(JD)
jd_to_cjdnf(JD, ZONE)
jd_to_rdnf(JD, ZONE)
jd_to_ldnf(JD, ZONE)
rjd_to_jdnf(RJD)rjd_to_rjdnf(RJD)rjd_to_mjdnf(RJD)rjd_to_djdnf(RJD)rjd_to_tjdnf(RJD)
rjd_to_cjdnf(RJD, ZONE)
rjd_to_rdnf(RJD, ZONE)
rjd_to_ldnf(RJD, ZONE)
mjd_to_jdnf(MJD)mjd_to_rjdnf(MJD)mjd_to_mjdnf(MJD)mjd_to_djdnf(MJD)mjd_to_tjdnf(MJD)
mjd_to_cjdnf(MJD, ZONE)
mjd_to_rdnf(MJD, ZONE)
mjd_to_ldnf(MJD, ZONE)
djd_to_jdnf(DJD)djd_to_rjdnf(DJD)djd_to_mjdnf(DJD)djd_to_djdnf(DJD)djd_to_tjdnf(DJD)
djd_to_cjdnf(DJD, ZONE)
djd_to_rdnf(DJD, ZONE)
djd_to_ldnf(DJD, ZONE)
tjd_to_jdnf(TJD)tjd_to_rjdnf(TJD)tjd_to_mjdnf(TJD)tjd_to_djdnf(TJD)tjd_to_tjdnf(TJD)
tjd_to_cjdnf(TJD, ZONE)
tjd_to_rdnf(TJD, ZONE)
tjd_to_ldnf(TJD, ZONE)
cjd_to_jdnf(CJD, ZONE)
cjd_to_rjdnf(CJD, ZONE)
cjd_to_mjdnf(CJD, ZONE)
cjd_to_djdnf(CJD, ZONE)
cjd_to_tjdnf(CJD, ZONE)
cjd_to_cjdnf(CJD)cjd_to_rdnf(CJD)cjd_to_ldnf(CJD)
rd_to_jdnf(RD, ZONE)
rd_to_rjdnf(RD, ZONE)
rd_to_mjdnf(RD, ZONE)
rd_to_djdnf(RD, ZONE)
rd_to_tjdnf(RD, ZONE)
rd_to_cjdnf(RD)rd_to_rdnf(RD)rd_to_ldnf(RD)
ld_to_jdnf(LD, ZONE)
ld_to_rjdnf(LD, ZONE)
ld_to_mjdnf(LD, ZONE)
ld_to_djdnf(LD, ZONE)
ld_to_tjdnf(LD, ZONE)
ld_to_cjdnf(LD)ld_to_rdnf(LD)ld_to_ldnf(LD)
These functions convert from a continuous day count to an integral
day count with separate fraction. The input identifies a point in
time, as a continuous day count of input flavour. The function
returns a list of two items: the day number and fractional day of
output flavour, which together identify the same point in time as
the input.
jd_to_jdn(JD)jd_to_rjdn(JD)jd_to_mjdn(JD)jd_to_djdn(JD)jd_to_tjdn(JD)
jd_to_cjdn(JD, ZONE)
jd_to_rdn(JD, ZONE)
jd_to_ldn(JD, ZONE)
rjd_to_jdn(RJD)rjd_to_rjdn(RJD)rjd_to_mjdn(RJD)rjd_to_djdn(RJD)rjd_to_tjdn(RJD)
rjd_to_cjdn(RJD, ZONE)
rjd_to_rdn(RJD, ZONE)
rjd_to_ldn(RJD, ZONE)
mjd_to_jdn(MJD)mjd_to_rjdn(MJD)mjd_to_mjdn(MJD)mjd_to_djdn(MJD)mjd_to_tjdn(MJD)
mjd_to_cjdn(MJD, ZONE)
mjd_to_rdn(MJD, ZONE)
mjd_to_ldn(MJD, ZONE)
djd_to_jdn(DJD)djd_to_rjdn(DJD)djd_to_mjdn(DJD)djd_to_djdn(DJD)djd_to_tjdn(DJD)
djd_to_cjdn(DJD, ZONE)
djd_to_rdn(DJD, ZONE)
djd_to_ldn(DJD, ZONE)
tjd_to_jdn(TJD)tjd_to_rjdn(TJD)tjd_to_mjdn(TJD)tjd_to_djdn(TJD)tjd_to_tjdn(TJD)
tjd_to_cjdn(TJD, ZONE)
tjd_to_rdn(TJD, ZONE)
tjd_to_ldn(TJD, ZONE)
cjd_to_jdn(CJD, ZONE)
cjd_to_rjdn(CJD, ZONE)
cjd_to_mjdn(CJD, ZONE)
cjd_to_djdn(CJD, ZONE)
cjd_to_tjdn(CJD, ZONE)
cjd_to_cjdn(CJD)cjd_to_rdn(CJD)cjd_to_ldn(CJD)
rd_to_jdn(RD, ZONE)
rd_to_rjdn(RD, ZONE)
rd_to_mjdn(RD, ZONE)
rd_to_djdn(RD, ZONE)
rd_to_tjdn(RD, ZONE)
rd_to_cjdn(RD)rd_to_rdn(RD)rd_to_ldn(RD)
ld_to_jdn(LD, ZONE)
ld_to_rjdn(LD, ZONE)
ld_to_mjdn(LD, ZONE)
ld_to_djdn(LD, ZONE)
ld_to_tjdn(LD, ZONE)
ld_to_cjdn(LD)ld_to_rdn(LD)ld_to_ldn(LD)
These functions convert from a continuous day count to an integral
day count, possibly with separate fraction. The input identifies a
point in time, as a continuous day count of input flavour. If
called in scalar context, the function returns the day number of
output flavour that applies at that instant, throwing away
information about the time of (output-flavour) day. If called in
list context, the function returns a list of two items: the day
number and fractional day of output flavour, which together
identify the same point in time as the input.
These functions are not recommended, because the context-sensitive
return convention makes their use error-prone. They are retained
for backward compatibility. You should prefer to use the more
specific functions shown above.
jdn_to_jd(JDN, JDF)
jdn_to_rjd(JDN, JDF)
jdn_to_mjd(JDN, JDF)
jdn_to_djd(JDN, JDF)
jdn_to_tjd(JDN, JDF)
jdn_to_cjd(JDN, JDF, ZONE)
jdn_to_rd(JDN, JDF, ZONE)
jdn_to_ld(JDN, JDF, ZONE)
rjdn_to_jd(RJDN, RJDF)
rjdn_to_rjd(RJDN, RJDF)
rjdn_to_mjd(RJDN, RJDF)
rjdn_to_djd(RJDN, RJDF)
rjdn_to_tjd(RJDN, RJDF)
rjdn_to_cjd(RJDN, RJDF, ZONE)
rjdn_to_rd(RJDN, RJDF, ZONE)
rjdn_to_ld(RJDN, RJDF, ZONE)
mjdn_to_jd(MJDN, MJDF)
mjdn_to_rjd(MJDN, MJDF)
mjdn_to_mjd(MJDN, MJDF)
mjdn_to_djd(MJDN, MJDF)
mjdn_to_tjd(MJDN, MJDF)
mjdn_to_cjd(MJDN, MJDF, ZONE)
mjdn_to_rd(MJDN, MJDF, ZONE)
mjdn_to_ld(MJDN, MJDF, ZONE)
djdn_to_jd(DJDN, DJDF)
djdn_to_rjd(DJDN, DJDF)
djdn_to_mjd(DJDN, DJDF)
djdn_to_djd(DJDN, DJDF)
djdn_to_tjd(DJDN, DJDF)
djdn_to_cjd(DJDN, DJDF, ZONE)
djdn_to_rd(DJDN, DJDF, ZONE)
djdn_to_ld(DJDN, DJDF, ZONE)
tjdn_to_jd(TJDN, TJDF)
tjdn_to_rjd(TJDN, TJDF)
tjdn_to_mjd(TJDN, TJDF)
tjdn_to_djd(TJDN, TJDF)
tjdn_to_tjd(TJDN, TJDF)
tjdn_to_cjd(TJDN, TJDF, ZONE)
tjdn_to_rd(TJDN, TJDF, ZONE)
tjdn_to_ld(TJDN, TJDF, ZONE)
cjdn_to_jd(CJDN, CJDF, ZONE)
cjdn_to_rjd(CJDN, CJDF, ZONE)
cjdn_to_mjd(CJDN, CJDF, ZONE)
cjdn_to_djd(CJDN, CJDF, ZONE)
cjdn_to_tjd(CJDN, CJDF, ZONE)
cjdn_to_cjd(CJDN, CJDF)
cjdn_to_rd(CJDN, CJDF)
cjdn_to_ld(CJDN, CJDF)
rdn_to_jd(RDN, RDF, ZONE)
rdn_to_rjd(RDN, RDF, ZONE)
rdn_to_mjd(RDN, RDF, ZONE)
rdn_to_djd(RDN, RDF, ZONE)
rdn_to_tjd(RDN, RDF, ZONE)
rdn_to_cjd(RDN, RDF)
rdn_to_rd(RDN, RDF)
rdn_to_ld(RDN, RDF)
ldn_to_jd(LDN, LDF, ZONE)
ldn_to_rjd(LDN, LDF, ZONE)
ldn_to_mjd(LDN, LDF, ZONE)
ldn_to_djd(LDN, LDF, ZONE)
ldn_to_tjd(LDN, LDF, ZONE)
ldn_to_cjd(LDN, LDF)
ldn_to_rd(LDN, LDF)
ldn_to_ld(LDN, LDF)
These functions convert from an integral day count with separate
fraction to a continuous day count. The input identifies a point
in time, as an integral day number of input flavour plus day
fraction in the range [0, 1). The function returns the same point
in time, represented as a continuous day count of output flavour.
jdn_to_jdnn(JDN[, JDF])
jdn_to_rjdnn(JDN[, JDF])
jdn_to_mjdnn(JDN, JDF)
jdn_to_djdnn(JDN[, JDF])
jdn_to_tjdnn(JDN, JDF)
jdn_to_cjdnn(JDN, JDF, ZONE)
jdn_to_rdnn(JDN, JDF, ZONE)
jdn_to_ldnn(JDN, JDF, ZONE)
rjdn_to_jdnn(RJDN[, RJDF])
rjdn_to_rjdnn(RJDN[, RJDF])
rjdn_to_mjdnn(RJDN, RJDF)
rjdn_to_djdnn(RJDN[, RJDF])
rjdn_to_tjdnn(RJDN, RJDF)
rjdn_to_cjdnn(RJDN, RJDF, ZONE)
rjdn_to_rdnn(RJDN, RJDF, ZONE)
rjdn_to_ldnn(RJDN, RJDF, ZONE)
mjdn_to_jdnn(MJDN, MJDF)
mjdn_to_rjdnn(MJDN, MJDF)
mjdn_to_mjdnn(MJDN[, MJDF])
mjdn_to_djdnn(MJDN, MJDF)
mjdn_to_tjdnn(MJDN[, MJDF])
mjdn_to_cjdnn(MJDN, MJDF, ZONE)
mjdn_to_rdnn(MJDN, MJDF, ZONE)
mjdn_to_ldnn(MJDN, MJDF, ZONE)
djdn_to_jdnn(DJDN[, DJDF])
djdn_to_rjdnn(DJDN[, DJDF])
djdn_to_mjdnn(DJDN, DJDF)
djdn_to_djdnn(DJDN[, DJDF])
djdn_to_tjdnn(DJDN, DJDF)
djdn_to_cjdnn(DJDN, DJDF, ZONE)
djdn_to_rdnn(DJDN, DJDF, ZONE)
djdn_to_ldnn(DJDN, DJDF, ZONE)
tjdn_to_jdnn(TJDN, TJDF)
tjdn_to_rjdnn(TJDN, TJDF)
tjdn_to_mjdnn(TJDN[, TJDF])
tjdn_to_djdnn(TJDN, TJDF)
tjdn_to_tjdnn(TJDN[, TJDF])
tjdn_to_cjdnn(TJDN, TJDF, ZONE)
tjdn_to_rdnn(TJDN, TJDF, ZONE)
tjdn_to_ldnn(TJDN, TJDF, ZONE)
cjdn_to_jdnn(CJDN, CJDF, ZONE)
cjdn_to_rjdnn(CJDN, CJDF, ZONE)
cjdn_to_mjdnn(CJDN, CJDF, ZONE)
cjdn_to_djdnn(CJDN, CJDF, ZONE)
cjdn_to_tjdnn(CJDN, CJDF, ZONE)
cjdn_to_cjdnn(CJDN[, CJDF])
cjdn_to_rdnn(CJDN[, CJDF])
cjdn_to_ldnn(CJDN[, CJDF])
rdn_to_jdnn(RDN, RDF, ZONE)
rdn_to_rjdnn(RDN, RDF, ZONE)
rdn_to_mjdnn(RDN, RDF, ZONE)
rdn_to_djdnn(RDN, RDF, ZONE)
rdn_to_tjdnn(RDN, RDF, ZONE)
rdn_to_cjdnn(RDN[, RDF])
rdn_to_rdnn(RDN[, RDF])
rdn_to_ldnn(RDN[, RDF])
ldn_to_jdnn(LDN, LDF, ZONE)
ldn_to_rjdnn(LDN, LDF, ZONE)
ldn_to_mjdnn(LDN, LDF, ZONE)
ldn_to_djdnn(LDN, LDF, ZONE)
ldn_to_tjdnn(LDN, LDF, ZONE)
ldn_to_cjdnn(LDN[, LDF])
ldn_to_rdnn(LDN[, LDF])
ldn_to_ldnn(LDN[, LDF])
These functions convert from an integral day count with separate
fraction to an integral day count. The input identifies a point in
time, as an integral day number of input flavour plus day fraction
in the range [0, 1). The function returns the day number of output
flavour that applies at that instant. The process throws away
information about the time of (output-flavour) day. If converting
between systems that delimit days identically (e.g., between JD and
RJD), the day fraction makes no difference and may be omitted from
the input.
jdn_to_jdnf(JDN, JDF)
jdn_to_rjdnf(JDN, JDF)
jdn_to_mjdnf(JDN, JDF)
jdn_to_djdnf(JDN, JDF)
jdn_to_tjdnf(JDN, JDF)
jdn_to_cjdnf(JDN, JDF, ZONE)
jdn_to_rdnf(JDN, JDF, ZONE)
jdn_to_ldnf(JDN, JDF, ZONE)
rjdn_to_jdnf(RJDN, RJDF)
rjdn_to_rjdnf(RJDN, RJDF)
rjdn_to_mjdnf(RJDN, RJDF)
rjdn_to_djdnf(RJDN, RJDF)
rjdn_to_tjdnf(RJDN, RJDF)
rjdn_to_cjdnf(RJDN, RJDF, ZONE)
rjdn_to_rdnf(RJDN, RJDF, ZONE)
rjdn_to_ldnf(RJDN, RJDF, ZONE)
mjdn_to_jdnf(MJDN, MJDF)
mjdn_to_rjdnf(MJDN, MJDF)
mjdn_to_mjdnf(MJDN, MJDF)
mjdn_to_djdnf(MJDN, MJDF)
mjdn_to_tjdnf(MJDN, MJDF)
mjdn_to_cjdnf(MJDN, MJDF, ZONE)
mjdn_to_rdnf(MJDN, MJDF, ZONE)
mjdn_to_ldnf(MJDN, MJDF, ZONE)
djdn_to_jdnf(DJDN, DJDF)
djdn_to_rjdnf(DJDN, DJDF)
djdn_to_mjdnf(DJDN, DJDF)
djdn_to_djdnf(DJDN, DJDF)
djdn_to_tjdnf(DJDN, DJDF)
djdn_to_cjdnf(DJDN, DJDF, ZONE)
djdn_to_rdnf(DJDN, DJDF, ZONE)
djdn_to_ldnf(DJDN, DJDF, ZONE)
tjdn_to_jdnf(TJDN, TJDF)
tjdn_to_rjdnf(TJDN, TJDF)
tjdn_to_mjdnf(TJDN, TJDF)
tjdn_to_djdnf(TJDN, TJDF)
tjdn_to_tjdnf(TJDN, TJDF)
tjdn_to_cjdnf(TJDN, TJDF, ZONE)
tjdn_to_rdnf(TJDN, TJDF, ZONE)
tjdn_to_ldnf(TJDN, TJDF, ZONE)
cjdn_to_jdnf(CJDN, CJDF, ZONE)
cjdn_to_rjdnf(CJDN, CJDF, ZONE)
cjdn_to_mjdnf(CJDN, CJDF, ZONE)
cjdn_to_djdnf(CJDN, CJDF, ZONE)
cjdn_to_tjdnf(CJDN, CJDF, ZONE)
cjdn_to_cjdnf(CJDN, CJDF)
cjdn_to_rdnf(CJDN, CJDF)
cjdn_to_ldnf(CJDN, CJDF)
rdn_to_jdnf(RDN, RDF, ZONE)
rdn_to_rjdnf(RDN, RDF, ZONE)
rdn_to_mjdnf(RDN, RDF, ZONE)
rdn_to_djdnf(RDN, RDF, ZONE)
rdn_to_tjdnf(RDN, RDF, ZONE)
rdn_to_cjdnf(RDN, RDF)
rdn_to_rdnf(RDN, RDF)
rdn_to_ldnf(RDN, RDF)
ldn_to_jdnf(LDN, LDF, ZONE)
ldn_to_rjdnf(LDN, LDF, ZONE)
ldn_to_mjdnf(LDN, LDF, ZONE)
ldn_to_djdnf(LDN, LDF, ZONE)
ldn_to_tjdnf(LDN, LDF, ZONE)
ldn_to_cjdnf(LDN, LDF)
ldn_to_rdnf(LDN, LDF)
ldn_to_ldnf(LDN, LDF)
These functions convert from one integral day count with separate
fraction to another. The input identifies a point in time, as an
integral day number of input flavour plus day fraction in the range
[0, 1). The function returns a list of two items: the day number
and fractional day of output flavour, which together identify the
same point in time as the input.
jdn_to_jdn(JDN[, JDF])
jdn_to_rjdn(JDN[, JDF])
jdn_to_mjdn(JDN, JDF)
jdn_to_djdn(JDN[, JDF])
jdn_to_tjdn(JDN, JDF)
jdn_to_cjdn(JDN, JDF, ZONE)
jdn_to_rdn(JDN, JDF, ZONE)
jdn_to_ldn(JDN, JDF, ZONE)
rjdn_to_jdn(RJDN[, RJDF])
rjdn_to_rjdn(RJDN[, RJDF])
rjdn_to_mjdn(RJDN, RJDF)
rjdn_to_djdn(RJDN[, RJDF])
rjdn_to_tjdn(RJDN, RJDF)
rjdn_to_cjdn(RJDN, RJDF, ZONE)
rjdn_to_rdn(RJDN, RJDF, ZONE)
rjdn_to_ldn(RJDN, RJDF, ZONE)
mjdn_to_jdn(MJDN, MJDF)
mjdn_to_rjdn(MJDN, MJDF)
mjdn_to_mjdn(MJDN[, MJDF])
mjdn_to_djdn(MJDN, MJDF)
mjdn_to_tjdn(MJDN[, MJDF])
mjdn_to_cjdn(MJDN, MJDF, ZONE)
mjdn_to_rdn(MJDN, MJDF, ZONE)
mjdn_to_ldn(MJDN, MJDF, ZONE)
djdn_to_jdn(DJDN[, DJDF])
djdn_to_rjdn(DJDN[, DJDF])
djdn_to_mjdn(DJDN, DJDF)
djdn_to_djdn(DJDN[, DJDF])
djdn_to_tjdn(DJDN, DJDF)
djdn_to_cjdn(DJDN, DJDF, ZONE)
djdn_to_rdn(DJDN, DJDF, ZONE)
djdn_to_ldn(DJDN, DJDF, ZONE)
tjdn_to_jdn(TJDN, TJDF)
tjdn_to_rjdn(TJDN, TJDF)
tjdn_to_mjdn(TJDN[, TJDF])
tjdn_to_djdn(TJDN, TJDF)
tjdn_to_tjdn(TJDN[, TJDF])
tjdn_to_cjdn(TJDN, TJDF, ZONE)
tjdn_to_rdn(TJDN, TJDF, ZONE)
tjdn_to_ldn(TJDN, TJDF, ZONE)
cjdn_to_jdn(CJDN, CJDF, ZONE)
cjdn_to_rjdn(CJDN, CJDF, ZONE)
cjdn_to_mjdn(CJDN, CJDF, ZONE)
cjdn_to_djdn(CJDN, CJDF, ZONE)
cjdn_to_tjdn(CJDN, CJDF, ZONE)
cjdn_to_cjdn(CJDN[, CJDF])
cjdn_to_rdn(CJDN[, CJDF])
cjdn_to_ldn(CJDN[, CJDF])
rdn_to_jdn(RDN, RDF, ZONE)
rdn_to_rjdn(RDN, RDF, ZONE)
rdn_to_mjdn(RDN, RDF, ZONE)
rdn_to_djdn(RDN, RDF, ZONE)
rdn_to_tjdn(RDN, RDF, ZONE)
rdn_to_cjdn(RDN[, RDF])
rdn_to_rdn(RDN[, RDF])
rdn_to_ldn(RDN[, RDF])
ldn_to_jdn(LDN, LDF, ZONE)
ldn_to_rjdn(LDN, LDF, ZONE)
ldn_to_mjdn(LDN, LDF, ZONE)
ldn_to_djdn(LDN, LDF, ZONE)
ldn_to_tjdn(LDN, LDF, ZONE)
ldn_to_cjdn(LDN[, LDF])
ldn_to_rdn(LDN[, LDF])
ldn_to_ldn(LDN[, LDF])
These functions convert from an integral day count with separate
fraction to an integral day count, possibly with separate fraction.
The input identifies a point in time, as an integral day number of
input flavour plus day fraction in the range [0, 1). If called in
scalar context, the function returns the day number of output
flavour that applies at that instant, throwing away information
about the time of (output-flavour) day. If called in list context,
the function returns a list of two items: the day number and
fractional day of output flavour, which together identify the same
point in time as the input.
If converting between systems that delimit days identically (e.g.,
between JD and RJD), the day fraction makes no difference to the
integral day number of the output, and may be omitted from the
input. If the day fraction is extracted from the output when it
wasn't supplied as input, it will default to zero.
These functions are not recommended, because the context-sensitive
return convention makes their use error-prone. They are retained
for backward compatibility. You should prefer to use the more
specific functions shown above.
SEE ALSO
Date::ISO8601, Date::MSD, DateTime, Time::UTC
AUTHOR
Andrew Main (Zefram) <zefram@fysh.org>
COPYRIGHT
Copyright (C) 2006, 2007, 2009, 2010, 2011 Andrew Main (Zefram)
<zefram@fysh.org>
LICENSE
This module is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.
perl v5.14.1 2011-08-16 Date::JD(3)
