chart 13.4

services/data/predict_edb_info.go

@@ -248,6 +248,11 @@ func GetChartPredictEdbInfoDataListByConfList(predictEdbConfList []*data_manage.
 
 		var tmpMinValue, tmpMaxValue float64 // 当前预测结果中的最大/最小值
 
+		dayList := getPredictEdbDayList(startDate, dataEndTime, frequency)
+		if len(dayList) <= 0 { // 如果未来没有日期的话，那么就退出当前循环，进入下一个循环
+			continue
+		}
+
 		switch predictEdbConf.RuleType {
 		case 1: //1：最新
 			var lastDataValue float64 //最新值
@@ -369,6 +374,44 @@ func GetChartPredictEdbInfoDataListByConfList(predictEdbConfList []*data_manage.
 			if err != nil {
 				return
 			}
+		case 13: //13：根据 同比增速差值 规则获取预测数据
+			tmpValDecimal, tmpErr := decimal.NewFromString(predictEdbConf.Value)
+			if tmpErr != nil {
+				err = tmpErr
+				return
+			}
+			tbEndValue, _ := tmpValDecimal.Float64()
+			predictEdbInfoData, tmpMinValue, tmpMaxValue = GetChartPredictEdbInfoDataListByRuleTbzscz(predictEdbConf.PredictEdbInfoId, tbEndValue, dayList, frequency, realPredictEdbInfoData, predictEdbInfoData, existMap)
+		case 14: //14：根据 一元线性拟合 规则获取预测数据
+			var ruleConf RuleLineNhConf
+			err = json.Unmarshal([]byte(predictEdbConf.Value), &ruleConf)
+			if err != nil {
+				err = errors.New("一元线性拟合配置信息异常:" + err.Error())
+				return
+			}
+
+			// 规则计算的拟合残差值map
+			newNhccDataMap := make(map[string]float64)
+			if predictEdbConf.PredictEdbInfoId > 0 { //已经生成的动态数据
+				tmpPredictEdbRuleDataList, tmpErr := data_manage.GetPredictEdbRuleDataList(predictEdbConf.PredictEdbInfoId, predictEdbConf.ConfigId, "", "")
+				if tmpErr != nil {
+					err = tmpErr
+					return
+				}
+				for _, v := range tmpPredictEdbRuleDataList {
+					newNhccDataMap[v.DataTime] = v.Value
+				}
+			} else { //未生成的动态数据，需要使用外部传入的数据进行计算
+				newNhccDataMap, err = getCalculateNhccData(append(realPredictEdbInfoData, predictEdbInfoData...), ruleConf)
+				if err != nil {
+					return
+				}
+			}
+
+			predictEdbInfoData, tmpMinValue, tmpMaxValue, err = GetChartPredictEdbInfoDataListByRuleLineNh(predictEdbConf.PredictEdbInfoId, dayList, realPredictEdbInfoData, predictEdbInfoData, newNhccDataMap, existMap)
+			if err != nil {
+				return
+			}
 		}
 		//startDate = dataEndTime.AddDate(0, 0, 1)
 		if startDate.Before(dataEndTime) {

services/data/predict_edb_info_rule.go

@@ -8,6 +8,7 @@ import (
 	"hongze/hongze_chart_lib/models"
 	"hongze/hongze_chart_lib/models/data_manage"
 	"hongze/hongze_chart_lib/utils"
+	"math"
 	"strings"
 	"time"
 )
@@ -1073,3 +1074,423 @@ func GetChartPredictEdbInfoDataListByRuleMoveAverageTb(edbInfoId int, nValue, ye
 	}
 	return
 }
+
+// GetChartPredictEdbInfoDataListByRuleTbzscz 根据 同比增速差值 规则获取预测数据
+// 同比增速差值计算方式:
+// 1、首先计算出所选指标实际最新日期值的同比增速：（本期数值-同期数值）÷同期数值*100%
+// 2、根据预测截止日期的同比增速终值、最新日期值的同比增速、与最新日期距离截止日期的期数，计算出到截止日期为止的每一期的同比增速。（等差规则计算每一期的同比增速，结合去年同期值，计算出每一期的同比预测值）。公差=（末项-首项）÷（n-1），an=a1+(n-1)d，（n为正整数，n大于等于2）
+// 3、根据去年同期值和未来每一期的同比增速值，求出同比预测值，同比预测值=同期值*(1+同比增速)
+// 同比增速差值：计算最新数据的同比增速（（本期数值-同期数值）÷同期数值*100%），结合同比增速终值与期数，计算每一期同比增速，进而求出同比预测值。
+//
+// 例：如上图所示指标，（1）最新日期值2022-12-31   141175 ，结合同期值，计算同比增速；
+// （2）同比增速终值，若为50%，    预测日期为2023-03-31，则根据（1）中的同比增速值与同比增速终值，计算出中间两期的同比增速；
+// （3）求出每一期的预测同比值，预测同比值=同期值*（1+同比增速）
+func GetChartPredictEdbInfoDataListByRuleTbzscz(edbInfoId int, tbEndValue float64, dayList []time.Time, frequency string, realPredictEdbInfoData, predictEdbInfoData []*models.EdbDataList, existMap map[string]float64) (newPredictEdbInfoData []*models.EdbDataList, minValue, maxValue float64) {
+	allDataList := make([]*models.EdbDataList, 0)
+	allDataList = append(allDataList, realPredictEdbInfoData...)
+	allDataList = append(allDataList, predictEdbInfoData...)
+	newPredictEdbInfoData = predictEdbInfoData
+
+	index := len(allDataList)
+
+	// 获取近期数据的同比值
+	if index <= 0 {
+		return
+	}
+	lastData := allDataList[index-1]
+	lastDayTime, _ := time.ParseInLocation(utils.FormatDate, lastData.DataTime, time.Local)
+
+	var lastTb decimal.Decimal // 计算最新数据与上一期的数据同比值
+	{
+		//上一年的日期
+		preDate := lastDayTime.AddDate(-1, 0, 0)
+		preDateStr := preDate.Format(utils.FormatDate)
+		if preValue, ok := existMap[preDateStr]; ok { //上一年同期找到
+			lastTb = decimal.NewFromFloat(lastData.Value).Div(decimal.NewFromFloat(preValue))
+		} 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 { //上一年同期->下一个月找到
+						lastTb = decimal.NewFromFloat(lastData.Value).Div(decimal.NewFromFloat(preValue))
+						break
+					} else {
+						preDateDayStr := preDateDay.Format(utils.FormatDate)
+						if preValue, ok := existMap[preDateDayStr]; ok { //上一年同期->上一个月找到
+							lastTb = decimal.NewFromFloat(lastData.Value).Div(decimal.NewFromFloat(preValue))
+							break
+						}
+					}
+					nextDateDay = nextDateDay.AddDate(0, 0, 1)
+					preDateDay = preDateDay.AddDate(0, 0, -1)
+				}
+
+			case "季度", "年度":
+				if preValue, ok := existMap[preDateStr]; ok { //上一年同期->下一个月找到
+					lastTb = decimal.NewFromFloat(lastData.Value).Div(decimal.NewFromFloat(preValue))
+					break
+				}
+			default:
+				nextDateDay := preDate
+				preDateDay := preDate
+
+				for i := 0; i < 35; i++ {
+					nextDateDayStr := nextDateDay.Format(utils.FormatDate)
+					if preValue, ok := existMap[nextDateDayStr]; ok { //上一年同期->下一个月找到
+						lastTb = decimal.NewFromFloat(lastData.Value).Div(decimal.NewFromFloat(preValue))
+						break
+					} else {
+						preDateDayStr := preDateDay.Format(utils.FormatDate)
+						if preValue, ok := existMap[preDateDayStr]; ok { //上一年同期->上一个月找到
+							lastTb = decimal.NewFromFloat(lastData.Value).Div(decimal.NewFromFloat(preValue))
+							break
+						} else {
+							//fmt.Println("pre not find:", preDateStr, "i:", i)
+						}
+					}
+					nextDateDay = nextDateDay.AddDate(0, 0, 1)
+					preDateDay = preDateDay.AddDate(0, 0, -1)
+				}
+			}
+		}
+	}
+
+	//获取后面的预测数据
+	lenDay := len(dayList)
+	tbEndValueDecimal := decimal.NewFromFloat(tbEndValue)
+	avgTbVal := tbEndValueDecimal.Sub(lastTb).Div(decimal.NewFromInt(int64(lenDay)))
+
+	fmt.Println(lastTb.Float64())
+	fmt.Println(decimal.NewFromFloat(tbEndValue).Sub(lastTb))
+	fmt.Println(avgTbVal.Float64())
+
+	predictEdbInfoData = make([]*models.EdbDataList, 0)
+	for k, currentDate := range dayList {
+		var tbValue decimal.Decimal
+		if k == lenDay-1 { // 如果是最后的日期了，那么就用终值去计算
+			tbValue = tbEndValueDecimal
+		} else { // 最近数据的同比值 + （平均增值乘以当前期数）
+			tbValue = lastTb.Add(avgTbVal.Mul(decimal.NewFromInt(int64(k + 1))))
+		}
+		tmpData := &models.EdbDataList{
+			EdbDataId: edbInfoId + 100000 + index + k,
+			EdbInfoId: edbInfoId,
+			DataTime:  currentDate.Format(utils.FormatDate),
+			//Value:         dataValue,
+			DataTimestamp: (currentDate.UnixNano() / 1e6) + 1000, //前端需要让加1s，说是2022-09-01 00:00:00 这样的整点不合适
+		}
+
+		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, _ = decimal.NewFromFloat(preValue).Mul(tbValue).RoundCeil(4).Float64()
+			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, _ = decimal.NewFromFloat(preValue).Mul(tbValue).RoundCeil(4).Float64()
+						calculateStatus = true
+						break
+					} else {
+						preDateDayStr := preDateDay.Format(utils.FormatDate)
+						if preValue, ok := existMap[preDateDayStr]; ok { //上一年同期->上一个月找到
+							val, _ = decimal.NewFromFloat(preValue).Mul(tbValue).RoundCeil(4).Float64()
+							calculateStatus = true
+							break
+						}
+					}
+					nextDateDay = nextDateDay.AddDate(0, 0, 1)
+					preDateDay = preDateDay.AddDate(0, 0, -1)
+				}
+
+			case "季度", "年度":
+				if preValue, ok := existMap[preDateStr]; ok { //上一年同期->下一个月找到
+					val, _ = decimal.NewFromFloat(preValue).Mul(tbValue).RoundCeil(4).Float64()
+					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, _ = decimal.NewFromFloat(preValue).Mul(tbValue).RoundCeil(4).Float64()
+						calculateStatus = true
+						break
+					} else {
+						preDateDayStr := preDateDay.Format(utils.FormatDate)
+						if preValue, ok := existMap[preDateDayStr]; ok { //上一年同期->上一个月找到
+							val, _ = decimal.NewFromFloat(preValue).Mul(tbValue).RoundCeil(4).Float64()
+							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
+}
+
+// RuleLineNhConf 一元线性拟合规则的配置
+type RuleLineNhConf struct {
+	StartDate string `description:"开始日期"`
+	EndDate   string `description:"结束日期"`
+	MoveDay   int    `description:"移动天数"`
+	EdbInfoId int    `description:"指标id"`
+}
+
+//	GetChartPredictEdbInfoDataListByRuleLineNh 根据 一元线性拟合 的计算规则获取预测数据
+//
+// 选择被预测的指标B（作为自变量，非预测指标），选择指标A（作为因变量，可以是基础指标和预测指标）
+// 2、选择拟合时间段，起始日期至今或指定时间段，选择至今，在计算时截止到指标B的最新日期
+// 3、设定A领先B时间（天），正整数、负整数、0
+// 4、调用拟合残差的数据预处理和算法，给出拟合方程Y=aX+b的系数a，b
+// 5、指标A代入拟合方程得到拟合预测指标B'，拟合预测指标使用指标B的频度，在指标B的实际值后面连接拟合预测指标B'对应日期的预测值
+//
+// 注：选择预测截止日期，若所选日期  ≤  指标A设置领先后的日期序列，则预测指标日期最新日期有值（在指标B'的有值范围内）；若所选日期 ＞ 指标A设置领先后的日期序列，则预测指标只到指标A领先后的日期序列（超出指标B'的有值范围，最多到指标B'的最新值）；指标A、B更新后，更新预测指标
+func GetChartPredictEdbInfoDataListByRuleLineNh(edbInfoId int, dayList []time.Time, realPredictEdbInfoData, predictEdbInfoData []*models.EdbDataList, newNhccDataMap, existMap map[string]float64) (newPredictEdbInfoData []*models.EdbDataList, minValue, maxValue float64, err error) {
+	allDataList := make([]*models.EdbDataList, 0)
+	allDataList = append(allDataList, realPredictEdbInfoData...)
+	allDataList = append(allDataList, predictEdbInfoData...)
+	newPredictEdbInfoData = predictEdbInfoData
+
+	lenAllData := len(allDataList)
+	if lenAllData <= 0 {
+		return
+	}
+
+	for k, currentDate := range dayList {
+		// 动态拟合残差值数据
+		currentDateStr := currentDate.Format(utils.FormatDate)
+		val, ok := newNhccDataMap[currentDateStr]
+		if !ok {
+			continue
+		}
+		tmpData := &models.EdbDataList{
+			EdbDataId:     edbInfoId + 100000 + 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
+}
+
+// getCalculateNhccData 获取计算出来的 拟合残差 数据
+func getCalculateNhccData(secondDataList []*models.EdbDataList, ruleConf RuleLineNhConf) (newBDataMap map[string]float64, err error) {
+	firstEdbInfoId := ruleConf.EdbInfoId
+	moveDay := ruleConf.MoveDay
+	startDate, _ := time.ParseInLocation(utils.FormatDate, ruleConf.StartDate, time.Local)
+	endDate, _ := time.ParseInLocation(utils.FormatDate, ruleConf.EndDate, time.Local)
+
+	//查询当前指标现有的数据
+	edbInfo, err := data_manage.GetEdbInfoById(firstEdbInfoId)
+	if err != nil {
+		return
+	}
+
+	//第一个指标
+	aDataList := make([]models.EdbDataList, 0)
+	aDataMap := make(map[string]float64)
+	{
+		//第一个指标的数据列表
+		var firstDataList []*models.EdbDataList
+		switch edbInfo.EdbInfoType {
+		case 0:
+			firstDataList, err = models.GetEdbDataList(edbInfo.Source, edbInfo.EdbInfoId, ``, ``)
+		case 1:
+			_, firstDataList, _, _, err, _ = GetPredictDataListByPredictEdbInfoId(edbInfo.EdbInfoId, ``, ``, false)
+		default:
+			err = errors.New(fmt.Sprint("获取失败,指标类型异常", edbInfo.EdbInfoType))
+		}
+		if err != nil {
+			return
+		}
+		aDataList, aDataMap = handleNhccData(firstDataList, moveDay)
+	}
+
+	//第二个指标
+	bDataList := make([]models.EdbDataList, 0)
+	bDataMap := make(map[string]float64)
+	{
+		bDataList, bDataMap = handleNhccData(secondDataList, 0)
+	}
+
+	if len(aDataList) <= 0 {
+		err = errors.New("指标A没有数据")
+		return
+	}
+	if len(bDataList) <= 0 {
+		err = errors.New("指标B没有数据")
+		return
+	}
+	// 拟合残差计算的结束日期判断
+	{
+		endAData := aDataList[len(aDataList)-1]
+		tmpEndDate, tmpErr := time.ParseInLocation(utils.FormatDate, endAData.DataTime, time.Local)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+		// 如果A指标的最新数据日期早于拟合残差的结束日期，那么就用A指标的最新数据日期
+		if tmpEndDate.Before(endDate) {
+			endDate = tmpEndDate
+		}
+		endBData := bDataList[len(bDataList)-1]
+		tmpEndDate, tmpErr = time.ParseInLocation(utils.FormatDate, endBData.DataTime, time.Local)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+		// 如果B指标的最新数据日期早于拟合残差的结束日期，那么就用A指标的最新数据日期
+		if tmpEndDate.Before(endDate) {
+			endDate = tmpEndDate
+		}
+	}
+
+	// 计算线性方程公式
+	var a, b float64
+	{
+		coordinateData := make([]utils.Coordinate, 0)
+		for i := startDate; i.Before(endDate) || i.Equal(endDate); i = i.AddDate(0, 0, 1) {
+			dateStr := i.Format(utils.FormatDate)
+			xValue, ok := aDataMap[dateStr]
+			if !ok {
+				err = errors.New("指标A日期：" + dateStr + "数据异常，导致计算线性方程公式失败")
+				return
+			}
+			yValue, ok := bDataMap[dateStr]
+			if !ok {
+				err = errors.New("指标B日期：" + dateStr + "数据异常，导致计算线性方程公式失败")
+				return
+			}
+			tmpCoordinate := utils.Coordinate{
+				X: xValue,
+				Y: yValue,
+			}
+			coordinateData = append(coordinateData, tmpCoordinate)
+		}
+		a, b = utils.GetLinearResult(coordinateData)
+	}
+
+	if math.IsNaN(a) || math.IsNaN(b) {
+		err = errors.New("线性方程公式生成失败")
+		return
+	}
+	//fmt.Println("a:", a, ";======b:", b)
+
+	//计算B’
+	newBDataMap = make(map[string]float64)
+	{
+		//B’=aA+b
+		aDecimal := decimal.NewFromFloat(a)
+		bDecimal := decimal.NewFromFloat(b)
+		for _, aData := range aDataList {
+			xDecimal := decimal.NewFromFloat(aData.Value)
+			val, _ := aDecimal.Mul(xDecimal).Add(bDecimal).RoundCeil(4).Float64()
+			newBDataMap[aData.DataTime] = val
+		}
+
+	}
+	return
+}
+
+// handleNhccData 处理拟合残差需要的数据
+func handleNhccData(dataList []*models.EdbDataList, moveDay int) (newDataList []models.EdbDataList, dateDataMap map[string]float64) {
+	dateMap := make(map[time.Time]float64)
+	var minDate, maxDate time.Time
+	dateDataMap = make(map[string]float64)
+
+	for _, v := range dataList {
+		currDate, _ := time.ParseInLocation(utils.FormatDate, v.DataTime, time.Local)
+		if minDate.IsZero() || currDate.Before(minDate) {
+			minDate = currDate
+		}
+		if maxDate.IsZero() || currDate.After(maxDate) {
+			maxDate = currDate
+		}
+		dateMap[currDate] = v.Value
+	}
+
+	// 处理领先、滞后数据
+	newDateMap := make(map[time.Time]float64)
+	for currDate, value := range dateMap {
+		newDate := currDate.AddDate(0, 0, moveDay)
+		newDateMap[newDate] = value
+	}
+	minDate = minDate.AddDate(0, 0, moveDay)
+	maxDate = maxDate.AddDate(0, 0, moveDay)
+
+	// 开始平移天数
+	dayNum := utils.GetTimeSubDay(minDate, maxDate)
+
+	for i := 0; i <= dayNum; i++ {
+		currDate := minDate.AddDate(0, 0, i)
+		tmpValue, ok := newDateMap[currDate]
+		if !ok {
+			// 万一没有数据,那么就过滤当次循环
+			if len(newDataList) <= 0 {
+				continue
+			}
+			//找不到数据，那么就用前面的数据吧
+			tmpValue = newDataList[len(newDataList)-1].Value
+		}
+		tmpData := models.EdbDataList{
+			//EdbDataId: 0,
+			DataTime: currDate.Format(utils.FormatDate),
+			Value:    tmpValue,
+		}
+		dateDataMap[tmpData.DataTime] = tmpData.Value
+		newDataList = append(newDataList, tmpData)
+	}
+
+	return
+}