Anexo:Implementaciones del algoritmo de cálculo de la fecha de Pascua

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda

Lo siguiente es un anexo sobre la implementación del algoritmo de cálculo de la fecha de Pascua en los diferentes lenguajes de programación.

Algoritmo en Java[editar]

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.getFechaPascua()));
    }
}


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

12/04/2009

Algoritmo en Javascript[editar]

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#[editar]

/// <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[editar]

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[editar]

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[editar]

(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,Noviembre,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[editar]

  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[editar]

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[editar]

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[editar]

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[editar]

//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)[editar]

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[editar]

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[editar]

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[editar]

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[editar]

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)[editar]

-------------------------------------------------------------------------------
--- 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[editar]