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

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;

-- Было:
function OnStop()
    WORKING_FLAG = false -- Резкий обрыв без очистки
end

-- Стало:
function handleStoppedState()
    cancelAllOrders() -- Гарантированная отмена
    closePositions() -- Корректное закрытие
    releaseResources() -- Контроль утечек
    Log:info("Система остановлена безопасно")
end

function OnInit()
    -- Порядок инициализации важен!
    StateMachine = require("StateMachine")     -- 1. Состояния
    ErrorCollector = require("ErrorCollector") -- 2. Ошибки
    GUI = require("GUI")                       -- 3. Интерфейс
    
    -- Проверка инициализации
    assert(StateMachine, "StateMachine не загружен")
    assert(ErrorCollector, "ErrorCollector не загружен")
    
    -- Конфигурация
    StateMachine:configure({
        transitions = cfg.transitions,
        initialState = "IDLE"
    })
end

-- Тест переходов между состояниями
local function testStateTransitions()
    local sm = StateMachine
    sm:transitionTo("RUNNING")
    assert(sm:isState("RUNNING"), "Ошибка перехода в RUNNING")
    
    sm:transitionTo("ERROR")
    assert(sm:isState("ERROR"), "Ошибка перехода в ERROR")
    
    sm:transitionTo("IDLE")
    assert(not sm:isState("IDLE"), "Недопустимый переход ERROR → IDLE должен быть запрещен")
end

-- Core/Main.lua
function main()
    ConfigManager.load("config.prod.json")
    Logger.init(ConfigManager.get("logging"))
    
    local ok, err = pcall(function()
        StateManager:restore()
        RiskManager:init()
        
        while StateManager:is_active() do
            local signals = SignalGenerator.generate()
            local filtered = RiskManager.filter(signals)
            OrderExecutor.execute_all(filtered)
            
            StateManager:update_metrics()
            ReportManager.send_daily()
            
            sleep(100)
        end
    end)
    
    if not ok then
        Logger:error("Critical failure", {error = err})
        EmergencyShutdown.execute()
    end
end

function main() 
    message('Стратегия 3ТФ запущена: ' ..  CLASS_CODE ..'; '..SEC_CODE )

    DS = {}
    DS.D1 = CreateDataSource(CLASS_CODE, SEC_CODE, INTERVAL_D1)
    DS.H1 = CreateDataSource(CLASS_CODE, SEC_CODE, INTERVAL_H1)
    DS.M1 = CreateDataSource(CLASS_CODE, SEC_CODE, INTERVAL_M1)
    message( 1)..' '.. type(DS.D1) .. ' DS.D1:Size() ' .. tostring(DS.D1:Size()) .. ' DS.H1:Size() ' .. tostring(DS.H1:Size()) .. ' DS.M1:Size() ' .. tostring(DS.M1:Size()) )

    DS.D1 = Source(CLASS_CODE, SEC_CODE, INTERVAL_D1)
    DS.H1 = Source(CLASS_CODE, SEC_CODE, INTERVAL_H1)
    DS.M1 = Source(CLASS_CODE, SEC_CODE, INTERVAL_M1)
    message(2)..' '..  type(DS.D1) .. ' DS.D1:Size() ' .. tostring(DS.D1:Size()) .. ' DS.H1:Size() ' .. tostring(DS.H1:Size()) .. ' DS.M1:Size() ' .. tostring(DS.M1:Size()) )