数学运算实战策略

def calculate_position_size():
    """根据波动率动态调整仓位"""
    records = exchange.GetRecords()
    
    # 计算ATR（真实波动幅度）
    atr = TA.ATR(records, 14)
    current_atr = atr[-1]
    
    # 账户余额
    account = exchange.GetAccount()
    balance = account.Balance
    
    # 每1%风险承受金额
    risk_per_percent = balance * 0.01
    
    # 仓位大小 = 风险金额 / ATR
    # ATR越大，仓位越小
    position_size = risk_per_percent / current_atr
    
    Log(f"当前ATR: {current_atr}, 建议仓位: {position_size}")
    
    return position_size

def correlation_strategy():
    """基于相关性的配对交易"""
    # 获取BTC数据
    records_btc = exchange.GetRecords()
    btc_closes = [r.Close for r in records_btc[-100:]]
    
    # 获取ETH数据
    exchange.SetCurrency("ETH_USDT")
    records_eth = exchange.GetRecords()
    eth_closes = [r.Close for r in records_eth[-100:]]
    
    # 计算收益率
    btc_returns = []
    eth_returns = []
    
    for i in range(1, len(btc_closes)):
        btc_ret = (btc_closes[i] - btc_closes[i-1]) / btc_closes[i-1]
        eth_ret = (eth_closes[i] - eth_closes[i-1]) / eth_closes[i-1]
        btc_returns.append(btc_ret)
        eth_returns.append(eth_ret)
    
    # 计算价格比率
    ratio = TA.DIV(btc_closes, eth_closes)
    ratio_ma = TA.MA([{'Close': r} for r in ratio], 20)
    ratio_std = TA.STDDEV([{'Close': r} for r in ratio], 20)
    
    current_ratio = ratio[-1]
    z_score = (current_ratio - ratio_ma[-1]) / ratio_std[-1]
    
    Log(f"BTC/ETH比率Z-score: {z_score}")
    
    if z_score > 2:
        Log("BTC相对高估，卖BTC买ETH")
        return "short_btc_long_eth"
    elif z_score < -2:
        Log("BTC相对低估，买BTC卖ETH")
        return "long_btc_short_eth"
    else:
        return "hold"

def price_strength_indicator():
    """价格强度指标 = (当前价 - 最低价) / (最高价 - 最低价)"""
    records = exchange.GetRecords()
    
    period = 20
    
    closes = [r.Close for r in records]
    
    # 最高价和最低价
    max_prices = TA.MAX(records, period)
    min_prices = TA.MIN(records, period)
    
    # 当前价与最低价的差
    price_from_low = TA.SUB(closes[-len(max_prices):], min_prices)
    
    # 价格区间
    price_range = TA.SUB(max_prices, min_prices)
    
    # 强度 = (当前 - 最低) / (最高 - 最低)
    strength = TA.DIV(price_from_low, price_range)
    
    current_strength = strength[-1]
    
    Log(f"价格强度: {current_strength*100:.1f}%")
    
    if current_strength > 0.8:
        Log("接近区间上沿，超买")
        return "overbought"
    elif current_strength < 0.2:
        Log("接近区间下沿，超卖")
        return "oversold"
    else:
        return "neutral"

def volume_weighted_ma(period=20):
    """成交量加权移动平均"""
    records = exchange.GetRecords()
    
    closes = [r.Close for r in records[-period:]]
    volumes = [r.Volume for r in records[-period:]]
    
    # 价格 × 成交量
    price_volume = TA.MULT(closes, volumes)
    
    # 总价值 / 总成交量
    total_pv = sum(price_volume)
    total_volume = sum(volumes)
    
    vwma = total_pv / total_volume
    
    # 普通MA
    ma = TA.MA(records, period)[-1]
    
    Log(f"VWMA: {vwma}, SMA: {ma}")
    
    # VWMA > SMA：大单买入推高价格
    if vwma > ma * 1.005:
        Log("VWMA高于SMA，大单买入")
        return "bullish"
    # VWMA < SMA：大单卖出压低价格
    elif vwma < ma * 0.995:
        Log("VWMA低于SMA，大单卖出")
        return "bearish"
    else:
        return "neutral"

# 全局变量
trade_returns = []

def track_cumulative_returns():
    """追踪累计收益"""
    global trade_returns
    
    if len(trade_returns) == 0:
        return
    
    # 构造收益数组
    return_records = [{'Close': r} for r in trade_returns]
    
    # 最近20笔累计收益
    if len(trade_returns) >= 20:
        cumulative_20 = TA.SUM(return_records, 20)
        
        Log(f"最近20笔累计收益: {cumulative_20[-1]*100:.2f}%")
        
        # 连续亏损过多，暂停交易
        if cumulative_20[-1] < -0.1:  # 亏损超过10%
            Log("累计亏损过大，暂停交易")
            return False
        
    return True

def on_trade_close(entry_price, exit_price):
    """交易平仓时记录收益"""
    global trade_returns
    
    ret = (exit_price - entry_price) / entry_price
    trade_returns.append(ret)
    
    Log(f"本次交易收益: {ret*100:.2f}%")

def comprehensive_strategy():
    """综合运用多个数学运算的策略"""
    records = exchange.GetRecords()
    
    # 1. 价格归一化
    closes = [r.Close for r in records[-100:]]
    max_price = max(closes)
    min_price = min(closes)
    
    normalized_prices = TA.DIV(
        TA.SUB(closes, [min_price] * len(closes)),
        [max_price - min_price] * len(closes)
    )
    
    # 2. 动量计算
    momentum = TA.SUB(closes[-50:], closes[-100:-50])
    
    # 3. 波动率调整
    volatility = TA.STDDEV(records, 20)
    risk_adjusted_momentum = TA.DIV(momentum, volatility[-50:])
    
    # 4. 信号生成
    signal_threshold = 1.5
    
    if risk_adjusted_momentum[-1] > signal_threshold:
        Log("强势上涨，风险调整后动量显著")
        return "buy"
    elif risk_adjusted_momentum[-1] < -signal_threshold:
        Log("强势下跌，风险调整后动量显著")
        return "sell"
    else:
        return "hold"