VPM (Все сообщения пользователя)

local SignalEngine = {
    factors = {},
    regime = "unknown",
    score = 0
}

function SignalEngine:updateFromBreakout(buy, sell, support, resistance, volRatio)

    local factor = {}

    -- Фактор направления
    factor.breakout =
        buy and 1 or
        sell and -1 or
        0

    -- Фактор структуры
    factor.structure =
        support and 0.5 or
        resistance and -0.5 or
        0

    -- Фактор волатильности
    factor.volatility = clamp((volRatio or 0) - 1, -1, 1)

    self.factors.breakout = factor
end

local Trader =  {}
function Trader:process(signalScore, regime)
    if regime == "flat" then return end

    if signalScore > 0.7 then
        self:buy()
    elseif signalScore < -0.7 then
        self:sell()
    end
end

function SignalEngine:detectRegime(vol, adx)
    if vol < 0.7 and adx < 15 then
        return "flat"
    elseif adx > 25 then
        return "trend"
    else
        return "transition"
    end
end

function SignalEngine:filterFactorsByRegime(regime)
    if regime == "flat" then
        self.factors.breakout.breakout = 0
    elseif regime == "transition" then
        self.factors.breakout.breakout = 0.5
    end
end

function SignalEngine:calcScore()
    local score = 0
    for _, f in pairs(self.factors) do
        score = score + (f.breakout or 0) + (f.structure or 0)
    end
    self.score = clamp(score, -1, 1)
    return self.score
end

function OnTrade(trade)

    if not WORKING_FLAG then return end

    local key = trade.trans_id
    local i = tonumber(sdelka[0]); 
    
  if working 
  and key and key>0
  and (i==0 and key~=sdelka.id) or (i>0 and sdelka[i][1]~=key)
  --and trade.sec_code==symbol --and trade.class_code==class 
  then
    
    i=i+1;  
    sdelka[0]=i;                         
    sdelka[i]={};                     
    sdelka[i][0]=sdelka[0];
    sdelka[i][1]=trade.trans_id;      
    sdelka[i][2]=get_date(trade.datetime)
    sdelka[i][3]=get_time(trade.datetime)
    
    sdelka[i][4]="B"; if bit.band(trade.flags,4)~=0 then sdelka[i][4]="S"; end;
    local dir = sdelka[i][4]=="B" and 1 or sdelka[i][4]=="S" and -1 or 0;
    sdelka[i][5]=trade.qty*dir;       
    sdelka[i][6]=trade.price;         
    ----- comission 
    sdelka[i][7]=trade.clearing_comission+trade.exchange_comission+trade.tech_center_comission;
    
    sdelka[i][8]=trade.order_num;    
    sdelka[i][9]=trade.trade_num;  
    sdelka[i][10]=trade.sec_code;     
                        
    sdelka.id=trade.trans_id;
    
    Log:info("OnTrade! sdelka "..i .."; "
                                  .."; trans_id="..sdelka[i][1] 
                                  .."; "..sdelka[i][2]
                                  .."; "..sdelka[i][3]
                                  .."; "..sdelka[i][4]
                                  .."; "..sdelka[i][5]
                                  .."; "..sdelka[i][6]
                                  .."; comission="..sdelka[i][7]
                                  .."; onum="..sdelka[i][8]
                                  .."; tnum="..sdelka[i][9]
                                  .."; "..sdelka[i][10]
                                  .."\n"
                                  );
    --local a,v; for a,v in pairs(sdelka[i) do Log:trace( 'OnTrade! sdelka['..i..']['..tostring(a)..'] = '.. tostring(v) ) end;
  end
end;

local path = getWorkingFolder()
local f;
local save = {
    position = 0,
    d = 0,
    t = 0
    }

Settings={}
Settings.Name = "*BreakoutIndicator"
Settings.period = 5
Settings.k = 1
Settings.wid = 0

function Init()
    local Cached = dofile(path .. "\\cached.lua"); 
   f = BreakoutIndicator()
   Cached=nil
   Settings.line = {
   {Name = "BUY", Type = TYPE_TRIANGLE_UP, Width = 1, Color = RGB(0, 0, 255) },
   {Name = "SELL", Type = TYPE_TRIANGLE_DOWN, Width = 1, Color = RGB(255, 0, 128) },
   
   {Name = "save.upper", Type = TYPE_BAR , Width = 1, Color = RGB(0, 128, 255) },
   {Name = "save.lower", Type = TYPE_BAR, Width = 1, Color = RGB(255, 0, 128) },
   {Name = "SL", Type =TYPE_DASH, Width = 1, Color = RGB(255, 0, 0) }
   }
   return #Settings.line
end
function OnCalculate(index)

   -- ====== ТЕКУЩИИ ЗНАЧЕНИЯ ======
    local position1 = save.position 
    local d1 = save.d
    local t1 = save.t
    
    -- ====== Расчет ЗНАЧЕНИЙ ======
    local breakout = f( index, Settings )
    
    -- ====== Обработка ======
    local newbar = (breakout and d1 ~= breakout.d or breakout.t ~= t1)
    
    save.position = breakout and breakout.position
    save.d = breakout and breakout.d
    save.t = breakout and breakout.t
    
    --====== RETURN LINES ======
    if Settings.wid == 2 then
        return nil,nil,nil,nil, breakout and breakout.volatilityRatio > 1 and breakout.volatilityRatio or nil
    end
    return  breakout and (d1 ~= breakout.d or breakout.t ~= t1) and breakout.position == 1 and  breakout.entryLevel or nil,   -- BUY
            breakout and (d1 ~= breakout.d or breakout.t ~= t1) and breakout.position == -1 and breakout.entryLevel or nil,   -- SELL
            breakout and breakout.position == 1 and breakout.upperPivot or nil,
            breakout and breakout.position == -1 and breakout.lowerPivot or nil,
            breakout and breakout.position ~= 0 and breakout.slLevel or nil

end

----- Получаем цену последней сделки с графика цены 
      local I = getNumCandles(tag.price)   
      while I==nil or I==0 do
         sleep (100)
         I = getNumCandles(tag.price)
      end
       if I<=4 then toLog(log,  'Недостаточно бар для продолжения работы ' .. tostring(I) ) return end

-- Безопасное получение значения с графика
function Utils.getGraphValue(tag, line, index, field)
    local candles = getCandlesByIndex(tag, line, index, 1)
    if not candles or not candles[0] then
        return nil
    end
    return candles[0][field]
end
-- ===============================
-- ДАННЫЕ (DATA LAYER)
-- ===============================
local Data = {}

function Data:init()
    self.context = {}
    self.history = {}
    self.current_index = 0
end

function Data:update()
    -- Получаем количество свечей
    local num_candles = getNumCandles(CFG.tags.price)
    if num_candles < 20 then
        Utils.log("WARN", "Недостаточно свечей: " .. num_candles)
        return false
    end
    
    -- Текущая свеча
    local candle = Utils.getGraphValue(CFG.tags.price, 0, num_candles - 1, "close")
    if not candle then return false end
    
    self.context = {
        -- Цены
        bar_index = num_candles - 1,
        datetime = Utils.getGraphValue(CFG.tags.price, 0, num_candles - 1, "datetime"),
        open = Utils.getGraphValue(CFG.tags.price, 0, num_candles - 1, "open"),
        high = Utils.getGraphValue(CFG.tags.price, 0, num_candles - 1, "high"),
        low = Utils.getGraphValue(CFG.tags.price, 0, num_candles - 1, "low"),
        close = Utils.getGraphValue(CFG.tags.price, 0, num_candles - 1, "close"),
        volume = Utils.getGraphValue(CFG.tags.price, 0, num_candles - 1, "volume"),
        
        -- Price Channel
        resistance = Utils.getGraphValue(CFG.tags.channel, 0, num_candles - 1, "close"),
        middle = Utils.getGraphValue(CFG.tags.channel, 1, num_candles - 1, "close"),
        support = Utils.getGraphValue(CFG.tags.channel, 2, num_candles - 1, "close"),
        
        -- Decycler
        decycler_high = Utils.getGraphValue(CFG.tags.decycler, 0, num_candles - 1, "close"),
        decycler_low = Utils.getGraphValue(CFG.tags.decycler, 1, num_candles - 1, "close"),
        decycler_high_prev = Utils.getGraphValue(CFG.tags.decycler, 0, num_candles - 2, "close"),
        
        -- RSI
        rsi = Utils.getGraphValue(CFG.tags.rsi, 0, num_candles - 1, "close"),
        
        -- ADX
        adx = Utils.getGraphValue(CFG.tags.adx, 0, num_candles - 1, "close"),
        plus_di = Utils.getGraphValue(CFG.tags.adx, 1, num_candles - 1, "close"),
        minus_di = Utils.getGraphValue(CFG.tags.adx, 2, num_candles - 1, "close"),
        
        -- ATR
        atr = Utils.getGraphValue(CFG.tags.atr, 0, num_candles - 1, "close")
    }
    
    -- Проверка данных
    if not self.context.resistance or not self.context.middle or not self.context.support then
        Utils.log("ERROR", "Не удалось получить данные Price Channel")
        return false
    end
    
    -- Расчет процента ATR
    if self.context.atr and self.context.close then
        self.context.atr_pct = (self.context.atr / self.context.close) * 100
    else
        self.context.atr_pct = 0
    end
    
    -- Сохраняем в историю 
    table.insert(self.history, {
        index = self.context.bar_index,
        datetime = self.context.datetime,
        open = self.context.open,
        high = self.context.high,
        low = self.context.low,
        close = self.context.close,
        data = {
            resistance = self.context.resistance,
            middle = self.context.middle,
            support = self.context.support,
            decycler_high = self.context.decycler_high,
            decycler_low = self.context.decycler_low,
            rsi = self.context.rsi,
            adx = self.context.adx,
            plus_di = self.context.plus_di,
            minus_di = self.context.minus_di,
            atr = self.context.atr
        }
    })
    
    return true
end

local Graph = {}

function Graph.new(tag, line)
    local o = {}
    o.tag = tag
    o.line = line or 0

    function o:last()
        for i = 0, 50000 do
            local _, n = getCandlesByIndex(o.tag, o.line, i, 1)
            if n == 0 then
                local t = getCandlesByIndex(o.tag, o.line, i - 1, 1)
                return t and t[1] or nil
            end
        end
    end

    return o
end

return Graph

local Graph   = require("Graph")
local NewBar  = require("NewBar")
local Trade   = require("Trade")
local is_run = true

function main()
local price = Graph.new("graph_SBER", 0)
local ma20  = Graph.new("graph_SBER", 1)
local ma50  = Graph.new("graph_SBER", 2)

local bar = NewBar.new("graph_SBER")

while is_run do
    if bar:check() then
        local p  = price:last()
        local m20 = ma20:last()
        local m50 = ma50:last()

        if p and m20 and m50 then
            if p.close > m20.close and m20.close > m50.close then
                Trade.buy()
            elseif p.close < m20.close and m20.close < m50.close then
                Trade.sell()
            end
        end
    end
    sleep(200)
end
end

function OnStop()
    is_run = false
end

----- Получаем цену последней сделки с графика цены 
      local I = getNumCandles(tag.price)   
      while I==nil or I==0 do
         sleep (100)
         I = getNumCandles(tag.price)
      end
       if I<=4 then toLog(log,  'Недостаточно бар для продолжения работы ' .. tostring(I) ) return end
      
      local newber = I > I1 I1=I

Эталонная структура сигнала
Signal = {
    dir     = "BUY" | "SELL" | "NONE",
    score   = 0..100,
    class   = "A" | "B" | "C" | "NONE",
    regime  = "TREND" | "RANGE" | "TRANSITION" | "VOLATILE",
    rr      = number,
}

-- Принцип:
1. Определяем Regime;
2. Считаем SignalScore;
3. Проверяем Risk/Reward;
4. Только потом -> торговое решение.

local bar_cur1 = getCandlesByIndex(tag.price,0,I-1,1)[0]
      while not bar_cur1 or bar_cur1==nil do
            sleep (100);
            I = getNumCandles(tag.price);   
            bar_cur1 = getCandlesByIndex(tag.price,0,I-1,1)[0];
      end

--[[ Как выбораем метод (Памятка)?
Кто уже или еще? не очень дружен со cтатистикой и методами анализа, могу порекомендовать (в сваободном достепе Эл. с примерами на lua 5.1): 
John R. Hauser "Numerical Methods for Nonlinear Engineering Models"

1. Используйте AGC когда. Нужно сохранить форму волны для визуального анализа. Работаете с осцилляторами в реальном времени. Важна минимальная задержка.
2. Используйте Z-score когда. Данные приблизительно нормально распределены. Нужны статистически значимые пороги. Работаете с mean-reverting стратегиями.
3. Используйте Robust scaling когда. Есть выбросы и тяжелые хвосты. Данные не нормально распределены. Нужна устойчивость к экстремальным движениям.
4. Используйте Percentile когда. Важны ранги и относительное положение. Работаете с непараметрическими статистиками. Нужна полная независимость от распределения.

Вывод. Не существует универсального лучшего метода. AGC прекрасен для своей ниши (осцилляторы, визуализация), но для машинного обучения и статистических решений нужен более тонкий подход. Реализуйте адаптивную систему, которая для каждой метрики анализирует распределение и автоматически выбирает оптимальный метод нормализации. Это даст преимущества каждого подхода без их недостатков.
--]]
-------------------------------
-- АДАПТИВНАЯ СИСТЕМА НОРМАЛИЗАЦИИ
-------------------------------
function CandleManager:adaptiveNormalize(data, method, parameters)
    parameters = parameters or {}
    
    -- Анализ характеристик временного ряда
    local stats = self:calculateTimeSeriesStats(data)
    
    -- Автоматический выбор метода если не указан явно
    if not method then
        method = self:selectNormalizationMethod(stats)
    end
    
    if method == "AGC" then
        return self:AGC(data, parameters.alpha or 0.991)
    elseif method == "ZSCORE" then
        return self:ZScoreNormalize(data, parameters)
    elseif method == "ROBUST" then
        return self:robustScale(data, parameters)
    elseif method == "PERCENTILE" then
        return self:percentileNormalize(data, parameters)
    elseif method == "ADAPTIVE" then
        return self:adaptiveHybridNormalize(data, stats, parameters)
    else
        return self:minMaxScale(data)
    end
end

-------------------------------
-- АНАЛИЗ СТАТИСТИК ВРЕМЕННОГО РЯДА
-------------------------------
function CandleManager:calculateTimeSeriesStats(data)
    local stats = {}
    
    -- Базовые статистики
    stats.mean = self:mean(data)
    stats.std = self:stdDev(data)
    stats.min = math.min(unpack(data))
    stats.max = math.max(unpack(data))
    
    -- Анализ выбросов (outliers)
    stats.skewness = self:skewness(data)
    stats.kurtosis = self:kurtosis(data)
    
    -- Анализ волатильности (кластеризация)
    stats.volatility_clustering = self:detectVolatilityClustering(data)
    
    -- Тест на нормальность (приблизительный)
    stats.is_normal = math.abs(stats.skewness) < 1 and stats.kurtosis < 3.5
    
    -- Коэффициент вариации
    stats.coefficient_of_variation = stats.std / math.abs(stats.mean)
    
    return stats
end

-------------------------------
-- АВТОМАТИЧЕСКИЙ ВЫБОР МЕТОДА НОРМАЛИЗАЦИИ
-------------------------------
function CandleManager:selectNormalizationMethod(stats)
    -- Если данные приблизительно нормальны
    if stats.is_normal and stats.coefficient_of_variation < 2 then
        return "ZSCORE"
    
    -- Если есть выбросы (тяжелые хвосты)
    elseif math.abs(stats.skewness) > 1 or stats.kurtosis > 4 then
        return "ROBUST"
    
    -- Сильная кластеризация волатильности
    elseif stats.volatility_clustering then
        return "ADAPTIVE"
    
    -- Стабильный диапазон, мало выбросов
    else
        return "AGC"
    end
end

-- Специализированные методы нормализации:

-- 1. Robust Scaling (устойчивый к выбросам)
function CandleManager:robustScale(data, parameters)
    local median = self:median(data)
    local q75 = self:quantile(data, 0.75)
    local q25 = self:quantile(data, 0.25)
    local iqr = q75 - q25
    
    local normalized = {}
    for i = 1, #data do
        if iqr ~= 0 then
            normalized[i] = (data[i] - median) / iqr
        else
            normalized[i] = 0
        end
    end
    
    return normalized
end

-- 2. Percentile Normalization
function CandleManager:percentileNormalize(data, parameters)
    local sorted = {}
    for i, v in ipairs(data) do sorted[i] = v end
    table.sort(sorted)
    
    local normalized = {}
    for i = 1, #data do
        local rank = 0
        for j = 1, #sorted do
            if sorted[j] <= data[i] then rank = rank + 1 end
        end
        normalized[i] = (rank / #sorted) * 2 - 1  -- [-1, 1]
    end
    
    return normalized
end

-- 3. Adaptive Hybrid Normalization
function CandleManager:adaptiveHybridNormalize(data, stats, parameters)
    -- Разделяем данные на режимы: тренд и шум
    local trend = self:EMA(data, parameters.trend_period or 20)
    local noise = {}
    
    for i = 1, #data do
        noise[i] = data[i] - (trend[i] or data[i])
    end
    
    -- К тренду применяем AGC, к шуму - Robust scaling
    local normalized_trend = self:AGC(trend, 0.995)
    local normalized_noise = self:robustScale(noise)
    
    -- Комбинируем с весами
    local combined = {}
    local trend_weight = parameters.trend_weight or 0.7
    
    for i = 1, #data do
        combined[i] = trend_weight * (normalized_trend[i] or 0) + 
                     (1 - trend_weight) * (normalized_noise[i] or 0)
    end
    
    return combined
end

-- Пример применения в вашем Navigator
function Navigator:enhancedNormalizeMetrics(
                                            EMA20, 
                                            EMA50, 
                                            ATR, 
                                            RSI, 
                                            Vol, 
                                            SMA_Vol, 
                                            sentiment
                                            )

    -- Собираем метрики
    local raw_metrics = {
        (EMA20-EMA50)/ATR,     -- Нормализованный тренд
        (RSI-50)/25,           -- Моментум
        (ATR/close-0.01)/0.05, -- Волатильность
        (Vol/SMA_Vol-1),       -- Объем
        sentiment              -- Настроения
    }

    -- Анализируем каждую метрику и применяем оптимальную нормализацию
    local normalized_metrics = {}
    local method_per_metric = {}
    
    for i, metric in ipairs(raw_metrics) do
        local metric_data = {metric} -- В реальности это будет история метрики
        
        local stats = CandleManager:calculateTimeSeriesStats(metric_data)
        local best_method = CandleManager:selectNormalizationMethod(stats)
        
        normalized_metrics[i] = CandleManager:adaptiveNormalize(
                                                                metric_data, best_method
                                                                )[1] -- Берем последнее значение
        
        method_per_metric[i] = best_method
    end
    
    -- Логируем выбранные методы для отладки (обращаем внимание на точность)
    log_write("Normalization methods: " .. table.concat(method_per_metric, ", "))
    
    return normalized_metrics
end