StepNRTRsimple

--logfile=io.open(getWorkingFolder().."\\LuaIndicators\\qlua_log.txt", "w")

min_price_step = 0

Settings=
{
	Name = "*StepNRTR simple",
	Length = 5,
	value_type = "ATR",
	Kv = 1.5,
	StepSize = 0,
	Percentage = 0,
	Switch = 1, --1 - HighLow, 2 - CloseClose
	ShowLine = 1,
	ShowSignalLine = 0,
	line =
	{		
		{
			Name = "NRTR",
			Color = RGB(0, 64, 0),
			Type = TYPE_LINE, --TYPE_DASHDOT,
			Width = 2
		},
		{
			Name = "NRTR_buy",
			Color = RGB(89,217,107),
			Type = TYPE_TRIANGLE_UP,
			Width = 4
		},
		{
			Name = "NRTR_sell",
			Color = RGB(255,0,0),
			Type = TYPE_TRIANGLE_DOWN,
			Width = 4
		},
		{
			Name = "signal_buy",
			Color = RGB(40,240,250),
			Type = TYPET_BAR,
			Width = 4
		},
		{
			Name = "signal_sell",
			Color = RGB(255,0,255),
			Type = TYPET_BAR,
			Width = 4
		}
	}
}


function Init()
	myNRTR = cached_NRTR()
	return #Settings.line
end


function OnCalculate(index)
	
	if index == 1 then
		DSInfo = getDataSourceInfo()     	
		min_price_step = getParamEx(DSInfo.class_code, DSInfo.sec_code, "SEC_PRICE_STEP").param_value
		if tonumber(min_price_step) == 0 or min_price_step == nil then
			min_price_step = 1
		end
		--WriteLog ("min_price_step "..tostring(min_price_step))
	end
	return myNRTR(index, Settings)
		
end

--------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------
function FindExistCandle(I)

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

function dValue(i,param)
local v = param or "C"
	
	if not CandleExist(i) then
		return nil
	end
	
	if  v == "O" then
		return O(i)
	elseif   v == "H" then
		return H(i)
	elseif   v == "L" then
		return L(i)
	elseif   v == "C" then
		return C(i)
	elseif   v == "V" then
		return V(i)
	elseif   v == "M" then
		return (H(i) + L(i))/2
	elseif   v == "T" then
		return (H(i) + L(i)+C(i))/3
	elseif   v == "W" then
		return (H(i) + L(i)+2*C(i))/4
	elseif   v == "ATR" then
	
		local previous = i-1
		
		if not CandleExist(previous) then
			previous = FindExistCandle(previous)
		end
	
		return math.max(math.abs(H(i) - L(i)), math.abs(H(i) - C(previous)), math.abs(C(previous) - L(i)))
	else
		return C(i)
	end 
end
function cached_NRTR()
	
	local cache_NRTR={}
	local smax1={}
	local smin1={}
	local trend={}
	local signal={}
		
	return function(ind, Fsettings, ds)
	
		local Fsettings=(Fsettings or {})
		local p = 0
		local ATR = 0
		
		local index = ind
		local Length = Fsettings.Length or 64
		local Kv = Fsettings.Kv or 1
		local v_type = Fsettings.value_type or "ATR"
		local StepSize = Fsettings.StepSize or 0		
		local Percentage = Fsettings.Percentage or 0
		local Switch = Fsettings.Switch or 1
		local ShowLine = Fsettings.ShowLine or 0
		local ShowSignalLine = Fsettings.ShowSignalLine or 1
		
		local ratio=Percentage/100.0*min_price_step	
		
		local out1 = nil
		local out2 = nil
		local out3 = nil		
		local out4 = nil
		local out5 = nil		
		
		if index == 1 then
			cache_NRTR = {}
			cache_NRTR[index] = 0			
			signal = {}
			signal[index] = 0			
			smax1 = {}
			smin1 = {}
			trend = {}
			smax1[index] = 0
			smin1[index] = 0
			trend[index] = 1
			return nil
		end
		
		cache_NRTR[index] = cache_NRTR[index-1] 
		smax1[index] = smax1[index-1] 
		smin1[index] = smin1[index-1] 
		trend[index] = trend[index-1] 
		signal[index] = signal[index-1] 
		
		if not CandleExist(index) then
			return nil
		end
		if index <= (Length + 3) then
			return nil
		end
		
		--WriteLog ("---------------------------------")
		--WriteLog ("index "..tostring(index))
		--WriteLog ("C(index) "..tostring(C(index)))
		--WriteLog ("H(index) "..tostring(H(index)))
		--WriteLog ("L(index) "..tostring(L(index)))
		
		local Step=StepSizeCalc(Length,Kv,StepSize,Switch,index)
		if Step == 0 then Step = 1 end
		
		local SizeP=Step*min_price_step
		local Size2P=2*SizeP
		
		--WriteLog ("Step "..tostring(Step))

		local result
		
		local previous = index-1
		
		if not CandleExist(previous) then
			previous = FindExistCandle(previous)
		end
		
		if Switch == 1 then     
			smax0=L(previous)+Size2P
			smin0=H(previous)-Size2P    
		else   
			smax0=C(previous)+Size2P
			smin0=C(previous)-Size2P
		end
		
		--WriteLog ("smax0 "..tostring(smax0))
		--WriteLog ("smin0 "..tostring(smin0))
		--WriteLog ("smax1[index] "..tostring(smax1[index]))
		--WriteLog ("smin1[index] "..tostring(smin1[index]))

		if C(index)>smax1[index] then trend[index] = 1 end
		if C(index)<smin1[index] then trend[index]= -1 end
		--WriteLog ("trend "..tostring(trend[index]))

		if trend[index]>0 then
			if smin0<smin1[index] then smin0=smin1[index] end
			result=smin0+SizeP
		else
			if smax0>smax1[index] then smax0=smax1[index] end
			result=smax0-SizeP
		end
		--WriteLog ("result "..tostring(result))
	 		
		smax1[index] = smax0
		smin1[index] = smin0
		--WriteLog ("smax0 "..tostring(smax0))
		--WriteLog ("smin0 "..tostring(smin0))
		--WriteLog ("smax1[index] "..tostring(smax1[index]))
		--WriteLog ("smin1[index] "..tostring(smin1[index]))
		
		if trend[index]>0 then
			cache_NRTR[index]=(result+ratio/Step)-Step*min_price_step
		end
		if trend[index]<0 then
			cache_NRTR[index]=(result+ratio/Step)+Step*min_price_step		
		end	
		
		--WriteLog ("cache_NRTR "..tostring(cache_NRTR[index]))

		if trend[index-1]>0 and trend[index-2]<0 then
			out2 = O(index)
			out3 = nil
		end

		if trend[index-1]<0 and trend[index-2]>0 then
			out2 = nil
			out3 = O(index)
		end
								
		if ShowLine == 1 and ShowSignalLine ~= 1 then
			out1 = cache_NRTR[index]
		end
		
		if ShowSignalLine == 1 then
			if trend[index]>0 then
				out4 = cache_NRTR[index-1]
			else
				out5 = cache_NRTR[index-1]
			end
		end
		
		return out1, out2, out3, out4, out5 
		
	end
end

function WriteLog(text)

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

end;

function StepSizeCalc(Len, Km, Size, Switch, index)

	local result

	if Size == 0 then
		 
		local Range=0.0
		local ATRmax=-1000000
		local ATRmin=1000000

		for iii=1, Len do	
			if CandleExist(index-iii) then				
				if Switch == 1 then     
					Range=H(index-iii)-L(index-iii)
				else   
					Range=math.abs(O(index-iii)-C(index-iii))
				end
				if Range>ATRmax then ATRmax=Range end
				if Range<ATRmin then ATRmin=Range end
			end
		end
		result = round(0.5*Km*(ATRmax+ATRmin)/min_price_step, nil)
		 
	else result=Km*Size
	end

	return result
end


function round(num, idp)
	if idp and num then
	   local mult = 10^(idp or 0)
	   if num >= 0 then return math.floor(num * mult + 0.5) / mult
	   else return math.ceil(num * mult - 0.5) / mult end
	else return num end
end