/// <summary>
/// 命理八字计算(普通计算, 不转换为当地真太阳时), 并保存到日对象 ob 中
/// </summary>
/// <param name="jd">格林尼治UT(J2000起算)</param>
/// <param name="J">本地经度</param>
/// <param name="ob">日对象</param>
/// <param name="southernHemisphere">南半球的标志</param>
public static void mingLiBaZiNormal(double jd, double J, OB ob, BaZiTypeS baziTypeS)
{
int i;
string c;
double v;
double jd2 = jd + JD.deltatT2(jd); // 力学时
double w = XL.S_aLon(jd2 / 36525, -1); // 此刻太阳视黄经
double k = LunarHelper.int2((w / LunarHelper.pi2 * 360 + 45 + 15 * 360) / 30); // 1984年立春起算的节气数(不含中气)
//----------------------------------------------------------------------------------------------
// C#: 注: 仅有下列代码段与 mingLiBaZi 方法中的代码不同, 其余部分都是相同的
//----------------------------------------------------------------------------------------------
jd += 0 - J / Math.PI / 2; // 将格林尼治UT(J2000起算), 转换为本地时间, 不必考虑真太阳与平太阳时之间的时差
ob.bz_zty = ""; // 真太阳时置空串
ob.bz_pty = JD.timeStr(jd); // 计算平太阳时
jd += 13d / 24d; // 转为前一日23点起算(原jd为本日中午12点起算) // C#: 注意数据类型
double D = Math.Floor(jd), SC = LunarHelper.int2((jd - D) * 12); // 日数与时辰
v = LunarHelper.int2(k / 12 + 6000000); ob.bz_jn = obb.Gan[(int)(v % 10)] + obb.Zhi[(int)(v % 12)];
v = k + 2 + 60000000; ob.bz_jy = obb.Gan[(int)(v % 10)] + obb.Zhi[(int)(v % 12)];
// C#: 新增的代码段, 计算南半球八字(仅纪月不同)
switch (baziTypeS)
{
case BaZiTypeS.TianChongDiChong:
ob.bz_jy = obb.Gan[(int)((v + 4) % 10)] + obb.Zhi[(int)((v + 6) % 12)];
break;
case BaZiTypeS.TianKeDiChong:
ob.bz_jy = obb.Gan[(int)((v + 6) % 10)] + obb.Zhi[(int)((v + 6) % 12)];
break;
case BaZiTypeS.TianTongDiChong:
ob.bz_jy = obb.Gan[(int)((v + 0) % 10)] + obb.Zhi[(int)((v + 6) % 12)];
break;
default:
break;
}
v = D - 6 + 9000000; ob.bz_jr = obb.Gan[(int)(v % 10)] + obb.Zhi[(int)(v % 12)];
v = (D - 1) * 12 + 90000000 + SC; ob.bz_js = obb.Gan[(int)(v % 10)] + obb.Zhi[(int)(v % 12)];
v -= SC;
ob.bz_JS = ""; // 全天纪时表
for (i = 0; i < 13; i++)
{
// 一天中包含有13个纪时
c = obb.Gan[(int)((v + i) % 10)] + obb.Zhi[(int)((v + i) % 12)]; // 各时辰的八字
if (SC == i)
{
ob.bz_js = c;
// c = "<font color=red>" + c + "</font>"; //红色显示这时辰 // C#: 注释, 即取消格式显示
}
ob.bz_JS += (i != 0 ? " " : "") + c;
}
}
/// <summary>
/// 较高精度朔计算
/// </summary>
/// <param name="W"></param>
/// <returns></returns>
private static double so_high(double W)
{
double t = XL.MS_aLon_t2(W) * 36525;
t = t - JD.deltatT2(t) + 8d / 24d;
double v = ((t + 0.5) % 1) * 86400;
if (v < 600 || v > 86400 - 600)
{
t = XL.MS_aLon_t(W) * 36525 - JD.deltatT2(t) + 8d / 24d;
}
return(t);
}
/// <summary>
/// 月亮到中升降时刻计算,传入jd含义与St()函数相同
/// </summary>
/// <param name="jd"></param>
/// <returns></returns>
public static LunarInfoListT <double> Mt(double jd)
{
SZJ.dt = JD.deltatT2(jd);
SZJ.E = ZB.hcjj(jd / 36525);
jd -= LunarHelper.mod2(0.1726222 + 0.966136808032357 * jd - 0.0366 * SZJ.dt - SZJ.L / LunarHelper.pi2, 1); //查找最靠近当日中午的月上中天,mod2的第1参数为本地时角近似值
LunarInfoListT <double> r = new LunarInfoListT <double>(3, 0d);
double sv = LunarHelper.pi2 * 0.966;
r.z__ = r.s__ = r.j__ = r.c__ = r.h__ = jd;
SZJ.Mcoord(jd, 1, r); //月亮坐标
r.s__ += (-r.H0 - r.H) / sv;
r.j__ += (r.H0 - r.H) / sv;
r.z__ += (0 - r.H) / sv;
SZJ.Mcoord(r.s__, 1, r); r.s__ += (-r.H0 - r.H) / sv;
SZJ.Mcoord(r.j__, 1, r); r.j__ += (+r.H0 - r.H) / sv;
SZJ.Mcoord(r.z__, 0, r); r.z__ += (0 - r.H) / sv;
return(r);
}
/// <summary>
/// 太阳到中升降时刻计算,传入jd是当地中午12点时间对应的2000年首起算的格林尼治时间UT
/// </summary>
/// <param name="jd"></param>
/// <returns></returns>
public static LunarInfoListT <double> St(double jd)
{
SZJ.dt = JD.deltatT2(jd);
SZJ.E = ZB.hcjj(jd / 36525);
jd -= LunarHelper.mod2(jd - SZJ.L / LunarHelper.pi2, 1); //查找最靠近当日中午的日上中天,mod2的第1参数为本地时角近似值
LunarInfoListT <double> r = new LunarInfoListT <double>(3, 0d);
double sv = LunarHelper.pi2;
r.z__ = r.s__ = r.j__ = r.c__ = r.h__ = jd;
SZJ.Scoord(jd, 1, 1, r); //太阳坐标
r.s__ += (-r.H0 - r.H) / sv; //升起
r.j__ += (r.H0 - r.H) / sv; //降落
r.c__ += (-r.H1 - r.H) / sv; //民用晨
r.h__ += (r.H1 - r.H) / sv; //民用昏
r.z__ += (0 - r.H) / sv; //中天
SZJ.Scoord(r.s__, 1, 0, r); r.s__ += (-r.H0 - r.H) / sv;
SZJ.Scoord(r.j__, 1, 0, r); r.j__ += (+r.H0 - r.H) / sv;
SZJ.Scoord(r.c__, 0, 1, r); r.c__ += (-r.H1 - r.H) / sv;
SZJ.Scoord(r.h__, 0, 1, r); r.h__ += (+r.H1 - r.H) / sv;
SZJ.Scoord(r.z__, 0, 0, r); r.z__ += (0 - r.H) / sv;
return(r);
}
/// <summary>
/// 计算公历某一个月的"公农回"三合历, 并把相关信息保存到月对象 lun, 以及日对象 lun[?] 中
/// </summary>
/// <param name="By">要计算月历的年</param>
/// <param name="Bm">要计算月历的月</param>
public void yueLiCalc(int By, int Bm)
{
int i, j;
double c, Bd0, Bdn;
// 日历物件初始化
JD.h = 12; JD.m = 0; JD.s = 0.1;
JD.Y = By; JD.M = Bm; JD.D = 1; Bd0 = LunarHelper.int2(JD.toJD()) - LunarHelper.J2000; // 公历某年的月首,中午
JD.M++;
if (JD.M > 12)
{
JD.Y++; JD.M = 1;
} // C#: 如果月份大于 12, 则年数 + 1, 月数取 1
Bdn = LunarHelper.int2(JD.toJD()) - LunarHelper.J2000 - Bd0; // 本月天数(公历)
this.w0 = (Bd0 + LunarHelper.J2000 + 1) % 7; //本月第一天的星期
this.y = By; // 公历年份
this.m = Bm; // 公历月分
this.d0 = Bd0;
this.dn = Bdn;
// 所属公历年对应的农历干支纪年
c = By - 1984 + 9000;
this.Ly = obb.Gan[(int)(c % 10)] + obb.Zhi[(int)(c % 12)]; //干支纪年
this.ShX = obb.ShX[(int)(c % 12)]; // 该年对应的生肖
this.nianhao = obb.getNH(By);
double D, w;
OB ob, ob2;
// 循环提取各日信息
for (i = 0, j = 0; i < Bdn; i++)
{
ob = (this.lun[i]);
ob.d0 = Bd0 + i; // 儒略日,北京时12:00
ob.di = i; // 公历月内日序数
ob.y = By; // 公历年
ob.m = Bm; // 公历月
ob.dn = Bdn; // 公历月天数
ob.week0 = this.w0; // 月首的星期
ob.week = (this.w0 + i) % 7; // 当前日的星期
ob.weeki = LunarHelper.int2((this.w0 + i) / 7); // 本日所在的周序号
ob.weekN = LunarHelper.int2((this.w0 + Bdn - 1) / 7) + 1; // 本月的总周数
JD.setFromJD(ob.d0 + LunarHelper.J2000); ob.d = (int)JD.D; //公历日名称
// 农历月历
if (SSQ.ZQ.Count == 0 || ob.d0 < SSQ.ZQ[0] || ob.d0 >= SSQ.ZQ[24]) // 如果d0已在计算农历范围内则不再计算
{
SSQ.calcY(ob.d0);
}
int mk = (int)LunarHelper.int2((ob.d0 - SSQ.HS[0]) / 30); if (mk < 13 && SSQ.HS[mk + 1] <= ob.d0)
{
mk++; // 农历所在月的序数
}
ob.Ldi = (int)(ob.d0 - SSQ.HS[mk]); // 距农历月首的编移量,0对应初一
ob.Ldc = obb.rmc[(int)(ob.Ldi)]; // 农历日名称
ob.cur_dz = ob.d0 - SSQ.ZQ[0]; // 距冬至的天数
ob.cur_xz = ob.d0 - SSQ.ZQ[12]; // 距夏至的天数
ob.cur_lq = ob.d0 - SSQ.ZQ[15]; // 距立秋的天数
ob.cur_mz = ob.d0 - SSQ.ZQ[11]; // 距芒种的天数
ob.cur_xs = ob.d0 - SSQ.ZQ[13]; // 距小暑的天数
if (ob.d0 == SSQ.HS[mk] || ob.d0 == Bd0)
{
// 月的信息
ob.Lmc = SSQ.ym[mk]; // 月名称
ob.Ldn = SSQ.dx[mk]; // 月大小
ob.Lleap = (SSQ.leap != 0 && SSQ.leap == mk) ? "闰" : ""; // 闰状况
ob.Lmc2 = mk < 13 ? SSQ.ym[mk + 1] : "未知"; // 下个月名称,判断除夕时要用到
}
else
{
ob2 = (this.lun[i - 1]);
ob.Lmc = ob2.Lmc; ob.Ldn = ob2.Ldn;
ob.Lleap = ob2.Lleap; ob.Lmc2 = ob2.Lmc2;
}
int qk = (int)LunarHelper.int2((ob.d0 - SSQ.ZQ[0] - 7) / 15.2184); if (qk < 23 && ob.d0 >= SSQ.ZQ[qk + 1])
{
qk++; //节气的取值范围是0-23
}
if (ob.d0 == SSQ.ZQ[qk])
{
ob.Ljq = obb.jqmc[qk];
}
else
{
ob.Ljq = "";
}
ob.yxmc = ob.yxjd = ob.yxsj = ""; // 月相名称,月相时刻(儒略日),月相时间串
ob.jqmc = ob.jqjd = ob.jqsj = ""; // 定气名称,节气时刻(儒略日),节气时间串
// 干支纪年处理
// 以立春为界定年首
D = SSQ.ZQ[3] + (ob.d0 < SSQ.ZQ[3] ? -365 : 0) + 365.25 * 16 - 35; //以立春为界定纪年
ob.Lyear = Math.Floor(D / 365.2422 + 0.5); //农历纪年(10进制,1984年起算)
// 以下几行以正月初一定年首
D = SSQ.HS[2]; // 一般第3个月为春节
for (j = 0; j < 14; j++)
{
// 找春节
if (SSQ.ym[j] != "正")
{
continue;
}
D = SSQ.HS[j];
if (ob.d0 < D)
{
D -= 365; break;
} // 无需再找下一个正月
}
D = D + 5810; // 计算该年春节与1984年平均春节(立春附近)相差天数估计
ob.Lyear0 = Math.Floor(D / 365.2422 + 0.5); // 农历纪年(10进制,1984年起算)
D = ob.Lyear + 9000;
ob.Lyear2 = obb.Gan[(int)(D % 10)] + obb.Zhi[(int)(D % 12)]; // 干支纪年(立春)
D = ob.Lyear0 + 9000;
ob.Lyear3 = obb.Gan[(int)(D % 10)] + obb.Zhi[(int)(D % 12)]; // 干支纪年(正月)
ob.Lyear4 = ob.Lyear0 + 1984 + 2698; // 黄帝纪年
// 纪月处理,1998年12月7(大雪)开始连续进行节气计数,0为甲子
mk = (int)LunarHelper.int2((ob.d0 - SSQ.ZQ[0]) / 30.43685);
if (mk < 12 && ob.d0 >= SSQ.ZQ[2 * mk + 1])
{
mk++; //相对大雪的月数计算,mk的取值范围0-12
}
D = mk + LunarHelper.int2((SSQ.ZQ[12] + 390) / 365.2422) * 12 + 900000; //相对于1998年12月7(大雪)的月数,900000为正数基数
ob.Lmonth = D % 12;
ob.Lmonth2 = obb.Gan[(int)(D % 10)] + obb.Zhi[(int)(D % 12)];
// 纪日,2000年1月7日起算
D = ob.d0 - 6 + 9000000;
ob.Lday2 = obb.Gan[(int)(D % 10)] + obb.Zhi[(int)(D % 12)];
// 星座
mk = (int)LunarHelper.int2((ob.d0 - SSQ.ZQ[0] - 15) / 30.43685); if (mk < 11 && ob.d0 >= SSQ.ZQ[2 * mk + 2])
{
mk++; //星座所在月的序数,(如果j=13,ob.d0不会超过第14号中气)
}
ob.XiZ = obb.XiZ[(int)((mk + 12) % 12)] + "座";
// 回历
oba.getHuiLi(ob.d0, ob);
// 节日
ob.A = ob.B = ob.C = ""; ob.Fjia = 0;
oba.getDayName(ob, ob); //公历
obb.getDayName(ob, ob); //农历
}
// 以下是月相与节气的处理
double d, jd2 = Bd0 + JD.deltatT2(Bd0) - 8d / 24d;
int xn;
// 月相查找
w = XL.MS_aLon(jd2 / 36525, 10, 3);
w = LunarHelper.int2((w - 0.78) / Math.PI * 2) * Math.PI / 2;
do
{
d = obb.so_accurate(w);
D = LunarHelper.int2(d + 0.5);
xn = (int)LunarHelper.int2(w / LunarHelper.pi2 * 4 + 4000000.01) % 4;
w += LunarHelper.pi2 / 4;
if (D >= Bd0 + Bdn)
{
break;
}
if (D < Bd0)
{
continue;
}
ob = (this.lun[(int)(D - Bd0)]);
ob.yxmc = obb.yxmc[xn]; // 取得月相名称
ob.yxjd = d.ToString();
ob.yxsj = JD.timeStr(d);
} while (D + 5 < Bd0 + Bdn);
// 节气查找
w = XL.S_aLon(jd2 / 36525, 3);
w = LunarHelper.int2((w - 0.13) / LunarHelper.pi2 * 24) * LunarHelper.pi2 / 24;
do
{
d = obb.qi_accurate(w);
D = LunarHelper.int2(d + 0.5);
xn = (int)LunarHelper.int2(w / LunarHelper.pi2 * 24 + 24000006.01) % 24;
w += LunarHelper.pi2 / 24;
if (D >= Bd0 + Bdn)
{
break;
}
if (D < Bd0)
{
continue;
}
ob = (this.lun[(int)(D - Bd0)]);
ob.jqmc = obb.jqmc[xn]; // 取得节气名称
ob.jqjd = d.ToString();
ob.jqsj = JD.timeStr(d);
} while (D + 12 < Bd0 + Bdn);
// C#: 转换时新增的代码行
this.CalcRiJianThisMonth(); // 计算本月所有日期的日十二建信息
}
/// <summary>
/// 精朔计算
/// </summary>
/// <param name="W"></param>
/// <returns></returns>
public static double so_accurate(double W)
{
double t = XL.MS_aLon_t(W) * 36525;
return(t - JD.deltatT2(t) + 8d / 24d); // 精朔
}
} // = 0;
#endregion
#endregion 公共属性
#region 公共方法
/// <summary>
/// 计算 sun_moon 类的成员。参数：T是力学时,站点经度L,纬度fa,海拔high(千米)
/// </summary>
/// <param name="T">力学时</param>
/// <param name="L">站点经度</param>
/// <param name="fa">站点纬度</param>
/// <param name="high">海拔</param>
public void calc(double T, double L, double fa, double high)
{
//基本参数计算
this.T = T;
this.L = L; this.fa = fa;
this.dt = JD.deltatT2(T); //TD-UT
this.jd = T - this.dt; //UT
T /= 36525; ZB.nutation(T);
this.dL = ZB.dL; //黄经章
this.dE = ZB.dE; //交角章动
this.E = ZB.hcjj(T) + this.dE; //真黄赤交角
this.gst = ZB.gst(this.jd, this.dt) + this.dL * Math.Cos(this.E); //真恒星时(不考虑非多项式部分)
double[] z = new double[4];
//=======月亮========
//月亮黄道坐标
XL.M_coord(T, z, -1, -1, -1); //月球坐标
z[0] = LunarHelper.rad2mrad(z[0] + ZB.gxc_moonLon(T) + this.dL); z[1] += ZB.gxc_moonLat(T); //补上月球光行差及章动
this.mHJ = z[0]; this.mHW = z[1]; this.mR = z[2]; //月球视黄经,视黄纬,地月质心距
//月球赤道坐标
ZB.llrConv(z, this.E); //转为赤道坐标
this.mCJ = z[0]; this.mCW = z[1]; //月球视赤经,月球赤纬
//月亮时角计算
this.mShiJ = LunarHelper.rad2mrad(this.gst - L - z[0]); //得到此刻天体时角
if (this.mShiJ > Math.PI)
{
this.mShiJ -= LunarHelper.pi2;
}
//修正了视差的赤道坐标
ZB.parallax(z, this.mShiJ, fa, high); //视差修正
this.mCJ2 = z[0]; this.mCW2 = z[1]; this.mR2 = z[2];
//月亮时角坐标
z[0] += Math.PI / 2d - this.gst + L; //转到相对于地平赤道分点的赤道坐标(时角坐标)
//月亮地平坐标
ZB.llrConv(z, Math.PI / 2 - fa); //转到地平坐标(只改经纬度)
z[0] = LunarHelper.rad2mrad(Math.PI / 2 - z[0]);
this.mDJ = z[0]; this.mDW = z[1]; //方位角,高度角
if (z[1] > 0)
{
z[1] += ZB.AR2(z[1]); //大气折射修正
}
this.mPJ = z[0]; this.mPW = z[1]; //方位角,高度角
//=======太阳========
//太阳黄道坐标
XL.E_coord(T, z, -1, -1, -1); //地球坐标
z[0] = LunarHelper.rad2mrad(z[0] + Math.PI + ZB.gxc_sunLon(T) + this.dL); //补上太阳光行差及章动
z[1] = -z[1] + ZB.gxc_sunLat(T); //z数组为太阳地心黄道视坐标
this.sHJ = z[0]; this.sHW = z[1]; this.sR = z[2]; //太阳视黄经,视黄纬,日地质心距
//太阳赤道坐标
ZB.llrConv(z, this.E); //转为赤道坐标
this.sCJ = z[0]; this.sCW = z[1]; //太阳视赤经,视赤纬
//太阳时角计算
this.sShiJ = LunarHelper.rad2mrad(this.gst - L - z[0]); //得到此刻天体时角
if (this.sShiJ > Math.PI)
{
this.sShiJ -= LunarHelper.pi2;
}
//修正了视差的赤道坐标
ZB.parallax(z, this.sShiJ, fa, high); //视差修正
this.sCJ2 = z[0]; this.sCW2 = z[1]; this.sR2 = z[2];
//太阳时角坐标
z[0] += Math.PI / 2 - this.gst + L; //转到相对于地平赤道分点的赤道坐标
//太阳地平坐标
ZB.llrConv(z, Math.PI / 2 - fa);
z[0] = LunarHelper.rad2mrad(Math.PI / 2 - z[0]);
//z[1] -= 8.794/rad/z[2]*Math.cos(z[1]); //直接在地平坐标中视差修正(这里把地球看为球形,精度比ZB.parallax()稍差一些)
this.sDJ = z[0]; this.sDW = z[1]; //方位角,高度角
if (z[1] > 0)
{
z[1] += ZB.AR2(z[1]); //大气折射修正
}
this.sPJ = z[0]; this.sPW = z[1]; //方位角,高度角
//=======其它========
//时差计算
double t = T / 10; double t2 = t * t, t3 = t2 * t, t4 = t3 * t, t5 = t4 * t;
double Lon = (1753469512 + 6283319653318 * t + 529674 * t2 + 432 * t3 - 1124 * t4 - 9 * t5 + 630 * Math.Cos(6 + 3 * t)) / 1000000000 + Math.PI - 20.5 / LunarHelper.rad; //修正了光行差的太阳平黄经
Lon = LunarHelper.rad2mrad(Lon - (this.sCJ - this.dL * Math.Cos(this.E))); //(修正了光行差的平黄经)-(不含dL*cos(E)的视赤经)
if (Lon > Math.PI)
{
Lon -= LunarHelper.pi2; //得到时差,单位是弧度
}
this.sc = Lon / LunarHelper.pi2; //时差(单位:日)
//真太阳与平太阳
this.pty = this.jd - L / LunarHelper.pi2; //平太阳时
this.zty = this.jd - L / LunarHelper.pi2 + this.sc; //真太阳时
//视半径
//this.mRad = XL.moonRad(this.mR,this.mDW); //月亮视半径(角秒)
this.mRad = 358473400d / this.mR2; //月亮视半径(角秒)
this.sRad = 959.63 / this.sR2; //太阳视半径(角秒)
this.e_mRad = 358473400d / this.mR; //月亮地心视半径(角秒)
this.eShadow = (LunarHelper.cs_rEarA / this.mR * LunarHelper.rad - (959.63 - 8.794) / this.sR) * 51 / 50; //地本影在月球向径处的半径(角秒),式中51/50是大气厚度补偿
this.eShadow2 = (LunarHelper.cs_rEarA / this.mR * LunarHelper.rad + (959.63 + 8.794) / this.sR) * 51 / 50; //地半影在月球向径处的半径(角秒),式中51/50是大气厚度补偿
this.mIll = XL.moonIll(T); //月亮被照面比例
//中心食计算
if (Math.Abs(LunarHelper.rad2rrad(this.mCJ - this.sCJ)) < 50 / 180 * Math.PI)
{
ZB.line_earth(this.mCJ, this.mCW, this.mR, this.sCJ, this.sCW, this.sR * LunarHelper.cs_AU);
this.zx_J = LunarHelper.rad2rrad(this.gst - ZB.le_J);
this.zx_W = ZB.le_W; //无解返回值是100
}
else
{
this.zx_J = this.zx_W = 100;
}
}
