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

function _G.Init()
    PlotLines = Algo(_G.Settings)
    return 1
end
function _G.OnChangeSettings()
    _G.Init()
end

function Cached.Roofing_Filter(FSettings, ds)

    -- Параметры
    local ds = ds or nil
    local FSettings = FSettings or {}
    local v_t = FSettings.v_t or 'C'
    local P = FSettings.period or 48
    local N = FSettings.N or 10
    local x = FSettings.x or nil

    -- Локальные таблицы для хранения данных между вызовами
    local Price, HP, SSF, Lead = {}, {}, {}, {}
    local alpha1, a1, b1, c2, c3, c1 = 0, 0, 0, 0, 0, 0
    local I1 = 0  -- Индекс предыдущего бара

    -- Функция для ограничения размера таблицы
    local function limit_table_size(tbl, max_size)
        while #tbl > max_size do
            table.remove(tbl, 1)
        end
    end

    return function(I)
        -- Текущая цена
        local p0 = x or Value(I, v_t, ds) or 0

        -- Проверка смены бара
        local newbar = I > I1
        if newbar then
            -- Обновление индекса бара
            I1 = I

            -- Инициализация на первом баре
            if I == 1 then
                Price[I], HP[I], SSF[I], Lead[I] = p0, 0, 0, 0
                local fi = (0.707 * 2 * math.pi / P)
                alpha1 = (math.cos(fi) + math.sin(fi) - 1) / math.cos(fi)
                a1 = math.exp(-1.41421356 * math.pi / N)
                b1 = 2 * a1 * math.cos(1.41421356 * math.pi / N)
                c2, c3, c1 = b1, -a1 * a1, 1 - c2 - c3
            else
                -- Обновление цены
                Price[I] = p0

                -- Разница цен для выделения высокочастотных компонентов
                local p1 = Price[I - 1] or p0
                local p2 = Price[I - 2] or p1
                local noise = p0 - 2 * p1 + p2

                -- Расчет HP-фильтра
                local hp1 = HP[I - 1] or 0
                local hp2 = HP[I - 2] or hp1
                local hp = (1 - alpha1 / 2) * (1 - alpha1 / 2) * noise + 2 * (1 - alpha1) * hp1 - (1 - alpha1) * (1 - alpha1) * hp2
                HP[I] = hp

                -- Расчет SuperSmoother
                local ssf1 = SSF[I - 1] or 0
                local ssf2 = SSF[I - 2] or ssf1
                local ssf = c1 * (hp + hp1) * 0.5 + c2 * ssf1 + c3 * ssf2
                SSF[I] = ssf

                -- Расчет опережающего сигнала (Lead)
                local lead1 = Lead[I - 1] or 0
                local lead = 2 * ssf - 1 * ssf2
                Lead[I] = lead
            end

            -- Ограничение размера таблиц
            limit_table_size(Price, 3)  -- Храним только последние 3 бара
            limit_table_size(HP, 3)
            limit_table_size(SSF, 3)
            limit_table_size(Lead, 3)
        end

        -- Возвращаемые значения
        return Lead[I] or 0, SSF[I] or 0
    end, Lead, SSF
end

local fAlgo, Lead, SSF = Cached.Roofing_Filter(FSettings, ds)

local last = os.clock()
print = _G.message or print

local sleep = sleep or function(ms)
    last = os.clock()*1000
    while (os.clock()*1000 - last) < ms do
    end
end

local tt1 = {}
local tt2 = {}

local test = function()

    for n = 1,10000 do
        tt1[n] = 100.12345
    end

    print('1. mem '..collectgarbage('count'))

    tt1 = nil

    collectgarbage()
    sleep(10)

    print('2. mem '..collectgarbage('count'))

    for n = 1,10000 do
        tt2[n] = 100.12345
        tt2[n-3] = nil
    end

    print('3. mem '..collectgarbage('count'))

    collectgarbage()

    sleep(10)

    print('4. mem '..collectgarbage('count'))
end

function main()
    test()
    sleep(1000)
end

-- main()