Path: christian
Newsgroups: soc.religion.christian
From: mls@sfsup.att.com (Mike Siemon)
Subject: Easter algorithms I
Organization: AT&T Bell Laboratories
Approved: christian@aramis.rutgers.edu

Cathy Fasano asks:

+ I have this vague memory of seeing somewhere on the net an algorithm
+ for calculating the date of Easter in any particular year.  Of course
+ I know about "the first Sunday after the first full moon after the
+ vernal equinox", but I don't, in general, know the dates of full moons,
+ so that's not very useful.

Actually, knowledge of full moons and equinoxes is only marginally useful
anyway :-)  because the actual calculations that set the date of Easter
are dependent on cyclical approximations.  I will try to answer Cathy's

the one that gives the algorithm she seeks; this article doesn't have it!)

Sources for what follows are early editions of the Encyclopedia Britannica
(11th and 13th editions certainly; I don't know when they dropped the data
that are needed for this purpose, but the editions from the mid-50s on are
inadequate to this purpose) and the _Explanatory Supplement to the Astro-
nomical Ephemeris_ (published jointly by the US and UK governements) which
is my most immediate source.

Given some of my dyspepctic comments about this in earlier articles, I want
here to explain in some detail what is going on, and why the matter is so
easy for "simple" statements in ordinary language to misrepresent.  Please
bear with me -- or if you would rather not, you may ignore this note and go
to the end of my second one for a detailed C program for Easter dates.

Calendar cycles.
----------------

This whole issue of Easter, if we are to follow Nicea, has several distinct
components.  Easter is on a Sunday -- thus we are concerned with the cycle
of days of the week.  It follows the spring equinox -- and so we need to
represent THAT, despite the problem that the equinoctial position recurs at
an interval (approximately 365.2422 days) that is NOT easily represented in
a calendar.  And, we also believe, it is necessary to observe the phases of
the moon, since the Jewish calendar that sets the time of Passover was a
lunar calendar, and 14 Nisan represents the full moon of the first month of
spring.  I will beg off dealing here with Jewish calendars, and just take
Cathy's statement of the Nicene constraints.  In any case, Sunday, equinox,
and full moon are ALL elements which we agree must enter into Easter dating.
[Recent posts suggest that the Orthodox churches see the Nicene constraints
a bit differently from the way the West does; I am not trying to controvert
that understanding here -- things are hard enough with the Western version.]

To see the *kind* of thing that happens in calendars, the day-of-the-week
cycle is a good starting point.  52 weeks of 7 days constitute 364 days --
one short of the "usual" 365 and two short of the 366 days in leap years
of the Julian calendar.  Thus, throughout the year if you know that today
is day N, and that January 1 was an X-day (sunday, monday, tuesday, ...),
then today is an [X + (N modulo 7)]-day. (And one sees that if *this* year
Jan. 1 is an X-day, then *next* year, it is an X+1-day -- except on leap
years!)  For calendar purposes, it is usually prefereable to take March 1
as the start of the year, with the variable February as the "last" month.

Our B.C./A.D. calendar is the construct of Dionysius Exiguous (in the late
6th century?)  It is of some interest that he started with the year 0 (or
in his nomenclature, 1 B.C.)  When people loudly insist that the new millen-
ium begins in 2001 (and not 2000), it is worth observing that they do not
know the history of our calendar.  Dionysius did not use a notation with
zeros, but his construction is as much 0-origin as arrays in the the C
language.  Those of you who wish TRULY to be pedantic can insist that the
"correct" millenium is in 2000 :-)

Anyway, to quote the _Explanatory Supplement_, "In the Julian calendar,
January 1 of the year 0 [1 B.C.], which is a leap year [yet further data
in favor of my statement above that Dionysius was using a zero origin :-)]
was Thursday; therefore, the Julian dominical letter for January and February
is D and for the remainder of the year C.

This introduces a sequence of letters A,B,C,D,E,F,G for the residues modulo
7 of the start of the year.  (These are the "dominical letters.")  It is
preferable, for algorithmic purposes, to use 0-6 instead for these.  Noting
that March 1 is 31+28 = 59 days after the start of (non-leap) years, and 60
days after Jan. 1 in leap years, we have Thursday Jan. 1 -> Monday March 1,
0 A.D., and the remark in the Explanatory Supplement translates to:

	day N (= date - March 1) of year Y (Julian) is 1+Y+N modulo 7,

plus a leap year correction of 1+(int)Y/4.  That is, if the Julian calendar
had remained in use in Europe, we could still define the day of the week as
the mapping of this residue into the set {Sun,Mon,Tue,Wed,Thu,Fri,Sat}. The
Gregorian correction amounts to a  *decrement* of a day (counteracting the
Julian term) on century years not multiples of 400.  In other words, the
day of the week of March 1 in year Y of the Gregorian calendar (after 1582)
is:

	D = 3+Y+(int)(Y/4)-(int)(Y/100)+(int)(Y/400) modulo 7

(My first attempt at this was an off-by-one version with a leading 2; you
may confirm this version by trying various years in the UNIX cal comand,
with cal 3 <year> input.)

The first step towards an "Easter algorithm" is to combine this with the
"Sunday after the equinox" constraint.  March 22 is three weeks after the
1st of March, and hence has the same day of the week we just calculated.
Thus if D above is 0, March 22 is a Sunday; otherwise, March 22 + 7 - D
is the next Sunday after the equinox.

Note: I have just skirted over a touchy point.  The spring equinox is NOT
always on (Julian or Gregorian) March 21.  That is a conventional date, and
is indeed sometimes incorrect.  But for ecclesiastical calculations, it is
the presumed date of the equinox. Everything that follows *assumes* March
21 as the equinox -- please keep in mind that this is astronomically naive.

Anyway, taking March 21 as *the* equinox, and Easter as of necessity AFTER
this, we may seek the dates of Sundays falling on or after March 22.  The
day of the week of March 22 is given by D above. Subsequent Sundays are
given by

	March 22 + 7*(7-D)*n, n = 0,1,2,3,...

In pre-Nicean times, the Roman church celebrated Pascha on the Sunday  
nearest (first after?) the equinoctial date of March 21 (actually, in
the earliest period it was assumed that the equinox was on the 25th, and
this was the traditional date of the original Resurrection in Rome.)

In any case, we get (as long as we continue to ignore the moon) a date
for Easter that can be formulated as

	March 22 (if D = 0) or March 22 + 7-D (for D > 0)

I am going to cut off this first article here.  To deal with the lunar
cycle requires (at least!) another article -- and no Easter algorithm
(post Nicaea) can be constructed that doesn't have some reference to the
moon.  In my next note I will (try to) explain lunar cycles as they
interact with the solar calendar we are familiar with.  Here, too, there
are some arbitrary choices, like taking March 21 as THE spring equinox.
Much of the subtlety of the Gregorian calendar shift of 1582 has to do
with lunations; I probably will not do justice to all of that, but I do
hope to come out at the end with a usable algorithm, nonetheless.  For
now, I will leave things at a point that has no reference to moons or
months, the real "jokers" in most human calendars.
-- 
Michael L. Siemon		I was ready to be sought by those
m.siemon@ATT.COM		    who did not ask for me;
...!att!attunix!mls		I was ready to be found by those
standard disclaimer	  	    who did not seek me. --  Isaiah 65:1

From mls@cbnewsm.att.com  Wed Jul  3 23:00:25 1991
Received: from att.att.com by aramis.rutgers.edu (5.59/SMI4.0/RU1.4/3.08) 
	id AA14591; Wed, 3 Jul 91 23:00:25 EDT
To: christian@aramis.rutgers.edu
Date: Wed,  3 Jul 91 22:56:36 EDT
From: mls@sfsup.att.com (Mike Siemon)
Newsgroups: soc.religion.christian
Path: mls
Subject: Julian Easter algorithm
Organization: AT&T Bell Laboratories
Distribution: na
Message-Id: <1991Jul4.025618.9264@cbnewsm.att.com>
Summary: Mostly description, plus a small code fragment
Keywords: computus, saltus lunae, C-code
Lines: 101


It is the moon that gives the most difficulty in calendars that pay it any
attention (our civil calendar "months" have only a tenuous, historical
connection to any lunar actuality.)    The solar year is close enough to
365.25 that "add a day every four years" is a good approximation for most
practical purposes -- the difference from a more accurate 365.2422 (i.e.,
.0078 days per year) accumulates to one day's difference in 1/.0078 = 128.2
years; it's a matter of less than a day per lifetime.

But the moon goes from new moon to new moon in (an average of) 29.53059
days -- and it's motion is complex, so that it may tt a month every two or
three years, originally just by tracking sightings of the new moon.  But
this was usually under political authority, and the result was sometimes
pure chaos.  Babylonia and the Greeks (possibly with substantial input from
Babylon) eventually came up with *computed* systems that did a good job.
These used a cycle of 19 years equated to 235 months and a total of 6939 or
6940 days.  If we do 4 of these cycles in 76 Julian years, we get a value
of 1 month = 27759/940 = 29.53085, pretty close to (average) reality.

Note that 235 = 19*12 + 7 months, so we have to "intercalate" 7 months into
the "regular" calendar of 12 alternating 29 and 30 day months.  If these 7
extra months are all 30-day months, our total of days comes to 19*354 + 7*30
= 6936 -- 3 (or 4) days short!  In fact, the Greek calendars using this 19-
year "Metonic" cycle had various ways of distributing 30-day months (one is
to start considering ALL months 30 days; this comes out with 7050 days, 110
too many; so go along "striking out" every (7050/110)th = 64th day.)

In the Western world, with its Julian calendar, there is an "implicit" extra
day in a February month every leap year, that is 4 or 5 days "sneak in" on
top of a cycle laid out in unvarying 365-day years.  NOW the Western lunar
cycle is one day too LONG! and by a truly dreadful hack, a 30-day month in
the last year of the cycle gets arbitrarily shortened to 29 days.  This was
the moon's jump, _saltus lunae_ that medieval undergraduates tended to find
incomprehensible.

Luckily, we can avoid describing the full calendar in calculating the dates
for Easter.  The new moon in March recurs constantly at the same days over
the 19 year cycle.  Years are given the numbers 1 through 19 (the "golden
number") as (year modulo 19)+1, the first year being 1 B.C. [this is just
dodging around the zero-origin; we could take (year % 19) starting at 0 in
the year 0.  However, I'll be traditional so as not to conflict with what
you may find elsewhere.]  In 1 B.C. (golden number 1), the March new moon
is on the 23rd.  A year later it falls 11 days before that, on the 12th.
The next year, it's 11 days earlier still, taking it to March 1st.  But we
have also had an intercalary month, and another month starts at March 31st.
THIS will be the paschal (Easter) new moon. If the moon is new on March 1st,
it is full on the 14th, which is before the equinox.  Note that if the moon
is full on March 21st, it was new 13 days earlier on March 8th.  [There are
a couple of conventions buried in here; the new moon is actually taken to
be one day old, and the full moon always to be 14 days old.]

The calendar is arranged so that the moon before the paschal moon is ALWAYS
a 30-day moon.  So we can keep on going down the 19 year cycle subtracting
11 days each year, and adding 30 when the number we get falls below 8.  That
is, starting with March 23rd:

	new moon = last year's new moon - 11
	if new moon < March 8, add 30.

In table form:

 year  moon          year  moon          year  moon          year  moon
  1  March 23         6  March 28        10  March 14        15  March 19
  2  March 12         7  March 17        11  April 2         16  March 8
  3  March 31         8  Mar. 6+30       12  March 22        17  March 27
  4  March 20            (April 5)       13  March 11        18  March 16
  5  March 9          9  March 25        14  March 30        19  April 4

If you examine this rule from April 4 (March 35) in year 19, the next year
"should" be March 24.  This is where the "saltus lunae" I mentioned comes
into the Easter calculation, the extra Julian day we have to cast out.

To calculate the day of the week at the full moon, we use the kind of
thing I did in the first article.  March Nth in one year is on some day of
the week D.  Feb. 28 of the next year is on the same weekday as March 1,
so next year March N is on D+1 (or D+2 in leap years.)  If we keep every-
thing in March days, we get the following C code fragment to find the date
of Easter in the Julian calendar:

	new_moon = 23 - 11*(year%19);
	while (new_moon < 8)
		new_moon += 30;
	full_moon = new_moon+13;
	week_day = (year + year/4 + full_moon) % 7;
	easter = full_moon + 7 - week_day;
	if (easter > 31)
		printf("April %d\n", easter-31);
	else
		printf("March %d\n", easter);
 
Week days come out as 0 (Sunday) through 6 (Saturday), so that if the
full moon is on day 0, Easter is the NEXT sunday 7 days later.  

That's enough for this installment; I will give the Gregorian version in
my next post, and also follow up with a full C program that should have
enough bells and whistles to satisfy just about anyone.
-- 
Michael L. Siemon		The Son of Man has come eating and drinking;
...!att!attunix!mls		and you say "Behold, a glutton and a drunkard,
m.siemon@ATT.COM		a friend of tax collectors and sinners."  And
standard disclaimer		yet, Wisdom is justified by all her children.

From mls@cbnewsm.att.com  Thu Jul  4 14:48:37 1991
Received: from att.att.com by aramis.rutgers.edu (5.59/SMI4.0/RU1.4/3.08) 
	id AA04863; Thu, 4 Jul 91 14:48:37 EDT
To: christian@aramis.rutgers.edu
Date: Thu,  4 Jul 91 14:44:11 EDT
From: mls@sfsup.att.com (Mike Siemon)
Newsgroups: soc.religion.christian
Path: mls
Subject: Easter Algorithms III -- the Gregorian computus
Organization: AT&T Bell Laboratories
Distribution: na
Message-Id: <1991Jul4.184358.22620@cbnewsm.att.com>
Summary: My environmental epact statement : -)
Keywords: epact, Clavius, Gauss
Lines: 134


The Gregorian Modifications
---------------------------

The reformed calendar is actually extremely conservative.  Its one 
radical measure, dropping 10 days in October, was itself done under 
constraint of the Nicene date of March 21 for the equinox.  The Julian 
leap-year is basically kept intact, with a "correction" on century 
years (which I'd bet most people don't remember, except maybe for a 
brief time near the centuries :-)).  More accurate rules could be 
devised -- and had been proposed; some criticism was directed at the
Gregorian proposal BECAUSE it wasn't as accurate as it might be.

	[My own, tongue-in-cheek, proposal would be for us to go over
	to an octal system; we would use the Julian rule except that
	octal "bicentennial" (every 128 = 2*8^2) years don't leap.]

The actual rule is both fairly good and fairly easy -- and almost no 
difference in practice from what it replaces.  The lunar calendar, 
though necessarily more complex, also retains a form which permits 
construction, for all years in a given century, of the same kind of 
simple table I constructed last time for the paschal moons.  Because 
of the Gregorian leap year correction, there is a "missing" day every 
non-leap century year, and at those points the new moons slip forward
a day.  (So, in the Gregorian calendar it's possible to have a paschal
new moon on any day from March 8 to April 5, not just on the 19 days
of the table I gave last time.)

Besides the "solar" correction to the 19-year cycle, there's a "lunar"
correction as well.  The Julian cycle *assumed* that 235 months were
exactly equal to 6939.75 days; but 235 * 29.53059 = 6939.68865 days;
i.e. the new moons of a new cycle are about an hour and a half earlier
than the previous ones.  This mounts up to the new moons slipping behind
one day in about 310 years (19 * 1/(.75 - .68865)).  The Gregorian
commission took this value to be 312.5, so that working to an integral
number of centuries there are 8 days in 2500 years to account for.  The
solar correction adds a day to the new moon dates in 3 out of 4 century
years; the lunar correction subtracts a day every 300 years (the first
was in 1800, then 2100 and so on to 3900; after 8 of these the cycle runs
out a final century to 4000, and the next subtraction is in 4300.)

Details
-------

For a number of reasons, notably the possible appearance of new moons
at any day of any month, the underlying details of calendar construction
for ecclesiastical months uses a different method than the older Julian
construction.  It gets new months *indirectly* from a quantity called
"epact" -- essentially the "age" of the moon on Jan. 1st (and also March
1st, which is what I'll actually calculate with).

Starting with a new moon on March 1st one year, after 12 regular months
the "same" month begins next year 11 days back into February, and the
moon on March 1st is 11 days "older" -- the epact is 1+11.  Next year
it's 23, then 34-30 = 4, etc.  This is almost the "same" calculation in
the reverse direction to what I used last time to get paschal new moons.
But by adding the solar and lunar corrections, we can come out with any
value from 1 to 30 (or 0 to 29 with 0 identified with 30 -- it's the last
day of the "old" moon and the day of astronomical conjunction, with epact
1 being the new moon for church purposes.)

	epact = (13 + 11 * (year % 19) - solar + lunar) % 30;

where	century = year/100;		/* the Gregorian calendar very  */
	solar = century - century/4;	/* cleverly does all adjustment */
	lunar = (century - 15)/3;	/* on century years only!       */

Notes:	the solar correction as I give it here is 12, not the 10 one might
	expect (for that, I'd have to use (century-3) - (century-3)/4, as
	we are adjusting back to Nicea, not to the year 1 A.D.  There is
	no need here to be fussy, since I can absorb the other two days in
	the constant term of the epact equation.  Also, this version of the
	lunar correction is valid only up to 4199 A.D.  For true pedantry,
	you can use

		lunar = (century - 15 - (century-17)/25)/3;

	In the form above, epact can be negative (e.g. if year % 19 == 0
	and the solar correction is large enough).  Some systems take the
	% operator to yield negative remainders from negative input, so
	the equation for epact should be supplemented by:

	if (epact < 0)
		epact += 30;

This is almost enough to give us the paschal new moon and easter.  There
is a new moon in March determined from the epact:

	new_moon = 31 - epact;
	if (new_moon < 8)
		new_moon += 30;

Unfortunately this is not quite right.  Unlike the old Julian cycle, it
is *possible* for the moon before the paschal moon to have 29 days.  The
details of how 29-day months are disposed are complex (but clever; they
have to do with some hacking with epacts 24, 25 and 26 in constructing a
full table of calendar new moons against epacts.  See the _Encyclopedia
Britannica_ calendar article for details.)  For our purposes, it is enough
to note that the pre-paschal month has 29 days ONLY when epact is 24 or
it is 25 and the cycle is in its last 8 years -- this is usually marked
in tables as epact 25', and it is assimilated to epact 24.)  Thus, we get
(correctly this time :-))

	new_moon = 31 - epact;
	if (new_moon < 8)
		if (epact == 24 || epact == 25 && (year%19) > 10)
			new_moon += 29;
		else
			new_moon += 30;

We get from there to the full moon, its weekday and Easter by the same
method as in the Julian calendar:

	full_moon = new_moon + 13;
	week_day = (2 + year + year/4 - solar + full_moon) % 7;
	easter = full_moon + 7 - week_day;
	if (easter > 31)
		printf("April %d\n", easter-31);
	else
		printf("March %d\n", easter);

the only difference being the week_day calculation, which has to take
into account the 10 days of October 1582 and subsequent solar correction.)

The final installment in this series will be a C program that prints out
both Julian and (after 1582) Gregorian data on golden numbers, dominical
letters (i.e. day of the week counted from Jan 1 as A on which Sundays
fall), epacts, paschal moon, Easter and Ash Wednesday (= easter - 46;
remember that Sundays are not fast days) for a year or range of years.
-- 
Michael L. Siemon		The Son of Man has come eating and drinking;
...!att!attunix!mls		and you say "Behold, a glutton and a drunkard,
m.siemon@ATT.COM		a friend of tax collectors and sinners."  And
standard disclaimer		yet, Wisdom is justified by all her children.

From kilroy@gboro.glassboro.edu  Fri Jul  5 11:20:41 1991
Received: from RUTGERS.EDU by aramis.rutgers.edu (5.59/SMI4.0/RU1.4/3.08) 
	id AA15402; Fri, 5 Jul 91 11:20:41 EDT
Received: from njin.UUCP by rutgers.edu (5.59/SMI4.0/RU1.4/3.08) with UUCP 
	id AA05235; Fri, 5 Jul 91 11:12:08 EDT
Received: from gboro.UUCP by pilot.njin.net (5.59/SMI4.0/RU1.4/3.08) with UUCP 
	id AA23165; Fri, 5 Jul 91 10:28:17 EDT
Message-Id: <9107051428.AA23165@pilot.njin.net>
From: kilroy@gboro.glassboro.edu (Dr Nancy's Sweetie)
Date: 5 Jul 91 12:53:12 GMT
To: soc-religion-christian@rutgers.edu
Subject: Submission for soc-religion-christian
Responding-System: gboro.glassboro.edu

Path: gboro!kilroy
From: kilroy@gboro.glassboro.edu (Dr Nancy's Sweetie)
Newsgroups: soc.religion.christian
Subject: Re: Algorithm for calculating date of Easter
Summary: How about some code?
Message-ID: <1157@gboro.glassboro.edu>
Date: 5 Jul 91 12:53:12 GMT
References: <Jun.22.21.44.10.1991.18352@athos.rutgers.edu>
Organization: Glassboro State College
Lines: 37


Our All Wise Moderator asked about Easter algorithms for people who want
to write code.

It can be found in Knuth's _The Art of Computer Programming_, on page 155
of Volume 1, "Fundamental Algorithms"; as it is fairly long, I won't type
the whole thing in.


For people who want code, Fred Avolio sent this in to the MailJC list a
few years ago:

#!/bin/sh
#
# eas.sh - find the date of Easter for a given year.
#
# Usage:  eas.sh <year>

echo $* '[ddsf[lfp[too early
]Pq]s@1583>@
ddd19%1+sg100/1+d3*4/12-sx8*5+25/5-sz5*4/lx-10-sdlg11*20+lz+lx-30%
d[30+]s@0>@d[[1+]s@lg11<@]s@25=@d[1+]s@24=@se44le-d[30+]s@21>@dld+7%-7+
[March ]smd[31-[April ]sm]s@31<@psnlmPpsn1z>p]splpx' | dc | sed 'N
y/\n/ /'


Believe it or not, it works.

Anyone who can derive the algorithm from the code is officially entitled
to post to comp.unix.wizards.  8-)

(I have mailed a copy of this to Cathy, per her request.)


kilroy@gboro.glassboro.edu      Darren F. Provine      ...njin!gboro!kilroy
"There's no need to write things down when you have a computer."
                                                             -- Vivek Khera

From mls@cbnewsm.att.com  Fri Jul  5 22:15:29 1991
Received: from att.att.com by aramis.rutgers.edu (5.59/SMI4.0/RU1.4/3.08) 
	id AA19619; Fri, 5 Jul 91 22:15:29 EDT
To: christian@aramis.rutgers.edu
Date: Fri,  5 Jul 91 22:01:40 EDT
From: mls@sfsup.att.com (Mike Siemon)
Newsgroups: soc.religion.christian
Path: mls
Subject: Easter Algorithms IV: Easter, the Program
Organization: AT&T Bell Laboratories
Distribution: na
Message-Id: <1991Jul6.020124.28363@cbnewsm.att.com>
Lines: 279


There follows a somewhat bloated program to compute Julian and
Gregorian Easter, and related data, for any range of years.
I have decomposed it rather radically into tiny functions in
hopes that the pieces might be of some use to others, outside
the densely-packed output lines produced by the main() function
here.  The program is highly commented, but I have not given
explanations of C idioms used (I've tried to avoid the worst.)
--------------------------------------------------------------

#include <stdio.h>

typedef	enum	{Julian, Gregorian} calendar;

#define	WARNING	\
"\n\
Early dates should not be taken too seriously; even in post-1000 A.D.   \n\
Catholic Europe, uniformity of calendars was the exception, not the rule\n\
until the Gregorian calendar was accepted (e.g. New Year varied at lot.)\n"

/*	The "Golden Number" is the order of the year in the 19-year lunar cycle.
 *	It is the same in Julian or Gregorian calendars, and is listed in the
 *	output of this program under the heading GN.
 */
int	GoldenNumber(year)
	int	year;
{
	return ((year % 19) + 1);
}

/*	All dates in this program are referred to March 1st; so 32 means
 *	April 1 and 0 means February 28th or 29th.  Leap years are needed
 *	for printing February dates (and for dominical letters).
 */
int	Leap(year, style)
	int		year;
	calendar	style;
{
	if (year % 4)
		return 0;
	else switch(style) {
		case Julian:	return 1;
		case Gregorian: return (year % 100 || year % 400 == 0);
	}
}

PrintDate(n, year, style)
	int	n;
	int		year;
	calendar	style;
{
	if (n > 31)
		printf("Apr.%2d", n-31);
	else if (n > 0)
		printf("Mar.%2d", n);
	else
		printf("Feb.%2d", 28+n+Leap(year,style));
}

#define	century	(year/100)

/*	Gregorian solar correction -- this is the number of days difference
 *	between Julian and Gregorian civil dates, in effect the number of
 *	excess leap years in the Julian calendar since the time of Nicea.
 *	This correction derives from the Gregorian introduction of non-leap
 *	century years, giving mean tropical year = 365.2425 days.
 */
int	Solar(year)
	int	year;
{
	return (century - century/4 - 2);
}

/*	Gregorian lunar correction -- this is only used for the computation of
 *	the paschal new moon (via epact), but might as well be pulled out on
 *	its own.  I give the pedantically correct version.
 *	This correction derives from the mean lunar month being 29.53059 days
 *	instead of the 6939.75/235 assumed in the Julian calendar.  It is one
 *	days in (roughly) 312.5 years, or 8 days in 2500 years.
 */
int	Lunar(year)
	int	year;
{
	return ((century - 15 - (century-17)/25)/3);
}

/*	Dominical letters are also listed here, but not used in calculations.
 *	These derive from taking Jan. 1 as A and thereafter lettering all the
 *	days of the year successively A though G.  The dominical letter is the
 *	one on which Sundays appear throughout the year (or through February
 *	in leap years, with the next letter over applying from March on.) The
 *	Julian and Gregorian values differ, because of the "solar correction"
 *	-- the nonleap century years of the Gregorian calendar.  The two will
 *	coincide whenever the difference between the calendars is a multiple of
 *	7, as it will be next in the 22nd century.
 *
 *	The function here computes the March dominical letter returning that
 *	or a digraph with the Jan/Feb letter prefixed in leap years (this is
 *	the standard practice in almanacs, etc.)  The return value is a static
 *	character string -- use it before calling the function a second time!
 */
char	*DominicalLetter(year, style)
	int		year;
	calendar	style;
{
	static	char	val[3];
		int	letter;

	letter = 2 - year - year/4;
	if (style == Gregorian)
		letter += Solar(year);
	letter %= 7;
	if (letter < 0)
		letter += 7;
	val[2] = 0;
	val[1] = 'A' + letter;
	if (Leap(year,style) == 0)
		val[0] = ' ';
	else {
		letter = (letter+1) % 7;
		val[0] = 'A'+letter;
	}
	return val;
}

/*	Epact is the "age" of the moon on March 1st (same as January 1st);
 *	It (may have) derived from Greek methods of calculating the extra
 *	("epagomenal") months intercalated into the regular 12 at 7 points
 *	of the 19-year Metonic cycle.  However, it is not used in Julian
 *	easter calculations and is provided here only for Gregorian NewMoon.
 */
int	Epact(year)
	int	year;
{
	int	epact;

	epact = (11*GoldenNumber(year) - Solar(year) + Lunar(year)) % 30;
	if (epact < 0)
		epact += 30;
	return epact;
}

/*	Here's the hard one.  Keep in mind that there are several artificial
 *	conventions -- the equinox is ALWAYS March 21; new moon is ALWAYS the
 *	date on which a fictitious "average" moon is one day old, and the full
 *	moon is 13 days later, on the 14th of the month.  In the Julian version
 *	(and MOSTLY in the Gregorian) the pre-paschal month has 30 days.  All
 *	of this works out keeping fairly close to astronomical reality in the
 *	Gregorian case, but it is not necessarily exact.
 */
int	NewMoon(year, style)
	int		year;
	calendar	style;
{
	int	new_moon, epact;

	switch (style) {
		case Julian:
			new_moon = (4 - 11*GoldenNumber(year)) % 30;
			while (new_moon < 8)
				new_moon += 30;
			return new_moon;
		case Gregorian:
			epact = Epact(year);
			new_moon = 31-epact;
			if (new_moon < 8) {
				new_moon += 30;
				if (epact == 24 || epact == 25 && year%19 > 10)
					new_moon--;
			}
			return new_moon;
	}
}

int	PaschalMoon(year, style)
	int		year;
	calendar	style;
{
	return	(NewMoon(year,style) + 13);
}

/*	This gives day-of-the-week values [0..7] for dates refered to March 1st.
 */
char	*day[7] = {"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};

int	WeekDay(date, year, style)
	int	date;
{
	int	d;

	d = date + year + year/4;
	if (style == Gregorian)
		d -= Solar(year);
	return  (d % 7);
}

/*	Given the Paschal full moon, we just step to the next Sunday ...
 */
int	Easter(year, style)
	int		year;
	calendar	style;
{
	int	moon;

	moon = PaschalMoon(year, style);
	return (moon + 7 - WeekDay(moon, year, style));
}

/*	This prints out Dominical Letter, Pascal full moon (and its weekday)
 *	Easter Sunday and Ash Wednesday, for a given year in either calendar.
 */
PrintEaster(year, style)
	int		year;
	calendar	style;
{
	int	full_moon, easter;

	printf(" %s ", DominicalLetter(year, style));
	full_moon = PaschalMoon(year, style);
	printf(" %s ", day[ WeekDay(full_moon, year, style) ]);
	PrintDate(full_moon, year, style);
	easter = Easter(year, style);
	printf(" (");
	PrintDate(easter-46, year, style);
	printf(") ");
	PrintDate(easter, year, style);
}

/*	The program crams a whole bunch of data rather tightly on one line
 *	per year, either from 1583 to 2200, or between any start and stop
 *	dates you chose.  You may need to tinker to show only what you want.
 *	The Golden Number is printed next to the year, followed by the full
 *	moon, start of Lent, and Easter dates in the Julian calendar.  If
 *	you are in the range of the Gregorian calendar, the relevant data for
 *	that are also printed -- including a difference (d) to go from Julian
 *	to Gregorian civil dates, and the epact for Gregorian Easter computus.
 *	(For amusement, omit the if "(year > 1582) {}" and print extrapolated
 *	Gregorian dates back to Nicea.)
 *
 *	Note that in 1583 Gregorian Easter (April 10) was actually on the SAME
 *	day as Julian Easter (March 31 == April 10-10 == April 0).  Identity
 *	was maintained until the new version differs because the Julian full
 *	moon is on Gregorian March 17, too early for the (corrected) equinox.
 */
main(argc, argv)
	int	argc;
	char	*argv[];
{
	int	year, start = 1583, stop = 2200;

	if (argc == 3) {
		if ((start = atoi(argv[1])) < 1000)
			puts(WARNING);
		if ((stop = atoi(argv[2])) < start)
			stop = start;
	}
	else if (argc == 2)
		start = stop = atoi(argv[1]);

	printf(" year GN DL\tJulian Easter%s\n",
			stop<1583? "": "\t\t d epact DL\tGregorian Easter");
	printf("\t   full moon, Ash Wed., Easter%s\n\n",
			stop<1583? "": "\t\t    full moon, Ash Wed., Easter");

	for (year = start; year <= stop; year++) {
		printf("%4d %2d", year, GoldenNumber(year));
		PrintEaster(year, Julian);
		if (year > 1582) {
			printf("\t -%2d  %2d", Solar(year), Epact(year));
			PrintEaster(year, Gregorian);
		}
		putchar('\n');
	}
}
-- 
Michael L. Siemon		"It is no good talking to hobbits about
m.siemon@ATT.COM		dragons; they either disbelieve you, or
...!att!attunix!mls		feel uncomfortable; and in either case
standard disclaimer	  	tend to avoid you afterwards."  JRR Tolkien

Path: christian
Newsgroups: soc.religion.christian
From: bill@twg.bc.ca (Bill Irwin)
Subject: Re: When is easter?
Organization: The Westrheim Group, Vancouver, B.C., Canada
Approved: christian@aramis.rutgers.edu

jarrell@vtserf.cc.vt.edu (Ron Jarrell) writes:

: Does anyone know what the formula is for computing easter for any
: given year is?

Here is a program that I came across once for giving the date for
Easter.  I have no idea how it works, but it does work, from 1583
onwards.

#!/bin/sh
# Usage: easter YEAR
# Returns the date of Easter for the year given
#
if [ ! $# -eq 1 ]
then
        echo "Usage: $0 year"
        exit 1
fi
echo $* '[ddsf[lfp[too early
]Pq]s@1583>@
ddd19%1+sg100/1+d3*4/12-sx8*5+25/5-sz5*4/lx-10-sdlg11*20+lz+lx-30%
d[30+]s@0>@d[[1+]s@lg11<@]s@25=@d[1+]s@24=@se44le-d[30+]s@21>@dld+7%-7+
[March ]smd[31-[April ]sm]s@31<@psnlmPpsn1z>p]splpx' | dc | sed 'N
y/\n/ /'
# End
-- 
Bill Irwin    -       The Westrheim Group     -    Vancouver, BC, Canada
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
uunet!van-bc!twg!bill     (604) 431-9600 (voice) |     Your Computer  
bill@twg.bc.ca            (604) 430-4329 (fax)   |    Systems Partner


From usenet@agate.berkeley.edu  Thu May 21 20:19:14 1992
Received: from ucbvax.Berkeley.EDU by aramis.rutgers.edu (5.59/SMI4.0/RU1.4/3.08) 
	id AA25900; Thu, 21 May 92 20:19:14 EDT
Received: from mammoth.Berkeley.EDU by ucbvax.Berkeley.EDU (5.63/1.43)
	id AA00959; Thu, 21 May 92 17:19:38 -0700
Received: from agate.Berkeley.EDU by mammoth.Berkeley.EDU (5.61/1.37)
	id AA18696; Thu, 21 May 92 15:17:00 -0700
Received: by agate.berkeley.edu (5.64/1.33)
	id AA12757; Thu, 21 May 92 15:15:06 -0700
Date: Thu, 21 May 92 15:15:06 -0700
From: usenet@agate.berkeley.edu (USENET Administrator)
Message-Id: <9205212215.AA12757@agate.berkeley.edu>
To: soc-religion-christian@ucbvax.berkeley.edu
Subject: Easter

Path: chaos.berkeley.edu!conan
From: conan@chaos.berkeley.edu (David Cruz-Uribe)
Newsgroups: soc.religion.christian
Subject: Easter
Date: 21 May 1992 22:15:05 GMT
Organization: U.C. Berkeley Math. Department.
Lines: 119
Message-ID: <vh7d9INNcej@agate.berkeley.edu>
NNTP-Posting-Host: chaos.berkeley.edu

[I posted this earlier, but it never got to back to my site,
so I presume the net ate it.  Please excuse me if this is a
duplicate post.]

Recent posts have discussed the dating of Easter.  While this
has been discussed extensively in the past, I had not saved any
of the detailed posts, so I was forced to the library for more
information.  I thought I would attempt to summarize what
I found.  I make no claims at completeness and only moderate
ones for accuracy.  I would welcome additional information and
references, especially from the Orthodox perspective.

[To the moderator:  is there an FAQ on this subject?  It seems
to come up once a year for some reason :-)]

In the early church, the date of Easter fell into two camps:
in Asia Minor it was celebrated on 14 Nissan (the date of 
Passover) or the Sunday following;  in Alexandria an independent
calculation was made based on the vernal equinox.  This method
spread to Rome and to many parts of the Western Church.  This
difference developed into a controversy which was addressed at
the First Council of Nicea, which established the following
rule:  Easter should be celebrated on the Sunday after the
first full moon following the spring equinox.

The exact canons of the council on this subject did not survive from
antiquity; their substance is known from later or nearly contemporary
sources.  Differences quickly arose between East and West over the
calculational method to be used.  In 525, through the work of
Dionysius Exiguus, Rome adopted the Alexandrian method used in
the East.  (A summary of this method can be found in the most
recent Encyclopedia Brittanica.)  There were several more
controversies in the West, all of which were apparently resolved
well before 1000.

Sometime during this period a new difference arose between East 
and West to the dating of Easter.  The East adopted the practice
that Easter could not be celebrated on or before the Jewish Passover.
This was canonically formulated and became the universal practice
following the work of the Byzantine jurist Ioannes Zonoras. 
(* PLEASE SEE BELOW FOR MORE DETAILS *)

The final difference between East and West resulted from the calendar
reforms of Pope Gregory.  As part of reforming the Julian calendar,
the method for calculating Easter (which boils down to a method of
harmonizing the lunar and solar calendars) was also revised.  These
changes, which lead to some variations in determining the vernal
equinox and the full moon following, combined with the above proviso
about Passover, are what cause the differences in calculating Easter
between East and West.  (The East still uses the older method and
works off of the Julian calendar.)

As a postscript, I would like to add more about the Passover
proviso.  Frankly, seeing how contentious this issue is on the
net, I was _very_ surprised to find an Orthodox source describe it
as being a later addition to the original canons.  I found this
in the book _A Dictionary of Greek Orthodoxy_, Rev. Nicon D. 
Patrinacos, Hellenic Heritage Publications, Pleasantville NY.  I
have no idea how authoritative this book is:  it was a reference
work at the Graduate Theological Union Library in Berkeley, and
it comes with an approving forward by Archbishop Iakovos, Primate
of the Greek Orthodox Church in the Americas.  I found this book
on the whole to be informative and temperate in its approach to
issues which separate Catholic and Orthodox, and I would appreciate
it if someone could comment on its reliability.

On this issue, let me quote at length from the article on Easter:

=== Begin Quote ===

Controversies and enmities began to develop to the point that
one of the more important items on the agenda of the First
Ecumenical Council at Nicaea (325) was the discussion and deciding
of the date when all Christians should celebrate the day of the
Resurrection.  The decision of this important Council regulating
the day Easter should be observed by all has not survived either
in the form of a Canon or in any other kind of entry....It appears
[from other sources] that the first concern of the Council as
regards the celebration of Easter was to avoid connecting it in
any way wiht the day of the Jewish Passover.  And though the 
increasing hostility of the Christians against the Jews in
subsequent centuries resulted in misunderstanding the decision
of the Council on the day of Easter, it has been recently resolved
by scholars that the Council did not issue or even hint at the
much later mentioned proviso by which Easter cannot be celebrated
before the Jewish Passover....The objection of people to celebrating
Easter with or before the Jewish Passover culminated in its being
canonically tabulated by the famous Byzantine jurist Ioannes
Zonaras [in the] 12th century, as follows:  Easter is to be
celebrated on the Sunday after the first full moon following the
spring equinox, provided that the Jewish Passover has already
been celebrated.

=== End Quote ===

Now Mark Gilstrap (I believe) had posted references to later 
canons (which I forgot :-(), but this source makes no reference
to them.  I could not find any other reference which dealt with
this matter.  (However, I must confess that I did not have
access to many Orthodox works:  they are kept at a different
site and an appointment is needed to see them.)  I would be
interested in more information on this question, since it is
one of two factors which keeps East and West apart on Easter.

The article did go on this discuss proposals put forward by
the Geneva Consultation (held in 1977 by the Secretariat for
preparing the Great Council of the Orthodox Churches) to resolve
this matter.  They proposed that the Passover proviso be dropped,
and that the Churches ask eminent astronomers to draw up tables
of the vernal equinox and the full moon to date Easter--said
tables would supercede the Eastern system (and hopefully in
agreement with the West) the Western, resulting in a uniform
date for Easter.  However, these recommendations were 
rejected by the second Geneva Consultation in 1982.

Yours in Christ, 

David Cruz-Uribe, SFO