这是E语言的悲哀！总是被误报为病毒！我是用NOD32的V2.7版，没有对楼主的万年历报毒。

本人也写用E了个万年历，功能尚可，包括了黄历等内容。但怕被误报，所以就不发上来了。

 

 

此主题相关图片如下：未标题-1 拷贝.jpg


此主题相关图片如下：未标题-1 拷贝.jpg

楼主能否把计算日月经度部分的源码发来  谢谢

公开 类 万年历
{
    //====================================================================
    公开 静态 整数 取农历年天数(整数 农历年份)//取某农历年份的总天数
    {
        整数 i, sum = 348;
        for(i=0x8000; i>0x8; i>>=1)
        {
            sum += 选择(农历信息[农历年份-1900] & i, 1, 0);
        }
        返回(sum+取农历闰月天数(农历年份));
    }
    //====================================================================
    公开 静态 整数 取农历闰月天数(整数 农历年份)//取某农历年份闰月的天数
    {
        if(取农历闰月(农历年份)!=0)
            返回 选择(农历信息[农历年份-1900] & 0x10000, 30, 29);
        else
            返回 0;
    }
    //====================================================================
    公开 静态 整数 取农历闰月(整数 农历年份)// 取某农历年份闰哪个月 1-12 , 没闰传回 0
    {
        返回 农历信息[农历年份-1900] & 0xf;
    }
    //====================================================================
    公开 静态 整数 取农历月天数(整数 农历年份,整数 农历月份)//取某农历年份的某月的总天数
    {
        返回 选择( 农历信息[农历年份-1900] & (0x10000>>农历月份), 30, 29);
    }
    //====================================================================
    公开 静态 日期 取农历日期(日期 公历日期)// 把公历日期转换为农历日期
    {
        整数 offset;
        整数 i, leap=0, temp=0;
        日期 返回日期 = new 日期();

        offset=取相差天数(公历日期)-30;

        for(i=1900; i<2050 && offset>0; i++)
        {
            temp = 取农历年天数(i);
            offset -= temp;
        }

        if(offset<0)
        {
            offset += temp;
            i--;
        }

        返回日期.年 = i;

        leap = 取农历闰月(i);
        bool isLeap = 假;

        for(i=1; i<13 && offset>0; i++)
        {
            if(leap>0 && i==(leap+1) && isLeap==假)
            {
                i--;
                isLeap = 真;
                temp = 取农历闰月天数(返回日期.年);
            }
            else
            {
                temp = 取农历月天数(返回日期.年, i);
            }
            if(isLeap==真 && i==(leap+1))
            {
                isLeap = 假;
            }
            offset -= temp;
        }
        if(offset==0 && leap>0 && i==leap+1)
        {
            if(isLeap)
            {
                isLeap = 假;
            }
            else
            {
                isLeap = 真;
                i--;
            }
        }
        if(offset<=0)
        {
            offset += temp;
            i--;
        }
        返回日期.月 = i;
        返回日期.日 = offset ;
        返回日期.是否闰月=isLeap;
        返回 返回日期;

    }
    //====================================================================
    公开 静态 文本 取农历文本(日期 农历日期 )// 取某农历日期的表示文本
    {
        文本 农历文本, 农历日文本,属象文本;
        常量 文本[] 天干  = {"甲","乙","丙","丁","戊","己","庚","辛","壬","癸"}; /*天干名称*/
        常量 文本[] 地支    = {"子","丑","寅","卯","辰","巳","午", "未","申","酉","戌","亥"}; /*地支名称*/
        常量 文本[] 属象 = {"鼠","牛","虎","兔","龙","蛇","马","羊","猴","鸡","狗","猪"}; /*属相名称*/
        常量 文本[] 农历日名  = { "*","初一","初二","初三","初四","初五", /*农历日期名*/
            "初六","初七","初八","初九","初十",
            "十一","十二","十三","十四","十五",
            "十六","十七","十八","十九","二十",
            "廿一","廿二","廿三","廿四","廿五",      
            "廿六","廿七","廿八","廿九","三十"};
        常量 文本[] 农历月名  = {"*","正","二","三","四","五","六", "七","八","九","十","十一","腊"};

        /*--生成农历天干、地支、属相 ==> wNongli--*/
        int 属象索引 = ((农历日期.年 - 4) % 60) % 12;
        if ( 属象索引 < 0 || 属象索引 >= 属象.长度 )
        {
            返回 "";
        }
        属象文本 = 属象[属象索引];

        int 天干索引 = ((农历日期.年 - 4) % 60) % 10;
        if ( 天干索引 < 0 || 天干索引 >= 天干.长度 )
        {
            返回 "";
        }
        int 地支索引 = ((农历日期.年 - 4) % 60) % 12;
        if ( 地支索引 < 0 || 地支索引 >= 地支.长度 )
        {
            返回 "";
        }
        农历文本 = 属象文本 + "(" + 天干[天干索引] + 地支[地支索引] + ")年";

        /*--生成农历月、日 ==> wNongliDay--*/
        if ( 农历日期.月 < 0 || 农历日期.月 >= 农历月名.长度 )
        {
            返回 "";
        }

        if (农历日期.是否闰月)
        {
            农历日文本 = "闰" + 农历月名[农历日期.月];
        }
        else
        {
            农历日文本 = 农历月名[农历日期.月];
        }
        农历日文本 += "月";

        if ( 农历日期.日 < 0 || 农历日期.日 >= 农历日名.长度 )
        {
            返回 "";
        }

        农历日文本 += 农历日名[农历日期.日];

        农历文本 += 农历日文本;
       
        返回 农历文本;

    }

    //====================================================================
    公开 静态 文本 取星期(日期 公历日期)//取某公历日期是星期几
    {
        常量 文本[] 星期名 = {"星期日","星期一","星期二","星期三","星期四","星期五","星期六"};

        整数 年 = 公历日期.年;
        整数 月 = 公历日期.月;
        整数 日 = 公历日期.日;

        if(月==1||月==2)
        {
            月+=12;
            年--;
        }
        返回 星期名[(日+1+2*月+3*(月+1)/5+年+年/4-年/100+年/400)%7];
    }
    //====================================================================
    公开 静态 整数 取月天数(整数 公历年份,整数 公历月份)//取某公历年份的某月的天数
    {
        if(公历月份==2)//2月
        {
            返回 选择((公历年份%4 == 0) && (公历年份%100 != 0) || (公历年份%400 == 0), 29, 28);
        }
        else
        {
            返回(公历月天数[公历月份-1]);
        }
    }

    //====================================================================
    静态 整数 取相差天数(日期 公历日期)//取某日与1900年相差的天数
    {
        整数 天数;

        天数=365*公历日期.年+(公历日期.年-1)/4-(公历日期.年-1)/100+(公历日期.年-1)/400-
            (365*1900+(1900-1)/4-(1900-1)/100+(1900-1)/400);

        for(int i=0;i<公历日期.月-1;i++)
        {
            天数+=公历月天数[i];
        }
        天数+=公历日期.日;
        if((公历日期.年%4==0&&公历日期.年%100!=0)||公历日期.年%400==0)
        {
            if(公历日期.月>2)
            {
                天数++;
            }
        }
        返回 天数;
    }
    //====================================================================
    静态 整数 选择(逻辑 n,整数 n1, 整数 n2)
    {
        if(n)
            返回(n1);
        else
            返回(n2);
    }
    静态 整数 选择(整数 n,整数 n1, 整数 n2)
    {
        返回 选择( n!=0, n1, n2 );
    }

    //====================================================================

    静态 整数[] 农历信息 = {    0x04bd8,0x04ae0,0x0a570,0x054d5,0x0d260,0x0d950,0x16554,0x056a0,0x09ad0,0x055d2,
                        0x04ae0,0x0a5b6,0x0a4d0,0x0d250,0x1d255,0x0b540,0x0d6a0,0x0ada2,0x095b0,0x14977,
                        0x04970,0x0a4b0,0x0b4b5,0x06a50,0x06d40,0x1ab54,0x02b60,0x09570,0x052f2,0x04970,
                        0x06566,0x0d4a0,0x0ea50,0x06e95,0x05ad0,0x02b60,0x186e3,0x092e0,0x1c8d7,0x0c950,
                        0x0d4a0,0x1d8a6,0x0b550,0x056a0,0x1a5b4,0x025d0,0x092d0,0x0d2b2,0x0a950,0x0b557,
                        0x06ca0,0x0b550,0x15355,0x04da0,0x0a5d0,0x14573,0x052d0,0x0a9a8,0x0e950,0x06aa0,
                        0x0aea6,0x0ab50,0x04b60,0x0aae4,0x0a570,0x05260,0x0f263,0x0d950,0x05b57,0x056a0,
                        0x096d0,0x04dd5,0x04ad0,0x0a4d0,0x0d4d4,0x0d250,0x0d558,0x0b540,0x0b5a0,0x195a6,
                        0x095b0,0x049b0,0x0a974,0x0a4b0,0x0b27a,0x06a50,0x06d40,0x0af46,0x0ab60,0x09570,
                        0x04af5,0x04970,0x064b0,0x074a3,0x0ea50,0x06b58,0x055c0,0x0ab60,0x096d5,0x092e0,
                        0x0c960,0x0d954,0x0d4a0,0x0da50,0x07552,0x056a0,0x0abb7,0x025d0,0x092d0,0x0cab5,
                        0x0a950,0x0b4a0,0x0baa4,0x0ad50,0x055d9,0x04ba0,0x0a5b0,0x15176,0x052b0,0x0a930,
                        0x07954,0x06aa0,0x0ad50,0x05b52,0x04b60,0x0a6e6,0x0a4e0,0x0d260,0x0ea65,0x0d530,
                        0x05aa0,0x076a3,0x096d0,0x04bd7,0x04ad0,0x0a4d0,0x1d0b6,0x0d250,0x0d520,0x0dd45,
                        0x0b5a0,0x056d0,0x055b2,0x049b0,0x0a577,0x0a4b0,0x0aa50,0x1b255,0x06d20,0x0ada0    };
    静态 整数[] 公历月天数 = {31,28,31,30,31,30,31,31,30,31,30,31};

}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/efdev/archive/2008/02/02/2077861.aspx

这好像是列表法的万的历吧，谢谢了。

天文算法万年历请参考《寿星天文历》。

因前段时间有点事情一直没有时间上网跟大家探讨 为表歉意现在将这个万年历的星历函数无偿贡献给大家！水平有限希望大家不要见笑 改自寿星万年历！

另请高手对易语言在星历算法中的精度问题给以帮组支持 谢谢！

.版本 2

.程序集 星历函数

.子程序 rad, 双精度小数型

返回 (180 × 3600 ÷ #pi1)

.子程序 pi2, 双精度小数型

返回 (#pi1 × 2)

.子程序 int2, 整数型
.参数 v

v ＝ 取整 (v)
.如果真 (v ＜ 0)
    返回 (v － 1)
.如果真结束
返回 (v)

.子程序 gxc_sunLon, 双精度小数型, , 太阳光行差(黄经),t是世纪数
.参数 t, 双精度小数型
.局部变量 v, 双精度小数型
.局部变量 e, 双精度小数型

v ＝ -0.043126 ＋ 628.301955 × t － 2.732e-006 × t × t  ' 平近点角
e ＝ 0.016708634 － 4.2037e-005 × t － 1.267e-007 × t × t
返回 (-20.49552 × (1 ＋ e × 求余弦 (v)) ÷ rad ())

.子程序 gxc_sunLat, 双精度小数型, , 黄纬光行差
.参数 t, 双精度小数型

返回 (0)

.子程序 gxc_moonLon, 双精度小数型, , 月球经度光行差,误差0.07"
.参数 t, 双精度小数型

返回 (-3.4e-006)

.子程序 gxc_moonLat, 双精度小数型, , 月球纬度光行差,误差0.006"
.参数 t, 双精度小数型

返回 (0.063 × 求正弦 (0.057 ＋ 8433.4662 × t ＋ 6.4e-005 × t × t) ÷ rad ())

.子程序 nutationLon, 双精度小数型, , 只计算黄经章动
.参数 t, 双精度小数型
.局部变量 nutB, 双精度小数型, , "0"
.局部变量 t2, 双精度小数型
.局部变量 dL, 双精度小数型
.局部变量 a, 双精度小数型
.局部变量 i, 整数型

nutB ＝ { 2.1824, -33.75705, 3.6e-005, -1720, 920, 3.5069, 1256.66393, 1.1e-005, -132, 57, 1.3375, 16799.4182, -5.1e-005, -23, 10, 4.3649, -67.5141, 7.2e-005, 21, -9, 0.04, -628.302, 0, -14, 0, 2.36, 8328.691, 0, 7, 0, 3.46, 1884.966, 0, -5, 2, 5.44, 16833.175, 0, -4, 2, 3.69, 25128.11, 0, -3, 0, 3.55, 628.362, 0, 2, 0 }
t2 ＝ t × t
dL ＝ 0
i ＝ 1
.判断循环首 (i ＜ 取数组成员数 (nutB))
    .如果 (i ＝ 1)
        a ＝ -1.742 × t
    .否则
        a ＝ 0
    .如果结束
    dL ＝ dL ＋ (nutB [i ＋ 3] ＋ a) × 求正弦 (nutB [i] ＋ nutB [i ＋ 1] × t ＋ nutB [i ＋ 2] × t2)
    i ＝ i ＋ 5
.判断循环尾 ()
返回 (dL ÷ 100 ÷ rad ())

.子程序 Enn, 双精度小数型, , 计算E_L0或E_L1或E_L2等
.参数 f, 双精度小数型, 数组
.参数 ff, 双精度小数型, 数组
.参数 t, 双精度小数型
.参数 n, 双精度小数型
.局部变量 v, 双精度小数型
.局部变量 i, 整数型

n ＝ 取整 (n × 取数组成员数 (f) ＋ 0.5)  ' 按百分比取项数
.如果真 (f [1] ≠ ff [1])
    n ＝ n ＋ 3
.如果真结束
.如果真 (n ＞ 取数组成员数 (f))
    n ＝ 取数组成员数 (f)
.如果真结束
v ＝ 0
.变量循环首 (1, n, 3, i)
    v ＝ v ＋ f [i] × 求余弦 (f [i ＋ 1] ＋ t × f [i ＋ 2])
.变量循环尾 ()
返回 (v)


.子程序 E_Lon, 双精度小数型, , 地球经度计算,返回Date分点黄经,传入世纪数和取项数
.参数 t, 双精度小数型
.参数 n, 双精度小数型
.局部变量 t2, 双精度小数型
.局部变量 t3, 双精度小数型
.局部变量 t4, 双精度小数型
.局部变量 t5, 双精度小数型
.局部变量 v, 双精度小数型

t ＝ t ÷ 10  ' 转为千年数
.如果 (n ＜ 0)
    n ＝ 1
.否则
    n ＝ 3 × n ÷ 取数组成员数 (EL0)
.如果结束
t2 ＝ t × t
t3 ＝ t2 × t
t4 ＝ t3 × t
t5 ＝ t4 × t
v ＝ Enn (EL0, EL0, t, n)
v ＝ v ＋ Enn (EL1, EL0, t, n) × t
v ＝ v ＋ Enn (EL2, EL0, t, n) × t2
v ＝ v ＋ Enn (EL3, EL0, t, n) × t3
v ＝ v ＋ Enn (EL4, EL0, t, n) × t4
v ＝ v ＋ Enn (EL5, EL0, t, n) × t5
v ＝ v ÷ 10000000000
v ＝ v ＋ (-0.0728 － 2.7702 × t － 1.1019 × t2 － 0.0996 × t3) ÷ rad ()
返回 (v)

.子程序 E_coord, , , 返回地球坐标,t为世纪数
.参数 t, 双精度小数型
.参数 n1, 双精度小数型
.参数 n2, 双精度小数型
.参数 n3, 双精度小数型
.参数 re, 双精度小数型, 参考 数组
.局部变量 t2, 双精度小数型
.局部变量 t3, 双精度小数型
.局部变量 t4, 双精度小数型
.局部变量 t5, 双精度小数型

t ＝ t ÷ 10  ' 转为千年数
t2 ＝ t × t
t3 ＝ t2 × t
t4 ＝ t3 × t
t5 ＝ t4 × t
re [1] ＝ E_Lon (t × 10, n1)
re [2] ＝ Enn (EB0, EB0, t, 选择 (n2 ＜ 0, 1, 3 × n2 ÷ 取数组成员数 (EB0))) ＋ Enn (EB1, EB0, t, 选择 (n2 ＜ 0, 1, 3 × n2 ÷ 取数组成员数 (EB0))) × t ＋ Enn (EB2, EB0, t, 选择 (n2 ＜ 0, 1, 3 × n2 ÷ 取数组成员数 (EB0))) × t2
re [3] ＝ Enn (ER0, ER0, t, 选择 (n3 ＜ 0, 1, 3 × n3 ÷ 取数组成员数 (ER0))) ＋ Enn (ER1, ER0, t, 选择 (n3 ＜ 0, 1, 3 × n3 ÷ 取数组成员数 (ER0))) × t ＋ Enn (ER2, ER0, t, 选择 (n3 ＜ 0, 1, 3 × n3 ÷ 取数组成员数 (ER0))) × t2 ＋ Enn (ER3, ER0, t, 选择 (n3 ＜ 0, 1, 3 × n3 ÷ 取数组成员数 (ER0))) × t3 ＋ Enn (ER4, ER0, t, 选择 (n3 ＜ 0, 1, 3 × n3 ÷ 取数组成员数 (ER0))) × t4 ＋ Enn (ER5, ER0, t, 选择 (n3 ＜ 0, 1, 3 × n3 ÷ 取数组成员数 (ER0))) × t5
re [3] ＝ re [3] ÷ 10000000000
re [3] ＝ re [3] ＋ (-0.002 ＋ 0.0044 × t ＋ 0.0213 × t2 － 0.025 × t3) ÷ 1000000
re [2] ＝ re [2] ÷ 10000000000
re [2] ＝ re [2] ＋ (0 ＋ 0.0004 × t ＋ 0.0004 × t2 － 0.0026 × t3) ÷ rad ()

.子程序 Mnn, 双精度小数型, , 计算ML0或ML1或ML2
.参数 f, 双精度小数型, 数组
.参数 ff, 双精度小数型, 数组
.参数 t, 双精度小数型
.参数 t2, 双精度小数型
.参数 t3, 双精度小数型
.参数 t4, 双精度小数型
.参数 n, 双精度小数型
.局部变量 v, 双精度小数型
.局部变量 i, 整数型

n ＝ 取整 (n × 取数组成员数 (f) ＋ 0.5)  ' //按百分比取项数
.如果真 (f [1] ≠ ff [1])
    n ＝ n ＋ 6
.如果真结束
.如果真 (n ＞ 取数组成员数 (f))
    n ＝ 取数组成员数 (f)
.如果真结束
v ＝ 0
t2 ＝ t2 ÷ 10000
t3 ＝ t3 ÷ 100000000
t4 ＝ t4 ÷ 100000000
.变量循环首 (1, n, 6, i)
    v ＝ v ＋ f [i] × 求余弦 (f [i ＋ 1] ＋ t × f [i ＋ 2] ＋ t2 × f [i ＋ 3] ＋ t3 × f [i ＋ 4] ＋ t4 × f [i ＋ 5])
.变量循环尾 ()
返回 (v)

.子程序 M_Lon, 双精度小数型, , 月球经度计算,返回Date分点黄经,传入世纪数,n是项数
.参数 t, 双精度小数型
.参数 n, 双精度小数型
.局部变量 t2, 双精度小数型
.局部变量 t3, 双精度小数型
.局部变量 t4, 双精度小数型
.局部变量 t5, 双精度小数型
.局部变量 tx, 双精度小数型
.局部变量 v, 双精度小数型

.如果 (n ＜ 0)
    n ＝ 1
.否则
    n ＝ 6 × n ÷ 取数组成员数 (ML0)
.如果结束
t2 ＝ t × t
t3 ＝ t2 × t
t4 ＝ t3 × t
t5 ＝ t4 × t
tx ＝ t － 10
v ＝ Mnn (ML0, ML0, t, t2, t3, t4, n)
v ＝ v ＋ Mnn (ML1, ML0, t, t2, t3, t4, n) × t
v ＝ v ＋ Mnn (ML2, ML0, t, t2, t3, t4, n) × t2
v ＝ v ＋ Mnn (ML3, ML0, t, t2, t3, t4, n) × t3
v ＝ v ＋ (3.81034409 ＋ 8399.684730072 × t － 3.319e-005 × t2 ＋ 3.11e-008 × t3 － 2.033e-010 × t4) × rad ()  ' 月球平黄经(弧度)
v ＝ v ＋ 5028.792262 × t ＋ 1.1124406 × t2 ＋ 7.699e-005 × t3 － 2.3479e-005 × t4 － 1.78e-008 × t5  ' 岁差(角秒)
.如果真 (tx ＞ 0)
    v ＝ v － (0.866 － 1.43 × tx － 0.054 × tx × tx)  ' 对公元3000年至公元5000年的拟合,最大误差小于10角秒
.如果真结束
返回 (v ÷ rad ())

.子程序 M_coord, , , 返回月球坐标
.参数 t, 双精度小数型
.参数 n1, 双精度小数型
.参数 n2, 双精度小数型
.参数 n3, 双精度小数型
.参数 re, 双精度小数型, 参考 数组
.局部变量 t2, 双精度小数型
.局部变量 t3, 双精度小数型
.局部变量 t4, 双精度小数型

t2 ＝ t × t
t3 ＝ t2 × t
t4 ＝ t3 × t
re [1] ＝ M_Lon (t, n1)
re [2] ＝ Mnn (MB0, MB0, t, t2, t3, t4, 选择 (n2 ＜ 0, 1, 6 × n2 ÷ 取数组成员数 (MB0))) ＋ Mnn (MB1, MB0, t, t2, t3, t4, 选择 (n2 ＜ 0, 1, 6 × n2 ÷ 取数组成员数 (MB0))) × t ＋ Mnn (MB2, MB0, t, t2, t3, t4, 选择 (n2 ＜ 0, 1, 6 × n2 ÷ 取数组成员数 (MB0))) × t2
re [3] ＝ Mnn (MR0, MR0, t, t2, t3, t4, 选择 (n3 ＜ 0, 1, 6 × n3 ÷ 取数组成员数 (MR0))) ＋ Mnn (MR1, MR0, t, t2, t3, t4, 选择 (n3 ＜ 0, 1, 6 × n3 ÷ 取数组成员数 (MR0))) × t ＋ Mnn (MR2, MR0, t, t2, t3, t4, 选择 (n3 ＜ 0, 1, 6 × n3 ÷ 取数组成员数 (MR0))) × t2
re [2] ＝ re [2] ÷ rad ()

.子程序 E_v, 双精度小数型, , 地球速度,t是世纪数,误差小于万分3
.参数 t, 双精度小数型
.局部变量 f, 双精度小数型

f ＝ 628.307585 × t
返回 (628.332 ＋ 21 × 求正弦 (1.527 ＋ f) ＋ 0.44 × 求正弦 (1.48 ＋ f × 2) ＋ 0.129 × 求正弦 (5.82 ＋ f) × t ＋ 0.00055 × 求正弦 (4.21 ＋ f) × t × t)

.子程序 M_v, 双精度小数型, , 月球速度计算,传入世经数
.参数 t, 双精度小数型
.局部变量 v, 双精度小数型

v ＝ 8399.71 － 914 × 求正弦 (0.7848 ＋ 8328.691425 × t ＋ 0.0001523 × t × t)  ' 误差小于5%
v ＝ v － (179 × 求正弦 (2.543 ＋ 15542.7543 × t) ＋ 160 × 求正弦 (0.1874 ＋ 7214.0629 × t) ＋ 62 × 求正弦 (3.14 ＋ 16657.3828 × t) ＋ 34 × 求正弦 (4.827 ＋ 16866.9323 × t) ＋ 22 × 求正弦 (4.9 ＋ 23871.4457 × t) ＋ 12 × 求正弦 (2.59 ＋ 14914.4523 × t) ＋ 7 × 求正弦 (0.23 ＋ 6585.7609 × t) ＋ 5 × 求正弦 (0.9 ＋ 25195.624 × t) ＋ 5 × 求正弦 (2.32 － 7700.3895 × t) ＋ 5 × 求正弦 (3.88 ＋ 8956.9934 × t) ＋ 5 × 求正弦 (0.49 ＋ 7771.3771 × t))
返回 (v)

.子程序 MS_aLon, 双精度小数型, , 月日视黄经的差值
.参数 t, 双精度小数型
.参数 mn, 双精度小数型
.参数 sn, 双精度小数型

返回 (M_Lon (t, mn) ＋ gxc_moonLon (t) － (E_Lon (t, sn) ＋ gxc_sunLon (t) ＋ #pi1))

.子程序 S_aLon, 双精度小数型, , 太阳视黄经
.参数 t, 双精度小数型
.参数 n, 双精度小数型

返回 (E_Lon (t, n) ＋ nutationLon (t) ＋ gxc_sunLon (t) ＋ #pi1)

.子程序 MS_aLon_t, 双精度小数型, , 已知月日视黄经差求时间
.参数 w, 双精度小数型
.局部变量 v, 双精度小数型
.局部变量 t, 双精度小数型

v ＝ 7771.377145002
t ＝ (w ＋ 1.08472) ÷ v
t ＝ t ＋ (w － MS_aLon (t, 3, 3)) ÷ v
v ＝ M_v (t) － E_v (t)  ' v的精度0.5%，详见原文
t ＝ t ＋ (w － MS_aLon (t, 20, 10)) ÷ v
t ＝ t ＋ (w － MS_aLon (t, -1, 60)) ÷ v
返回 (t)

.子程序 S_aLon_t, 双精度小数型, , 已知太阳视黄经反求时间
.参数 w, 双精度小数型
.局部变量 v, 双精度小数型
.局部变量 t, 双精度小数型

v ＝ 628.3319653318
t ＝ (w － 1.75347 － #pi1) ÷ v
v ＝ E_v (t)  ' v的精度0.03%，详见原文
t ＝ t ＋ (w － S_aLon (t, 10)) ÷ v
v ＝ E_v (t)  ' 再算一次v有助于提高精度,不算也可以
t ＝ t ＋ (w － S_aLon (t, -1)) ÷ v
返回 (t)

.子程序 MS_aLon_t2, 双精度小数型, , 已知月日视黄经差求时间,高速低精度,误差不超过600秒(只验算了几千年)
.参数 w, 双精度小数型
.局部变量 v, 双精度小数型
.局部变量 t, 双精度小数型
.局部变量 t2, 双精度小数型
.局部变量 L, 双精度小数型

v ＝ 7771.377145002
t ＝ (w ＋ 1.08472) ÷ v
t2 ＝ t × t
t ＝ t － (-3.309e-005 × t2 ＋ 0.10976 × 求余弦 (0.784758 ＋ 8328.6914246 × t ＋ 0.000152292 × t2) ＋ 0.02224 × 求余弦 (0.1874 ＋ 7214.0628654 × t － 0.00021848 × t2) － 0.03342 × 求余弦 (4.669257 ＋ 628.307585 × t)) ÷ v
L ＝ M_Lon (t, 20) － (4.8950632 ＋ 628.3319653318 × t ＋ 5.297e-006 × t × t ＋ 0.0334166 × 求余弦 (4.669257 ＋ 628.307585 × t) ＋ 0.0002061 × 求余弦 (2.67823 ＋ 628.307585 × t) × t ＋ 0.000349 × 求余弦 (4.6261 ＋ 1256.61517 × t) － 20.5 ÷ rad ())
v ＝ 7771.38 － 914 × 求正弦 (0.7848 ＋ 8328.691425 × t ＋ 0.0001523 × t × t) － 179 × 求正弦 (2.543 ＋ 15542.7543 × t) － 160 × 求正弦 (0.1874 ＋ 7214.0629 × t)
t ＝ t ＋ (w － L) ÷ v
返回 (t)

.子程序 S_aLon_t2, 双精度小数型, , 已知太阳视黄经反求时间,高速低精度,最大误差不超过600秒
.参数 w, 双精度小数型
.局部变量 v, 双精度小数型
.局部变量 t, 双精度小数型

v ＝ 628.3319653318
t ＝ (w － 1.75347 － #pi1) ÷ v
t ＝ t － (5.297e-006 × t × t ＋ 0.0334166 × 求余弦 (4.669257 ＋ 628.307585 × t) ＋ 0.0002061 × 求余弦 (2.67823 ＋ 628.307585 × t) × t) ÷ v
t ＝ t ＋ (w － E_Lon (t, 8) － #pi1 ＋ (20.5 ＋ 17.2 × 求正弦 (2.1824 － 33.75705 × t)) ÷ (180 × 3600 ÷ #pi1)) ÷ v
返回 (t)

请问 您的那个  行星初始数据的数组是怎么 写的 ，易语言好像不支持 长 的不维度不等长的数组

我现在是用 文本保存的  计算非常慢

楼主，可否历法内核写成可供VB6调用的DLL，如此，将感激不尽！

行星初始数据的数组 我是把它分解成单个数组计算的

楼主，我要E源代码，583669991@qq.com，谢谢。