From d20d989f5495492f1258c8313db7c19b429111a3 Mon Sep 17 00:00:00 2001
From: ulrich
Date: Thu, 23 Mar 2023 17:55:43 +0000
Subject: [PATCH] Chinesischer Kalender implementiert
---
src/de/uhilger/zeitrechnung/ereignis/EinzelEreignis.java | 20 +
src/de/uhilger/zeitrechnung/ereignis/JulianischesEreignis.java | 3
src/de/uhilger/zeitrechnung/ereignis/ChinesischesEreignis.java | 100 +++++++++++
src/de/uhilger/zeitrechnung/kalender/BasisKalender.java | 115 +++++++++++-
src/de/uhilger/zeitrechnung/ereignis/EreignisBasis.java | 2
src/de/uhilger/zeitrechnung/ChinesischesDatum.java | 37 ++++
src/de/uhilger/zeitrechnung/ereignis/Ereignis.java | 3
src/de/uhilger/zeitrechnung/kalender/ChinesischerKalender.java | 227 +++++++++++++++++++++++++
8 files changed, 488 insertions(+), 19 deletions(-)
diff --git a/src/de/uhilger/zeitrechnung/ChinesischesDatum.java b/src/de/uhilger/zeitrechnung/ChinesischesDatum.java
new file mode 100644
index 0000000..3ece41c
--- /dev/null
+++ b/src/de/uhilger/zeitrechnung/ChinesischesDatum.java
@@ -0,0 +1,37 @@
+package de.uhilger.zeitrechnung;
+
+/**
+ *
+ * @author Ulrich Hilger
+ */
+public class ChinesischesDatum extends Datum {
+
+ private long zyklus;
+ private boolean schaltmonat;
+
+ public ChinesischesDatum() {
+ super();
+ }
+
+ public ChinesischesDatum(long zyklus, long jahr, int monat, boolean schaltmonat, int tag) {
+ super(jahr, monat, tag);
+ this.zyklus = zyklus;
+ this.schaltmonat = schaltmonat;
+ }
+
+ public long getZyklus() {
+ return zyklus;
+ }
+
+ public void setZyklus(long zyklus) {
+ this.zyklus = zyklus;
+ }
+
+ public boolean isSchaltmonat() {
+ return schaltmonat;
+ }
+
+ public void setSchaltmonat(boolean schaltmonat) {
+ this.schaltmonat = schaltmonat;
+ }
+}
diff --git a/src/de/uhilger/zeitrechnung/ereignis/ChinesischesEreignis.java b/src/de/uhilger/zeitrechnung/ereignis/ChinesischesEreignis.java
new file mode 100644
index 0000000..ff9b9f8
--- /dev/null
+++ b/src/de/uhilger/zeitrechnung/ereignis/ChinesischesEreignis.java
@@ -0,0 +1,100 @@
+/*
+ Zeitrechnung - a class library to determine calendar events
+ Copyright (c) 1984-2023 Ulrich Hilger, http://uhilger.de
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package de.uhilger.zeitrechnung.ereignis;
+
+import de.uhilger.zeitrechnung.ChinesischesDatum;
+import de.uhilger.zeitrechnung.Datum;
+import de.uhilger.zeitrechnung.Definition;
+import de.uhilger.zeitrechnung.kalender.ChinesischerKalender;
+import de.uhilger.zeitrechnung.kalender.ISOKalender;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Ein Ereignis, das durch ein Datum im traditionellen
+ * chinesischen Kalender definiert ist.
+ *
+ * <p>Soll nicht ein Ereignis bestimmt sondern in den oder vom chinesischen
+ * Kalender umgerechnet werden, muss die Klasse ChinesischerKalender genutzt
+ * werden.</p>
+ *
+ * <p>
+ * Die Ereignis-Definition lautet:<br>
+ * ChinesischesEreignis.getDefinition.setp1(Monat des chinesischen Kalenders);<br>
+ * ChinesischesEreignis.getDefinition.setp2(Tag im Monat des chinesischen Kalenders);<br>
+ * wobei Monat einer Ganzzahl aus
+ * [ChinesischerKalender.noch-angeben .. ChinesischerKalender.noch-angeben]
+ * entspricht.
+ * </p>
+ *
+ * @author Ulrich Hilger
+ */
+public class ChinesischesEreignis extends EreignisBasis {
+
+ @Override
+ public int getTyp() {
+ return EreignisBasis.TYP_CHINESISCH;
+ }
+
+ @Override
+ public List<Datum> getZeitpunkte(long isoJahr) {
+ Definition def = getDefinition();
+ ChinesischerKalender j = new ChinesischerKalender();
+ long tag = j.cDatumZuGenerisch(isoJahr, (int) def.getp1(), (int) def.getp2());
+ List daten = new ArrayList();
+ daten.add(new ISOKalender().vonTagen(tag));
+ return daten;
+ }
+
+ public List<Datum> getZeitpunkte2(long isoJahr) {
+ ISOKalender w = new ISOKalender();
+ long start = w.zuTagen(isoJahr, Definition.JANUAR, 1);
+ long ende = w.zuTagen(isoJahr, Definition.DEZEMBER, 31);
+
+ ChinesischerKalender j = new ChinesischerKalender();
+ Definition def = getDefinition();
+ List daten = new ArrayList();
+ long y = 0;
+ long tag = start;
+ long ersterJanuar = start;
+ while(tag < ende) {
+
+ // Neujahr vor dem 1.1. als generisches Datum
+ long cNeujahr = j.neujahrAmOderVor(ersterJanuar);
+
+ // Neujahrstag als chinesisches Datum, z.B. 7. Feb 2022 für Neujahr vor 1.1.2023
+ ChinesischesDatum cdNeujahr = j.vonTagen(cNeujahr);
+
+ // generisches Datum fuer den Tag des Ereignisses bestimmen,
+ // Ereignisse fallen nie auf Schaltmonate, deshalb schaltmonat auf false
+ tag = j.zuTagen(cdNeujahr.getZyklus(), (int) cdNeujahr.getJahr(), (int) def.getp1(),
+ false, (int) def.getp2());
+
+ // der Liste hinzufügen, wenn das Ereignis ins isoJahr fällt
+ if (tag >= start && tag <= ende) {
+ Datum d = w.vonTagen(tag);
+ daten.add(d);
+ }
+
+ // für nächstes Jahr wiederholen, bis das Ereignis nicht mehr im isoJahr liegt
+ ++y;
+ ersterJanuar = w.zuTagen(isoJahr+y, Definition.JANUAR, 1);
+ }
+ return daten;
+ }
+}
diff --git a/src/de/uhilger/zeitrechnung/ereignis/EinzelEreignis.java b/src/de/uhilger/zeitrechnung/ereignis/EinzelEreignis.java
index ae5fb41..4ce9094 100644
--- a/src/de/uhilger/zeitrechnung/ereignis/EinzelEreignis.java
+++ b/src/de/uhilger/zeitrechnung/ereignis/EinzelEreignis.java
@@ -19,6 +19,7 @@
import de.uhilger.zeitrechnung.Datum;
import de.uhilger.zeitrechnung.Definition;
+import de.uhilger.zeitrechnung.kalender.ChinesischerKalender;
import de.uhilger.zeitrechnung.kalender.HebraeischerKalender;
import de.uhilger.zeitrechnung.kalender.ISOKalender;
import java.util.ArrayList;
@@ -49,6 +50,10 @@
/** Typnummer fuer Jom Ha Zikaron */
public static final int EE_JOM_HA_ZIKARON = 4;
+
+ public static final int EE_CHINESISCHES_NEUJAHR = 5;
+
+ public static final int EE_QINGMING = 6;
/**
* Den Typ des Ereignisses ermitteln
@@ -74,26 +79,31 @@
Definition def = getDefinition();
int typ = (int) def.getp1();
ISOKalender g = new ISOKalender();
- HebraeischerKalender h = new HebraeischerKalender();
List daten = new ArrayList();
long tage;
switch(typ) {
case EE_SCHAVUOT:
- tage = h.passah(isoJahr);
+ tage = new HebraeischerKalender().passah(isoJahr);
daten.add(g.vonTagen(tage + 50));
break;
case EE_PURIM:
- tage = h.purim(isoJahr);
+ tage = new HebraeischerKalender().purim(isoJahr);
daten.add(g.vonTagen(tage));
break;
case EE_TA_ANIT_ESTHER:
- tage = h.taAnitEsther(isoJahr);
+ tage = new HebraeischerKalender().taAnitEsther(isoJahr);
daten.add(g.vonTagen(tage));
break;
case EE_JOM_HA_ZIKARON:
- tage = h.yomHaZikkaron(isoJahr);
+ tage = new HebraeischerKalender().yomHaZikkaron(isoJahr);
daten.add(g.vonTagen(tage));
break;
+ case EE_CHINESISCHES_NEUJAHR:
+ daten.add(g.vonTagen(new ChinesischerKalender().neujahr(isoJahr)));
+ break;
+ case EE_QINGMING:
+ daten.add(g.vonTagen(new ChinesischerKalender().qingMing(isoJahr)));
+ break;
}
return daten;
}
diff --git a/src/de/uhilger/zeitrechnung/ereignis/Ereignis.java b/src/de/uhilger/zeitrechnung/ereignis/Ereignis.java
index bfa923d..4aa0d15 100644
--- a/src/de/uhilger/zeitrechnung/ereignis/Ereignis.java
+++ b/src/de/uhilger/zeitrechnung/ereignis/Ereignis.java
@@ -60,6 +60,9 @@
/** Typnummer fuer JulianischesEreignis */
public static final int TYP_JULIANISCH = 9;
+ /** Typnummer fuer ChinesischesEreignis */
+ public static final int TYP_CHINESISCH = 10;
+
public static final int GREGORIANISCHER_KALENDER = 1;
public static final int JULIANISCHER_KALENDER = 2;
diff --git a/src/de/uhilger/zeitrechnung/ereignis/EreignisBasis.java b/src/de/uhilger/zeitrechnung/ereignis/EreignisBasis.java
index d99eb11..89d6f55 100644
--- a/src/de/uhilger/zeitrechnung/ereignis/EreignisBasis.java
+++ b/src/de/uhilger/zeitrechnung/ereignis/EreignisBasis.java
@@ -32,7 +32,7 @@
TagDatumEreignis.class.getName(), OsterEreignis.class.getName(),
JahreszeitEreignis.class.getName(), HebraeischesEreignis.class.getName(),
EinzelEreignis.class.getName(), MuslimischesEreignis.class.getName(),
- JulianischesEreignis.class.getName()
+ JulianischesEreignis.class.getName(), ChinesischesEreignis.class.getName()
};
/**
diff --git a/src/de/uhilger/zeitrechnung/ereignis/JulianischesEreignis.java b/src/de/uhilger/zeitrechnung/ereignis/JulianischesEreignis.java
index fa1ab01..bd1ccef 100644
--- a/src/de/uhilger/zeitrechnung/ereignis/JulianischesEreignis.java
+++ b/src/de/uhilger/zeitrechnung/ereignis/JulianischesEreignis.java
@@ -53,8 +53,7 @@
long anzahlJahre = (jEndJahr - jStartJahr) + (long) 1;
ArrayList list = new ArrayList();
for (long y = 0; y < anzahlJahre; y++) {
- Datum jDatum = new Datum(isoJahr + y, (int) definition.getp1(), (int) definition.getp2());
- long tage = j.zuTagen(jDatum);
+ long tage = j.zuTagen(jStartJahr + y, (int) definition.getp1(), (int) definition.getp2());
if(tage >= start && tage <= end) {
list.add(g.vonTagen(tage));
}
diff --git a/src/de/uhilger/zeitrechnung/kalender/BasisKalender.java b/src/de/uhilger/zeitrechnung/kalender/BasisKalender.java
index 7a726f2..bd70083 100644
--- a/src/de/uhilger/zeitrechnung/kalender/BasisKalender.java
+++ b/src/de/uhilger/zeitrechnung/kalender/BasisKalender.java
@@ -22,10 +22,12 @@
import de.uhilger.zeitrechnung.Zeit;
/**
- * Abstrakte Basisklasse fuer Klassen, die ein Kalendersystem implementieren
+ * Abstrakte Basisklasse fuer Klassen, die ein Kalendersystem implementieren.
+ *
+ * Hier sind neben allerlei relevanten Rechenmethoden die grundlegenden
+ * astronomischen Algorithmen für die Zeit- und Kalenderrechnung implementiert.
*
* @author Ulrich Hilger
- * @version 2, 1.10.2022
*/
public abstract class BasisKalender implements Zeitrechnung {
@@ -82,6 +84,12 @@
return nterTag(-1, t, datum);
}
+ /* ----- */
+
+ public double moduloAngepasst(double x, double y) {
+ return y + modulo(x, -y);
+ }
+
/* ---- Zeit ----- */
public double zuMoment(int stunde, int minute, double sekunde) {
@@ -100,7 +108,10 @@
return z;
}
- /* ----------- Mondphase ----------- */
+ /* ----------- Mond ----------- */
+
+ /** durchschnittliche Dauer eines Mondphasenzyklus (synodischer Monat) in Tagen */
+ public static final double MITTLERER_SYNODISCHER_MONAT = 29.530588853;
public double mondphase(double t) {
return modulo(mondLaenge(t) - solareLaenge(t), 360);
@@ -109,7 +120,7 @@
public double mondHoehe(double t, Ort ort) {
double phi = ort.getBreite();
double psi = ort.getLaenge();
- double varepsilon = obliquity(t);
+ double varepsilon = schiefstand(t);
double lambda = mondLaenge(t);
double beta = mondBreite(t);
double alpha = arcTanGrad(
@@ -266,6 +277,80 @@
private static final double[] siderealCoeff = new double[] {280.46061837, 36525 * 360.98564736629, 0.000387933, 1d/38710000};
}
+ public double neumondNach(double tee) {
+ return nterNeumond(1 + Math.round(tee / MITTLERER_SYNODISCHER_MONAT - mondphase(tee) / (double) (360)));
+ }
+
+ public double neumondVor(double tee) {
+ return nterNeumond(Math.round(tee / MITTLERER_SYNODISCHER_MONAT - mondphase(tee) / (double) (360)));
+ }
+
+ public double nterNeumond(long n) {
+ double k = n - 24724;
+ double c = k / 1236.85;
+ double approx = poly(c, nm.coeffApprox);
+ double capE = poly(c, nm.coeffCapE);
+ double solarAnomaly = poly(c, nm.coeffSolarAnomaly);
+ double lunarAnomaly = poly(c, nm.coeffLunarAnomaly);
+ double moonArgument = poly(c, nm.coeffMoonArgument);
+ double capOmega = poly(c, nm.coeffCapOmega);
+ double correction = -0.00017 * sinGrad(capOmega);
+ for(int ix = 0; ix < nm.sineCoeff.length; ++ix) {
+ correction += nm.sineCoeff[ix] * Math.pow(capE, nm.EFactor[ix]) *
+ sinGrad(nm.solarCoeff[ix] * solarAnomaly +
+ nm.lunarCoeff[ix] * lunarAnomaly +
+ nm.moonCoeff[ix] * moonArgument);
+ }
+ double additional = 0;
+ for(int ix = 0; ix < nm.addConst.length; ++ix) {
+ additional += nm.addFactor[ix] *
+ sinGrad(nm.addConst[ix] + nm.addCoeff[ix] * k);
+ }
+ double extra = 0.000325 * sinGrad(poly(c, nm.extra));
+ return universalVonDynamisch(approx + correction + extra + additional);
+ }
+ private static class nm {
+ private static final double[] coeffApprox = new double[] {730125.59765, MITTLERER_SYNODISCHER_MONAT * 1236.85, 0.0001337, -0.000000150, 0.00000000073};
+ private static final double[] coeffCapE = new double[] {1, -0.002516, -0.0000074};
+ private static final double[] coeffSolarAnomaly = new double[] {2.5534, 29.10535669 * 1236.85, -0.0000218, -0.00000011};
+ private static final double[] coeffLunarAnomaly = new double[] {201.5643, 385.81693528 * 1236.85, 0.0107438, 0.00001239, -0.000000058};
+ private static final double[] coeffMoonArgument = new double[] {160.7108, 390.67050274 * 1236.85, -0.0016341, -0.00000227, 0.000000011};
+ private static final double[] coeffCapOmega = new double[] {124.7746, -1.56375580 * 1236.85, 0.0020691, 0.00000215};
+ private static final byte[] EFactor = new byte[] {0, 1, 0, 0, 1, 1, 2, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+ private static final byte[] solarCoeff = new byte[] {0, 1, 0, 0, -1, 1, 2, 0, 0, 1, 0, 1, 1, -1, 2, 0, 3, 1, 0, 1, -1, -1, 1, 0};
+ private static final byte[] lunarCoeff = new byte[] {1, 0, 2, 0, 1, 1, 0, 1, 1, 2, 3, 0, 0, 2, 1, 2, 0, 1, 2, 1, 1, 1, 3, 4};
+ private static final byte[] moonCoeff = new byte[] {0, 0, 0, 2, 0, 0, 0, -2, 2, 0, 0, 2, -2, 0, 0, -2, 0, -2, 2, 2, 2, -2, 0, 0};
+ private static final double[] sineCoeff = new double[] {
+ -0.40720, 0.17241, 0.01608, 0.01039, 0.00739, -0.00514, 0.00208,
+ -0.00111, -0.00057, 0.00056, -0.00042, 0.00042, 0.00038, -0.00024,
+ -0.00007, 0.00004, 0.00004, 0.00003, 0.00003, -0.00003, 0.00003,
+ -0.00002, -0.00002, 0.00002
+ };
+ private static final double[] addConst = new double[] {
+ 251.88, 251.83, 349.42, 84.66, 141.74, 207.14, 154.84, 34.52, 207.19,
+ 291.34, 161.72, 239.56, 331.55
+ };
+ private static final double[] addCoeff = new double[] {
+ 0.016321, 26.641886, 36.412478, 18.206239, 53.303771, 2.453732,
+ 7.306860, 27.261239, 0.121824, 1.844379, 24.198154, 25.513099, 3.592518
+ };
+ private static final double[] addFactor = new double[] {
+ 0.000165, 0.000164, 0.000126, 0.000110, 0.000062, 0.000060, 0.000056,
+ 0.000047, 0.000042, 0.000040, 0.000037, 0.000035, 0.000023
+ };
+ private static final double[] extra = new double[] {
+ 299.77, 132.8475848, -0.009173
+ };
+ }
+
+ public double universalVonDynamisch(double tee) {
+ return tee - ephemeridenKorrektur(tee);
+ }
+
+ public double universalVonStandard(double teeS, Ort locale) {
+ return teeS - locale.getZeitzone() / 24;
+ }
+
/* ----------- Sonnenauf- und -untergang ----------- */
public double sonnenaufgang(long date, Ort ort) throws Exception {
@@ -312,7 +397,7 @@
public double zeitVonHorizont(double approx, Ort ort, double alpha) throws Exception {
double phi = ort.getBreite();
double t = universalVonLokal(approx, ort);
- double delta = arcSinGrad(sinGrad(obliquity(t)) * sinGrad(solareLaenge(t)));
+ double delta = arcSinGrad(sinGrad(schiefstand(t)) * sinGrad(solareLaenge(t)));
boolean morgen = modulo(approx, 1) < 0.5;
double sinusAbstand = tanGrad(phi) * tanGrad(delta) +
sinGrad(alpha) / (kosGrad(delta) * kosGrad(phi));
@@ -340,14 +425,14 @@
double laenge = poly(c, et.koeffLaenge);
double anomalie = poly(c, et.koeffAnomalie);
double exzentrizitaet = poly(c, et.koeffExzentrizitaet);
- double varepsilon = obliquity(t);
+ double varepsilon = schiefstand(t);
double y = quadrat(tanGrad(varepsilon / 2));
double equation = (1d / 2d / Math.PI) * (y * sinGrad(2 * laenge) +
-2 * exzentrizitaet * sinGrad(anomalie) +
4 * exzentrizitaet * y * sinGrad(anomalie) * kosGrad(2 * laenge) +
-0.5 * y * y * sinGrad(4 * laenge) +
-1.25 * exzentrizitaet * exzentrizitaet * sinGrad(2 * anomalie));
- return signum(equation) * Math.min(Math.abs(equation), stunde(12));
+ return vorzeichen(equation) * Math.min(Math.abs(equation), stunde(12));
}
private static class et {
private static final double[] koeffLaenge = new double[] {280.46645, 36000.76983, 0.0003032};
@@ -355,13 +440,13 @@
private static final double[] koeffExzentrizitaet = new double[] {0.016708617, -0.000042037, -0.0000001236};
}
- public double obliquity(double t) {
+ public double schiefstand(double t) {
double c = julJahrhunderte(t);
return winkel(23, 26, 21.448) + poly(c, coeffObliquity);
}
private final double[] coeffObliquity = new double[] {0, winkel(0, 0, -46.8150), winkel(0, 0, -0.00059), winkel(0, 0, 0.001813)};
- public int signum(double x) {
+ public int vorzeichen(double x) {
if(x < 0)
return -1;
else if(x > 0)
@@ -400,7 +485,8 @@
/* ---------------- Jahreszeiten ----- */
- public static final double TROPISCHES_JAHR = 365.242189;
+ /** durchschnittliche Dauer eines Umlaufs der Erde um die Sonne in Tagen */
+ public static final double MITTLERES_TROPISCHES_JAHR = 365.242189;
public double standardVonUniversal(double t, Ort ort) {
return t + ort.getZeitzone() / 24;
@@ -408,7 +494,7 @@
public double solareLaengeNach(double t, double phi) {
double varepsilon = 0.00001;
- double rate = TROPISCHES_JAHR / (double) 360;
+ double rate = MITTLERES_TROPISCHES_JAHR / (double) 360;
double tau = t + rate * modulo(phi - solareLaenge(t), 360);
double l = Math.max(t, tau - 5);
double u = tau + 5;
@@ -437,6 +523,13 @@
return modulo(laenge + aberration(t) + nutation(t), 360);
}
+ public double geschaetzteSolareLaengeVor(double tee, double phi) {
+ double rate = MITTLERES_TROPISCHES_JAHR / (double) (360);
+ double tau = tee - rate * modulo(solareLaenge(tee) - phi, 360);
+ double capDelta = modulo(solareLaenge(tau) - phi + (double) (180), 360) - (double) (180);
+ return Math.min(tee, tau - rate * capDelta);
+ }
+
public double julJahrhunderte(double t) {
return (dynamischVonUniversal(t) - j2000()) / 36525;
}
diff --git a/src/de/uhilger/zeitrechnung/kalender/ChinesischerKalender.java b/src/de/uhilger/zeitrechnung/kalender/ChinesischerKalender.java
new file mode 100644
index 0000000..aaad010
--- /dev/null
+++ b/src/de/uhilger/zeitrechnung/kalender/ChinesischerKalender.java
@@ -0,0 +1,227 @@
+/*
+ Zeitrechnung - a class library to determine calendar events
+ Copyright (c) 1984-2023 Ulrich Hilger, http://uhilger.de
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package de.uhilger.zeitrechnung.kalender;
+
+import de.uhilger.zeitrechnung.ChinesischesDatum;
+import de.uhilger.zeitrechnung.Datum;
+import de.uhilger.zeitrechnung.Definition;
+import de.uhilger.zeitrechnung.Ort;
+
+/**
+ * Der traditionelle chinesichen Kalender ist unterteilt in Mond- und Sonnenjahr.
+ * Das Sonnenjahr (sui) beginnt am Tag der Wintersonnenwende ist weiter unterteilt
+ * in solare Abschnitte und noch weiter unterteilt in solare Haupt- und Unterabschnitte.
+ *
+ * Die Bahn, die die Sonne innerhalb eines tropischen Jahres von 365,24 Tagen scheinbar
+ * auf der Ekliptik durchläuft, wird in 24 Teile von je 15 Grad unterteilt. Dies sind die 24
+ * Stationen oder Jahreseinteilungen (節氣 / 节气, jiéqì). Jede zweite Station ist ein
+ * Zhongqi (中氣 / 中气, zhōngqì – „zentrale/Haupt-Jahreseinteilung“), wobei die Sonnenwenden
+ * und Tagundnachtgleichen vier der zwölf Zhongqi sind. Der zeitliche Abstand von einem
+ * Zhongqi zum nächsten beträgt im Mittel ein Zwölftel eines tropischen Jahres oder 30,44 Tage.
+ * Er variiert leicht aufgrund der elliptischen Umlaufbahn der Erde um die Sonne.
+ *
+ * Jeweils sechs Jahreseinteilungen gehören zu einer Jahreszeit. Während aber im westlichen
+ * Kalender die Jahreszeiten mit dem Tag der Sonnenwende bzw. der Tagundnachtgleiche beginnen,
+ * liegen im chinesischen Kalender diese Tage in der Mitte der jeweiligen Jahreszeit. Man zählt
+ * die Stationen beginnend mit dem Frühlingsanfang – lichun, und mancherorts gilt der
+ * Frühlingsanfang (und nicht die Wintersonnenwende) als Beginn des sui-Jahres.
+ *
+ * Eine Besonderheit des Chinesischen Kalenders ist, dass ein Chinesisches Datum neben
+ * Tag, Monat und Jahr auch den Zyklus und die Angabe zum Schaltmonat benoetigt. Um
+ * die Schnittstelle Wandler vollstaendig implementieren zu koennen, werden
+ * die Methoden setZyklus und setSchaltmonat zusaetzlich eingebaut.
+ *
+ * Bei Nutzung der Wandler-Schnittstelle sollte im Falle des Chinesischen Kalenders
+ * darauf geachtet werden, dass der Methode zuTagen() entweder ein Datum der
+ * Klasse ChinesischesDatum uebergeben wird oder zuvor setZyklus und setSchaltmonat genutzt wird.
+ * Auch vor Nutzung der Methode zuTagen(jahr, monat, tag) muss zuvor setZyklus und
+ * setSchaltmonat genutzt oder stattdessen die Methode
+ * zuTagen(zyklus, jahr, monat, schaltmonat, tag) verwendet werden.
+ *
+ * @author Ulrich Hilger
+ */
+public class ChinesischerKalender extends BasisKalender implements Wandler {
+
+ public static final long STARTTAG = new ISOKalender().zuTagen(-2636, Definition.FEBRUAR, 15);
+
+ private long zyklus;
+ private boolean schaltmonat;
+
+ public void setZyklus(long zyklus) {
+ this.zyklus = zyklus;
+ }
+
+ public void setSchaltmonat(boolean schaltmonat) {
+ this.schaltmonat = schaltmonat;
+ }
+
+ public long zuTagen(long zyklus, int jahr, int monat, boolean schaltmonat, int tag) {
+ this.zyklus = zyklus;
+ this.schaltmonat = schaltmonat;
+ return zuTagen(jahr, monat, tag);
+ }
+
+ @Override
+ public long zuTagen(long jahr, int monat, int tag) {
+ long midYear = (long)Math.floor(STARTTAG + ((zyklus - 1) * 60 + (jahr - 1) + .5) * MITTLERES_TROPISCHES_JAHR);
+ long theNewYear = neujahrAmOderVor(midYear);
+ long p = chinesischerNeumondAmOderNach(theNewYear + 29 * (monat - 1));
+ ChinesischesDatum d = vonTagen(p);
+ long priorNewMoon = monat == d.getMonat() && schaltmonat == d.isSchaltmonat() ?
+ p :
+ chinesischerNeumondAmOderNach(p + 1);
+ return priorNewMoon + tag - 1;
+ }
+
+ @Override
+ public long zuTagen(Datum d) {
+ if(d instanceof ChinesischesDatum) {
+ ChinesischesDatum cd = (ChinesischesDatum) d;
+ return zuTagen(cd.getZyklus(), (int) cd.getJahr(), cd.getMonat(), cd.isSchaltmonat(), cd.getTag());
+ } else {
+ return zuTagen(zyklus, (int) d.getJahr(), d.getMonat(), schaltmonat, d.getTag());
+ }
+ }
+
+ @Override
+ public ChinesischesDatum vonTagen(long tage) {
+ long s1 = winterSonnenwendeAmOderVor(tage);
+ long s2 = winterSonnenwendeAmOderVor(s1 + 370);
+ long m12 = chinesischerNeumondAmOderNach(s1 + 1);
+ long nextM11 = chinesischerNeumondVor(s2 + 1);
+ long m = chinesischerNeumondVor(tage + 1);
+ boolean leapYear = Math.round((nextM11 - m12) / MITTLERER_SYNODISCHER_MONAT) == 12;
+ int month = (int)moduloAngepasst(
+ (long)Math.round((m - m12) / MITTLERER_SYNODISCHER_MONAT) -
+ (leapYear && hatSchaltmonatVorher(m12, m) ? 1 : 0),
+ 12);
+ boolean leapMonth = leapYear &&
+ keinSolarerHauptabschnitt(m) &&
+ !hatSchaltmonatVorher(m12, chinesischerNeumondVor(m));
+ long elapsedYears = (long)Math.floor(1.5 - (month / 12d) + (tage - STARTTAG) / MITTLERES_TROPISCHES_JAHR);
+ long cycle = ganzzahlQuotient(elapsedYears - 1, 60) + 1;
+ int year = (int)moduloAngepasst(elapsedYears, 60);
+ int day = (int)(tage - m + 1);
+ return new ChinesischesDatum(cycle, year, month, leapMonth, day);
+ }
+
+ /* ---- */
+
+ public boolean hatSchaltmonatVorher(long mPrime, long m) {
+ return m >= mPrime && (keinSolarerHauptabschnitt(m) || hatSchaltmonatVorher(mPrime, chinesischerNeumondVor(m)));
+ }
+
+ public double mitternachtInChina(long date) {
+ return universalVonStandard(date, chinesischerOrt(date));
+ }
+
+ public final Ort peking(double tee) {
+ ISOKalender g = new ISOKalender();
+ long year = g.jahrVonTagen((long)Math.floor(tee));
+ return new Ort("Peking", (double) (39.55), winkel(116,25,0),
+ (double) (43.5), year < 1929 ? 1397d/180 : 8);
+ }
+
+ public final Ort chinesischerOrt(double tee) {
+ return peking(tee);
+ }
+
+ public long neujahrAmOderVor(long tage) {
+ long neujahr = neujahrInSui(tage);
+ return tage >= neujahr ? neujahr : neujahrInSui(tage - 180);
+ }
+
+ public long neujahrInSui(long tage) {
+ long s1 = winterSonnenwendeAmOderVor(tage);
+ long s2 = winterSonnenwendeAmOderVor(s1 + 370);
+ long m12 = chinesischerNeumondAmOderNach(s1 + 1);
+ long m13 = chinesischerNeumondAmOderNach(m12 + 1);
+ long nextM11 = chinesischerNeumondVor(s2 + 1);
+ if((Math.round((nextM11 - m12) / MITTLERER_SYNODISCHER_MONAT) == 12) && (keinSolarerHauptabschnitt(m12) || keinSolarerHauptabschnitt(m13))) {
+ return chinesischerNeumondAmOderNach(m13 + 1);
+ } else {
+ return m13;
+ }
+ }
+
+ public long neujahr(long gYear) {
+ ISOKalender g = new ISOKalender();
+ return neujahrAmOderVor(g.zuTagen(gYear, Definition.JULI, 1));
+ }
+
+ public long qingMing(long gYear) {
+ ISOKalender g = new ISOKalender();
+ return (long)Math.floor(solarerNebenabschnittAmOderNach(g.zuTagen(gYear, Definition.MAERZ, 30)));
+ }
+
+ public long cDatumZuGenerisch(long isoJahr, int cMonat, int cTag) {
+ ISOKalender g = new ISOKalender();
+ long elapsedYears = isoJahr - g.jahrVonTagen(STARTTAG) + 1;
+ long cycle = ganzzahlQuotient(elapsedYears - 1, 60) + 1;
+ int year = (int)moduloAngepasst(elapsedYears, 60);
+ return zuTagen(cycle, year, cMonat, false, cTag);
+ }
+
+ public long winterSonnenwendeAmOderVor(long date) {
+ double approx = geschaetzteSolareLaengeVor(mitternachtInChina(date + 1), Definition.WINTER);
+ long i;
+ for(i = (long)(Math.floor(approx) - 1); !(Definition.WINTER <= solareLaenge(mitternachtInChina(i + 1))); ++i);
+ return i;
+ }
+
+ public boolean keinSolarerHauptabschnitt(long date) {
+ return aktuellerSolarerHauptabschnitt(date) ==
+ aktuellerSolarerHauptabschnitt(chinesischerNeumondAmOderNach(date + 1));
+ }
+
+ public int aktuellerSolarerHauptabschnitt(long date) {
+ double s = solareLaenge(standardVonUniversal(date, chinesischerOrt(date)));
+ return (int)moduloAngepasst(2 + ganzzahlQuotient(s, (double) (30)), 12);
+ }
+
+ public double solarerHauptabschnittAmOderNach(long date) {
+ double l = modulo(30 * Math.ceil(solareLaenge(mitternachtInChina(date)) / 30), 360);
+ return chinesischeSolareLaengeAmOderNach(date, l);
+ }
+
+ public double solarerNebenabschnittAmOderNach(long date) {
+ double l = modulo(30 * Math.ceil((solareLaenge(mitternachtInChina(date)) - (double) (15)) / 30) + (double) (15), 360);
+ return chinesischeSolareLaengeAmOderNach(date, l);
+ }
+
+ public double chinesischeSolareLaengeAmOderNach(long date, double theta) {
+ Ort beijing = chinesischerOrt(date);
+ double tee = solareLaengeNach(standardVonUniversal(date, beijing), theta);
+ return standardVonUniversal(tee, beijing);
+ }
+
+ public int aktuellerSolarerUnterabschnitt(long date) {
+ double s = solareLaenge(mitternachtInChina(date));
+ return (int)moduloAngepasst(3 + ganzzahlQuotient(s - (double) (15), (double) (30)), 12);
+ }
+
+ public long chinesischerNeumondAmOderNach(long date) {
+ double t = neumondNach(mitternachtInChina(date));
+ return (long)Math.floor(standardVonUniversal(t, chinesischerOrt(t)));
+ }
+
+ public long chinesischerNeumondVor(long date) {
+ double t = neumondVor((long) mitternachtInChina(date));
+ return (long)Math.floor(standardVonUniversal(t, chinesischerOrt(t)));
+ }
+}
--
Gitblit v1.9.3