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

---------------------------------
-- Fuzzy Operations
---------------------------------

-------------------------------------------------------------------------------
-- Tmin
-------------------------------------------------------------------------------
function tmin(a1,a2)
  if a2 < a1 then
    return a2
  else
    return a1
  end
end

-------------------------------------------------------------------------------
-- Tmax
-------------------------------------------------------------------------------
function tmax(a1,a2)
  if a2 < a1 then
    return a1
  else
    return a2
  end
end

-------------------------------------------------------------------------------
-- Tsum
-------------------------------------------------------------------------------
function tsum(a1,a2)
  --local y = a1 + a2
  return a1 + a2--y -- stop in one(limit)?
end

-------------------------------------------------------------------------------
-- Tprod
-------------------------------------------------------------------------------
function prod(a1,a2)
  return a1*a2
end

---------------------------------
-- Membership Functions (членство)
---------------------------------

-------------------------------------------------------------------------------
--[[-- Gaussian membership function
-- @param x Input value
-- @param params Table of parameters: 
--   - params[1] = standard deviation 
--   - params[2] = mean
-- @return The value of the pertinence
Гауссова функция принадлежности
- @ Параметров х Входное значение
- @ Параметров ПАРАМЕТРЫ Таблица параметров:
--- ПАРАМЕТРЫ [1] = стандартное отклонение
--- ПАРАМЕТРЫ [2] = средняя
- @ Возвращать значение уместности]]
-------------------------------------------------------------------------------
function gaussmf( x, params )
  return math.exp( -((x - params[2])^2)/(2*params[1]^2))
end

-------------------------------------------------------------------------------
--[[-- Trapezoidal membership function
-- @param x Input value
-- @param params Table of parameters(see chart below)
-- @return The value of the pertinence
--
-- pertinency
- Функция принадлежности трапецеидальной
- @ Параметров х Входное значение
- @ Параметров ПАРАМЕТРЫ Таблица параметров (см. таблицу ниже)
- @ Возвращать значение уместности
- уместность]]
--   ^
--   |
--   |  /2+++3\  
--   | /       \
--  -|1---------4-->x
-------------------------------------------------------------------------------
function trapmf( x, params)
  if x > params[1] and x < params[2] then
    return (x-params[1])/(params[2]-params[1])
  elseif x >= params[2] and x < params[3] then
    return 1
  elseif x >= params[3] and x < params[4] then
    return (params[4]-x)/(params[4]-params[3])
  else
    return 0
  end
end

-------------------------------------------------------------------------------
--[[-- Triangular membership function
-- @param x Input value
-- @param params Table of parameters(see chart below)
-- @return The value of the pertinence
--
-- pertinency
- Треугольные функции принадлежности
- @ Параметров х Входное значение
- @ Параметров ПАРАМЕТРЫ Таблица параметров (см. таблицу ниже)
- @ Возвращать значение уместности
- уместность]]
--   ^
--   |
--   |  /2\  
--   | /   \
--  -|1-----3-->x
-------------------------------------------------------------------------------
function trimf( x, params )
  if x > params[1] and x < params[2] then
    return (x-params[1])/(params[2]-params[1])
  elseif x >= params[2] and x < params[3] then
    return  (params[3]-x)/(params[3]-params[2])
  else
    return 0
  end
end

---------------------------------
-- Deffuzification Functions
---------------------------------

-------------------------------------------------------------------------------
-- Centroid deffuzyfication method
-- @param fs A fuzzyset with pairs of x and y like: fs[1].x, fs[1].y
-- @returm Return the geometric center value
-------------------------------------------------------------------------------
function centroid( fs )
  if #fs <= 1 then
    error('invalid number of fuzzyset entries')
  end
  local accxy = 0
  local accy = 0
  for i,v in ipairs(fs) do    
    if v.y > 0 then
      accxy = accxy + v.x*v.y
      accy = accy + v.y
    end
  end
  if accy > 0 then  
    return accxy/accy
  else
    return (fs[1].y-fs[#fs].y)/2
  end
end

---------------------------------
-- Fuzzy Inference System
---------------------------------

-------------------------------------------------------------------------------
 --[[-- Method to solve a fuzzy system
-- @param self The fuzzy system
-- @param ... A vararg list of input values
-- @return A vararg list of output values
Метод решить нечеткой системы
- @ Параметр self нечеткая система
- @ Параметр ... Список переменных аргументов входных значений
- @ Возвращать список VARARG выходных значений]]
-------------------------------------------------------------------------------
local function solvefuzzy( self, ... )
  local fuzzy = self
  local inpvals = {...}
  -- error check
  if #fuzzy.inps <= 0 then error('invalid number of inputs') end
  if #fuzzy.outs <= 0 then error('invalid number of outputs') end
  if #fuzzy.rules <= 0 then error('invalid number of rules') end
  -- solve each input
  for i,inp in ipairs(fuzzy.inps) do
    -- current input value
    local x = inpvals[i]
    
    -- error check
    if x > inp.mx or x < inp.mn then
      error('value ' .. x .. ' out of range for input \'' .. inp.name .. '\'')
    end
    -- save the current value of the function for each lingvar
    for _,lg in pairs(inp.lingvars) do
      lg.value = lg.mf( x, lg.params )
    end
  end

  -- for each rule...
  for ri,r in ipairs(fuzzy.rules) do
    --
    -- Errors Check
    --
    -- range errors check
    if #r.pres <= 0 then error('invalid number of premises') end
    if #r.imps <= 0 then error('invalid number of implications') end
    -- premises errors check
    for pi=1,#r.pres do
      if not fuzzy.inps[r.pres[pi].ifpart] then 
        error('invalid \'if part = '..r.pres[pi].ifpart..'\' for premise '..pi..' of rule ' .. ri) 
      end      
      if not fuzzy.inps[r.pres[pi].ifpart].lingvars[r.pres[pi].ispart] then
        error('invalid \'is part = '..r.pres[pi].ispart..'\' for premise '..pi..' of rule ' .. ri) 
      end
    end
    -- implications errors check
    for ii,imp in ipairs(r.imps) do
      if not fuzzy.outs[imp.thenpart] then 
        error('invalid \'then part = '..imp.thenpart..'\' for implication '..ii..' of rule ' .. ri) 
      end      
      if not fuzzy.outs[imp.thenpart].lingvars[imp.ispart] then 
        error('invalid \'is part = '..imp.ispart..'\' for implication '..ii..' of rule ' .. ri) 
      end      
    end
    -- connection function error check
    if not fuzzy[r.connmethod] then
      error('invalid \'connection method = '..r.connmethod..'\' for rule '..ri..'. (must be \'andmethod\' or \'ormethod\')') 
    end
    --
    -- Calculate the result value for a rule...
    --
    -- retrive the connection function
    local conn = fuzzy[r.connmethod]
    -- result value of premises
    r.value = fuzzy.inps[r.pres[1].ifpart].lingvars[r.pres[1].ispart].value
    -- for each premise...
    for pi=2,#r.pres do
      local v = fuzzy.inps[r.pres[pi].ifpart].lingvars[r.pres[pi].ispart].value
      r.value = conn(v, r.value)
    end
    --
    -- Calculate the resulting fuzzyset for each implication...
    --
    for _,imp in ipairs(r.imps) do
      -- retrive the out's table
      local out = fuzzy.outs[imp.thenpart]
      -- retrive the lingvar fr om the out table
      local lg = out.lingvars[imp.ispart]
      -- save the fuzzyset for each implication
      imp.fuzzyset = {}
      -- compute the step
      local step = (out.mx - out.mn)*fuzzy.step
      -- calculate the resulting fuzzyset
      for i=out.mn,out.mx,step do
        -- computes the mf value for i
        local lgval = lg.mf( i, lg.params )        
        -- compute the implication result
        local v = fuzzy.implicmethod( lgval , r.value )
        -- add the result to the fuzzy set
        table.insert( imp.fuzzyset, { x=i, y=v } )
      end
    end -- end implications
  end -- end rules
  --
  -- Computes output...
  --
  -- result table
  local outvals = {}
  -- solve each output
  for i,out in ipairs(fuzzy.outs) do
    -- clear previews fuzzyset
    out.fuzzyset = nil
    -- for each rule...
    for _,r in ipairs(fuzzy.rules) do
      --
      -- Aggregation
      --
      -- for each implication
      for _,imp in ipairs(r.imps) do
        if out.name == imp.thenpart then
          if not out.fuzzyset then
            out.fuzzyset = {}
            -- copy the first implication fuzzyset
            for k,v in ipairs(imp.fuzzyset) do
              out.fuzzyset[k] = { x=v.x, y=v.y }
            end
          else
            -- calculate the resulting fuzzyset with aggregation method
            for i,v in ipairs(out.fuzzyset) do
              -- computes the new value
              out.fuzzyset[i] = { x=v.x, y = fuzzy.aggregmethod( v.y, imp.fuzzyset[i].y ) }
            end
          end
        end
      end
    end
    --
    -- Defuzzification...
    --
    -- call deffuzyfication method
    out.value = fuzzy.defuzzmethod( out.fuzzyset )
    -- add output value to result table
    table.insert( outvals, out.value )    
  end

  return unpack( outvals )
end

---------------------------------
-- Fuzzy System
---------------------------------
--
-------------------------------------------------------------------------------
--[[-- Method to add a new linguistic variable to a fuzzy input or output
-- @param self The variable's table
-- @param name Name of the variable
-- @param mf The membership function
-- @param params Table of parameters of the membership function
-- @return The lingvar's table
Метод для добавления нового языкового переменной нечеткой входа или выхода
- @ Параметров самостоятельно таблице переменной
- @ Параметров имя Имя переменной
- @ Параметров MF функция принадлежности
- @ Параметров ПАРАМЕТРЫ Таблица параметров функции принадлежности
- @ Вернуться таблицу в lingvar в]]
-------------------------------------------------------------------------------
local function addlingvar( self, name, mf, params )
  local var = self
  local lg = {}
  lg.name = name
  lg.mf = mf
  lg.params = params
  var.lingvars[lg.name] = lg
  return lg  
end

-------------------------------------------------------------------------------
--[[-- Method to add a new input variable to a fuzzy system
-- @param self The fuzzy system table
-- @param name Name of the variable
-- @param mn Lower lim it of values
-- @param mx Upper limit of values
-- @return The variable's table
- Метод, чтобы добавить новую переменную ввода на нечеткой системы
- @ Параметров самостоятельно нечеткой системной таблицы
- @ Параметров имя Имя переменной
- @ Параметров млн. Нижний предел значений
- @ Параметров м Верхний предел значений
- @ Вернуться таблицу переменной]]
-------------------------------------------------------------------------------
local function addinp( self, name, mn, mx )
  local fis = self
  local inp = {}
  inp.name = name
  inp.mn = mn
  inp.mx = mx
  inp.lingvars = {}     
  inp.addlingvar = addlingvar  
  table.insert( fis.inps, inp )
  fis.inps[inp.name] = inp
  return inp
end

-------------------------------------------------------------------------------
--[[-- Method to add a new output variable to a fuzzy system
-- @param self The fuzzy system table
-- @param name Name of the variable
-- @param mn Lower limit of values
-- @param mx Upper limit of values
-- @return The variable's table
Метод для добавления нового выходной переменной к нечеткой системы
- @ Параметров самостоятельно нечеткой системной таблицы
- @ Параметров имя Имя переменной
- @ Параметров млн. Нижний предел значений
- @ Параметров м Верхний предел значений
- @ Вернуться таблицу переменной]]
-------------------------------------------------------------------------------
local function addout( self, name, mn, mx )
  local fis = self
  local out = {}
  out.name = name
  out.mn = mn
  out.mx = mx
  out.lingvars = {}     
  out.addlingvar = addlingvar  
  table.insert( fis.outs, out )
  fis.outs[out.name] = out
  return out
end

-------------------------------------------------------------------------------
--[[-- Method to add a new premise to a rule
-- @param self The rule's table
-- @param neg Flag to informe if the implication output should be negated
-- @param ifpart Name of the input variable
-- @param ispart Name of the linguistic variable of the input
-- @return The premises table
- Метод, чтобы добавить новое помещение, чтобы правило
- @ Параметров самостоятельно таблице в правиле
- @ Параметров нег Флаг, Informe если выход вывод следует быть сведены на нет
- @ Параметров ifpart Имя входной величины
- @ Параметров ispart Название лингвистической переменной входа
- @ Вернуть таблицу помещения]]
-------------------------------------------------------------------------------
local function addpremise( self, neg, ifpart, ispart )
  local rule = self
  local prem = {}
  prem.neg = neg
  prem.ifpart = ifpart
  prem.ispart = ispart
  table.insert( rule.pres, prem )
  return prem
end

-------------------------------------------------------------------------------
--[[-- Method to add a new implication to a rule
-- @param self The rule's table
-- @param neg Flag to informe if the implication output should be negated
-- @param thenpart Name of the output variable
-- @param ispart Name of the linguistic variable of the ouput
-- @return The implication's table--]]
-------------------------------------------------------------------------------
local function addimplic( self, neg, thenpart, ispart )
  local rule = self
  local impl = {}
  impl.neg = neg
  impl.thenpart = thenpart
  impl.ispart = ispart
  table.insert( rule.imps, impl )
  return impl
end

-------------------------------------------------------------------------------
--[[-- Method to add a new rule to a fuzzy sistem
-- @param self The fuzzy system
-- @param weight The weight of the rule
-- @param connmethod The connection method. (must be: 'andmethod' or 'ormethod')
-- @return The rule's table--]]
-------------------------------------------------------------------------------
local function addrule( self, weight, connmethod )
  local fis = self
  local rule = {}
  rule.weight = weight
  rule.connmethod = connmethod
  rule.pres = {}
  rule.imps = {}
  rule.addpremise = addpremise
  rule.addimplic = addimplic
  table.insert( fis.rules, rule )
  return rule
end

-------------------------------------------------------------------------------
-- Create a new fuzzy system
-- @return A new table with the fuzzy system
-------------------------------------------------------------------------------
function luafuzzy()
  -- create new table(создать новую таблицу)
  local fuzzy = {}
  
  -- and method
  fuzzy.andmethod = tmin
  
  -- or method
  fuzzy.ormethod = tmax
  
  -- implication method(метод Смысл)
  fuzzy.implicmethod = tmin
  
  -- aggregation method()
  fuzzy.aggregmethod = tmax
  
  -- deffuzification method
  fuzzy.defuzzmethod = centroid
  
  -- step used to compute a discrete fuzzyset(Шаг используется для вычисления дискретного fuzzyset)
  fuzzy.step = 0.01
  
  -- table os rules
  fuzzy.rules = {}
  
  -- table of inputs
  fuzzy.inps = {}
  
  -- tabla of outputs
  fuzzy.outs = {}
  
  -- method to add a new input
  fuzzy.addinp = addinp
  
  -- method to add a new output
  fuzzy.addout = addout
  
  -- method to add a new rule
  fuzzy.addrule = addrule
  
  -- method to solve the fuzzy inferece system
  fuzzy.solve = solvefuzzy
  
  return fuzzy
end

function List.new()
 --return {first = 0, last = -1}
 return {first = 0, last = 0}
end

local list=List.new()
local length=10; local M=1000--00--00
print("объем начального массива", M, "Кол. элементов в созданном length=",length);
local count1 = collectgarbage("count") -- получаем текущий размер памяти
------------------------------ LIFO
for i=1, M do

print(i, ')','Начальные индексы', 'list.first =', list.first, '; list.last =', list.last )

List.pushlast(list,i)
print(i, ')','Вставил', 'index list.last =', list.last,'; присвоил значение элементa =',list[list.last], '(',collectgarbage("count"),')' )

if i>length then
List.popfirst(list)
print( i, 'Операция - Удаление первого:', ')', 'присвоил индекс первоve элементу =', list.first, 'вернул значение первого элементa =', list[list.first] ,'(',collectgarbage("count"),')' ) --, list.first
end

end
print("LIFO (вариант реализации стека с помощью двусторонней очереди.) ----------------------");
print("начальный объем занятой памяти",count1);

print("число элементов в LIFO list после "..(M).." циклов функции рор=" ..(list.last-list.first))
local countOUT = collectgarbage("count")
print("объем занятой памяти",countOUT);
--------------------------------
collectgarbage("collect")
print("объем занятой памяти после сборщика мусора",collectgarbage("count"));

local lifo=List.new() List.pushlast(lifo,i) List.popfirst(lifo)

local fifo=List.new() List.pushfirst(fifo,i) List.popfirst(fifo)

local list=List.new()
local length=10; local M=1000--00--00
print("объем начального массива", M, "Кол. элементов в созданном length=",length);
local count1 = collectgarbage("count") -- получаем текущий размер памяти
------------------------------ LIFO
for i=1, M do 
 
print(i, ')','Начальные индексы', 'list.first =', list.first, '; list.last =', list.last )

List.pushlast(list,i)
print(i, ')','Вставил', 'index list.last =', list.last,'; присвоил значение элементa =',list[list.last], '(',collectgarbage("count"),')' )

if i>length then 
List.popfirst(list)
print( i, 'Операция - Удаление первого:', ')', 'присвоил индекс первоve элементу =', list.first, 'вернул значение первого элементa =', list[list.first] ,'(',collectgarbage("count"),')' ) --, list.first
end

end
print("LIFO (вариант реализации стека с помощью двусторонней очереди.) ----------------------");
print("начальный объем занятой памяти",count1);

print("число элементов в LIFO list после "..(M).." циклов функции рор=" ..(list.last-list.first))
local countOUT = collectgarbage("count")
print("объем занятой памяти",countOUT);
--------------------------------
collectgarbage("collect")
print("объем занятой памяти после сборщика мусора",collectgarbage("count"));

объем начального массива   1000   Кол. элементов в созданом length=   10
1   )   Начальные индексы   list.first =   0   ; list.last =   0
1   )   Вставил   index list.last =   1   ; присвоил значение элементa =   1   (   27.3759765625   )
2   )   Начальные индексы   list.first =   0   ; list.last =   1
2   )   Вставил   index list.last =   2   ; присвоил значение элементa =   2   (   28.4384765625   )
3   )   Начальные индексы   list.first =   0   ; list.last =   2
3   )   Вставил   index list.last =   3   ; присвоил значение элементa =   3   (   28.5166015625   )
4   )   Начальные индексы   list.first =   0   ; list.last =   3
4   )   Вставил   index list.last =   4   ; присвоил значение элементa =   4   (   28.5634765625   )
5   )   Начальные индексы   list.first =   0   ; list.last =   4
5   )   Вставил   index list.last =   5   ; присвоил значение элементa =   5   (   28.6728515625   )
6   )   Начальные индексы   list.first =   0   ; list.last =   5
6   )   Вставил   index list.last =   6   ; присвоил значение элементa =   6   (   28.7197265625   )
7   )   Начальные индексы   list.first =   0   ; list.last =   6
7   )   Вставил   index list.last =   7   ; присвоил значение элементa =   7   (   28.7666015625   )
8   )   Начальные индексы   list.first =   0   ; list.last =   7
8   )   Вставил   index list.last =   8   ; присвоил значение элементa =   8   (   28.8134765625   )
9   )   Начальные индексы   list.first =   0   ; list.last =   8
9   )   Вставил   index list.last =   9   ; присвоил значение элементa =   9   (   28.9853515625   )
10   )   Начальные индексы   list.first =   0   ; list.last =   9
10   )   Вставил   index list.last =   10   ; присвоил значение элементa =   10   (   29.0146484375   )
11   )   Начальные индексы   list.first =   0   ; list.last =   10
11   )   Вставил   index list.last =   11   ; присвоил значение элементa =   11   (   29.0625   )
11   Операция - Удаление первого:   )   присвоил индекс первоve элементу =   1   вернул значение первого элементa =   1   (   29.1484375   )
.........
1000   )   Начальные индексы   list.first =   989   ; list.last =   999
1000   )   Вставил   index list.last =   1000   ; присвоил значение элементa =   1000   (   51.08203125   )
1000   Операция - Удаление первого:   )   присвоил индекс первоve элементу =   990   вернул значение первого элементa =   990   (   51.109375   )

LIFO (вариант реализации стека с помощью двусторонней очереди.) ----------------------
начальный объем занятой памяти   26.5283203125
число элементов в LIFO list после 1000 циклов функции рор=10
объем занятой памяти   51.28125
объем занятой памяти после сборщика мусора   30.7470703125

local M=1000--0000
local count1 = collectgarbage("count") -- получаем текущий размер памяти
print("начальный объем занятой памяти",count1);
--------------------------
local list=List.new()
for i=1, M do  
List.pushlast(list,i)
print('Вставил', i, 'элемент ',  collectgarbage("count") )

if i>10 then print( 'Удалил первого', List.popfirst(list) , type(list), #list, collectgarbage("count") ) 
--local countI = collectgarbage("count")
end
end
print("число элементов в очереди list после "..M.." циклов функции push="..#list)
local count1 = collectgarbage("count")
print("объем занятой памяти",count1);
--------------------------------
-- for i=1, M do  List.popfirst(list) end
 
print("число элементов в очереди list после "..M.." циклов pop="..#list)
local count1 = collectgarbage("count")
print("объем занятой памяти после сборщика мусора",count1);
collectgarbage("collect")
local count1 = collectgarbage("count") -- получаем текущий размер памяти
print("объем занятой памяти после pop",count1);
------------------------------
collectgarbage("collect") -- выполняем сбор мусора
local count2 = collectgarbage("count") -- получаем размер памяти после сбора
print("объем занятой памяти после сборщика мусора",count1);

начальный объем занятой памяти   35.4248046875
List.pushlast: ; number; ; list.last=0; number; list[last]=1
Вставил   1   элемент    27.283203125
List.pushlast: ; number; ; list.last=1; number; list[last]=2
Вставил   2   элемент    27.404296875
List.pushlast: ; number; ; list.last=2; number; list[last]=3
Вставил   3   элемент    27.556640625
List.pushlast: ; number; ; list.last=3; number; list[last]=4
Вставил   4   элемент    28.677734375
List.pushlast: ; number; ; list.last=4; number; list[last]=5
Вставил   5   элемент    28.830078125
List.pushlast: ; number; ; list.last=5; number; list[last]=6
Вставил   6   элемент    28.951171875
List.pushlast: ; number; ; list.last=6; number; list[last]=7
Вставил   7   элемент    29.134765625
List.pushlast: ; number; ; list.last=7; number; list[last]=8
Вставил   8   элемент    29.255859375
List.pushlast: ; number; ; list.last=8; number; list[last]=9
Вставил   9   элемент    29.376953125
List.pushlast: ; number; ; list.last=9; number; list[last]=10
Вставил   10   элемент    29.5009765625
List.pushlast: ; number; ; list.last=10; number; list[last]=11
Вставил   11   элемент    29.751953125
Удалил первого   1   table   10   29.7802734375
List.pushlast: ; number; ; list.last=11; number; list[last]=12
Вставил   12   элемент    29.9052734375
Удалил первого   2   table   11   29.9345703125
List.pushlast: ; number; ; list.last=12; number; list[last]=13
Вставил   13   элемент    30.0595703125
Удалил первого   3   table   12   30.0888671875
......
Удалил первого   989   table   0   56.8974609375
List.pushlast: ; number; ; list.last=999; number; list[last]=1000
Вставил   1000   элемент    57.0283203125
Удалил первого   990   table   0   57.0576171875

число элементов в очереди list после 1000 циклов функции push=0
объем занятой памяти   57.1650390625
число элементов в очереди list после 1000 циклов pop=0
объем занятой памяти после сборщика мусора   57.263671875
объем занятой памяти после pop   28.4912109375
объем занятой памяти после сборщика мусора   28.4912109375

for i=1,#sec do ----  цикла по бумагам:
for j=1,#tf do   ---- Получаю Тек.index Свечей на всех tf:

Index[i][j]=DS[i][j]:Size()


td[i][j] = DS[i][j]:T( Index[i][j] ); 
bar[i][j][index].d = td[i][j] and get_date(td[i][j]) or nil;---- день один для разных тайфремов
bar[i][j][index].t = td[i][j] and get_time(td[i][j]) or nil;

bar[i][j][index].o = DS[i][j]:O( Index[i][j] ); 
bar[i][j][index].h = DS[i][j]:H( Index[i][j] );
bar[i][j][index].l = DS[i][j]:L( Index[i][j] );

---- ответ от индикатора тоже добавляю
bar[i][j][index].dec=nil;

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

Но массив растет