El calendario Java implementa términos solares
{
int fuente;
int SolarYear
int SolarMonth
int SolarDate
Período del calendario lunar;
Período del mes del calendario lunar;
int LunarDate
int día laborable;
int Kan< /p >
int Chih
};
unsigned _ _ int 64m _ ui 64 términos solares[24];
unsigned _ _ int 64m _ ui64 días del mes[13];
m_ui64 días del mes[0]= 0ui 64;
m_ui64 días del mes[1]= 31ui 64;
m_ui64 días del mes[2]= 28ui 64;
m_ui64 días del mes[3]= 31ui 64;
m_ui64 días del mes[4]= 30ui 64 ;
m _ ui64 días del mes[5]= 31ui 64;
m _ ui64 días del mes[6]= 30ui 64;
m _ ui64 días del mes[7]= 31ui 64;
m_ui64 días del mes[8]= 31ui 64;
m_ui64 días del mes[9]= 30ui 64;
m_ui64 días del mes[10]= 31ui 64 ;
m_ui 64 días del mes[11]= 30ui 64;
m_ui64 días del mes[12] = 31ui 64;
m _ ui 64 solarterms[0 ]= 0ui 64;
m _ ui 64 solarterms[1]= 21208 ui 64;
m _ ui 64 solarterms[2]= 42467 ui 64;
m _ ui 64 solarterms[3]= 63836 ui 64;
m _ ui 64 solarterms[4]= 85337 ui 64
m _ ui 64 solarterms[5] = 107014ui 64;
m _ ui 64 solarterms[6]= 128867 ui 64;
m _ ui 64 solarterms[7]= 150921ui 64;
m _ ui 64 solarterms[8]= 173149 ui 64;
m _ ui 64 solarterms[9]= 195551ui 64
m _ ui 64 solarterms[10]= 218072 ui 64;
m _ ui 64 términos solares[11]= 240693 ui 64;
m _ ui 64 términos solares[12]= 263343 ui 64;
m _ ui 64 solarterms[13]= 285989 ui 64;
m _ ui 64 solarterms[14]= 308563 ui 64;
m_ui 64 solarterms;
[15]= 331033 ui 64;
m _ ui 64 solarterms[16]= 353350 ui 64;
m _ ui 64 solarterms[17]= 375494 ui 64;
p>
m _ ui 64 solarterms[18]= 397447 ui 64;
m _ ui 64 solarterms[19]= 419210ui 64;
m _ ui 64 solarterms[ 20]= 440795 ui 64;
m_ui 64 solarterms[21]= 462224 ui 64;
m _ ui 64 solarterms[22]= 483532 ui 64;
m _ ui 64 solarterms[23]= 504758 ui 64;
/* Cálculo de 24 términos solares*/
int _ _ la llamada rápida es el año bisiesto (int iYear)
{
Si ((iYear & amp3) != 0)
{
Devuelve 0;
}
si no (iAño % 100!= 0)
{
Devuelve 1;
}
else if (iYear % 400 == 0)
{
Devolución 1;
}
Otro
{
Devuelve 0;
}
}
int _ _ llamada rápida TheSolarTerm(int iYear , int n)
{
Sin firmar _ _ int 64k
sin firmar _ _ int 64 ddate _ utc = 22085493000000 ui 64
unsigned __int64 doffdate, dadddate
fecha doff = m _ ui 64 solarterms[n]* 600000 ui 64
fecha doff+= static _ cast & lt; & gt( iYear-1900)* 315569259747 ui 64;
fecha de salida-= ddate _ utc
fecha de salida/= 864000000 ui 64; 24 * 1000
int I = 1969;
dadddate = 0ui64
mientras(dadddate & lt;doffdate)
{
i++;
k = dadddate
dadd date+= 365 ui 64+static _ cast & lt;unsigned _ _ int64 & gt(IsLeapYear(I));
};
if(dadddate & gt;doffdate)
{
int j = 0;
dadd fecha = k;
mientras(dadddate & lt;doffdate & amp& ampj & lt12)
{
j++;
k = fechapapá
p>
dadd fecha+= m _ ui 64 días del mes[j];
if(j == 2 & amp; & amp(IsLeapYear(i)!= 0))
{
fecha papá++;
}
};
Devolver static_cast<int>(fecha papá- k+1ui 64);
}
else // j = doffdate
{
Retorno 1;
}
}
int CalConv(struct ConvDate & amp; disco)
{
int salto, d, sm, y, im, l1, l2, acc, I, lm, KC;
If (cd. Source == 0) /* Solar */
{
if (cd. SolarYear & lt=primer año || cd SolarYear & gt el año pasado)
{
Retorno 1;
}
p>sm = cd. mes solar-1;
if(sm & lt; 0 | | sm & gt11)
{
retorno 2;
}
salto = GetLeap(cd.año solar);
d = (sm == 1)? (Salto + 28): cal solar[sm];
If (cd. SolarDate & lt1 || cd. SolarDate & gtd)
{
Regresar 3;
}
y = cd. SolarYear - primer año;
acc = SolarDays[leap][sm] + cd. FechaSolar
CD. Día laborable = (acc + LunarCal[y]). día laborable base)% 7;
kc = acc + LunarCal[y]. BaseKanChih
CD. Kan = KC % 10;
CD. chih = KC % 12;
if(ACC & lt; = LunarCal[y]. Fecha base)
{
y-;
CD. Año Lunar = cd. oreja solar-1;
salto = GetLeap(cd.lunar año);
sm+= 12
acc = SolarDays[leap][sm] + cd. SolarDate
}
Otro
{
CD. Año Lunar = cd. AñoSolar
}
l1 = Cal Lunar[y]. día base;
for(I = 0;i<13;i++)
{
l2 = l1 + LunarCal[y]. mes días[I]+29;
if(ACC & lt; = l2)
{
Descanso;
}
l 1 = L2;
}
CD. mes lunar = I+1;
CD. fecha lunar = ACC-l 1;
im = LunarCal[y].
intercalación;
if (im != 0 & amp& amp disc. LunarMonth & gt im)
{
cd. mes lunar-;
if (cd. LunarMonth == im)
{
CD. mes lunar = -im;
}
}
if (cd. LunarMonth & gt12)
{
CD. mes lunar-= 12;
}
}
else /* Lunar */
{
if (cd. LunarYear & lt primer año || cd. LunarYear & gt = año pasado)
{
Retorno 1;
}
y = CD. Año Nuevo Lunar - Año 1;
im = LunarCal[y]. intercalación;
lm = cd. Mes Lunar
if(lm & lt; 0)
{
if (lm!= -im)
{
devolver 2;
}
}
si no(lm & lt; 1 | | lm & gt; 12)
{
devuelve 2;
}
si (¡im!= 0)
{
si(lm & gt;im)
{
lm++;
}
si no (lm == -im)
{
lm = soy+1;
}
}
lm-;
p>
If (cd. LunarDate & gtLunarCal[y]. Días en el mes [lm] + 29)
{
Return 3;
}
acc = LunarCal[y]. día base;
for(I = 0;i<lm;i++)
{
acc += LunarCal[y]. mes días[I]+29;
}
acc += cd. LunarDate
salto = GetLeap(cd.año lunar);
for(I = 13; i>= 0; i-)
{
if(ACC & gt; días solares[salto][i])
{
Descanso;
}
}
CD. fecha solar = ACC-días solares[salto][I];
if (i<=11)
{
CD. AñoSolar = cd. Año Lunar
CD. mes solar = I+1;
}
Otros
{
CD. AñoSolar = cd. año lunar+1;
CD. mes solar = I-11;
}
salto = GetLeap(cd. año solar); SolarYear - primer año;
acc = SolarDays[leap][cd. MesSolar - 1] + cd. FechaSolar
CD.
Día laborable = (acc + LunarCal[y]). día laborable base)% 7;
kc = acc + LunarCal[y]. BaseKanChih
CD. Kan = KC % 10;
CD. chih = KC % 12;
}
Devuelve 0;
}