Quik Lua

работа индикатора заключается в том, чтоб показать ближашие горизонтальные уровни (один снизу, другой сверху) и один наклонный

Settings=              
        {                          
            Name = "Zigzag5",   -- название индикатора
            delta=2,                  -- параметр индикатора                          
            deltaY=1,                  -- параметр индикатора   			
            linedeltaY=0.75,                  -- параметр индикатора   				
            line=                                     
                {                               
                    {  
                        Name = "zigzagline3",
                        Type =TYPE_LINE,
                        Width = 2,
                        Color = RGB(0,255, 0)
                    },
                    {  
                        Name = "upline",
                        Type =TYPE_LINE,
                        Width = 2,
                        Color = RGB(255,0, 0)
                    },
                    {  
                        Name = "lowline",
                        Type =TYPE_LINE,
                        Width = 2,
                        Color = RGB(0,0, 255)
                    },
                    {  
                        Name = "declineline",
                        Type =TYPE_LINE,
                        Width = 2,
                        Color = RGB(255,0, 0)
                    },
                    {  
                        Name = "upline2",
                        Type =TYPE_LINE,
                        Width = 1,
                        Color = RGB(255,0, 0)
                    },
                    {  
                        Name = "lowline2",
                        Type =TYPE_LINE,
                        Width = 1,
                        Color = RGB(0,0, 255)
                    },
                    {  
                        Name = "declineline2",
                        Type =TYPE_LINE,
                        Width = 1,
                        Color = RGB(255,0, 0)
                    }				
                }
       }
	
	
function getradius(x, y)
  return math.sqrt(Settings.deltaY*y*y+x*x)
end

function koef(val)
  return 1 - 1/(1-1/val)
end


function Init()

  vMin = 0
  vMax = 0
  vMinindex = 0
  vMaxindex = 0
  voldMinindex = 0
  voldMaxindex = 0
  upval = 0
  lowval = 0
  upindex = 1
  lowindex = 1  
  veu = nil
  vel = nil
  curfrom = 1
  curto = 1

  return 7
end


function OnCalculate(index)
  local printz = 0
  vsize = Size()	  

  ve = nil
  veu = nil
  vel = nil 
  curv = nil 
  veu2 = nil
  vel2 = nil 
  curv2 = nil  
  
  if index == 1 then
    vMin = C(index)
    vMax = C(index)
    vMinindex = index
    vMaxindex = index
    voldMinindex = index
    voldMaxindex = index
    ve = C(index)  
	  
  else
         
    if voldMaxindex >= voldMinindex then
        
       
	  if C(index) > (1 + Settings.delta/100)*vMin then
         
        vMin = C(index)  
        vMax = C(index) 
        vMaxindex = index
        voldMinindex = vMinindex 
        vFrom = voldMaxindex  
        vTo = vMinindex
        printz = 1		
		
        if (C(vMinindex) > C(vsize)) and (upval > koef(getradius(vsize - vMinindex, C(vMinindex) - C(vsize)))) then
		  upval = koef(getradius(vsize - vMinindex, C(vMinindex) - C(vsize)))
		  upindex = vMinindex
		end
        if (C(vMinindex) < C(vsize)) and (lowval > koef(getradius(vsize - vMinindex, C(vMinindex) - C(vsize)))) then
		  lowval = koef(getradius(vsize - vMinindex, C(vMinindex) - C(vsize)))
		  lowindex = vMinindex
	   end	
	   
	    curfrom = voldMaxindex
	    curto = voldMinindex	  	   
	      	    
      else      
	  
        if vMin > C(index) then
          vMin = C(index)
          vMinindex = index
          vFrom = voldMaxindex      
          vTo = index
          printz = 0
		  curto = index		
        else
          vFrom = vMinindex 
          vTo = index
          printz = 0
        end 		
	  
	    curfrom = voldMaxindex	
		
      end
	 
 	 
    else
     
    if voldMaxindex <= voldMinindex then
	  
      if C(index) < (1 - Settings.delta/100)*vMax then
	     	  
        vMax = C(index) 
        vMin = C(index)  
        vMinindex = index
        voldMaxindex = vMaxindex
        vFrom = voldMinindex
        vTo = vMaxindex
        printz = 1
	
        if (C(vMaxindex) > C(vsize)) and (upval > koef(getradius(vsize - vMaxindex, C(vMaxindex) - C(vsize)))) then
		  upval = koef(getradius(vsize - vMaxindex, C(vMaxindex) - C(vsize)))
		  upindex = vMaxindex
		end                   
        if (C(vMaxindex) < C(vsize)) and (lowval > koef(getradius(vsize - vMaxindex, C(vMaxindex) - C(vsize)))) then
		  lowval = koef(getradius(vsize - vMaxindex, C(vMaxindex) - C(vsize)))
		  lowindex = vMaxindex
		end		
		
	    curfrom = voldMinindex		
	    curto = voldMaxindex
		
      else 
	    	    
        if vMax < C(index) then
          vMax = C(index)
          vMaxindex = index
          vFrom = voldMinindex    
          vTo = index
          printz = 0
		  curto = index		
        else  
          vFrom = vMaxindex  
          vTo = index        
          printz = 0
        end
		
	    curfrom = voldMinindex
		
      end  

	
    end
    end
 
    if (printz == 1) or (Size() == index) then
      for i = vFrom, vTo do
        k = (C(vTo)- C(vFrom))/(vTo- vFrom)
        v = i*k + C(vTo) - vTo*k
        SetValue(i, 1, v)
        ve = v
      end   
      if (Size() == index) then
        ve = C(index)
        if voldMaxindex >= voldMinindex then
          vFrom = voldMaxindex 
          vTo = vMinindex
        end 
        if voldMaxindex <= voldMinindex then  
          vFrom = voldMinindex
          vTo = vMaxindex
        end 
        for i = vFrom, vTo do
          k = (C(vTo)- C(vFrom))/(vTo- vFrom)
          v = i*k + C(vTo) - vTo*k
          SetValue(i, 1, v)
        end  
           
        -- up level line 
        if upindex ~= nil then
		  if C(upindex) > C(index) then		
            for i = upindex, index do
              SetValue(i, 2, C(upindex))
              SetValue(i, 5, C(upindex)-Settings.linedeltaY*C(vsize)/100)			  
            end  	
            veu = C(upindex)	
          end 		  
		end
		
		-- low level line 
		if lowindex ~= nil then
		  if C(lowindex) < C(index) then
            for i = lowindex, index do
              SetValue(i, 3, C(lowindex))
              SetValue(i, 6, C(lowindex)+Settings.linedeltaY*C(vsize)/100)				  
            end  			
            vel = C(lowindex)
         end
       end		
        
       if voldMaxindex >= voldMinindex then     
	    vsign = -1
		if curfrom == voldMinindex then
		  vsign = -1
		end
		if curfrom == voldMaxindex then
		  vsign = 1
		end		

        -- inclined line
	    if curto- curfrom > 0 then
	     maxcurv = 0
	     k = (C(curto)- C(curfrom))/(curto- curfrom)
         for i = curfrom, curto  do        
          curv = i*k + C(curto) - curto*k	
          if vsign == -1 then  		  
 		    if L(i) < curv then
		      if maxcurv < curv - L(i) then
		        maxcurv = curv - L(i)
              end
            end
		  else
 		    if H(i) > curv then
		      if maxcurv < H(i) - curv then
		        maxcurv = H(i) - curv
              end
            end		  
		  end
         end   		
         for i = curfrom, index  do
          curv = i*k + C(curto) - curto*k + vsign*maxcurv	  
          SetValue(i, 4,curv)
		  curv2 = curv+ vsign*Settings.linedeltaY*C(vsize)/100
		  SetValue(i, 7,curv2)		  
         end   		
	    end
	    curv = nil	
	   end 
	  
       if voldMaxindex <= voldMinindex then
	    vsign = -1
		if curfrom == voldMaxindex then
		  vsign = 1
		end		
		if curfrom == voldMinindex then
		  vsign = -1
		end			
  
        -- inclined line
        if curto- curfrom > 0 then
         maxcurv = 0
         k = (C(curto)- C(curfrom))/(curto- curfrom)
         for i = curfrom, curto  do        
          curv = i*k + C(curto) - curto*k		  
          if vsign == -1 then  		  
 		    if L(i) < curv then
		      if maxcurv < curv - L(i) then
		        maxcurv = curv - L(i)
              end
            end
		  else
 		    if H(i) > curv then
		      if maxcurv < H(i) - curv then
		        maxcurv = H(i) - curv
              end
            end		  
		  end
         end   		
         for i = curfrom, index  do
          k = (C(curto)- C(curfrom))/(curto- curfrom)
          curv = i*k + C(curto) - curto*k + vsign*maxcurv	  		
          SetValue(i, 4,curv)
		  curv2 = curv+ vsign*Settings.linedeltaY*C(vsize)/100
		  SetValue(i, 7,curv2)
         end   		     
        end
	    curv = nil		
       end	  
	          
      end
    end

  end  
  
  return ve, veu, vel, curv, veu2, vel2, curv2  
  
end

Settings={
Name="STATDIVVOL",
period=10,
  line=
  {
    {
      Name="curve",
      Color=RGB(0,0,255),
      Type=TYPE_LINE,
      Width=1
    },
    {
      Name="line",
      Color=RGB(255,0,0),
      Type=TYPE_LINE,
      Width=1
    }
  } 
}

function Init()
  return 2
end

function OnCalculate(index)
  local sum1=0
  local sum2=0  
  if index < Settings.period then
    return nil, nil
  else   	
    for i=index-Settings.period+1, index do  
      if C(i) > O(i) then
        sum1 = sum1 + (C(i) - O(i))*V(i)
        sum2 = sum2 + (C(i) - O(i))*V(i)
      else
        sum2 = sum2 + (O(i) - C(i))*V(i)
      end  
    end 
    sum1 = sum1/sum2    
  end
  
  return sum1, 0.5

end

Settings=              
        {                          
            Name = "Zigzag3",   -- название индикатора
            delta=2,                  -- параметр индикатора                          
            line=                                     
                {                               
                    {  
                        Name = "zigzagline3",
                        Type =TYPE_LINE,
                        Width = 2,
                        Color = RGB(120,90, 140)
                    },
                    {  
                        Name = "upline",
                        Type =TYPE_LINE,
                        Width = 2,
                        Color = RGB(255,0, 0)
                    },
                    {  
                        Name = "lowline",
                        Type =TYPE_LINE,
                        Width = 2,
                        Color = RGB(0,0, 255)
                    }					
                }
       }


function Init()

  vMin = 0
  vMax = 0
  vMinindex = 0
  vMaxindex = 0
  voldMinindex = 0
  voldMaxindex = 0
  upval = 9999999
  lowval = 9999999  
  upindex = 1
  lowindex = 1  
  veu = nil
  vel = nil

  return 3
end


function OnCalculate(index)
  local printz = 0
  vsize = Size()	  
  
  if index == 1 then
    vMin = C(index)
    vMax = C(index)
    vMinindex = index
    vMaxindex = index
    voldMinindex = index
    voldMaxindex = index
    ve = C(index)  
	  
  else
         
    if voldMaxindex >= voldMinindex then
      if C(index) > (1 + Settings.delta/100)*vMin then
        vMin = C(index)  
        vMax = C(index) 
        vMaxindex = index
        voldMinindex = vMinindex 
        vFrom = voldMaxindex  
        vTo = vMinindex
        printz = 1		
        if (C(vMinindex) > C(vsize)) and (upval > C(vMinindex) - C(vsize)) then
		  upval = C(vMinindex) - C(vsize)
		  upindex = vMinindex
		end
        if (C(vMinindex) < C(vsize)) and (lowval > C(vsize)- C(vMinindex)) then
		  lowval = C(vsize) - C(vMinindex)
		  lowindex = vMinindex
		end		
		
		
      else     
        if vMin > C(index) then
          vMin = C(index)
          vMinindex = index
          vFrom = voldMaxindex      
          vTo = index
          printz = 0
        else
          vFrom = vMinindex 
          vTo = index
          printz = 0
        end 
      end
    else
     
    if voldMaxindex <= voldMinindex then
      if C(index) < (1 - Settings.delta/100)*vMax then
        vMax = C(index) 
        vMin = C(index)  
        vMinindex = index
        voldMaxindex = vMaxindex
        vFrom = voldMinindex
        vTo = vMaxindex
        printz = 1
        if (C(vMaxindex) > C(vsize)) and (upval > C(vMaxindex) - C(vsize)) then
		  upval = C(vMaxindex) - C(vsize)
		  upindex = vMaxindex
		end
        if (C(vMaxindex) < C(vsize)) and (lowval > C(vsize)- C(vMaxindex)) then
		  lowval = C(vsize) - C(vMaxindex)
		  lowindex = vMaxindex
		end			
      else 
        if vMax < C(index) then
          vMax = C(index)
          vMaxindex = index
          vFrom = voldMinindex    
          vTo = index
          printz = 0
        else  
          vFrom = vMaxindex  
          vTo = index        
          printz = 0
        end
      end  
    end
    end
 
    if (printz == 1) or (Size() == index) then
      for i = vFrom, vTo do
        k = (C(vTo)- C(vFrom))/(vTo- vFrom);
        v = i*k + C(vTo) - vTo*k
        SetValue(i, 1, v)
        ve = v
      end   
      if (Size() == index) then
        ve = C(index)
        if voldMaxindex >= voldMinindex then
          vFrom = voldMaxindex 
          vTo = vMinindex
        end 
        if voldMaxindex <= voldMinindex then  
          vFrom = voldMinindex
          vTo = vMaxindex
        end 
        for i = vFrom, vTo do
          k = (C(vTo)- C(vFrom))/(vTo- vFrom);
          v = i*k + C(vTo) - vTo*k
          SetValue(i, 1, v)
        end  

		if upindex ~= nil then
		  if C(upindex) > C(index) then		
            for i = upindex, index do
              SetValue(i, 2, C(upindex))
            end  	
            veu = C(upindex)	
          end 		  
		end
		if lowindex ~= nil then
		  if C(lowindex) < C(index) then
            for i = lowindex, index do
              SetValue(i, 3, C(lowindex))
            end  			
		    vel = C(lowindex)
		  end
		end		



      end
    end

  end   
  return ve, veu, vel
end

Settings={
Name="XXX",
period=25,
  line=
  {
    {
      Name="curve",
      Color=RGB(255,0,0),
      Type=TYPE_LINE,
      Width=1
    }
  } 
}

function Init()  
  return 1
end

function OnCalculate(index)
  if index < Settings.period then
    return nil
  else

    for i=index-Settings.period+1, index do  
    do
      j=1
    end
    for k=1, 10 do  
    do
      j=1
    end


  end 

  return 2
end

end

Settings={
Name="STATDIV3",
period=50,
  line=
  {
    {
      Name="curve",
      Color=RGB(0,0,255),
      Type=TYPE_LINE,
      Width=1
    },
    {
      Name="line",
      Color=RGB(255,0,0),
      Type=TYPE_LINE,
      Width=1
    },
    {
      Name="MA",
      Color=RGB(0,0,255),
      Type=TYPE_LINE,
      Width=1
    },
    {
      Name="MA2",
      Color=RGB(0,128,128),
      Type=TYPE_LINE,
      Width=1
    },
    {
      Name="line2",
      Color=RGB(0,0,255),
      Type=TYPE_LINE,
      Width=1
    },
    {
      Name="line3",
      Color=RGB(0,128,128),
      Type=TYPE_LINE,
      Width=1
    }
  } 
}

function Init()
  cache_ind={}
  cache_ind2={}
  cache_ind3={}
  return 2
end

function OnCalculate(index)
  if index < Settings.period then
    return nil
  else
    local sum1=0
    local sum2=0
    local sum0=0
    local sum02=0
    local sum03=0
    for i=index-Settings.period+1, index do  
    do
      if C(i) > O(i) then
        sum1 = sum1 + C(i) - O(i)
        sum2 = sum2 + C(i) - O(i)
      else
        sum2 = sum2 + O(i) - C(i)
      end  
    end 
    cache_ind[index] = sum1/sum2    
    if index > Settings.period+12 then 
--[[
      sum0 = 1*cache_ind[index]+
            (1)*cache_ind[index-1]+
            (1)*cache_ind[index-2]+
            (1)*cache_ind[index-3]+
            (1)*cache_ind[index-4]+
            (1)*cache_ind[index-5]+
            (1)*cache_ind[index-6]+
            (1)*cache_ind[index-7]+
            (1)*cache_ind[index-8]+
            (1/2)*cache_ind[index-9]+
            (1/3)*cache_ind[index-10]+
            (1/4)*cache_ind[index-11]+
            (1/5)*cache_ind[index-12]
--]]
      sum0 = 1*cache_ind[index]+
            (1/2)*cache_ind[index-1]+
            (1/3)*cache_ind[index-2]+
            (1/4)*cache_ind[index-3]+
            (1/5)*cache_ind[index-4]+
            (1/6)*cache_ind[index-5]+
            (1/7)*cache_ind[index-6]+
            (1/8)*cache_ind[index-7]+
            (1/9)*cache_ind[index-8]+
            (1/10)*cache_ind[index-9]+
            (1/11)*cache_ind[index-10]+
            (1/12)*cache_ind[index-11]+
            (1/13)*cache_ind[index-12]

    end
--[[
    sum0 = sum0/(1+1+1+1+1+1+1+1+1+1/2+1/3+1/4+1/5)
--]]
    sum0 = sum0/(1+1/2+1/3+1/4+1/5+1/6+1/7+1/8+1/9+1/10+1/11+1/12+1/13)

       
    cache_ind2[index] = sum0
    if index > Settings.period+50 then   
      sum02 = 1*cache_ind2[index]+
            (1)*cache_ind2[index-1]+
            (1)*cache_ind2[index-2]+
            (1)*cache_ind2[index-3]+
            (1)*cache_ind2[index-4]+
            (1)*cache_ind2[index-5]+
            (1)*cache_ind2[index-6]+
            (1)*cache_ind2[index-7]+
            (1/2)*cache_ind2[index-8]+
            (1/3)*cache_ind2[index-9]+
            (1/4)*cache_ind2[index-10]+
            (1/5)*cache_ind2[index-11]+
            (1/6)*cache_ind2[index-12]
--[[
      sum02 = 1*cache_ind2[index]+
            (1/2)*cache_ind2[index-1]+
            (1/3)*cache_ind2[index-2]+
            (1/4)*cache_ind2[index-3]+
            (1/5)*cache_ind2[index-4]+
            (1/6)*cache_ind2[index-5]+
            (1/7)*cache_ind2[index-6]+
            (1/8)*cache_ind2[index-7]+
            (1/9)*cache_ind2[index-8]+
            (1/10)*cache_ind2[index-9]+
            (1/11)*cache_ind2[index-10]+
            (1/12)*cache_ind2[index-11]+
            (1/13)*cache_ind2[index-12]
--]]
    end
    sum02 = sum02/(1+1+1+1+1+1+1+1+1/2+1/3+1/4+1/5+1/6)
--[[
    sum02 = sum02/(1+1/2+1/3+1/4+1/5+1/6+1/7+1/8+1/9+1/10+1/11+1/12+1/13)
--]]
    cache_ind3[index] = sum0 - sum02
    if index > Settings.period+50 then   
      sum03 = 1*cache_ind3[index]+
            (1/2)*cache_ind3[index-1]+
            (1/3)*cache_ind3[index-2]+
            (1/4)*cache_ind3[index-3]+
            (1/5)*cache_ind3[index-4]+
            (1/6)*cache_ind3[index-5]+
            (1/7)*cache_ind3[index-6]+
            (1/8)*cache_ind3[index-7]+
            (1/9)*cache_ind3[index-8]+
            (1/10)*cache_ind3[index-9]+
            (1/11)*cache_ind3[index-10]+
            (1/12)*cache_ind3[index-11]+
            (1/13)*cache_ind3[index-12]
    end
    sum03 = sum03/(1+1/2+1/3+1/4+1/5+1/6+1/7+1/8+1/9+1/10+1/11+1/12+1/13)

  end  

  if sum1/sum2 > 0.5 and sum03 > 0 then
    sum1 = sum03
  else
    if sum1/sum2 < 0.5 and sum03 < 0 then
      sum1 = sum03 
    else 
      sum1 = 0
    end
  end

  return sum1, 0
end

end

 всем удачи!

Ошибка создания заявки. [GW][332] «Нехватка средств по лимитам клиента.».

Не могу сообразить, как предварительно до отправки заявки в систему проверить, что она отвечает требования достаточности средств по лимитам. 

Друзья, коллеги, роботорговцы, подскажите как проверить, что заявка на фортсе проходит под имеющееся свободное ГО ?

Добрый.
В одном из видео автор рассказывал об уровнях и использовал индикатор фрактал. Но для того чтобы потенциальные точки находились быстрее, он использовал ассиметричный показатель, например, 4 слева и 3 справа.
Такой индикатор можно построить с помощью Lua.
Параметры: количество свечей слева и справа
Отображение в виде треугольников. Один треугольник было плохо видно, я добавил несколько )
Второй раз пошло легче. Работаем дальше

Исходник

yadi.sk/d/gDeCrw-2FPwNVQ

4 года и 4 месяца прошло с выхода поста «Торговый робот на LUA для QUIK» (https://smart-lab.ru/blog/200767.php) про конструктор Lbot. За это время он повзрослел, лишился графического интерфейса и… превратился в младшего брата для Lbot3D. И если раньше для Lbot была пробная версия (с одним инструментом и одним лотом), то теперь, фактически, сам превратился в пробную версию для Lbot3D и, с этого дня, предоставляется в свободное пользование с полным функционалом:



Скачать Lbot180.zip можно тут: drive.google.com/open?id=1DL9jGEBm2Uhk89PcQdlK-ObaOe2zihnx
INI-файл написан для демо-QUIK на 3 инструмента — Сбербанк, Газпром и Лукойл. Стратегия на Газпроме — безиндикаторная, на Сбербанке — на скользящих средних, на Лукойле — на пересечениях MACD.

encoding = "UTF-8"
FREQUENCY = 1000
account = NL0011100043, 10110
PositionSize = 300000
xy = 421, 0, 859, 118
;-------------------------------------------------------------------------------
[GAZP]
Security = GAZP, QJSIM, Gazp_moex
WorkSize = 3		//  рабочий объем, в штуках;
LossLimit = 100		// ограничение на убыток по стратегии
OpenSlippage = 10	// допустимое проскальзывание на сделке, в количестве минимальных шагов цены;
OpenLong =  {Close, 1} < {High, 2}	// цена 'close' предыдущей 'полной' свечи превысила 'high' предшествующего ей бара;
OpenShort = {Close, 1} > {Low, 5-2}	// цена 'close' предыдущей 'полной' свечи принизила 'low' 5-2 баров;
StopLoss = 2
TakeProfit = 3, 1, 1
EOD = 18:29:00	//закрытия позиции в указанное время.
autoBot = Y
[SBER]
Security = SBER, QJSIM, Sber_moex
WorkSize = 10
LossLimit = 100
OpenSlippage = 10
OpenLong	= {Ema1} > {Ema2}
CloseLong	= {Ema1} < {Ema2}
OpenShort	= {Ema1} < {Ema2}
CloseShort	= {Ema1} > {Ema2}
autoBot = Y
[LKOH]
WorkSize = 2
Security = LKOH, QJSIM, Lkoh_moex
LossLimit = 225
OpenSlippage = 10
OpenLong	= cross(macd_Lkoh.0, macd_Lkoh.1)
OpenShort	= cross(macd_Lkoh.1, macd_Lkoh.0)
;OpenLong =  {Close, 1} < {Low, 5-2}
;OpenShort = {Close, 1} > {High, 2}
StopLoss = 30
TakeProfit = 50, 10, 10
autoBot = Y

          В программе Lbot3D появилась реализация вычисления скользящего экстремума в конкретной стратегии при наличии позиции. Слово «конкретной» звучит потому, что этот самый экстремум можно использовать в других стратегиях из портфеля стратегий. Согласен, это нужно не всем. Скорее так: мало кому он нужен. Тем не менее, продолжу.

          Допустим мы придумали стратегию на некотором активе, рассчитанную на тренд:
Покупаем на четверть портфеля. Если цена пошла против нас (пусть на 1%)- стопимся, но если в нашу сторону +1%, то в предположении, что мы тренде, выставим лимитированную заявку на покупку второй четверти на 0.5% ниже достигнутого экстремума: откат вероятен, и после того, как на откате вытряхнут часть пассажиров, (самых пугливых, самых недостойных :)), наш портфель зацепит еще несколько лотов и едем дальше, «на север». Но если первая четверть бумаг размещена в нашем портфеле на «долгосрок», то вторая четверть будет сразу же выставлена на продажу с профитом, например, в 1%.

В своей торговле применяю комбинации рыночных и лимитированных заявок, (методику описывал ранее, "Настоящая торговая стратегия."  и "US500: Объемы больше, спреды уже!" ). Временами количество одновременно работающих стратегий зашкаливало за сотню и на некоторые из них не хватало денег под выставление заявок, они отключались, иногда ломая логику работы связанных с ней стратегий. В QUIK в таблице «Состояние счета» считается цифра — «Свободно» — свободные средства под заявки, но сходу вытащить ее из Lua у меня не получилось. И пришлось вписать расчет этой величины в робота.
Сегодня предлагаю вашему вниманию доработанный скрипт Fn044.lua (https://yadi.sk/d/O-6JzZdXkOxyow)


в котором реализован расчет свободных средств для заявок на ФОРТС с учетом имеющихся контрактов и заявок.
Один в один вывести не получилось, как смог.
As is, и все такое!

--переменные
keyRateCB = 7.5
classCode = "TQOB"

function CreateTable()
    t_id = AllocTable()
    AddColumn(t_id, 0, "Бумага", true, QTABLE_STRING_TYPE, 15)
    AddColumn(t_id, 1, "Цена", true, QTABLE_DOUBLE_TYPE, 15)
    AddColumn(t_id, 2, "Доходность, %", true, QTABLE_DOUBLE_TYPE, 15)
    AddColumn(t_id, 3, "Дюрация, лет", true, QTABLE_DOUBLE_TYPE, 15)
    AddColumn(t_id, 4, "Купон, %", true, QTABLE_DOUBLE_TYPE, 15)
    AddColumn(t_id, 5, "Премия к ЦБ, бп", true, QTABLE_INT_TYPE, 15)
    AddColumn(t_id, 6, "Погашение", true, QTABLE_STRING_TYPE, 15)
    t = CreateWindow(t_id)
    SetWindowCaption(t_id, "ОФЗ")
end

function string.split(str, sep)
    local fields = {}
    str:gsub(string.format("([^%s]+)", sep), function(f_c) fields[#fields + 1] = f_c end)
    return fields
end

function getParamNumber(code, param)
    return tonumber(getParamEx(classCode, code, param).param_value)
end

function formatData(prm)
    return string.format("%02d.%02d.%04d", prm%100, (prm%10000)/100, prm/10000)
end

CreateTable()

arr = {}
sec_list = getClassSecurities(classCode)
sec_listTable = string.split(sec_list, ',')
j = 0
for i = 1, #sec_listTable do
    secCode = sec_listTable[i]
    securityInfo = getSecurityInfo(classCode, secCode)
    short_name = securityInfo.short_name
    if short_name:find("ОФЗ 26") ~= nil then
        j = j + 1
        r = {}
        r["short_name"] = short_name
        r["price"] = getParamNumber(securityInfo.code, "PREVPRICE")
        r["yield"] = getParamNumber(securityInfo.code, "YIELD")
        r["duration"] = getParamNumber(securityInfo.code, "DURATION")/365
        couponvalue = getParamNumber(securityInfo.code, "COUPONVALUE")
        couponperiod = getParamNumber(securityInfo.code, "COUPONPERIOD")
        r["coupon"] = ((365/couponperiod) * couponvalue)/10
        r["bonus"] = (r["yield"] - keyRateCB)*100
        r["mat_date"] = getParamNumber(securityInfo.code, "MAT_DATE")
        table.insert(arr, j, r)
    end
end

table.sort(arr, function(a,b) return a["duration"] < b["duration"] end)

for j = 1, #arr do
    row = InsertRow(t_id, -1)
    SetCell(t_id, row, 0, arr[j]["short_name"])
    price = arr[j]["price"]
    SetCell(t_id, row, 1, string.format("%.2f", price), price)
    yield = arr[j]["yield"]
    SetCell(t_id, row, 2, string.format("%.2f", yield), yield)
    duration = arr[j]["duration"]
    SetCell(t_id, row, 3, string.format("%.2f", duration), duration)
    coupon = arr[j]["coupon"]
    SetCell(t_id, row, 4, string.format("%.2f", coupon), coupon)
    bonus = arr[j]["bonus"]
    SetCell(t_id, row, 5, string.format("%.0f", bonus), bonus)
    mat_date = arr[j]["mat_date"]
    SetCell(t_id, row, 6, formatData(mat_date), mat_date)
end