/* ************************************************************************************
 *	Das Modul beinhaltet Funktionen zur Berechnung des Julianischen Datums und was
 *	damit zusammenhängt. Die Funktionen und Algorithmen haben keinen Anspruch auf
 *	hohe Genauigkeit, Vollständigkeit und Richtigkeit.
 *
 *	Funktionsliste:
 *
 *	- partOfTheCentury(year, jd)
 *	- function calcJD2Date(jd)
 *	- calcJD(day, month, year, hour, minute, second, msecond, dst, tz)
 *	- function julianDate2Date(jd)
 *	- function date2JulianDate(day, month, year, hour, minute, second, msecond, dst, tz)
 *
 *
 *	21.09.2020, Dieter Steffan
 *
 *********************************************************************************** */


 
/* ************************************************************************************
 *	Ermittelt den vergangenen Teil des Jahrhunderts, anhand des Datums, und berechnet
 *	daraus den schon vergangenen Teil des Jagrhunderts vom 0.5 Januar des Datums bis
 *	zum Datum. Werte von 0.5 < T < 1 oder -0.5 < T < -1 sind möglich, jenachdem ob das 
 *	Datum v. Chr. liegt oder danach.
 *
 *	Die Übergabewerte werden nicht auf Plausibilität überprüft. Bitte vor dem Aufruf
 *	der Funktion selber überprüfen.
 *
 *	Übergabeparameter:
 *
 *	year	= Jahr des zu berechneten Datums
 *	jd		= Julianisches Datum des zu berechnenden Datums
 *
 *
 *	Returnwert:
 
 *	Der Teil des vergangenen Jahrhunderts ab dem 0.5 Januar XXXX als Number und das
 *	verwendete Jahrhundert, das ja als JXXXX bezeichnet wird.
 *	
 *	Array[0] = Das verwendete Jahrhunder, also z.B. 1900.
 *	Array[1] = Das vergangene Jahrhundert.
 *
 *********************************************************************************** */
 
function partOfTheCentury(year, jd){
	var YEAR = String(year);
	var JD = Number(jd);
	var CENTURY = [];
	
	// Beginn ist 0.5 Januar -4712. Bei kleineren Werten das Jahr auf -4712 setzen ...
	if (parseInt(YEAR) < -4712){
		YEAR = String(-4712);
	}

	// ... Bei neagtiven jahren ...
	if (parseInt(YEAR) < 0){
		// ... Jahrhundert aus den ersten 3 Zahlen extrahieren
		// und mit 100 zum Jahrhundert multiplizieren und ab
		// ins Array  an Index 0 ...
		CENTURY.push(parseInt(YEAR.substring(0, 3)) * 100);
	// Jahr ist = 0
	}else if (parseInt(YEAR) == 0){
		// ... und alles mit 0 auffüllen, also "0000"
		CENTURY.push(LPad(YEAR, 4, "0"));
	// Jahreszahl > 0
	}else{
		// Ersten zwei Zahlen als Jahrhunder extrahieren und * 100
		// und ab ins Array an Index 0
		CENTURY.push(parseInt(YEAR.substring(0, 2)) * 100);
	}
	
	// Aus JD und JD zum 0.5 Januar des Jahrhunderts T berechnen
	// und ab ins Array an Index 1
	CENTURY.push((JD - calcJD(0, 1, CENTURY[0], 12, 0, 0, 0, 0)) / 36525);
						
	return(CENTURY);
}


/* ************************************************************************************
 *	Die Funktion berechnet aus dem zu übergebenden Julianischen Datum als Gleitkomma-
 *	zahl das dazugehörige Datum und Uhrzeit.
 *	Der Algorithmus funktioniert zuverlässig von 1600 - XXXX. 
 *	Datum v. Chr. liegt oder danach. Es werden auch die Übergänge bei den Monaten bzw. Jahren
 * 	berücksichtigt. Dies kommt ja oft vor, wenn Datum und Uhrzeit am Anfang des Monats
 *	oder Jahres liegen und eine hohe Zeitzone vorhanden ist. In dem Falle fällt das Datum
 *	der UT gegenüber der LT ja in den Vormonat oder das Vorjahr. Siehe Beispiel.
 *
 *	Die Übergabewerte werden nicht auf Plausibilität überprüft. Bitte vor dem Aufruf
 *	der Funktion selber überprüfen. Der Datentyp sollte ebenfalls eine Gleitkommazahl sein.
 *
 *	Übergabeparameter:
 *
 *	jd	= Julianisches Datum aus dem das Gregorianische Datum berechnet wird
  *
 *
 *	Returnwert:
 
 *	Ein Array mit 3 Werten an den Indizes 0 - 2
 *	verwendete Jahrhundert, das ja als JXXXX bezeichnet wird.
 *	
 *	Array[0] = Der Tag des Datums als Gleitkommazahl. Nachkommastellen sind die Uhrzeit. 
 *	Array[1] = Der Monat des Datums als Ganzzahl.
 *	Array[2] = Das Jahr des Datums als Ganzzahl.
 *
 *	Quelle: Grundlagen der Ephemeridenberechnung - von Oliver Montenbruck
 *
 *********************************************************************************** */
 
function calcJD2Date(jd){
	// Variablendeklarationen
	var DATE = [];
	var a = 0;
	var b = 0;
	var c = 0;
	var d = 0;
	var e = 0;
	var f = 0;
	
	// Das Julianische Datum um 12 h erhöhen ...
	a = Math.floor(Number(jd) + 0.5);
	
	// ... und die Hilfsvariablen berechnen
	if (a < 2299161){
		c = a + 1524;
	}else if (a >= 2299161){
		b = Math.floor((a - 1867216.25)/36524.25);
		c = a + b - Math.floor(b/4) + 1525;
	}
	
	d = Math.floor((c - 122.1)/365.25);
	e = Math.floor(365.25 * d);
	f = Math.floor((c - e)/30.6001);
	
	// ... Tag, Monat und Jahr berechnen. Der Tag beinhaltet als
	// Nachkommaanteil die Uhrzeit ...
	var day = c - e - Math.floor( 30.60001 * f) + (jd + 0.5 - a);
	var month = f - 1 - 12 * Math.floor(f/14);
	var year = d - 4715 - Math.floor((7+month)/10);
	
	// und in einem Array mit dem Index 0 - 2 speichern ...
	DATE.push(day);
	DATE.push(month);
	DATE.push(year);
	
	// ... und zurück zum Caller.
	return(DATE);
}



/* ************************************************************************************
 *	Berechnung des julianischen Datums.
 *	Am 0.5 Januar -4712 ist das JD = 0 aber nach den Formeln ist dies am 24.4 November 
 *	-4713 der Fall und am eigentlichen Datum 0.5 Januar -4712 sind schon 37 Tage vergangen.
 *	Das ist ein Fehler von 0,015% auf die gesamten Tage Zeit seit Begin bis 2020 und
 *	2,3 * 10 e-6 für ein Jahr.
 * 
 *	Berücksichtigt werden Schaltjahre und die Zeit des Übergangs vom Julianischen- 
 *	zum Gregorianischen kalender, sowie die Zeitzone und Daylight Savings Time.
 *
 *	Soll das julianische Datum des aktuellen Datums berechnet werden, dann muss man
 *	die UTC Zeit angeben, also die Zeit der Uhren/PC-Datum usw. . Die Übergabeparameter
 * 	DST und TZ müssen dabei 0 sein.
 *
 *	Soll die UT bzw. GMT berechnet werden, dann muss man DST und TZ mit angeben.
 *
 *	Es wird keine Plausibiliätsprüfung der einzelnen Übergabeparameter vorgenommen.
 *	Bitte vor Aufruf überprüfen.
 *
 *	Übergabeparameter:
 *
 *	Getrennt Datum mit Uhrzeit des zu berechnenden Datums und DST mit TZ
 *	Der Tag day als Int, wird aber noch konvertiert
 *	Der Monat month als Int, wird aber noch konvertiert
 *	Das Jahr year als Int, wird aber noch konvertiert
 *	Die Stunde hour als Number, wird aber noch konvertiert
 *	Die Minute minute als Number, wird aber noch konvertiert
 *	Die Sekunde second als Number, wird aber noch konvertiert
 *	Die Millisekunde misecond als Number, wird aber noch konvertiert
 *	Die TZ und DST als Int, wird aber noch konvertiert
 * 	TZ -12 < 0 < 12
 *  DST = 1 Sommerzeit
 *	DST = 0 Winterzeit
 *
 *	Returnwert:
 *	Das Julianische Datum als Number
 *
 *	Quelle: Grundlagen der Ephemeridenberechnung - von Oliver Montenbruck
 *
 * --------------------------------------------------------------------------------
 *
 * Calculating the Julian date. * On 0. 5 January -4712 the JD = 0 but according to the formulas this is on 24. 4 November
 * -4713 and on the actual date 0. 5 January -4712 37 days have passed. * This is an error of 0. 015% on the total day time since the beginning until 2020 and
 * 2. 3 * 10 e-6 for one year. *
 * Leap years and the time of transition from the Julian
 * to the Gregorian calendar, as well as the time zone and Daylight Savings Time.
 *
 * If you want to calculate the Julian date of the current date, you have to
 * Specify the UTC time, i. e. the time of the clocks/PC date, etc. The transfer parameters
 * DST and TZ must be 0. *
 * Should the UT or the UT GMT, then you have to specify DST and TZ.
 *
 * No plausibility check of the individual transfer parameters is performed.
 * Please check before calling.
 *
 * Transfer parameters:
 *
 * Separate date with time of the date to be calculated and DST with TZ
 * The tag day as Int, but is still being converted
 * The month month as Int, but is still being converted
 * The year year as Int, but is still being converted
 * The hour hour as number, but is still being converted
 * The minute minute as number, but is still being converted
 * The second second as number, but is still being converted
 * The millisecond misecond as number, but is still being converted
 * The TZ and DST as Int, but is still being converted
 * TC -12 < 0 < 12
 * DST = 1 daylight saving time
 * DST = 0 winter time
 *
 * Return value:
 * The Julian date as number
 *
 * Source: Basics of Ephemerid Calculation – by Oliver Montenbruck
 *
 *********************************************************************************** */
 
function calcJD(day, month, year, hour, minute, second, msecond, dst, tz){

	// Variablen der Hilfsgrößen
	// Variables of auxiliary variables
	var y = 0; var m = 0; var B = 0;
	var ret = 0.0;
	DAY = Number(day);
	MONTH = Number(month);
	YEAR = Number(year);
	
	// Alles östlich Greenwich, wenn die Timezone positiv ist ...
	// All east of Greenwich when the timezone is positive ...
	if (tz > 0)
		hour = hour - (dst + tz);
	// Alles westlich Greenwich, wenn die Timezone negativ ist ...
	// All west of Greenwich, if the timezone is negative ...
	else if (tz < 0)
		hour = hour + (dst - tz);
	
	// Beginn ist 0.5 Januar -4712. Bei kleineren Werten das Jahr auf -4712 setzen ...
	// Start is 0. 5 January -4712. At smaller values, set the year to -4712 ...
	if (parseInt(YEAR) < -4712){
		YEAR = String(-4712);
	}

	// Universal Time = GMT als Gleitkommazahl ...
	// Weltzeit = GMT als Gleitkommazahl ...
	UT = Number(hour) + (Number(minute)/60.) + (Number(second)/3600.) + (Number(msecond)/1000./3600.);
	
	// Date Objekte für die Umstellung von Julianischen- auf
	// Gregorianischen Kalender aktuelles Datum holen ...
	// Date objects for the conversion from Julian to
	// Gregorian calendar get current date ...
	var date = new Date();						
	var date1 = new Date("1582", "10", "4");
	var date2 = new Date("1582", "10", "15")
	// Hilfsgrößen berechnen
	// Calculate auxiliary sizes
	if (MONTH <= 2) {
		y = YEAR - 1;
		m = MONTH + 12; 
	}else{
		y = YEAR;
		m = MONTH;
	}

	/* **************************************************
	 * Beschränkt man sich bei den Berechnungen nur auf den
	 * Zeitraum vom 01.03.1900 - 28.02.2100, dann kann man
	 * B = -15 setzen.
	 * The calculations are limited only to the
	 * Period from 01. 03. 1900 – 28. 02. 2100, then you can
	 * B = -15 set.
	 * **************************************************/
	// Übergebenes Datum liegt im Julianischen Bereich ...
	// Passed date is in the Julian area ...
	if (date <= date1){
		B = -2;
	// Übergebenes Datum liegt im Gregorianischen Bereich ...
	// Date passed is in the Gregorian range ...
	}else if (date >= date2){
		B = Math.floor(y/400) - Math.floor(y/100);
	}
	
	// Julianisches Datum berechnen anhand des siderischen Jahres ...
	// Calculate Julian date using the sidereal year ...
	ret = Number(Math.floor(365.25 * y) + Math.floor(30.6001 * (m + 1)) + B + 1720996.5 + DAY + (UT/24));

	// Und zurück zum Caller.
	// And back to the caller.
	return(ret);
	
}



/* ************************************************************************************
 *	Die Funktion berechnet aus dem zu übergebenden Julianischen Datum als Gleitkomma-
 *	zahl das dazugehörige Datum und Uhrzeit.
 *	Der Algorithmus funktioniert zuverlässig von 1600 - XXXX. 
 *	Datum v. Chr. liegt oder danach. Es werden auch die Übergänge bei den Monaten bzw. Jahren
 * 	berücksichtigt. Dies kommt ja oft vor, wenn Datum und Uhrzeit am Anfang des Monats
 *	oder Jahres liegen und eine hohe Zeitzone vorhanden ist. In dem Falle fällt das Datum
 *	der UT gegenüber der LT ja in den Vormonat oder das Vorjahr. Siehe Beispiel.
 *
 *	Die Übergabewerte werden nicht auf Plausibilität überprüft. Bitte vor dem Aufruf
 *	der Funktion selber überprüfen. Der Datentyp sollte ebenfalls eine Gleitkommazahl sein.
 *
 *	Übergabeparameter:
 *
 *	jd	= Julianisches Datum aus dem das Gregorianische Datum berechnet wird
 *
 *
 *	Returnwert:
 *
 *	Ein Array mit 3 Werten an den Indizes 0 - 2
 *	verwendete Jahrhundert, das ja als JXXXX bezeichnet wird.
 *	
 *	Array[0] = Der Tag des Datums als Gleitkommazahl. Nachkommastellen sind die Uhrzeit. 
 *	Array[1] = Der Monat des Datums als Ganzzahl.
 *	Array[2] = Das Jahr des Datums als Ganzzahl.
 *	
 *	Quelle:
 *	https://de.wikipedia.org/wiki/Umrechnung_zwischen_julianischem_Datum_und_gregorianischem_Kalender
 *
 *	--------------------------------------------------------------------------------
 *
 * The function calculates from the Julian date to be passed as floating point
 * pay the corresponding date and time. * The algorithm works reliably from 1600 - XXXX. * Date B. C. or after. There will also be transitions in the months and months. years
 * taken into account. This often happens when the date and time at the beginning of the month
 * or year and a high time zone is present. In this case, the date falls
 * the UT compared to the LT in the previous month or the previous year. See example. *
 * The transfer values are not checked for plausibility. Please before the call
 * check the function itself. The data type should also be a floating-point number. *
 * Transfer parameters:
 *
 * jd = Julian date from which the Gregorian date is calculated
 *
 *
 * Return value:
 *
 * An array with 3 values at the indices 0 - 2
 * used century, which is referred to as JXXXX.
 *
 * Array[0] = The date as floating point number. Decimal places are the time.
 * Array[1] = The month of the date as an integer.
 * Array[2] = The year of the date as an integer.
 *
 * Source:
 * https://de. wikipedia. org/wiki/Umrechnung_zwischen_julianischem_Datum_und_gregorianischem_Kalender
 *
 *********************************************************************************** */
 
function julianDate2Date(jd){
	// Definition und Deklaration der Variablen ...
	// Definition and declaration of variables ...
	var DATE = [];
	var Z = 0.0
	var F = 0.0;
	var a = 0.0;
	var A = 0.0;
	var Z = 0.0;
	var B = 0.0;
	var C = 0.0;
	var D = 0.0;
	var E = 0.0;
	var day = 0.0;
	var month = 0;
	var year = 0;
							
	// Ganzahliger Anteil von JD ...
	// Integer fraction of JD ...
	Z = Math.floor(jd + 0.5);
	
	// ... und hier der Nachkommaanteil ...
	// ... and here the decimal part ...
	F = (jd + 0.5) - Z;
							
	if (Z < 2299161.0)
		a = Z;
	else if (Z > 2299161.0)
		a = Math.floor((Z - 1867216.25)/36524.25);
							
	// Hilfsvariablen berechnen	...
	// Calculate auxiliary variables ...	
	A = Z + 1 + a - Math.floor(a/4.0);
	B = A + 1524;
	C = Math.floor((B - 122.1)/365.25);
	D = Math.floor(365.25 * C);
	E = Math.floor((B-D)/30.6001);
	
	// ... und den Tag berechnen ...
	// ... and calculate the day ...
	day = B - D - Math.floor(30.6001 * E) + F;
	
	// ... sowie den Monat ...
	// ... as well as the month ...
	if ( E < 14)
		month = E - 1;
	else if ((E == 14) || (E == 15))
		month = E - 13;

	// ... und das Jahr ...
	// ... and the year ...
	if (month > 2)
		year = C -4716;
	else if ((month == 1) || (month == 2))
		year = C -4715;
								
	// Werte im Array Speichern ...
	// Values in the Save Array	...
	DATE.push(day);
	DATE.push(month);
	DATE.push(year);
	
	// ... und zurück zum Caller.
	// ... and back to the caller.
	return(DATE);
}
						
						
/* ************************************************************************************
 *	Die Funktion arbeitet wie die Funktion calcJD(), in diesem Modul, mit dem Algorithmus
 *	von Oliver Montenbruck.
 *
 *	Übergabeparameter:
 *	
 *	wie die Funktion calcJD()
 *	
 *	Returnwert:
 *
 *	wie die Funktion calcJD()
 *	
 *	Quelle:
 *	https://de.wikipedia.org/wiki/Umrechnung_zwischen_julianischem_Datum_und_gregorianischem_Kalender
 *
 * ---------------------------------------------------------------------------------
 *
 * The function works like the calcJD () function in this module, with the algorithm
 * by Oliver Montenbruck. *
 * handover parameters:
 *
 * like calcJD ()
 *
 * Return value:
 *
 * like calcJD ()
 *
 * Source:
 * https://de. wikipedia. org/wiki/Umrechnung_zwischen_julianischem_Datum_und_gregorianischem_Kalender
 *
 *********************************************************************************** */
						
function date2JulianDate(day, month, year, hour, minute, second, msecond, dst, tz){
	// Deklaration und Definition der Variablen ...
	// Declaration and definition of variables ...
	var JD = 0.0;
	var y = 0.0;
	var m = 0.0;
	var b = 0.0;
	var d = 0.0;
	

	// Alles östlich Greenwich, wenn die Timezone positiv ist.
	// All east of Greenwich when the timezone is positive.
	if (tz > 0)
		hour = hour - (dst + tz);
	// Alles westlich Greenwich, wenn die Timezone negativ ist.
	// All west of Greenwich if the timezone is negative.
	else if (tz < 0)
		hour = hour + (dst - tz);

	// Beginn ist 0.5 Januar -4712. Bei kleineren Werten das Jahr auf -4712 setzen ...
	// Start is 0. 5 January -4712. Set the year to -4712 for smaller values ...
	if (parseInt(year) < -4712){
		year = String(-4712);
	}
	
	// Korrigieren von Monat und Jahr, da mit 13 + 14 Monaten gerechnet wird.
	// Correction of month and year, as 13 + 14 months is expected.	
	if(month > 2){
		y = year;
		m = month;
	}else{
		y = year - 1;
		m = month + 12;
	}
	
	// Den Tag und Uhrzeit Berechnen.
	// Calculate the day and time.
	d = day + (hour / 24.0) + (minute / 1440.0) + (second / 86400.0) + (msecond / 86400000.0);

	// Hier den Wert für das Jahr mit Schaltjahren.
	// Here is the value for the year with leap years.
	b = 2 - Math.floor(y/100.0) + Math.floor(y/400.0);
	
	// ... und alles aufaddieren ...
	// ... and add up everything ...
	JD = Math.floor(365.25 * (y + 4716)) + Math.floor(30.6001 *(m + 1)) + d + b - 1524.5;

	// ... und zurück zum Caller.
	// ... and back to the caller.
	return(JD);
}