Система принятия решений и/или Нечеткая логика(FuzzyLogic)

--logfile=io.open("C:\\SBERBANK\\QUIK_SMS\\LuaIndicators\\qlua_log.txt", "w")

Settings = {Name = "*iReg",
      bars = 182,
      kstd=2,
      degree = 3, -- 1 linear, 2 parabolic, 3 third-power 
      barsshift=0
   }
-- Пользовательcкие функции
function WriteLog(text)

   logfile:write(tostring(os.date("%c",os.time())).." "..text.."\n")
   logfile:flush()
   LASTLOGSTRING = text

end
----------------------------------------------------------
----------------------------------------------------------
----------------------------------------------------------
function Reg()
            
   local sql_buffer={}
    local sqh_buffer={}
    local fx_buffer={}
   local sx={}
   local calculated_buffer={}
           
    return function(ind, Fsettings)
      
      local Fsettings=(Fsettings or {})
      local index = ind
      local bars = Fsettings.bars or 182
      local kstd = Fsettings.kstd or 2
      local barsshift = Fsettings.barsshift or 0
      local degree = Fsettings.degree or 1
      local index = ind

      local out1 = nil
      local out2 = nil
      local out3 = nil
      
      local p = 0
      local n = 0
      local f = 0
      local qq = 0
      local mm = 0
      local tt = 0
      local ii = 0
      local jj = 0
      local kk = 0
      local ll = 0
      local nn = 0
      local sq = 0
      local i0 = 0
      
      local mi = 0
       local ai={{1,2,3,4}, {1,2,3,4}, {1,2,3,4}, {1,2,3,4}}      
      local b={}
      local x={}
      
      p = bars 
      nn = degree+1
 
      if index == 1 then
         sql_buffer = {}
         sqh_buffer = {}
         fx_buffer = {}
         calculated_buffer = {}
         
         sql_buffer[index]= 0
         sqh_buffer[index]= 0
         fx_buffer[index]= 0

         --- sx 
         sx={}
         sx[1] = p+1
         
         for mi=1, nn*2-2 do
            sum=0
            for n=i0, i0+p do
               sum = sum + math.pow(n,mi)
            end
         sx[mi+1]=sum
         end
         
         return nil
      end
            
      sql_buffer[index] = sql_buffer[index-1]   
      sqh_buffer[index] = sqh_buffer[index-1]   
      fx_buffer[index] = fx_buffer[index-1]
       
      out1 = fx_buffer[bars]
      out2 = sqh_buffer[bars]
      out3 = sql_buffer[bars]

      SetValue(index-bars-barsshift, 1, nil)
        SetValue(index-bars-barsshift, 2, nil)
        SetValue(index-bars-barsshift, 3, nil)
       
      if not CandleExist(index) or index <= bars then
         return nil
      end
        if index < (Size() - barsshift) then return nil end
      if index > (Size() - barsshift) then return nil end
        if calculated_buffer[index] ~= nil then return out1, out2, out3 end
      
       
      --- syx 
      for mi=1, nn do
         sum = 0
         for n=i0, i0+p do
            if CandleExist(index+n-bars) then
               if mi==1 then
                  sum = sum + C(index+n-bars)
               else
                  sum = sum + C(index+n-bars)*math.pow(n,mi-1)
               end
            end
         end
      b[mi]=sum
      end
          
      --- Matrix 
      for jj=1, nn do
         for ii=1, nn do
            kk=ii+jj-1
            ai[ii][jj]=sx[kk]
         end
      end
          
      --- Gauss 
      for kk=1, nn-1 do
         ll=0
         mm=0
         for ii=kk, nn do
            if math.abs(ai[ii][kk])>mm then
               mm=math.abs(ai[ii][kk])
               ll=ii
            end
         end
            
         if ll==0 then
            return nil
         end
         if ll~=kk then

            for jj=1, nn do
               tt=ai[kk][jj]
               ai[kk][jj]=ai[ll][jj]
               ai[ll][jj]=tt
            end
            tt=b[kk]
            b[kk]=b[ll]
            b[ll]=tt
         end
         for ii=kk+1, nn do
            qq=ai[ii][kk]/ai[kk][kk]
            for jj=1, nn do
               if jj==kk then
                  ai[ii][jj]=0
               else
                  ai[ii][jj]=ai[ii][jj]-qq*ai[kk][jj]
               end
            end
            b[ii]=b[ii]-qq*b[kk]
         end
      end
         
       x[nn]=b[nn]/ai[nn][nn]
         
      for ii=nn-1, 1, -1 do
         tt=0
         for jj=1, nn-ii do
            tt=tt+ai[ii][ii+jj]*x[ii+jj]
            x[ii]=(1/ai[ii][ii])*(b[ii]-tt)
         end
      end
         
      ---
      for n=i0, i0+p do
         sum=0
         for kk=1, degree do
            sum = sum + x[kk+1]*math.pow(n,kk)
         end
         fx_buffer[n]=x[1]+sum
            SetValue(index+n-bars, 1, fx_buffer[n])
      end
          
      --- Std 
      sq=0.0
      for n=i0, i0+p do
         if CandleExist(index+n-bars) then
            sq = sq + math.pow(C(index+n-bars)-fx_buffer[n],2)
         end
      end
         
      sq = math.sqrt(sq/(p+1))*kstd

      for n=i0, i0+p do
         sqh_buffer[n]=fx_buffer[n]+sq
         sql_buffer[n]=fx_buffer[n]-sq
            SetValue(index+n-bars, 2, sqh_buffer[n])
            SetValue(index+n-bars, 3, sql_buffer[n])
      end
                  
      SetValue(index-bars, 1, nil)
        SetValue(index-bars, 2, nil)
        SetValue(index-bars, 3, nil)
      
      calculated_buffer[index] = true
      out1 = fx_buffer[bars]
      out2 = sqh_buffer[bars]
      out3 = sql_buffer[bars]
      
      return out1, out2, out3
   
   end
   
end
----------------------------    ----------------------------    ----------------------------
----------------------------    ----------------------------    ----------------------------
----------------------------    ----------------------------    ----------------------------
function FindExistCandle(I)

   local out = I
   
   while not CandleExist(out) and out > 0 do
      out = out -1
   end   
   
   return out
 
end

local myfunc
function Init()
   myfunc = Reg()
   Settings.line=
         {
            {
               Name = "iReg",
               Color = RGB(0, 0, 255),
               Type = TYPE_LINE,
               Width = 2
            },
            {
               Name = "+iReg",
               Color = RGB(0, 128, 0),
               Type = TYPE_LINE,
               Width = 2
            },
            {
               Name = "-iReg",
               Color = RGB(192, 0, 0),
               Type = TYPE_LINE,
               Width = 2
            }
         }
   return #Settings.line
 end
 
function OnCalculate(index)
   
   --WriteLog ("OnCalc() ".."CandleExist("..index.."): "..tostring(CandleExist(index)))

   if Settings.degree > 3 then
      return nil
   end
   
   return myfunc(index, Settings)
 end

 -- Получение значений индикаторов
        local rsi_val = rsi(I, {period = period_rsi}, ds)
        local adx_val, plusDI, minusDI = adx(I, {di_len = period_adx, adx_len = period_adx}, ds)
        local ema_val = ema(I, {period = period_ema}, ds)
        local price = C(I) or 0
        -- Определение рыночной фазы
        local market_phase
        if adx_val > 25 and plusDI > minusDI 
      --and price > ema_val 
      then
            market_phase = "uptrend"
        elseif adx_val > 25 and minusDI > plusDI 
      --and price < ema_val 
      then
            market_phase = "downtrend"
        else
            market_phase = "range"
        end

        -- Сигналы управления
        local signal = 0

        -- Правило 2: Не торгуем в флэте
        if market_phase == "range" then
            if position ~= 0 then
                signal = -position -- Закрытие позиции
            end
            return signal
        end

        -- Длинные позиции
        if market_phase == "uptrend" then
            -- Сигнал на покупку (Правило 3)
            if position <= 0 and 
               price > ema_val and 
               adx_val > prev_adx and 
               rsi_val < 75 then
                signal = 1
            end

            -- Выход из лонга (Правило 4)
            if position == 1 and 
              (rsi_val > 75 or adx_val < prev_adx) then
                signal = -1
            end
        end

        -- Короткие позиции
        if market_phase == "downtrend" then
            -- Сигнал на продажу (Правило 5)
            if position >= 0 and 
               price < ema_val and 
               adx_val > prev_adx and 
               rsi_val > 25 then
                signal = -1
            end

            -- Выход из шорта (Правило 6)
            if position == -1 and 
              (rsi_val < 25 or adx_val < prev_adx) then
                signal = 1
            end
        end

        -- Обновление состояния
        prev_adx = adx_val or 0
        position = position + signal
        
        -- Ограничение позиции [-1, 0, 1]
        position = math.max(-1, math.min(1, position))

2. Пояснение на Конкретной Математике
Возьмём пример: Товар / Деньги.
В учебнике: Это два отдельных показателя. Выручка 10 000 руб. и производство 100 единиц товара. Анализ линейный: «Надо производить больше, чтобы больше продать».
В данном подходе: Мы сразу смотрим на отношение Товар/Деньги = 100 / 10 000 = 0.01.
------------------------ 
2.1 Что это число на самом деле означает?
Это коэффициент окупаемости или «ценность» товара в денежном выражении. Число 0.01 говорит, что 1 рубль выручки «обеспечен» всего 0.01 единицы товара. Это крайне низкая производительность труда или маржинальность.
А если бы отношение было равно 1? Это означало бы идеал: 1 единица товара приносит 1 условную единицу денег. То система работала бы на 100% своей эффективности.