eta_index_lib/models/predict_edb_info_rule.go

package models

import (
	"errors"
	"github.com/shopspring/decimal"
	"hongze/hongze_edb_lib/utils"
	"math"
	"time"
)

// GetChartPredictEdbInfoDataListByRule1 根据规则1获取预测数据
func GetChartPredictEdbInfoDataListByRule1(edbInfoId int, dataValue float64, startDate, endDate time.Time, frequency string, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData) {
	newPredictEdbInfoData = predictEdbInfoData
	//获取后面的预测数据
	dayList := getPredictEdbDayList(startDate, endDate, frequency)
	predictEdbInfoData = make([]*EdbInfoSearchData, 0)
	for k, v := range dayList {
		newPredictEdbInfoData = append(newPredictEdbInfoData, &EdbInfoSearchData{
			EdbDataId: edbInfoId + 10000000000 + k,
			DataTime:  v.Format(utils.FormatDate),
			Value:     dataValue,
		})
		existMap[v.Format(utils.FormatDate)] = dataValue
	}
	return
}

//	GetChartPredictEdbInfoDataListByRuleTb 根据同比值规则获取预测数据
//	2.1 同比: 在未来某一个时间段内，给定一个固定的同比增速a，用去年同期值X乘以同比增速(1+a)，得到预测值Y=X(1+a)
//	例: 今年1-3月值，100，100，120。给定同比增速a=0.1，则明年1-3月预测值为: 100*1.1=110，100*1.1=110，120*1.1=132。
func GetChartPredictEdbInfoDataListByRuleTb(edbInfoId int, tbValue float64, startDate, endDate time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
	allDataList := make([]*EdbInfoSearchData, 0)
	allDataList = append(allDataList, realPredictEdbInfoData...)
	allDataList = append(allDataList, predictEdbInfoData...)
	newPredictEdbInfoData = predictEdbInfoData

	index := len(allDataList)
	//获取后面的预测数据
	dayList := getPredictEdbDayList(startDate, endDate, frequency)
	predictEdbInfoData = make([]*EdbInfoSearchData, 0)
	for k, currentDate := range dayList {

		tmpData := &EdbInfoSearchData{
			EdbDataId: edbInfoId + 10000000000 + index + k,
			DataTime:  currentDate.Format(utils.FormatDate),
			//Value:         dataValue,
		}

		var val float64
		var calculateStatus bool //计算结果
		//currentItem := existMap[av]
		//上一年的日期
		preDate := currentDate.AddDate(-1, 0, 0)
		preDateStr := preDate.Format(utils.FormatDate)
		if preValue, ok := existMap[preDateStr]; ok { //上一年同期找到
			val = PredictTbzDiv(preValue, tbValue)
			calculateStatus = true
		} else {
			switch frequency {
			case "月度":
				//向上和向下，各找一个月
				nextDateDay := preDate
				preDateDay := preDate
				for i := 0; i <= 35; i++ {
					nextDateDayStr := nextDateDay.Format(utils.FormatDate)
					if preValue, ok := existMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
						val = PredictTbzDiv(preValue, tbValue)
						calculateStatus = true
						break
					} else {
						preDateDayStr := preDateDay.Format(utils.FormatDate)
						if preValue, ok := existMap[preDateDayStr]; ok { //上一年同期->上一个月找到
							val = PredictTbzDiv(preValue, tbValue)
							calculateStatus = true
							break
						}
					}
					nextDateDay = nextDateDay.AddDate(0, 0, 1)
					preDateDay = preDateDay.AddDate(0, 0, -1)
				}

			case "季度", "年度":
				if preValue, ok := existMap[preDateStr]; ok { //上一年同期->下一个月找到
					val = PredictTbzDiv(preValue, tbValue)
					calculateStatus = true
					break
				}
			default:
				nextDateDay := preDate
				preDateDay := preDate

				for i := 0; i < 35; i++ {
					nextDateDayStr := nextDateDay.Format(utils.FormatDate)
					if preValue, ok := existMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
						val = PredictTbzDiv(preValue, tbValue)
						calculateStatus = true
						break
					} else {
						preDateDayStr := preDateDay.Format(utils.FormatDate)
						if preValue, ok := existMap[preDateDayStr]; ok { //上一年同期->上一个月找到
							val = PredictTbzDiv(preValue, tbValue)
							calculateStatus = true
							break
						} else {
							//fmt.Println("pre not find:", preDateStr, "i:", i)
						}
					}
					nextDateDay = nextDateDay.AddDate(0, 0, 1)
					preDateDay = preDateDay.AddDate(0, 0, -1)
				}
			}
		}

		if calculateStatus {
			tmpData.Value = val
			newPredictEdbInfoData = append(newPredictEdbInfoData, tmpData)
			allDataList = append(allDataList, tmpData)
			existMap[tmpData.DataTime] = val

			// 最大最小值
			if val < minValue {
				minValue = val
			}
			if val > maxValue {
				maxValue = val
			}
		}
	}
	return
}

// PredictTbzDiv 同比值计算
// @params a float64 去年同期值
// @params b float64 固定同比增速
func PredictTbzDiv(a, b float64) (result float64) {
	if b != 0 {
		// 去年同期值
		af := decimal.NewFromFloat(a)

		// 同比增速
		bf := decimal.NewFromFloat(b)

		// 默认1
		cf := decimal.NewFromFloat(1)

		// 总增速
		val := bf.Add(cf)

		// 计算
		result, _ = val.Mul(af).RoundCeil(4).Float64()
	} else {
		result = 0
	}
	return
}

//	GetChartPredictEdbInfoDataListByRuleTc 根据同差值规则获取预测数据
//	2.2 同差: 在未来某一个时间段内，给定一个固定的同比增加值a，用去年同期值X加上同比增加值A，得到预测值Y=X+a
//	例: 今年1-3月值，100，100，120。给定同比增加值a=10，则明年1-3月预测值为: 100+10=110，100+10=110，120+10=130
func GetChartPredictEdbInfoDataListByRuleTc(edbInfoId int, tcValue float64, startDate, endDate time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
	allDataList := make([]*EdbInfoSearchData, 0)
	allDataList = append(allDataList, realPredictEdbInfoData...)
	allDataList = append(allDataList, predictEdbInfoData...)
	newPredictEdbInfoData = predictEdbInfoData

	index := len(allDataList)
	//获取后面的预测数据
	dayList := getPredictEdbDayList(startDate, endDate, frequency)
	predictEdbInfoData = make([]*EdbInfoSearchData, 0)
	for k, currentDate := range dayList {

		tmpData := &EdbInfoSearchData{
			EdbDataId: edbInfoId + 10000000000 + index + k,
			DataTime:  currentDate.Format(utils.FormatDate),
			//Value:         dataValue,
		}

		var val float64
		var calculateStatus bool //计算结果
		//currentItem := existMap[av]
		//上一年的日期
		preDate := currentDate.AddDate(-1, 0, 0)
		preDateStr := preDate.Format(utils.FormatDate)
		if preValue, ok := existMap[preDateStr]; ok { //上一年同期找到
			val = PredictTczDiv(preValue, tcValue)
			calculateStatus = true
		} else {
			switch frequency {
			case "月度":
				//向上和向下，各找一个月
				nextDateDay := preDate
				preDateDay := preDate
				for i := 0; i <= 35; i++ {
					nextDateDayStr := nextDateDay.Format(utils.FormatDate)
					if preValue, ok := existMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
						val = PredictTczDiv(preValue, tcValue)
						calculateStatus = true
						break
					} else {
						preDateDayStr := preDateDay.Format(utils.FormatDate)
						if preValue, ok := existMap[preDateDayStr]; ok { //上一年同期->上一个月找到
							val = PredictTczDiv(preValue, tcValue)
							calculateStatus = true
							break
						}
					}
					nextDateDay = nextDateDay.AddDate(0, 0, 1)
					preDateDay = preDateDay.AddDate(0, 0, -1)
				}

			case "季度", "年度":
				if preValue, ok := existMap[preDateStr]; ok { //上一年同期->下一个月找到
					val = PredictTczDiv(preValue, tcValue)
					calculateStatus = true
					break
				}
			default:
				nextDateDay := preDate
				preDateDay := preDate

				for i := 0; i < 35; i++ {
					nextDateDayStr := nextDateDay.Format(utils.FormatDate)
					if preValue, ok := existMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
						val = PredictTczDiv(preValue, tcValue)
						calculateStatus = true
						break
					} else {
						preDateDayStr := preDateDay.Format(utils.FormatDate)
						if preValue, ok := existMap[preDateDayStr]; ok { //上一年同期->上一个月找到
							val = PredictTczDiv(preValue, tcValue)
							calculateStatus = true
							break
						} else {
							//fmt.Println("pre not find:", preDateStr, "i:", i)
						}
					}
					nextDateDay = nextDateDay.AddDate(0, 0, 1)
					preDateDay = preDateDay.AddDate(0, 0, -1)
				}
			}
		}

		if calculateStatus {
			tmpData.Value = val
			newPredictEdbInfoData = append(newPredictEdbInfoData, tmpData)
			allDataList = append(allDataList, tmpData)
			existMap[tmpData.DataTime] = val

			// 最大最小值
			if val < minValue {
				minValue = val
			}
			if val > maxValue {
				maxValue = val
			}
		}
	}
	return
}

// PredictTczDiv 环差值计算
// @params a float64 上一期值
// @params b float64 固定的环比增加值
func PredictTczDiv(a, b float64) (result float64) {
	if b != 0 {
		// 上一期值
		af := decimal.NewFromFloat(a)

		// 固定的环比增加值
		bf := decimal.NewFromFloat(b)

		// 计算
		result, _ = af.Add(bf).RoundCeil(4).Float64()
	} else {
		result = 0
	}
	return
}

//	GetChartPredictEdbInfoDataListByRuleHb 根据环比值规则获取预测数据
//	环比：在未来某一个时间段内，给定一个固定的环比增速a，用上一期值X乘以环比增速(1+a)，得到预测值Y=X(1+a)
//	例: 最近1期值为100，给定环比增速a=0.2，则未来3期预测值为: 100*1.2=120，120*1.2=144，144*1.2=172.8
func GetChartPredictEdbInfoDataListByRuleHb(edbInfoId int, hbValue float64, startDate, endDate time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
	allDataList := make([]*EdbInfoSearchData, 0)
	allDataList = append(allDataList, realPredictEdbInfoData...)
	allDataList = append(allDataList, predictEdbInfoData...)
	newPredictEdbInfoData = predictEdbInfoData

	index := len(allDataList)
	//获取后面的预测数据
	dayList := getPredictEdbDayList(startDate, endDate, frequency)
	for k, currentDate := range dayList {
		tmpK := index + k - 1 //上1期的值

		// 环比值计算
		val := PredictHbzDiv(allDataList[tmpK].Value, hbValue)

		currentDateStr := currentDate.Format(utils.FormatDate)
		tmpData := &EdbInfoSearchData{
			EdbDataId: edbInfoId + 10000000000 + index + k,
			DataTime:  currentDateStr,
			Value:     val,
		}
		newPredictEdbInfoData = append(newPredictEdbInfoData, tmpData)
		allDataList = append(allDataList, tmpData)
		existMap[currentDateStr] = val

		// 最大最小值
		if val < minValue {
			minValue = val
		}
		if val > maxValue {
			maxValue = val
		}
	}
	return
}

// PredictHbzDiv 环比值计算
// @params a float64 上一期值
// @params b float64 固定的环比增速
func PredictHbzDiv(a, b float64) (result float64) {
	if b != 0 {
		// 上一期值
		af := decimal.NewFromFloat(a)

		// 固定的环比增速
		bf := decimal.NewFromFloat(b)

		// 默认1
		cf := decimal.NewFromFloat(1)

		// 总增速
		val := bf.Add(cf)

		// 计算
		result, _ = val.Mul(af).RoundCeil(4).Float64()
	} else {
		result = 0
	}
	return
}

//	GetChartPredictEdbInfoDataListByRuleHc 根据环差值规则获取预测数据
//	2.4 环差：在未来某一个时间段内，给定一个固定的环比增加值a，用上一期值X加上环比增加值a，得到预测值Y=X+a
//	例: 最近1期值为100，给定环比增加值a=10，则未来3期预测值为: 100+10=110，110+10=120，120+10=130
func GetChartPredictEdbInfoDataListByRuleHc(edbInfoId int, hcValue float64, startDate, endDate time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
	allDataList := make([]*EdbInfoSearchData, 0)
	allDataList = append(allDataList, realPredictEdbInfoData...)
	allDataList = append(allDataList, predictEdbInfoData...)
	newPredictEdbInfoData = predictEdbInfoData

	index := len(allDataList)
	//获取后面的预测数据
	dayList := getPredictEdbDayList(startDate, endDate, frequency)
	for k, currentDate := range dayList {
		tmpK := index + k - 1 //上1期的值

		// 环差别值计算
		val := PredictHczDiv(allDataList[tmpK].Value, hcValue)

		currentDateStr := currentDate.Format(utils.FormatDate)
		tmpData := &EdbInfoSearchData{
			EdbDataId: edbInfoId + 10000000000 + index + k,
			DataTime:  currentDateStr,
			Value:     val,
		}
		newPredictEdbInfoData = append(newPredictEdbInfoData, tmpData)
		allDataList = append(allDataList, tmpData)
		existMap[currentDateStr] = val

		// 最大最小值
		if val < minValue {
			minValue = val
		}
		if val > maxValue {
			maxValue = val
		}
	}
	return
}

// PredictHczDiv 环差值计算
// @params a float64 上一期值
// @params b float64 固定的环比增加值
func PredictHczDiv(a, b float64) (result float64) {
	if b != 0 {
		// 上一期值
		af := decimal.NewFromFloat(a)

		// 固定的环比增加值
		bf := decimal.NewFromFloat(b)

		// 计算
		result, _ = af.Add(bf).RoundCeil(4).Float64()
	} else {
		result = 0
	}
	return
}

//	GetChartPredictEdbInfoDataListByRuleNMoveMeanValue 根据N期移动均值规则获取预测数据
//	2.5 N期移动均值：在未来某一个时间段内，下一期值等于过去N期值得平均值。
//	例：最近3期值(N=3),为95，98，105则未来第1期值为 1/3*(95+98+105)=99.33, 未来第2期值为 1/3*(98+105+99.33)=100.78依次类推。
func GetChartPredictEdbInfoDataListByRuleNMoveMeanValue(edbInfoId int, nValue int, startDate, endDate time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
	allDataList := make([]*EdbInfoSearchData, 0)
	allDataList = append(allDataList, realPredictEdbInfoData...)
	allDataList = append(allDataList, predictEdbInfoData...)
	newPredictEdbInfoData = predictEdbInfoData

	lenAllData := len(allDataList)
	if lenAllData < nValue || lenAllData <= 0 {
		return
	}
	if nValue <= 0 {
		return
	}
	// 分母
	decimalN := decimal.NewFromInt(int64(nValue))

	//获取后面的预测数据
	dayList := getPredictEdbDayList(startDate, endDate, frequency)
	for k, currentDate := range dayList {
		tmpIndex := lenAllData + k - 1 //上1期的值

		// 数据集合中的最后一个数据
		tmpDecimalVal := decimal.NewFromFloat(allDataList[tmpIndex].Value)
		for tmpK := 2; tmpK <= nValue; tmpK++ {
			tmpIndex2 := tmpIndex - tmpK //上N期的值
			tmpDecimalVal2 := decimal.NewFromFloat(allDataList[tmpIndex2].Value)
			tmpDecimalVal = tmpDecimalVal.Add(tmpDecimalVal2)
		}

		// N期移动均值计算
		val, _ := tmpDecimalVal.Div(decimalN).RoundCeil(4).Float64()

		currentDateStr := currentDate.Format(utils.FormatDate)
		tmpData := &EdbInfoSearchData{
			EdbDataId: edbInfoId + 10000000000 + lenAllData + k,
			DataTime:  currentDateStr,
			Value:     val,
		}
		newPredictEdbInfoData = append(newPredictEdbInfoData, tmpData)
		allDataList = append(allDataList, tmpData)
		existMap[currentDateStr] = val

		// 最大最小值
		if val < minValue {
			minValue = val
		}
		if val > maxValue {
			maxValue = val
		}
	}
	return
}

//	GetChartPredictEdbInfoDataListByRuleNLinearRegression 根据N期移动均值规则获取预测数据
//	2.6N期段线性外推值：给出过去N期值所确定的线性回归方程(Y=aX+b)在未来一段时间内的推算值。回归方程虽然比较复杂，但各种编程语言应该都有现成的模块或函数，应该无需自己编写。
//	例1：过去5期值(N=5)分别为：3，5，7，9，11（每两期值之间的时间间隔相等）。那么按照线性回归方程推算，未来三期的预测值是：13，15，17。
//
//	例2：过去6期值(N=6)分别为：3，3，5，7，9，11（每两期值之间的时间间隔相等）。那么按照线性回归方程推算，未来三期的预测值是：12.33，14.05，15.76。例1和例2的区别在于，多加了一期数据，导致回归方程发生改变，从而预测值不同。
func GetChartPredictEdbInfoDataListByRuleNLinearRegression(edbInfoId int, nValue int, startDate, endDate time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64, err error) {
	//var errMsg string
	//defer func() {
	//	if errMsg != `` {
	//		go alarm_msg.SendAlarmMsg("更新上海的token失败；ERR："+err.Error(), 3)
	//	}
	//}()
	allDataList := make([]*EdbInfoSearchData, 0)
	allDataList = append(allDataList, realPredictEdbInfoData...)
	allDataList = append(allDataList, predictEdbInfoData...)
	newPredictEdbInfoData = predictEdbInfoData

	lenAllData := len(allDataList)
	if lenAllData < nValue || lenAllData <= 0 {
		return
	}

	if nValue <= 1 {
		return
	}

	//获取后面的预测数据
	// 获取线性方程公式的a、b的值
	coordinateData := make([]Coordinate, 0)
	for tmpK := nValue; tmpK > 0; tmpK-- {
		tmpIndex2 := lenAllData - tmpK //上N期的值
		tmpCoordinate := Coordinate{
			X: float64(nValue - tmpK + 1),
			Y: allDataList[tmpIndex2].Value,
		}
		coordinateData = append(coordinateData, tmpCoordinate)
	}
	a, b := getLinearResult(coordinateData)
	if math.IsNaN(a) || math.IsNaN(b) {
		err = errors.New("线性方程公式生成失败")
		return
	}
	//fmt.Println("a:", a, ";======b:", b)

	aDecimal := decimal.NewFromFloat(a)
	bDecimal := decimal.NewFromFloat(b)
	dayList := getPredictEdbDayList(startDate, endDate, frequency)
	for k, currentDate := range dayList {
		tmpK := nValue + k + 1

		xDecimal := decimal.NewFromInt(int64(tmpK))
		val, _ := aDecimal.Mul(xDecimal).Add(bDecimal).RoundCeil(4).Float64()

		currentDateStr := currentDate.Format(utils.FormatDate)
		tmpData := &EdbInfoSearchData{
			EdbDataId: edbInfoId + 10000000000 + lenAllData + k,
			DataTime:  currentDateStr,
			Value:     val,
		}
		newPredictEdbInfoData = append(newPredictEdbInfoData, tmpData)
		allDataList = append(allDataList, tmpData)
		existMap[currentDateStr] = val

		// 最大最小值
		if val < minValue {
			minValue = val
		}
		if val > maxValue {
			maxValue = val
		}
	}
	return
}

// Series is a container for a series of data
type Series []Coordinate

// Coordinate holds the data in a series
type Coordinate struct {
	X, Y float64
}

func getLinearResult(s []Coordinate) (gradient, intercept float64) {
	if len(s) <= 1 {
		return
	}

	// Placeholder for the math to be done
	var sum [5]float64

	// Loop over data keeping index in place
	i := 0
	for ; i < len(s); i++ {
		sum[0] += s[i].X
		sum[1] += s[i].Y
		sum[2] += s[i].X * s[i].X
		sum[3] += s[i].X * s[i].Y
		sum[4] += s[i].Y * s[i].Y
	}

	// Find gradient and intercept
	f := float64(i)
	gradient = (f*sum[3] - sum[0]*sum[1]) / (f*sum[2] - sum[0]*sum[0])
	intercept = (sum[1] / f) - (gradient * sum[0] / f)

	//fmt.Println("gradient:", gradient, ";intercept:", intercept)
	// Create the new regression series
	//for j := 0; j < len(s); j++ {
	//	regressions = append(regressions, Coordinate{
	//		X: s[j].X,
	//		Y: s[j].X*gradient + intercept,
	//	})
	//}

	return
}

//	GetChartPredictEdbInfoDataListByRuleTrendsHC 根据动态环比增加值的计算规则获取预测数据
// 研究员有对预测指标进行动态环差计算的需求，即预测指标使用环差规则进行预测时，环比增加值不是固定值，而是由几个预测指标计算得出的动态变化的值；
//需求说明：
//1、增加“动态环差”预测规则；
//2、环比增加值在弹窗设置；
//3、动态环差预测举例：
//指标A实际最新数据为2022-10-27（100）；
//预测指标B预测数据为2022-10-28（240）、2022-10-29（300）；
//预测指标C预测数据为2022-10-28（260）、2022-10-29（310）；
//计算公式为B-C；
//则指标A至2022-10-29的预测值为2022-10-28（100+（240-260）=80）、2022-10-29（80+（300-310）=90）；
//注：动态环比增加值的计算遵从计算指标的计算规则，即用于计算的指标若有部分指标缺少部分日期数据，则这部分日期数据不做计算，为空；若动态环比增加值某一天为空，则往前追溯最近一期有值的环比增加值作为该天的数值参与计算；
func GetChartPredictEdbInfoDataListByRuleTrendsHC(edbInfoId, configId int, startDate, endDate time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
	allDataList := make([]*EdbInfoSearchData, 0)
	allDataList = append(allDataList, realPredictEdbInfoData...)
	allDataList = append(allDataList, predictEdbInfoData...)
	newPredictEdbInfoData = predictEdbInfoData

	lenAllData := len(allDataList)
	if lenAllData <= 0 {
		return
	}

	hcDataMap := make(map[string]float64) //规则计算的环差值map

	tmpPredictEdbRuleDataList, err := GetPredictEdbRuleDataItemList(edbInfoId, configId, startDate.Format(utils.FormatDate), endDate.Format(utils.FormatDate))
	if err != nil {
		return
	}
	for _, v := range tmpPredictEdbRuleDataList {
		hcDataMap[v.DataTime] = v.Value
	}

	dayList := getPredictEdbDayList(startDate, endDate, frequency)
	for k, currentDate := range dayList {
		// 最近一条数据
		tmpLenAllDataList := len(allDataList)
		lastValue := allDataList[tmpLenAllDataList-1].Value

		// 动态环差值数据
		currentDateStr := currentDate.Format(utils.FormatDate)
		hcVal, ok := hcDataMap[currentDateStr]
		if !ok {
			continue
		}
		lastValueDecimal := decimal.NewFromFloat(lastValue)
		hcValDecimal := decimal.NewFromFloat(hcVal)

		val, _ := lastValueDecimal.Add(hcValDecimal).RoundCeil(4).Float64()

		tmpData := &EdbInfoSearchData{
			EdbDataId: edbInfoId + 10000000000 + lenAllData + k,
			//EdbInfoId:     edbInfoId,
			DataTime: currentDateStr,
			Value:    val,
			//DataTimestamp: (currentDate.UnixNano() / 1e6) + 1000, //前端需要让加1s，说是2022-09-01 00:00:00 这样的整点不合适
		}
		newPredictEdbInfoData = append(newPredictEdbInfoData, tmpData)
		allDataList = append(allDataList, tmpData)
		existMap[currentDateStr] = val

		// 最大最小值
		if val < minValue {
			minValue = val
		}
		if val > maxValue {
			maxValue = val
		}
	}
	return
}

//	GetChartPredictEdbInfoDataListByRuleFinalValueHc 根据 给定终值后插值 规则获取预测数据
// 项目背景：
//假设螺纹产量在2023年1月1号的预测值是255万吨，从当下到2023年1月1号，螺纹产量将会线性变化，那么每一期的螺纹产量是多少？
//算法：从当下(2022/10/28)到2023/1/1号，一共65天，从当前值(305.02)到255，差值-50.02,
//则每日环差为-50.02/65=-0.7695。因为数据点是周度频率，每周环差为，-0.3849*7=-5.3868。
//从以上计算过程可看出，“给定终值后差值”的算法，是在“环差”算法的基础上，做的一个改动。即这个”环差值”=【（终值-最新值）/终值与最新值得日期差】*数据频率
//需求说明：
//1、增加一个预测规则，名为“给定终值后插值”，给定预测截止日期和预测终值，计算最新数据日期至预测截止日期的时间差T，计算最新数据和预测终值的数据差S，数据频率与指标频度有关，日度=1，周度=7，旬度=10，月度=30，季度=90，年度=365，环差值=S/T*频率，预测数值=前一天数值+环差值；
//2、最新数据值和日期改动后，需重新计算环差值和预测数值；
func GetChartPredictEdbInfoDataListByRuleFinalValueHc(edbInfoId int, finalValue float64, startDate, endDate time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*EdbInfoSearchData, existMap map[string]float64) (newPredictEdbInfoData []*EdbInfoSearchData, minValue, maxValue float64) {
	allDataList := make([]*EdbInfoSearchData, 0)
	allDataList = append(allDataList, realPredictEdbInfoData...)
	allDataList = append(allDataList, predictEdbInfoData...)
	newPredictEdbInfoData = predictEdbInfoData

	index := len(allDataList)
	//获取后面的预测日期
	dayList := getPredictEdbDayList(startDate, endDate, frequency)
	lenDay := len(dayList)
	if lenDay <= 0 {
		return
	}

	var hcValue float64
	lastValueDeciamal := decimal.NewFromFloat(allDataList[index-1].Value)            // 实际数据的最后一个值
	finalValueDeciamal := decimal.NewFromFloat(finalValue)                           // 给定的终止数据
	dayDecimal := decimal.NewFromInt(int64(lenDay))                                  // 需要作为分母的期数
	hcValue, _ = finalValueDeciamal.Sub(lastValueDeciamal).Div(dayDecimal).Float64() // 计算出来的环差值

	//获取后面的预测数据
	predictEdbInfoData = make([]*EdbInfoSearchData, 0)
	lastK := lenDay - 1 // 最后的日期
	for k, currentDate := range dayList {
		tmpK := index + k - 1 //上1期的值

		var val float64
		// 环差别值计算
		if k == lastK { //如果是最后一天，那么就用最终值，否则就计算
			val = finalValue
		} else {
			val = PredictHczDiv(allDataList[tmpK].Value, hcValue)
		}

		currentDateStr := currentDate.Format(utils.FormatDate)
		tmpData := &EdbInfoSearchData{
			EdbDataId: edbInfoId + 10000000000 + index + k,
			//EdbInfoId:     edbInfoId,
			DataTime: currentDateStr,
			Value:    val,
			//DataTimestamp: (currentDate.UnixNano() / 1e6) + 1000, //前端需要让加1s，说是2022-09-01 00:00:00 这样的整点不合适
		}
		newPredictEdbInfoData = append(newPredictEdbInfoData, tmpData)
		allDataList = append(allDataList, tmpData)
		existMap[currentDateStr] = val

		// 最大最小值
		if val < minValue {
			minValue = val
		}
		if val > maxValue {
			maxValue = val
		}
	}
	return
}