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

----- Получаем цену последней сделки с графика цены 
      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

--[[Automatic Gain Control (AGC) Автоматическая регулировка усиления
Цель AGC - обеспечить единообразный внешний вид индикатора независимо от диапазона колебаний цены. 
Процесс AGC делит текущую цену на абсолютное значение недавнего максимального колебания, 
так что нормализованная форма волны имеет максимум 1 или минимум -1.
--]]
function Cached.AGC() -- Automatic Gain Control (Oscillator © 2013 John F. Ehler)
    
    local abs=math.abs
    
    local Peak={},{}
    local Out={}

    return function( I,FSettings,ds )
        local I = (I or 1)
        local ds = (ds or nil)
        local FSettings = (FSettings or {})
        local v_t = (FSettings.v_t or 'C')
        local x = (FSettings.x or nil)
        --------------------------------------
        local p0 = x or Value(I, v_t, ds) or 0;
        if I == 1 then
            Peak={}; Peak[I]=0;
            Out={}; Out[I]=0;
        end
        
        ----------------------------------------
        -- Automatic Gain Control (AGC) Автоматическая регулировка усиления
        local peak1 = I > 1 and Peak[I-1] or p0;
        local peak = 0.991 * peak1;
        if abs( p0 ) > peak then peak = abs( p0 ) end
        local out1 = I>1 and Out[I-1] or p0;
        local out=0; if peak~=0 then out=p0/peak end
        ----------------------------------------
        
        Peak[I] = peak
        Out[I] = out
        ----------------------------------------
        return out,out1
    end
end