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

--stopped = false  -- Этот флаг здесь не нужен
function OnStop()
   --stopped = true
   return 5000
end

-- Установки
local Kod_klienta = "10800"; -- нужно поставить свое значение
local Torg_schet = "NL0011100043"; -- нужно поставить свое значение
local CLASS_CODE = "QJSIM" -- Код класса
local SEC_CODE = "SPBE" -- Код бумаги
local Kod_FirM = "NC0011100000" -- Код фирмы
local step_grid = 5

local run = true -- флаг работы скипта
function main()
    
   -- один раз получает шаг цены (так как величина постоянная)
    local step_price = getParamEx(CLASS_CODE, SEC_CODE, "SEC_PRICE_STEP").param_value

  while run do
    --в цикле каждые милисекунды (sleep(10000)) обновляем цену перед расчетом нового уровня
    local Sena = getParamEx(CLASS_CODE, SEC_CODE, "LAST").param_value
    -- Расчет 10 уровней с шагом сетки step_grid = 5
    for i = 1, 10 do
    
        -- расчет сдвига цены (сетка)
      Sena = Sena + i * step_price * step_grid 

      local podgot = {
                        ACCOUNT = Torg_schet,
                        CLIENT_CODE = Kod_klienta,
                        TYPE = "L",
                        TRANS_ID = "1",
                        CLASSCODE = CLASS_CODE,
                        SECCODE = SEC_CODE,
                        ACTION = "NEW_ORDER",
                        OPERATION = "B",
                        PRICE = tostring(Sena),
                        QUANTITY = "1"
                        }
      --Отпровляется транзакция
        --if -- Условия для выхода из расчета
          sendTransaction(podgot) 
      --then break; end;
    end
       
   sleep(10000)
  end
end

 
local sec_codes = {'SU26219RMFS4', ...}

 -- infinite loop to compensate for problems with getting the price
        while true do

         for _, sec_code in ipairs(sec_codes) do

            quoteLevel = getQuoteLevel2('TQOB', sec_code)
            if quoteLevel.offer then
                pc = tonumber(quoteLevel.offer[1].price)
            end
            if pc == 0 or pc < 0 or pc == nil then
                co.toLog(sn, '    still nothing...')
                sleep(math.random(1000, 2000))
            else
                break
            end
         end
        end

-- Получаем дату и время
local sysdate = os.sysdate()
-- Создаем строку временной метки с точностью до микросекунд
local timestamp = string.format("%04d-%02d-%02d %02d:%02d:%02d.%03d.%03d", sysdate.year, sysdate.month, sysdate.day, sysdate.hour, sysdate.min, sysdate.sec, sysdate.ms, sysdate.mcs)
-- Выводим временную метку
print("Timestamp with microsecond precision:", timestamp)

---------------------------------
-- Константы для правила трех сигм
---------------------------------
local mean_bid = 0   -- Среднее значение ликвидности Bid (можно обновлять)
local std_bid = 0.3  -- Стандартное отклонение ликвидности Bid
local mean_ask = 0   -- Среднее значение ликвидности Ask (можно обновлять)
local std_ask = 0.3  -- Стандартное отклонение ликвидности Ask

local sigma_threshold = 3  -- Граница трех сигм

---------------------------------
-- Функция проверки трех сигм
---------------------------------
function check_three_sigma(bid_liq, ask_liq)
    local bid_outlier = (bid_liq > mean_bid + sigma_threshold * std_bid) or (bid_liq < mean_bid - sigma_threshold * std_bid)
    local ask_outlier = (ask_liq > mean_ask + sigma_threshold * std_ask) or (ask_liq < mean_ask - sigma_threshold * std_ask)

    return bid_outlier, ask_outlier
end

---------------------------------
-- Создаем нечеткую систему
---------------------------------
local fuzzy = luafuzzy()

---------------------------------
-- Входные переменные (нормализованная ликвидность)
---------------------------------
-- Ликвидность Bid
local bid_liq = fuzzy:addinp('bid_liq', -1, 1)
bid_liq:addlingvar('low', gaussmf, { 0.3, -1.0 })  
bid_liq:addlingvar('medium', gaussmf, { 0.3, 0.0 }) 
bid_liq:addlingvar('high', gaussmf, { 0.3, 1.0 })  

-- Ликвидность Ask
local ask_liq = fuzzy:addinp('ask_liq', -1, 1)
ask_liq:addlingvar('low', gaussmf, { 0.3, -1.0 })  
ask_liq:addlingvar('medium', gaussmf, { 0.3, 0.0 }) 
ask_liq:addlingvar('high', gaussmf, { 0.3, 1.0 })  

---------------------------------
-- Выходная переменная (решение)
---------------------------------
local decision = fuzzy:addout('decision', 0, 10)
decision:addlingvar('sell', trimf, { 0, 2, 4 })   
decision:addlingvar('hold', trimf, { 3, 5, 7 })  
decision:addlingvar('buy', trimf, { 6, 8, 10 })  

---------------------------------
-- Правила нечеткой логики
---------------------------------
-- 1. Если Bid высокий и Ask низкий > Покупка
local r1 = fuzzy:addrule(1, 'andmethod')
r1:addpremise(false, 'bid_liq', 'high')
r1:addpremise(false, 'ask_liq', 'low')
r1:addimplic(false, 'decision', 'buy')

-- 2. Если Bid низкий и Ask высокий > Продажа
local r2 = fuzzy:addrule(1, 'andmethod')
r2:addpremise(false, 'bid_liq', 'low')
r2:addpremise(false, 'ask_liq', 'high')
r2:addimplic(false, 'decision', 'sell')

-- 3. Если Bid и Ask средние > Удержание позиции
local r3 = fuzzy:addrule(1, 'andmethod')
r3:addpremise(false, 'bid_liq', 'medium')
r3:addpremise(false, 'ask_liq', 'medium')
r3:addimplic(false, 'decision', 'hold')

---------------------------------
-- Функция получения торгового решения с учетом трех сигм
---------------------------------
function get_trade_decision(bid_norm, ask_norm)
    -- Проверяем выбросы по правилу трех сигм
    local bid_outlier, ask_outlier = check_three_sigma(bid_norm, ask_norm)

    if bid_outlier and ask_outlier then
        if bid_norm > 0 and ask_norm < 0 then
            return "STRONG BUY (3-sigma)"
        elseif bid_norm < 0 and ask_norm > 0 then
            return "STRONG SELL (3-sigma)"
        end
    end

    -- Если выбросов нет, используем нечеткую логику
    local result = fuzzy:solve(bid_norm, ask_norm)

    if result < 4 then
        return "SELL"
    elseif result > 6 then
        return "BUY"
    else
        return "HOLD"
    end
end

---------------------------------
-- Пример использования в QUIK
---------------------------------
local bid_liq_value = 0.9  -- Пример нормализованной ликвидности Bid
local ask_liq_value = -0.9  -- Пример нормализованной ликвидности Ask

local decision = get_trade_decision(bid_liq_value, ask_liq_value)
print("Торговое решение: " .. decision)

-- Пытаемся загрузить библиотеку
            local fuzzy;
            local success, err = pcall(dofile, path..'\\luafuzzy.lua')
            if not success then
                Log:error("Ошибка при загрузке файла luafuzzy: " .. err)
            else
                -- Если библиотека успешно загружена, используем её
                local fuzzy = luafuzzy()
                Log:info("Библиотека luafuzzy успешно загружена!")
            end

    while WORKING_FLAG do

-- основной скрипт (main.lua)
local is_other_script_running = false
-- Функция для проверки, запущен ли другой скрипт
function check_if_other_script_running()
    -- Здесь можно реализовать проверку, например, через файл или глобальную переменную
    -- В данном примере просто используем переменную для демонстрации
    return is_other_script_running
end
-- Функция для запуска другого скрипта
function run_other_script()
    is_other_script_running = true
    dofile("other_script.lua")  -- Запуск другого скрипта
    is_other_script_running = false
end
-- Основной цикл
while true do
    if not check_if_other_script_running() then
        print("Другой скрипт не запущен, запускаю...")
        run_other_script()
    else
        print("Другой скрипт уже запущен.")
    end

    -- Пауза перед следующей проверкой
    os.execute("sleep 1")  -- Для Linux/MacOS
    -- os.execute("timeout /t 1")  -- Для Windows
end

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