NISAN (ABIB) 14 CALCULATOR


Jewish Year 3761 = Julian Year 1 or 0 (1 AD)

Jewish Year 3760 = Julian Year -1 (1 BC)

Jewish Year 1 = Julian Year -3760 (3760 BC)

Both Fields are Syncronized

Enter Jewish Year     Julian Year      
Enter Range 1 - 100    

 


Author of this Program: Lucien LeSage
Email: lucienlesage@cox.net
The 14th day of Abib or later Nisan, as it was called after the Babylonian Captivity, was the day the Passover Lamb was slain.

It was in the month of Abib, or the first month, that the Lord brought them out of Egypt (See Exodus 13:4). The Passover lamb was kept from the 10th to the 14th and was slain before sunset on the 14th. (See Exodus 12:6). According to the New Testament Jesus is our Passover (1st Corinthians 5:7) and surely He would have fulfilled what the Old Testament Passover Lamb foreshadowed on Nisan 14.

Pontius Pilate served under Emperor Tiberius from 26/27 to 36/37 AD. We know Pilate is best known for being the official who presided over the trial of Jesus and ultimately ordered his crucifixion. So we know Jesus was crucified somewhere in this window of time. Jesus said that he would be in the grave three days and three nights (See Matthew 12:40) and John tells us that there was a High Sabbath day that week as well as the Saturday Sabbath (See John 19:31). Nisan 15 would have been a High Sabbath day. The only thing that makes sense is that Nisan 14 fell on a Wednesday and Jesus was crucified on Wednesday, Nisan 14, and the next day was a Sabbath day, but a high day and then He would have beeen in the grave three days and three nights and rising after the weekly Sabbath which ended after sunset. This calculator shows a Wednesday Nisan 14 for year 27 and year 30. I did find a webpage (a follower of Herbert Armstrong) that showed year 31 but that appears to be a late date that year and the calculator shows March 26 which was a Monday rather than the Wednesday of April 25. From that said, perhaps we can not prove exactly which year Christ was crucified but a Wednesday is the only day that makes sense with a High Sabbath day on the next day which was a Thursday.

See: Three Days and Three Nights by Milburn Cockrell.

This calculator for determining Nisan 14 was created using the formula generated by mathematician Carl Friedrich Gauss in 1802 from the Jewish Calendar year. Albert Einstein commented that only Gauss could have produced such a formula. From that Nisan 14 date there are proceedures available to determine the day of the week as well as convert the Julian date to the Gregorian date. Knowing the formulas it is pretty much straight forward to create a computer program to work it out in a fraction of a second. Nowadays, Hebrew years are generally counted according to the system of Anno Mundi (Latin: "in the year of the world"; Hebrew: לבריאת העולם, "from the creation of the world", abbreviated AM). This system attempts to calculate the number of years since the creation of the world, according to the Genesis creation narrative and subsequent Biblical stories. The current Hebrew year, AM 5784, began at sunset on 15 September 2023 and will end at sunset on 2 October 2024.

The Julian Calendar was introduced by Julius Caesar in 46 BC and took effect in 45 BC. The calendar fixed the length of a year at 365 days, divided into twelve months, with a leap day added to February every fourth year.

Taken from the University of Nottingham: Julian/Gregorian Calendars. The Julian Calendar was the system of dating followed from 46 BC onwards. It was this calendar which added one extra day in every four years (giving us our 'leap year') because it had been calculated that the earth takes 365 days to complete its circuit around the sun, not a straight 365 days. Unfortunately, this calculation was not entirely accurate. In fact, the sun's circuit is not exactly 365 days - it's approximately 11 minutes less. This may seem a very small amount, but over a large number of years the figure builds up. As a result, it emerged that the Julian Calendar was over-correcting by around 8 days each millennium. In the 16th century the problem was examined. A solution was hit upon whereby centenary years would not be leap years unless they were divisible by 400. This meant that three out of four centenary years would not be leap years, or, that in every 400 years there would not be 100 leap years but 97. Using this calculation meant that there would only be an over-correction of 23 seconds, and that it would take 3,700 years before the over-correction amounted to a full day. In 1582 Pope Gregory ruled that this new calendar - thereafter called the Gregorian Calendar - should be brought into use. By that stage, the Julian Calendar had added ten days too many to the calendar, so Pope Gregory decreed that the day after the 4th of October 1582 should be the 15th of October 1582, thus correcting the error.

 Julian Day number starts on January 1, 4713 BC (the 7980 year Julian Period) and numbers each day forward as REAL numbers rather than INTEGERS. For example the Julian Day number for January 1, 1 AD is 1721423.4436111 or a little over 1 million 721 thousand and 4 hundred and 23 days since January 1, 4713 BC. This system was introduced within the last several hundred years.

Rosetta Calendar

Abdicate - Jewish Calendar

Home Page
 
HERE IS A SIMPLE COMMAND LINE PROGRAM TO DO THE SAME THING
----------------------------------------------------------
Author: Lucien LeSage
Email: lucienlesage@cox.net
MAIN PROGRAM CODE
-----------------
Program Nisan14CommandLine;
uses sysutils;
Const
  MonthAr: Array[1..12] of String =
    ('January','February','March','April','May','June',
     'July','August','September','October','November','December');
Type
  MyDateRecord = Record
    Year,Month,Day:Integer
   end;
var
  JewishYear,JulianYear,JDN:LongInt;
  Nisan14Date,Gregorian:MyDateRecord;
  BCAD:String; // BC or AD string
Function GetNisan14Date(JYear:LongInt):MyDateRecord; // Jewish Year Returns Julian Date
// Jewish Year 3761 = Julian Year 1
// Jewish Year 3760 = Julian Year -1 (1 BC)
// Jewish Year 1 = Julian Year -3760 (3760 BC)
// This routine developed from Gauss' Formula
var
  Year,a,b,c,Month,Day:LongInt;
  M,Temp:Real;
begin
  Year:=JYear;
  a:=((12*Year)+17) mod 19;
  b:=Year mod 4;
  M:=32+4343/98496+(1+272953/492480)*a+b/4-(313/98496)*Year;
  Month:=3; Day:=Trunc(M);
  Temp:=((3*Year)+(5*b)+Int(M)+5);
  c:=Trunc(Temp) mod 7;
  if ((c=2) or (c=4) or (c=6)) then
    Begin
      Month:=3;
      Day:=Trunc(M)+1;// March M+1
    End else
      if (c=1) and (a>6) and (Frac(M)>=1367/2160) then
        begin
          Month:=3;
          Day:=Trunc(M)+2;// March M+2
        end else
          if ((c=0) and (a>11) and (Frac(M)>=23269/25920)) then
          begin
            Month:=3;
            Day:=Trunc(M)+1;// March M+1
          end;
  Dec(Day); // Set to Nisan 14 - Gauss' formula was for Nisan 15
  If Day>31 then
    begin
      Inc(Month);
      Dec(Day,31);
    end;
  GetNisan14Date.Year:=Year-3760; // Julian Year
  GetNisan14Date.Month:=Month;
  GetNisan14Date.Day:=Day;
end;
Function GregDATE(JD:Real):MyDateRecord;
  // Returns Gregorian date from Julian Day Number
  // ChatGPT gave me this routine in Pascal code
var
  JDN, year, month, day, century, a, b, c, d, e: LongInt;
  begin
    JDN:=Trunc(JD);
    // Calculate auxiliary variables
    a := JDN + 32044;
    b := (4 * a + 3) div 146097;
    c := a - (146097 * b) div 4;
    // Calculate the centuries
    century := (4 * c + 3) div 1461;
    // Calculate the year within the century
    d := c - (1461 * century) div 4;
    e := (5 * d + 2) div 153;
    // Calculate the month
    month := e + 3 - 12 * (e div 10);
    // Calculate the day
    day := d - (153 * e + 2) div 5 + 1;
    // Calculate the year
    year := 100 * b + century - 4800; // Adjust for BC dates
    // Return the result
    // if year <= 0 then BC else AD
    GregDATE.YEAR:=Year;
    GregDATE.MONTH:=Month;
    GregDATE.DAY:=Day;
  end;
Function DayOfWeekStr(JDN:LongInt):String;// Julian Day Number needs to be an Integer
// Returns day of the week as a Name string, such as Monday, Tuesday, etc.
// 0=Monday, 1=Tuesday, ..., 6=Sunday
// ChatGPT suggested this simple one line formula if JDN is known
const
  JDNDowAr: Array[0..6] of String =
    ('Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday');
var
  i:Integer;
begin
   i:=JDN mod 7;// Divide by 7 and use remainder as pointer into Day array
   DayOfWeekStr:=JDNDowAr[i];
end;
Function CalculateJulianDayNumber(MyDate:MyDateRecord):LongInt;
// Calculate Julian Day Number (JDN) from Julian Date
// Developed this routine myself
var
  JulianYear: LongInt;
  JulianDay: Real;
begin
  // Julian Day number starts on January 1, 4713 BC
  JulianYear:=MyDate.Year+4712;
  JulianDay:=JulianYear*365.25; // Number of days in a year
  If (((JulianYear) mod 4)=0) then JulianDay:=JulianDay+31+29-1 else
    JulianDay:=JulianDay+31+28; // Gets day to March 1
  // Previous if statement has same results for true and false and could be removed
  If MyDate.Month=4 then JulianDay:=JulianDay+31; // Gets to April 1 as March has 31 days
  // Nisan 14 will always be in March or April
  JulianDay:=JulianDay+MyDate.Day; // Gets to day in month
  CalculateJulianDayNumber:=Trunc(JulianDay); // Make an integer and discard part less than 1
end;
begin // Program begins here
  Writeln('Enter Julian Year to determine Nisan 14 date');
    // 0 or -1 is BC 1, for any BC date use minus in front of number
  Readln(JulianYear);
  If JulianYear<0 then Inc(JulianYear); // Make -1 equal value=0 or to 1 BC
    // Program treats 0 as 1 BC and -1 as 2 BC so zero is significant in calculation
  JewishYear:=JulianYear+3760; //Julian Year is AD but BC is entered as negative
    // Jewish Year 3761 = Julian Year 1 (AD)
    // Jewish Year 3760 = Julian Year -1 (1 BC)
    // Jewish Year 1 = Julian Year -3760 (3760 BC)
  Nisan14Date:=GetNisan14Date(JewishYear); // Julian Date: Uses Gauss' formula to calculate
  JDN:=CalculateJulianDayNumber(Nisan14Date); // JDN is day number since Jan 1, 4713 BC
  Gregorian:=GregDate(JDN);
  if Nisan14Date.Year<1 then // Make negative years display as BC positive number
     begin // BC
       Dec(Nisan14Date.Year);
       BCAD:='BC';
       Nisan14Date.Year:=Abs(Nisan14Date.Year); // Change negative number to positive BC
       Dec(Gregorian.Year);
       Gregorian.Year:=Abs(Gregorian.Year); // Change negative number to positive BC
     end else BCAD:='AD'; // AD
  // Display output here
  Writeln('Nisan (Abib) 14 for Jewish Year = '+IntToStr(JewishYear)+
    Chr(13)+Chr(10)+ // Carriage Return, Line Feed
    'Julian Date = '+MonthAr[Nisan14Date.Month]+' '+
    IntToStr(Nisan14Date.Day)+', '+
    IntToStr(Nisan14Date.Year)+' '+BCAD+
    Chr(13)+Chr(10)+ // Carriage Return, Line Feed
    'Day of the week = '+DayOfWeekStr(JDN)+
    Chr(13)+Chr(10)+ // Carriage Return, Line Feed
    'Gregorian Date = '+MonthAr[Gregorian.Month]+' '+
    IntToStr(Gregorian.Day)+', '+
    IntToStr(Gregorian.Year)+' '+BCAD);
  Writeln('Julian Day = '+IntToStr(JDN));
  writeln;
end.