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

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))

--logfile=io.open("C:\\SBERBANK\\QUIK_SMS\\LuaIndicators\\qlua_log.txt", "w")

Settings = {Name = "*iReg",
      bars = 182,
      kstd=2,
      degree = 3, -- 1 linear, 2 parabolic, 3 third-power 
      barsshift=0
   }
-- Пользовательcкие функции
function WriteLog(text)

   logfile:write(tostring(os.date("%c",os.time())).." "..text.."\n")
   logfile:flush()
   LASTLOGSTRING = text

end
----------------------------------------------------------
----------------------------------------------------------
----------------------------------------------------------
function Reg()
            
   local sql_buffer={}
    local sqh_buffer={}
    local fx_buffer={}
   local sx={}
   local calculated_buffer={}
           
    return function(ind, Fsettings)
      
      local Fsettings=(Fsettings or {})
      local index = ind
      local bars = Fsettings.bars or 182
      local kstd = Fsettings.kstd or 2
      local barsshift = Fsettings.barsshift or 0
      local degree = Fsettings.degree or 1
      local index = ind

      local out1 = nil
      local out2 = nil
      local out3 = nil
      
      local p = 0
      local n = 0
      local f = 0
      local qq = 0
      local mm = 0
      local tt = 0
      local ii = 0
      local jj = 0
      local kk = 0
      local ll = 0
      local nn = 0
      local sq = 0
      local i0 = 0
      
      local mi = 0
       local ai={{1,2,3,4}, {1,2,3,4}, {1,2,3,4}, {1,2,3,4}}      
      local b={}
      local x={}
      
      p = bars 
      nn = degree+1
 
      if index == 1 then
         sql_buffer = {}
         sqh_buffer = {}
         fx_buffer = {}
         calculated_buffer = {}
         
         sql_buffer[index]= 0
         sqh_buffer[index]= 0
         fx_buffer[index]= 0

         --- sx 
         sx={}
         sx[1] = p+1
         
         for mi=1, nn*2-2 do
            sum=0
            for n=i0, i0+p do
               sum = sum + math.pow(n,mi)
            end
         sx[mi+1]=sum
         end
         
         return nil
      end
            
      sql_buffer[index] = sql_buffer[index-1]   
      sqh_buffer[index] = sqh_buffer[index-1]   
      fx_buffer[index] = fx_buffer[index-1]
       
      out1 = fx_buffer[bars]
      out2 = sqh_buffer[bars]
      out3 = sql_buffer[bars]

      SetValue(index-bars-barsshift, 1, nil)
        SetValue(index-bars-barsshift, 2, nil)
        SetValue(index-bars-barsshift, 3, nil)
       
      if not CandleExist(index) or index <= bars then
         return nil
      end
        if index < (Size() - barsshift) then return nil end
      if index > (Size() - barsshift) then return nil end
        if calculated_buffer[index] ~= nil then return out1, out2, out3 end
      
       
      --- syx 
      for mi=1, nn do
         sum = 0
         for n=i0, i0+p do
            if CandleExist(index+n-bars) then
               if mi==1 then
                  sum = sum + C(index+n-bars)
               else
                  sum = sum + C(index+n-bars)*math.pow(n,mi-1)
               end
            end
         end
      b[mi]=sum
      end
          
      --- Matrix 
      for jj=1, nn do
         for ii=1, nn do
            kk=ii+jj-1
            ai[ii][jj]=sx[kk]
         end
      end
          
      --- Gauss 
      for kk=1, nn-1 do
         ll=0
         mm=0
         for ii=kk, nn do
            if math.abs(ai[ii][kk])>mm then
               mm=math.abs(ai[ii][kk])
               ll=ii
            end
         end
            
         if ll==0 then
            return nil
         end
         if ll~=kk then

            for jj=1, nn do
               tt=ai[kk][jj]
               ai[kk][jj]=ai[ll][jj]
               ai[ll][jj]=tt
            end
            tt=b[kk]
            b[kk]=b[ll]
            b[ll]=tt
         end
         for ii=kk+1, nn do
            qq=ai[ii][kk]/ai[kk][kk]
            for jj=1, nn do
               if jj==kk then
                  ai[ii][jj]=0
               else
                  ai[ii][jj]=ai[ii][jj]-qq*ai[kk][jj]
               end
            end
            b[ii]=b[ii]-qq*b[kk]
         end
      end
         
       x[nn]=b[nn]/ai[nn][nn]
         
      for ii=nn-1, 1, -1 do
         tt=0
         for jj=1, nn-ii do
            tt=tt+ai[ii][ii+jj]*x[ii+jj]
            x[ii]=(1/ai[ii][ii])*(b[ii]-tt)
         end
      end
         
      ---
      for n=i0, i0+p do
         sum=0
         for kk=1, degree do
            sum = sum + x[kk+1]*math.pow(n,kk)
         end
         fx_buffer[n]=x[1]+sum
            SetValue(index+n-bars, 1, fx_buffer[n])
      end
          
      --- Std 
      sq=0.0
      for n=i0, i0+p do
         if CandleExist(index+n-bars) then
            sq = sq + math.pow(C(index+n-bars)-fx_buffer[n],2)
         end
      end
         
      sq = math.sqrt(sq/(p+1))*kstd

      for n=i0, i0+p do
         sqh_buffer[n]=fx_buffer[n]+sq
         sql_buffer[n]=fx_buffer[n]-sq
            SetValue(index+n-bars, 2, sqh_buffer[n])
            SetValue(index+n-bars, 3, sql_buffer[n])
      end
                  
      SetValue(index-bars, 1, nil)
        SetValue(index-bars, 2, nil)
        SetValue(index-bars, 3, nil)
      
      calculated_buffer[index] = true
      out1 = fx_buffer[bars]
      out2 = sqh_buffer[bars]
      out3 = sql_buffer[bars]
      
      return out1, out2, out3
   
   end
   
end
----------------------------    ----------------------------    ----------------------------
----------------------------    ----------------------------    ----------------------------
----------------------------    ----------------------------    ----------------------------
function FindExistCandle(I)

   local out = I
   
   while not CandleExist(out) and out > 0 do
      out = out -1
   end   
   
   return out
 
end

local myfunc
function Init()
   myfunc = Reg()
   Settings.line=
         {
            {
               Name = "iReg",
               Color = RGB(0, 0, 255),
               Type = TYPE_LINE,
               Width = 2
            },
            {
               Name = "+iReg",
               Color = RGB(0, 128, 0),
               Type = TYPE_LINE,
               Width = 2
            },
            {
               Name = "-iReg",
               Color = RGB(192, 0, 0),
               Type = TYPE_LINE,
               Width = 2
            }
         }
   return #Settings.line
 end
 
function OnCalculate(index)
   
   --WriteLog ("OnCalc() ".."CandleExist("..index.."): "..tostring(CandleExist(index)))

   if Settings.degree > 3 then
      return nil
   end
   
   return myfunc(index, Settings)
 end

function algorithms.getADX()
--[[
    Индикатор ADX с +DI и -DI 
    Среда: QUIK, Lua 5.4
    По методике Уэллса Уайлдера (period = 14)
--]]
-- Вспомогательные функции
local function sum(t, start_idx, end_idx)
    local total = 0
    for i = start_idx, end_idx do total = total + (t[i] or 0) end
    return total
end
local function average(t, start_idx, end_idx)
    return sum(t, start_idx, end_idx)/(end_idx - start_idx + 1)
end
    
   -- Локальные буферы для хранения данных
    local TR, plusDM, minusDM = {}, {}, {}
    local smoothedTR, smoothedPlusDM, smoothedMinusDM = {}, {}, {}
    local plusDI, minusDI, DX, ADX = {}, {}, {}, {}
    local initialized = false  -- Флаг инициализации

    return function (I, Fsettings, ds)
        local Fsettings = Fsettings or {}
        local P = Fsettings.Period or 14  -- Период расчета

        -- Инициализация буферов при первом запуске
        if I == 1 or not initialized then
            TR, plusDM, minusDM = {}, {}, {}
            smoothedTR, smoothedPlusDM, smoothedMinusDM = {}, {}, {}
            plusDI, minusDI, DX, ADX = {}, {}, {}, {}
            initialized = true
            return nil, nil, nil
        end

        -- Получение цен текущего и предыдущего бара
        local high = H(I) or 0
        local low = L(I) or 0
        local closePrev = C(I-1) or 0
        local highPrev = H(I-1) or 0
        local lowPrev = L(I-1) or 0

        -- 1. Расчет True Range (TR)
        TR[I] = math.max(
            high - low,
            math.abs(high - closePrev),
            math.abs(low - closePrev)
        )

        -- 2. Расчет Directional Movement (+DM и -DM)
        local upMove = high - highPrev
        local downMove = lowPrev - low
        plusDM[I] = (upMove > downMove and upMove > 0) and upMove or 0
        minusDM[I] = (downMove > upMove and downMove > 0) and downMove or 0

        -- 3. Сглаживание по методу Уайлдера
        if I == P then
            -- Первичное сглаживание (сумма первых P значений)
            smoothedTR[I] = sum(TR, 2, P)  -- TR начинается с 2-го бара
            smoothedPlusDM[I] = sum(plusDM, 2, P)
            smoothedMinusDM[I] = sum(minusDM, 2, P)
        elseif I > P then
            -- Рекуррентное сглаживание
            smoothedTR[I] = smoothedTR[I-1] - (smoothedTR[I-1]/P) + TR[I]
            smoothedPlusDM[I] = smoothedPlusDM[I-1] - (smoothedPlusDM[I-1]/P) + plusDM[I]
            smoothedMinusDM[I] = smoothedMinusDM[I-1] - (smoothedMinusDM[I-1]/P) + minusDM[I]
        end

        -- 4. Расчет Directional Indicators (+DI и -DI)
        if I >= P and smoothedTR[I] and smoothedTR[I] > 0 then
            plusDI[I] = 100 * (smoothedPlusDM[I]/smoothedTR[I])
            minusDI[I] = 100 * (smoothedMinusDM[I]/smoothedTR[I])
            
            -- 5. Расчет Directional Movement Index (DX)
            local di_sum = plusDI[I] + minusDI[I]
            DX[I] = (di_sum ~= 0) and (100 * math.abs(plusDI[I] - minusDI[I])/di_sum) or 0
        end

        -- 6. Расчет ADX (сглаженный DX)
        if I >= 2*P then
            if I == 2*P then
                -- Начальное значение ADX
                ADX[I] = average(DX, P+1, 2*P)  -- Среднее за P периодов
            else
                -- Сглаживание методом Уайлдера
                ADX[I] = (ADX[I-1]*(P-1) + DX[I])/P
            end
        end

        -- Возврат значений (ADX, +DI, -DI)
        return ADX[I] or nil, plusDI[I] or nil, minusDI[I] or nil
    end
end

local function GetValueEX(I, VT, ds)  
       VT = (VT and string.upper(string.sub(VT, 1, 1))) or ANY  
   ...  
   end

   Видимо, это аналог записи:  local p0 = x or Value(I, v_t, ds) or 0;