本文介绍在资产价格更新后，如何科学地重新计算权重向量，使加权期望值（即价格与权重的点积）严格保持不变；重点解析约束优化思想、提供可落地的数值求解方案，并附带健壮的 java 实现示例。

本文介绍在资产价格更新后，如何科学地重新计算权重向量，使加权期望值（即价格与权重的点积）严格保持不变；重点解析约束优化思想、提供可落地的数值求解方案，并附带健壮的 java 实现示例。

在量化投资、组合再平衡或风险归因等场景中，常需在部分资产价格发生变动后，动态调整其对应权重，同时严格维持原组合的期望价格（Expected Value, EV）不变。这并非简单的比例缩放问题——因为价格变化是非均匀的，直接对旧权重做全局缩放（如原代码中的 scaleFactor 方法）仅能保证总和为1，却无法满足新的加权平均约束。

核心数学约束如下：
给定原始价格向量 $ \mathbf{p}_0 = [p_0^{(1)}, \dots, p_0^{(n)}] $ 和原始权重 $ \mathbf{w}_0 = [w_0^{(1)}, \dots, w0^{(n)}] $，其期望值为
$$ \mu = \sum{i=1}^n w_0^{(i)} \cdot p_0^{(i)} $$
当价格更新为新向量 $ \mathbf{p}_1 = [p_1^{(1)}, \dots, p_1^{(n)}] $ 后，需求解新权重 $ \mathbf{w}_1 = [w_1^{(1)}, \dots, w_1^{(n)}] $，满足：

• 线性等式约束：$ \sum_i w_1^{(i)} \cdot p_1^{(i)} = \mu $
• 单纯形约束：$ w_1^{(i)} \geq 0 $，且 $ \sum_i w_1^{(i)} = 1 $

该问题在 $ n \geq 3 $ 时存在无穷多解（自由度 ≥ 1），因此必须引入偏好先验来唯一确定解。常见且实用的策略是：令权重随价格呈特定形状分布（如高斯型、指数衰减、线性单调等），再通过数值搜索拟合目标期望值。

✅ 推荐方案：基于高斯核的参数化权重生成

我们采用权重与价格距离的高斯函数成正比的设计： $$ w_i \propto \exp\left(-\frac{(p_i - k)^2}{2\sigma^2}\right) $$ 其中 $k$ 是可控中心参数（决定权重峰值位置），$\sigma$ 可固定为价格标准差或设为常数（如1.0）。归一化后，权重向量完全由 $k$ 决定。目标是搜索最优 $k^*$，使得： $$ \sum_i w_i(k) \cdot p_i = \mu $$

以下为生产就绪的 Java 实现（含二分搜索 + 自动区间初始化）：

public class WeightRedistributor {
    private static final double EPS = 1e-6;
    private static final int MAX_ITER = 100;

    // 计算给定 k 下的权重向量（归一化）
    public static double[] weightsForK(double[] prices, double k, double sigma) {
        int n = prices.length;
        double[] unnormalized = new double[n];
        double sum = 0.0;
        for (int i = 0; i < n; i++) {
            double expArg = -Math.pow(prices[i] - k, 2) / (2 * sigma * sigma);
            unnormalized[i] = Math.exp(expArg);
            sum += unnormalized[i];
        }
        double[] weights = new double[n];
        for (int i = 0; i < n; i++) {
            weights[i] = unnormalized[i] / sum;
        }
        return weights;
    }

    // 计算当前权重下的期望价格
    public static double expectedPrice(double[] prices, double[] weights) {
        double ep = 0.0;
        for (int i = 0; i < prices.length; i++) {
            ep += prices[i] * weights[i];
        }
        return ep;
    }

    // 二分搜索最优 k，使期望价格等于 targetMu
    public static double[] redistributeToMatchEV(double[] prices, double targetMu, double sigma) {
        // Step 1: 自动确定搜索区间 [kLow, kHigh]
        double minP = Arrays.stream(prices).min().orElse(0.0);
        double maxP = Arrays.stream(prices).max().orElse(0.0);
        double kLow = minP - 10.0, kHigh = maxP + 10.0;

        // 粗略定位：确保 f(kLow) < targetMu < f(kHigh)
        double fLow = expectedPrice(prices, weightsForK(prices, kLow, sigma));
        double fHigh = expectedPrice(prices, weightsForK(prices, kHigh, sigma));

        if (fLow > targetMu) {
            // 向左扩展
            while (fLow > targetMu && kLow > minP - 100) {
                kLow -= 10.0;
                fLow = expectedPrice(prices, weightsForK(prices, kLow, sigma));
            }
        }
        if (fHigh < targetMu) {
            // 向右扩展
            while (fHigh < targetMu && kHigh < maxP + 100) {
                kHigh += 10.0;
                fHigh = expectedPrice(prices, weightsForK(prices, kHigh, sigma));
            }
        }

        // Step 2: 二分搜索
        double kLeft = kLow, kRight = kHigh;
        for (int iter = 0; iter < MAX_ITER; iter++) {
            double kMid = (kLeft + kRight) / 2.0;
            double fMid = expectedPrice(prices, weightsForK(prices, kMid, sigma));
            if (Math.abs(fMid - targetMu) < EPS) {
                return weightsForK(prices, kMid, sigma);
            }
            if (fMid < targetMu) {
                kLeft = kMid;
            } else {
                kRight = kMid;
            }
        }
        // 返回更优端的解
        double fLeft = expectedPrice(prices, weightsForK(prices, kLeft, sigma));
        double fRight = expectedPrice(prices, weightsForK(prices, kRight, sigma));
        return Math.abs(fLeft - targetMu) < Math.abs(fRight - targetMu)
                ? weightsForK(prices, kLeft, sigma)
                : weightsForK(prices, kRight, sigma);
    }

    // 使用示例
    public static void main(String[] args) {
        double[] originalPrices = {5.0, 8.0, 18.0, 58.0, 80.0, 49.3991671624033};
        double[] originalWeights = {0.34146341463414637, 0.3902439024390244,
                0.14634146341463414, 0.024390243902439025,
                0.024390243902439025, 0.07317073170731707};

        // 计算原始期望值 μ
        double mu = expectedPrice(originalPrices, originalWeights);
        System.out.printf("Original EV: %.6f%n", mu); // ≈ 24.31...

        // 新价格（第1个变回5.0，第5个升至82.0）
        double[] newPrices = {5.0, 8.0, 20.0, 58.0, 82.0, 49.3991671624033};

        // 生成新权重（σ=10.0，平衡局部性与鲁棒性）
        double[] newWeights = redistributeToMatchEV(newPrices, mu, 10.0);

        System.out.println("New weights:");
        for (int i = 0; i < newWeights.length; i++) {
            System.out.printf("  w[%d] = %.6f%n", i, newWeights[i]);
        }
        System.out.printf("New EV: %.6f%n", expectedPrice(newPrices, newWeights));
    }
}

⚠️ 关键注意事项

• 不可行性检查：若目标期望值 $\mu$ 超出新价格区间 $[\min(\mathbf{p}_1), \max(\mathbf{p}_1)]$，则无解（因加权平均必介于极值之间）。实际应用中应前置校验。
• 参数敏感性：$\sigma$ 控制权重集中度——$\sigma$ 越小，权重越聚焦于接近 $k$ 的价格；过大则趋近均匀分布。建议初始设为价格范围的 1/5～1/3。
• 替代核函数：除高斯核外，亦可选用：
  • 线性衰减：$w_i \propto \max(0,\, a - |p_i - k|)$（适合强调邻近价格）
  • 指数衰减：$w_i \propto \exp(-\lambda |p_i - k|)$（长尾更平缓）
  • 分段常数：按价格分桶，每桶内权重相等（便于业务解释）
• 性能优化：对高频调用场景，可预计算价格排序索引，或改用牛顿法加速收敛（需解析导数）。

综上，保持期望值恒定的本质是在约束流形上选择最符合业务直觉的解。参数化建模+数值搜索的方法兼具数学严谨性与工程灵活性，远优于启发式缩放，是金融建模与算法交易中的推荐实践。