Está en la página 1de 22

Implementación del algoritmo de cálculo de la

fecha de Pascua en los diferentes lenguajes de programación.


Índice
• 1 Algoritmo en Java
• 2 Algoritmo en Javascript
• 3 Algoritmo en C#
• 4 Algoritmo en Python
• 5 Algoritmo en Perl
• 6 Algoritmo en PHP
• 7 Algoritmo en Turbo Pascal
• 8 Algortimo en pl/pgsql de postgresql
• 9 Algoritmo en Delphi
• 10 Algoritmo en Ruby
• 11 Algoritmo en PowerBuilder
• 12 Cálculo en SQL Anywhere (Transact SQL)
• 13 Cálculo en EXCEL
• 14 Algoritmo en Fortran 9X
• 15 Algoritmo en PL SQL Oracle
• 16 Algoritmo en Visual Basic
• 17 Algoritmo en SQL Server (2008-2014)
• 18 Referencias

Algoritmo en Java
import java.util.Date;
import java.util.Calendar;

public class Pascua {

private static int M=24;


private static int N=5;

private int anno;

/* Constructor de Pascua */
public Pascua(int anno) {
if (anno >= 1583 && anno <= 1699){
M = 22;
N = 2;
}else if ( anno >=1700 && anno <= 1799){
M = 23;
N = 3;
}else if ( anno >=1800 && anno <= 1899){
M = 23;
N = 4;
}else if ( anno >=1900 && anno <=2099){
M = 24;
N = 5;
}else if ( anno >=2100 && anno <=2199){
M= 24;
N= 6;
}else if ( anno>=2200 && anno <= 2299){
M= 25;
N= 0;
}
this.anno = anno;
}

public Date getFechaPascua(){


int a,b,c,d,e,dia,mes;

//Cálculo de residuos
a = anno % 19;
b = anno % 4;
c = anno % 7;
d = (19*a + M) % 30;
e = (2*b+4*c+6*d + N) % 7;

// Decidir entre los 2 casos:


if (d+e < 10) {
dia = d+e+22;
mes = Calendar.MARCH;
}else{
dia = d+e-9;
mes = Calendar.APRIL;
}

// Excepciones especiales (según artículo)


if (dia == 26 && mes == Calendar.APRIL)
dia = 19;
if (dia == 25 && mes == Calendar.APRIL && d==28 && e == 6 && a >10)
dia = 18;

Calendar fechaPascua = Calendar.getInstance();


fechaPascua.set(Calendar.DAY_OF_MONTH,dia);
fechaPascua.set(Calendar.MONTH,mes);
fechaPascua.set(Calendar.YEAR,this.anno);

return fechaPascua.getTime();
}

public static void main (String [] args){


Pascua pascua = new Pascua(2009);

System.out.println(java.text.DateFormat.getDateInstance().format(pascua.getFechaPas
cua()));
}
}
Esta es la salida al ejecutar el código anterior.
12/04/2009

Algoritmo en Javascript
function pascua($annio) {
if ($annio>1583 && annio<1699) { $M=22; $N=2; }
else if ($annio>1700 && annio<1799) { $M=23; $N=3; }
else if ($annio>1800 && annio<1899) { $M=23; $N=4; }
else if ($annio>1900 && annio<2099) { $M=24; $N=5; }
else if ($annio>2100 && annio<2199) { $M=24; $N=6; }
else if ($annio>2200 && annio<2299) { $M=25; $N=0; }
$a = $anio % 19;
$b = $anio % 4;
$c = $anio % 7;
$d = ((19*$a) + $M) % 30;
$e = ((2*$b) + (4*$c) + (6*$d) + $N) % 7;
$f = $d + $e;
if ($f < 10) {
$dia = $f + 22;
$mes = 3;
} else {
$dia = $f - 9;
$mes = 4;
};
if ($dia == 26 && $mes == 4){
$dia = 19;
};
if ($dia == 25 && $mes == 4 && $d == 28 && $e == 6 && $a > 10){
$dia = 18;
};
$pascua = new Date($anio,$mes,$dia);
return $pascua;
};

Algoritmo en C#
/// <summary>
/// Método que devuelve el Domingo de Pascua dado un año a consultar.
/// </summary>
/// <param name="anyo">Año a consultar.</param>
/// <returns>Día del año que es Domingo de Pascua.</returns>
public static DateTime GetEasterSunday(int anyo)
{
int M = 25;
int N = 5;

if (anyo >= 1583 && anyo <= 1699) { M = 22; N = 2; }


else if (anyo >= 1700 && anyo <= 1799) { M = 23; N = 3; }
else if (anyo >= 1800 && anyo <= 1899) { M = 23; N = 4; }
else if (anyo >= 1900 && anyo <= 2099) { M = 24; N = 5; }
else if (anyo >= 2100 && anyo <= 2199) { M = 24; N = 6; }
else if (anyo >= 2200 && anyo <= 2299) { M = 25; N = 0; }

int a, b, c, d, e, dia, mes;


//Cálculo de residuos
a = anyo % 19;
b = anyo % 4;
c = anyo % 7;
d = (19 * a + M) % 30;
e = (2 * b + 4 * c + 6 * d + N) % 7;

// Decidir entre los 2 casos:


if (d + e < 10) { dia = d + e + 22; mes = 3; }
else { dia = d + e - 9; mes = 4; }

// Excepciones especiales
if (dia == 26 && mes == 4) dia = 19;
if (dia == 25 && mes == 4 && d == 28 && e == 6 && a > 10) dia = 18;

return new DateTime(anyo, mes, dia);


}

static void Main()


{
DateTime domingo = GetEasterSunday(2014);
DateTime jueves = domingo.AddDays(-3);
DateTime viernes = domingo.AddDays(-2);
DateTime lunes = domingo.AddDays(+1);

//Console.WriteLine(domingo);
Console.WriteLine("Jueves Santo -> " + jueves.ToShortDateString());
Console.WriteLine("Viernes Santo -> " + viernes.ToShortDateString());
Console.WriteLine("Lunes de Pascua -> " + lunes.ToShortDateString());
}

Esta es la salida al ejecutar el código anterior.


// Jueves Santo -> 17/04/2014
// Viernes Santo -> 18/04/2014
// Lunes de Pascua -> 21/04/2014

Algoritmo en Python
La siguiente es una implementación del algoritmo anterior en el lenguaje Python, siguiendo fielmente
los pasos descritos en el algoritmo anterior.
#coding: latin-1

def Pascua(anno):
# Constantes mágicas
M = 24
N = 5

#Cálculo de residuos
a = anno % 19
b = anno % 4
c = anno % 7
d = (19*a + M) % 30
e = (2*b+4*c+6*d + N) % 7

# Decidir entre los 2 casos:


if d+e < 10 :
dia = d+e+22
mes = "marzo"
else:
dia = d+e-9
mes = "abril"

# Excepciones especiales (según artículo)


if dia == 26 and mes == "abril":
dia = 19
if dia == 25 and mes == "abril" and d==28 and e == 6 and a >10:
dia = 18

return [dia, mes, anno]

print Pascua(2008)

El resultado de ejecutar el programa anterior sería


[23, 'marzo',2008]

Otra forma sería


#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys

# Magic constants
# Años M N
# 1583-1699 22 2
# 1700-1799 23 3
# 1800-1899 23 4
# 1900-2099 24 5
# 2100-2199 24 6
# 2200-2299 25 0

def easter(year):
# Calculation of the Magic constants
if (year>=1583 and year<1700):
M=22
N=2
if (year>=1700 and year<1800):
M=23
N=3
if (year>=1800 and year<1900):
M=23
N=4
if (year>=1900 and year<2100):
M=24
N=5
if (year>=2100 and year<2200):
M=24
N=6
if (year>=2200 and year<2300):
M=25
N=0

# Calculating variables
a = year%19
b = year%4
c = year%7
d = (19*a + M)%30
e = (2*b + 4*c + 6*d + N)%7

date=()

if (d+e<10):
date = ('marzo', d+e+22)
else:
date = ('abril', d+e+-9)

# Calculating Exceptions
if (date[0]=='abril') and ((date[1]==25 and d==28 and e==6 and a>10) or
(date[1]==26)):
date = (date[0], date[1]-7)

return date

if __name__ == '__main__':
year = int(sys.argv[1])
date = easter(year)
print('El %d, Pascua es el %d de %s' % (year, date[1], date[0]))

Algoritmo en Perl
Tomando el algoritmo anterior y pasándolo al lenguaje Perl, Tendríamos algo así:
#perl
#ejecutarlo pasando el año como parámetro.

printf "La pascua es: %s %s %d\n", Pascua( shift );

sub Pascua {
# Constantes mágicas
$M = 24;
$N = 5;

$anno = shift;
#Cálculo de residuos
$a = $anno % 19;
$b = $anno % 4;
$c = $anno % 7;
$d = (19*$a + $M) % 30;
$e = (2*$b+4*$c+6*$d + $N) % 7;

# Decidir entre los 2 casos:


if ( $d + $e < 10 ) {
$dia = $d + $e + 22;
$mes = "marzo";
}
else {
$dia = $d + $e - 9;
$mes = "abril";
}

# Excepciones especiales (según artículo)


if ( $dia == 26 and $mes == "abril" ) {
$dia = 19;
}
if ( $dia == 25 and $mes == "abril" and $d==28 and $e == 6 and $a >10 ) {
$dia = 18;
}

return ( $dia, $mes, $anno );


}

El resultado de ejecutar: % perl pascua.pl 2008


La pascua es: 23 de marzo de 2008

Algoritmo en PHP
(PHP tiene una función propia llamada easter_date() que calcula el día del Domingo de Resurrección).
1

En el siguiente algoritmo, a diferencia de los otros este no solo obtiene la fecha del domingo de pascua
sino también todas las demás fechas de la pascua tales como: Domingo de Pascua, Miércoles de ceniza,
Domingo de Ramos, Jueves y Viernes Santo, Ascensión, Pentecostés, Santísima Trinidad y Corpus
Christi
Tomando los algoritmos anteriores e implementándolo en PHP con salida a HTML tenemos:
<?php
function pascua ($anno){
# Constantes mágicas
$M = 24;
$N = 5;
#Cálculo de residuos
$a = $anno % 19;
$b = $anno % 4;
$c = $anno % 7;
$d = (19*$a + $M) % 30;
$e = (2*$b+4*$c+6*$d + $N) % 7;
# Decidir entre los 2 casos:
if ( $d + $e < 10 ) {
$dia = $d + $e + 22;
$mes = 3; // marzo
}
else {
$dia = $d + $e - 9;
$mes = 4; //abril
}
# Excepciones especiales (según artículo)
if ( $dia == 26 and $mes == 4 ) { // 4 = abril
$dia = 19;
}
if ( $dia == 25 and $mes == 4 and $d==28 and $e == 6 and $a >10 ) { // 4 =
abril
$dia = 18;
}
$ret = $dia.'-'.$mes.'-'.$anno;
return ($ret);
}

function mesespanol($m){
$m=intval($m);
$meses="No
Especificado,Enero,Febrero,Marzo,Abril,Mayo,Junio,Julio,Agosto,Septiembre,Octubre,N
oviembre,Diciembre";
$mes=explode(",",$meses);
$mesespan=$mes[$m];
return $mesespan;
}
function diaespanol($d){
$d=intval($d);
$dias="No
Especificado,Lunes,Martes,Miercoles,Jueves,Viernes,Sabado,Domingo";
$dia=explode(",",$dias);
$diasspan=$dia[$d];
return $diasspan;
}
?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title>Calcular Semana Santa | Pascua | PHP</title>
</head>

<body>
<center>
<h1>Calcular Pascua:</h1>
<form action="index.php" name="forma" method="post">
<font face="Arial, Helvetica, sans-serif" size="2">
Año: <input type="text" name="anno" size="5" maxlength="4"
value="<?php if(intval($_POST['anno']) > 0){ echo intval($_POST['anno']); }
else{ echo date("Y"); }?>">
<input type="submit" name="Go!" value="Calcular!">
</font>
</form>
</center>
<?php
#ejecutarlo pasando el año como parámetro.
if (isset($_POST['anno'])) {
$fecha = explode('-',pascua($_POST['anno']));
?><br />
<div align=center><font face=arial>
La pascua (domingo de resurrección)
en el año introducido es el:
<strong><?php echo $fecha[0]; ?> de <?php echo mesespanol($fecha[1]); ?> de <?php
echo $fecha[2]; ?></strong><br /><br />
<br />
<table width="400" cellspacing="0" cellpadding="0" style="margin:0px auto;">
<tr>
<td colspan="3" align="center"><strong>Fechas especiales:</strong></td>
</tr>
<tr>
<td colspan="3">&nbsp;</td>
</tr>
<tr bgcolor="#CCCCCC">
<td align="left"><strong><font
face="arial">Celebracion</font></strong></td>
<td align="center"><strong>Dia</strong></td>
<td align="center"><strong>Fecha</strong></td>
</tr>
<tr>
<td align="left"><strong>Domingo de Pascua</strong></td>
<td align="center"><?php echo diaespanol(date("N",
mktime(0,0,0,$fecha[1],$fecha[0],$fecha[2]))); ?></td>
<td align="center"><?php echo date("d/m/Y", mktime(0,0,0,$fecha[1],
$fecha[0],$fecha[2])); ?></td>
</tr>
<tr>
<td align="left">Mi&eacute;rcoles de ceniza</td>
<td align="center"><?php echo diaespanol(date("N",
mktime(0,0,0,$fecha[1],$fecha[0]-46,$fecha[2]))); ?></td>
<td align="center"><?php echo date("d/m/Y", mktime(0,0,0,$fecha[1],
$fecha[0]-46,$fecha[2])); ?></td>
</tr>
<tr>
<td align="left">Domingo de Ramos</td>
<td align="center"><?php echo diaespanol(date("N",
mktime(0,0,0,$fecha[1],$fecha[0]-7,$fecha[2]))); ?></td>
<td align="center"><?php echo date("d/m/Y", mktime(0,0,0,$fecha[1],
$fecha[0]-7,$fecha[2])); ?></td>
</tr>
<tr>
<td align="left"><strong>Jueves Santo</strong></td>
<td align="center"><?php echo diaespanol(date("N",
mktime(0,0,0,$fecha[1],$fecha[0]-3,$fecha[2]))); ?></td>
<td align="center"><?php echo date("d/m/Y", mktime(0,0,0,$fecha[1],
$fecha[0]-3,$fecha[2])); ?></td>
</tr>
<tr>
<td align="left"><strong>Viernes Santo</strong></td>
<td align="center"><?php echo diaespanol(date("N",
mktime(0,0,0,$fecha[1],$fecha[0]-2,$fecha[2]))); ?></td>
<td align="center"><?php echo date("d/m/Y", mktime(0,0,0,$fecha[1],
$fecha[0]-2,$fecha[2])); ?></td>
</tr>
<tr>
<td align="left">Ascensi&oacute;n</td>
<td align="center"><?php echo diaespanol(date("N",
mktime(0,0,0,$fecha[1],$fecha[0]+39,$fecha[2]))); ?></td>
<td align="center"><?php echo date("d/m/Y", mktime(0,0,0,$fecha[1],
$fecha[0]+39,$fecha[2])); ?></td>
</tr>
<tr>
<td align="left">Pentecost&eacute;s</td>
<td align="center"><?php echo diaespanol(date("N",
mktime(0,0,0,$fecha[1],$fecha[0]+49,$fecha[2]))); ?></td>
<td align="center"><?php echo date("d/m/Y", mktime(0,0,0,$fecha[1],
$fecha[0]+49,$fecha[2])); ?></td>
</tr>
<tr>
<td align="left">Sant&iacute;sima Trinidad</td>
<td align="center"><?php echo diaespanol(date("N",
mktime(0,0,0,$fecha[1],$fecha[0]+56,$fecha[2]))); ?></td>
<td align="center"><?php echo date("d/m/Y", mktime(0,0,0,$fecha[1],
$fecha[0]+56,$fecha[2])); ?></td>
</tr>
<tr>
<td align="left">Corpus Christi</td>
<td align="center"><?php echo diaespanol(date("N",
mktime(0,0,0,$fecha[1],$fecha[0]+60,$fecha[2]))); ?></td>
<td align="center"><?php echo date("d/m/Y", mktime(0,0,0,$fecha[1],
$fecha[0]+60,$fecha[2])); ?></td>
</tr>
</table>
<br />
</font></div>
<?php }?>
</div>
</body>
</html>

Algoritmo en Turbo Pascal


program fechadesemanasanta;
uses crt;
var
anno, a, b, c, d, e, res, F, G: integer;
begin
clrscr;
Textmode(12);
Textcolor(10);
write('Ingrese número de anno entre 1900 y 2099: ');
readln (anno);
a:= anno mod 20;
b:= anno mod 0;
c:= anno mod 8;
d:= (19*a + 24) mod 30;
e:= (2*b + 4*c + 6*d + 5) mod 7;
writeln('Resultado de A es: ', a);
writeln('Resultado de B es: ', b);
writeln('Resultado de C es: ', c);
writeln('Resultado de D es: ', d);
writeln('Resultado de E es: ', e);
res:= d+e;
writeln('Resultado de D+E es: ', res);
readln;
F:= res + 22;
G:= res - 9;
writeln('Resultado de F es: ', F);
writeln('Resultado de G es: ', G);
if res<10 then
begin
gotoxy(15,14);
writeln('La fecha de La Pascua ',anno,' es: ', F , ' de Marzo ', anno);
gotoxy(15,17);
writeln('La fecha del Viernes Santo ',anno,' es: ', F-2 , ' de Marzo ',
anno);
readln;
end
else
begin
gotoxy(15,14);
writeln('La fecha de La Pascua ',anno, ' es: ', G , ' de Abril ',
anno);
gotoxy(15,17);
writeln('La fecha del Viernes Santo ',anno, ' es: ', G-2 , ' de Abril
', anno);
readln;
end;
if G=2 then
begin
gotoxy(15,19);
writeln('La fecha CORRECTA del Viernes Santo ',anno, ' es: ', 31 , ' de
Marzo ', anno);
readln;
end;
if G=1 then
begin
gotoxy(15,19);
writeln('La fecha CORRECTA del Viernes Santo ',anno, ' es: ', 30 , ' de
Marzo ', anno);
readln;
end;
if G= 26 then
begin
gotoxy(15,19);
writeln ('La fecha de CORRECTA de la Pascua ',anno, ' es: 19 de
Abril');
gotoxy(15,20);
writeln ('La fecha del CORRECTA del Viernes Santo ',anno, ' es: 17 de
Abril');
gotoxy(1,22);
writeln ('Ya que la Fecha de Pascua puede variar entre el 22 de Marzo
y el 25 de Abril');
readln;
end;
if G=25 then
if d=28 then
if e=6 then
if a>10 then
begin
gotoxy(15,19);
writeln ('La fecha CORRECTA de la Pascua es: 18 de Abril');
gotoxy(15,20);
writeln ('La fecha CORRECTA del Viernes Santo es: 16 de Abril');
gotoxy(15,22);
writeln ('Puesto que los resultados de G:25 con D:28 E:6 y A>10');
gotoxy(15,23);
writeln ('Ignorar esta nota si algún resultado NO concuerda ');
readln;
end;
end.

Algortimo en pl/pgsql de postgresql


CREATE OR REPLACE FUNCTION p_fecha_pascua(
iv_ano text, -- Año a calcular
out iv_fecpascua date -- Fecha de salida
)
AS
$BODY$
DECLARE
p_m int := 24;
p_n int := 5;
p_a int;
p_b int;
p_c int;
p_d int;
p_e int;
p_dia int;
p_mes int;
BEGIN
p_a := iv_ano::integer % 19;
p_b := iv_ano::integer % 4;
p_c := iv_ano::integer % 7;
p_d := (19*p_a + p_m) % 30;
p_e := (2*p_b+4*p_c+6*p_d + p_n) % 7;
if p_d+p_e < 10 then
p_dia := p_d+p_e+22;
p_mes := 3;
else
p_dia := p_d+p_e-9;
p_mes = 4;
end if;
if p_dia = 26 and p_mes = 4 then
p_dia = 19;
elsif p_dia = 25 and p_mes = 4 and p_d=28 and p_e = 6 and p_a >10 then
p_dia = 18;
end if;
iv_fecpascua := to_date(iv_ano ||'/'|| p_mes ||'/'|| p_dia,'yyyy/mm/dd');
end;
$BODY$ LANGUAGE 'plpgsql' volatile;
-- Uso:
select p_fecha_pascua('2012');

Algoritmo en Delphi
function Pascua(Anio: word): TDateTime;
var
a, b, c, d, e, f, g, h, i, k, l, m, n: word;
Mes, Dia: word;
begin
{ Devuelve la fecha del año en la que cae la Pascua de Resurrección.
Se utiliza para ello el Algoritmo de Butcher }
a := anio mod 19;
b := anio div 100;
c := anio 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;
Mes := n div 31;
Dia := 1 + n mod 31;

Result := EncodeDate(Anio, Mes, Dia);


end;

Fuente: http://www.clubdelphi.com/foros/showthread.php?t=30413

Algoritmo en Ruby
puts "indique el año a calcular"
anio = gets.to_i

case anio
when 1583..1699
M= 22
N= 2
when 1700..1799
M=23
N=3
when 1800..1899
M=23
N=4
when 1900..2099
M=24
N=5
when 2100..2199
M=24
N=6
when 2200..2299
M=25
N=0
end

a = anio % 19
b = anio % 4
c = anio % 7
d = ((19*a + M) % 30)
e = (2*b + 4*c + 6*d + N) % 7

if (d + e < 10) then


dia = (d + e + 22).to_s
mes = " Marzo"
else
dia = (d + e -9).to_s
mes = " Abril"
end

dia = 18 if (d + e -9) == 25 && mes == " Abril" && d==28 && e == 6 && a >10
dia = 19 if (d + e -9) == 26 && mes == " Abril"

puts "Domingo de pascuas será el " + dia + mes

Algoritmo en PowerBuilder
//Función: ej. f_calculo_domingo_pascua(ano_a_calcular)
// a_ano=año de cálculo: parámetro(integer) que recibe la función.

// ld_fecha=fecha (date): es la variable que retorna la función.

//

// Proceso de la función:

//

date ld_fecha

// variables de trabajo.

integer a, b, c, d ,e, M, N

IF a_ano >= 1583 and a_ano <= 1699 THEN


M=22
N=2
ELSEIF a_ano >= 1700 AND a_ano <= 1799 THEN
M=23
N=3
ELSEIF a_ano >= 1800 AND a_ano <= 1899 THEN
M=23
N=4
ELSEIF a_ano >= 1900 AND a_ano <= 2099 THEN
M=24
N=5
ELSEIF a_ano >= 2100 AND a_ano <= 2199 THEN
M=24
N=6
ELSEIF a_ano >= 2200 AND a_ano <= 2299 THEN
M=25
N=0
END IF

a=Mod(a_ano,19)

b=Mod(a_ano,4)

c=Mod(a_ano,7)

d=Mod(((19*a) + M),30)

e=Mod(((2*b)+(4*c)+(6*d)+N),7)

//Cálculo de fecha relativa.

IF (d+e) < 10 THEN

// se resta 1 (22 dias -1) porque se toma como base el 1ro. de marzo.

ld_fecha=RelativeDate(date('01/03/'+string(a_ano)),((d+e)+(22 - 1)))

ELSE

// se resta 1 (9 dias -1) porque se toma como base el 1ro. de abril.


ld_fecha=RelativeDate(date('01/04/'+string(a_ano)),(((d+e)-9)-1))

END IF

//Condicionales especiales (excepciones según explicación).

//Existen dos excepciones a tener en cuenta:

//

//Si la fecha obtenida es el 26 de abril...

// la Pascua caerá en el 19 de abril.

//Si la fecha obtenida es el 25 de abril, con d = 28, e = 6 y a > 10.…

// la Pascua caerá en el 18 de abril.

//

IF ld_fecha=date('26/04/'+string(a_ano)) then

ld_fecha=date('19/04/'+string(a_ano))

ELSEIF ld_fecha=date('25/04/'+string(a_ano)) AND d=28 and e = 6 AND a > 10 then

ld_fecha=date('18/04/'+string(a_ano))

END IF

return(ld_fecha)

Cálculo en SQL Anywhere (Transact SQL)


Create function F_CALCULA_DOMINGO_PASCUA(in @A_ANO integer)

returns date

begin
--
-- @LD_FECHA= VARIABLE QUE RETORNA LA FUNCIÓN.
declare @LD_FECHA date;
declare @A integer;
declare @B integer;
declare @C integer;
declare @D integer;
declare @E integer;
declare @M integer;
declare @N integer;
-- PROCESO DE LA FUNCIÓN:
if @A_ANO>=1583 and @A_ANO<=1699 then
set @M=22;
set @N=2
elseif @A_ANO>=1700 and @A_ANO<=1799 then
set @M=23;
set @N=3
elseif @A_ANO>=1800 and @A_ANO<=1899 then
set @M=23;
set @N=4
elseif @A_ANO>=1900 and @A_ANO<=2099 then
set @M=24;
set @N=5
elseif @A_ANO>=2100 and @A_ANO<=2199 then
set @M=24;
set @N=6
elseif @A_ANO>=2200 and @A_ANO<=2299 then
set @M=25;
set @N=0
end if;
set @A=MOD(@A_ANO,19);
set @B=MOD(@A_ANO,4);
set @C=MOD(@A_ANO,7);
set @D=MOD(((19*@A)+@M),30);
set @E=MOD(((2*@B)+(4*@C)+(6*@D)+@N),7);
--CÁLCULO DE FECHA RELATIVA.
if(@D+@E)<10 then
-- SE RESTA 1 (22 DIAS -1) PORQUE SE TOMA COMO BASE EL 1RO. DE MARZO.
set @LD_FECHA=DAYS("DATE"(STRING(@A_ANO)+'/03/01'),((@D+@E)+(22-1)))
else
-- SE RESTA 1 (9 DIAS -1) PORQUE SE TOMA COMO BASE EL 1RO. DE ABRIL.
set @LD_FECHA=DAYS("DATE"(STRING(@A_ANO)+'/04/01'),(((@D+@E)-9)-1))
end if;
if @LD_FECHA="DATE"(STRING(@A_ANO)+'/04/26') then
set @LD_FECHA="DATE"(STRING(@A_ANO)+'/04/19')
elseif @LD_FECHA="DATE"(STRING(@A_ANO)+'/04/25') and @D=28 and @E=6 and @A>10
then
set @LD_FECHA="DATE"(STRING(@A_ANO)+'/04/18')
end if;
return(@LD_FECHA)
end

Cálculo en EXCEL
Suponiendo que en la celda A3 se tiene el año:
=MULTIPLO.INFERIOR(FECHA(A3;5;DIA(MINUTO(A3/38)/2+56));7)-34

o
=MONEDA(("4/"&A3)/7+RESIDUO(19*RESIDUO(A3;19)-7;30)*14%;)*7-6

Algoritmo en Fortran 9X
PROGRAM pascua
! -------------------------------------------------------------
! pascua: permite calcular el día correspondiente al Domingo
! de Pascua para un año dado.
!
! La fecha del Domingo de Pascua corresponde al primer domingo
! después de la primera luna llena que sigue al equinocio de
! primavera en el hemisferio norte.
!
! La fórmula implementada es válida para años entre 1900 y 2099
!
! Referencia:
! http://es.wikipedia.org/wiki/Cálculo_de_la_fecha_de_Pascua
! -------------------------------------------------------------
! Declaración de variables
! -------------------------------------------------------------
INTEGER, PARAMETER :: min_year = 1900 ! Rango de validez
INTEGER, PARAMETER :: max_year = 2099 ! del año
INTEGER :: year ! Año ingresado por el usuario
INTEGER :: a,b,c,d,e ! Variables auxiliares
INTEGER :: n ! Número de día del mes de marzo
! (abril si n > 31) correspondiente
! al Domingo de Pascua.
INTEGER :: m ! Mes (3 = marzo, 4 = abril)
! -------------------------------------------------------------
! Ingreso de datos
! -------------------------------------------------------------
WRITE(*,'(A)',ADVANCE='no') 'Ingrese año: '
READ(*,*) year
! -------------------------------------------------------------
! Comprobar validez del año en el rango permitido
! -------------------------------------------------------------
IF (year < min_year .OR. &
& year > max_year ) STOP 'Año fuera de rango.'
! -------------------------------------------------------------
! Cálculo del Domingo de Pascua
! -------------------------------------------------------------
a = MOD(year,19)
b = MOD(year,4)
c = MOD(year,7)
d = MOD(19*a+24,30)
e = MOD(2*b+4*c+6*d+5,7)
n = 22+d+e
IF (n <= 31) THEN
m = 3 ! Marzo
ELSE
m = 4 ! Abril
n = n - 31
ENDIF
! -------------------------------------------------------------
! Casos excepcionales
! -------------------------------------------------------------
IF ( m == 4 .AND. n == 26) n = 19
IF ( m == 4 .AND. n == 25 .AND. d == 18 &
& .AND. e == 6 .AND. a > 10 ) n = 18
! -------------------------------------------------------------
! Imprimir el resultado
! -------------------------------------------------------------
WRITE(*,*) 'Domingo de Pascua'
WRITE(*,*) 'Año = ', year
WRITE(*,*) 'Mes = ', m
WRITE(*,*) 'Día = ', n
! -------------------------------------------------------------
! Terminar
! -------------------------------------------------------------
STOP
END PROGRAM pascua

El resultado de ejecutar el programa ingresando el año 2011 sería:


Domingo de Pascua
Año = 2011
Mes = 4
Día = 24

Algoritmo en PL SQL Oracle


CREATE OR REPLACE FUNCTION cp_fu_fecha_pascua(
p_ano_a_calcular varchar2 -- Año a calcular

) return date
AS

ld_fecha date;
a_ano number;

a integer;
b integer;
c integer;
d integer;
e integer;
M integer;
N integer;

BEGIN
a_ano := to_number(p_ano_a_calcular);

IF a_ano >= 1583 and a_ano <= 1699 THEN


M:=22;
N:=2;
ELSIF a_ano >= 1700 AND a_ano <= 1799 THEN
M:=23;
N:=3;
ELSIF a_ano >= 1800 AND a_ano <= 1899 THEN
M:=23;
N:=4;
ELSIF a_ano >= 1900 AND a_ano <= 2099 THEN
M:=24;
N:=5;
ELSIF a_ano >= 2100 AND a_ano <= 2199 THEN
M:=24;
N:=6;
ELSIF a_ano >= 2200 AND a_ano <= 2299 THEN
M:=25;
N:=0;
END IF;

a:=Mod(a_ano,19);

b:=Mod(a_ano,4);

c:=Mod(a_ano,7);

d:=Mod(((19*a) + M),30);

e:=Mod(((2*b)+(4*c)+(6*d)+N),7);

--Cálculo de fecha relativa.


IF (d+e) < 10 THEN

-- se resta 1 (22 dias -1) porque se toma como base el 1ro. de marzo.

ld_fecha:= to_date('01/03/'||p_ano_a_calcular,'dd/mm/yyyy')+((d+e)+(22 - 1));

ELSE

-- se resta 1 (9 dias -1) porque se toma como base el 1ro. de abril.

ld_fecha:= to_date('01/04/'||p_ano_a_calcular,'dd/mm/yyyy')+(((d+e)-9)-1);

END IF;

/*Condicionales especiales (excepciones según explicación).

Existen dos excepciones a tener en cuenta:

Si la fecha obtenida es el 26 de abril...

la Pascua caerá en el 19 de abril.

Si la fecha obtenida es el 25 de abril, con d = 28, e = 6 y a > 10.…

la Pascua caerá en el 18 de abril.*/

IF to_char(ld_fecha,'dd/mm') = '26/04' then

ld_fecha:=to_date('19/04/'||p_ano_a_calcular,'dd/mm/yyyy');

ELSIF to_char(ld_fecha,'dd/mm') = '25/04' AND d=28 and e = 6 AND a > 10 then

ld_fecha:=to_date('18/04/'||p_ano_a_calcular,'dd/mm/yyyy');

END IF;

return ld_fecha;

end;

Algoritmo en Visual Basic


La segunda función permite obtener otras fechas relacionadas usando las correspondientes constantes
Option Explicit

Public Const ssDomingoResurrección = 0


Public Const ssMiércolesCeniza = -46
Public Const ssDomingoRamos = -7
Public Const ssAscensión = 40
Public Const ssDomingoAscensión = 43
Public Const ssPentecostés = 50
Public Const ssSantísimaTrinidad = 57
Public Const ssCorpusChristi = 61
Public Const ssDomingoCorpusChristi = 64

Public Function DomingoResurrección(Año As Integer) As Date


Dim a As Integer, b As Integer, c As Integer, d As Integer, e As Integer
Dim f As Integer, g As Integer, h As Integer, i As Integer
Dim k As Integer, l As Integer, m As Integer, n As Integer
Dim mes As Integer, día As Integer

a = Año Mod 19
b = Int(Año / 100)
c = Año Mod 100
d = Int(b / 4)
e = b Mod 4
f = Int((b + 8) / 25)
g = Int((b - f + 1) / 3)
h = (19 * a + b - d - g + 15) Mod 30
i = Int(c / 4)
k = c Mod 4
l = (32 + 2 * e + 2 * i - h - k) Mod 7
m = Int((a + 11 * h + 22 * l) / 451)
n = h + l - 7 * m + 114
mes = Int(n / 31)
día = 1 + n Mod 31
DomingoResurrección = DateSerial(Año, mes, día)

End Function

Public Function FechaSemanaSanta(Año As Integer, Optional ssFechaSanta As Integer)


As Date
'Si se omite ssFechaSanta se asume ssMiércolesCeniza = 0

FechaSemanaSanta = DomingoResurrección(Año) + ssFechaSanta

End Function

Algoritmo en SQL Server (2008-2014)


-------------------------------------------------------------------------------
--- Autores: Martinez Camilo, Toro Brayan
--- Ingenieros de Sistemas - UMB -
-------------------------------------------------------------------------------

CREATE FUNCTION [dbo].[CalcularDiaPascua]


(
@A_ANO INT
)
RETURNS DATETIME

AS
BEGIN
DECLARE @LD_FECHA DATETIME,@A INT, @B INT,@C INT,@D INT,@E INT, @M INT,@N INT

-- PROCESO DE LA FUNCIÓN:
IF @A_ANO>=1583 AND @A_ANO<=1699
BEGIN
SET @M=22
SET @N=2
END
IF @A_ANO>=1700 AND @A_ANO<=1799
BEGIN
SET @M=23
SET @N=3
END
IF @A_ANO>=1800 AND @A_ANO<=1899
BEGIN
SET @M=23
SET @N=4
END
IF @A_ANO>=1900 AND @A_ANO<=2099
BEGIN
SET @M=24
SET @N=5
END
IF @A_ANO>=2100 AND @A_ANO<=2199
BEGIN
SET @M=24
SET @N=6
END
IF @A_ANO>=2200 AND @A_ANO<=2299
BEGIN
SET @M=25
SET @N=0
END

SET @A = @A_ANO % 19
SET @B = @A_ANO % 4
SET @C = @A_ANO % 7
SET @D = ((19*@A)+@M) % 30
SET @E = ((2*@B)+(4*@C)+(6*@D)+@N) % 7

--CÁLCULO DE FECHA RELATIVA.

IF(@D+@E)<10
BEGIN
SET @LD_FECHA=DATEADD(DD,((@D+@E)+(21)),CAST(@A_ANO AS VARCHAR)
+'0301')
END
ELSE
BEGIN
-- SE RESTA 1 (9 DIAS -1) PORQUE SE TOMA COMO BASE EL 1RO. DE ABRIL.
SET @LD_FECHA=DATEADD(DD,(((@D+@E)-9)-1),CAST(@A_ANO AS VARCHAR)
+'0401')
END

IF @LD_FECHA=CAST(@A_ANO AS VARCHAR)+'0426'
BEGIN
SET @LD_FECHA=CAST(@A_ANO AS VARCHAR)+'0419'
END

IF @LD_FECHA=CAST(@A_ANO AS VARCHAR)+'0425' and @D=28 and @E=6 and @A>10


BEGIN
SET @LD_FECHA=CAST(@A_ANO AS VARCHAR)+'0418'
END

RETURN @LD_FECHA
END

Referencias
1.
http://php.net/manual/es/function.easter-date.php