- Cuadrado
- ¿Qué es lo que está pasando?
¿Qué es lo que está pasando?
El autor:
a624587332, Fecha: 2022-08-02 23:44:45
Las etiquetas:
strategy("EtHEriOOOm [30MIN]", overlay=true, pyramiding=1,initial_capital = 10000, default_qty_type= strategy.percent_of_equity, default_qty_value = 100, calc_on_order_fills=false, slippage=0,commission_type=strategy.commission.percent,commission_value=0.04)
//SOURCE =============================================================================================================================================================================================================================================================================================================
src = input(hl2)
// POSITION ==========================================================================================================================================================================================================================================================================================================
Position = input("Both", title= "Longs / Shorts", options = ["Both","Longs","Shorts"])
is_Long = Position == "SHORT" ? na : true
is_Short = Position == "LONG" ? na : true
// INPUTS ============================================================================================================================================================================================================================================================================================================
//ADX --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Act_ADX = input(true, title = "AVERAGE DIRECTIONAL INDEX", type = input.bool, group = "ADX")
ADX_options = input("MASANAKAMURA", title = "ADX OPTION", options = ["CLASSIC", "MASANAKAMURA"], group = "ADX")
ADX_len = input(19, title = "ADX LENGTH", type = input.integer, minval = 1, group = "ADX")
th = input(16, title = "ADX THRESHOLD", type = input.float, minval = 0, step = 0.5, group = "ADX")
// Range Filter ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Act_RF = input(true, title = "RANGE FILTER")
per_ = input(35, title = "SAMPLING PERIOD", minval=1, group = "Range Filter")
mult = input(0.2, title="RANGE MULTIPLIER", minval=0.1, step = 0.1, group = "Range Filter")
//JMA--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
inp = input(defval=close, title="JMA Source", type=input.source, group = "Jurik Moving Average")
reso = input("", title="JMA Resolution", type=input.resolution, group = "Jurik Moving Average")
rep = input(false, title="JMA Allow Repainting?", type=input.bool, group = "Jurik Moving Average")
src0 = security(syminfo.tickerid, reso, inp[rep ? 0 : barstate.isrealtime ? 1 : 0])[rep ? 0 : barstate.isrealtime ? 0 : 1]
lengths = input(31, title="JMA Length", type=input.integer, group = "Jurik Moving Average")
//MACD----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
fast_length = input(13, title="Fast Length", type=input.integer, group="MACD")
slow_length = input(19, title="Slow Length", type=input.integer, group="MACD")
signal_length = input(19, title="Signal Smoothing", type=input.integer, group="MACD")
//MA----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
length = input(61, title="MA Length", minval=1, group="Fast MA" )
matype = input(5, title="AvgType", minval=1, maxval=5, group="Fast MA")
//Volume weight------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
maLength = input(61, title="Volume Weight Length", type=input.integer, minval=1, group = "Volume")
maType = input(defval="EMA", title="Volume Weight Type", type=input.string, options=["EMA", "SMA", "HMA", "WMA", "DEMA"], group = "Volume")
rvolTrigger = input(1.1, title="Volume To Trigger Signal", type=input.float, step=0.1, minval=0.1, group = "Volume")
//RSI----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
len_3 = input(50, title="RSI lenght", group = "Relative Strenght Indeks")
src_3 = input(close, title="RSI Source", group = "Relative Strenght Indeks")
//TREND STRENGHT--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
n1 = input(10, title= "Channel Length", group="Trend Strenght")
n2 = input(21, title= "Average Length", group="Trend Strenght")
//TWAP Trend --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
smoothing = input(20, title="TWAP Smoothing", group="TWAP")
resolution = input("0", title="TWAP Timeframe", group="TWAP")
//Stoch Divergence Scalping--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ACT_S_SCLP = input(true, title = "SCALPING", type = input.bool, group ="Stoch Scalps")
ll = input(42, title="lower lenght", maxval=50, group ="Stoch Scalps")
lengthd = input(12, title="lenght D", group ="Stoch Scalps")
smoothK = input(72, title="smooth K", minval=1, group ="Stoch Scalps")
ul = input(67, title="upper lenght", minval=50, group ="Stoch Scalps")
//BACKTESTING--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ACT_BT = input(true, title="BACKTEST", type = input.bool, group= "BACKTEST")
long_ = input(true, title="Longs", group= "BACKTEST")
short_ = input(true, title="Shorts", group= "BACKTEST")
risk = input(100, group= "BACKTEST")
testStartYear = input(2019, title="start year", minval = 1997, maxval = 3000, group= "BACKTEST")
testStartMonth = input(06, title="start month", minval = 1, maxval = 12, group= "BACKTEST")
testStartDay = input(01, title="start day", minval = 1, maxval = 31, group= "BACKTEST")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)
testStopYear = input(2222, title="stop year", minval=1980, maxval = 2222, group= "BACKTEST")
testStopMonth = input(12, title="stop month", minval=1, maxval=12, group= "BACKTEST")
testStopDay = input(31, title="stop day", minval=1, maxval=31, group= "BACKTEST")
testPeriodStop = timestamp(testStopYear, testStopMonth, testStopDay, 0, 0)
testPeriod = time >= testPeriodStart and time <= testPeriodStop ? true : false
//INDICATORS ==============================================================================================================================================================================================================================================================
//ADX-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
calcADX(_len) =>
up = change(high)
down = -change(low)
plusDM = na(up) ? na : (up > down and up > 0 ? up : 0)
minusDM = na(down) ? na : (down > up and down > 0 ? down : 0)
truerange = rma(tr, _len)
_plus = fixnan(100 * rma(plusDM, _len) / truerange)
_minus = fixnan(100 * rma(minusDM, _len) / truerange)
sum = _plus + _minus
_adx = 100 * rma(abs(_plus - _minus) / (sum == 0 ? 1 : sum), _len)
[_plus,_minus,_adx]
calcADX_Masanakamura(_len) =>
SmoothedTrueRange = 0.0
SmoothedDirectionalMovementPlus = 0.0
SmoothedDirectionalMovementMinus = 0.0
TrueRange = max(max(high - low, abs(high - nz(close[1]))), abs(low - nz(close[1])))
DirectionalMovementPlus = high - nz(high[1]) > nz(low[1]) - low ? max(high - nz(high[1]), 0) : 0
DirectionalMovementMinus = nz(low[1]) - low > high - nz(high[1]) ? max(nz(low[1]) - low, 0) : 0
SmoothedTrueRange := nz(SmoothedTrueRange[1]) - (nz(SmoothedTrueRange[1]) /_len) + TrueRange
SmoothedDirectionalMovementPlus := nz(SmoothedDirectionalMovementPlus[1]) - (nz(SmoothedDirectionalMovementPlus[1]) / _len) + DirectionalMovementPlus
SmoothedDirectionalMovementMinus := nz(SmoothedDirectionalMovementMinus[1]) - (nz(SmoothedDirectionalMovementMinus[1]) / _len) + DirectionalMovementMinus
DIP = SmoothedDirectionalMovementPlus / SmoothedTrueRange * 100
DIM = SmoothedDirectionalMovementMinus / SmoothedTrueRange * 100
DX = abs(DIP-DIM) / (DIP+DIM)*100
adx = sma(DX, _len)
[DIP,DIM,adx]
[DIPlusC,DIMinusC,ADXC] = calcADX(ADX_len)
[DIPlusM,DIMinusM,ADXM] = calcADX_Masanakamura(ADX_len)
DIPlus = ADX_options == "CLASSIC" ? DIPlusC : DIPlusM
DIMinus = ADX_options == "CLASSIC" ? DIMinusC : DIMinusM
ADX = ADX_options == "CLASSIC" ? ADXC : ADXM
L_adx = DIPlus > DIMinus and ADX > th
S_adx = DIPlus < DIMinus and ADX > th
// Range Filter ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
var bool L_RF = na, var bool S_RF = na
Range_filter(_src, _per_, _mult)=>
var float _upward = 0.0
var float _downward = 0.0
wper = (_per_*2) - 1
avrng = ema(abs(_src - _src[1]), _per_)
_smoothrng = ema(avrng, wper)*_mult
_filt = _src
_filt := _src > nz(_filt[1]) ? ((_src-_smoothrng) < nz(_filt[1]) ? nz(_filt[1]) : (_src-_smoothrng)) : ((_src+_smoothrng) > nz(_filt[1]) ? nz(_filt[1]) : (_src+_smoothrng))
_upward := _filt > _filt[1] ? nz(_upward[1]) + 1 : _filt < _filt[1] ? 0 : nz(_upward[1])
_downward := _filt < _filt[1] ? nz(_downward[1]) + 1 : _filt > _filt[1] ? 0 : nz(_downward[1])
[_smoothrng,_filt,_upward,_downward]
[smoothrng, filt, upward, downward] = Range_filter(src, per_, mult)
hband = filt + smoothrng
lband = filt - smoothrng
L_RF := (Act_RF ? (high > hband and upward > 0) : L_adx)
S_RF := (Act_RF ? (low < lband and downward > 0) : S_adx)
filtcolor = upward > 0 ? color.lime : downward > 0 ? color.red : color.orange
filtplot = plot(Act_RF ? filt : na, color = filtcolor, linewidth = 3, title="Range Filter", editable = false)
hbandplot = plot(Act_RF ? hband : na, color = color.green, transp = 60, title = "High Target", editable = false)
lbandplot = plot(Act_RF ? lband : na, color = color.red, transp = 60, title = "Low Target", editable = false)
fill(hbandplot, filtplot, color = color.green, title = "HT RF", editable = false)
fill(lbandplot, filtplot, color = color.red, title = "LT RF", editable = false)
//MACD-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
fast_ma = ema(src, fast_length)
slow_ma = ema(src, slow_length)
macd = fast_ma - slow_ma
signal_ = sma(macd, signal_length)
L_macd = macd > signal_
S_macd = macd < signal_
//JMA------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
jsa = (src0 + src0[lengths]) / 2
sig = src0 > jsa ? 1 : src0 < jsa ? -1 : 0
L_jma = sig > 0
S_jma = sig < 0
//MA----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
simplema = sma(src,length)
exponentialma = ema(src,length)
hullma = wma(2*wma(src, length/2)-wma(src, length), round(sqrt(length)))
weightedma = wma(src, length)
volweightedma = vwma(src, length)
avgval = matype==1 ? simplema : matype==2 ? exponentialma : matype==3 ? hullma : matype==4 ? weightedma : matype==5 ? volweightedma : na
MA_speed = (avgval / avgval[1] -1 ) *100
L_s_ma = MA_speed > 0
S_s_ma = MA_speed < 0
//Volume weight------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
getMA0(length) =>
maPrice = ema(volume, length)
if maType == "SMA"
maPrice := sma(volume, length)
if maType == "HMA"
maPrice := hma(volume, length)
if maType == "WMA"
maPrice := wma(volume, length)
if maType == "DEMA"
e1 = ema(volume, length)
e2 = ema(e1, length)
maPrice := 2 * e1 - e2
maPrice
ma = getMA0(maLength)
rvol = volume / ma
volumegood = volume > rvolTrigger * ma
//RSI------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
up_3 = rma(max(change(src_3), 0), len_3)
down_3 = rma(-min(change(src_3), 0), len_3)
rsi_3 = down_3 == 0 ? 100 : up_3 == 0 ? 0 : 100 - (100 / (1 + up_3 / down_3))
L_rsi = (rsi_3 < 70)
S_rsi = (rsi_3 > 30)
//TREND STRENGHT---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ap = hlc3
esa = ema(ap, n1)
d = ema(abs(ap - esa), n1)
ci = (ap - esa) / (0.015 * d)
tci = ema(ci, n2)
wt1 = tci
wt2 = sma(wt1,4)
mfi_upper = sum(volume * (change(hlc3) <= 0 ? 0 : hlc3), 58)
mfi_lower = sum(volume * (change(hlc3) >= 0 ? 0 : hlc3), 58)
_mfi_rsi(mfi_upper, mfi_lower) =>
if mfi_lower == 0
100
if mfi_upper == 0
0
100.0 - (100.0 / (1.0 + mfi_upper / mfi_lower))
mf = _mfi_rsi(mfi_upper, mfi_lower)
mfi = (mf - 50) * 3
L_mfi = mfi > 1
S_mfi = mfi < -1
//TWAP Trend --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
res = resolution != "0" ? resolution : timeframe.period
weight = barssince(change(security(syminfo.tickerid, res, time, lookahead=barmerge.lookahead_on)))
price = 0.
price := weight == 0 ? src : src + nz(price[1])
twap = price / (weight + 1)
ma_ = smoothing < 2 ? twap : sma(twap, smoothing)
bullish = iff(smoothing < 2, src >= ma_, src > ma_)
disposition = bullish ? color.lime : color.red
basis = plot(src, "OHLC4", disposition, linewidth=1, transp=100)
work = plot(ma_, "TWAP", disposition, linewidth=2, transp=20)
fill(basis, work, disposition, transp=90)
//Stoch Divergence ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
k = sma(stoch(close, high, low, lengthd), smoothK)
uline = ul
lline = ll
d_stoch_L_condt = crossover(uline, k)
d_stoch_S_condt = crossunder(lline, k)
//L/S variables----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
var bool longCond = na, var bool shortCond = na, longCond := nz(longCond[1]), shortCond := nz(shortCond[1])
var int CondIni_long = 0, var int CondIni_short = 0, CondIni_long := nz(CondIni_long[1]), CondIni_short := nz(CondIni_short[1])
var bool Final_longCondition = na, var bool Final_shortCondition = na, Final_longCondition := nz(Final_longCondition[1]), Final_shortCondition := nz(Final_shortCondition[1])
var bool BT_Final_longCondition = na, var bool BT_Final_shortCondition = na, BT_Final_longCondition := nz(BT_Final_longCondition[1]), BT_Final_shortCondition := nz(BT_Final_shortCondition[1])
var float last_open_longCondition = na, var float last_open_shortCondition = na
var int last_longCondition = na, var int last_shortCondition = na
var int nLongs = na, var int nShorts = na, nLongs := nz(nLongs[1]), nShorts := nz(nShorts[1])
//CONDITIONS =======================================================================================================================================================================================================================================================================================================
L_scalp_condt = d_stoch_L_condt and ACT_S_SCLP
S_scalp_condt = d_stoch_S_condt and ACT_S_SCLP
//STRATEGY ==========================================================================================================================================================================================================================================================================================================
L_basic_condt = L_adx and L_RF and L_jma and L_macd and L_s_ma and volumegood and L_rsi and L_mfi
S_basic_condt = S_adx and S_RF and S_jma and S_macd and S_s_ma and volumegood and S_rsi and S_mfi
L_second_condt = L_basic_condt or L_scalp_condt
S_second_condt = S_basic_condt or S_scalp_condt
longCond := L_second_condt
shortCond := S_second_condt
CondIni_long := longCond[1] ? 1 : shortCond[1] ? -1 : nz(CondIni_long[1])
CondIni_short := longCond[1] ? 1 : shortCond[1] ? -1 : nz(CondIni_short[1])
longCondition = (longCond[1] and nz(CondIni_long[1]) == -1)
shortCondition = (shortCond[1] and nz(CondIni_short[1]) == 1)
// Price position----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
var int last_long_sl = na, var int last_short_sl = na
last_open_longCondition := longCondition ? close[1] : nz(last_open_longCondition[1])
last_open_shortCondition := shortCondition ? close[1] : nz(last_open_shortCondition[1])
last_longCondition := longCondition ? time : nz(last_longCondition[1])
last_shortCondition := shortCondition ? time : nz(last_shortCondition[1])
in_longCondition = last_longCondition > last_shortCondition
in_shortCondition = last_shortCondition > last_longCondition
if longCondition
nLongs := nLongs + 1
nShorts := na
if shortCondition
nLongs := na
nShorts := nShorts + 1
//TP -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
tp = input(1.9, "% TP [PLOTSHAPE]", type = input.float, step = 0.1)
var bool long_tp = na, var bool short_tp = na
var int last_long_tp = na, var int last_short_tp = na
var bool Final_Long_tp = na, var bool Final_Short_tp = na, Final_Long_tp := nz(Final_Long_tp[1]), Final_Short_tp := nz(Final_Short_tp[1])
long_tp := (is_Long and high > (last_open_longCondition*(1+(tp/100))) and in_longCondition)
short_tp := (is_Short and low < (last_open_shortCondition*(1-(tp/100))) and in_shortCondition)
last_long_tp := long_tp ? time : nz(last_long_tp[1])
last_short_tp := short_tp ? time : nz(last_short_tp[1])
Final_Long_tp := (long_tp and last_longCondition > nz(last_long_tp[1]) and last_longCondition > nz(last_long_sl[1]))
Final_Short_tp := (short_tp and last_shortCondition > nz(last_short_tp[1]) and last_shortCondition > nz(last_short_sl[1]))
//LONG/SHORT CONDT=================================================================================================================================================================================================================================================================================================
Final_longCondition := is_Long and longCondition
Final_shortCondition := is_Short and shortCondition
//RE-ENTRY ON TP-HIT-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
var float sum_long = 0.0, var float sum_short = 0.0
var float Position_Price = 0.0
if Final_Long_tp
CondIni_long := -1
sum_long := 0.0
nLongs := na
if Final_Short_tp
CondIni_short := 1
sum_short := 0.0
nShorts := na
//BAR COLORS =======================================================================================================================================================================================================================================================================================================
bar_col = L_adx ? color.green : S_adx ? color.red : L_scalp_condt ? color.lime : S_scalp_condt ? color.maroon : color.orange
barcolor(color = bar_col)
//PLOTSPAHES =======================================================================================================================================================================================================================================================================================================
plotshape(Final_longCondition, title="Long", style=shape.triangleup, location=location.belowbar, color=color.blue, size=size.small , transp=0)
plotshape(Final_shortCondition, title="Short", style=shape.triangledown, location=location.abovebar, color=color.red, size=size.small ,transp=0)
plotshape(Final_Long_tp , title = "TP", style = shape.triangledown, location = location.abovebar, text="TP", textcolor=color.red, color = color.red, transp = 0, size = size.tiny)
plotshape(Final_Short_tp , title = "TP", style = shape.triangleup, location = location.belowbar, text="TP", textcolor=color.green,color = color.green, transp = 0, size = size.tiny)
//BACKTESTING--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
g(v, p) => round(v * (pow(10, p))) / pow(10, p)
tp_= input(0.019, step=0.001, title=" TP/100", group= "BACKTEST")
sl_= input(0.081, step=0.001, title=" SL/100", group = "BACKTEST")
if long_ and ACT_BT
strategy.entry("L" ,1, when=L_second_condt and testPeriod )
strategy.exit("S_tp/sl", "L", profit=close * tp_ / syminfo.mintick, loss=close * sl_ / syminfo.mintick)
if long_ and ACT_BT
strategy.entry("S" ,0, when=S_second_condt and testPeriod )
strategy.exit("S_tp/sl", "S", profit=close * tp_ / syminfo.mintick, loss=close * sl_ / syminfo.mintick)
// By wielkieef
Más.