运势计算：以双向链表实现： 计算爻卦

1.0 准备开始

我们先制定一个计算结构体，一切开始于此。

我们首先需要知道参与计算的 算子有多少，我们就按最常用的数49来制定。

type DataTao struct {
        DefMean    map[int]string // 卦象坐标名称
        DefValue   map[int]string // 卦象坐标值 4个
        GuaData    []int          // 卦象的 6爻初始值
        Indent     int            // 格式化输出间隔
        Env        int            // 影响偏差，Env 把一年分为 3个部分，每个部分4个月，这个值可以影响天地分开的比例，自己随意
        Total      int            // 大衍之数 个数
        PrintLevel int            // 计算过程显示控制，如果为 1 则显示
        Coordinate map[int]string //卦象坐标的 爻，古称
    }

制作该计算对象的构造函数

/*
      @param env 环境参数
      @param indent 格式化输出的缩进
      @param total 天地 大衍数 49
      */
      func MakeNewDataTao(env string, indent, total int) *DataTao {
          envNum := map[string]int{"A": 1, "B": 0, "C": 2}
          guaCoor := map[int]string{6: "六", 7: "七", 8: "八", 9: "九"}

        var envLevel = 0

        if indent <= 0 {
            indent = 8
        }

        if env != "" {
            envLevel = envNum[env]
        }

        if total < 49 {
            total = 49
        }

        newData := &DataTao{
            DefMean:    defMean,
            DefValue:   guaCoor,
            GuaData:    []int{},
            Indent:     indent,
            Env:        envLevel,
            Total:      total,
            PrintLevel: envNum["A"],
            Coordinate: Coordinates,
        }
        return newData
    }

1.1 开天辟地，创建爻变

创建天地大衍之数，创建一个新的天地列表 大衍之数，使用49

func (dt *DataTao) NewCircle() []int {
    var newCir []int
    for i := 0; i < dt.Total; i++ {
        newCir = append(newCir, i)
    }
    return newCir
}

由于每一变 除以4的余数可能为 0，此时需要拿走4个算子，所以，3变最多需要12个算子，而分天地，

默认随机算法 计算后 将其值 限定为下限 12，上限 37，为什么要如此限定，就在于变爻的初始算子数量。

func (dt *DataTao) SplitNum(topNum int) int {
    /*
        Seed 使用提供的种子值将生成器初始化为确定性状态。
        Seed 不应与任何其他 Rand 方法同时调用。
    */
    rand.Seed(time.Now().UnixNano())
    top := topNum - 4
    sn := rand.Intn(top) + 4 // A random int in [4, 45]

    if dt.Env != 0 {
        if dt.Env == 1 {
            sn = sn + (dt.Env * 3)
        } else {
            sn = sn + (dt.Env * 2)
        }

    }
    if sn < 4 {
        sn = 4
    }

    if sn > topNum - 4 {
        sn = topNum - 4
    }

    logger.Printf("outcome sn:%v with topNum:%v\n", sn, topNum)
    return sn
}

1.1.1 创建爻变,得天地人三才

从天，地随机选择一方，拿出一个算子 作为天地人的 人才 // 分三才 从选定的一方 得一人

func (dt *DataTao) RandLis(lis []int) ([]int, int) {

    rand.Seed(time.Now().UnixNano())
    if len(lis) < 2 {
        return lis, 0
    }
    t := rand.Intn(len(lis) - 1)
    ren := lis[t]
    lis = append(lis[:t], lis[t+1:]...)
    return lis, ren

}

推算的主要过程就是爻变的操作，每一爻都需要有3次爻变，最后得出一爻，我们先实现一变 //做一变

/*
@param: lis, 天地混沌，需要分开的算子集合
@param: sn, 从算子集合的哪一个位置执行分开
// 做一变，为得一爻
*/
func (dt *DataTao) DoOneYao(lis []int, sn int) []int {

    //分天地
    tian := lis[:sn]
    di := lis[sn:]

    var ran int
    //从天地 取一人
    rand.Seed(time.Now().UnixNano())
    r := rand.Intn(2)
    if r == 0 {
        tian, ran = dt.RandLis(tian)
    } else {
        di, ran = dt.RandLis(di)
    }

    //一变
    var tia, d, newOrigin []int
    xt := len(tian) % 4
    if xt == 0 {
        //取 4个
        tia = tian[:4]
        tian = tian[4:]
    } else {
        tia = tian[:xt]
        tian = tian[xt:]
    }

    dtv := len(di) % 4
    if dtv == 0 {
        d = di[:4]
        di = di[4:]
    } else {
        d = di[:dtv]
        di = di[dtv:]
    }

    //返回一变
    newOrigin = append(tia, d...)
    newOrigin = append(newOrigin, ran)

    if dt.Env == dt.PrintLevel {
        SixYao = append(SixYao, newOrigin)
        logger.Println("余天:", tian, "\n余地:", di, "\n变数:", newOrigin, "人才:", ran, "\n新天地:", len(tian)+len(di))
        logger.Println("已变总数:", len(SixYao))
    }
    newDT := append(tian, di...)
    return newDT
}

每一个爻都需要对 天地大衍之数做三变，最后剩下的算子数 除以4 就是 一爻，算6次爻 那么就是一卦。 // 连续三变 得一爻，返回新天地

func (dt *DataTao) TianDiYao(lis []int) ([]int, int) {
    /*
            分天地 进行 变一
                :param lis:
                :param sn:
                :return:  最后的 天，地，归档人列表， 和 爻 值
    */
    finalTiandi := lis
    for _, k := range []int{1, 2, 3} {
        if dt.Env == dt.PrintLevel {
            logger.Println("第", k, "变")
        }
        finalTiandi = dt.DoOneYao(finalTiandi, dt.SplitNum(len(finalTiandi)))
    }

    yao := len(finalTiandi) / 4
    if dt.Total > 49 {
        db := dt.Total / 49
        yao := yao / db
        if dt.Env == dt.PrintLevel {
            logger.Println("大衍之数:", dt.Total, "三变后的爻:", yao, "距离 倍数 db:", db, "新天地:", len(finalTiandi))
        }

    }
    if dt.Env == dt.PrintLevel {
        logger.Println("三变后的爻:", yao)
    }
    return finalTiandi, yao
}

1.1.2 创建爻变, 得到6爻 即一卦

计算6个爻 则需要 3变 6次，并使用上一节的双向链表保存结果。 // 推演函数，开天辟地，并计算6爻

func (dt *DataTao) SuanGua() *dlist {
    // gua := []int{}
    logger.Printf("开始占卜运势...")
    for i := 1; i < 7; i++ {
        nc := dt.NewCircle()
        if dt.Env == dt.PrintLevel {
            logger.Println(len(nc), nc, dt.SplitNum(len(nc)))
        }
        ///分天地人
        ft, y := dt.TianDi(nc)
        if dt.Env == dt.PrintLevel {
            logger.Println("新天地:", ft)
            logger.Println(dt.Coordinate[i]+dt.DefValue[y], "\n第", i, "爻", y, dt.DefMean[y])
        }
        time.Sleep(time.Millisecond * 100)
        // gua = append(gua, y)
        ResultNodes.append(&node{number: y})
    }
    return ResultNodes
}

小结

本小节 我们实现了推演运势的过程，在下一小节，我们将实现对链表的数据读取 和 爻象的解读，然后以直观的方式给用户展示。