A Momentum Tracking Mean Reversion Strategy
Author: ChaoZhang, Date: 2023-12-19 14:42:26Tags:
Overview
This strategy uses multiple indicators including moving averages, Bollinger Bands, RSI and Stochastics across different timeframes to design a strategy that utilizes momentum indicators to determine market reversals.
How It Works
The core logic of this strategy is to track crosses of short-term and long-term moving averages to identify bottoms and tops, while referring to momentum indicators like RSI and Stochastics for additional confirmation of overbought and oversold conditions.
Specifically, it plots two moving averages with different parameters, a shorter one to determine the current trend and a longer one for the major trend. When the shorter moving average crosses above the longer moving average from below, it signals a reversal and generates a buy signal. When crossing down, it generates a sell signal.
In addition, the strategy also checks whether RSI has entered the oversold territory and if the Stochastics K line has entered the oversold area to confirm bottoming signals. The reverse logic is used to confirm topping signals.
On the exit side, the strategy uses take profit, stop loss and trailing stop mechanisms to manage positions.
Advantage Analysis
This is a strategy combining trend following and reversal identification, while also incorporating momentum indicators. The main advantages are:
-
Crossovers of moving averages are simple yet effective ways to identify reversals. Dual moving average strategies are easy to implement and have good historical performance.
-
Combining indicators like RSI adds reliability to reversal signals, avoiding false signals at non-bottoms or non-tops.
-
Take profit, stop loss and trailing stop mechanisms help lock in profits and control risk.
Risk Analysis
Despite its advantages, some risks to note include:
-
Dual moving average strategies can get whipsawed in ranging markets, frequently opening and closing positions when prices oscillate in sideways moves.
-
Indicators like RSI cannot fully prevent incorrect signals. For example, quickly breaking previous highs could stop RSI from reaching overbought territory.
-
Stop loss levels set too wide increase risk of larger losses. Stop loss percentages need to be adjusted based on the specifics of each market.
Optimization Directions
Some ways this strategy can be further optimized:
-
Different types of moving averages can be tested to find the best fit for the strategy.
-
More complementary indicators like MACD, KDJ, Bollinger Bands can be added to enrich the logic.
-
Machine learning can be used to automatically optimize position sizing and profit taking/stopping parameters.
-
Parameters can be separately optimized for different products based on their characteristics.
Conclusion
In summary, the Momentum Tracking Mean Reversion Strategy is a simple yet practical quant strategy. It uses moving average crossovers to determine reversal points, confirms signal reliability with momentum indicators, and manages positions intelligently to lock in profits and control risk. Easy to understand and implement, it is a good starting point for traders to learn algorithmic trading strategies.
/*backtest
start: 2023-11-18 00:00:00
end: 2023-11-23 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=3
strategy("APEX - Tester - Buy/Sell Strategies - Basic - BACKTESTER", overlay = true)
//study("APEX - Tester - Buy/Sell Strategies - Basic ", overlay = true)
source_main = close
/////////////////////////////////////////////////
// BUY STRATEGIES - SELECTION
/////////////////////////////////////////////////
puppy_sep = input(false, title=" APEX Tester Buy/Sell Basic v01 ")
buy1_sep = input(false, title="▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔" )
buy2_sep = input(false, title="******** BUY STRATEGIES ********")
ma_sep = input(false, title="⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻ MA ⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻")
ma_length_short = input(8, minval=1, title="MA length - short")
ma_length_long = input(9, minval=1, title="MA length - long")
ma_useRes = input(false, title="Check to turn ON Different Time Frame")
ma_candle_period = input("5", title="MA - Different Time Frame")
ma_type = input("T3", title="MA Type", options=["SMA", "EMA", "WMA", "DEMA", "TEMA", "TRIMA", "KAMA", "MAMA", "T3"])
ma_detector = input("Short Crosses Above Long", title="Detector", options=["Short Crosses Above Long",
"Short Above Long","Price Cross Above Short","Price Above Short","Price Cross Above Long","Price Above Long","Price Above Both","Price Below Both"])
ma_use = input(false, title="Use Moving Average ? (On / Off)")
bb_sep = input(false, title="⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻ BB ⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻")
bb_length = input(10, minval=1, title="BB length")
bb_std = input(2.1, minval=0, type = float, title="BB std")
bb_useDifferentRes = input(false, title="Check to turn ON Different Time Frame")
bb_candle_period = input("3", title="BB - Time Frame")
bb_type = input("T3", title="MA", options=["SMA", "EMA", "WMA", "DEMA", "TEMA", "TRIMA", "KAMA", "MAMA", "T3"])
bb_detector = input("Price Cross Below", title="Detector", options=["Price Cross Below", "Price Below", "Price Cross Above", "Price Above"])
bb_use = input(true, title="Use BB ? (On / Off)")
rsi_sep = input(false, title="⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻ RSI ⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻")
rsi_length = input(2, minval=1, title="RSI length")
rsi_useDifferentRes = input(false, title="Check to turn ON Different Time Frame")
rsi_candle_period = input("3", title="STOCH - Time Frame")
rsi_oversold = input(defval = 12 , title = "RSI Oversold", minval=0)
rsi_detector = input("Signal Below Oversold", title="Detector", options=["Signal Below Oversold", "Cross Below Oversold", "Signal Above Oversold", "Cross Above Oversold"])
rsi_use = input(true, title="Use RSI ? (On / Off)")
stoch_sep = input(false, title="⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻ STOCH ⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻")
stoch_useDifferentRes = input(false, title="Check to turn ON Different Time Frame")
stoch_candle_period = input("3", title="STOCH - Time Frame")
stoch_length_fk = input(12, minval=1, title="STOCH fast K")
stoch_length_sk = input(1, minval=1, title="STOCH slow K")
stoch_type_sk = input("EMA", title="STOCH slow K", options=["SMA", "EMA", "WMA", "DEMA", "TEMA", "TRIMA", "KAMA", "MAMA", "T3"])
stoch_length_sd = input(1, minval=1, title="STOCH slow D")
stoch_type_sd = input("EMA", title="STOCH slow D", options=["SMA", "EMA", "WMA", "DEMA", "TEMA", "TRIMA", "KAMA", "MAMA", "T3"])
stoch_oversold = input(defval = 10 , title = "STOCH Oversold Treashold", minval=0)
stoch_detector = input("Signal Below Oversold", title="Detector", options=["Signal Below Oversold", "Cross Below Oversold", "Cross Above Oversold"])
stoch_use = input(true, title="Use STOCH ? (On / Off)")
srsi_sep = input(false, title="⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻ SRSI ⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻")
stochrsi_useDifferentRes= input(false, title="Check to turn ON Different Time Frame")
stochrsi_candle_period = input("3", title="SRSI - Time Frame")
stochrsi_len = input(14, minval=1, title="RSI length")
stochrsi_stoch = input(14, minval=1, title="Time Period")
stochrsi_length_fk = input(3, minval=1, title="Fast K")
stochrsi_length_sd = input(3, minval=1, title="Slow D(or Fast)")
stochrsi_oversold = input(defval = 30 , title = "STOCHRSI Oversold Treashold", minval=0)
stochrsi_detector = input("K Below Oversold", title="Detector", options=["K Cross Above D and Oversold", "K Cross Above D", "K Cross Above Oversold",
"K Cross Below Oversold","K Below Oversold","K Above Oversold"])
stochrsi_use = input(false, title="Use STOCHRSI (On / Off)?")
macd_sep = input(false, title="⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻ MACD ⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻")
macd_fast = input(12, title="MACD fast")
macd_slow = input(26, title="MACD slow")
macd_signal = input(9, title="MACD signal")
macd_useDifferentRes = input(false, title="Check to turn ON Different Time Frame")
macd_candle_period = input("3", title="MACD - Time Frame")
macd_detector = input("MACD Cross Above Signal", title="Detector", options=["MACD Cross Above Signal", "MACD Above Signal", "MACD Below Signal",
"MACD Above Treshold", "MACD Below Treshold", "Centerline Cross Upward", "Centerline Cross Downward"])
macd_treshold = input(defval = 0 , title = "Treshold", type = float)
macd_use = input(false, title="Use MACD (On / Off)?")
cci_sep = input(false, title="⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻ CCI ⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻")
cci_len = input(14, title="CCI Length")
cci_treshold = input(100, title="CCI Treshold")
cci_useDifferentRes = input(false, title="Check to turn ON Different Time Frame")
cci_candle_period = input("3", title="CCI - Time Frame")
cci_detector = input("Signal Below Treshold", title="Detector", options=["Signal Cross Above Treshold", "Signal Above Treshold", "Signal Cross Below Treshold", "Signal Below Treshold"])
cci_use = input(false, title="Use CCI (On / Off)?")
vwap_sep = input(false, title="⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻ VWAP ⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻")
vwap_useRes = input(false, title="Check to turn ON Different Time Frame")
vwap_candle_period = input("5", title="VWAP - Time Frame")
vwap_detector = input("Price Above", title="Detector", options=["Price Cross Above","Price Above","Price Cross Below","Price Below"])
vwap_use = input(false, title="Use VWAP (On / Off)?")
pc_sep = input(false, title="⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻Perc.Chan.⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻")
pc_change = input(-2, type=float, title="Drop Percent")
pc_useDifferentRes = input(false, title="Check to turn ON Different Time Frame")
pc_candle_period = input("3", title="Percent Change - Time Frame")
pc_use = input(false, title="Use Percent Change (On / Off)?")
///////////////////////////////////////////////
// SELL STRATEGIES - SELECTION
///////////////////////////////////////////////
sell0_sep = input(false, title="▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔" )
sell1_sep = input(false, title="******** SELL STRATEGIES ********")
sell_ma_sep = input(false, title="⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻ MA ⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻")
sell_ma_length_short = input(10, minval=1, title="MA length - short")
sell_ma_length_long = input(20, minval=1, title="MA length - long")
sell_ma_useRes = input(false, title="Check to turn ON Different Time Frame")
sell_ma_candle_period = input("5", title="MA - Different Time Frame")
sell_ma_type = input("EMA", title="MA Type", options=["SMA", "EMA", "WMA", "DEMA", "TEMA", "TRIMA", "KAMA", "MAMA", "T3"])
sell_ma_detector = input("Short Crosses Below Long", title="Detector", options=["Short Crosses Below Long",
"Short Below Long","Short Above Long","Price Cross Below Short","Price Below Short","Price Cross Below Long","Price Below Long","Price Above Both MA","Price Below Both MA"])
sell_ma_use = input(true, title="Use Moving Average ? (On / Off)")
sell_bb_sep = input(false, title="⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻ BB ⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻")
sell_bb_length = input(10, minval=1, title="BB length")
sell_bb_std = input(2.1, minval=0, type = float, title="BB std")
sell_bb_useDifferentRes = input(false, title="Check to turn ON Different Time Frame")
sell_bb_candle_period = input("3", title="BB - Time Frame")
sell_bb_type = input("T3", title="MA", options=["SMA", "EMA", "WMA", "DEMA", "TEMA", "TRIMA", "KAMA", "MAMA", "T3"])
sell_bb_detector = input("Price Cross Below", title="Detector", options=["Price Cross Above", "Price Above","Price Cross Below", "Price Below"])
sell_bb_use = input(false, title="Use BB ? (On / Off)")
sell_rsi_sep = input(false, title="⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻ RSI ⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻")
sell_rsi_length = input(2, minval=1, title="RSI length")
sell_rsi_useDifferentRes = input(false, title="Check to turn ON Different Time Frame")
sell_rsi_candle_period = input("3", title="STOCH - Time Frame")
sell_rsi_overbought = input(defval = 12 , title = "RSI Overbought", minval=0)
sell_rsi_detector = input("Signal Above Overbought", title="Detector", options=["Signal Below Overbought", "Cross Below Overbought", "Signal Above Overbought", "Cross Above Overbought"])
sell_rsi_use = input(false, title="Use RSI ? (On / Off)")
sell_stoch_sep = input(false, title="⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻ STOCH ⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻")
sell_stoch_useDifferentRes = input(false, title="Check to turn ON Different Time Frame")
sell_stoch_candle_period = input("3", title="STOCH - Time Frame")
sell_stoch_length_fk = input(12, minval=1, title="STOCH fast K")
sell_stoch_length_sk = input(1, minval=1, title="STOCH slow K")
sell_stoch_type_sk = input("EMA", title="STOCH slow K", options=["SMA", "EMA", "WMA", "DEMA", "TEMA", "TRIMA", "KAMA", "MAMA", "T3"])
sell_stoch_length_sd = input(1, minval=1, title="STOCH slow D")
sell_stoch_type_sd = input("EMA", title="STOCH slow D", options=["SMA", "EMA", "WMA", "DEMA", "TEMA", "TRIMA", "KAMA", "MAMA", "T3"])
sell_stoch_overbought = input(defval = 10 , title = "STOCH Overbought Treashold", minval=0)
sell_stoch_detector = input("Signal Above Overbought", title="Detector", options=["Signal Above Overbought", "Cross Below Overbought", "Cross Above Overbought"])
sell_stoch_use = input(false, title="Use STOCH ? (On / Off)")
sell_stochrsi_sep = input(false, title="⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻ SRSI ⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻")
sell_stochrsi_useDifferentRes = input(false, title="Check to turn ON Different Time Frame")
sell_stochrsi_candle_period = input("3", title="SRSI - Time Frame")
sell_stochrsi_len = input(14, minval=1, title="RSI length")
sell_stochrsi_stoch = input(14, minval=1, title="Time Period")
sell_stochrsi_length_fk = input(3, minval=1, title="Fast K")
sell_stochrsi_length_sd = input(3, minval=1, title="Slow D(or Fast)")
sell_stochrsi_overbought = input(defval = 30 , title = "STOCHRSI Overbought Treashold", minval=0)
sell_stochrsi_detector = input("K Above Overbought", title="Detector", options=["K Cross Above D and Overbought", "K Cross Above D", "K Cross Above Overbought",
"K Cross Below Overbought","K Below Overbought","K Above Overbought"])
sell_stochrsi_use = input(false, title="Use STOCHRSI (On / Off)?")
sell_macd_sep = input(false, title="⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻ MACD ⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻")
sell_macd_fast = input(12, title="MACD fast")
sell_macd_slow = input(26, title="MACD slow")
sell_macd_signal = input(9, title="MACD signal")
sell_macd_useDifferentRes = input(false, title="Check to turn ON Different Time Frame")
sell_macd_candle_period = input("3", title="MACD - Time Frame")
sell_macd_detector = input("MACD Cross Below Signal", title="Detector", options=["MACD Cross Below Signal", "MACD Above Signal", "MACD Below Signal",
"MACD Above Treshold", "MACD Below Treshold", "Centerline Cross Upward", "Centerline Cross Downward"])
sell_macd_treshold = input(defval = 0 , title = "Treshold", type = float)
sell_macd_use = input(false, title="Use MACD (On / Off)?")
sell_cci_sep = input(false, title="⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻ CCI ⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻")
sell_cci_len = input(14, title="CCI Length")
sell_cci_treshold = input(100, title="CCI Treshold")
sell_cci_useDifferentRes = input(false, title="Check to turn ON Different Time Frame")
sell_cci_candle_period = input("3", title="CCI - Time Frame")
sell_cci_detector = input("Signal Below Treshold", title="Detector", options=["Signal Cross Above Treshold", "Signal Above Treshold", "Signal Cross Below Treshold", "Signal Below Treshold"])
sell_cci_use = input(false, title="Use CCI (On / Off)?")
sell_vwap_sep = input(false, title="⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻ VWAP ⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻")
sell_vwap_useRes = input(false, title="Check to turn ON Different Time Frame")
sell_vwap_candle_period = input("5", title="VWAP - Time Frame")
sell_vwap_detector = input("Price Above", title="Detector", options=["Price Cross Above","Price Above","Price Cross Below","Price Below"])
sell_vwap_use = input(false, title="Use VWAP (On / Off)?")
sell_pc_sep = input(false, title="⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻Perc.Chan.⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻")
sell_pc_change = input(2, type=float, title="Rise Percent")
sell_pc_useDifferentRes = input(false, title="Check to turn ON Different Time Frame")
sell_pc_candle_period = input("3", title="Percent Change - Time Frame")
sell_pc_use = input(false, title="Use Percent Change (On / Off)?")
strat1_sep = input(false, title="▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔" )
strat2_sep = input(false, title="******** STRATEGY SETTINGS ********")
///////////////////////////////////////////////
// GLOBAL FUNCTIONS
///////////////////////////////////////////////
kama(src, len)=>
xvnoise = abs(src - src[1])
nfastend = 0.666
nslowend = 0.0645
nsignal = abs(src - src[len])
nnoise = sum(xvnoise, len)
nefratio = iff(nnoise != 0, nsignal / nnoise, 0)
nsmooth = pow(nefratio * (nfastend - nslowend) + nslowend, 2)
nAMA = 0.0
nAMA := nz(nAMA[1]) + nsmooth * (src - nz(nAMA[1]))
mama(src, len)=>
fl=0.5
sl=0.05
pi = 3.1415926
sp = (4*src + 3*src[1] + 2*src[2] + src[3]) / 10.0
p = 0.0
i2 = 0.0
q2 = 0.0
dt = (.0962*sp + .5769*nz(sp[2]) - .5769*nz(sp[4])- .0962*nz(sp[6]))*(.075*nz(p[1]) + .54)
q1 = (.0962*dt + .5769*nz(dt[2]) - .5769*nz(dt[4])- .0962*nz(dt[6]))*(.075*nz(p[1]) + .54)
i1 = nz(dt[3])
jI = (.0962*i1 + .5769*nz(i1[2]) - .5769*nz(i1[4])- .0962*nz(i1[6]))*(.075*nz(p[1]) + .54)
jq = (.0962*q1 + .5769*nz(q1[2]) - .5769*nz(q1[4])- .0962*nz(q1[6]))*(.075*nz(p[1]) + .54)
i2_ = i1 - jq
q2_ = q1 + jI
i2 := .2*i2_ + .8*nz(i2[1])
q2 := .2*q2_ + .8*nz(q2[1])
re_ = i2*nz(i2[1]) + q2*nz(q2[1])
im_ = i2*nz(q2[1]) - q2*nz(i2[1])
re = 0.0
im = 0.0
re := .2*re_ + .8*nz(re[1])
im := .2*im_ + .8*nz(im[1])
p1 = iff(im!=0 and re!=0, 2*pi/atan(im/re), nz(p[1]))
p2 = iff(p1 > 1.5*nz(p1[1]), 1.5*nz(p1[1]), iff(p1 < 0.67*nz(p1[1]), 0.67*nz(p1[1]), p1))
p3 = iff(p2<6, 6, iff (p2 > 50, 50, p2))
p := .2*p3 + .8*nz(p3[1])
spp = 0.0
spp := .33*p + .67*nz(spp[1])
phase = 180/pi * atan(q1 / i1)
dphase_ = nz(phase[1]) - phase
dphase = iff(dphase_< 1, 1, dphase_)
alpha_ = fl / dphase
alpha = iff(alpha_ < sl, sl, iff(alpha_ > fl, fl, alpha_))
mama = 0.0
mama := alpha*src + (1 - alpha)*nz(mama[1])
t3(src, len)=>
xe1_1 = ema(src, len)
xe2_1 = ema(xe1_1, len)
xe3_1 = ema(xe2_1, len)
xe4_1 = ema(xe3_1, len)
xe5_1 = ema(xe4_1, len)
xe6_1 = ema(xe5_1, len)
b_1 = 0.7
c1_1 = -b_1*b_1*b_1
c2_1 = 3*b_1*b_1+3*b_1*b_1*b_1
c3_1 = -6*b_1*b_1-3*b_1-3*b_1*b_1*b_1
c4_1 = 1+3*b_1+b_1*b_1*b_1+3*b_1*b_1
nT3Average_1 = c1_1 * xe6_1 + c2_1 * xe5_1 + c3_1 * xe4_1 + c4_1 * xe3_1
variant(type, src, len) =>
v1 = sma(src, len) // Simple
v2 = ema(src, len) // Exponential
v3 = 2 * v2 - ema(v2, len) // Double Exponential
v4 = 3 * (v2 - ema(v2, len)) + ema(ema(v2, len), len) // Triple Exponential
v5 = wma(src, len) // Weighted
v6 = sma(sma(src, ceil(len / 2)), floor(len / 2) + 1) // TRIMA
v7 = kama(src, len) // KAMA
v8 = mama(src, len) // MAMA
v9 = t3(src, len) // T3
type=="EMA"?v2 : type=="DEMA"?v3 : type=="TEMA"?v4 : type=="WMA"?v5 : type=="TRIMA"?v6 : type=="KAMA"?v7 : type=="MAMA"?v8 : type=="T3"?v9 : v1
calc_cci(src, len, res) =>
cci_ma = sma(src, len)
cci = (src - cci_ma) / (0.015 * dev(src, len))
cci_res = request.security(syminfo.tickerid, res, cci)
calc_macd(macd_fast, macd_slow, src, res) =>
macd = ema(src, macd_fast) - ema(src, macd_slow)
res_macd = request.security(syminfo.tickerid, res, macd)
///////////////////////////////////////////////
// BUY STRATEGIES LOGIC
///////////////////////////////////////////////
//RSI
rsi = rsi(source_main, rsi_length)
per_rsi = rsi_useDifferentRes?request.security(syminfo.tickerid, rsi_candle_period, rsi):rsi
rsiBelow = false
rsiCrossBelow = false
rsiCrossAbove = false
rsiAbove = false
rsiBelow := per_rsi<rsi_oversold
rsiCrossBelow := crossunder(per_rsi, rsi_oversold)
rsiCrossAbove := crossover(per_rsi, rsi_oversold)
rsiAbove := per_rsi>rsi_oversold
rsiBuy = rsi_use ? (
rsi_detector=="Signal Below Oversold"?rsiBelow:
rsi_detector=="Cross Below Oversold"?rsiCrossBelow:
rsi_detector=="Cross Above Oversold"?rsiCrossAbove:
rsi_detector=="Signal Above Oversold"?rsiAbove:
false ) : true
//STOCH
stoch_k = variant(stoch_type_sk, stoch(source_main, high, low, stoch_length_fk), stoch_length_sk)
stoch_d = variant(stoch_type_sd, stoch_k, stoch_length_sd)
per_stoch_k = stoch_useDifferentRes?request.security(syminfo.tickerid, stoch_candle_period, stoch_k):stoch_k
per_stoch_d = stoch_useDifferentRes?request.security(syminfo.tickerid, stoch_candle_period, stoch_d):stoch_d
stochBelow = false
stochCrossBelow = false
stochCrossAbove = false
stochBelow := per_stoch_k<stoch_oversold
stochCrossBelow := crossunder(per_stoch_k, stoch_oversold)
stochCrossAbove := crossover(per_stoch_k, stoch_oversold)
stochBuy = stoch_use ? (
stoch_detector=="Signal Below Oversold"?stochBelow:
stoch_detector=="Cross Below Oversold"?stochCrossBelow:
stoch_detector=="Cross Above Oversold"?stochCrossAbove:
false ) : true
//STOCHRSI
stochrsi_rsi = rsi(source_main, stochrsi_len)
stochrsi_stoch_k = sma(stoch(stochrsi_rsi, stochrsi_rsi, stochrsi_rsi, stochrsi_stoch), stochrsi_length_fk)
stochrsi_stoch_d = sma(stochrsi_stoch_k, stochrsi_length_sd)
per_stochrsi_k = stochrsi_useDifferentRes?request.security(syminfo.tickerid, stochrsi_candle_period, stochrsi_stoch_k):stochrsi_stoch_k
per_stochrsi_d = stochrsi_useDifferentRes?request.security(syminfo.tickerid, stochrsi_candle_period, stochrsi_stoch_d):stochrsi_stoch_d
stochrsiKDCrossOversold = false
stochrsiKDCross = false
stochrsiKCrossAboveOversold = false
stochrsiKCrossBelowOversold = false
stochrsiKBelowOversold = false
stochrsiKAboveOversold = false
stochrsiKDCrossOversold := crossover(per_stochrsi_k, per_stochrsi_d) and per_stochrsi_k<stochrsi_oversold
stochrsiKDCross := crossover(per_stochrsi_k, per_stochrsi_d)
stochrsiKCrossAboveOversold := crossover(per_stochrsi_k, stochrsi_oversold)
stochrsiKCrossBelowOversold := crossunder(per_stochrsi_k, stochrsi_oversold)
stochrsiKBelowOversold := per_stochrsi_k<stochrsi_oversold
stochrsiKAboveOversold := per_stochrsi_k>stochrsi_oversold
stochrsiBuy = stochrsi_use ? (
stochrsi_detector=="K Cross Above D and Oversold"?stochrsiKDCrossOversold:
stochrsi_detector=="K Cross Above D"?stochrsiKDCross:
stochrsi_detector=="K Cross Above Oversold"?stochrsiKCrossAboveOversold:
stochrsi_detector=="K Cross Below Oversold"?stochrsiKCrossBelowOversold:
stochrsi_detector=="K Below Oversold"?stochrsiKBelowOversold:
stochrsi_detector=="K Above Oversold"?stochrsiKAboveOversold:
false ) : true
//CCI
per_cci = calc_cci(hlc3, cci_len, cci_candle_period)
cciBelow = false
cciCrossBelow = false
cciCrossAbove = false
cciAbove = false
cciBelow := per_cci<cci_treshold
cciCrossBelow := crossover(per_cci, cci_treshold)
cciCrossAbove := crossunder(cci_treshold, per_cci)
cciAbove := per_cci>cci_treshold
cciBuy = cci_use ? (
cci_detector=="Signal Below Treshold"?cciBelow:
cci_detector=="Signal Cross Belove Treshold"?cciCrossBelow:
cci_detector=="Signal Cross Above Treshold"?cciCrossAbove:
cci_detector=="Signal Above Treshold"?cciAbove:
false ) : true
//MACD
fastMA = ema(source_main, macd_fast)
slowMA = ema(source_main, macd_slow)
macd = fastMA - slowMA
signal = sma(macd, macd_signal)
delta = macd - signal
outmacd = request.security(syminfo.tickerid, macd_candle_period, macd)
outsignal = request.security(syminfo.tickerid, macd_candle_period, signal)
outdelta = request.security(syminfo.tickerid, macd_candle_period, delta)
plot_macd = macd_useDifferentRes?outmacd:macd
plot_signal = macd_useDifferentRes?outsignal:signal
plot_delta = macd_useDifferentRes?outdelta:delta
MACDCrossAboveSignal = false
CenterlineCrossUpwards = false
CenterlineCrossDownwards = false
MACDAboveSignal = false
MACDBelowSignal = false
MACDAboveTreshold = false
MACDBelowTreshold = false
MACDCrossAboveSignal := crossunder(plot_signal, plot_macd)
CenterlineCrossUpwards := crossover(plot_delta, 0)
CenterlineCrossDownwards := crossunder(plot_delta, 0)
MACDAboveSignal := plot_macd > plot_signal
MACDBelowSignal := plot_macd < plot_signal
MACDAboveTreshold := plot_macd > macd_treshold
MACDBelowTreshold := plot_macd < macd_treshold
macdBuy=macd_use ? (
macd_detector=="MACD Cross Above Signal"?MACDCrossAboveSignal:
macd_detector=="Centerline Cross Upwards"?CenterlineCrossUpwards:
macd_detector=="Centerline Cross Downwards"?CenterlineCrossDownwards:
macd_detector=="MACD above Signal"?MACDAboveSignal:
macd_detector=="MACD below Signal"?MACDBelowSignal:
macd_detector=="MACD above Treshold"?MACDAboveTreshold:
macd_detector=="MACD below Treshold"?MACDBelowTreshold:
false ) : true
//BB
bb_basis = variant(bb_type, source_main, bb_length)
bb_dev = bb_std * stdev(source_main, bb_length)
bb_upper = bb_basis + bb_dev
bb_lower = bb_basis - bb_dev
per_lower_bb = bb_useDifferentRes?request.security(syminfo.tickerid, bb_candle_period, bb_lower):bb_lower
per_upper_bb = bb_useDifferentRes?request.security(syminfo.tickerid, bb_candle_period, bb_upper):bb_upper
per_bb_basis = bb_useDifferentRes?request.security(syminfo.tickerid, bb_candle_period, bb_basis):bb_basis
bbBelow = false
bbCrossBelow = false
bbCrossAbove = false
bbAbove = false
bbBelow := per_lower_bb>close or per_lower_bb>low
bbAbove := per_lower_bb<high or per_lower_bb<close
bbCrossAbove := crossover(source_main, per_lower_bb)
bbCrossBelow := crossunder(source_main, per_lower_bb)
bbBuy = stochrsi_use ? (
bb_detector=="Price Cross Below"?bbCrossBelow:
bb_detector=="Price Below"?bbBelow:
bb_detector=="Price Cross Above"?bbCrossAbove:
bb_detector=="Price Above"?bbAbove:false ) : true
plot(per_bb_basis, color=green, linewidth=2)
p1 = plot(per_upper_bb, color=green)
p2 = plot(per_lower_bb, color=green)
fill(p1, p2)
//MA Calculation
ma_short = variant(ma_type, source_main, ma_length_short)
ma_long = variant(ma_type, source_main, ma_length_long)
per_ma_short = ma_useRes?request.security(syminfo.tickerid, ma_candle_period, ma_short):ma_short
per_ma_long = ma_useRes?request.security(syminfo.tickerid, ma_candle_period, ma_long ):ma_long
p1ma = plot(ma_use?per_ma_short:na, color=green)
p2ma = plot(ma_use?per_ma_long:na , color=red)
ShortCrossesAboveLong = false
ShortAboveLong = false
PriceCrossesAboveShort = false
PriceAboveShort = false
PriceCrossesAboveLong = false
PriceAboveLong = false
PriceAboveBoth = false
PriceBelowBoth = false
ShortCrossesAboveLong := crossover(per_ma_short, per_ma_long)
ShortAboveLong := per_ma_short > per_ma_long
PriceCrossesAboveShort := ( close > per_ma_short or high > per_ma_short ) and low < per_ma_short
PriceAboveShort := close > per_ma_short or high > per_ma_short
PriceCrossesAboveLong := ( close > per_ma_long or high > per_ma_long ) and low < per_ma_long
PriceAboveLong := close > per_ma_long or high > per_ma_long
PriceAboveBoth := ( close > per_ma_long or high > per_ma_long ) and (close > per_ma_short or high > per_ma_short )
PriceBelowBoth := ( close < per_ma_long or low < per_ma_long ) and (close < per_ma_short or low < per_ma_short )
maBuy = ma_use ? ( ma_detector=="Short Crosses Above Long"?ShortCrossesAboveLong:
ma_detector=="Short Above Long"?ShortAboveLong:
ma_detector=="Price Cross Above Short"?PriceCrossesAboveShort:
ma_detector=="Price Above Short"?PriceAboveShort:
ma_detector=="Price Crosses Above Long"?PriceCrossesAboveLong:
ma_detector=="Price Above Long"?PriceAboveLong:
ma_detector=="Price Above Both"?PriceAboveBoth:
ma_detector=="Price Below Both"?PriceBelowBoth:
false ) : true
//VWAP
var_vwap = vwap(hlc3)
per_vwap = vwap_useRes?request.security(syminfo.tickerid,vwap_candle_period,var_vwap):var_vwap
PriceCrossAbove = false
PriceAbove = false
PriceCrossBelow = false
PriceBelow = false
PriceCrossAbove := ( close > per_vwap or high > per_vwap ) and low < per_vwap
PriceAbove := close > per_vwap or high > per_vwap
PriceCrossBelow := ( close < per_vwap or low < per_vwap ) and high > per_vwap
PriceBelow := close < per_vwap or low < per_vwap
vwapBuy = false
vwapBuy := vwap_use ?(
vwap_detector=="Price Cross Above"?PriceCrossAbove:
vwap_detector=="Price Above"?PriceAbove:
vwap_detector=="Price Cross Below"?PriceCrossBelow:
vwap_detector=="Price Below"?PriceBelow:false ) : true
//PC
price_change = (close - close[1])/close[1]*100
per_price_change = pc_useDifferentRes?request.security(syminfo.tickerid, pc_candle_period, price_change):price_change
pcBuy = false
pcBuy := pc_use ? ( per_price_change < pc_change ) : true
///////////////////////////////////////////////
// SELL STRATEGIES LOGIC
///////////////////////////////////////////////
//SELL RSI
sell_rsi = rsi(source_main, sell_rsi_length)
sell_per_rsi = sell_rsi_useDifferentRes?request.security(syminfo.tickerid, sell_rsi_candle_period, sell_rsi):sell_rsi
sell_rsiBelow = false
sell_rsiCrossBelow = false
sell_rsiCrossAbove = false
sell_rsiAbove = false
sell_rsiBelow := sell_per_rsi<sell_rsi_overbought
sell_rsiCrossBelow := crossunder(sell_per_rsi, sell_rsi_overbought)
sell_rsiCrossAbove := crossover(sell_per_rsi, sell_rsi_overbought)
sell_rsiAbove := sell_per_rsi>sell_rsi_overbought
sell_rsiBuy = sell_rsi_use ? (
sell_rsi_detector=="Signal Below Overbought"?sell_rsiBelow:
sell_rsi_detector=="Cross Below Overbought"?sell_rsiCrossBelow:
sell_rsi_detector=="Cross Above Overbought"?sell_rsiCrossAbove:
sell_rsi_detector=="Signal Above Overbought"?sell_rsiAbove:
false ) : true
//SELL STOCH
sell_stoch_k = variant(sell_stoch_type_sk, stoch(source_main, high, low, sell_stoch_length_fk), sell_stoch_length_sk)
sell_stoch_d = variant(sell_stoch_type_sd, sell_stoch_k, sell_stoch_length_sd)
sell_per_stoch_k = sell_stoch_useDifferentRes?request.security(syminfo.tickerid, sell_stoch_candle_period, sell_stoch_k):sell_stoch_k
sell_per_stoch_d = sell_stoch_useDifferentRes?request.security(syminfo.tickerid, sell_stoch_candle_period, sell_stoch_d):sell_stoch_d
sell_stochAbove = false
sell_stochBelow = false
sell_stochCrossAbove = false
sell_stochAbove := sell_per_stoch_k>sell_stoch_overbought
sell_stochBelow := sell_per_stoch_k<sell_stoch_overbought
sell_stochCrossAbove := crossover(sell_per_stoch_k, sell_stoch_overbought)
sell_stochBuy = sell_stoch_use ? (
sell_stoch_detector=="Signal Above Overbought"?sell_stochAbove:
sell_stoch_detector=="Signal Below Overbought"?sell_stochBelow:
sell_stoch_detector=="Cross Above Overbought"?sell_stochCrossAbove:
false ) : true
//SELL STOCHRSI
sell_stochrsi_rsi = rsi(source_main, sell_stochrsi_len)
sell_stochrsi_stoch_k = sma(stoch(sell_stochrsi_rsi, sell_stochrsi_rsi, sell_stochrsi_rsi, sell_stochrsi_stoch), sell_stochrsi_length_fk)
sell_stochrsi_stoch_d = sma(sell_stochrsi_stoch_k, sell_stochrsi_length_sd)
sell_per_stochrsi_k = sell_stochrsi_useDifferentRes?request.security(syminfo.tickerid, sell_stochrsi_candle_period, sell_stochrsi_stoch_k):sell_stochrsi_stoch_k
sell_per_stochrsi_d = sell_stochrsi_useDifferentRes?request.security(syminfo.tickerid, sell_stochrsi_candle_period, sell_stochrsi_stoch_d):sell_stochrsi_stoch_d
sell_stochrsiKDCrossOverbought = false
sell_stochrsiKDCross = false
sell_stochrsiKCrossAboveOverbought = false
sell_stochrsiKCrossBelowOverbought = false
sell_stochrsiKBelowOverbought = false
sell_stochrsiKAboveOverbought = false
sell_stochrsiKDCrossOverbought := crossover(sell_per_stochrsi_k, sell_per_stochrsi_d) and sell_per_stochrsi_k>sell_stochrsi_overbought
sell_stochrsiKDCross := crossover(sell_per_stochrsi_k, sell_per_stochrsi_d)
sell_stochrsiKCrossAboveOverbought := crossover(sell_per_stochrsi_k, sell_stochrsi_overbought)
sell_stochrsiKCrossBelowOverbought := crossunder(sell_per_stochrsi_k, sell_stochrsi_overbought)
sell_stochrsiKBelowOverbought := sell_per_stochrsi_k<sell_stochrsi_overbought
sell_stochrsiKAboveOverbought := sell_per_stochrsi_k>sell_stochrsi_overbought
sell_stochrsiBuy = sell_stochrsi_use ? (
sell_stochrsi_detector=="K Cross Below D and Overbought"?sell_stochrsiKDCrossOverbought:
sell_stochrsi_detector=="K Cross Below D"?sell_stochrsiKDCross:
sell_stochrsi_detector=="K Cross Above Overbought"?sell_stochrsiKCrossAboveOverbought:
sell_stochrsi_detector=="K Cross Below Overbought"?sell_stochrsiKCrossBelowOverbought:
sell_stochrsi_detector=="K Below Overbought"?sell_stochrsiKBelowOverbought:
sell_stochrsi_detector=="K Above Overbought"?sell_stochrsiKAboveOverbought:
false ) : true
//SELL CCI
sell_per_cci = calc_cci(hlc3, sell_cci_len, sell_cci_candle_period)
sell_cciBelow = false
sell_cciCrossBelow = false
sell_cciCrossAbove = false
sell_cciAbove = false
sell_cciBelow := sell_per_cci<sell_cci_treshold
sell_cciCrossBelow := crossunder(sell_per_cci, sell_cci_treshold)
sell_cciCrossAbove := crossover(sell_cci_treshold, sell_per_cci)
sell_cciAbove := sell_per_cci>sell_cci_treshold
sell_cciBuy = sell_cci_use ? (
sell_cci_detector=="Signal Below Treshold"?sell_cciBelow:
sell_cci_detector=="Signal Cross Belove Treshold"?sell_cciCrossBelow:
sell_cci_detector=="Signal Cross Above Treshold"?sell_cciCrossAbove:
sell_cci_detector=="Signal Above Treshold"?sell_cciAbove:
false ) : true
//SELL MACD
sell_fastMA = ema(close, sell_macd_fast)
sell_slowMA = ema(close, sell_macd_slow)
sell_macd = sell_fastMA - sell_slowMA
sell_signal = sma(sell_macd, sell_macd_signal)
sell_delta = sell_macd - sell_signal
sell_outmacd = request.security(syminfo.tickerid, sell_macd_candle_period, sell_macd)
sell_outsignal = request.security(syminfo.tickerid, sell_macd_candle_period, sell_signal)
sell_outdelta = request.security(syminfo.tickerid, sell_macd_candle_period, sell_delta)
sell_plot_macd = sell_macd_useDifferentRes?sell_outmacd:sell_macd
sell_plot_signal = sell_macd_useDifferentRes?sell_outsignal:sell_signal
sell_plot_delta = sell_macd_useDifferentRes?sell_outdelta:sell_delta
sell_MACDCrossBelowSignal = false
sell_CenterlineCrossUpwards = false
sell_CenterlineCrossDownwards = false
sell_MACDAboveSignal = false
sell_MACDBelowSignal = false
sell_MACDAboveTreshold = false
sell_MACDBelowTreshold = false
sell_MACDCrossBelowSignal := crossover(sell_plot_signal, sell_plot_macd)
sell_CenterlineCrossUpwards := crossover(sell_plot_delta, 0.0)
sell_CenterlineCrossDownwards := crossunder(sell_plot_delta, 0.0)
sell_MACDAboveSignal := sell_plot_macd > sell_plot_signal
sell_MACDBelowSignal := sell_plot_macd < sell_plot_signal
sell_MACDAboveTreshold := sell_plot_macd > sell_macd_treshold
sell_MACDBelowTreshold := sell_plot_macd < sell_macd_treshold
sell_macdBuy=sell_macd_use ? (
sell_macd_detector=="MACD Cross Below Signal"?sell_MACDCrossBelowSignal:
sell_macd_detector=="Centerline Cross Upwards"?sell_CenterlineCrossUpwards:
sell_macd_detector=="Centerline Cross Downwards"?sell_CenterlineCrossDownwards:
sell_macd_detector=="MACD above Signal"?sell_MACDAboveSignal:
sell_macd_detector=="MACD below Signal"?sell_MACDBelowSignal:
sell_macd_detector=="MACD above Treshold"?sell_MACDAboveTreshold:
sell_macd_detector=="MACD below Treshold"?sell_MACDBelowTreshold:
false ) : true
//SELL BB
sell_bb_basis = variant(bb_type, source_main, sell_bb_length)
sell_bb_dev = sell_bb_std * stdev(source_main, sell_bb_length)
sell_bb_upper = sell_bb_basis + sell_bb_dev
sell_bb_lower = sell_bb_basis - sell_bb_dev
sell_per_lower_bb = sell_bb_useDifferentRes?request.security(syminfo.tickerid, sell_bb_candle_period, sell_bb_lower):sell_bb_lower
sell_per_upper_bb = sell_bb_useDifferentRes?request.security(syminfo.tickerid, sell_bb_candle_period, sell_bb_upper):sell_bb_upper
sell_per_bb_basis = sell_bb_useDifferentRes?request.security(syminfo.tickerid, sell_bb_candle_period, sell_bb_basis):sell_bb_basis
sell_bbBelow = false
sell_bbCrossBelow = false
sell_bbCrossAbove = false
sell_bbAbove = false
sell_bbBelow := sell_per_upper_bb>close or sell_per_upper_bb>low
sell_bbAbove := sell_per_upper_bb<high or sell_per_upper_bb<close
sell_bbCrossAbove := crossover(source_main, sell_per_upper_bb)
sell_bbCrossBelow := crossunder(source_main, sell_per_upper_bb)
sell_bbBuy = sell_bb_use ? (
sell_bb_detector=="Price Cross Below"?sell_bbCrossBelow:
sell_bb_detector=="Price Below"?sell_bbBelow:
sell_bb_detector=="Price Cross Above"?sell_bbCrossAbove:
sell_bb_detector=="Price Above"?sell_bbAbove:false ) : true
//SELL MA Calculation
sell_ma_short = variant(sell_ma_type, source_main, sell_ma_length_short)
sell_ma_long = variant(sell_ma_type, source_main, sell_ma_length_long)
sell_per_ma_short = sell_ma_useRes?request.security(syminfo.tickerid, sell_ma_candle_period, sell_ma_short):sell_ma_short
sell_per_ma_long = sell_ma_useRes?request.security(syminfo.tickerid, sell_ma_candle_period, sell_ma_long ):sell_ma_long
sell_p1ma = plot(sell_ma_use?sell_per_ma_short:na, color=green)
sell_p2ma = plot(sell_ma_use?sell_per_ma_long:na , color=red)
sell_ShortCrossesBelowLong = false
sell_ShortBelowLong = false
sell_ShortAboveLong = false
sell_PriceCrossesBelowShort = false
sell_PriceBelowShort = false
sell_PriceCrossesBelowLong = false
sell_PriceBelowLong = false
sell_PriceAboveBoth = false
sell_PriceBelowBoth = false
sell_ShortCrossesBelowLong := crossunder(sell_per_ma_short, sell_per_ma_long)
sell_ShortBelowLong := sell_per_ma_short < sell_per_ma_long
sell_ShortAboveLong := sell_per_ma_short > sell_per_ma_long
sell_PriceCrossesBelowShort := ( close > sell_per_ma_short or high > sell_per_ma_short ) and low < sell_per_ma_short
sell_PriceBelowShort := close > sell_per_ma_short or high > sell_per_ma_short
sell_PriceCrossesBelowLong := ( close > sell_per_ma_long or high > sell_per_ma_long ) and low < sell_per_ma_long
sell_PriceBelowLong := close > sell_per_ma_long or high > sell_per_ma_long
sell_PriceAboveBoth := ( close > sell_per_ma_long or high > sell_per_ma_long ) and (close > sell_per_ma_short or high > sell_per_ma_short )
sell_PriceBelowBoth := ( close < sell_per_ma_long or low < sell_per_ma_long ) and (close < sell_per_ma_short or low < sell_per_ma_short )
sell_maBuy = sell_ma_use ? (
sell_ma_detector=="Short Crosses Below Long"?sell_ShortCrossesBelowLong:
sell_ma_detector=="Short Below Long"?sell_ShortBelowLong :
sell_ma_detector=="Price Cross Below Short"?sell_PriceCrossesBelowShort:
sell_ma_detector=="Price Below Short"?sell_PriceBelowShort:
sell_ma_detector=="Price Cross Below Long"?sell_PriceBelowShort:
sell_ma_detector=="Price Below Long"?sell_PriceCrossesBelowLong:
sell_ma_detector=="Price Above Both"?sell_PriceAboveBoth:
sell_ma_detector=="Price Below Both"?sell_PriceBelowBoth:
false ) : true
//SELL VWAP
sell_var_vwap = vwap(hlc3)
sell_per_vwap = sell_vwap_useRes?request.security(syminfo.tickerid,sell_vwap_candle_period,sell_var_vwap):sell_var_vwap
sell_PriceCrossAbove = false
sell_PriceAbove = false
sell_PriceCrossBelow = false
sell_PriceBelow = false
sell_PriceCrossAbove := ( close > sell_per_vwap or high > sell_per_vwap ) and low < sell_per_vwap
sell_PriceAbove := close > sell_per_vwap or high > sell_per_vwap
sell_PriceCrossBelow := ( close < sell_per_vwap or low < sell_per_vwap ) and high > sell_per_vwap
sell_PriceBelow := close < sell_per_vwap or low < sell_per_vwap
sell_vwapBuy = false
sell_vwapBuy := sell_vwap_use ?(
sell_vwap_detector=="Price Cross Above"?sell_PriceCrossAbove:
sell_vwap_detector=="Price Above"?sell_PriceAbove:
sell_vwap_detector=="Price Cross Below"?sell_PriceCrossBelow:
sell_vwap_detector=="Price Below"?sell_PriceBelow:false ) : true
//PC
sell_price_change = (close - close[1])/close[1]*100
sell_per_price_change = sell_pc_useDifferentRes?request.security(syminfo.tickerid, sell_pc_candle_period, sell_price_change):sell_price_change
sell_pcBuy = false
sell_pcBuy := sell_pc_use ? ( sell_per_price_change > sell_pc_change ) : true
///////////////////////////////////////////////
// MAIN LOGIC
///////////////////////////////////////////////
allBuy = false
allBuy := rsiBuy and bbBuy and stochBuy and stochrsiBuy and cciBuy and macdBuy and maBuy and vwapBuy and pcBuy
allSell = false
allSell := sell_rsiBuy and sell_bbBuy and sell_stochBuy and sell_stochrsiBuy and sell_cciBuy and sell_macdBuy and sell_maBuy and sell_vwapBuy and sell_pcBuy
buy = allBuy
sell = (
sell_pc_use?sell_pcBuy:false or
sell_vwap_use?sell_vwapBuy:false or
sell_rsi_use?sell_rsiBuy:false or
sell_ma_use?sell_maBuy:false or
sell_bb_use?sell_bbBuy:false or
sell_cci_use?sell_cciBuy:false or
sell_macd_use?sell_macdBuy:false or
sell_stoch_use?sell_stochBuy:false or
sell_stochrsi_use?sell_stochrsiBuy:false ) ? true : false
//////////////////////////////////////////////////////////////////////////////////////////
//*** This Trade Management Section of code is a modified version of that found in ***//
//*** "How to automate this strategy for free using a chrome extension" by CryptoRox ***//
//*** Modifications and tradeState engine by JustUncleL. ***//
//////////////////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////
//* Backtesting Period Selector | Component *//
///////////////////////////////////////////////
// * https://www.tradingview.com/script/eCC1cvxQ-Backtesting-Period-Selector-Component *//
// * https://www.tradingview.com/u/pbergden/ *//
// * Modifications made by JustUncleL*//
testStartYear = input(2018, "Backtest Start Year",minval=1980)
testStartMonth = input(9, "Backtest Start Month",minval=1,maxval=12)
testStartDay = input(20, "Backtest Start Day",minval=1,maxval=31)
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)
testStopYear = 9999 //input(9999, "Backtest Stop Year",minval=1980)
testStopMonth = 12 // input(12, "Backtest Stop Month",minval=1,maxval=12)
testStopDay = 31 //input(31, "Backtest Stop Day",minval=1,maxval=31)
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)
testPeriod() => time >= testPeriodStart and time <= testPeriodStop ? true : false
//////////////////////////
//* Strategy Component *//
//////////////////////////
high_ = high
low_ = low
AQUA = #00FFFFFF
BLUE = #0000FFFF
RED = #FF0000FF
LIME = #00FF00FF
GRAY = #808080FF
DARKRED = #8B0000FF
DARKGREEN = #006400FF
//
//fastExit = input(false,title="Use Opposite Trade as a Close Signal")
//clrBars = input(true,title="Colour Candles to Trade Order state")
fastExit = true
clrBars = false
//orderType = input("LongsOnly",title="What type of Orders", options=["Longs+Shorts","LongsOnly","ShortsOnly","Flip"])
orderType = "LongsOnly"
//
isLong = (orderType != "ShortsOnly")
isShort = (orderType != "LongsOnly")
//////////////////////////////////////////////////
//* Put Entry and special Exit conditions here *//
//////////////////////////////////////////////////
//////////////////////////
//* tradeState Engine *//
INACTIVE = 0 // No trades open
ACTIVELONG = 1 // Long Trade Started
ACTIVESHORT = -1 // Short Trade Started
//
//////////////////////////
// Keep track of current trade state
longClose = false, longClose := nz(longClose[1],false)
shortClose = false, shortClose := nz(shortClose[1],false)
tradeState = INACTIVE, tradeState := nz(tradeState[1])
tradeState := tradeState==INACTIVE ? buy==1 and (barstate.isconfirmed or barstate.ishistory) and isLong and not longClose and not shortClose? ACTIVELONG :
sell==1 and (barstate.isconfirmed or barstate.ishistory) and isShort and not longClose and not shortClose? ACTIVESHORT :
tradeState : tradeState
//Entry Triggers, this happens when tradeState changes from neutral to active
longCondition = false
shortCondition = false
longCondition := change(tradeState) and tradeState==ACTIVELONG
shortCondition := change(tradeState) and tradeState==ACTIVESHORT
if orderType=="Flip"
temp = longCondition
longCondition := shortCondition
shortCondition := temp
//end if
//SPECIAL Exit Condition.
// Exit on Average Fast/Slow MA cross over, force no repaint
longExitC = sell ? 1 : 0
shortExitC = 0
// Exit Trigger without SL set and trade Actine
longExit = change(longExitC) and longExitC==1 and tradeState==1
shortExit = change(shortExitC) and shortExitC==1 and tradeState==-1
// -- debugs
//plotchar(tradeState,"tradeState at Event",location=location.bottom, color=na)
//plotchar(longCondition, title="longCondition",color=na)
//plotchar(shortCondition, title="shortCondition",color=na)
//plotchar(tradeState, title="tradeState",color=na)
// -- /debugs
/////////////////////////////////////
//======[ Deal Entry Prices ]======//
/////////////////////////////////////
last_open_longCondition = na
last_open_shortCondition = na
last_open_longCondition := longCondition ? close : nz(last_open_longCondition[1])
last_open_shortCondition := shortCondition ? close : nz(last_open_shortCondition[1])
//////////////////////////////////
//======[ Position State ]======//
//////////////////////////////////
in_longCondition = tradeState == ACTIVELONG
in_shortCondition = tradeState == ACTIVESHORT
/////////////////////////////////
//======[ Trailing Stop ]======//
/////////////////////////////////
// This Trailing Stop Starts as soon as trade is Started
isTS = input(false, "Trailing Stop")
ts = input(3.0, "Trailing Stop (%)", minval=0,step=0.1, type=float) /100
// Initialise and track highs and lows
short_ts = false, long_ts = false
last_high = 0.0, last_high := nz(last_high[1],na)
last_low = 0.0, last_low := nz(last_low[1],na)
last_high_short = 0.0, last_high_short := nz(last_high_short[1],na)
last_low_long = 0.0, last_low_long := nz(last_low_long[1],na)
// LONGS TSL
if in_longCondition == true
last_high := (na(last_high) or high_ > last_high) ? high_ : last_high
last_low_long := (na(last_low_long) or low_ < last_low_long) ? low_ : last_low_long
long_ts := isTS and (low_ <= last_high - last_high * ts)
//else
if in_longCondition == false
long_ts := false
last_high := na
last_low_long := na
//end if
//SHORTS TSL
if in_shortCondition == true
last_low := (na(last_low) or low_ < last_low) ? low_ : last_low
last_high_short := (na(last_high_short) or high_ > last_high_short) ? high_ : last_high_short
short_ts := isTS and (high_ >= last_low + last_low * ts)
if in_shortCondition == false
short_ts := false
last_low := na
last_high_short := na
//end if
///////////////////////////////
//======[ Take Profit ]======//
///////////////////////////////
isTP = input(true, "Take Profit")
tp = input(1.0, "Take Profit (%)",minval=0,step=0.1,type=float) / 100
ttp = input(0.0, "Trailing Profit (%)",minval=0,step=0.1,type=float) / 100
ttp := ttp>tp ? tp : ttp
long_tp = isTP and in_longCondition and (last_high >= last_open_longCondition + last_open_longCondition * tp) and (low_ <= last_high - last_high * ttp)
short_tp = isTP and in_shortCondition and (last_low <= last_open_shortCondition - last_open_shortCondition * tp) and (high_ >= last_low + last_low * ttp)
/////////////////////////////
//======[ Stop Loss ]======//
/////////////////////////////
isSL = input(true, "Stop Loss")
sl = input(2.0, "Stop Loss (%)", minval=0,step=0.1, type=float) / 100
long_sl = isSL and in_longCondition and (low_ <= last_open_longCondition - last_open_longCondition * sl)
short_sl = isSL and in_shortCondition and (high_ >= last_open_shortCondition + last_open_shortCondition * sl)
////////////////////////////////////
//======[ Stop on Opposite ]======//
////////////////////////////////////
//NOTE Short exit signal is non-repainting, no need to force it, if Pyramiding keep going
long_sos = (fastExit or (not isTS and not isSL)) and longExit and in_longCondition
short_sos = (fastExit or (not isTS and not isSL)) and shortExit and in_shortCondition
/////////////////////////////////
//======[ Close Signals ]======//
/////////////////////////////////
// Create a single close for all the different closing conditions, all conditions here are non-repainting
longClose := isLong and (long_tp or long_sl or long_ts or long_sos) and not longCondition
shortClose := isShort and (short_tp or short_sl or short_ts or short_sos) and not shortCondition
///////////////////////////////
//======[ Plot Colors ]======//
///////////////////////////////
longCloseCol = na
shortCloseCol = na
longCloseCol := long_tp ? green : long_sl ? maroon : long_ts ? purple : long_sos ? orange :longCloseCol[1]
shortCloseCol := short_tp ? green : short_sl ? maroon : short_ts ? purple : short_sos ? orange : shortCloseCol[1]
//
tpColor = isTP and in_longCondition ? lime : isTP and in_shortCondition ? lime : na
slColor = isSL and in_longCondition ? red : isSL and in_shortCondition ? red : na
//////////////////////////////////
//======[ Strategy Plots ]======//
//////////////////////////////////
//LONGS
plot(isTS and in_longCondition?
last_high - last_high * ts : na, "Buy Trailing", fuchsia, style=2, linewidth=1,offset=1)
plot(isTP and in_longCondition and last_high < last_open_longCondition + last_open_longCondition * tp ?
last_open_longCondition + last_open_longCondition * tp : na, "Long TP Active", tpColor, style=3,join=false, linewidth=1,offset=1)
plot(isTP and in_longCondition and last_high >= last_open_longCondition + last_open_longCondition * tp ?
last_high - last_high * ttp : na, "Buy Trailing", black, style=2, linewidth=1,offset=1)
plot(isSL and in_longCondition and last_low_long > last_open_longCondition - last_open_longCondition * sl ?
last_open_longCondition - last_open_longCondition * sl : na, "Long SL", slColor, style=3,join=false, linewidth=1,offset=1)
//SHORTS
plot(isTS and in_shortCondition?
last_low + last_low * ts : na, "Short Trailing", fuchsia, style=2, linewidth=1,offset=1)
plot(isTP and in_shortCondition and last_low > last_open_shortCondition - last_open_shortCondition * tp ?
last_open_shortCondition - last_open_shortCondition * tp : na, "Short TP Active", tpColor, style=3,join=false, linewidth=1,offset=1)
plot(isTP and in_shortCondition and last_low <= last_open_shortCondition - last_open_shortCondition * tp ?
last_low + last_low * ttp : na, "Short Trailing", black, style=2, linewidth=1,offset=1)
plot(isSL and in_shortCondition and last_high_short < last_open_shortCondition + last_open_shortCondition * sl ?
last_open_shortCondition + last_open_shortCondition * sl : na, "Short SL", slColor, style=3,join=false, linewidth=1,offset=1)
// Colour code the candles for Profit/Loss: Profit=LIGHT colour, Loss=DARK colour
bclr = not clrBars ? na : tradeState==INACTIVE ? GRAY :
in_longCondition ? close<last_open_longCondition? DARKGREEN : LIME :
in_shortCondition ? close>last_open_shortCondition? DARKRED : RED : GRAY
barcolor(bclr,title="Trade State Bar Colouring")
///////////////////////////////
//======[ Alert Plots ]======//
///////////////////////////////
// //LONGS
// plotshape(longCondition?close:na, title="Buy", color=green, textcolor=green, transp=0,
// style=shape.triangleup, location=location.belowbar, size=size.small,text="Buy",offset=0)
// plotshape(longClose?close:na, title="Sell", color=longCloseCol, textcolor=white, transp=0,
// style=shape.labeldown, location=location.abovebar, size=size.small,text="Sell",offset=0)
// //SHORTS
// plotshape(shortCondition?close:na, title="Short", color=red, textcolor=red, transp=0,
// style=shape.triangledown, location=location.abovebar, size=size.small,text="SHORT",offset=0)
// plotshape(shortClose?close:na, title="Short Close", color=shortCloseCol, textcolor=white, transp=0,
// style=shape.labelup, location=location.belowbar, size=size.small,text="Short",offset=0)
// Autoview alert syntax - This assumes you are trading coins BUY and SELL on Binance Exchange
// WARNING*** Only use Autoview to automate a strategy after you've sufficiently backtested and forward tested the strategy.
// You can learn more about the syntax here:
// http://autoview.with.pink/#syntax and you can watch this video here: https://www.youtube.com/watch?v=epN5Tjinuxw
// For the opens you will want to trigger BUY orders on LONGS (eg ETHBTC) with alert option "Once Per Bar Close"
// and SELL orders on SHORTS (eg BTCUSDT)
// b=buy q=0.001 e=binance s=ethbtc u=currency t=market ( LONG )
// or b=sell q=0.001 e=binance s=btcusdt t=market ( SHORT )
//alertcondition(longCondition, "Open Long", "LONG")
//alertcondition(shortCondition, "Open Short", "SHORT")
// For the closes you will want to trigger these alerts on condition with alert option "Once Per Bar"
// (NOTE: with Renko you can only use "Once Per Bar Close" option)
// b=sell q=99% e=binance s=ethbtc t=market ( CLOSE LONGS )
// or b=buy q=99% e=binance s=btcusdt u=currency t=market ( CLOSE SHORTS )
// This gets it as it happens and typically results in a better exit live than in the backtest.
// It works really well for counteracting some market slippage
//alertcondition(longClose, "Close Longs", "CLOSE LONGS")
//alertcondition(shortClose, "Close Shorts", "CLOSE SHORTS")
////////////////////////////////////////////
//======[ Strategy Entry and Exits ]======//
////////////////////////////////////////////
if testPeriod() and isLong
strategy.entry("Long", 1, when=longCondition)
strategy.close("Long", when=longClose )
//if testPeriod() and isShort
// strategy.entry("Short", 0, when=shortCondition)
// strategy.close("Short", when=shortClose )
// --- Debugs
//plotchar(longExit,title="longExit",location=location.bottom,color=na)
//plotchar(longCondition,title="longCondition",location=location.bottom,color=na)
//plotchar(in_longCondition,title="in_longCondition",location=location.bottom,color=na)
//plotchar(longClose,title="longClose",location=location.bottom,color=na,color=na)
//plotchar(buy,title="buy",location=location.bottom,color=na)
// --- /Debugs
///////////////////////////////////
//======[ Reset Variables ]======//
///////////////////////////////////
if longClose or shortClose
tradeState := INACTIVE
in_longCondition := false
in_shortCondition := false
last_low := na
last_low_long := na
last_high := na
last_high_short := na
// EOF
//-- SUPPORT/RESISTANCE LINES by:ByDipsOnly -----------------------------------------------------------------------------
sr_sep = input(false, title="⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻ S/R Lines ⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻⎻")
show_SPlines_input = input(true, "Show S/R Lines")
tf = timeframe.period
vamp = input(title="VolumeMA", defval=6)
vam = sma(volume, vamp)
upside = high[3]>high[4] and high[4]>high[5] and high[2]<high[3] and high[1]<high[2] and volume[3]>vam[3]
downside = low[3]<low[4] and low[4]<low[5] and low[2]>low[3] and low[1]>low[2] and volume[3]>vam[3]
calcup() =>
fractalup = na
fractalup := upside ? high[3] : fractalup[1]
calcdown() =>
fractaldown = na
fractaldown := downside ? low[3] : fractaldown[1]
fuptf = request.security(syminfo.tickerid,tf == "current" ? timeframe.period : tf, calcup())
fdowntf = request.security(syminfo.tickerid,tf == "current" ? timeframe.period : tf, calcdown())
plotup = show_SPlines_input==true?fuptf:na
plotdown = show_SPlines_input==true?fdowntf:na
plot(plotup, "FractalUp", color=yellow, linewidth=1, style=cross, transp=0, offset =-3, join=false)
plot(plotdown, "FractalDown", color=blue, linewidth=1, style=cross, transp=0, offset=-3, join=false)
fractalupalert = na
fractalup = na
fractalup := upside ? high[3] : fractalup[1]
fractalupalert := high[3] > open or fractalup[1] > open
alertcondition(show_SPlines_input?fractalupalert:na, title="R Line", message='R Line')
//-- END SUPPORT/RESISTANCE LINES -------------------------------------------------------------------------------------------
More
- Momentum Breakout Trading Strategy
- Ichimoku Moving Average Crossover Strategy
- Momentum and Volume Trading Strategy
- Fractal Breakout Strategy
- Bill Williams Awesome Oscillator Trading Strategy
- Volatility Finite Volume Elements Strategy
- This BIST stocks 4-stage quantitative acquisition strategy
- Kifier's Hidden MFI/STOCH Divergence/Trend Breaker Trading Strategy
- MACD Quantitative Trading Strategy
- Dual Moving Average Trend Tracking Strategy
- Directional Movement Index Dual-direction Trading Strategy
- Bollinger Band Breakout Trading Strategy
- Laguerre RSI Trading Strategy
- Dynamic Re-entry Buy-only Strategy
- The Solid as a Rock VIP Quant Strategy
- Golden Cross Optimized Moving Average Crossover Trading Strategy
- Crossing Moving Average Strategy
- The Wave Trend Trading Strategy Based on LazyBear
- Eight Day Extended Run Strategy
- Moving Average Pullback Strategy