When looking through some of my old papers I found at my father’s house after he died, I found some old Fortran code for converting Gergorian calendar dates to and from Julian dates. I haven’t used Fortran since the 1970s, so the code looked a little strange.

Some examples of Julian dates:

Julian Date | Equivalent Gregorian Date |
---|---|

2369916.0 | July 4, 1776 12:00:00.0 UT |

2436911.509722 | December 9, 1959 00:14:00.0 UT (the time of my birth) |

2457533.5 | May 25, 2016 00:00:00.0 UT |

Julian dates are a continuous count of days since Greenwich Mean Noon on January 1, 4713 BCE. January 1, 4713 BCE is also known as -4712 January 1 when used for astronomical calculations. The apparent one year difference is due to there being no year 0—the day after December 31, 1 BCE was January 1, 1 CE. It makes adding and subtracting dates easier.

Greenwich Mean Noon is 12:00 noon UT (Universal Time). UT is a time standard based on Earth’s rotation. It is a modern continuation of Greenwich Mean Time (GMT), i.e., the mean solar time on the Prime Meridian at Greenwich, London, UK. In fact, the expression “Universal Time” is ambiguous when accuracy of better than a few seconds is required, as there are several versions of it, the most commonly used being Coordinated Universal Time (UTC) and UT1. All of these versions of UT, except for UTC, are based on Earth’s rotation relative to distant celestial objects (stars and quasars), but with a scaling factor and other adjustments to make them closer to solar time. UTC, on the other hand, is based on International Atomic Time, with leap seconds added to keep it within 0.9 second of UT1.

## Gregorian Calendar Date to Julian Date Formula

Conversion of a Gregorian calendar date to a Julian date for years 1801–2099 CE can be carried out with the following formula (in JavaScript notation). The indentation is a little strange, but that was meant to make it easier to read the formula,

julianDate =

367 * year –

ccTruncate((7 * (year +

ccTruncate((month + 9) / 12, 0)

)) / 4, 0)

+

ccTruncate((275 * month) / 9, 0)

+ day + 1721013.5 + universalTime / 24

– 0.5 * ccGetSign(100 * year + month – 190002.5) + 0.5;

// ]]></script>

Where `year`

is in the range 1801–2099, `month`

is in the range 1–12, `day`

is in the range 1–31, and `universalTime`

is the universal time in hours.

The last two terms in the formula add up to zero for all dates after 1900 February 28, so these two terms can be omitted for subsequent dates. This formula makes use of the `ccGetSign()`

and `ccTruncate()`

functions described below:

## ccGetSign() and ccTruncate() Functions

The `ccGetSign()`

function serves to extract the sign, positive or negative, from a number.

function ccGetSign(number) {

if (number < 0)

return -1;

return 1;

}

// ]]></script>

The `ccTruncate()`

function extracts the integral part of a number. Here’s the JavaScript code for it in case you think it’s useful.

function ccTruncate(number, places) {

var shift = Math.pow(10, places);

return ((number * shift) | 0) / shift;

};

// ]]></script>

For the current problem we just need to truncate floating point numbers to make them integers, but this function will work for all kinds of decimal places.

## Conversion From a Gregorian Calendar Date to a Julian Date

Here is the Fortran code that takes a year, month, and day in the Gregorian calendar as an input and returns the Julian date. This is valid for any Gregorian calendar date producing a Julian date greater than zero.

C

C COMPUTES THE JULIAN DATE (JD) GIVEN A GREGORIAN CALENDAR

C DATE (YEAR,MONTH,DAY).

C

INTEGER YEAR,MONTH,DAY,I,J,K

C

I= YEAR

J= MONTH

K= DAY

C

JD= K-32075+1461*(I+4800+(J-14)/12)/4+367*(J-2-(J-14)/12*12)

2 /12-3*((I+4900+(J-14)/12)/100)/4

C

RETURN

END

## JavaScript Example

Example using January 1, 1970 (Julian date 2440588):

var jd, year, month, day, i, j, k;

year = 1970;

month = 1;

day = 1;

i = year;

j = month;

k = day;

jd = Math.floor(k – 32075 + 1461 * (i + 4800 + (j – 14) / 12) / 4 + 367 * (j – 2 – (j – 14) / 12 * 12) / 12 – 3 * ((i + 4900 + (j – 14) / 12) / 100) / 4);

document.write(“julian date = ” + jd);

// ]]></script>

Note: This formula works if JavaScript’s `Math.floor()`

function is applied at the very end of the calculation. When `Math.floor()`

was applied after every division operation, it produced inaccurate results.

## Conversion From a Julian Date to a Gregorian Calendar Date

Here is the Fortran code that takes a Julian date as an input and returns the year, month, and day in the Gregorian calendar.

C

C COMPUTES THE GREGORIAN CALENDAR DATE (YEAR,MONTH,DAY)

C GIVEN THE JULIAN DATE (JD).

C

INTEGER JD,YEAR,MONTH,DAY,I,J,K

C

L= JD+68569

N= 4*L/146097

L= L-(146097*N+3)/4

I= 4000*(L+1)/1461001

L= L-1461*I/4+31

J= 80*L/2447

K= L-2447*J/80

L= J/11

J= J+2-12*L

I= 100*(N-49)+I+L

C

YEAR= I

MONTH= J

DAY= K

C

RETURN

END

## JavaScript Example

In the example code below, JavaScript’s `Math.floor()`

function is used after each division operation to make sure all the values are integers like they are in Fortran.

Example using Julian date 2440588 (January 1, 1970):

var jd, year, month, day, l, n, i, j, k;

jd = 2440588;

l = jd + 68569;

n = Math.floor(Math.floor(4 * l) / 146097);

l = l – Math.floor((146097 * n + 3) / 4);

i = Math.floor(4000 * (l + 1) / 1461001);

l = l – Math.floor(1461 * i / 4) + 31;

j = Math.floor(80 * l / 2447);

k = l – Math.floor(2447 * j / 80);

l = Math.floor(j / 11);

j = j + 2 – 12 * l;

i = 100 * (n – 49) + i + l;

year = i;

month = j;

day = k;

document.write(“year = ” + year + “, month = ” + month + “, day = ” + day);

// ]]></script>