Date of Easter < Date of Easter

See also the book Calendrical Calculations: The Millennium Edition by Edward M. Reingold and Nachum Dershowitz (Cambridge University Press, 2001).

This page just gives a few algorithms for finding Easter in the Gregorian calendar, i.e. that which was introduced in October 1582 and is used by Catholic and Protestant churches. (The Greek Orthodox Church still calculates Easter by the Julian calendar.) The algorithms are written in Pascal, but could easily be adapted to other languages.

All the algorithms here have been compared with one another and with Reingold & Dershowitz’s algorithm over the years 1583 to 100,000,000 AD, and found to agree completely.

Most Easter algorithms contain instructions like “Divide n by b and call the remainder r”, which in a computer program becomes something like r := n mod b or r = n % b. There can be trouble here when n is negative. In this case the remainder r is still required to be in the range 0 to b – 1, as it is when n is positive; for instance, –13 divided by 10 should give remainder 7. In some computer languages this does not happen, so that where n might be negative a workaround is required.

Reingold & Dershowitz make this point on p. 20 of their book. Some such workaround is required in their Easter algorithm on p. 121, where in the expression for shifted-epact the quantity taken mod 30 can be negative (this first happens in the year 3401). See De Morgan’s algorithm below for another example.

Before the Easter algorithms, here is a subroutine for finding the day of the week for any date in the Gregorian calendar. By using the trick noticed by Reingold & Dershowitz (p. 48) we can do without a table for the number of days in each month (There is no validation of the input, but we don’t need that here.)

{------------------------------------------------------------------------------
Get day of week for given date, with convention Sunday = 0, ... Saturday = 6.
}
function DayOfWeek( year, month, day : integer) : integer;
var
  y, m, leapDays, daysSinceMarch0 : integer;
begin
  if (month < 3) then begin
    y := year - 1;
    m := month + 9;
    end
  else begin
    y := year;
    m := month - 3;
  end;
  leapDays := (y div 4) - (y div 100) + (y div 400);
  daysSinceMarch0 := 30*m + (7*(m+1) div 12) + day;
  result := (y + leapDays + daysSinceMarch0 + 2) mod 7;
end;

Now the Easter algorithms. The first one here is due to C.F. Gauss. This is the final version of 1816, as given by Reinhold Bien (“Gauß and beyond: the making of Easter algorithms”, Archive for History of Exact Sciences, 58(5), July 2004, 439–452). In his original version of 1800, Gauss overlooked certain corrections, and thus “caused much confusion during the following 16 years” (Bien). A shorter version of this algorithm, restricted to the years 1800 to 2099, was published in Nature in 1876.

{------------------------------------------------------------------------------
Get Gregorian Easter for given year, using Gauss's algorithm.
Returns result as number of days since March 0.
}
function Easter_Gauss( year : integer) : integer;
var
  a, b, c, k, p, q, M, N, d, e : integer;
  days : integer; // days since March 0
begin
  a := year mod 19;
  b := year mod 4;
  c := year mod 7;
  k := year div 100;
  p := (13 + 8*k) div 25;
  q := k div 4;
  M := (15 - p + k - q) mod 30;
  N := (4 + k - q) mod 7;
  d := (19*a + M) mod 30;
  e := (2*b + 4*c + 6*d + N) mod 7;
  days := d + e + 22;
  if (e = 6) then begin
    if (d = 29) and (days = 57) then
        days := 50
    else if (d = 28) and (((11*M + 11) mod 30) < 19) and (days = 56) then
        days := 49;
  end;
  result := days;
end;

The next algorithm is due to Augustus De Morgan (who, by the way, spelt his name thus, not “de Morgan” or “DeMorgan”). It is taken from his book A Budget of Paradoxes (2nd edition, ed. David Eugene Smith, 1915, vol. 1, pp. 366–7). Note the precaution needed in calculating the quantity XII as a residue modulo 30.

{-------------------------------------------------------------------------------
Get Gregorian Easter for given year, using De Morgan's algorithm.
Returns result as number of days since March 0.
}
function Easter_De_Morgan( year : integer) : integer;
var
  cent, epact, temp : integer;
  I, II, III, IV, V, VI, VII, VIII, IX, X, XI, XII, XIII, XIV, XV : integer;
begin
  I := year + 1;
  II := year div 4;
  // "Take 16 from the centurial figures of the given year, if it can be done".
  cent := year div 100;
  if cent >= 16 then III := cent - 16
                else III := 0;
  IV := III div 4;
  V := I + II - III + IV;
  VI := V mod 7;
  VII := 7 - VI;   // Dominical letter, A = 1, ..., G = 7;
  VIII := I mod 19;  // Golden number
  if (VIII = 0) then VIII := 19;
  IX := (cent - 17) div 25;
  X := (cent - IX - 15) div 3;
  XI := (VIII + 10*(VIII - 1)) mod 30;
  //---------------------------------------------------------------
  // Here De Morgan's original needs modifying because the quantity
  // to be taken mod 30 can be < 0 (first happens in 3165)
  // XII := (XI + X + IV - III) mod 30;
  temp := XI + X + IV - III;
  if (temp >= 0) then XII := temp mod 30
                 else XII := 29 - ((-temp - 1) mod 30);
  //---------------------------------------------------------------
  epact := XII;
  if (XII = 24) then epact := 25;
  if ((XII = 25) and (VIII > 11)) then epact := 26;
  if (XII = 0) then epact := 30;
  if (epact <= 23) then begin
    XIII := 45 - epact;
    XIV := (27 - epact) mod 7;
    if (XIV = 0) then XIV := 7;
    end
  else begin
    XIII := 75 - epact;
    XIV := (57 - epact) mod 7;
    if (XIV = 0) then XIV := 7;
  end;
  XV := XIII + VII - XIV;
  if (XIV > VII) then XV := XV + 7;
  result := XV;
end;

The next algorithm was first published in Nature, 13, 487 (20 April 1876). It was sent in from New York by an anonymous correspondent. According to Bien (op. cit.) it has often been reproduced. Translated from its original form into Pascal, it is as follows:

{------------------------------------------------------------------------------
Get Gregorian Easter for given year, using New York algorithm (Nature, 1876).
We'll return the result as days since March 0, to be consistent with other algos.
}
function Easter_New_York( year : integer) : integer;
var
  a, b, c, d, e, f, g, h, i, k, l, m, n, o : integer;
begin
  a := year mod 19;
  b := year div 100;
  c := year mod 100;
  d := b div 4;
  e := b mod 4;
  f := (b + 8) div 25;
  g := (b - f + 1) div 3;
  h := (19*a + b - d - g + 15) mod 30;
  i := c div 4;
  k := c mod 4;
  l := (32 + 2*e + 2*i - h - k) mod 7;
  m := (a + 11*h + 22*l) div 451;
  n := (h + l - 7*m + 114) div 31;
  o := (h + l - 7*m + 114) mod 31;
  // "n is the number of the month of the year and
  // o + 1 is the number of the day of the month on which Easter falls."
  if n = 3 then result := o + 1
           else result := o + 32;
end;

The following is an interpretation by Michael Behrend of Clavius’s original method, as detailed on Web sites. It relies on the subroutine DayOfWeek (above) to find the day of the week on which the Paschal full moon falls.

{------------------------------------------------------------------------------
Get Gregorian Easter for given year, using my understanding of Clavius
   method as found on Web sites.
Returns result as number of days since March 0.
}
function Easter_Clavius_MB( year : integer) : integer;
var
  g, ye_raw, c, solar_corr, lunar_corr, ye : integer;
  newMoon, dayOfMoon, paschalMoon : integer;
begin
// Golden number of year
  g := (year mod 19) + 1;
// Yearly epact before solar and lunar corrections
  ye_raw := ((11*(g - 1)) mod 30) + 1;
// Solar and lunar corrections
  c := year div 100;
  solar_corr := (3*(c - 15)) div 4;    // days to be subtracted
  lunar_corr := (8*(c - 14)) div 25;   // days to be added
// Corrected yearly epact
  ye := ye_raw - solar_corr + lunar_corr;
  while (ye <= 0) do ye := ye + 30;
  while (ye > 30) do ye := ye - 30;
// Kludge by Clavius
  if ((ye = 25) and (g >= 12)) then ye := 26;
// Allow for skipping daily epact 25 in short month
  if (ye = 24) then ye := 25;
// Change 23 (March 8) to 53, ... 1 (March 30) to 31
  if (ye <= 23) then ye := ye + 30;
// Get day of new moon before Paschal full moon (days since March 0)
  newMoon := 61 - ye;
// Paschal full moon is 13 days later
  paschalMoon := newMoon + 13;
// Finish off just as for R-D algorithm
// Get day of week of Paschal full moon (0 = Sun, ... 6 = Sat)
  dayOfMoon := DayOfWeek( year, 3, paschalMoon);
// Add 1..7 days to bring it to Easter Sunday
  result := paschalMoon + (7 - dayOfMoon);
end;

We can tidy this up a bit and replace the call to DayOfWeek by inline code. One possibility is as follows:

{------------------------------------------------------------------------------
Tidied-up version of Clavius_MB algorithm.
}
function Easter_MB( year : integer) : integer;
var
  c, d, e, f, q, w : integer;
begin
  c := year div 100;
  d := (3*c - 5) div 4;   // (solar correction) + 10, also used for day of week
  e := (8*c + 13) div 25; // (lunar correction) + 5
  f := year mod 19;       // (golden number of year) - 1
// Get q, where q = 53 - (Clavius epact), so that
//    q + 21 = date of Paschal full moon in days since March 0.
// Value on left of mod is always >= 0, so no worry there.
  q := (227 - 11*f + d - e) mod 30;
  if (q = 29) or ((q = 28) and (f >= 11)) then q := q - 1;
// Get day of week of Paschal full moon (0 = Sun, 1 = Mon, ..., 6 = Sat)
  w := (year + (year div 4) - d + q) mod 7;
// Get next Sunday strictly after Paschal full moon
  result := q + 28 - w;
end;

Date of Easter Sunday