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

1. Pешение с использованием кольцевого буфера

local F = {0, 0, 0}
local index = 0
local function addElement(x)
    index = (index % 3) + 1
    F[index] = x
   return F
end
for I=1,10 do
print(addElement(I), F[1], F[2], F[3] )
end

2. Вариант. Альтернативное решение
local F = {0, 0, 0}
local function shiftArray(x)
    -- Сдвигаем элементы массива
    F[3] = F[2]
    F[2] = F[1]
    F[1] = x -- Записываем новый элемент в конец массива
    return F -- Возвращаем массив целиком (или можете возвращать только F[1], если нужно)
end

for I=1,10 do
print(shiftArray(I), F[1], F[2], F[3] )
end

local F = {0, 0, 0}
local index = 0
local function addElement(x)
    -- Обновляем текущий индекс с учетом кольцевого буфера
    index = (index % 3) + 1
    -- Вставляем новый элемент в текущий индекс
    F[index] = x
    
    -- Для наглядности выводим текущий массив
    local result = {}
    for i = 1, 3 do
        result[i] = F[(index - i + 3) % 3 + 1]
    end
    return result
end

local F = {0, 0, 0}
local function shiftArray(x)
    -- Сдвигаем элементы массива
    F[3] = F[2]
    F[2] = F[1]
    F[1] = x -- Записываем новый элемент в конец массива
    return F -- Возвращаем массив целиком (или можете возвращать только F[1], если нужно)
end

for I=1,10 do
print(shiftArray(I), F[1], F[2], F[3] )
end

table: 0000000002710d50   1   0   0
table: 0000000002710d50   2   1   0
table: 0000000002710d50   3   2   1
table: 0000000002710d50   4   3   2
table: 0000000002710d50   5   4   3
table: 0000000002710d50   6   5   4
table: 0000000002710d50   7   6   5
table: 0000000002710d50   8   7   6
table: 0000000002710d50   9   8   7
table: 0000000002710d50   10   9   8
>Exit code: 0    Time: 0.3958

2. Альтернативное решение с использованием кольцевого буфера

local F = {0, 0, 0}
local index = 0
local function addElement(x)
    index = (index % 3) + 1
    F[index] = x
   return F
end
for I=1,10 do
print(addElement(I), F[1], F[2], F[3] )
end

table: 00000000025a1150   1   0   0
table: 00000000025a1150   1   2   0
table: 00000000025a1150   1   2   3
table: 00000000025a1150   4   2   3
table: 00000000025a1150   4   5   3
table: 00000000025a1150   4   5   6
table: 00000000025a1150   7   5   6
table: 00000000025a1150   7   8   6
table: 00000000025a1150   7   8   9
table: 00000000025a1150   10   8   9

local F={0,0,0} 
local function shiftArray(x) local x=F[1] F[1]=F[2] F[2]=F[3] F[3]=x  return x end
for I=1,10 do
print(shiftArray(I), F[1], F[2], F[3] )
end
ответы:
0   0   0   0
0   0   0   0
0   0   0   0
0   0   0   0
0   0   0   0
0   0   0   0
0   0   0   0
0   0   0   0
0   0   0   0
0   0   0   0
>Exit code: 0    Time: 0.4064

local Queue = require("QueueClass")  -- класс Queue сохранен в файле QueueClass.lua

Ehlers.ChannelPDF = {}
Ehlers.ChannelPDF.__index = Ehlers.ChannelPDF
function Ehlers.ChannelPDF.new(FSettings, ds)
    local self = setmetatable({}, Ehlers.ChannelPDF)
    
    self.FSettings = FSettings or {}
    self.ds = ds
    self.P = FSettings.period or 4
    self.up = FSettings.up or 1.0
    self.dw = FSettings.dw or -1.0
    
    self.I1 = 0
    self.hh, self.ll = 0, 0
    
    self.Lead = Queue.new()
    
    self:initialize()
    
    return self
end
function Ehlers.ChannelPDF:initialize()
    self.fTransformFisher = self:TransformFisher()
    self.fTransformIFisher = self:TransformIFisher()
    
    self.fFilterSmooth = self:FilterSmooth()
    self.fFilterLead = self:FilterLead()
    
    self.I1 = 0
    self.Lead = Queue.new()
end

function Ehlers.ChannelPDF:FilterSmooth()
    local F = Queue.new()
    return function(I, x)
        if I == 1 then
            F = Queue.new()
            for _ = 1, 3 do F:push_right(0) end
        end
        F:pop_left()
        F:push_right(x)
        local y = 2 * F[1] + F[2] - F[3]
        y = y and (y >= 1 and 0.999 or y <= -1 and -0.999 or x) or y
        return y
    end
end

-- класс двусвязной очереди:

local Queue = {}
Queue.__index = Queue
function Queue.new()
    return setmetatable({first = 0, last = -1}, Queue)
end
function Queue:push_left(value)
    local first = self.first - 1
    self.first = first
    self[first] = value
end
function Queue:pop_left()
    local first = self.first
    if first > self.last then error("queue is empty") end
    local value = self[first]
    self[first] = nil  -- to allow garbage collection
    self.first = first + 1
    return value
end
function Queue:push_right(value)
    local last = self.last + 1
    self.last = last
    self[last] = value
end
function Queue:pop_right()
    local last = self.last
    if self.first > last then error("queue is empty") end
    local value = self[last]
    self[last] = nil  -- to allow garbage collection
    self.last = last - 1
    return value
end
return Queue

-- Метод FilterSmooth
local ChannelPDF={}
function ChannelPDF:FilterSmooth()
    local F = {0, 0, 0}  -- кольцевой буфер на 3 элемента
    local index = 1
    local start = true
    return function(I, x)
        if I == 1 or start then
            F = {0, 0, 0} -- Инициализация значений
            index = 1 -- Инициализация индекса
            start = false
        end
        F[index] = x -- Обновление (новое значение)
        local y = F[index] + 2 * F[(index - 1 - 1) % 3 + 1] + F[(index - 2 - 1) % 3 + 1]
        y = y and (y >= 1 and 0.999 or y <= -1 and -0.999 or x) or y
        index = index % 3 + 1 -- Обновление индекса
        return y
    end
end

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

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