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

function detect_position()

    --[[ Проверки статуса заявок (1-й и 2-й биты flags):
    "Активна": bit.band(order.flags, 1) > 0
    "Неактивна" (исполнена либо снята): bit.band(order.flags, 1) == 0
    "Исполнена": bit.band(order.flags, 1) == 0 и bit.band(order.flags, 2) == 0
    "Снята": bit.band(order.flags, 1) == 0 и bit.band(order.flags, 2) > 0

    Нас интересуют два флага:
    OF_ACTIVE = 0x01
    OF_KILL = 0x02
    --]]

    local ord = "orders"
    local max_numorder = getNumberOf("orders")
    
    -- Отслеживаем количество ордеров
    Log:trace('detect_position: отслеживаю размер массива ' 
              .. ' getNumberOf =' .. tostring(max_numorder) 
              .. ' index =' .. tostring(max_numorder-1)
              .. ' / o_index = ' .. tostring(o_index) 
              .. ' save_needed =' .. tostring(save_needed))

    -- Функция для поиска ордеров
    local function myFind(A, C, S, F)
        return (A == ACCOUNT and C == CLASSCODE and S == SECCODE 
                and bit.band(F, 0x2) == 0 and bit.band(F, 0x1) == 0)
    end
    
    -- Поиск ордеров с нужными фильтрами
    local iItems = SearchItems("orders", 0, max_numorder - 1, myFind, "account,class_code,sec_code,flags")

    -- Проверка на пустой результат
    if not iItems or #iItems == 0 then
        Log:trace('ERROR: SearchItems вернул пустой результат')
        return false
    end

    Log:trace('detect_position: всего элементов ' .. tostring(#iItems) .. ' последний ордер: ' .. tostring(iItems[#iItems]))

    -- Если еще не инициализировано
    if initialized == 0 then
        initialized = -1
        return
    end

    -- Обработка ордеров
    for i = o_index, #iItems do
        local order = getItem("orders", iItems[i])
        if not order or type(order) ~= "table" then return false end

        -- Определение флагов состояния ордера
        local OF_ACTIVE = bit.band(order.flags, 1) > 0
        local NOT_ACTIVE = bit.band(order.flags, 1) == 0
        local OF_FILL = bit.band(order.flags, 1) == 0 and bit.band(order.flags, 2) == 0
        local OF_KILL = bit.band(order.flags, 1) == 0 and bit.band(order.flags, 2) > 0
        
        if order.account == ACCOUNT and order.class_code == CLASSCODE and order.sec_code == SECCODE 
            and (OF_FILL or OF_ACTIVE) and not Orders[order.order_num] then

            Orders[order.order_num] = os.time() -- Запоминаем время

            -- Получаем информацию о заказе
            local order_n = order.order_num
            local order_dt = order.datetime
            local order_d = get_date(order_dt) -- Дата
            local order_t = get_time(order_dt) -- Время
            last_tradedate = order_d

            local order_b = order.balance
            local order_q = order.qty - order_b
            local order_p = order.price
            local order_op = bit.band(order.flags, 0x4) == 0 and 'BUY' or 'SELL'

            -- Логирование активных ордеров
            if OF_ACTIVE then
                Log:trace(NAME_OF_STRATEGY .. ' ' .. i .. ' ACTIVE лимитная заявка по ' .. order.sec_code
                    .. ' number: ' .. tostring(order_n)
                    .. ' ' .. tostring(order_d)
                    .. ' ' .. tostring(order_t)
                    .. ' ' .. tostring(order_op)
                    .. ' ' .. tostring(order_q) .. ' (' .. tostring(order_b) .. ')'
                    .. ' ' .. tostring(order_p))
            end

            -- Обработка исполненных ордеров
            if OF_FILL then
                Log:trace(NAME_OF_STRATEGY .. ' ' .. i .. ' Исполнена лимитная заявка по ' .. order.sec_code
                    .. ' ' .. tostring(order_d)
                    .. ' ' .. tostring(order_t)
                    .. ' ' .. tostring(order_op)
                    .. ' ' .. tostring(order_q) .. ' (' .. tostring(order_b) .. ')'
                    .. ' ' .. tostring(order_p)
                    .. ' number: ' .. tostring(order_n))

                local trade_q = 0
                local trade_p = 0
                local exchange_comission = 0

                -- Поиск сделок, соответствующих ордеру
                for trades_i = 0, getNumberOf("trades") - 1 do
                    local trade = getItem("trades", trades_i)

                    if trade.order_num == order_n then
                        last_order_id = order_n

                        local trade_d = get_date(trade.datetime)
                        local trade_t = get_time(trade.datetime)

                        local qq = trade.qty
                        local pp = trade.price

                        trade_q = trade_q + qq
                        trade_p = trade_p + (qq * pp)
                        exchange_comission = exchange_comission + trade.exchange_comission
                    end
                end

                if trade_q ~= 0 then
                    trade_p = trade_p / trade_q
                    exchange_comission = exchange_comission / trade_q
                end

                -- Проверка на рассинхронизацию заявок и сделок
                if order_q ~= trade_q then
                    Log:trace("Рассинхронизация заявок и сделок: " .. tostring(order_n) 
                            .. ", " .. tostring(order_q) .. "/" .. tostring(trade_q))
                    message("Рассинхронизация заявок и сделок: " .. tostring(order_n) 
                            .. ", " .. tostring(order_q) .. "/" .. tostring(trade_q))
                end

                -- Запись в журнал
                Log:trace('Получаю тек. позицию: ' 
                    .. " " .. tostring(pos.dir) 
                    .. ' ' .. tostring(pos.qty)
                    .. ' ' .. tostring(pos.op)
                    .. ' ' .. tostring(pos.cap)
                    .. ' ' .. tostring(pos.be))

                Log:trace('Получаю изменения в позиции: '
                    .. ' ' .. tostring(qcap)
                    .. ' order_op=' .. tostring(order_op)
                    .. ' order_q=' .. tostring(order_q)
                    .. ' order_b=' .. tostring(order_b)
                    .. ' order_p=' .. tostring(order_p)
                    .. ' / trade_q=' .. tostring(trade_q)
                    .. ' trade_p=' .. tostring(trade_p))

                -- Управление позицией
                local log_action = ""
                if pos.dir == "n" then
                    pos.dir, pos.qty, pos.op, pos.cap, pos.be, pos.open = set_position(order_op, trade_q, trade_p)
                    write_journal(order_op, qcap, trade_q, trade_p, trade_datetime)
                    log_action = "Открытие позиции " .. tostring(pos.dir) .. ' ' .. tostring(pos.qty) .. ' ' .. tostring(pos.op)
                    Log:trace(i .. ' ' .. log_action)
                    save_needed = 1
                elseif (pos.dir == "L" and order_op == "BUY") or (pos.dir == "S" and order_op == "SELL") then
                    pos.op = pos.op * pos.qty + trade_p * trade_q
                    pos.qty = pos.qty + trade_q
                    pos.op = pos.op / pos.qty
                    write_journal(order_op, -1, trade_q, trade_p, trade_datetime)
                    log_action = "Наращивание позиции " .. tostring(pos.dir) .. tostring(pos.qty)
                    Log:trace(i .. ' ' .. log_action)
                    save_needed = 1
                else
                    if trade_q == pos.qty then
                        pos.dir, pos.qty, pos.op, pos.cap, pos.be, pos.open = "n", 0, 0, 0, 0, bar.open
                        write_journal(order_op, 0, trade_q, trade_p, trade_datetime)
                        log_action = "Закрытие позиции " .. tostring(pos.dir) .. ' ' .. tostring(pos.qty)
                        Log:trace(i .. ' ' .. log_action)
                    end
                    save_needed = 1
                end
            end
        end
    end
end

--[[ Trade CALLBACK ]]-- -- Вызов колбэка OnTrade, который использует self для контроля и записи данных
--function OnTrade(trade)    tradeManager:OnTrade(trade) end
function OnTrade(trade)

    local key = trade.trans_id
    local i=tonumber(sdelka[0]); 
    
  if working 
  and key and key>0
  and (i==0 and key~=sdelka.id) or (i>0 and sdelka[i][1]~=key)
  --and trade.sec_code==symbol --and trade.class_code==class 
  then
    
    i=i+1;  
    sdelka[0]=i;                         
    sdelka[i]={};                     
    sdelka[i][0]=sdelka[0];
    sdelka[i][1]=trade.trans_id;      
    sdelka[i][2]=get_date(trade.datetime)
    sdelka[i][3]=get_time(trade.datetime)
    
    sdelka[i][4]="B"; if bit.band(trade.flags,4)~=0 then sdelka[i][4]="S"; end;
    local dir = sdelka[i][4]=="B" and 1 or sdelka[i][4]=="S" and -1 or 0;
    sdelka[i][5]=trade.qty*dir;       
    sdelka[i][6]=trade.price;         
    ----- comission 
    sdelka[i][7]=trade.clearing_comission+trade.exchange_comission+trade.tech_center_comission;
    
    sdelka[i][8]=trade.order_num;    
    sdelka[i][9]=trade.trade_num;  
    sdelka[i][10]=trade.sec_code;     
                        
    sdelka.id=trade.trans_id;
    
    Log:info("OnTrade! sdelka "..i .."; "
                                  .."; trans_id="..sdelka[i][1] 
                                  .."; "..sdelka[i][2]
                                  .."; "..sdelka[i][3]
                                  .."; "..sdelka[i][4]
                                  .."; "..sdelka[i][5]
                                  .."; "..sdelka[i][6]
                                  .."; comission="..sdelka[i][7]
                                  .."; onum="..sdelka[i][8]
                                  .."; tnum="..sdelka[i][9]
                                  .."; "..sdelka[i][10]
                                  .."\n"
                                  );
    --local a,v; for a,v in pairs(sdelka[i) do Log:trace( 'OnTrade! sdelka['..i..']['..tostring(a)..'] = '.. tostring(v) ) end;
  end
end;

-- Функция для вычисления кумулятивной функции распределения нормального распределения (N(x))
function norm_cdf(x)
    local t = 1 / (1 + 0.2316419 * math.abs(x))
    local d = 0.3989422804014337 * math.exp(-0.5 * x * x)
    local prob = d * t * (0.319381530 + t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429)))))
    if x >= 0 then
        return 1 - prob
    else
        return prob
    end
end

-- Основная функция для расчета цены опциона по модели Блэка-Шоулза
function black_scholes_call_price(S, K, T, r, sigma)
    local d1 = (math.log(S / K) + (r + 0.5 * sigma * sigma) * T) / (sigma * math.sqrt(T))
    local d2 = d1 - sigma * math.sqrt(T)
    return S * norm_cdf(d1) - K * math.exp(-r * T) * norm_cdf(d2)
end

-- Функция для нахождения подразумеваемой волатильности для одного опциона
function implied_volatility(S, K, T, r, market_price)
    local low = 0.0001
    local high = 2.0
    local tolerance = 0.0001
    local sigma = (low + high) / 2
    local price = black_scholes_call_price(S, K, T, r, sigma)

    -- Итерационный метод поиска
    while math.abs(price - market_price) > tolerance do
        if price < market_price then
            low = sigma
        else
            high = sigma
        end
        sigma = (low + high) / 2
        price = black_scholes_call_price(S, K, T, r, sigma)
    end
    return sigma
end

-- Функция для нахождения подразумеваемых волатильностей для серии опционов
function implied_volatilities_for_series(S, r, options)
    local ivs = {}
    for i, option in ipairs(options) do
        local iv = implied_volatility(S, option.K, option.T, r, option.market_price)
        table.insert(ivs, {K = option.K, T = option.T, implied_volatility = iv})
    end
    return ivs
end

-- Пример использования
local S = 100     -- Текущая цена актива
local r = 0.05    -- Безрисковая процентная ставка (5%)

-- Список опционов с параметрами: Цена исполнения (K), Время до экспирации (T в годах), Рыночная цена опциона (market_price)
local options = {
    {K = 95, T = 30 / 365, market_price = 6},
    {K = 100, T = 30 / 365, market_price = 5},
    {K = 105, T = 30 / 365, market_price = 3.5},
    {K = 110, T = 60 / 365, market_price = 4.5}
}

-- Вычисляем подразумеваемую волатильность для каждого опциона
local ivs = implied_volatilities_for_series(S, r, options)

-- Выводим результаты
for _, iv in ipairs(ivs) do
    print(string.format("Цена исполнения: %.2f, Время до экспирации: %.2f лет, Подразумеваемая волатильность: %.4f%%",
        iv.K, iv.T, iv.implied_volatility * 100))
end

Что получилось:
Подразумеваемая волатильность: 42.0108
Цена исполнения: 95.00, Время до экспирации: 0.08 лет, Подразумеваемая волатильность: 21.5971%
Цена исполнения: 100.00, Время до экспирации: 0.08 лет, Подразумеваемая волатильность: 42.0108%
Цена исполнения: 105.00, Время до экспирации: 0.08 лет, Подразумеваемая волатильность: 46.9254%
Цена исполнения: 110.00, Время до экспирации: 0.16 лет, Подразумеваемая волатильность: 48.9867%

-- Функция для вычисления кумулятивной функции распределения нормального распределения (N(x))
function norm_cdf(x)
    local t = 1 / (1 + 0.2316419 * math.abs(x))
    local d = 0.3989422804014337 * math.exp(-0.5 * x * x)
    local prob = d * t * (0.319381530 + t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429) )))
    if x >= 0 then
        return 1 - prob
    else
        return prob
    end
end

-- Основная функция для расчета цены опциона по модели Блэка-Шоулза
function black_scholes_call_price(S, K, T, r, sigma)
    local d1 = (math.log(S / K) + (r + 0.5 * sigma * sigma) * T) / (sigma * math.sqrt(T))
    local d2 = d1 - sigma * math.sqrt(T)
    return S * norm_cdf(d1) - K * math.exp(-r * T) * norm_cdf(d2)
end

-- Функция для нахождения подразумеваемой волатильности
function implied_volatility(S, K, T, r, market_price)
    local low = 0.0001
    local high = 2.0
    local tolerance = 0.0001
    local sigma = (low + high) / 2
    local price = black_scholes_call_price(S, K, T, r, sigma)

    -- Итерационный метод поиска
    while math.abs(price - market_price) > tolerance do
        if price < market_price then
            low = sigma
        else
            high = sigma
        end
        sigma = (low + high) / 2
        price = black_scholes_call_price(S, K, T, r, sigma)
    end
    return sigma
end

-- Для примера использования
local S = 100          -- Текущая цена актива
local K = 100          -- Цена исполнения
local T = 30 / 365     -- Время до экспирации (в годах)
local r = 0.05         -- Безрисковая процентная ставка (5%)
local market_price = 5 -- Рыночная цена опциона call

local iv = implied_volatility(S, K, T, r, market_price)
print(string.format("Подразумеваемая волатильность: %.4f", iv * 100))

-- Округление для любого числа
    local rounded = math.floor(num * mult + 0.5 *(num >= 0 and 1 or -1)) / mult

print(round(12.345, 2))  -- 12.35
print(round(-12.345, 2)) -- -12.34
print(round(10.0))       -- 10
print(round(10))         -- 10
print(round(nil))        -- nil
print(round("abc"))      -- "abc"

-- Вывод рекомендаций
function Bond:print_recommendations(inflation_rate, expected_rate_change)
    local strategies = self:recommend_strategy(inflation_rate, expected_rate_change)
    print("Рекомендации для облигации:", self.name)
    for _, strategy in ipairs(strategies) do
        print(string.format("- Стратегия: %s", strategy.strategy))
        print(string.format("  Применима: %s", strategy.applicable and "Да" or "Нет"))
        print(string.format("  Рекомендация: %s", strategy.message))
    end
end

-- Пример использования
local myBond = Bond:new("ОФЗ 26207", "ОФЗ-ПД", 1000, 0.07, 950, 5)
local inflation_rate = 0.06   -- Текущая инфляция 6%
local expected_rate_change = -0.01 -- Ожидаемое снижение ставки на 1%

myBond:print_recommendations(inflation_rate, expected_rate_change)

modules\Bond.lua"  1  
Рекомендации для облигации:   ОФЗ 26207
- Стратегия: Сохранение капитала
  Применима: Да
  Рекомендация: Облигация сохраняет капитал при текущей инфляции.
- Стратегия: Стабильный доход
  Применима: Да
  Рекомендация: ОФЗ-ПД подходят для стабильного дохода благодаря фиксированным купонам.
- Стратегия: Заработок на ставках
  Применима: Нет
  Рекомендация: Для заработка на ставках подходят долгосрочные ОФЗ-ПД.
>Exit code: 0    Time: 0.8326

function round(num, idp)
    
    -- Если num некорректное, вернуть как есть
    if not num or type(num) ~= "number" then return num end
   
    -- Если idp не указан, использовать 0 (округление до целого числа)
    idp = idp or 0 
    local mult = 10^idp

    -- Округление для любого числа
    local rounded = math.floor(num * mult + 0.5) / mult

    -- Если число целое, убрать .0
    if rounded == math.floor(rounded) then
        return math.floor(rounded)
    end

    return rounded
end

-- Класс для управления портфелем инвестора на основе двойственного подхода
local DualityPortfolioManager = {}
DualityPortfolioManager.__index = DualityPortfolioManager
-- Конструктор
function DualityPortfolioManager:new()
    local instance = {
        assets = {},          -- Активы
        liabilities = {},     -- Обязательства
        income = 0,           -- Доходы
        expenses = 0,         -- Расходы
        dualityFactor = 1     -- Фактор двойственности (влияет на баланс активов и обязательств)
    }
    setmetatable(instance, DualityPortfolioManager)
    return instance
end
-- Метод для добавления актива
function DualityPortfolioManager:addAsset(name, value)
    self.assets[name] = (self.assets[name] or 0) + value
    self:balanceDuality()
end
-- Метод для удаления актива
function DualityPortfolioManager:removeAsset(name, value)
    if self.assets[name] then
        self.assets[name] = self.assets[name] - value
        if self.assets[name] <= 0 then
            self.assets[name] = nil
        end
    end
    self:balanceDuality()
end
-- Метод для добавления обязательства
function DualityPortfolioManager:addLiability(name, value)
    self.liabilities[name] = (self.liabilities[name] or 0) + value
    self:balanceDuality()
end
-- Метод для удаления обязательства
function DualityPortfolioManager:removeLiability(name, value)
    if self.liabilities[name] then
        self.liabilities[name] = self.liabilities[name] - value
        if self.liabilities[name] <= 0 then
            self.liabilities[name] = nil
        end
    end
    self:balanceDuality()
end
-- Метод для добавления дохода
function DualityPortfolioManager:addIncome(value)
    self.income = self.income + value
end
-- Метод для добавления расхода
function DualityPortfolioManager:addExpense(value)
    self.expenses = self.expenses + value
end
-- Метод для баланса двойственности (самонормировка)
function DualityPortfolioManager:balanceDuality()
    -- Рассчитываем соотношение активов и обязательств
    local totalAssets = self:getTotal(self.assets)
    local totalLiabilities = self:getTotal(self.liabilities)
    
    -- Применяем фактор двойственности для поддержания баланса
    if totalAssets > totalLiabilities then
        self.dualityFactor = totalAssets / totalLiabilities
    elseif totalLiabilities > totalAssets then
        self.dualityFactor = totalLiabilities / totalAssets
    else
        self.dualityFactor = 1
    end
end
-- Метод для получения общей стоимости активов или обязательств
function DualityPortfolioManager:getTotal(t)
    local total = 0
    for _, value in pairs(t) do
        total = total + value
    end
    return total
end
-- Метод для расчета чистой стоимости портфеля
function DualityPortfolioManager:calculateNetWorth()
    local totalAssets = self:getTotal(self.assets)
    local totalLiabilities = self:getTotal(self.liabilities)

    -- Рассчитываем с учетом фактора двойственности
    return (totalAssets - totalLiabilities) * self.dualityFactor
end
-- Метод для получения общей информации о портфеле
function DualityPortfolioManager:getPortfolioSummary()
    return {
        assets = self.assets,
        liabilities = self.liabilities,
        income = self.income,
        expenses = self.expenses,
        netWorth = self:calculateNetWorth(),
        dualityFactor = self.dualityFactor
    }
end

-- Пример использования класса
local investor = DualityPortfolioManager:new()
investor:addAsset("Stock A", 10000)
investor:addAsset("Real Estate", 25000)
investor:addLiability("Mortgage", 15000)
investor:addIncome(5000)
investor:addExpense(2000)

local summary = investor:getPortfolioSummary()
for k, v in pairs(summary) do
    if type(v) == "table" then
        print(k .. ":")
        for asset, value in pairs(v) do
            print("  " .. asset .. ": " .. value)
        end
    else
        print(k .. ": " .. v)
    end
end

------------------------------------------------------------------
----Moving Average SMA, MMA, EMA, WMA, SMMA, VMA
------------------------------------------------------------------

local SMA,MMA,EMA,WMA,SMMA,VMA = "SMA","MMA","EMA","WMA","SMMA","VMA"
local OPEN,HIGH,LOW,CLOSE,VOLUME,MEDIAN,TYPICAL,WEIGHTED,DIFFERENCE,ANY = "O","H","L","C","V","M","T","W","D","A"

--[[Simple Moving Average (SMA)
SMA = sum(Pi) / n]]
local function F_SMA()
   local sum = {}
   local it = {p=0, l=0}
return function (I, P, VT, ds)
   if I == 1 then
      sum = {}
      it = {p=0, l=0}
   end
   if CandleExist(I,ds) then
      if I~=it.p then it={p=I, l=it.l+1} end
      local Ip,Ipp,Ippp = Squeeze(it.l,P),Squeeze(it.l-1,P),Squeeze(it.l-P,P)
      sum[Ip] = (sum[Ipp] or 0) + GetValueEX(it.p,VT,ds)
      if it.l >= P then
         return (sum[Ip] - (sum[Ippp] or 0)) / P
      end
   end
return nil
end
end
--[[Modified Moving Average (MMA)
MMA = (MMAi-1*(n-1) + Pi) / n]]
local function F_MMA() 
   local sum = {}
   local tmp = {pp=nil, p=nil}
   local it = {p=0, l=0}
return function(I, P, VT, ds)
   if I == 1 then
      sum = {}
      tmp = {pp=nil, p=nil}
      it = {p=0, l=0}
   end
   if CandleExist(I,ds) then
      if I~=it.p then 
         it = {p=I, l=it.l+1} 
         tmp.pp = tmp.p
      end
      local Ip,Ipp,Ippp = Squeeze(it.l,P),Squeeze(it.l-1,P),Squeeze(it.l-P,P)
      if it.l <= P + 1 then
         sum[Ip] = (sum[Ipp] or 0) + GetValueEX(it.p,VT,ds)
         if (it.l == P) or (it.l == P + 1) then
            tmp.p = (sum[Ip] - (sum[Ippp] or 0)) / P
         end
      else
         tmp.p = (tmp.pp*(P-1) + GetValueEX(it.p,VT,ds)) / P
      end
      if it.l >= P then
         return tmp.p
      end
   end
return nil
end
end
--[[Exponential Moving Average (EMA)
EMAi = (EMAi-1*(n-1)+2*Pi) / (n+1)]]
local function F_EMA() 
   local tmp = {pp=nil, p=nil}
   local it = {p=0, l=0}
return function(I, P, VT, ds)
   if I == 1 then
      tmp = {pp=nil, p=nil}
      it = {p=0, l=0}
   end
   if CandleExist(I,ds) then
      if I~=it.p then 
         it = {p=I, l=it.l+1} 
         tmp.pp = tmp.p
      end
      if it.l == 1 then
         tmp.p = GetValueEX(it.p,VT,ds)
      else
         tmp.p = (tmp.pp*(P-1) + 2*GetValueEX(it.p,VT,ds)) / (P+1)
      end
      if it.l >= P then
         return tmp.p
      end
   end
return nil
end
end
--[[William Moving Average (WMA)
( Previous WILLMA * ( Period - 1 ) + Data ) / Period]]
local function F_WMA()
   local tmp = {pp=nil, p=nil}
   local it = {p=0, l=0}
return function(I, P, VT, ds)
   if I == 1 then
      tmp = {pp=nil, p=nil}
      it = {p=0, l=0}
   end
   if CandleExist(I,ds) then
      if I~=it.p then 
         it={p=I, l=it.l+1}
         tmp.pp = tmp.p
      end
      if it.l == 1 then
         tmp.p = GetValueEX(it.p,VT,ds)
      else
         tmp.p = (tmp.pp * (P-1) + GetValueEX(it.p,VT,ds)) / P
      end
      if it.l >= P then
         return tmp.p
      end
   end
return nil
end
end
--[[Volume Adjusted Moving Average (VMA)
VMA = sum(Pi*Vi) / sum(Vi)]]
local function F_VMA()
   local sum = {}
   local sum2 = {}
   local it = {p=0, l=0}
return function(I, P, VT, ds)
   if I == 1 then
      sum = {}
      sum2 = {}
      it = {p=0, l=0}
   end
   if CandleExist(I,ds) then
      if I~=it.p then it={p=I, l=it.l+1} end
      local Ip,Ipp,Ippp = Squeeze(it.l,P),Squeeze(it.l-1,P),Squeeze(it.l-P,P)
      sum[Ip] = (sum[Ipp] or 0) + GetValueEX(it.p,VT,ds) * GetValueEX(it.p,VOLUME,ds)
      sum2[Ip] = (sum2[Ipp] or 0) + GetValueEX(it.p,VOLUME,ds)
      if it.l >= P then
         return (sum[Ip] - (sum[Ippp] or 0)) / (sum2[Ip] - (sum2[Ippp] or 0))
      end
   end
return nil
end
end
--[[Smoothed Moving Average (SMMA)
SMMAi = (sum(Pi) - SMMAi-1 + Pi) / n]]
local function F_SMMA()
   local sum = {}
   local sum2 = {}
   local it = {p=0, l=0}
return function(I, P, VT, ds)
   if I == 1 then
      sum = {}
      sum2 = {}
      it = {p=0, l=0}
   end
   if CandleExist(I,ds) then
      if I~=it.p then it={p=I, l=it.l+1} end
      local Ip,Ipp,Ippp = Squeeze(it.l,P),Squeeze(it.l-1,P),Squeeze(it.l-P,P)
      sum[Ip] = (sum[Ipp] or 0) + GetValueEX(it.p,VT,ds)
      if it.l >= P then
         if it.l == P then
            sum2[Ip] = (sum[Ip] - (sum[Ippp] or 0)) / P
         else
            sum2[Ip] = ((sum[Ip] - (sum[Ippp] or 0)) - (sum2[Ipp] or 0)+ GetValueEX(it.p,VT,ds)) / P
         end
         return sum2[Ip]
      end
   end
return nil
end
end

local function CandleExist(I,ds)
return (type(C)=="function" and C(I)~=nil) or
   (type(ds)=="table" and (ds[I]~=nil or (type(ds.Size)=="function" and (I>0) and (I<=ds:Size()))))
end
local function Squeeze(I,P)
   return math.fmod(I-1,P+1)
end
local function ConvertValue(T,...)
local function r(V, R) 
   if R and string.upper(R)== "ON" then R=0 end
   if V and tonumber(R) then
      if V >= 0 then return math.floor(V * 10^R + 0.5) / 10^R
      else return math.ceil(V * 10^R - 0.5) / 10^R end
   else return V end
end
local arg = {...}
arg.n = select('#', ...)
   if arg.n > 0 then
      for i = 1, arg.n do
         arg[i]=arg[i] and r(arg[i] * ((T and T.Multiply) or 1), (T and T.Round) or "off")
      end
      return unpack(arg)
   else return nil end
end
local function GetValueEX(I,VT,ds) 
VT=(VT and string.upper(string.sub(VT,1,1))) or ANY
   if VT == OPEN then         --Open
      return (O and O(I)) or (ds and ds:O(I))
   elseif VT == HIGH then       --High
      return (H and H(I)) or (ds and ds:H(I))
   elseif VT == LOW then      --Low
      return (L and L(I)) or (ds and ds:L(I))
   elseif VT == CLOSE then      --Close
      return (C and C(I)) or (ds and ds:C(I))
   elseif VT == VOLUME then      --Volume
      return (V and V(I)) or (ds and ds:V(I)) 
   elseif VT == MEDIAN then      --Median
      return ((GetValueEX(I,HIGH,ds) + GetValueEX(I,LOW,ds)) / 2)
   elseif VT == TYPICAL then   --Typical
      return ((GetValueEX(I,MEDIAN,ds) * 2 + GetValueEX(I,CLOSE,ds))/3)
   elseif VT == WEIGHTED then   --Weighted
      return ((GetValueEX(I,TYPICAL,ds) * 3 + GetValueEX(I,OPEN,ds))/4) 
   elseif VT == DIFFERENCE then   --Difference
      return (GetValueEX(I,HIGH,ds) - GetValueEX(I,LOW,ds))
   else                     --Any
      return (ds and ds[I])
   end
return nil
end
local function MA() --Moving Average ("MA")
   local T_MA = {[SMA]=F_SMA(),[MMA]=F_MMA(),[EMA]=F_EMA(),[VMA]=F_VMA(),[SMMA]=F_SMMA(),[WMA]=F_WMA()}
return function (I, Fsettings, ds)
   local Fsettings=(Fsettings or {})
   local P = (Fsettings.Period or 14)
   if (P > 0) then
      return T_MA[string.upper(Fsettings.Metod or EMA)](I, P, (Fsettings.VType or CLOSE), ds)
   end
return nil
end
end

local function TR() --True Range ("TR")
   local it = {pp=0, p=0, l=0}
return function (I, ds)
   if I == 1 then
      it = {pp=0, p=0, l=0}
   end
   if CandleExist(I,ds) then
      if I~=it.p then it={pp=it.p, p=I, l=it.l+1} end
      if it.l == 1 then
         return math.abs(GetValueEX(it.p,DIFFERENCE, ds))
      else
         return math.max(math.abs(GetValueEX(it.p,DIFFERENCE, ds)), 
            math.abs(GetValueEX(it.p,HIGH,ds) - GetValueEX(it.pp,CLOSE,ds)), 
            math.abs(GetValueEX(it.pp,CLOSE,ds)-GetValueEX(it.p,LOW,ds)))
      end
   end
return nil
end
end
function ADX() --Average Directional Movement Index ("ADX")
   local pDI_MA=MA()
   local mDI_MA=MA()
   local ADX_MA=MA()
   local f_TR=TR()
   local it = {pp=0, p=0, l=0}
return function (I, Fsettings, ds)
local Fsettings=(Fsettings or {})
local P = (Fsettings.Period or 14)
local M = (Fsettings.Metod or EMA)
if (P>0) then
   if I == 1 then
      if (M==VMA) then M=SMA end
      it = {pp=0, p=0, l=0}
   end
   local i_TR = f_TR(I,ds)
   if CandleExist(I,ds) then
      if I~=it.p then it={pp=it.p, p=I, l=it.l+1} end
      if it.l > 1 then
         if GetValueEX(it.p,HIGH,ds) > GetValueEX(it.pp,HIGH,ds) then
            pDM = math.abs(GetValueEX(it.p,HIGH,ds)-GetValueEX(it.pp,HIGH,ds))
         else pDM = 0 end
         if GetValueEX(it.p,LOW,ds) < GetValueEX(it.pp,LOW,ds) then
            mDM = math.abs(GetValueEX(it.pp,LOW,ds)-GetValueEX(it.p,LOW,ds))
         else mDM = 0 end
         if pDM > mDM then mDM=0 end
         if mDM > pDM then pDM=0 end
         if pDM == mDM then pDM=0 mDM = 0 end
         if i_TR~=0 then pSDI = pDM / i_TR * 100 else pSDI = 0 end
         if i_TR~=0 then mSDI = mDM / i_TR * 100 else mSDI = 0 end
         local pDI = pDI_MA(it.l-1, {Period=P, Metod=M, VType=ANY}, {[it.l-1] = pSDI})
         
         local mDI = mDI_MA(it.l-1, {Period=P, Metod=M, VType=ANY}, {[it.l-1] = mSDI})
         
         if it.l>P and pDI and mDI then
            return ADX_MA(it.l-P, {Period=P, Metod=M, VType=ANY}, {[it.l-P]=math.abs(pDI-mDI)/(pDI+mDI)*100}),pDI,mDI
         else
            return nil,pDI,mDI
         end
      end
   end
end
return nil,nil,nil
end
end

Settings = {
Name = "*ADX (Average Directional Movement Index)", 
Period = 14, 
Metod = "EMA", --(SMA, MMA, EMA, WMA, SMMA, VMA)
line = {{
      Name = "Horizontal line",
      Type = TYPE_LINE, 
      Color = RGB(140, 140, 140)
      },
      {
      Name = "ADX", 
      Type = TYPE_LINE, 
      Color = RGB(0, 162, 232)
      },
      {
      Name = "ADX +DI",
      Type = TYPE_LINE, 
      Color = RGB(0, 206, 0)
      },
      {
      Name = "ADX -DI",
      Type = TYPE_LINE,
      Color = RGB(221, 44, 44)
      }
      },
Round = "off",
Multiply = 1,
Horizontal_line="off"
}
   local func      
function Init() 
   func = ADX()
   return #Settings.line
end
function OnCalculate(Index) 
   return tonumber(Settings.Horizontal_line),ConvertValue(Settings,func(Index, Settings))
end

function main()
    
   --local type = 0
   local firmid = 'SPBFUT'
    local account = 'SPBFUT00hkv'
   
    local symbol_names = {'NGU4' , 'BRQ4' , 'GDU4', 'NGU4' , 'NGX4' ,}
    working = true
   message("Robot started")
   
    local mm = MoneyManagement:new( firmid, account )-- , type
   
    while working do
   
       for _, symbol in ipairs(symbol_names) do
          mm:FuturesHolding(symbol)
      end
      sleep(1000)
   end
end

local MoneyManagement = {}
MoneyManagement.__index = MoneyManagement

function MoneyManagement:new(firmid, account )
    local self = setmetatable({}, MoneyManagement)
    
    self.firmid = firmid
    self.account = account
    self.type = 0
    self.holdings = {}

    return self
end

-- Function to get Futures Holding
function MoneyManagement:FuturesHolding(symbol)
    local holdings = nil --getFuturesHolding(self.firmid, self.account, symbol, self.type) 
    if holdings then
        
   self.holdings = holdings
        self.startbuy = holdings.startbuy or 0
        self.startsell = holdings.startsell or 0
        self.startnet = holdings.startnet or 0
        self.todaybuy = holdings.todaybuy or 0
        self.todaysell = holdings.todaysell or 0
        self.totalnet = holdings.totalnet or 0
        self.openbuys = holdings.openbuys or 0
        self.opensells = holdings.opensells or 0
        self.lused = holdings.cbplused or 0
        self.lplanned = holdings.cbplplanned or 0
        self.varmargin = holdings.varmargin or 0
        self.avrposnprice = holdings.avrposnprice or 0
        self.positionvalue = holdings.positionvalue or 0
        self.real_varmargin = holdings.real_varmargin or 0
        self.total_varmargin = holdings.total_varmargin or 0

        
        local session_status = {
            [0] = 'не определено',
            [1] = 'основная сессия',
            [2] = 'начался промклиринг',
            [3] = 'завершился промклиринг',
            [4] = 'начался основной клиринг',
            [5] = 'основной клиринг: новая сессия назначена',
            [6] = 'завершился основной клиринг',
            [7] = 'завершилась вечерняя сессия'
        }
        self.session_status = session_status[ math.floor(holdings.session_status)]
        if self.session_status ~= 'основная сессия' then
            message('Актуальный статус торговой сессии getFuturesHolding: ' .. holdings.session_status .. ' ' .. self.session_status)
        end
      
    else
        message("Ошибка функции getFuturesHolding, возвращает = " .. tostring(holdings) ..
                     "; self.firmid = " .. tostring(self.firmid) ..
                     "; self.account = " .. tostring(self.account) ..
                     "; symbol = " .. tostring(symbol) ..
                     "; self.type = " .. tostring(self.type)..' '.. type(self.type))
    end
end

    local working = nil
   
function OnStop(stop_flag)
  message(' OnStop: '..'stop_flag = '..tostring(stop_flag) )
  working = false
end

--[[ MAIN LOOP ]]--
function main()
    
   --local type = 0
   local firmid = ''
    local account = ''
   
    local symbol_names = {'NGU4' , 'BRQ4' , 'GDU4', 'NGU4' , 'NGX4' ,}
    working = true
   message("Robot started")
   
    local mm = MoneyManagement:new( firmid, account )-- , type
   
    while working do
   
       for _, symbol in ipairs(symbol_names) do
          mm:FuturesHolding(symbol)
      end
      
   end
end

local MoneyManagement = {}
MoneyManagement.__index = MoneyManagement

function MoneyManagement:new()
    local self = setmetatable({}, WindowCoordinates)
    
-- поставить свои данные

    self.firmid = ''
    self.account = ''
    self.type = 0

    return self
end

-- Function to get Futures Holding
function MoneyManagement:FuturesHolding(symbol)
    local holdings = getFuturesHolding(self.firmid, self.account, symbol, self.type)
    if holdings then
        self.holdings = holdings
        self.startbuy = holdings.startbuy or 0
        self.startsell = holdings.startsell or 0
        self.startnet = holdings.startnet or 0
        self.todaybuy = holdings.todaybuy or 0
        self.todaysell = holdings.todaysell or 0
        self.totalnet = holdings.totalnet or 0
        self.openbuys = holdings.openbuys or 0
        self.opensells = holdings.opensells or 0
        self.lused = holdings.cbplused or 0
        self.lplanned = holdings.cbplplanned or 0
        self.varmargin = holdings.varmargin or 0
        self.avrposnprice = holdings.avrposnprice or 0
        self.positionvalue = holdings.positionvalue or 0
        self.real_varmargin = holdings.real_varmargin or 0
        self.total_varmargin = holdings.total_varmargin or 0

        --self.session_status = math.floor(holdings.session_status) or 0
        local session_status = {
            [0] = 'не определено',
            [1] = 'основная сессия',
            [2] = 'начался промклиринг',
            [3] = 'завершился промклиринг',
            [4] = 'начался основной клиринг',
            [5] = 'основной клиринг: новая сессия назначена',
            [6] = 'завершился основной клиринг',
            [7] = 'завершилась вечерняя сессия'
        }
        self.session_status = session_status[ math.floor(holdings.session_status)]
        if getFuturesHolding ~= 'основная сессия' then
        Log:trace('Актуальный статус торговой сессии getFuturesHolding: ' .. holdings.session_status .. ' ' .. self.session_status)
        end
    else
        Log:info("Ошибка функции getFuturesHolding, возвращает = " .. tostring(holdings) ..
                     "; self.firmid = " .. tostring(self.firmid) ..
                     "; self.account = " .. tostring(self.account) ..
                     "; symbol = " .. tostring(symbol) ..
                     "; self.type = " .. tostring(self.type)..' '.. type(self.type))
    end
end

    local working = nil
   
function OnStop(stop_flag)
  message(' OnStop: '..'stop_flag = '..tostring(stop_flag) )
  working = false
end

--[[ MAIN LOOP ]]--
function main()

    local symbol_names = {
                     'NGU4' 
                  , 'BRQ4' 
                        , 'GDU4'
                   ,
                        }
    working = true
   message("Robot started")
    local mm = MoneyManagement:new()
   
    while working do
   
       for _, symbol in ipairs(symbol_names) do
          mm:FuturesHolding(symbol)
      end
      
   end
end

if self.session_status ~= 'основная сессия' then
        Log:trace('Актуальный статус торговой сессии getFuturesHolding: ' .. holdings.session_status .. ' ' .. self.session_status)
        end

-- Function to get Futures Holding
function MoneyManagement:FuturesHolding(symbol)
    local holdings = getFuturesHolding(self.firmid, self.account, symbol, self.type)
    if holdings then
        self.holdings = holdings
        self.startbuy = holdings.startbuy or 0
        self.startsell = holdings.startsell or 0
        self.startnet = holdings.startnet or 0
        self.todaybuy = holdings.todaybuy or 0
        self.todaysell = holdings.todaysell or 0
        self.totalnet = holdings.totalnet or 0
        self.openbuys = holdings.openbuys or 0
        self.opensells = holdings.opensells or 0
        self.lused = holdings.cbplused or 0
        self.lplanned = holdings.cbplplanned or 0
        self.varmargin = holdings.varmargin or 0
        self.avrposnprice = holdings.avrposnprice or 0
        self.positionvalue = holdings.positionvalue or 0
        self.real_varmargin = holdings.real_varmargin or 0
        self.total_varmargin = holdings.total_varmargin or 0

        --self.session_status = math.floor(holdings.session_status) or 0
        local session_status = {
            [0] = 'не определено',
            [1] = 'основная сессия',
            [2] = 'начался промклиринг',
            [3] = 'завершился промклиринг',
            [4] = 'начался основной клиринг',
            [5] = 'основной клиринг: новая сессия назначена',
            [6] = 'завершился основной клиринг',
            [7] = 'завершилась вечерняя сессия'
        }
        self.session_status = session_status[ math.floor(holdings.session_status)]
        if getFuturesHolding ~= 'основная сессия' then
        Log:trace('Актуальный статус торговой сессии getFuturesHolding: ' .. holdings.session_status .. ' ' .. self.session_status)
        end
    else
        Log:info("Ошибка функции getFuturesHolding, возвращает = " .. tostring(holdings) ..
                     "; self.firmid = " .. tostring(self.firmid) ..
                     "; self.account = " .. tostring(self.account) ..
                     "; symbol = " .. tostring(symbol) ..
                     "; self.type = " .. tostring(self.type)..' '.. type(self.type))
    end
end