Holidays related to Easter: Difference between revisions

For maximum compatibility, this program uses only the basic instruction set (S/360)

and two ASSIST macros (XDECO, XPRNT) to keep the code as short as possible.

HOLIDAYS CSECT

USING HOLIDAYS,R13 base register

XDEC DS CL12 temp for edit

YREGS

{{out}}

<pre>

=={{header|Ada}}==

Ada.Calendar can only handle years in the range 1901 to 2399.

with Ada.Calendar.Formatting;

with Ada.Text_IO;

Print_Easter (I);

end loop;

output:

Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.

-->

MODE DATE = STRUCT(

printf (($l"Christian holidays, related to Easter, for years from 2010 to 2020 CE:"l$));

Output:

<pre>

=={{header|BASH}}==

#! /bin/bash

# Carter's calendar algorithm: https://web.archive.org/web/19990117015544/http://www.ast.cam.ac.uk/pubinfo/leaflets/easter/easter.html

done

<pre>

2020-04-12

{{works with|BBC BASIC for Windows}}

As discussed on the Talk page, the task is not well defined for historical dates because the change from the Julian to the Gregorian calendar happened on different dates in different regions. Therefore only dates from 1800 onwards are output, by which time most countries (particularly those likely to celebrate the Christian Easter) had adopted the Gregorian calendar.

PRINT "Year Easter Ascension Pentecost Trinity Corpus"

e% -= ((year% MOD 7) + b% - d% + e% + 2) MOD 7

d% = e% >>> 5

'''Output:'''

<pre>

This program switches calendar from Julian to Gregorian during October 1582. Its algorithm takes from [http://www.merlyn.demon.co.uk/zel-1886.htm ''Kalendar-Formeln'' by Zeller (1886)].

/* Format d days after March 21. Assumes March, April, May or June. */

for (year = 2010; year <= 2020; year += 1) z = easter(year)

z = easter(2100)

{{out}}

This program switches calendar from Julian to Gregorian during March 1924. Pentecost and Trinity Sunday are the same day; [[wp:All Saints' Sunday|All Saints' Sunday]] is the next Sunday.

/* Format d days after March 21. Assumes March, April, May or June. */

for (year = 2010; year <= 2020; year += 1) z = easter(year)

z = easter(2100)

{{out}}

First two rows initialise the set of years to be processed; second two output the header; the main algorithm starts on row six.

^\+*"(2":< ^\*"d":< >$ v

v"Pentcst"9"Trinity"9"Corpus"+550<

>"'"\>:9\>:156*+`!#v_156*+-\3v>$$^

+9,^ ^\+3\-*65_v#`*65:\+ <^_

{{out}}

<pre>Year Easter Ascensn Pentcst Trinity Corpus

{{trans|ALGOL 68|Note: This specimen retains the original [[Holidays related to Easter#ALGOL 68|ALGOL 68]] coding style -

[http://rosettacode.org/mw/index.php?title=Holidays_related_to_Easter&diff=85840&oldid=85839 diff].}}

typedef int year_t, month_t, week_t, day_t;

for(year=2010; year<=2020; year++){ easter_related_print(year); }

return 0;

Output:

<pre>

{{works with|C sharp|3.0}}

using System.Collections;

using System.Collections.Specialized;

}

}

Output:

=={{header|COBOL}}==

identification division.

program-id. Easter.

move holiday-day to edt-day

.

{{out}}

Implemented the task for 1700 and greater years because COBOL is a Business language and their routines only works after Day zero that is equals to 00:00:00 31 December 1600

=={{header|Common Lisp}}==

;

; See:

(setq m (floor (+ a (* 11 h) (* 22 l)) 451))

(multiple-value-setq (n p) (floor (+ h l (- 114 (* 7 m))) 31))

=={{header|D}}==

{{trans|C sharp}}

void printEasterRelatedHolidays(in int year) {

foreach (immutable y; 2010 .. 2021)

printEasterRelatedHolidays(y);

{{out}}

<pre>Christian holidays, related to Easter, for each centennial from 400 to 2100 CE:

{{libheader| System.SysUtils}}

{{Trans|D}}

program Holidays_related_to_Easter;

printEasterRelatedHolidays(y);

readln;

=={{header|Elixir}}==

{{trans|Ruby}}

@offsets [ Easter: 0, Ascension: 39, Pentecost: 49, Trinity: 56, Corpus: 60 ]

@mon { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }

end

{{out}}

=={{header|Erlang}}==

{{trans|Elixir}}

-export([task/0]).

task(Year, Max, Step) ->

holidays(Year),

{{out}}

Factor already has an <code>easter</code> word in its <code>calendar</code> vocabulary, but is has been re-implemented here as it seems in the spirit of the task.

{{works with|Factor|0.99 2019-10-06}}

sequences ;

400 2100 100 holidays nl

{{out}}

<pre>

=={{header|Forth}}==

variable year

LOOP

;

Output:

<pre>

=={{header|Fortran}}==

c Easter sunday

c

month=n/31

day=mod(n,31)+1

=={{header|Fōrmulæ}}==

{{trans|ALGOL 68}}

This solution takes the ALGOL 68 as a reference solution, using its math for calculating the holidays, and reproducing its output.

import (

newEasterRelated(y).print()

}

Output:

<pre>

Aside from the already noted issues and inconsistencies with extending these calculations back centuries, the calculation of the correct and proper date of Easter has historically been responsible for massive conflict in Western history including excommunications, near wars, and contributing to the splitting of the Catholic Church. For more see [http://mangsbatpage.433rd.com/2008/03/calculating-easter.html Calculating Easter @ Mang's Bat Page].

procedure main()

}

return dr

Output:<pre>Christian holidays, related to Easter, for each centennial from 400 to 2100 CE:

This code is based on the above rationale, and http://www.merlyn.demon.co.uk/estr-bcp.htm and the wikipedia pages referenced in the task description:

pfm=. 21 + 30 | _4 + 19 * 1 + 19|y

sn=. 6 - 7 | 4 + <.@*&1.25 y

dys=. 1 40 50 50 +/~sn (] + 7 | 4 + -) pfm

y,"0 1(+/\0 0 0 31 30 31 30) (I.,"0]-<:@I.{[) dys

Required example:

output:

<pre style="height: 24ex; overflow: scroll"> 400 4 1

Nevertheless, here is an implementation which reproduces those numbers, based on the same resource I used for the Julian easters:

ce =. <. y%100

GN =. 1 + 19 | y

dys=. 0 39 49 56 60 +/~ DM + 1 + 7 | 60+SN-DM

y,"0 1(+/\0 0 0 31 30 31 30) (I.,"0]-<:@I.{[) dys

And here is the required example (and note that I am including the same Corpus Christi feast date here that others are using, because that makes sense with recent Gregorian dates even though it is a nonsense value for earlier dates):

output (in each block of dates, they are, in order Easter, Ascension Thursday, Pentecost, Trinity Sunday, and Corpus Christi feast):

<pre style="height: 24ex; overflow: scroll"> 400 4 2

=={{header|Java}}==

Translation of C Sharp via D

import java.util.*;

System.out.println();

}

Output:

=={{header|JavaScript}}==

(English version courtesy of google translate below)

let дата = (год % 19 * 19 + 15) % 30;

дата += (год % 4 * 2 + год % 7 * 4 + 6 * дата + 6) % 7;

);

}

Output:

=== English version ===

(same output)

let date = (year % 19 * 19 + 15) % 30;

date += (year % 4 * 2 + year % 7 * 4 + 6 * date + 6) % 7;

}).join("; ") + ".<br />"

);

=== Universal algorithm ===

/* year: a number of the year (from 325 CE);

church: an algorithm of the computus,

for (let year = 400; year <= 2100; year += year < 2000 ? 100 : year >= 2021 ? 80 : year < 2010 ? 10 : 1)

=={{header|Julia}}==

using Dates

for yr in 2010:2020

println(holiday2str(yr))

{{out}}

=={{header|Kotlin}}==

{{trans|C#}}

import java.util.Calendar

println()

for (year in 2010..2020) outputHolidays(year)

{{out}}

=={{header|Lua}}==

The function 'easter' is a Lua translation of a C function by Claus Tøndering. This script relies heavily on the 'time' library, available from scilua.org. Dates before 1582 are not supported.

function div (x, y) return math.floor(x / y) end

print("Year\tEaster\tAscen.\tPent.\tTrinity\tCorpus")

for year = 1600, 2100, 100 do show(year, holidays(year)) end

Output:

<pre>Year Easter Ascen. Pent. Trinity Corpus

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Map[StringJoin[ToString[#]," Easter: ",DateFormat[EasterSunday[#]],

", Ascension: ",DateFormat[DaysPlus[EasterSunday[#],39]],

2018 Easter: Sun 1 April, Ascension: Thu 10 May, Pentecost: Sun 20 May, Trinity: Sun 27 May, Corpus: Thu 31 May,

2019 Easter: Sun 21 April, Ascension: Thu 30 May, Pentecost: Sun 9 June, Trinity: Sun 16 June, Corpus: Thu 20 June,

=={{header|Maxima}}==

See:

f:quotient(b+8,25),g:quotient(b-f+1,3),h:remainder(19*a+b-d-g+15,30),

[i,k]:divide(c,4),l:remainder(32+2*e+2*i-h-k,7),m:quotient(a+11*h+22*l,451),

=={{header|МК-61/52}}==

П4 ИП2 7 ПП 86 П5 1 9 ИП3 *

1 5 + 3 0 ПП 86 П6 2 ИП4

- x>=0 76 П3 КИП4 ИП3 3 0 - x>=0

83 П3 КИП4 ИП3 ИП4 С/П П0 <-> П1 <->

Calculated, of course, the Orthodox Easter. Enter the number of the year, the result of: the day in the register Y, a month in the register X.

For the subsequent calculation of Ascension and Pentecost (Trinity Day):

1 - x>=0 19 П1 ИП0 1 + П0 ИП0

1 + П0 ИП1 ИП0 С/П ИП1 1 0 +

П1 3 1 - x>=0 41 П1 ИП0 1 +

''Example'': Easter in 2014 is 20.04; Ascension is 29.05; Pentecost is 08.06.

=={{header|Nim}}==

{{trans|Kotlin}}

const HolidayOffsets = {"Easter": 0, "Ascension": 39, "Pentecost": 49,

for year in countup(400, 2100, 100): outputHolidays(year)

echo ""

{{out}}

Code handles Gregorian / Julian holidays and dates correctly. Calendar reform was 1582-10-04.

* Normalized Julian Day Number from date (base 1899-12-30 00:00:00)

* D = Vec [year, month, day]

print("\nChristian holidays, related to Easter, for years from 2010 to 2020 CE:");

for (y = 2010, 2020, holiday(y));

Output:

use strict; use warnings;

cholidays($_) for(2010..2020);

Output:

The Phix timedate routines make no attempt to support pre-1752 dates, but the algorithm seems to work.<br>

(Note: that pre-1752 part got itself broken on 0.8.1, but is back working on the as-yet-unreleased 0.8.2)

<span style="color: #000080;font-style:italic;">-- demo\rosetta\Easter.exw</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">easter</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">year</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">show</span><span style="color: #0000FF;">(</span><span style="color: #000000;">year</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

=={{header|PicoLisp}}==

(de dayMon (Dat)

", Pentecost: " (dayMon (+ E 49))

", Trinity: " (dayMon (+ E 56))

Output:

<pre> 400 Easter: Sun 2 Apr, Ascension: Thu 11 May, Pentecost: Sun 21 May, Trinity: Sun 28 May, Corpus: Thu 1 Jun

=={{header|PL/I}}==

Easter: procedure options (main);

declare months(12) character (9) varying static initial (

end Easter_Sunday;

Results:

<pre>

=={{header|PowerShell}}==

function Get-Easter

{

}

}

$years = for ($i = 400; $i -le 2100; $i+=100) {$i}

$years0400to2100 = $years | Get-Easter

Write-Host "Christian holidays, related to Easter, for years from 2010 to 2020 AD:"

$years2010to2020 | Format-Table

{{Out}}

<pre>

=={{header|PureBasic}}==

C_DAYS:

Data.i 0,39,49,56,60

PrintN("")

For i=2010 To 2020 : PutTab(i) : PrintN(r$) : Next

{{out}}

<pre>Year Easter Ascension Pentecost Trinity C/Christi

Unfortunately, at present Python doesn't support date formatting for any dates before 1900. So while it is trivial to get the date for easter, it takes a bit more work to format the date.

import datetime, calendar

print_holidays(get_holiday_values(year))

Output:

=={{header|R}}==

library(tidyverse)

library(lubridate)

`Corpus Christi` = Trinity + 4,

across(.fns = pretty_date))

{{out}}

<pre>

(formerly Perl 6)

{{trans|Perl}}

my @holidays =

for flat (400,500 ... 2000), (2010 ... 2020), 2100 -> $year {

cholidays($year);

{{out}}

<pre> 400: Easter: 02 Apr, Ascension: 11 May, Pentecost: 21 May, Trinity: 28 May, Corpus: 01 Jun

=={{header|REXX}}==

* Test frame for computing Christian (Roman Catholic) holidays, related to Easter

* 16.04.2013 Walter Pachl

month=n%31

day=n//31+1

Output:

<pre>Christian holidays, related to Easter, for each centennial from 400 to 2200 CE:

{{works with|Ruby|1.8.7}}

def easter_date(year)

400.step(2100, 100).each {|year| emit_dates year}

puts

outputs

=={{header|Rust}}==

use std::ops::Add;

}

}

{{out}}

<pre>

=={{header|Scala}}==

{{trans|bc}}

import scala.swing._

size = new java.awt.Dimension(600, 400)

visible = true

=={{header|Scheme}}==

;

; See:

(m (quotient (+ a (* 11 h) (* 22 l)) 451))

(n (+ h l (- 114 (* 7 m)))))

=={{header|Seed7}}==

include "time.s7i";

include "duration.s7i";

writeHolidays(year);

end for;

Original source of the function easterDate, which uses the Gauss formula: [http://seed7.sourceforge.net/algorith/date.htm#easterDate]

=={{header|Sidef}}==

{{trans|Raku}}

var abbr = < Nil Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec >

for year in (400..2100 `by` 100, 2010..2020) {

cholidays(year)

=={{header|Tcl}}==

# Easter computation code from http://www.assa.org.au/edm.html

for {set year 2010} {$year <= 2020} {incr year} {

puts [DateInfo $year]

Output:

<pre>

=={{header|TUSCRIPT}}==

For dates before October 15, 1582 the Julian Calendar is taken as basis.

$$ MODE TUSCRIPT

SET years=*

ENDLOOP

ENDLOOP

Output:

<pre style='height:30ex;overflow:scroll'>

=={{header|VBA}}==

Private Function easter(year_ As Integer) As Date

'-- from https://en.wikipedia.org/wiki/Computus#Anonymous_Gregorian_algorithm

show year_

Next year_

<pre> Easter Ascension Pentecost Trinity Corpus

400 zo 02 apr do 11 mei zo 21 mei zo 28 mei do 01 jun

{{libheader|Wren-fmt}}

{{libheader|Wren-trait}}

import "/fmt" for Fmt

import "/trait" for Stepped

for (year in Stepped.new(400..2100, 100)) outputHolidays.call(year)

System.print()

{{out}}