(calc.info)Date Forms

---

Next: Modulo Forms Prev: HMS Forms Up: Data Types

---

Enter node , (file) or (file)node

6.9 Date Forms
==============

A "date form" represents a date and possibly an associated time.
Simple date arithmetic is supported:  Adding a number to a date
produces a new date shifted by that many days; adding an HMS form to a
date shifts it by that many hours.  Subtracting two date forms computes
the number of days between them (represented as a simple number).  Many
other operations, such as multiplying two date forms, are nonsensical
and are not allowed by Calc.

   Date forms are entered and displayed enclosed in `< >' brackets.
The default format is, e.g., `<Wed Jan 9, 1991>' for dates, or
`<3:32:20pm Wed Jan 9, 1991>' for dates with times.  Input is flexible;
date forms can be entered in any of the usual notations for dates and
times.  Note: Date Formats.

   Date forms are stored internally as numbers, specifically the number
of days since midnight on the morning of January 1 of the year 1 AD.
If the internal number is an integer, the form represents a date only;
if the internal number is a fraction or float, the form represents a
date and time.  For example, `<6:00am Wed Jan 9, 1991>' is represented
by the number 726842.25.  The standard precision of 12 decimal digits
is enough to ensure that a (reasonable) date and time can be stored
without roundoff error.

   If the current precision is greater than 12, date forms will keep
additional digits in the seconds position.  For example, if the
precision is 15, the seconds will keep three digits after the decimal
point.  Decreasing the precision below 12 may cause the time part of a
date form to become inaccurate.  This can also happen if astronomically
high years are used, though this will not be an issue in everyday (or
even everymillenium) use.  Note that date forms without times are
stored as exact integers, so roundoff is never an issue for them.

   You can use the `v p' (`calc-pack') and `v u' (`calc-unpack')
commands to get at the numerical representation of a date form.  Note:
Packing and Unpacking.

   Date forms can go arbitrarily far into the future or past.  Negative
year numbers represent years BC.  Calc uses a combination of the
Gregorian and Julian calendars, following the history of Great Britain
and the British colonies.  This is the same calendar that is used by
the `cal' program in most Unix implementations.

   Some historical background:  The Julian calendar was created by
Julius Caesar in the year 46 BC as an attempt to fix the gradual drift
caused by the lack of leap years in the calendar used until that time.
The Julian calendar introduced an extra day in all years divisible by
four.  After some initial confusion, the calendar was adopted around
the year we call 8 AD.  Some centuries later it became apparent that
the Julian year of 365.25 days was itself not quite right.  In 1582
Pope Gregory XIII introduced the Gregorian calendar, which added the
new rule that years divisible by 100, but not by 400, were not to be
considered leap years despite being divisible by four.  Many countries
delayed adoption of the Gregorian calendar because of religious
differences; in Britain it was put off until the year 1752, by which
time the Julian calendar had fallen eleven days behind the true
seasons.  So the switch to the Gregorian calendar in early September
1752 introduced a discontinuity:  The day after Sep 2, 1752 is Sep 14,
1752.  Calc follows this convention.  To take another example, Russia
waited until 1918 before adopting the new calendar, and thus needed to
remove thirteen days (between Feb 1, 1918 and Feb 14, 1918).  This
means that Calc's reckoning will be inconsistent with Russian history
between 1752 and 1918, and similarly for various other countries.

   Today's timekeepers introduce an occasional "leap second" as well,
but Calc does not take these minor effects into account.  (If it did,
it would have to report a non-integer number of days between, say,
`<12:00am Mon Jan 1, 1900>' and `<12:00am Sat Jan 1, 2000>'.)

   Calc uses the Julian calendar for all dates before the year 1752,
including dates BC when the Julian calendar technically had not yet
been invented.  Thus the claim that day number -10000 is called "August
16, 28 BC" should be taken with a grain of salt.

   Please note that there is no "year 0"; the day before `<Sat Jan 1,
+1>' is `<Fri Dec 31, -1>'.  These are days 0 and -1 respectively in
Calc's internal numbering scheme.

   Another day counting system in common use is, confusingly, also
called "Julian."  It was invented in 1583 by Joseph Justus Scaliger,
who named it in honor of his father Julius Caesar Scaliger.  For
obscure reasons he chose to start his day numbering on Jan 1, 4713 BC
at noon, which in Calc's scheme is -1721423.5 (recall that Calc starts
at midnight instead of noon).  Thus to convert a Calc date code
obtained by unpacking a date form into a Julian day number, simply add
1721423.5.  The Julian code for `6:00am Jan 9, 1991' is 2448265.75.
The built-in `t J' command performs this conversion for you.

   The Unix operating system measures time as an integer number of
seconds since midnight, Jan 1, 1970.  To convert a Calc date value into
a Unix time stamp, first subtract 719164 (the code for `<Jan 1,
1970>'), then multiply by 86400 (the number of seconds in a day) and
press `R' to round to the nearest integer.  If you have a date form,
you can simply subtract the day `<Jan 1, 1970>' instead of unpacking
and subtracting 719164.  Likewise, divide by 86400 and add `<Jan 1,
1970>' to convert from Unix time to a Calc date form.  (Note that Unix
normally maintains the time in the GMT time zone; you may need to
subtract five hours to get New York time, or eight hours for California
time.  The same is usually true of Julian day counts.)  The built-in `t
U' command performs these conversions.