紫微斗数算法的实现流程

未来新世界

题外话

我想了又想大凡能够修炼成绝世高手的都是“魔鬼”。只有魔鬼才会纯粹的“敢贪，敢嗔，敢痴”。 你我都困在了敢字。程序猿拿起拿锋利的刀，解构世间的一切吧！最近看西游有感而发。
“联系是普遍存在的，规律是客观存在的”，那能不能用程序来解构命运的客观存在？那就来试试吧！
​
 紫微斗数

紫微斗数，能够网上搜索出来的东西，在此不在啰嗦，简单来说就是可以算命。听起来好神秘，那我们一步步来，打怪通关。

排盘规则

排十二宫

不就是排十二个宫格子吗，先准备十二个格子，So easy!  有十二地支，有十二个宫位。为了快速通关，这里只讲解核心原理。

 
对应代码，提前把要用的十二格格准备好，以备不时之需。

1.         /// <summary>
2.         /// 十二宫
3.         /// </summary>
4.         public readonly static string[] CONST_SHIERGONG = { "命宫", "兄弟", "夫妻", "子女", "财帛", "疾厄", "迁移", "交友", "官禄", "田宅", "福德", "父母" };
7.         /// <summary>
8.         /// 天干
9.         /// </summary>
10.         public readonly static string[] CONST_TIANGAN = { "甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸" };
12.         /// <summary>
13.         /// 地支
14.         /// </summary>
15.         public readonly static string[] CONST_DIZHI = { "子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥" };
18.         /// <summary>
19.         /// 地支关系对应序号
20.         /// </summary>
21.         public readonly static Dictionary<string, int> DiZhi_No_MAP = new Dictionary<string, int>
22.         {
23.             { "子",1},
24.             { "丑",2},
25.             { "寅",3},
26.             { "卯",4},
27.             { "辰",5},
28.             { "巳",6},
29.             { "午",7},
30.             { "未",8},
31.             { "申",9},
32.             { "酉",10},
33.             { "戌",11},
34.             { "亥",12}
35.         };

复制代码

 
安命宫及身宫

看下规则：

在空白命盘图上，从寅宫起正月，顺时针方向数到出生月之宫止，再从该宫起子时，逆时针方向数到出生时支止安命宫；从寅宫起正月，顺时针方向数到出生月之宫止，再从该宫起子时，顺时针方向数到出生时支止安身宫。例如三月辰时生人，在寅宫起正月，顺数至卯宫为二月，辰宫三月，到辰宫后，再从辰宫起子时，逆数回卯宫为丑时，寅宫寅时，子宫辰时，已到生时宫，就在此宫安命宫。

不就是数格格吗，So Easy!

1.         /// <summary>
2.         /// 获取命宫和身宫 (如：正月,辰时)
3.         /// </summary>
4.         /// <returns></returns>
5.         public static string[] GetMingGongAndShenGong(int monthNum, int hourNum)
6.         {
7.             var shenggongIdx = monthNum + hourNum;
8.             var shenGongDiZhi = CommonVarRule.CONST_DIZHI[shenggongIdx % 12];
10.             var idx = 14 + (monthNum - hourNum);
11.             var ming = CommonVarRule.CONST_DIZHI[idx % 12];
13.             return new string[] { ming, shenGongDiZhi };
14.         }

复制代码

命盘十二宫

在上面，我们已经找到了命宫和身宫所在的格格，那么根据规则可以顺利排布十二宫。
这太简单，不赘婿，仔细看规则。

从命宫开始，把下列十二宫名称按次序逆时针方向填入空白命盘图的十二宫内：
⑴命宫⑵兄弟⑶夫妻⑷子女⑸财帛⑹疾厄⑺迁移 ⑻奴仆(交友) ⑼官禄⑽田宅⑾福德⑿父母
 
例如：命宫在子，则兄弟宫在亥，夫妻宫在戍，子女宫在酉，财帛宫在申，疾厄宫在未，迁移宫在午，奴仆宫在巳，事业宫在辰，田宅宫在卯，福德宫在寅，父母宫在丑。

 

安十二宫天干

宫干就是十个，甲乙丙丁戊己庚辛壬癸。看规则：

推月干的“五虎遁干”方法来推出寅宫的天干，然后从寅宫起按天干固有顺序(即甲、乙、丙……癸，循环绕排)顺时针排入十二个宫中。

五虎遁年起月诀
甲己之年丙作首，乙庚之岁戊为头，
丙辛岁首寻庚起，丁壬壬位顺行流，
若言戊癸何方发，甲寅之上好追求。

用代码怎么实现：

1.         /// <summary>
2.         /// 获取寅首
3.         /// </summary>
4.         /// <param name="tianGan"></param>
5.         /// <returns></returns>
6.         public static String GetYanShouByTianGan(string tianGan)
7.         {
8.             var yDict = new Dictionary<string, string>  {
9.                     { "丙","甲己"},
10.                     { "戊","乙庚"},
11.                     { "庚","丙辛"},
12.                     { "壬","丁壬"},
13.                     { "甲","戊癸"}
14.                  };
15.             var yearTianGan = tianGan.Substring(0, 1);
16.             return yDict.Where(t => t.Value.Contains(yearTianGan)).First().Key;
17.         }

复制代码

是不是很简单。
定命宫五行局

这步很重要，五行局是后面排布紫微星的基础哦。
按照惯例，先看规则：

纳音五行速记方法：
天干配数：甲乙1，丙丁2，庚辛3，戊己4，壬癸5。
地支配数：子丑午未1，寅卯申酉2，辰巳戍亥3。将干支数相加，以和数查（若大于5则减5，以余数查）得纳音五行为：1木，2金，3水，4火，5土。
 
以命宫的天干地支推算出纳音五行，纳音五行是什么，纳音五行局就是什么；纳音五行对应的数字是几数，五行局就是几局。例如，命宫干支纳音五行为木，则纳音五行局为木，木为1，故为木一局。
 
附：六十甲子配五行纳音
甲子乙丑海中金，丙寅丁卯炉中火，戊辰己巳大林木，庚午辛未路旁土，壬申癸酉剑锋金。
甲戌乙亥山头火，丙子丁丑涧下水，戊寅己卯城头土，庚辰辛巳白腊金，壬午癸未杨柳木。
甲申乙酉泉中水，丙戌丁亥屋上土，戊子己丑霹雳火，庚寅辛卯松柏木，壬辰癸巳常流水。
甲午乙未沙中金，丙申丁酉山下火，戊戌己亥平地木，庚子辛丑壁上土，壬寅癸卯金箔金。
甲辰乙巳覆灯火，丙午丁未天河水，戊申己酉大驿土，庚戌辛亥钗钏金，壬子癸丑桑柘木。
甲寅乙卯大溪水，丙辰丁巳沙中土，戊午己未天上火，庚申辛酉石榴木，壬戌癸亥大海水。

注意上面描述的是规则，并不是真正最后要用的。
不废话上代码：

1.         /// <summary>
2.         /// 获取五行局
3.         /// </summary>
4.         /// <param name="mingGan"></param>
5.         /// <param name="mingZhi"></param>
6.         /// <returns></returns>
7.         public static string GetWuXingJu(string mingGan, string mingZhi)
8.         {
10.             Dictionary<string, string> dict = new Dictionary<string, string>();
12.             dict.Add("甲乙子丑午未", "金四局");
13.             dict.Add("甲乙寅卯申酉", "水二局");
14.             dict.Add("甲乙辰巳戌亥", "火六局");
16.             dict.Add("丙丁子丑午未", "水二局");
17.             dict.Add("丙丁寅卯申酉", "火六局");
18.             dict.Add("丙丁辰巳戌亥", "土五局");
20.             dict.Add("戊己子丑午未", "火六局");
21.             dict.Add("戊己寅卯申酉", "土五局");
22.             dict.Add("戊己辰巳戌亥", "木三局");
24.             dict.Add("庚辛子丑午未", "土五局");
25.             dict.Add("庚辛寅卯申酉", "木三局");
26.             dict.Add("庚辛辰巳戌亥", "金四局");
28.             dict.Add("壬癸子丑午未", "木三局");
29.             dict.Add("壬癸寅卯申酉", "金四局");
30.             dict.Add("壬癸辰巳戌亥", "水二局");
32.             return dict.Where(t => t.Key.Contains(mingGan) && t.Key.Contains(mingZhi)).FirstOrDefault().Value;
33.         }

复制代码

定紫微星

这一步很关键，紫微星一定，后面的星，自然也就排出来了。
我们先看这个规则:

口诀：生日除局商为月，一自寅起紫微定。只加不减到整除，阳退阴进记心中。
 
注解：用出生日数除以命宫五行局得商数，商数按月支固有排序为对应的宫位地支，
即寅1，卯2，辰3，巳4，午5，未6，申7，酉8，戍9，亥10，子11，丑12，
商数所落地支宫位即为紫微所在；若不能整除时，需添加一个最小的数，至刚好能整除为止，所添加之数若为单数就从商数所落地支宫向后退几位，所添加之数若为偶数即从商数所落地支宫向前进几位，定紫微星所在。
 
比如：水二局28日生，28除以2，整除得14，14大于12减去12得2，2为卯宫，故紫微星落在卯宫。

 这里有两种方式，第一个方式是按照上面的实现出来。还有一种方式，使用的字典方式，把各种情况考虑进去。那么我们就采用这种笨简单粗暴的办法吧。上代码

1.         /// <summary>
2.         /// 获取紫微星所在宫位
3.         /// </summary>
4.         /// <param name="nongliDay">农历日（初一）</param>
5.         /// <param name="wuXingJu">五行局</param>
6.         /// <returns></returns>
7.         public static string GetZiWeiXingAtGongWei(string nongliDay, string wuXingJu)
8.         {
9.             Dictionary<string, int> wuxingJuMap = new Dictionary<string, int>();
10.             wuxingJuMap.Add("水二局", 0);
11.             wuxingJuMap.Add("木三局", 1);
12.             wuxingJuMap.Add("金四局", 2);
13.             wuxingJuMap.Add("土五局", 3);
14.             wuxingJuMap.Add("火六局", 4);
16.             Dictionary<string, int> dayMap = new Dictionary<string, int>();
17.             dayMap.Add("初一", 0);
18.             dayMap.Add("初二", 1);
19.             dayMap.Add("初三", 2);
20.             dayMap.Add("初四", 3);
21.             dayMap.Add("初五", 4);
22.             dayMap.Add("初六", 5);
23.             dayMap.Add("初七", 6);
24.             dayMap.Add("初八", 7);
25.             dayMap.Add("初九", 8);
26.             dayMap.Add("初十", 9);
28.             dayMap.Add("一", 0);
29.             dayMap.Add("二", 1);
30.             dayMap.Add("三", 2);
31.             dayMap.Add("四", 3);
32.             dayMap.Add("五", 4);
33.             dayMap.Add("六", 5);
34.             dayMap.Add("七", 6);
35.             dayMap.Add("八", 7);
36.             dayMap.Add("九", 8);
37.             dayMap.Add("十", 9);
39.             dayMap.Add("十一", 10);
40.             dayMap.Add("十二", 11);
41.             dayMap.Add("十三", 12);
42.             dayMap.Add("十四", 13);
43.             dayMap.Add("十五", 14);
44.             dayMap.Add("十六", 15);
45.             dayMap.Add("十七", 16);
46.             dayMap.Add("十八", 17);
47.             dayMap.Add("十九", 18);
49.             dayMap.Add("二十", 19);
50.             dayMap.Add("二十一", 20);
51.             dayMap.Add("二十二", 21);
52.             dayMap.Add("二十三", 22);
53.             dayMap.Add("二十四", 23);
54.             dayMap.Add("二十五", 24);
55.             dayMap.Add("二十六", 25);
56.             dayMap.Add("二十七", 26);
57.             dayMap.Add("二十八", 27);
58.             dayMap.Add("二十九", 28);
60.             dayMap.Add("廿", 19);
61.             dayMap.Add("廿一", 20);
62.             dayMap.Add("廿二", 21);
63.             dayMap.Add("廿三", 22);
64.             dayMap.Add("廿四", 23);
65.             dayMap.Add("廿五", 24);
66.             dayMap.Add("廿六", 25);
67.             dayMap.Add("廿七", 26);
68.             dayMap.Add("廿八", 27);
69.             dayMap.Add("廿九", 28);
71.             dayMap.Add("三十", 29);
72.             dayMap.Add("卅", 29);
75.             string[,] mTalbe = {
76.                         {"丑",   "辰",    "亥",     "午",   "酉"},
77.                         {"寅",   "丑",    "辰",    "亥",    "午"},
78.                         {"寅",   "未",    "丑",    "辰",    "亥"},
79.                         {"卯",   "巳",    "寅",    "丑",    "辰"},
80.                         {"卯",   "寅",    "子",    "寅",    "丑"},
81.                         {"辰",   "卯",    "巳",    "未",    "寅"},
82.                         {"辰",   "午",    "寅",    "子",    "戌"},
83.                         {"巳",   "卯",    "卯",    "巳",    "未"},
84.                         {"巳",   "卯",    "丑",    "寅",    "子"},
85.                         {"午",   "未",    "午",    "卯",    "巳"},
86.                         {"午",   "辰",    "卯",    "申",    "寅"},
87.                         {"未",   "巳",    "亥",    "丑",    "卯"},
88.                         {"未",   "申",    "寅",    "午",    "亥"},
89.                         {"申",   "巳",    "未",    "卯",    "申"},
90.                         {"申",   "午",    "辰",    "辰",    "丑"},
91.                         {"酉",   "酉",    "子",    "酉",    "午"},
92.                         {"酉",   "午",    "卯",    "寅",    "卯"},
93.                         {"戌",   "未",    "申",    "未",    "辰"},
94.                         {"戌",   "戌",    "巳",    "辰",    "子"},
95.                         {"亥",   "未",    "午",    "巳",    "酉"},
96.                         {"亥",   "申",    "丑",    "戌",    "寅"},
97.                         {"子",   "未",    "酉",    "卯",    "未"},
98.                         {"子",   "申",    "午",    "申",    "辰"},
99.                         {"丑",   "酉",    "未",    "巳",    "巳"},
100.                         {"丑",   "子",    "巳",    "午",    "丑"},
101.                         {"寅",   "酉",    "戌",    "亥",    "戌"},
102.                         {"寅",   "戌",    "未",    "辰",    "卯"},
103.                         {"卯",   "丑",    "申",    "酉",    "申"},
104.                         {"卯",   "戌",    "午",    "午",    "巳"},
105.                         {"辰",   "寅",    "亥",    "未",    "午"}
106.             };
108.             int rowIdx = dayMap[nongliDay];
109.             int clnIdx = wuxingJuMap[wuXingJu];
110.             return mTalbe[rowIdx, clnIdx];
111.         }

复制代码

如果到这步看懂了，离最后成功不远啦。用个简单图，看下我们到哪了。

​编辑
我们把十二宫的天干地支，宫位名称，紫微星都排布好了。相当于大桥的桥墩都建好了。剩下的只需要加亿点点细节。实话说，到了这步就可以开始简单论命啦。
安十四正星

十四正星，是以紫微为参照点，来排布的。看规则：

安紫微星系诀：
紫微天机逆行旁，隔一阳武天同当，又隔二位廉贞地，空三复见紫微郞。
 
天府星系诸星:
天府太阴与贪狼，巨门天相及天梁，七杀空三破军位，八星顺数细推详。

 代码怎么实现：

1.         /// <summary>
2.         /// 获取十四主星排布
3.         /// </summary>
4.         /// <returns></returns>
5.         public static Dictionary<string, List<string>> Get_ShiSiZhuXingLayout(string ziWeiAtDiZhi)
6.         {
7.             Dictionary<string, List<string>> diZhiGongWei = new Dictionary<string, List<string>>();
8.             foreach (var item in CommonVarRule.CONST_DIZHI)
9.             {
10.                 diZhiGongWei.Add(item, new List<string>());
11.             }
13.             Dictionary<string, string> tianFuPostion = new Dictionary<string, string>() {
14.                 {"子","辰"}, { "丑","卯"},{"寅","寅" }, { "卯","丑"},{"辰","子" },
15.                 { "巳","亥"},{"午","戌" }, {"未","酉" }, { "申","申"}, {"酉","未"},
16.                 { "戌","午"},{ "亥","巳"}
17.             };
19.             int ziWeiDiZhiIdx = CommonVarRule.DiZhi_No_MAP[ziWeiAtDiZhi] - 1;
20.             int tianFuDiZhiIdx = CommonVarRule.DiZhi_No_MAP[tianFuPostion[ziWeiAtDiZhi]] - 1;
22.             string[] ziWeiSeriesLayout = { "紫微", "", "", "", "廉贞", "", "", "天同", "武曲", "太阳", "", "天机" };
23.             string[] tianFuSeriesLayout = { "天府", "太阴", "贪狼", "巨门", "天相", "天梁", "七杀", "", "", "", "破军", "" };
25.             //紫微星系
26.             foreach (var item in ziWeiSeriesLayout)
27.             {
28.                 if (!string.IsNullOrEmpty(item))
29.                 {
30.                     if (ziWeiDiZhiIdx < 11)
31.                     {
32.                         diZhiGongWei[CommonVarRule.CONST_DIZHI[ziWeiDiZhiIdx]].Add(item);
33.                     }
34.                     else
35.                     {
36.                         diZhiGongWei[CommonVarRule.CONST_DIZHI[ziWeiDiZhiIdx % 12]].Add(item);
37.                     }
38.                 }
39.                 ziWeiDiZhiIdx++;
40.             }
42.             //天府星系
43.             foreach (var item in tianFuSeriesLayout)
44.             {
45.                 if (!string.IsNullOrEmpty(item))
46.                 {
47.                     if (tianFuDiZhiIdx < 11)
48.                     {
49.                         diZhiGongWei[CommonVarRule.CONST_DIZHI[tianFuDiZhiIdx]].Add(item);
50.                     }
51.                     else
52.                     {
53.                         diZhiGongWei[CommonVarRule.CONST_DIZHI[tianFuDiZhiIdx % 12]].Add(item);
54.                     }
55.                 }
56.                 tianFuDiZhiIdx++;
57.             }
59.             return diZhiGongWei;
60.         }

复制代码

 
安命主星

1.         /// <summary>
2.         /// 安命主星
3.         /// </summary>
4.         /// <param name="mingGongDizhi">天盘命宫地支</param>
5.         /// <returns></returns>
6.         public static string GetMingZhuXing(string mingGongDizhi)
7.         {            
8.             Dictionary<string, string> dDoct = new Dictionary<string, string>();
9.             dDoct.Add("子", "贪狼");
10.             dDoct.Add("丑亥", "巨门");
11.             dDoct.Add("寅戌", "禄存");
12.             dDoct.Add("卯酉", "文曲");
13.             dDoct.Add("巳未", "武曲");
14.             dDoct.Add("辰申", "廉贞");
15.             dDoct.Add("午", "破军");
16.             var fDict = dDoct.Where(t => t.Key.Contains(mingGongDizhi)).First();
17.             return fDict.Value;
18.         }

复制代码

安身主星

1.         /// <summary>
2.         /// 安身主星
3.         /// </summary>
4.         /// <param name="yearDiZhi">年地支</param>
5.         /// <returns></returns>
6.         public static string GetShenZhuXing(string yearDiZhi)
7.         {
8.             Dictionary<string, string> dDoct = new Dictionary<string, string>();
9.             dDoct.Add("子", "铃星");
10.             dDoct.Add("午", "火星");
11.             dDoct.Add("丑未", "天相");
12.             dDoct.Add("寅申", "天梁");
13.             dDoct.Add("卯酉", "天同");
14.             dDoct.Add("巳亥", "天机");
15.             dDoct.Add("辰戌", "文昌");
17.             var fDict = dDoct.Where(t => t.Key.Contains(yearDiZhi)).First();
18.             return fDict.Value;
19.         }

复制代码

左辅右弼

规则：

安左辅星：左辅从辰宫起正月，顺数至生月宫止，所在宫即是。
安右弼星：右弼从戍宫起正月，逆数至生月宫止，所在宫即是。

1.         /// <summary>
2.         /// 获取左辅右弼星
3.         /// </summary>
4.         /// <param name="monthNo">月份 1,2,3,4</param>
5.         /// <returns></returns>
6.         public static List<string> Get_FuBi_XingAtDiZhi(int monthNo)
7.         {
8.             string zuoFuXIngDiZhi = "";
9.             if (monthNo + 3 > 11)
10.             {
11.                 zuoFuXIngDiZhi = CommonVarRule.CONST_DIZHI[(monthNo + 3) % 12];
12.             }
13.             else
14.             {
15.                 zuoFuXIngDiZhi = CommonVarRule.CONST_DIZHI[monthNo + 3];
16.             }
18.             string youbiFuXingDiZhi = "";
19.             if (11 - monthNo >= 0)
20.             {
21.                 youbiFuXingDiZhi = CommonVarRule.CONST_DIZHI[11 - monthNo];
22.             }
23.             else
24.             {
25.                 youbiFuXingDiZhi = CommonVarRule.CONST_DIZHI[11];  //亥
26.             }
28.             return new List<string> { zuoFuXIngDiZhi, youbiFuXingDiZhi };
29.         }

复制代码

文昌文曲

规则：

安文昌星：文昌从戍宫起子时，逆数至生时宫止，所在宫即是。
安文曲星：文曲从辰宫起子时，顺数至生时宫止，所在宫即是。

1.         /// <summary>
2.         /// 获取文曲文昌星排布
3.         /// </summary>
4.         /// <param name="hourNo">地支时间编号</param>
5.         /// <returns></returns>
6.         public static List<string> Get_WenChangWenQu_AtDiZhi(string hourDiZhi)
7.         {
9.             int hourNo = CommonVarRule.DiZhi_No_MAP[hourDiZhi];
11.             string wenQuDiZhi = "";
12.             if (hourNo + 3 > 11)
13.             {
14.                 wenQuDiZhi = CommonVarRule.CONST_DIZHI[(hourNo + 3) % 12];
15.             }
16.             else
17.             {
18.                 wenQuDiZhi = CommonVarRule.CONST_DIZHI[hourNo + 3];
19.             }
21.             string wenChangDiZhi = "";
22.             if (11 - hourNo >= 0)
23.             {
24.                 wenChangDiZhi = CommonVarRule.CONST_DIZHI[11 - hourNo];
25.             }
26.             else
27.             {
28.                 //12-->11
29.                 wenChangDiZhi = CommonVarRule.CONST_DIZHI[11];
30.             }
32.             return new List<string> { wenQuDiZhi, wenChangDiZhi };
33.         }

复制代码

 
十干四化

十干四化，四化是紫微斗数的核心存在。紫微斗数四化是用神所在。非常重要。如果用程序来表示规则，很简单。
四化：禄权科忌。

1.         /// <summary>
2.         /// 十干四化（禄权科忌）
3.         /// </summary>
4.         /// <param name="tianGan">天干</param>
5.         /// <returns></returns>
6.         public static List<string> Get_ShiGanSiHuaXing(string tianGan)
7.         {
8.             Dictionary<string, List<string>> rDict = new Dictionary<string, List<string>>();
9.             rDict.Add("甲", new List<string> { "廉贞", "破军", "武曲", "太阳" });
10.             rDict.Add("乙", new List<string> { "天机", "天梁", "紫微", "太阴" });
11.             rDict.Add("丙", new List<string> { "天同", "天机", "文昌", "廉贞" });
12.             rDict.Add("丁", new List<string> { "太阴", "天同", "天机", "巨门" });
14.             rDict.Add("戊", new List<string> { "贪狼", "太阴", "右弼", "天机" });
15.             rDict.Add("己", new List<string> { "武曲", "贪狼", "天梁", "文曲" });
16.             rDict.Add("庚", new List<string> { "太阳", "武曲", "太阴", "天同" });
17.             rDict.Add("辛", new List<string> { "巨门", "太阳", "文曲", "文昌" });
19.             rDict.Add("壬", new List<string> { "天梁", "紫微", "左辅", "武曲" });
20.             rDict.Add("癸", new List<string> { "破军", "巨门", "太阴", "贪狼" });
22.             return rDict[tianGan];
23.         }

复制代码

伟大的分割线。
阶段总结

走到这里， 到此可以结束了吗？实话说可以啦。可开始图片中还有很多星星，还没有排布呢。举一反三，比葫芦画瓢。那些小星排布实现，非常容易。
 

安月系星

安天刑：从酉宫起正月，顺数至生月宫止，所在宫即是。
安天姚：从丑宫起正月，顺数至生月宫止，所在宫即是。
 
安阴煞：从正月至十二月顺序为：寅子戍申午辰寅子戍申午辰。
规律：正月至六月，正月从寅支起，以后逐月地支逆隔一支，七月至十二月重复同前。
安天月：从正月至十二月顺序为：戍巳辰寅未卯亥未寅午戍寅。
安天巫：从正月至十二月顺序为：巳申亥寅巳申亥寅巳申亥寅。

 
安时系星

安天空星：天空从亥宫起子时，逆数至生时宫止，所在宫即是。
安地劫星：地劫从亥宫起子时，顺数至生时宫止，所在宫即是。
安台辅星诀：从午宫起子时，顺数至生时止，所在宫即是。
安封诰星诀：从寅宫起子时，顺数至生时止，所在宫即是。

 
安生年支系诸星

安天哭星：天哭从午宫起子年，逆数至生年止，所在宫即是。
安天虚星：天虚从午宫起子年，顺数至生年止，所在宫即是。
安天马星：寅午戍年马居申，申子辰年马在寅，巳酉丑年马在亥，亥卯未年马居巳。
 
安红鸾星：从卯宫起子年，逆数至出生年支，所在宫即是。
安天喜星：天喜必在红鸾的对宫。
 
安龙池星：从辰宫起子年，顺数到生年地支止，所在宫即是。
安凤阁星：从戍宫起子年，逆数到生年地支止，所在宫即是。
 
安华盖星：申子辰年生人在辰，亥卯未年在未，寅午戍年在戍，巳酉丑年在丑。(四墓宫)
安劫煞星：申子辰年生人在巳，亥卯未年在申，寅午戍年在亥，巳酉丑年在寅。(四马宫)
安咸池星：申子辰年生人在酉，亥卯未年在子，寅午戍年在卯，巳酉丑年在午。(四败宫)
安孤辰星：寅卯辰年生人在巳，巳午未年在申，申酉戍年在亥，亥子丑年在寅。(四马宫)
安寡宿星：寅卯辰年生人在丑，巳午未年在辰，申酉戍年在未，亥子丑年在戍。(四墓宫)
 
安破碎星：子午卯酉年生人在巳，辰戍丑未年生人在丑，寅申巳亥年生人在酉。
安大耗星：子年在未，丑年在午，寅年在酉，卯年在申，辰年在亥，巳年在戍，
午年在丑，未年在子，申年在卯，酉年在寅，戍年在巳，亥年在辰。
 
安天德星：从酉宫起子年，顺数到生年地支止，所在宫即是。
安解神星：从戍宫起子年，逆数到生年地支止，所在宫即是。
 
安蜚廉星：子年在申，丑年在酉，寅年在戍，卯年巳，辰年在午，巳年在未，午年在寅，未年在卯，申年在辰，酉年在亥，戍年在子，亥年在丑。 

 
安生年干系诸星

安禄存星：甲禄在寅乙禄卯，丙戊在巳丁己午，庚禄居申辛禄酉，壬禄居亥癸禄子。
安擎羊陀罗：羊禄陀三星始终连在一起，禄居中间，羊在前(顺下为前一位)，陀在后(逆数为后一位)。
 
安天魁天钺：甲戊庚丑未，乙己子申乡，辛逢午寅是，丙丁亥酉位，壬癸卯巳藏，此是贵人方。(每句天干为出生年天干，前一地支为天魁所在宫，后一地支为天钺所在宫)。
 
安天官星：甲年在未，乙年在辰，丙年在巳，丁年在寅，戊年在卯，己年在酉，庚年在亥，辛年在酉，壬年在戍，癸年在午。
 
安天福星：甲年在酉，乙年在申，丙年在子，丁年在亥，戊年在卯，己年在寅，庚年在午，辛年在巳，壬年在午，癸年在巳。
 
安截空星：甲己年申酉，乙庚年午未，丙辛年辰巳，丁壬年寅卯，戊癸年子丑。意思是：甲年或己年的截空星是申和酉，余类推。截空星分正空和副空，正空力大，副空力小。天干为阳者则在阳宫的空星为正空，在阴宫的空星为副空；天干为阴者则在阴宫的空星为正空，在阳宫的空星为副空。例如，甲年生人，申为正空，酉为副空；己年生人，酉为正空，申为副空。
 
安火星：寅午戍年丑宫起，申子辰年寅宫始，巳酉丑年在卯宫，亥卯未年酉宫起，从起始宫起子时，顺数至生时止，所在宫即是。
安铃星：寅午戍年卯宫起子时，申子辰、巳酉丑、亥卯未年均从戍宫起子时，顺数至生时止，所在宫即是。
 
安三台星：由左辅星所在宫位上起初一日，沿十二宫顺时针方向数，数至出生日止，即在此宫安三台星。
安八座星：由右弼星所在宫位上起初一日，沿十二宫逆时针方向数，数至出生日止，即在此宫安八座星。
 
安天贵星：由文曲星所在宫位上起初一日，顺时针方向数，数至出生日宫再退回一宫，即在此宫安天贵星。
安恩光星：由文昌星所在宫位上起初一日，顺时针方向数，数至出生日宫再退回一宫，即在此宫安恩光星。
 
安天才星：由命宫起子年，沿十二宫顺时针方向数，数至出生年支所在宫止，即在此宫安天才星。
安天寿星：由身宫起子年，沿十二宫顺时针方向数，数至出生年支所在宫止，即在此宫安天寿星。
安天伤、天使星：天伤星固定在奴仆宫，天使星固定在疾厄宫。

 
 
安生年博士十二神

禄存星*所在宫打头，阳男阴女顺行，阴男阳女逆行
依次布下博士、力士、青龙、小耗、将军、奏书、飞廉、喜神、病符、大耗、伏兵、官符，每一宫安一星。

 
回首望

到这里，我们已经完整走完了整个流程（运限除外）。最终效果如下:

 
从整个过程中，我们能够发现整个排盘规则，复杂繁琐。其中我们可以窥探中，其中的隐藏的深处密码。比如，身主，左右昌曲等等 星的排布的秘密很值得挖掘。
从中我们也能体会，古人排布一个命例辛苦。我想，在当下信息技术加持下，借助大数据+人工智能，传统的紫微斗数学问，必将大放异彩，必将也成为了中国文化重要组成部分， 对此我深信不疑。
​

来源:https://www.cnblogs.com/voidobject/p/18510346
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！