1

zyy

2025-10-11 59605e4209652fa883a818537c8c637964be79c5

1

 trading-order-huobi/src/main/java/com.yami.trading.huobi/data/internal/CryptosKlineServiceImpl.java

@@ -37,12 +37,12 @@
    @Autowired
    private NamedParameterJdbcOperations namedParameterJdbcTemplate;

    public static void main(String[] args) {
        BigDecimal a = BigDecimal.valueOf(0.0007);
        BigDecimal b = BigDecimal.valueOf(333);
        BigDecimal c = a.divide(b, 6, BigDecimal.ROUND_HALF_UP);
    /*public static void main(String[] args) {
        BigDecimal a = BigDecimal.valueOf(0.003);
        BigDecimal b = BigDecimal.valueOf(7200);
        BigDecimal c = a.divide(b, 10, BigDecimal.ROUND_HALF_UP);
        System.out.println(c);
    }
    }*/
    @Override
    public void initBySql(String symbol) {
        this.bulidBySql(symbol, Kline.PERIOD_1MIN);

 trading-order-huobi/src/main/java/com.yami.trading.huobi/data/job/AbstractGetDataJob.java

@@ -101,6 +101,8 @@
                            item.setAdjustmentValue(AdjustmentValueCache.getCurrentValue().get(symbol));
                            itemService.saveOrUpdate(item);
                        }*/
                        //计算延时加大精度
                        Integer delayDecimal = 10;
                        // 保存原始总值用于计算随机分配
                        BigDecimal totalValue = delayValue.getValue();
                        // 计算已分配次数(从缓存中获取)
@@ -114,31 +116,84 @@
                            totalValue = AdjustmentValueCache.getTotalValue().get(symbol);
                        }

                        // ########## 新增：判断调整方向（正向/负向）##########
                        boolean isPositiveAdjustment = totalValue.compareTo(BigDecimal.ZERO) > 0; // 正向调整（>0）
                        boolean isNegativeAdjustment = totalValue.compareTo(BigDecimal.ZERO) < 0; // 负向调整（<0）

                        BigDecimal currentValue_frequency;
                        // 计算剩余分配次数
                        int remainingAllocations = frequency - allocatedCount;

                        if (remainingAllocations > 1) {
                            // 不是最后一次分配，生成随机值
                            // 计算基础平均值
                            BigDecimal average = totalValue.divide(new BigDecimal(frequency), decimal, RoundingMode.HALF_UP);
                            // 生成0.3到1.7之间的随机因子(可根据需求调整)
                            double randomFactor = 0.3 + random.nextDouble() * 1.4;
                            currentValue_frequency = average.multiply(new BigDecimal(randomFactor))
                                    .setScale(decimal, RoundingMode.HALF_UP);
                            BigDecimal average = totalValue.divide(new BigDecimal(frequency), delayDecimal, RoundingMode.HALF_UP);
                            BigDecimal randomFactor;

                            // 确保随机值不会超过剩余值的80%，防止最后一次分配出现负值
                            BigDecimal remainingValue = totalValue.subtract(AdjustmentValueCache.getAccumulatedValue().getOrDefault(symbol, BigDecimal.ZERO));
                            BigDecimal maxAllowed = remainingValue.multiply(new BigDecimal(0.8)).setScale(decimal, RoundingMode.HALF_UP);
                            if (currentValue_frequency.compareTo(maxAllowed) > 0) {
                                currentValue_frequency = maxAllowed;
                            // 根据调整方向动态调整负因子概率
                            double negativeProbability = isNegativeAdjustment ? 0.6 : 0.3;
                            if (Math.random() <= negativeProbability) {
                                // 负因子：范围 [-0.5, 0)
                                double randomNeg = -0.5 + Math.random() * 0.5; // 简化计算：max - min = 0 - (-0.5) = 0.5
                                randomFactor = new BigDecimal(randomNeg).setScale(delayDecimal, RoundingMode.HALF_UP);
                            } else {
                                // 正因子：范围 [0.3, 1.7)
                                double randomPos = 0.3 + Math.random() * 1.4; // 简化计算：max - min = 1.7 - 0.3 = 1.4
                                randomFactor = new BigDecimal(randomPos).setScale(delayDecimal, RoundingMode.HALF_UP);
                            }

                            currentValue_frequency = average.multiply(randomFactor).setScale(delayDecimal, RoundingMode.HALF_UP);

                            // 核心修改1：根据调整方向动态约束累计值
                            BigDecimal currentAccumulated = AdjustmentValueCache.getAccumulatedValue().getOrDefault(symbol, BigDecimal.ZERO);
                            BigDecimal tempAccumulated = currentAccumulated.add(currentValue_frequency);
                            if (isPositiveAdjustment) {
                                // 正向调整：累计值不能为负
                                if (tempAccumulated.compareTo(BigDecimal.ZERO) < 0) {
                                    currentValue_frequency = BigDecimal.ONE.divide(new BigDecimal("10").pow(delayDecimal), delayDecimal, RoundingMode.HALF_UP);
                                }
                            } else if (isNegativeAdjustment) {
                                // 负向调整：累计值不能小于目标值（避免过度减值）
                                if (tempAccumulated.compareTo(totalValue) < 0) {
                                    currentValue_frequency = totalValue.subtract(currentAccumulated).divide(new BigDecimal(2), delayDecimal, RoundingMode.HALF_UP);
                                }
                            }

                            //剩余的待分配值
                            BigDecimal remainingValue = totalValue.subtract(currentAccumulated);
                            //本次分配后剩余的待分配值
                            BigDecimal tempDelayValue = remainingValue.subtract(currentValue_frequency);

                            // 提取公共变量（剩余值的80%）
                            BigDecimal remaining80Percent = remainingValue.multiply(new BigDecimal("0.8"))
                                    .setScale(delayDecimal, RoundingMode.HALF_UP);

                            // 统一判断“是否需要修正剩余值”
                            boolean needFixRemaining = (isPositiveAdjustment && tempDelayValue.compareTo(BigDecimal.ZERO) < 0)
                                    || (isNegativeAdjustment && tempDelayValue.compareTo(totalValue) > 0);
                            if (needFixRemaining) {
                                // 直接使用公共变量，避免重复计算
                                currentValue_frequency = remaining80Percent;
                            }

                            // 直接使用公共变量作为maxAllowed，无需重复计算
                            if ((isPositiveAdjustment && currentValue_frequency.compareTo(remaining80Percent) > 0)
                                    || (isNegativeAdjustment && currentValue_frequency.compareTo(remaining80Percent) < 0)) {
                                currentValue_frequency = remaining80Percent;
                            }

                        } else {
                            // 最后一次分配，使用剩余的全部值
                            // 最后一次分配兜底（支持负值）
                            BigDecimal accumulated = AdjustmentValueCache.getAccumulatedValue().getOrDefault(symbol, BigDecimal.ZERO);
                            currentValue_frequency = totalValue.subtract(accumulated).setScale(decimal, RoundingMode.HALF_UP);
                            currentValue_frequency = totalValue.subtract(accumulated).setScale(delayDecimal, RoundingMode.HALF_UP);

                            // 正向调整：最后一次分配值不能为负；负向调整：不能为正（无重复，无需优化）
                            if (isPositiveAdjustment && currentValue_frequency.compareTo(BigDecimal.ZERO) < 0) {
                                currentValue_frequency = BigDecimal.ZERO.setScale(delayDecimal, RoundingMode.HALF_UP);
                            } else if (isNegativeAdjustment && currentValue_frequency.compareTo(BigDecimal.ZERO) > 0) {
                                currentValue_frequency = BigDecimal.ZERO.setScale(delayDecimal, RoundingMode.HALF_UP);
                            }
                        }


                        // 更新累计值
                        BigDecimal newAccumulated = AdjustmentValueCache.getAccumulatedValue().getOrDefault(symbol, BigDecimal.ZERO)
                                .add(currentValue_frequency);