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

function сложнаяЗадача()
    local data = загрузитьДанные("url") -- Здесь может быть yield
    local result = обработатьДанные(data) -- И здесь
    local success = сохранитьВБД(result) -- И здесь
    если success then
        обновитьИнтерфейс()
    end
end
-- Создаем сопрограмму и "опросом" управляем ее выполнением
local task = coroutine.create(сложная Задача)

-- Пул из нескольких "независимых задач", как вы и сказали
local tasks = {
    coroutine.create(function() ... end), -- Задача 1: загрузка контента
    coroutine.create(function() ... end), -- Задача 2: анимация UI
    coroutine.create(function() ... end), -- Задача 3: обработка ввода
}

-- Главный цикл "опросом" управляет всеми задачами
function главныйЦикл()
    while true do
        local всеЗавершены = true
        for i, co in ipairs(tasks) do
            if coroutine.status(co) ~= "dead" then
                всеЗавершены = false
                coroutine.resume(co) -- "Опрос" конкретной сопрограммы!
            end
        end
        если все Завершены then break end
    end
end

-- В движке: ждем 2 секунды перед загрузкой данных.
function ждать(секунды)
    local времяСтарта = os.clock()
    while os.clock() - времяСтарта < секунды do
        coroutine.yield() -- "Спим", не блокируя основной поток, отдавая управление другим задачам
    end
end

function бесконечнаяПоследовательность(старт, шаг)
    local текущее = старт
    while true do
        coroutine.yield(текущее)
        текущее = текущее + шаг
    end
end

-- Создаем генератор чисел, начиная с 10, с шагом 5
local генератор = coroutine.wrap(бесконечнаяПоследовательность)
local gen = генератор(10, 5)

print(gen()) --> 10
print(gen()) --> 15
print(gen()) --> 20
-- Можно получать значения по требованию, не вычисляя все сразу.

function OnMain()

    Log:trace("OnMain started")
    
    -- Создаем корутины Прверка пароля
    local coPassword   = coroutine.create(checkPassword)
    
    -- Прверка пароля при первом входе!(корутина с безопасным вызовом)
    safe_resume(coPassword, "coPassword")

    --[[GUI.initialize()

    -- Создание таблицы ордеров
    GUI.createTable({
        name = "orders",
        title = "Active Orders",
        width = 1000,
        height = 400,
        x = 10,
        y = 50,
        columns = {
            {
                iCode = 1,
                title = "Time",
                par_type = QTABLE_TIME_TYPE,
                width = 120
            },
            {
                iCode = 2,
                title = "Price",
                par_type = QTABLE_DOUBLE_TYPE,
                width = 100
            },
            {
                iCode = 3,
                title = "Volume",
                par_type = QTABLE_INT64_TYPE,
                width = 100
            }
        }
    })
    
    -- Создание информационной метки
    GUI.createLabel({
        id = "statusLabel",
        text = "System Status: OK",
        x = 10,
        y = 10,
        width = 300,
        color = "#00FF00",
        bgColor = "#333333"
    })
    --]]

    GUI.initialize()
    -- Создание таблицы ордеров
    GUI.createTable({
        name = "orders",
        title = "Активные ордера",
        columns = {
            {
                iCode = 1,
                title = "Время",
                type = QTABLE_TIME_TYPE,
                width = 120
            },
            {
                iCode = 2,
                title = "Операция",
                type = QTABLE_STRING_TYPE,
                width = 100
            },
            {
                iCode = 3,
                title = "Объем",
                type = QTABLE_INT_TYPE, -- Теперь правильно QTABLE_INT_TYPE = 1
                width = 80
            }
        }
    })

    -- Пример использования в главном цикле
    local hook = PerformanceHook()
    --local performanceHook = PerformanceHook()

    local fatal = nil

    AutoUpdateVersion()
    CreateWindowRobot()

    if Start ~= nil then
        Start()
    end

    AtExit(function()
        for _, so in pairs(SmartOrder.pool) do
            so:enough()
            so:process()
        end
    end)

    if Robot ~= nil then -- Провека на наличие основтой функции

        ---- функция для получения информации о классе 
        local ClassInfo = getClassInfo(class_names[1]);
        firmid = ClassInfo and ClassInfo.firmid or ''; Log:trace('firmid = ' .. tostring(firmid ) );
        
        -- Создаем корутину для функции Robot
        local routine = coroutine.create(Robot) 
        Log:trace("Robot started")
        
        -- Создаем корутины
        --local coPassword   = coroutine.create(checkPassword)
        local coConnection = coroutine.create(checkConnection)
        local coTradeDate  = coroutine.create(checkTradeDate)
        local coServerTime = coroutine.create(checkServerTime)
        local coWorkTime   = coroutine.create(checkWorkTime) -- Сопрограмма для отслеживания рабочего времени 
        --local coStopTimeTrading = coroutine.create(checkStopTimeTrading)

        -- Cоздание корутин для стратегий реального времени
        --if not rejime.test and event_co.connected == 1 and event_co.servertime[2] and flagTimeTrading then
            -- Cоздание корутины function 
            local coCapitalManager = coroutine.create(CapitalManagerCo--function() CapitalManagerCo(CONFIG) end
            )
            local coMoneyManagement = coroutine.create(function()
              --for _, class in ipairs(class_names) do
                --for n, symbol in ipairs(symbol_names) do  
                    --if mm[class][symbol] ~= nil then
                        --MoneyManagementCo( mm[class][symbol] )
                        MoneyManagementCo( firmid, account, class_names, symbol_names )
                    --else
                        --Log:error("MoneyManagement instance 'mm[n]' is nil. Cannot start MoneyManagementCoroutine.")
                    --end
                --end
              --end
            end)

        --if not rejime.test and event_co.connected == 1 and event_co.servertime[2] and flagTimeTrading then
            local co_alltrade = coroutine.create(alltrade_processor)
            local co_order_book = coroutine.create(order_book_processor)
            --local co_tt_parametrs = coroutine.create(trade_data_processor)
            
            local futuresCoroutine = coroutine.create(futures_position_processor)
            local futuresLimitCoroutine = coroutine.create(futures_limit_processor)
        --end
        
           
        while WORKING_FLAG do

            --------------------------
            local sek = os.clock();
            --------------------------

            --[[-- Обновление данных
            --GUI.update_connection_status(isConnected())
            --GUI.update_last_activity(os.time())
            --GUI.update_uptime(getUptime())

            -- Добавление новых ордеров
            --while hasNewOrders() do
            --    GUI.add_order(getNextOrder())
            --end

            -- Обновление торговой панели
            GUI.updateComponent("trading_panel", {
                {"BUY", 100.50, 10},
                {"SELL", 101.00, 5}
            })

            -- Добавление метки на график
            GUI.Chart.addLabel("MAIN_CHART", "Support Level", {
            YVALUE = 98.50,
            COLOR = RGB(46, 204, 113)
            })--]]

            -- Обновление данных
            GUI.updateTable("orders", {
                {os.date("%H:%M:%S"), "BUY", 10},
                {os.date("%H:%M:%S"), "SELL", 5}
            })

            -- Запуск корутин с безопасным вызовом
            if not rejime.test then

                safe_resume(coConnection, "coConnection")
                SetCell(table_id, 1, 1, tostring(event_co.connected == 1 and 'Connect' or 'NoConnect'))

                if event_co.connected == 1 then

                    safe_resume(coTradeDate,  "coTradeDate")
                    safe_resume(coServerTime, "coServerTime")
                    safe_resume(coWorkTime,   "coWorkTime")
                    --safe_resume(coStopTimeTrading, "coStopTimeTrading")

                    --if event_co.connected == 1 then
                    -- Запуск корутины MoneyManagement
                    --safe_resume( MoneyManagementRoutine, "MoneyManagementRoutine")
                    safe_resume( coCapitalManager, "coCapitalManager")
                    --end

                    -- Запускаем корутину (История сделок и стакан)
                    --Log:info('tradedate[1] =' ..tostring(event_co.tradedate[1]) ..'; worktime =' ..tostring(event_co.worktime[2]) ..'; servertime[2] =' ..tostring(event_co.servertime[2]) --..'; flagTimeTrading =' ..tostring(flagTimeTrading) )
                    
                    if event_co.tradedate[1] 
                    and event_co.worktime[2]
                    and event_co.servertime[2] 
                    then
                        safe_resume(co_alltrade, 'co_alltrade')
                        safe_resume(co_order_book, 'co_order_book')
                    end

                    --coroutine.resume(co_tt_parametrs)
                    -- Функция для запуска корутины
                    --start_futures_position_processing(futuresCoroutine)
                    --start_futures_limit_processing(futuresLimitCoroutine)

                    safe_resume(futuresCoroutine, 'futuresCoroutine')
                    --safe_resume(futuresLimitCoroutine, 'futuresLimitCoroutine')
                end

                -- Формирем модуль СМ
                --safe_resume( coCapitalManager, "coCapitalManager")
                --safe_resume( coMoneyManagement, "coMoneyManagement")
            end

            -- co Robot Затем используйте его методы
            local res, errmsg = coroutine.resume(routine)
            
            if not res then
                fatal = "Broken coroutine (Robot): " .. errmsg
                -- Вариант 1: Использование глобального обработчика (рекомендуется)
                _G.global_error_handler:handle_error(fatal, "Robot")
    
                -- Вариант 2: Статический вызов
                -- ErrorHandler.handle_error_static(fatal, "Robot")
                break
            end

            if coroutine.status(routine) == "dead" then
                Log:trace("Robot routine finished")
                break
            end
           
            ProcessRegistered()

            --local elapsed_ms = performanceHook(sek) -- sleep(1000)
            hook(sek)  -- Обновляем метрики

            sleep(spinner.config.interval * 1000)  -- Контроль частоты

            --if rejime.test then 
            --    sleep(100)
            --else
            --    Log:trace(math.floor(1000 - tonumber(elapsed_ms)))
                --sleep(  )
            --    sleep(1000)
            --end
        end
    end

    if Stop ~= nil then Stop() end
    ProcessAtExit()  -- Вызов ProcessAtExit
    ErrorCollector.log_all_errors()  -- Логирование всех ошибок при завершении
    Log:trace("Robot stopped")
    
    if fatal ~= nil then
        error(fatal)
    end
end

require "iuplua"

-- Указываем глобальный атрибут для работы с корутинами
iup.SetGlobal("IUPLUA_THREADED", "YES")

-- Функция для создания диалога с текстовым полем
function create_input_dialog()
    local text = iup.text{expand = "HORIZONTAL", value = ""}
    local ok_btn = iup.button{title = "OK", size = "50"}
    local cancel_btn = iup.button{title = "Cancel", size = "50"}
    
    local dlg = iup.dialog{
        iup.vbox{
            iup.label{title = "Введите текст:"},
            text,
            iup.hbox{ok_btn, cancel_btn}
        },
        title = "Ввод данных",
        size = "300x100"
    }
    
    return dlg, text, ok_btn, cancel_btn
end

-- Функция для асинхронного ввода через корутину
function async_input(coroutine_fn)
    return function(...)
        local co = coroutine.create(coroutine_fn)
        local success, result = coroutine.resume(co, ...)
        return result
    end
end

-- Основная функция диалога как корутина
function input_dialog_coroutine()
    local dlg, text, ok_btn, cancel_btn = create_input_dialog()
    
    -- Создаем promise-like объект для синхронизации
    local result = { waiting = true, value = nil }
    
    -- Callback для OK
    ok_btn.action = function()
        result.value = text.value
        result.waiting = false
        return iup.CLOSE
    end
    
    -- Callback для Cancel
    cancel_btn.action = function()
        result.value = nil
        result.waiting = false
        return iup.CLOSE
    end
    
    -- Показываем диалог (не модальный!)
    dlg:show()
    
    -- Ждем завершения в цикле (можно заменить на более изящное решение)
    while result.waiting do
        coroutine.yield()  -- Отдаем управление обратно
        iup.LoopStep()     -- Обрабатываем события IUP
    end
    
    dlg:destroy()
    return result.value
end

-- Пример использования в основном потоке Quik
function main()
    print("Начало работы скрипта")
    
    -- Запускаем диалог в корутине
    local co = coroutine.create(input_dialog_coroutine)
    
    -- Основной цикл обработки
    local timer = os.clock()
    while coroutine.status(co) ~= "dead" do
        -- Периодически возобновляем корутину
        if os.clock() - timer > 0.1 then  -- каждые 100 мс
            local success, input_text = coroutine.resume(co)
            if success and input_text then
                print("Пользователь ввел: " .. input_text)
                break
            elseif not success then
                print("Ошибка в корутине:", input_text)
                break
            end
            timer = os.clock()
        end
        
        -- Здесь может выполняться другой код
        -- Например, обработка данных из Quik
        process_quik_data()
        
        -- Небольшая пауза чтобы не грузить CPU
        os.execute("ping -n 1 127.0.0.1 > nul")  -- для Windows
        -- os.execute("sleep 0.1")  -- для Linux
    end
    
    print("Скрипт продолжает работу после диалога")
end

function process_quik_data()
    -- Здесь может быть код для работы с данными Quik
    -- который выполняется параллельно с открытым диалогом
end

-- Запуск основной функции
main()

RingBufferClassOPP.lua"  1  
Функциональный стиль:
Последнее значение:   100
Предпоследнее:   90
Первое в буфере:   30

Все элементы (новые сначала):
100
90
80
70
60
50
40
30

ООП стиль:
RSI   1   период назад:   45
RSI   2   период назад:   36
RSI   3   период назад:   50
RSI   4   период назад:   46
RSI   5   период назад:   54
Среднее RSI:   46.2

Анализ ADX:   Слабый тренд или флэт
Функциональный стиль:   0.43   сек
ООП стиль:   0.631   сек
>Exit code: 0    Time: 1.483

--- Функциональный стиль: кольцевой буфер
-- @param size_power_of_two степень двойки (например, 3 → буфер на 8 элементов)
function CreateRingBuffer(size_power_of_two)
    local size = 1 << size_power_of_two -- 2^n
    local mask = size - 1
    local data = {}
    for i = 1, size do
        data[i] = 0
    end

    local head = -1
    local count = 0

    local buffer = {}

    --- Добавление элемента
    function buffer:add(value)
        head = (head + 1) & mask
        data[head + 1] = value
        count = math.min(count + 1, size)
    end

    --- Получение элемента (1 - последний)
    function buffer:get(index)
        if index < 1 or index > count then return nil end
        local pos = (head - index + 1 + size) & mask
        return data[pos + 1]
    end

    --- Последний элемент
    function buffer:last()
        if count == 0 then return nil end
        return data[head + 1]
    end

    --- Первый элемент (самый старый)
    function buffer:first()
        if count == 0 then return nil end
        local pos = (head - count + 1 + size) & mask
        return data[pos + 1]
    end

    --- Количество элементов
    function buffer:length()
        return count
    end

    --- Очистка буфера
    function buffer:clear()
        head = -1
        count = 0
    end

    --- Итератор для цикла for (новые → старые)
    function buffer:iter()
        local i = 0
        return function()
            i = i + 1
            return buffer:get(i)
        end
    end

    --- Преобразование в таблицу (новые сначала)
    function buffer:toTable()
        local t = {}
        for i = 1, count do
            t[i] = buffer:get(i)
        end
        return t
    end

    --- Проверка на заполненность
    function buffer:isFull()
        return count == size
    end

    return buffer
end

local connection_status = isConnected()
if connection_status == 1 then
    message("Подключено к серверу connection_status = " .. (connection_status) ..' '.. type(connection_status))
elseif connection_status == 0 then
    message("Отключено от сервера = " .. (connection_status) ..' '.. type(connection_status))
else
    message("Неожиданный результат: " .. tostring(connection_status)..' '.. type(connection_status))
end

А так возвращает, выводит в QUIK сессия вечерняя в разгаре?
[2025-09-16 21:42:19] [Main] INFO: isConnected(): false

-- путь, по которому находится запускаемый скрипт Модуля.
local module_path = getScriptPath().."\\modules\\MultiplierModule.lua"
Settings=
{
    Name = "***MultiplierIndicator",
    scale = 0,
}
local M 
function Init()
    M = dofile(module_path)
    M.init_run()
    -- Используем настройки линий из модуля
    Settings.line = M.settings.line
    return #Settings.line
end
function OnCalculate(index)
    return M.run(index)
end

function Init() 

-- создаю псевдоним
        local Wilder = dofile("E:\\cached.lua") -- getWorkingFolder() .. 
f = Wilder.RSI_Indicator() 
Wilder=nil
        -- Задаю линии для вывода
Settings.line = {
{Name = "50", Color = RGB(24, 24, 24), Type = TYPE_DASHDOT, Width = 1},
{Name = "lineup", Color = RGB(240, 0, 0), Type = TYPE_DASHDOT, Width = 1},
{Name = "linedw", Color = RGB(240, 0, 0), Type = TYPE_DASHDOT, Width = 1},

{Name = "RSI", Color = RGB(0, 0, 255), Type = TYPE_DASHDOT, Width = 2},
--{Name = "trigger",Color = RGB(255, 0, 0), Type = TYPE_LINE, Width = 1},
--{Name = "signal",Color = RGB(055, 055, 055), Type = TYPE_HISTOGRAM, Width = 1}
}
return #Settings.line
end
function OnCalculate(I) 

-- получаю расчеты из внутренней функции
        local out = f(I, Settings)
-- вывод результатов
if out then
    return 50, Settings.lineup, Settings.linedw, out.rsi , out.rsi1 
end

return
end

 local cache = {
        initialized = false,
        last_index = 0,
        history = {},  -- Хранилище для исторических значений
        Configs = {
            period = 14,
            method = "SMMA",
            max_history = 100
        },
        prev_price = nil
    }

function Wilder.RSI_Indicator()
    -- 1. Локальные утилиты для оптимизации
    local math_abs = math.abs
    local math_max = math.max
    local math_min = math.min
    local math_floor = math.floor
    local string_format = string.format
    
    -- Форматирование даты и времени
    local get_date = function(td)
        return td and string_format("%.4d%.2d%.2d", td.year, td.month, td.day) or "00000000"
    end
    local get_time = function(td)
        return td and string_format("%.2d%.2d%.2d", td.hour, td.min, td.sec) or "000000"
    end
    
    -- Функция округления
    local round = function(x, n)
        n = n or 0
        local mult = 10 ^ n
        return x >= 0 and math_floor(x * mult + 0.5) / mult or math_floor(x * mult - 0.5) / mult
    end

    -- 2. Функции сглаживания
    local smoothing = {
        EMA = function(new_val, prev, period)
            local alpha = 2 / (period + 1)
            return alpha * new_val + (1 - alpha) * prev
        end,

        SMMA = function(new_val, prev, period, bars_count)
            if bars_count <= period then
                return (prev * (bars_count - 1) + new_val) / bars_count
            else
                return (prev * (period - 1) + new_val) / period
            end
        end
    }

    -- 3. Состояние индикатора
    local cache = {
        initialized = false,
        last_index = 0,
        history = {},  -- Хранилище для исторических значений
        Configs = {
            period = 14,
            method = "SMMA",
            max_history = 100
        },
        prev_price = nil
    }

    return function(I, F, ds)
        -- A. Обновление параметров
        if F then
            cache.Configs.period = F.Period or cache.Configs.period
            cache.Configs.method = F.Method or cache.Configs.method
            cache.Configs.max_history = F.Max_History or cache.Configs.max_history
        end

        local period = cache.Configs.period
        local method = cache.Configs.method

        -- B. Проверка нового бара
        local is_new_bar = I > cache.last_index

        -- C. Очистка старых данных при новом баре
        if is_new_bar then
            cache.last_index = I
            
            -- Удаляем устаревшие данные
            local min_index = I - cache.Configs.max_history
            for i = min_index - 10, min_index do
                if cache.history[i] then
                    cache.history[i] = nil
                end
            end
        end

        -- D. Получение текущей цены закрытия
        local current_price = Value(I, "C", ds)
        if not current_price then
            return {
                d = "00000000",
                t = "000000",
                rsi = 50,
                rsi1 = 50,
                rsi2 = 50,
                rsi3 = 50,
                gain = 0,
                loss = 0,
                avg_gain = 0,
                avg_loss = 0
            }
        end

        -- E. Инициализация записи для текущего индекса
        if not cache.history[I] then
            cache.history[I] = {
                price = current_price,
                change = 0,
                gain = 0,
                loss = 0,
                avg_gain = 0,
                avg_loss = 0,
                rsi = 50
            }
        end

        -- F. Расчет изменения цены
        local prev_price = cache.prev_price
        if not prev_price then
            -- Для первого бара используем текущую цену как предыдущую
            prev_price = current_price
        end

        local change = current_price - prev_price
        cache.history[I].change = change
        cache.prev_price = current_price  -- Сохраняем для следующего вызова

        -- G. Расчет положительных и отрицательных изменений
        local gain = math_max(change, 0)
        local loss = math_max(-change, 0)

        cache.history[I].gain = gain
        cache.history[I].loss = loss

        -- H. Расчет средних значений
        if I == 1 then
            -- Первый бар
            cache.history[I].avg_gain = gain
            cache.history[I].avg_loss = loss
        else
            local prev_entry = cache.history[I-1] or cache.history[I]
            local bars_count = math_min(I, period)
            
            if method == "SMMA" then
                cache.history[I].avg_gain = smoothing.SMMA(
                    gain, 
                    prev_entry.avg_gain, 
                    period, 
                    bars_count
                )
                
                cache.history[I].avg_loss = smoothing.SMMA(
                    loss, 
                    prev_entry.avg_loss, 
                    period, 
                    bars_count
                )
            else -- EMA
                cache.history[I].avg_gain = smoothing.EMA(
                    gain, 
                    prev_entry.avg_gain, 
                    period
                )
                
                cache.history[I].avg_loss = smoothing.EMA(
                    loss, 
                    prev_entry.avg_loss, 
                    period
                )
            end
        end

        -- I. Расчет RSI
        local avg_gain = cache.history[I].avg_gain
        local avg_loss = cache.history[I].avg_loss
        
        local rs = (avg_loss > 1e-5) and (avg_gain / avg_loss) or 0
        local rsi = 100 - (100 / (1 + rs))
        
        -- Корректировка граничных значений
        rsi = math_max(0, math_min(100, rsi))
        cache.history[I].rsi = rsi

        -- J. Получение предыдущих значений
        local prev1 = cache.history[I-1] or {rsi = 50}
        local prev2 = cache.history[I-2] or {rsi = 50}
        local prev3 = cache.history[I-3] or {rsi = 50}
        
        -- K. Формирование результата
        local td = ds:T(I)
        local Out = {
            d = get_date(td),
            t = get_time(td),
            rsi = round(rsi, 2),
            rsi1 = round(prev1.rsi, 2),
            rsi2 = round(prev2.rsi, 2),
            rsi3 = round(prev3.rsi, 2),
            gain = round(gain, 4),
            loss = round(loss, 4),
            avg_gain = round(avg_gain, 4),
            avg_loss = round(avg_loss, 4),
            _cache = cache.history[I]
        }
        Wilder.Log( tostring(I)..') '.. Out.d ..' / '.. Out.t 
        ..'; rsi = ' .. tostring(Out.rsi) 
        ..'; rsi1 = ' .. tostring(Out.rsi1) 
        ..'; rsi2 = ' .. tostring(Out.rsi2) 
        ..'; rsi3 = ' .. tostring(Out.rsi3) 

        ..'; gain = ' .. tostring(Out.gain) 
        ..'; loss = ' .. tostring(Out.loss)
        
        --..'; atr = ' .. tostring(Out.atr) 
        ..'; avg_gain = ' .. tostring(Out.avg_gain) 
        ..'; avg_loss = ' .. tostring(Out.avg_loss) 

        --..'; trend = ' .. tostring(Out.trend)
        --..'; trend1 = ' .. tostring(Out.trend1)
        --..'; trend2 = ' .. tostring(Out.trend2)

        --..'; signal = ' .. tostring(Out.signal)
        --..'; signal1 = ' .. tostring(Out.signal1)
        --..'; signal2 = ' .. tostring(Out.signal2)
        )--[[--]]
        cache.initialized = true

        return Out
    end
end

ADX («Индекс направления движения усредненной цены»)
Индикатор ADX (Average Directional Movement Index) предназначен для определения направления движения среднего значения цены на основе сравнения двух индикаторов направленности 
* +DI (положительного изменения цены) и 
* -DI (отрицательного изменения цены), 
построенных по 14 периодам. 
По рекомендации автора индикатора Уэллса Уайлдера преобладание линии +DI над -DI является сигналом «покупать», и «продавать» если значение -DI поднимается выше значения +DI.

Вычисление:
ADXj = EMA (DXj , N), Где DXj вычисляется следующим образом: 

DXj = |(+DIj - -DIj)| / (+DIj + -DIj) * 100

+DIj = EMA (+SDIj , N)
-DIj = EMA (-SDIj , N)

+SDIj = +DMj / TRj * 100 если TRj <> 0, иначе +SDIj = 0
-SDIj = -DMj / TRj * 100 если TRj <> 0, иначе -SDIj = 0

TRj = max(|HIGHj - LOWj|, |HIGHj - CLOSEj-1|, |LOWj - CLOSE j-1|)

+DMj = |HIGHj - HIGHj-1| если HIGHj > HIGHj-1, иначе +DMj = 0
-DMj = |LOWj-1 - LOWj| если LOWj < LOWj-1, иначе -DMj = 0

если +DMj > -DMj, то -DMj = 0
если -DMj > +DMj, то +DMj =0
если +DMj = -DMj, то +DMj =0, -DMj =0

где:
CLOSE — цена закрытия; 
LOW — минимальная цена интервала; 
HIGH — максимальная цена интервала.
Значения индикаторов +DI и –DI учитываются с двумя знаками после запятой. 
Параметры настройки: 
«Кол-во периодов» - количество периодов N для расчета MA. 
«Метод» - метод расчета МА (Simple, Exponential, Vol.Adjusted, Smoothed), по умолчанию используется метод «Exponential». 
«Цвет +DI» - выбор цвета линии +DI. 
«Цвет -DI» - выбор цвета линии -DI.

 -- Получение значений индикаторов
        local rsi_val = rsi(I, {period = period_rsi}, ds)
        local adx_val, plusDI, minusDI = adx(I, {di_len = period_adx, adx_len = period_adx}, ds)
        local ema_val = ema(I, {period = period_ema}, ds)
        local price = C(I) or 0
        -- Определение рыночной фазы
        local market_phase
        if adx_val > 25 and plusDI > minusDI 
      --and price > ema_val 
      then
            market_phase = "uptrend"
        elseif adx_val > 25 and minusDI > plusDI 
      --and price < ema_val 
      then
            market_phase = "downtrend"
        else
            market_phase = "range"
        end

        -- Сигналы управления
        local signal = 0

        -- Правило 2: Не торгуем в флэте
        if market_phase == "range" then
            if position ~= 0 then
                signal = -position -- Закрытие позиции
            end
            return signal
        end

        -- Длинные позиции
        if market_phase == "uptrend" then
            -- Сигнал на покупку (Правило 3)
            if position <= 0 and 
               price > ema_val and 
               adx_val > prev_adx and 
               rsi_val < 75 then
                signal = 1
            end

            -- Выход из лонга (Правило 4)
            if position == 1 and 
              (rsi_val > 75 or adx_val < prev_adx) then
                signal = -1
            end
        end

        -- Короткие позиции
        if market_phase == "downtrend" then
            -- Сигнал на продажу (Правило 5)
            if position >= 0 and 
               price < ema_val and 
               adx_val > prev_adx and 
               rsi_val > 25 then
                signal = -1
            end

            -- Выход из шорта (Правило 6)
            if position == -1 and 
              (rsi_val < 25 or adx_val < prev_adx) then
                signal = 1
            end
        end

        -- Обновление состояния
        prev_adx = adx_val or 0
        position = position + signal
        
        -- Ограничение позиции [-1, 0, 1]
        position = math.max(-1, math.min(1, position))