local size = 1000000 local N=1023  local F = {}

local function shiftArray(x)
    F[3] = F[2]    F[2] = F[1]  F[1] = x  end
start = os.clock() for I=1,size do shiftArray(I) end time = 1000000*(os.clock()- start)/size
print("1. вариант 1(мкс):",time)

local index=0;
local function addElement(x) index=(index % 3)+1 F[index] = x end
start = os.clock()  for I=1,size do addElement(I) end time = 1000000*(os.clock()- start)/size
print("2. вариант 1a(мкс):", time)

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 index=0 start= os.clock() for I=1,size do  addElement(I)  end time = 1000000*(os.clock()- start)/size
print("3. вариант 2:(мкс):", time)

---- 3. Простой вариант с переменной currentIndex
local cIndex = 1
local function addElement(x) F[cIndex]=x cIndex=cIndex+1 if cIndex>N then cIndex=1 end end
start = os.clock()  for i= 1, size do   addElement(i) end  time = 1000000*(os.clock()- start)/size
print("4. вариант 3(мкс):", time)

local cIndex=1
local function addElementNK(x) F[cIndex&N]=x cIndex=cIndex + 1 end
start=os.clock() for i = 1, size do    addElementNK(i) end  time = 1000000*(os.clock()- start)/size
print("5. вариант NK(мкс):", time)

local cIndex = 1
start=os.clock() for i = 1, size do F[cIndex&N]=i;cIndex=cIndex+1 end time = 1000000*(os.clock()- start)/size
print("6. вариант NK без функции(мкс):", time)

1. вариант 1(мкс):   0.047
2. вариант 1a(мкс):   0.048
3. вариант 2:(мкс):   0.721
4. вариант 3(мкс):   0.045
5. вариант NK(мкс):   0.04
6. вариант NK без функции(мкс):   0.012
>Exit code: 0

---- 3. Простой вариант с переменной currentIndex
local F = {} for i = 1, 1000 do  F[i]=0 end
size=1000000
local N=1024
local currentIndex = 1
local function addElement(x) F[currentIndex]=x currentIndex=currentIndex+1 if currentIndex>N then currentIndex=1 end return F end
local start_time = os.clock()
for i = 1, size do   addElement(i) end -- повторяем 1 млн.
local end_time = os.clock()
print("4. Время выполнения для варианта 3:", end_time - start_time, "секунд")

local N=1024
local F = {} for i = 1,N do  F[i]=0 end
size=1000000
local currentIndex = 1
local function addElementNK(x) F[currentIndex&(N-1)]=x currentIndex=currentIndex + 1 return F end
local start_time = os.clock()
for i = 1, size do    addElementNK(i) end -- повторяем 1 млн.
local end_time = os.clock()
print("5. Время выполнения для варианта NK:", end_time - start_time, "секунд")

4. Время выполнения для варианта 3:   0.046   секунд
5. Время выполнения для варианта NK:   0.043   секунд

local N=1024
local F = {} for i = 1,N do  F[i]=0 end
size=1000000
local currentIndex = 1
local start_time = os.clock()
for i = 1, size do    F[currentIndex&(N-1)]=i;currentIndex=currentIndex + 1 end -- повторяем 1 млн.
local end_time = os.clock()
print("6. Время выполнения для варианта NK без функции:", end_time - start_time, "секунд")

6. Время выполнения для варианта NK без функции:   0.014   секунд

Время выполнения стек 0(сек):   0.048,0.051
Время выполнения очередь(сек):   0.036,0.051
>Exit code: 0

Время выполнения стек 0(сек):   0.003,0.001
Время выполнения очередь(сек):   0,0.001

1. Время выполнения для варианта 1:   0.005   секунд
2. Время выполнения для варианта 1a:   0.005   секунд
3. Время выполнения для варианта 2:   0.077   секунд
4. Время выполнения для варианта 3:   0.004   секунд
>Exit code: 0

1. Время выполнения для варианта 1:   0.001   секунд
2. Время выполнения для варианта 1a:   0.001   секунд
3. Время выполнения для варианта 2:   0.015   секунд
4. Время выполнения для варианта 3:   0   секунд
>Exit code: 0

local size = 100000 -- 3
 
do ---- 1.
--local F = {0, 0, 0}
local F = {}
for i = 1, size do
    F[i] = 0
end

local start_time = os.clock()
local function shiftArray(x)
    -- Сдвигаем элементы массива
    F[3] = F[2]
    F[2] = F[1]
    F[1] = x -- Записываем новый элемент в конец массива
    return F -- Возвращаем массив целиком (или можете возвращать только F[3], если нужно)
end
for I=1,size do
--print( shiftArray(I), F[1], F[2], F[3] )
shiftArray(I)
end
local end_time = os.clock()
print("1. Время выполнения для варианта 1:", end_time - start_time, "секунд")
end
do --local F = {0, 0, 0}
local F = {}
for i = 1, size do
    F[i] = 0
end

local start_time = os.clock()
local index = 0
local function addElement(x)
    index = (index % 3) + 1
    F[index] = x
   return F
end
for I=1,size do
--print(addElement(I), F[1], F[2], F[3] )
addElement(I)
end
local end_time = os.clock()
print("2. Время выполнения для варианта 1a:", end_time - start_time, "секунд")
end
do ---- 2.
--local F = {0, 0, 0}
local F = {}
for i = 1, size do
    F[i] = 0
end

local start_time = os.clock()
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
for I=1,size do
--print('*',addElement(I), F[1], F[2], F[3] )
addElement(I)
end
local end_time = os.clock()
print("3. Время выполнения для варианта 2:", end_time - start_time, "секунд")
end
do ---- 3. Простой вариант с переменной currentIndex
local F = {}
for i = 1, 1000 do
    F[i] = 0
end

local start_time = os.clock()
local currentIndex = 1
local function addElement(x)
    F[currentIndex] = x
    currentIndex = currentIndex + 1
    if currentIndex > 1000 then
        currentIndex = 1
    end
    return F
end

for i = 1, 100000 do -- Повторяем операцию добавления 100000 раз
    addElement(i)
end

local end_time = os.clock()
print("4. Время выполнения для варианта 3:", end_time - start_time, "секунд")
end
А вот ответы:
1. Время выполнения для варианта 1:   0.009   секунд
2. Время выполнения для варианта 1a:   0.006   секунд
3. Время выполнения для варианта 2:   1.185   секунд
4. Время выполнения для варианта 3:   0.0050000000000001   секунд
>Exit code: 0    Time: 1.768

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 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   shiftArray (x)  local  z = F[ 1 ] F[ 1 ] = F[ 2 ] F[ 2 ] = F[ 3 ] F[ 3 ] = x   return  z  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)  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   function   shiftArray (x)  local  z = F[ 1 ] F[ 1 ] = F[ 2 ] F[ 2 ] = F[ 3 ] F[ 3 ] = x   return  z  end 
---------------------------
 for  I =  1 , 10   do  print (shiftArray(I), F[ 1 ], F[ 2 ], F[ 3 ] )
 end 
-----------------------  
результат:
0   0   0   1
0   0   1   2
0   1   2   3
1   2   3   4
2   3   4   5
3   4   5   6
4   5   6   7
5   6   7   8
6   7   8   9
7   8   9   10
>Exit code: 0

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

- Метод 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

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

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 CycleRowIndex(arr_input, operation)
   -- Пример вызова, есть массив arr:
   -- local currentRow = CycleRowIndex(arr, "current") выдаст текущую строку
   -- local firstRow = CycleRowIndex(arr, "first") выдаст первую строку
   -- local shiftRow = CycleRowIndex(arr, "shift") "сдвинет" строку
    if #arr_input == 0 then
        return nil -- если массив пуст, возвращаем nil
    end
    
    arr_input.currentRow = arr_input.currentRow or 0 -- используем строковый ключ
    local arraySize = #arr_input
    local currentRow

    if operation == "first" then
        local lastRow = arr_input.currentRow
        if lastRow <= arraySize then
            currentRow = 1
        else
            currentRow = ((lastRow) % arraySize) + 1
        end
    elseif operation == "current" then
        currentRow = (arr_input.currentRow) % arraySize
        if currentRow == 0 then
            if arr_input.currentRow >= arraySize then
                currentRow = arraySize
            else
                currentRow = 1
            end
        end
    elseif operation == "shift" then
        currentRow = (arr_input.currentRow) % arraySize + 1
        arr_input.currentRow = arr_input.currentRow + 1
    end
    
    return currentRow
end