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

-- Функция для нормализации цен
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

-- Обернуть функцию в сопрограмму
local my_coroutine = coroutine.wrap(function()
    print("Hello from coroutine")
end)

-- Запустить сопрограмму
coroutine.resume(my_coroutine) -- Выведет "Hello from coroutine"

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

math.randomseed(os.time())-- Модуль для генерации случайных чисел

function generate_trading_time()-- Функция для получения случайного времени торгов
    return math.random(0, 24) -- Возвращает случайное время в часах (0-24)
end
function is_market_open(trading_time)-- Функция для проверки, находится ли рынок в рабочее время
    return trading_time >= 9 and trading_time <= 17
end
function generate_quote()-- Функция для получения случайной котировки
    return {
        bid = math.random(100, 110),
        ask = math.random(110, 120),
        volume = math.random(1000, 5000)
    }
end
    local threshold = 110
function generate_event(quote)-- Функция для генерации события "купить" или "продать"
    if quote.bid > threshold then
        return "buy"
    else
        return "sell"
    end
end
--function execute_trade(event)-- Функция для имитации исполнения сделки
--    print("Исполнена сделка:", event)
--end

----- Функции для тестового примера:
--[[Описание:
  generate_buy_event() и generate_sell_event() генерируют события “купить” и “продать” соответственно на основе предоставленной котировки. События включают тип сделки, цену и количество акций.
  receive_event() имитирует получение события “купить” или “продать” из внешнего источника.
  execute_trade() имитирует исполнение сделки на основе предоставленного события.
--]]

function generate_buy_event(quote)-- Функция для генерации события "купить"
    return {
        type = "buy",
        price = quote.bid,
        quantity = math.random(100, 1000)
    }
end
function generate_sell_event(quote)-- Функция для генерации события "продать"
    return {
        type = "sell",
        price = quote.ask,
        quantity = math.random(100, 1000)
    }
end

function receive_event()-- Функция для имитации получения события "купить" или "продать"
    -- В реальном приложении эта функция должна получать события из очереди событий или другого источника.
    -- Здесь мы имитируем получение события, используя случайное число.
    math.randomseed(os.time())
    local event_type = math.random() < 0.5 and "buy" or "sell"
    local price = math.random(100, 120)
    local quantity = math.random(100, 1000)

    return {
        type = event_type,
        price = price,
        quantity = quantity
    }
end

function execute_trade(event)-- Функция для имитации исполнения сделки
    print("Исполнена сделка:", event.type, event.price, event.quantity)
end

coroutine.wrap(function()-- Отслеживание времени торгов
    while true do
        -- Получить текущее время торгов
        local trading_time = generate_trading_time()

        -- Проверить, находится ли рынок в рабочее время
        if is_market_open(trading_time) then
            -- Перейти в режим торговли
            print("Переход в режим торговли")
        else
            -- Перейти в режим ожидания торгов
            print("Переход в режим ожидания торгов")
        end

        -- Задержка перед следующим обновлением времени торгов
        coroutine.yield()
    end
end)()
coroutine.wrap(function()-- Отслеживание котировок и генерация событий
    while true do
        -- Получить котировку акции
        local quote = generate_quote()

        -- Сгенерировать событие "купить" или "продать"
        local event = generate_event(quote)

        -- Отправить событие
        print("Сгенерировано событие:", event)
    end
end)()
coroutine.wrap(function()-- Исполнение сделок
    while true do
        -- Получить событие "купить" или "продать"
        local event = receive_event() -- В этом примере мы имитируем получение события
        -- Исполнить сделку
        execute_trade(event)
    end
end)()

-- Основной цикл приложения
while true do
    -- Выполнять другие задачи, такие как управление пользовательским интерфейсом
end

end