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. See section 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. See section 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.

Go to the first, previous, next, last section, table of contents.