MINMAX - 最小最大值

min_values, max_values = TA.MINMAX(records, timeperiod)

def main():
    records = exchange.GetRecords()
    if len(records) < 20:
        return
    
    closes = [r['Close'] for r in records]
    
    # 计算20周期的最小最大值
    min_vals, max_vals = TA.MINMAX(closes, 20)
    
    current_min = min_vals[-1]
    current_max = max_vals[-1]
    current_price = closes[-1]
    
    Log(f"20周期区间: [{current_min:.2f}, {current_max:.2f}]")
    Log(f"当前价格: {current_price:.2f}")
    
    # 计算当前价格在区间的位置
    range_width = current_max - current_min
    position = (current_price - current_min) / range_width * 100
    
    Log(f"价格位于区间 {position:.1f}% 位置")

def donchian_channel_strategy():
    records = exchange.GetRecords()
    highs = [r['High'] for r in records[-50:]]
    lows = [r['Low'] for r in records[-50:]]
    closes = [r['Close'] for r in records[-50:]]
    
    # 20周期Donchian通道
    period = 20
    lower_band, upper_band = TA.MINMAX(closes, period)
    
    # 也可以用高低点
    # lower_band = TA.MIN(lows, period)
    # upper_band = TA.MAX(highs, period)
    
    current_price = closes[-1]
    upper = upper_band[-1]
    lower = lower_band[-1]
    middle = (upper + lower) / 2
    
    Log(f"Donchian通道: 上轨={upper:.2f}, 中轨={middle:.2f}, 下轨={lower:.2f}")
    
    # 突破上轨 - 买入
    if current_price >= upper and closes[-2] < upper_band[-2]:
        Log("突破上轨，买入信号！")
        return "BUY"
    
    # 跌破下轨 - 卖出
    elif current_price <= lower and closes[-2] > lower_band[-2]:
        Log("跌破下轨，卖出信号！")
        return "SELL"
    
    # 回归中轨 - 平仓
    elif abs(current_price - middle) / middle < 0.005:
        Log("回归中轨，平仓信号")
        return "CLOSE"
    
    return "HOLD"

def volatility_range():
    records = exchange.GetRecords()
    closes = [r['Close'] for r in records[-100:]]
    
    # 计算不同周期的波动范围
    min_10, max_10 = TA.MINMAX(closes, 10)
    min_20, max_20 = TA.MINMAX(closes, 20)
    min_50, max_50 = TA.MINMAX(closes, 50)
    
    # 各周期的区间宽度
    range_10 = (max_10[-1] - min_10[-1]) / min_10[-1] * 100
    range_20 = (max_20[-1] - min_20[-1]) / min_20[-1] * 100
    range_50 = (max_50[-1] - min_50[-1]) / min_50[-1] * 100
    
    Log(f"10周期波动: {range_10:.2f}%")
    Log(f"20周期波动: {range_20:.2f}%")
    Log(f"50周期波动: {range_50:.2f}%")
    
    # 判断市场状态
    if range_20 < 3:
        Log("极低波动，可能突破在即")
        return "LOW_VOLATILITY"
    elif range_20 > 15:
        Log("高波动，注意风险")
        return "HIGH_VOLATILITY"
    else:
        Log("正常波动")
        return "NORMAL"

def channel_squeeze_breakout():
    records = exchange.GetRecords()
    closes = [r['Close'] for r in records[-100:]]
    
    period = 20
    min_vals, max_vals = TA.MINMAX(closes, period)
    
    # 计算最近20根K线的通道宽度
    recent_ranges = []
    for i in range(-20, 0):
        range_width = (max_vals[i] - min_vals[i]) / min_vals[i] * 100
        recent_ranges.append(range_width)
    
    current_range = recent_ranges[-1]
    avg_range = sum(recent_ranges) / len(recent_ranges)
    
    # 通道收缩（宽度小于平均值的70%）
    if current_range < avg_range * 0.7:
        Log(f"通道收缩！当前宽度{current_range:.2f}% < 平均{avg_range:.2f}%")
        
        # 检查是否突破
        current_price = closes[-1]
        if current_price >= max_vals[-1]:
            Log("向上突破收缩通道！")
            return "BREAKOUT_UP"
        elif current_price <= min_vals[-1]:
            Log("向下突破收缩通道！")
            return "BREAKOUT_DOWN"
        else:
            Log("等待突破方向")
            return "SQUEEZE"
    
    return "NORMAL"

def range_trading():
    records = exchange.GetRecords()
    closes = [r['Close'] for r in records[-50:]]
    
    # 20周期区间
    min_vals, max_vals = TA.MINMAX(closes, 20)
    
    lower = min_vals[-1]
    upper = max_vals[-1]
    current = closes[-1]
    
    # 区间宽度
    range_width = upper - lower
    range_pct = range_width / lower * 100
    
    # 只在窄区间（<5%）交易
    if range_pct > 5:
        Log(f"区间过宽({range_pct:.2f}%)，不适合区间交易")
        return None
    
    # 计算当前位置
    position_in_range = (current - lower) / range_width
    
    Log(f"区间: [{lower:.2f}, {upper:.2f}], 宽度: {range_pct:.2f}%")
    Log(f"价格位于区间 {position_in_range * 100:.1f}% 位置")
    
    # 接近下轨买入
    if position_in_range < 0.2:
        Log("接近下轨，买入信号")
        return "BUY", lower
    
    # 接近上轨卖出
    elif position_in_range > 0.8:
        Log("接近上轨，卖出信号")
        return "SELL", upper
    
    # 中间区域观望
    else:
        Log("中间区域，观望")
        return "HOLD", None

def dynamic_stops():
    records = exchange.GetRecords()
    closes = [r['Close'] for r in records[-30:]]
    
    # 使用最近10周期的范围
    min_vals, max_vals = TA.MINMAX(closes, 10)
    
    current_low = min_vals[-1]
    current_high = max_vals[-1]
    current_price = closes[-1]
    
    # 多头止损：10周期最低点
    long_stop = current_low
    
    # 多头止盈：10周期最高点附近
    long_target = current_high
    
    # 空头相反
    short_stop = current_high
    short_target = current_low
    
    Log(f"当前价: {current_price:.2f}")
    Log(f"多头: 止损={long_stop:.2f}, 止盈={long_target:.2f}")
    Log(f"空头: 止损={short_stop:.2f}, 止盈={short_target:.2f}")
    
    return {
        'long_stop': long_stop,
        'long_target': long_target,
        'short_stop': short_stop,
        'short_target': short_target
    }