Moduł:Wielkanoc

 Dokumentacja modułu [zobacz] [edytuj] [historia] []

Moduł do wyznaczania dat Wielkanocy i dat ściśle z nią związanych.

Wyznacz

Funkcja do wyznaczania daty dziennej wydarzenia powiązanego z datą Wielkanocy.

parametry

Pole	Do czego służy?	Jak wypełnić?
1	Rok	Np. 2024 lub 1882.
metoda	Metoda obliczania daty Wielkanocy: juliańska wyznacza datę dla kalendarza juliańskiego wschodnia lub prawosławna wyznacza datę według kalendarza juliańskiego lecz przelicza wynik na kalendarz gregoriański zachodnia lub rzymska wyznacza datę według zreformowanej metody dla kalendarza gregoriańskiego. Jest to wartość domyślna.	Np. wschodnia aby obliczyć datę Wielkanocy w obrządku prawosławnym.
dzień	Nazwa wydarzenia zależnego od daty Wielkanocy, którego datę chcemy uzyskać lub liczba dni do (ujemne) lub po (dodatnie) Wielkanocy. Obecnie zdefiniowane są następujące dni: Przedpoście 63 dni przed Wielkanocą - jest to najwcześniejsza możliwa data wyznaczana przez funkcję Tłusty czwartek 52 dni przed Wielkanocą Popielec lub Środa popielcowa 46 dni przed Wielkanocą Niedziela Palmowa 7 dni przed Wielkanocą Wielki Czwartek 3 dni przed Wielkanocą Wielki Piątek 2 dni przed Wielkanocą Wielka Sobota 1 dzień przed Wielkanocą Wielkanoc 0 dni przesunięcia - to jest wartość domyślna Poniedziałek Wielkanocny lub Lany Poniedziałek 1 dzień po Wielkanocy Wniebowstąpienie 39 dni po Wielkanocy (w sensie zwykłym w czwartek) Zesłanie Ducha Świętego lub Pięćdziesiątnica 49 dni po Wielkanocy Boże Ciało 60 dni po Wielkanocy	Np. 1 lub zamiennie Poniedziałek Wielkanocny
format	Określa format wyświetlanej daty, który jest zgodny z funkcją parsera #time. Domyślny format to Y-m-d. Wartość specjalna nie pozwala na pominięcie etapu formatowania wyniku.	Np. j xd.

przykłady

{{#invoke:Wielkanoc|Wyznacz|{{CURRENTYEAR}}}}

2024-03-31

{{#invoke:Wielkanoc|Wyznacz|{{CURRENTYEAR}}|metoda=wschodnia}}

2024-05-05

{{#invoke:Wielkanoc|Wyznacz|{{CURRENTYEAR}}|format=[[j xg]]}}

31 marca

{{#invoke:Wielkanoc|Wyznacz|{{CURRENTYEAR}}|metoda=wschodnia|format=[[j xg]]}}

5 maja

{{#invoke:Wielkanoc|Wyznacz|{{CURRENTYEAR}}|dzień=Popielec}}

2024-02-14

{{#invoke:Wielkanoc|Wyznacz|{{CURRENTYEAR}}|metoda=wschodnia|dzień=Popielec}}

2024-03-20

{{#invoke:Wielkanoc|Wyznacz|{{CURRENTYEAR}}|format=[[j xg]] (l)|dzień=Popielec}}

14 lutego (środa)

{{#invoke:Wielkanoc|Wyznacz|{{CURRENTYEAR}}|metoda=wschodnia|format=[[j xg]] (l)|dzień=Popielec}}

20 marca (środa)

Przypisy

local m = {}

local EasterData = {
    defaultMethod = 3,        -- default method of Easter date calculation when Easter type is not given
    defaultFormat = "Y-m-d",  -- default date output format
    noFormat      = "nie",    -- prevent from final date formatting
    defaultOffset = 0,        -- the Easter date
    minimumOffset = -63,      -- Septuagesima
    maximumOffset = 68,       -- Feast of the Sacred Heart
 
    -- API
    apiEaster            = "Wyznacz",   -- public function name
    argEasterYear        = 1,           -- index or name of the argument with year
    argEasterMethod      = "metoda",    -- index or name of the argument with calculation method
    argEasterOffset      = "dzień",     -- index or name of the argument with offset in days relative to the calculated Easter Sunday
    argEasterFormat      = "format",    -- index or name of the argument with date output format (#time style)
 
    -- errors
    errorMissingYear     = "Brak parametru określającego rok",
    errorInvalidYear     = "Nieprawidłowy parametr określający rok: '%s'",
    errorInvalidOffset   = "Nieprawidłowy parametr dzień: '%s'",
    errorInvalidMethod   = "Nieprawidłowy parametr metoda: '%s'",
    errorYearOutOfRange  = "Poprawne daty Wielkanocy są obliczane dla lat od 326 do 4099; rok: %d",
    errorIncorrectMethod = "Rzymska lub prawosławna Wielkanoc istnieje od roku 1583; rok: %d",
    errorUnknownMethod   = "Nieprawidłowa metoda: %d",
 
    methods = {
        ["juliańska"]   = 1, -- Julian
        ["wschodnia"]   = 2, -- Eastern
        ["prawosławna"] = 2, -- alias (Orthodox)
        ["zachodnia"]   = 3, -- Western
        ["rzymska"]     = 3, -- alias (Roman)
    },
 
    relativeDates = {
        ["Przedpoście"]              = -63, -- Septuagesima
        ["Sexagesima"]               = -56,
        ["Tłusty czwartek"]          = -52, -- Fat Thursday
        ["Quinquagesima"]            = -49,
        ["Popielec"]                 = -46, -- Ash Wednesday
        ["Środa popielcowa"]         = -46, -- alias
        ["Niedziela Palmowa"]        =  -7, -- Palm Sunday
        ["Wielki Czwartek"]          =  -3, -- Maundy Thursday
        ["Wielki Piątek"]            =  -2, -- Good Friday
        ["Wielka Sobota"]            =  -1, -- Holy Saturday
        ["Wielkanoc"]                =   0, -- Easter
        ["Poniedziałek Wielkanocny"] =   1, -- Easter Monday
        ["Poniedziałek wielkanocny"] =   1, -- alias z błędną wcześniej używaną formą parametru
        ["Lany poniedziałek"]        =   1, -- alias z błędna wcześniej używaną formą parametru
        ["Lany Poniedziałek"]        =   1, -- alias
        ["Wniebowstąpienie"]         =  39, -- Ascension Thursday
        ["Zesłanie Ducha Świętego"]  =  49, -- Pentecost
        ["Pięćdziesiątnica"]         =  49, -- alias
        ["Boże Ciało"]               =  60, -- Corpus Christi
    },
}
 
local function formatEasterError(message, ...)
    if select('#', ... ) > 0 then
        message = string.format(message, ...)
    end
    return "<span class=\"error\">" .. message .. "</span>"
end
 
local function loadEasterYear(year)
    if not year then
        return false, formatEasterError(EasterData.errorMissingYear)
    end
    local result = tonumber(year)
    if not result or math.floor(result) ~= result then
        return false, formatEasterError(EasterData.errorInvalidYear, year)
    end
 
    return true, result
end
 
local function loadEasterMethod(method, year)
    local result = EasterData.defaultMethod
    if method then
        result = EasterData.methods[method]
        if not result then
            return false, formatEasterError(EasterData.errorInvalidMethod, method)
        end
    end
 
    if year < 1583 then
        result = 1
    end
 
    return true, result
end
 
local function loadEasterOffset(day)
    if not day then
        return true, ""
    end
 
    local data = EasterData.relativeDates
    local offset = tonumber(day)
    if not offset then
        offset = data[day]
    end
    if not offset or offset ~= math.floor(offset) or offset < EasterData.minimumOffset or offset > EasterData.maximumOffset then
        return false, formatEasterError(EasterData.errorInvalidOffset, day)
    end
 
    if offset < -1 then
        return true, string.format(" %d days", offset)
    elseif offset == -1 then
        return true, " -1 day"
    elseif offset == 0 then
        return true, ""
    elseif offset == 1 then
        return true, " +1 day"
    else -- if offset > 1 then
        return true, string.format(" +%d days", offset)
    end
end
 
local function loadEasterFormat(fmt)
    if fmt == EasterData.noFormat then
        return true, nil
    elseif not fmt then
        return true, EasterData.defaultFormat
    else
        return true, fmt
    end
end
 
--[[
 PURPOSE:     This function returns Easter Sunday day and month
              for a specified year and method.
 
 INPUTS:      Year   - Any year between 326 and 4099.
              Method - 1 = the original calculation based on the
                           Julian calendar
                       2 = the original calculation, with the
                           Julian date converted to the
                           equivalent Gregorian calendar
                       3 = the revised calculation based on the
                           Gregorian calendar
 
 OUTPUTS:     None.
 
 RETURNS:     0, error message - Error; invalid arguments
              month, day       - month and day of the Sunday
 
 NOTES:
              The code is translated from DN OSP 6.4.0 sources.
              The roots of the code might be found in
              http://www.gmarts.org/index.php?go=415
 
 ORIGINAL NOTES:
 
              This algorithm is an arithmetic interpretation
              of the 3 step Easter Dating Method developed
              by Ron Mallen 1985, as a vast improvement on
              the method described in the Common Prayer Book
 
              Published Australian Almanac 1988
              Refer to this publication, or the Canberra Library
              for a clear understanding of the method used
 
              Because this algorithm is a direct translation of
              the official tables, it can be easily proved to be
              100% correct
 
              It's free! Please do not modify code or comments!
]]
local function calculateEasterDate(year, method)
    if year < 326 or year > 4099 then
        -- Easter dates are valid for years between 326 and 4099
        return 0, formatEasterError(EasterData.errorYearOutOfRange, year)
    end
    if year < 1583 and method ~= 1 then
        -- Western or Orthodox Easter is valid since 1583
        return 0, formatEasterError(EasterData.errorIncorrectMethod, year)
    end
 
    -- intermediate result
    local firstDig = math.floor(year / 100)
    local remain19 = year % 19
    local temp = 0
    -- table A to E results
    local tA = 0
    local tB = 0
    local tC = 0
    local tD = 0
    local tE = 0
     -- Easter Sunday day
    local d = 0
 
    if method == 1 or method == 2 then
        -- calculate PFM date
        tA   = ((225 - 11 * remain19) % 30) + 21
        -- find the next Sunday
        tB   = (tA - 19) % 7
        tC   = (40 - firstDig) % 7
        temp = year % 100
        tD   = (temp + math.floor(temp / 4)) % 7
        tE   = ((20 - tB - tC - tD) % 7) + 1
        d    = tA + tE
        if method == 2 then
            -- convert Julian to Gregorian date
            -- 10 days were skipped in the Gregorian calendar from 5-14 Oct 1582
            temp = 10
            -- only 1 in every 4 century years are leap years in the Gregorian
            -- calendar (every century is a leap year in the Julian calendar)
            if year > 1600 then
                temp = temp + firstDig - 16 - math.floor((firstDig - 16) / 4)
            end
            d = d + temp
        end
    elseif method == 3 then
        -- calculate PFM date
        temp = math.floor((firstDig - 15) / 2)  + 202 - 11 * remain19
        if firstDig > 26 then
            temp = temp - 1
        end
        if firstDig > 38 then
            temp = temp - 1
        end
        if firstDig == 21 or firstDig == 24 or firstDig == 25 or firstDig == 33 or firstDig == 36 or firstDig == 37 then
            temp = temp - 1
        end
        temp = temp % 30
        tA   = temp + 21
        if temp == 29 then
            tA = tA - 1
        end
        if temp == 28 and remain19 > 10 then
            tA = tA - 1
        end
        -- find the next Sunday
        tB   = (tA - 19) % 7
        tC   = (40 - firstDig) % 4
        if tC == 3 then
            tC = tC + 1
        end
        if tC > 1 then
            tC = tC + 1
        end
        temp = year % 100
        tD   = (temp + math.floor(temp / 4)) % 7
        tE   = ((20 - tB - tC - tD) % 7) + 1
        d    = tA + tE
    else
        -- Unknown method
        return 0, formatEasterError(EasterData.errorUnknownMethod, method)
    end
    if d > 61 then
        -- when the oryginal calculation os converted to the Gregorian
        -- calendar, Easter Sunday can occur in May
        return 5, d - 61
    elseif d > 31 then
        return 4, d - 31
    else
        return 3, d
    end
end
 
local function Easter(args)
    local ok
    local year
    ok, year = loadEasterYear(args[EasterData.argEasterYear])
    if not ok then
        return year
    end
 
    local method
    ok, method = loadEasterMethod(args[EasterData.argEasterMethod], year)
    if not ok then
        return method
    end
 
    local offset
    ok, offset = loadEasterOffset(args[EasterData.argEasterOffset])
    if not ok then
        return offset
    end
 
    local format
    ok, format = loadEasterFormat(args[EasterData.argEasterFormat])
    if not ok then
        return format
    end
 
    local month, day = calculateEasterDate(year, method)
    if month == 0 then
        return day
    end
 
    local result = string.format("%04d-%02d-%02d%s", year, month, day, offset)
    if format then
        result = mw.language.getContentLanguage():formatDate(format, result)
    end
 
    return result
end
 
m[EasterData.apiEaster] = function (frame)
    return Easter(frame.args)
end
 
return m