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

Попробуйте так, должен выводить внутренний бар и внешний бар поглощения. надеюсь ничего не напутал, давно не пользуюсь, но это самый простой и понятный вариант.

function Structure()
    local I1 = 0
    local Structura = 0

    return function(I, FS, ds)
        I = I or 1
        ds = ds or nil
        FS = FS or {}
        local p = FS.persent or 4 -- %
        local wid = FS.wid or 0

        local o0 = Value(I, 'O', ds) or 0
        local c0 = Value(I, 'C', ds) or o0
        local h0 = Value(I, 'H', ds) or c0
        local l0 = Value(I, 'L', ds) or c0

        if I == 1 then
            I1 = 0
            Structura = 0
        end

        local flag = h0 and l0 and c0 and o0 or false

        local o1 = I > 1 and Value(I-1, 'O', ds) or o0
        local c1 = I > 1 and Value(I-1, 'C', ds) or c0
        local h1 = I > 1 and Value(I-1, 'H', ds) or h0
        local l1 = I > 1 and Value(I-1, 'L', ds) or l0
        local flag1 = I > 1 and flag and h1 and l1 or false

        local h2 = I > 2 and Value(I-2, 'H', ds) or h1
        local l2 = I > 2 and Value(I-2, 'L', ds) or l1
        local flag2 = I > 2 and h2 and l2 and flag1 and flag or false

        local newbar = I > I1

        -- Определение типов баров
        local up_bar1 = flag2 and h1 > h2 and l1 >= l2 or false
        local down_bar1 = flag2 and l1 < l2 and h1 <= h2 or false
        local inbar1 = flag2 and h1 <= h2 and l1 >= l2 or false
        local outbar1 = flag2 and h1 > h2 and l1 < l2 or false
        local outbar_up1 = outbar1 and c1 > o1 or false
        local outbar_down1 = outbar1 and c1 <= o1 or false

        local outbar0 = flag1 and h0 > h1 and l0 < l1 or false
        local outbar_up0 = outbar0 and c0 > o0 or false
        local outbar_down0 = outbar0 and c0 < o0 or false
        local up_bar0 = flag1 and h0 > h1 and l0 >= l1 or false
        local down_bar0 = flag1 and l0 < l1 and h0 <= h1 or false
        local inbar0 = flag1 and h0 < h1 and l0 > l1 or false

        local event = newbar and (outbar0 or up_bar0 or down_bar0) or false

        local struc = (outbar_up0 or up_bar0) and 1 or (outbar_down0 or down_bar0) and -1 or 0
        local structura = Structura
        Structura = (newbar or event) and Structura + struc or structura

        I1 = I

        return newbar and inbar1 or nil, newbar and outbar1 or nil
   end
end

Settings={};
Settings.Name = "Structure";

local f;
function Init()

f=Structure();
Settings.line = {
{Name = "InBar",Color = RGB(0, 0, 255), Type = TYPE_POINT, Width = 2},
{Name = "OutBar",Color = RGB(255, 0, 255), Type = TYPE_HISTOGRAM, Width = 2},
};
return #Settings.line;

end
function OnCalculate(index)
return f( index,Settings )
end

function Cached.Structure()
    local I1 = 0
    local Structura = 0

    return function(I, FS, ds)
        I = I or 1
        ds = ds or nil
        FS = FS or {}
        local p = FS.persent or 4 -- %
        local wid = FS.wid or 0

        local o0 = Value(I, 'O', ds) or 0
        local c0 = Value(I, 'C', ds) or o0
        local h0 = Value(I, 'H', ds) or c0
        local l0 = Value(I, 'L', ds) or c0

        if I == 1 then
            I1 = 0
            Structura = 0
        end

        local flag = h0 and l0 and c0 and o0 or false

        local o1 = I > 1 and Value(I-1, 'O', ds) or o0
        local c1 = I > 1 and Value(I-1, 'C', ds) or c0
        local h1 = I > 1 and Value(I-1, 'H', ds) or h0
        local l1 = I > 1 and Value(I-1, 'L', ds) or l0
        local flag1 = I > 1 and flag and h1 and l1 or false

        local h2 = I > 2 and Value(I-2, 'H', ds) or h1
        local l2 = I > 2 and Value(I-2, 'L', ds) or l1
        local flag2 = I > 2 and h2 and l2 and flag1 and flag or false

        local newbar = I > I1

        -- Определение типов баров
        local up_bar1 = flag2 and h1 > h2 and l1 >= l2 or false
        local down_bar1 = flag2 and l1 < l2 and h1 <= h2 or false
        local inbar1 = flag2 and h1 <= h2 and l1 >= l2 or false
        local outbar1 = flag2 and h1 > h2 and l1 < l2 or false
        local outbar_up1 = outbar1 and c1 > o1 or false
        local outbar_down1 = outbar1 and c1 <= o1 or false

        local outbar0 = flag1 and h0 > h1 and l0 < l1 or false
        local outbar_up0 = outbar0 and c0 > o0 or false
        local outbar_down0 = outbar0 and c0 < o0 or false
        local up_bar0 = flag1 and h0 > h1 and l0 >= l1 or false
        local down_bar0 = flag1 and l0 < l1 and h0 <= h1 or false
        local inbar0 = flag1 and h0 < h1 and l0 > l1 or false

        local event = newbar and (outbar0 or up_bar0 or down_bar0) or false

        local struc = (outbar_up0 or up_bar0) and 1 or (outbar_down0 or down_bar0) and -1 or 0
        local structura = Structura
        Structura = (newbar or event) and Structura + struc or structura

        I1 = I

        if wid == 0 then
            return Structura
        end
        return struc
    end
end

function BALVAN() 
       
          local Price={}
 
 return function (I, FSettings, ds)

    local ds=ds
    local FSettings=(FSettings or {})
    local P=(FSettings.period or 9)
    local v_t=(FSettings.v_t or 'C')  
    --------------------------------

    if I == 1 then 

       Price={};  

       local info=getDataSourceInfo(); 

       if info then
               interval,symbol,class = info.interval,info.sec_code,info.class_code
               local sec_info = getSecurityInfo(class_code, sec_code)
       end
    end
 end 
end

-- Функция для нормализации цен
local function normalize_prices(prices, step)
    local normalized_prices = {}
    for i, price in ipairs(prices) do
        normalized_prices[i] = price / step
    end
    return normalized_prices
end

calcMean()
    
    local Price = {} -- Инициализируем для хранения таблицу
    local Mean = {}
    
    return function (I, FSettings, ds)
        I = I or 1
        ds = ds or nil
        FSettings = FSettings or {}
        local v_t = FSettings.v_t or 'C'
        local P = FSettings.period or 9
        local max_cache_size = FSettings.max_cache_size or 5 -- Максимальный размер кэша для Mean[I]
      local x = FSettings.x or nil
        
        local p0 = x or (Value(I, v_t, ds) or 0)
        Price[I] = p0 -- сохраняем
        
        if I == 1 then 
            Price[I] = p0
            Mean[I] = p0
        end
        
        -- Освобождаем память от старых значений Price[I]
        if I > P then
            Price[I-P] = nil
        end
        
        local sum = 0
        local n = math.min(I, P) -- Ограничиваем количество значений для усреднения
        for i = n, 1, -1 do
            sum = sum + Price[I-i+1] -- Берем только последние P значений
        end
        
        local mean = sum / n or p0
        Mean[I] = mean
        
        -- Освобождаем память от старых значений Mean[I]
        if #Mean > max_cache_size then
            table.remove(Mean, 1)
        end
        
        return mean
    end
end

-- 1) Запуск программы main в потоке терминала QUIK

-- 2) Запуск сопрограммы в потоке терминала main
local working = true -- Флаг для продолжения цикла
function Robot()

  local events = {} -- Таблица для хранения событий
  local routine = coroutine.create(function()-- Создание сопрограммы для отслеживания событий
    
    while working do -- Отслеживание событий и создание итераций
      
      -- ... (реализация отслеживания событий)
      local conect = coroutine.create(function()-- реализация отслеживания события соединения с сервером
          while working do 
            local event_conect = math.random(1,10) -- print("event_conect",event_conect)
            -- Добавление события в таблицу
            --table.insert(events, { event }) -- Добавляем данные события
            
            -- Если соединение установлено делаю Паузу до следующей итерации, Если нет соединение ждем.
            if event_conect >= 5 then coroutine.yield() else print("No conect?",event_conect) end
          end
      end)
      coroutine.resume(conect)
      -- ... (реализация отслеживания событий)
      local WorkTime = coroutine.create(function()-- реализация отслеживания события Рабочего времени
          while working do
            local event_WorkTime = math.random(1,10)
            --print("event_WorkTime",event_WorkTime)
            -- Добавление события в таблицу
            --table.insert(events, { event }) -- Добавляем данные события
            -- Пауза для отслеживания новых событий
            if event_conect >= 5 then coroutine.yield() else print("No WorkTime?",event_conect) end
          end
      end)
      coroutine.resume(WorkTime)
      
      -- реализация создания итераций для получения рыночной информации и ее обработки
      local event = math.random(1,10) print("event",event)
      -- Добавление события в таблицу
      table.insert(events, { event }) -- Добавляем данные события
      -- Пауза для отслеживания новых рыночных событий
      coroutine.yield()
    end
    
  end)
  
  -- Запуск сопрограммы coroutine.resume(routine)
  
  while working do -- Главный цикл для обработки событий (поток main)
    
    coroutine.resume(routine)-- Заход в сопрограмму для отслеживания событий
    if coroutine.status(routine) == "dead" then -- Проверка статуса сопрограммы
      print("Robot routine finished")
      break 
    end
    for _, event in ipairs(events) do-- Обработка событий из таблицы
      -- ... (реализация обработки событий)
      print("event",event[#event],#event)
      if event[#event] >= 5 then print("Buy") else print("Sell")  end
    end
    events = {} -- Очистка таблицы событий

    -- Заход в сопрограмму для дальнейшего отслеживания событий
    --coroutine.resume(routine)
    
  end
  working = false
end

# Команда меню - Выполнить (F5)
# Скрипт запускается с помошью внутреннего интерпретатора Lua и вывод направляется в встроенную консоль
command.go.*.lua;*.macro=dofile $(FilePath)
command.go.subsystem.*.lua;*.macro=3

# Команда меню - Собрать (F7)
# Скрипт выполняется внешним интерпретатором
command.build.*.lua=lua -e "io.stdout:setvbuf 'no'" "$(FilePath)" $(1) $(2) $(3) $(4)
command.build.*.wlua="$(FilePath)" $(1) $(2) $(3) $(4)
command.build.subsystem.*.wlua=2

# Команда меню - Собрать (F7)
# Скрипт выполняется внешним интерпретатором
command.build.*.lua=lua -e "io.stdout:setvbuf 'no'" "$(FilePath)" $(1) $(2) $(3) $(4)
command.build.*.wlua="$(FilePath)" $(1) $(2) $(3) $(4)
command.build.subsystem.*.wlua=2

# Команда меню - Компилировать (Ctrl+F7) Lua 5.4 
command.compile.*.lua="Lua-5.4.1\luac.exe" -s -o "$(FileName).luac" "$(FileNameExt)"

# Lua 5.4
command.go.*.lua=D:/lua54/lua54.exe -e "io.stdout:setvbuf 'no'" "$(FileNameExt)"

# Команда меню - Собрать (F7)
# выполняем скрипт lua внешним интерпретатором
command.build.*.lua=lua "$(FilePath)"
command.build.*.wlua="$(FilePath)"
command.build.subsystem.*.wlua=2

-- это main() создали основной поток
    -- создается сопрограмма 
    local routine = coroutine.create(Robot)
    while working do
   
      ---Запускается сопрограмма 
      local res, errmsg = coroutine.resume(routine)
      
      --(Обработка заказов (Orders) вызывает на каждой итерации сопрограммы)
      for trans_id, smartorder in pairs(SmartOrder.pool) do
        smartorder:process()
      end
     -- Здесь нет задержки
   end
   
function Robot()--сопрограмма
    
   -- Выполняется сопрограмма
   while working do
        
      for i=1,#sec do
          --... Обрабатываются стратегии
         rule[i] = 'buy'
         if then
             smartorder = 'buy'
              coroutine.yield() -- Переход в основной цикл
         end
      end
      sleep(1000)-- Здесь задержка
   end
end

--Пример реализации алгоритма переключения между задачами в Lua. Планировщик задач извлекает задачи из очереди и выполняет их одну за другой, пока очередь не станет пустой.

--Алгоритм (thread scheduler) в Lua

--1. Первым шагом является создание очереди задач, которая будет хранить задачи, ожидающие выполнения. В Lua это таблица в качестве очереди.
local task_queue = {}

--2. Затем мы создадим несколько функций задач, которые будут выполняться нашим планировщиком задач.
function task1()
    print("Выполнение задачи 1")
end

function task2()
    print("Выполнение задачи 2")
end

function task3()
    print("Выполнение задачи 3")
end

--3. Теперь мы можем добавить наши задачи в очередь задач.
table.insert(task_queue, task1)
table.insert(task_queue, task2)
table.insert(task_queue, task3)

--4. Далее мы реализуем сам планировщик задач. Планировщик будет извлекать задачи из очереди и выполнять их одну за другой.
function thread_scheduler()
    while #task_queue > 0 do
        -- Извлекаем первую задачу из очереди
        local task = task_queue[1]
        table.remove(task_queue, 1)

        -- Выполняем задачу
        task()
    end
end

--5. Наконец, мы запускаем планировщик задач, вызвав функцию thread_scheduler().
thread_scheduler()

--Пример вывода:
--Выполнение задачи 1
--Выполнение задачи 2
--Выполнение задачи 3