跳转至

求解器

求解器是一种高性能算法模块，专门用于在极低延迟环境下进行快速最优决策、资源分配或路径规划。这类组件通常集成在策略引擎、风险控制系统或资源分配系统中，能够在微秒级别内计算出最优解决方案。

1. 订单分配求解器 (Order Allocation Solver)

该求解器处理单笔目标仓位如何在多个交易渠道、合约品种或账户间进行最优分配的问题。

核心输入参数：

  • 目标买卖数量
  • 各交易渠道的市场深度数据
  • 滑点成本模型
  • 交易手续费结构
  • 延迟和成交率数据

输出结果：

  • 精确分配比例（如 "Binance 30%，OKX 50%，Bybit 20%"）

常用算法实现：

  • 贪心最优价格分配
  • 线性规划（LP）
  • 二次规划（QP）
  • 基于深度预测的最优执行

应用场景：

  • 多平台套利策略（三角套利、期现套利、永续合约套利）
  • TWAP/VWAP执行优化
  • 多头空头组合再平衡
#include
#include
#include
#include

class OrderAllocationSolver {
 private:
  static constexpr int MAX_EXCHANGES = 8;
  static constexpr double EPSILON = 1e-9;

 public:
  struct ExchangeData {
    double best_bid;
    double best_ask;
    double bid_volume;
    double ask_volume;
    double fee_rate;
    double latency_us;
    double fill_ratio;
  };

  struct AllocationResult {
    std::array weights;
    double total_cost;
    int num_active_exchanges;
  };

  AllocationResult solve(const std::vector& exchanges, double target_quantity,
                         bool is_buy) {
    AllocationResult result = {};

    // 预计算有效交易所
    std::array valid_indices;
    int valid_count = 0;

    for (int i = 0; i < exchanges.size() && i < MAX_EXCHANGES; ++i) {
      if (exchanges[i].fill_ratio > EPSILON) {
        valid_indices[valid_count++] = i;
      }
    }

    if (valid_count == 0) {
      return result;
    }

    // 按最优价格排序（买入按ask升序，卖出按bid降序）
    std::array sorted_indices;
    for (int i = 0; i < valid_count; ++i) {
      sorted_indices[i] = valid_indices[i];
    }

    std::sort(sorted_indices, sorted_indices + valid_count, [&](int a, int b) {
      if (is_buy) {
        return exchanges[a].best_ask < exchanges[b].best_ask;
      } else {
        return exchanges[a].best_bid > exchanges[b].best_bid;
      }
    });

    // 贪心分配算法
    double remaining_quantity = target_quantity;
    double total_cost = 0.0;
    int active_exchanges = 0;

    for (int i = 0; i < valid_count && remaining_quantity > EPSILON; ++i) {
      int idx = sorted_indices[i];
      const auto& exch = exchanges[idx];

      double available_volume = is_buy ? exch.ask_volume : exch.bid_volume;
      double price = is_buy ? exch.best_ask : exch.best_bid;

      double allocation = std::min(remaining_quantity, available_volume);
      double weight = allocation / target_quantity;

      result.weights[idx] = weight;
      total_cost += allocation * price * (1.0 + exch.fee_rate);
      remaining_quantity -= allocation;
      active_exchanges++;
    }

    result.total_cost = total_cost;
    result.num_active_exchanges = active_exchanges;
    return result;
  }
};

2. 最优执行求解器 (Optimal Execution Solver)

该求解器专注于订单的时间维度分配策略，确定分时下单节奏和等待时机。

核心功能：

  • 市场冲击成本建模
  • 随机抖动风险控制
  • 盘口结构预测
  • 信息泄露风险评估

主要算法：

  • Almgren-Chriss模型
  • 动态规划方法
  • 强化学习执行器（少数团队）

应用领域：

  • 高频做市策略的对冲操作
  • 大额订单执行（如再平衡/清仓）
  • 仓位建仓/平仓的执行时序控制
#include
#include
#include

class OptimalExecutionSolver {
 private:
  static constexpr int MAX_SLICES = 100;
  static constexpr double EPSILON = 1e-9;

 public:
  struct MarketState {
    double current_price;
    double volatility;
    double bid_ask_spread;
    double volume_profile;
    double market_impact_factor;
  };

  struct ExecutionSlice {
    double time_to_execute;
    double quantity;
    double expected_cost;
  };

  struct ExecutionPlan {
    std::array slices;
    int slice_count;
    double total_cost;
  };

  ExecutionPlan solve(const MarketState& market_state, double total_quantity,
                      double execution_time, double risk_aversion) {
    ExecutionPlan plan = {};

    // Almgren-Chriss模型实现
    double gamma = market_state.market_impact_factor;
    double sigma = market_state.volatility;
    double spread = market_state.bid_ask_spread;

    // 计算最优时间分割
    int slices = std::min(static_cast(execution_time * 1000), MAX_SLICES);
    slices = std::max(slices, 1);

    double dt = execution_time / slices;
    double sqrt_dt = std::sqrt(dt);

    // 使用动态规划计算最优执行策略
    double remaining_quantity = total_quantity;
    double total_cost = 0.0;

    for (int i = 0; i < slices; ++i) {
      // 计算当前slice的最优执行量
      double time_remaining = execution_time - i * dt;
      double optimal_rate = remaining_quantity / time_remaining;

      // 考虑风险厌恶的调整
      double adjustment = risk_aversion * sigma * sqrt_dt;
      double execution_rate = optimal_rate - adjustment;

      execution_rate =
          std::max(execution_rate, remaining_quantity / (slices - i));
      execution_rate = std::min(execution_rate, remaining_quantity);

      double slice_quantity = execution_rate * dt;

      // 计算执行成本（包含市场冲击）
      double market_impact = gamma * std::abs(slice_quantity) / time_remaining;
      double execution_cost = slice_quantity * market_state.current_price *
                              (1.0 + market_impact + spread / 2.0);

      plan.slices[i].time_to_execute = (i + 1) * dt;
      plan.slices[i].quantity = slice_quantity;
      plan.slices[i].expected_cost = execution_cost;

      remaining_quantity -= slice_quantity;
      total_cost += execution_cost;

      if (remaining_quantity < EPSILON) {
        plan.slice_count = i + 1;
        break;
      }
    }

    plan.total_cost = total_cost;
    if (plan.slice_count == 0) {
      plan.slice_count = slices;
    }

    return plan;
  }
};

3. 风控约束求解器 (Risk Constraint Solver)

该求解器在多重限制条件下寻找最佳可行解，处理各种风险约束。

约束类型：

  • 最大头寸限制
  • 交易所风控约束（如仓位增速）
  • Delta/Gamma/资金使用限制
  • 多策略资金共享分配

主要方法：

  • 二次规划（QP）
  • 内点法/障碍法
  • 贪心+启发式算法（为降低延迟）

应用场景：

  • 多策略投资组合管理
  • 高频做市团队资金动态分配
  • 期现对冲套利的实时资金约束
#include
#include
#include
#include

class RiskConstraintSolver {
 private:
  static constexpr int MAX_STRATEGIES = 16;
  static constexpr double EPSILON = 1e-9;

 public:
  struct StrategyConstraints {
    double min_allocation;
    double max_allocation;
    double risk_limit;
    double correlation_with_others;
    double expected_return;
  };

  struct PortfolioResult {
    std::array allocations;
    double total_risk;
    double expected_return;
    int active_strategies;
  };

  PortfolioResult solve(const std::vector& strategies, double total_capital,
                        double max_portfolio_risk) {
    PortfolioResult result = {};

    // 初始化分配
    std::array temp_allocations = {};
    int strategy_count =
        std::min(static_cast(strategies.size()), MAX_STRATEGIES);

    // 首先满足最小分配要求
    double remaining_capital = total_capital;
    for (int i = 0; i < strategy_count; ++i) {
      temp_allocations[i] = strategies[i].min_allocation;
      remaining_capital -= strategies[i].min_allocation;
    }

    if (remaining_capital < 0) {
      // 如果最小分配超出总资本，按比例缩减
      double scale_factor = total_capital / (total_capital - remaining_capital);
      for (int i = 0; i < strategy_count; ++i) {
        temp_allocations[i] *= scale_factor;
      }
      remaining_capital = 0;
    }

    // 按预期收益排序，优先分配给高收益策略
    std::array sorted_indices;
    for (int i = 0; i < strategy_count; ++i) {
      sorted_indices[i] = i;
    }

    std::sort(
        sorted_indices, sorted_indices + strategy_count, [&](int a, int b) {
          return strategies[a].expected_return > strategies[b].expected_return;
        });

    // 分配剩余资本
    for (int i = 0; i < strategy_count && remaining_capital > EPSILON; ++i) {
      int idx = sorted_indices[i];
      double additional_allocation =
          std::min(remaining_capital,
                   strategies[idx].max_allocation - temp_allocations[idx]);

      temp_allocations[idx] += additional_allocation;
      remaining_capital -= additional_allocation;
    }

    // 风险约束检查和调整
    double portfolio_risk =
        calculate_portfolio_risk(strategies, temp_allocations, strategy_count);

    if (portfolio_risk > max_portfolio_risk) {
      // 按风险贡献比例缩减分配
      double risk_reduction_factor = max_portfolio_risk / portfolio_risk;
      for (int i = 0; i < strategy_count; ++i) {
        temp_allocations[i] *= risk_reduction_factor;
      }
    }

    // 复制结果并计算统计信息
    int active_count = 0;
    double total_risk = 0.0;
    double total_return = 0.0;

    for (int i = 0; i < strategy_count; ++i) {
      result.allocations[i] = temp_allocations[i];
      if (temp_allocations[i] > EPSILON) {
        active_count++;
        total_return += temp_allocations[i] * strategies[i].expected_return;
      }
      total_risk += temp_allocations[i] * strategies[i].risk_limit;
    }

    result.total_risk = total_risk;
    result.expected_return = total_return;
    result.active_strategies = active_count;

    return result;
  }

 private:
  double calculate_portfolio_risk(const std::vector& strategies,
                                  const std::array& allocations, int count) {
    double total_risk = 0.0;
    for (int i = 0; i < count; ++i) {
      total_risk += allocations[i] * strategies[i].risk_limit;
    }
    return total_risk;
  }
};

4. 做市报价求解器 (Market-Making Quote Solver)

做市策略的核心组件，需要在微秒级别内计算出最优买卖报价。

输入参数：

  • 基础公允价格估计
  • 近期成交率
  • 波动率水平
  • 库存状态
  • 竞争对手报价与价差

输出结果：

  • 最优买卖报价
  • 各档位挂单数量

主要实现方法：

  • Avellaneda-Stoikov模型
  • 多因子公允价格回归+优化
  • QP优化（库存+价差惩罚）
  • 强化学习（极少数团队，但不稳）

高频做市报价求解器核心流程：

  • 计算中间价→公允价格，加入微观结构信号预测
  • 添加库存惩罚项
  • 添加风险惩罚项
  • 求解最优报价点
#include
#include
#include

class MarketMakingQuoteSolver {
 private:
  static constexpr double EPSILON = 1e-9;
  static constexpr double GAMMA = 0.1;   // 风险厌恶系数
  static constexpr double K = 1.5;       // 市场流动性参数
  static constexpr double SIGMA = 0.02;  // 波动率

 public:
  struct MarketData {
    double bid_price;
    double ask_price;
    double bid_volume;
    double ask_volume;
    double fair_price;
    double volatility;
    double inventory;
    double max_inventory;
    double time_to_close;
  };

  struct QuoteResult {
    double bid_price;
    double ask_price;
    double bid_size;
    double ask_size;
    double spread;
    double inventory_risk;
  };

  QuoteResult solve(const MarketData& market_data) {
    QuoteResult result = {};

    double current_price = market_data.fair_price;
    double inventory = market_data.inventory;
    double time_left = market_data.time_to_close;
    double max_inv = market_data.max_inventory;

    // Avellaneda-Stoikov模型计算
    // 计算库存调整项
    double inventory_factor = GAMMA * SIGMA * SIGMA * time_left * inventory;

    // 计算最优价差
    double optimal_spread = (2.0 / GAMMA) * std::log(1.0 + GAMMA / K);

    // 应用库存惩罚调整
    double inventory_adjustment = inventory_factor;
    if (std::abs(inventory) > max_inv * 0.8) {
      // 库存过高时增加惩罚
      inventory_adjustment *= 2.0;
    }

    // 计算最终报价
    double half_spread = optimal_spread / 2.0;
    result.bid_price = current_price - half_spread - inventory_adjustment;
    result.ask_price = current_price + half_spread + inventory_adjustment;

    result.spread = result.ask_price - result.bid_price;
    result.inventory_risk = std::abs(inventory) / max_inv;

    // 计算挂单量（基于库存状态调整）
    double base_size = 1.0;  // 基础挂单量
    double inventory_penalty = 1.0 - std::abs(inventory) / max_inv;
    inventory_penalty = std::max(inventory_penalty, 0.1);

    result.bid_size = base_size * inventory_penalty;
    result.ask_size = base_size * inventory_penalty;

    // 如果库存偏向买入，减少买挂单量，增加卖挂单量
    if (inventory > 0) {
      result.bid_size *= 0.8;
      result.ask_size *= 1.2;
    } else if (inventory < 0) {
      result.bid_size *= 1.2;
      result.ask_size *= 0.8;
    }

    return result;
  }

  // 实时更新公允价格估计
  double update_fair_price(double current_price,
                           const std::array& recent_trades, int trade_count) {
    if (trade_count == 0) {
      return current_price;
    }

    // 简单的移动平均更新
    double sum = 0.0;
    int count = std::min(trade_count, 10);

    for (int i = 0; i < count; ++i) {
      sum += recent_trades[i];
    }

    double ma_price = sum / count;
    // 结合当前价格和历史平均，使用指数平滑
    return 0.3 * ma_price + 0.7 * current_price;
  }
};