1

zyy

2025-10-21 bb020bc9f8c6edca7125229e10d1ea279726fc8c

1

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

New file
@@ -0,0 +1,181 @@
package com.yami.trading.huobi.data;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class RandomNumbersGenerator {

    /**
     * 生成多个有正有负的数，总和等于目标value
     * @param target 目标总和（BigDecimal）
     * @param count 生成的数字数量（至少为2）
     * @param scale 小数位数（确保精度）
     * @return 满足条件的数字列表
     */
    public static List<BigDecimal> generateNumbers(BigDecimal target, int count, int scale) {
        // 校验参数：数量至少为2
        if (count < 2) {
            throw new IllegalArgumentException("生成数量必须至少为2");
        }

        List<BigDecimal> numbers;

        // 计算target的20%（绝对值，作为最后一个数的阈值）
        BigDecimal threshold = target.abs().multiply(new BigDecimal("0.2")).setScale(scale, RoundingMode.HALF_UP);

        do {
            numbers = new ArrayList<>(count);
            Random random = new Random();

            // 步骤1：确定单个数字的最大绝对值范围（目标值的15%，可调整）
            BigDecimal maxAbsValue = target.abs().multiply(new BigDecimal("0.15"));
            if (maxAbsValue.compareTo(BigDecimal.ZERO) == 0) {
                maxAbsValue = new BigDecimal("100"); // 目标为0时的默认范围
            }

            // 正数概率60%
            double positiveProbability = 0.6;

            // 步骤2：生成前count-1个随机数
            for (int i = 0; i < count - 1; i++) {
                BigDecimal randomValue = generateRandomValue(maxAbsValue, scale, random);
                // 按概率设置正负
                if (random.nextDouble() >= positiveProbability) {
                    randomValue = randomValue.negate();
                }
                numbers.add(randomValue);
            }

            // 步骤3：计算最后一个数（确保总和为target）
            BigDecimal sumPrev = numbers.stream().reduce(BigDecimal.ZERO, BigDecimal::add);
            BigDecimal lastNum = target.subtract(sumPrev).setScale(scale, RoundingMode.HALF_UP);
            numbers.add(lastNum);

            // 步骤4：确保有正有负
            ensureBothPositiveAndNegative(numbers, scale);

            // 检查最后一个数是否超过阈值：若lastNum的绝对值 > threshold，则重新生成
        } while (numbers.get(numbers.size() - 1).abs().compareTo(threshold) > 0);

        return numbers;
    }

    /**
     * 生成0到max之间的随机BigDecimal（指定小数位数，兼容Java 8+）
     */
    private static BigDecimal generateRandomValue(BigDecimal max, int scale, Random random) {
        // 将max转换为整数（放大10^scale倍），避免double精度问题
        BigDecimal scaleFactor = new BigDecimal(Math.pow(10, scale)).setScale(scale);
        long maxLong = max.multiply(scaleFactor).setScale(0, RoundingMode.FLOOR).longValue();

        // 兼容Java 8+的写法：生成[0, maxLong]范围内的随机long
        long randomLong;
        if (maxLong == 0) {
            // 若最大值为0，直接返回0
            randomLong = 0;
        } else {
            // 生成[0, maxLong]的随机数（避免nextLong()的负数问题）
            // 逻辑：(random.nextLong() % (maxLong + 1) + (maxLong + 1)) % (maxLong + 1)
            long range = maxLong + 1; // 范围长度（0到maxLong共range个数字）
            randomLong = (random.nextLong() % range + range) % range;
        }

        // 转换回BigDecimal并缩小scaleFactor倍
        return new BigDecimal(randomLong).divide(scaleFactor, scale, RoundingMode.HALF_UP);
    }

    /**
     * 确保列表中既有正数也有负数，若不满足则调整
     */
    private static void ensureBothPositiveAndNegative(List<BigDecimal> numbers, int scale) {
        boolean hasPositive = numbers.stream().anyMatch(num -> num.compareTo(BigDecimal.ZERO) > 0);
        boolean hasNegative = numbers.stream().anyMatch(num -> num.compareTo(BigDecimal.ZERO) < 0);

        if (hasPositive && hasNegative) {
            return; // 已满足条件，无需调整
        }

        // 若全为非负（可能有0），需要调整出一个负数
        if (!hasNegative) {
            adjustToHaveNegative(numbers, scale);
        }
        // 若全为非正（可能有0），需要调整出一个正数
        else if (!hasPositive) {
            adjustToHavePositive(numbers, scale);
        }
    }

    /**
     * 当全为非负时，调整出一个负数（保持总和不变）
     */
    private static void adjustToHaveNegative(List<BigDecimal> numbers, int scale) {
        // 选第一个非零的数（避免调整0，否则还是0）
        int idx = -1;
        for (int i = 0; i < numbers.size(); i++) {
            if (numbers.get(i).compareTo(BigDecimal.ZERO) > 0) {
                idx = i;
                break;
            }
        }
        if (idx == -1) {
            // 极端情况：全为0（目标值必为0），直接将第一个数设为1，最后一个设为-1
            numbers.set(0, new BigDecimal("1").setScale(scale));
            numbers.set(numbers.size() - 1, new BigDecimal("-1").setScale(scale));
            return;
        }

        // 调整逻辑：将选中的数变为负数，同时将最后一个数加上2倍的原数（保持总和不变）
        BigDecimal original = numbers.get(idx);
        BigDecimal negative = original.negate();
        numbers.set(idx, negative);

        BigDecimal last = numbers.get(numbers.size() - 1);
        BigDecimal adjustedLast = last.add(original.multiply(new BigDecimal("2")))
                .setScale(scale, RoundingMode.HALF_UP);
        numbers.set(numbers.size() - 1, adjustedLast);
    }

    /**
     * 当全为非正时，调整出一个正数（保持总和不变）
     */
    private static void adjustToHavePositive(List<BigDecimal> numbers, int scale) {
        // 选第一个非零的数（避免调整0）
        int idx = -1;
        for (int i = 0; i < numbers.size(); i++) {
            if (numbers.get(i).compareTo(BigDecimal.ZERO) < 0) {
                idx = i;
                break;
            }
        }
        if (idx == -1) {
            // 极端情况：全为0（目标值必为0），直接将第一个数设为1，最后一个设为-1
            numbers.set(0, new BigDecimal("1").setScale(scale));
            numbers.set(numbers.size() - 1, new BigDecimal("-1").setScale(scale));
            return;
        }

        // 调整逻辑：将选中的数变为正数，同时将最后一个数减去2倍的原数（保持总和不变）
        BigDecimal original = numbers.get(idx);
        BigDecimal positive = original.negate();
        numbers.set(idx, positive);

        BigDecimal last = numbers.get(numbers.size() - 1);
        BigDecimal adjustedLast = last.subtract(original.multiply(new BigDecimal("2")))
                .setScale(scale, RoundingMode.HALF_UP);
        numbers.set(numbers.size() - 1, adjustedLast);
    }


    // 测试示例
    public static void main(String[] args) {
        // 测试1：目标值为100，生成5个数，保留2位小数
        BigDecimal target1 = new BigDecimal("0.01");
        List<BigDecimal> result1 = generateNumbers(target1, 200/10, 10);
        System.out.println("目标值：" + target1 + "，生成的数：" + result1);
        System.out.println("总和：" + result1.stream().reduce(BigDecimal.ZERO, BigDecimal::add) + "\n");

    }
}

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

@@ -6,6 +6,7 @@
import com.yami.trading.common.util.Arith;
import com.yami.trading.huobi.data.AdjustmentValueCache;
import com.yami.trading.huobi.data.DataCache;
import com.yami.trading.huobi.data.RandomNumbersGenerator;
import com.yami.trading.huobi.data.internal.DataDBService;
import com.yami.trading.huobi.data.model.AdjustmentValue;
import com.yami.trading.huobi.hobi.HobiDataService;
@@ -87,7 +88,15 @@

                        // 首次执行：生成含正负值的调整序列
                        if (adjustments == null || currentIndex == null) {
                            adjustments = generateRandomAdjustments(delayValue.getValue(), frequency, decimal);
                            //分几段执行
                            int nums = Math.max(10, frequency / 10);
                            List<BigDecimal> result = RandomNumbersGenerator.generateNumbers(delayValue.getValue(), nums, decimal + 4);
                            for (int i = 0; i < result.size(); i++) {
                                if (adjustments == null) {
                                    adjustments = new ArrayList<>();
                                }
                                adjustments.addAll(generateRandomAdjustments(result.get(i), frequency / 10, decimal));
                            }
                            currentIndex = 0;
                            AdjustmentValueCache.getPreAllocatedAdjustments().put(symbol, adjustments);
                            AdjustmentValueCache.getCurrentAdjustmentIndex().put(symbol, currentIndex);
@@ -299,7 +308,16 @@

    public static void main(String[] args) {
        AbstractGetDataJob abstractGetDataJob = new CryptosGetDataJob();
        List<BigDecimal> list = abstractGetDataJob.generateRandomAdjustments(new BigDecimal(0.002), 300, 8);
        List<BigDecimal> list = new ArrayList<>();
        int frequency = 200;
        int decimal = 6;
        //分几段执行
        int nums = Math.max(10, frequency / 10);
        List<BigDecimal> result = RandomNumbersGenerator.generateNumbers(BigDecimal.valueOf(0.02), nums, decimal + 4);
        for (int i = 0; i < result.size(); i++) {
            list.addAll(abstractGetDataJob.generateRandomAdjustments(result.get(i), frequency / 10, decimal));
        }

        BigDecimal sum = BigDecimal.ZERO;
        int num = 0;
        int dmt = 1;