//@version=5nbnb

//
VERSION = 'v13'// 2024.3.20
strategy(
'ALGOX',
shorttitle = 'ALGOX ' + VERSION,
overlay = true,
explicit_plot_zorder = true,
pyramiding = 0,
default_qty_type = strategy.percent_of_equity,
default_qty_value = 50,
calc_on_every_tick = false,
process_orders_on_close = true,
max_bars_back = 500,
initial_capital = 5000,
commission_type = strategy.commission.percent,
commission_value = 0.02
)

//Truncate Function
truncate(number, decimals) =>
factor = math.pow(10, decimals)
int(number * factor) / factor

//
// === INPUTS ===
TPSType = input.string('Trailing', 'What TPS should be taken : ', options =
['ATR', 'Trailing', 'Options'])
setupType = input.string('Open/Close', title='What Trading Setup should be taken :
', options=['Open/Close', 'Renko'])
scolor = input(true, title='Show coloured Bars to indicate Trend?')
almaRibbon = input(false, title='Enable Ribbon?')
//tradeType = input.string('BOTH', title='What trades should be taken : ',
options=['LONG', 'SHORT', 'BOTH', 'NONE'])
// === /INPUTS ===

// Display the probabilities in a table

//text01_ = str.tostring(timeframe.multiplier * intRes, '####')

//t = timenow + math.round(ta.change(time) * 25)

//var label lab01 = na
//label.delete(lab01)
//lab01 := label.new(t, close, text=text01_, style=label.style_label_left,
yloc=yloc.price, xloc=xloc.bar_time, textalign=text.align_left,
textcolor=color.white)

// Constants colours that include fully non-transparent option.

green100 = #008000FF
lime100 = #00FF00FF
red100 = #FF0000FF
blue100 = #0000FFFF
aqua100 = #00FFFFFF
darkred100 = #8B0000FF
gray100 = #808080FF

/////////////////////////////////////////////
// Create non-repainting security function
rp_security(_symbol, _res, _src) =>
request.security(_symbol, _res, _src[1])
//
f_tfInMinutes() =>
_tfInMinutes = timeframe.period == '1' ? '3' : timeframe.period == '3' ? '5' :
timeframe.period == '5' ? '15' : timeframe.period == '15' ? '30' : timeframe.period
== '30' ? '60' : timeframe.period == '60' ? '240' : 'D'
_tfInMinutes
my_time1 = f_tfInMinutes()

tfmult = 18 //input.int(18, "Input Timeframe Multiplier")

f_resInMinutes() =>
_resInMinutes = timeframe.multiplier * (
timeframe.isseconds ? 1. / 60. :
timeframe.isminutes ? 1. :
timeframe.isdaily ? 1440. :
timeframe.isweekly ? 10080. :
timeframe.ismonthly ? 43800. : na)
my_time = str.tostring(f_resInMinutes()*tfmult)

useSource = close //input.string('Close', 'What Source to be used?', options =

['Close', 'HL2'])
enableFilter = input(true, "Enable Backtesting Range Filtering")
fromDate = input.time(timestamp("01 Jan 2023 00:00 +0300"), "Start Date")
toDate = input.time(timestamp("31 Dec 2099 00:00 +0300"), "End Date")

tradeDateIsAllowed = not enableFilter or (time >= fromDate and time <= toDate)

filter1 = 'Filter with Atr'

filter2 = 'Filter with RSI'
filter3 = 'Atr or RSI'
filter4 = 'Atr and RSI'
filter5 = 'No Filtering'
filter6 = 'Entry Only in sideways market(By ATR or RSI)'
filter7 = 'Entry Only in sideways market(By ATR and RSI)'
typefilter = input.string(filter5, title='Sideways Filtering Input',
options=[filter1, filter2, filter3, filter4, filter5, filter6, filter7],
group='Strategy Options')

RSI = truncate(ta.rsi(close, input.int(7, group='RSI Filterring')), 2)

toplimitrsi = input.int(45, title='TOP Limit', group='RSI Filterring')
botlimitrsi = input.int(10, title='BOT Limit', group='RSI Filterring')

//ST = input.bool(true, title='Show Supertrend?', group='Supertrend Indicator')

//period = input.int(1440, group='Supertrend Indicator')
//mult = input.float(2.612, group='Supertrend Indicator')
atrfiltLen = 5 //input.int(5, minval=1, title='atr Length', group='Sideways
Filtering Input')
atrMaType = 'EMA' //input.string('EMA', options=['SMA', 'EMA'], group='Sideways
Filtering Input', title='atr Moving Average Type')
atrMaLen = 5 //input.int(5, minval=1, title='atr MA Length', group='Sideways
Filtering Input')

//filtering
atra = request.security(syminfo.tickerid, '', ta.atr(atrfiltLen))
atrMa = atrMaType == 'EM' ? ta.ema(atra, atrMaLen) : ta.sma(atra, atrMaLen)
updm = ta.change(high)
downdm = -ta.change(low)
plusdm = na(updm) ? na : updm > downdm and updm > 0 ? updm : 0
minusdm = na(downdm) ? na : downdm > updm and downdm > 0 ? downdm : 0

cndSidwayss1 = atra >= atrMa

cndSidwayss2 = RSI > toplimitrsi or RSI < botlimitrsi
cndSidways = cndSidwayss1 or cndSidwayss2
cndSidways1 = cndSidwayss1 and cndSidwayss2
Sidwayss1 = atra <= atrMa
Sidwayss2 = RSI < toplimitrsi and RSI > botlimitrsi
Sidways = Sidwayss1 or Sidwayss2
Sidways1 = Sidwayss1 and Sidwayss2

trendType = typefilter == filter1 ? cndSidwayss1 : typefilter == filter2 ?

cndSidwayss2 : typefilter == filter3 ? cndSidways : typefilter == filter4 ?
cndSidways1 : typefilter == filter5 ? RSI > 0 : typefilter == filter6 ? Sidways :
typefilter == filter7 ? Sidways1 : na

// === /INPUTS ===

tf = my_time //input('15')

r = ticker.heikinashi(syminfo.tickerid)
openSeriesAlt = request.security(r, tf, open, lookahead=barmerge.lookahead_on)
closeSeriesAlt = request.security(r, tf, close, lookahead=barmerge.lookahead_on)
//openP = plot(almaRibbon ? openSeriesAlt : na, color=color.new(color.lime, 0),
linewidth=3)
//closeP = plot(almaRibbon ? closeSeriesAlt : na, color=color.new(color.red, 0),
linewidth=3)

BUYOC = ta.crossover(closeSeriesAlt, openSeriesAlt) and setupType == "Open/Close"

and trendType
SELLOC = ta.crossunder(closeSeriesAlt, openSeriesAlt) and setupType == "Open/Close"
and trendType

//strategy.entry('sell', direction=strategy.short, qty=trade_size, comment='sell',

when=sel_entry)
//strategy.entry('buy', direction=strategy.long, qty=trade_size, comment='buy',
when=buy_entry)

//trendColour = closeSeriesAlt > openSeriesAlt ? color.green : color.red

//bcolour = closeSeriesAlt > openSeriesAlt ? lime100 : red100
//barcolor(scolor ? bcolour : na, title='Bar Colours')
//closeP = plot(almaRibbon ? closeSeriesAlt : na, title='Close Series',
color=color.new(trendColour, 20), linewidth=2, style=plot.style_line)
//openP = plot(almaRibbon ? openSeriesAlt : na, title='Open Series',
color=color.new(trendColour, 20), linewidth=2, style=plot.style_line)
//fill(closeP, openP, color=color.new(trendColour, 80))
//

//rt = input(true, title="ATR Based REnko is the Default, UnCheck to use

Traditional ATR?")
atrLen = 3 //input.int(3, title="RENKO_ATR", group = "Renko Settings")
isATR = true //input.bool(true, title="RENKO_USE_RENKO_ATR", group = "Renko
Settings")
tradLen1 = 1000 //input.int(1000, title="RENKO_TRADITIONAL", group = "Renko
Settings")

//Code to be implemented in V2
//mul = input(1, "Number Of minticks")
//value = mul * syminfo.mintick

tradLen = tradLen1 * 1

param = isATR ? ticker.renko(syminfo.tickerid, "ATR", atrLen) :

ticker.renko(syminfo.tickerid, "Traditional", tradLen)

renko_close = request.security(param, my_time, close,

lookahead=barmerge.lookahead_on)
renko_open = request.security(param, my_time, open,
lookahead=barmerge.lookahead_on)

//============================================
//
Sniper-----------------------------------------------------------------------------
-------------------------------------------------------- // Signal 2
//============================================

//============================================
//
EMA_CROSS--------------------------------------------------------------------------
------------------------------------------------------ // Signal 4
//============================================

EMA1_length=input.int(2, "EMA1_length", group = "Renko Settings")

EMA2_length=input.int(10, "EMA2_length", group = "Renko Settings")

a = ta.ema(renko_close, EMA1_length)
b = ta.ema(renko_close, EMA2_length)

//BUY = ta.cross(a, b) and a > b and renko_open < renko_close

//SELL = ta.cross(a, b) and a < b and renko_close < renko_open
///////////////////////////////
// Determine long and short conditions
BUYR = ta.crossover(a, b) and setupType == "Renko" and trendType
SELLR = ta.crossunder(a, b) and setupType == "Renko" and trendType

sel_color = setupType == "Open/Close" ? closeSeriesAlt < openSeriesAlt : setupType

== "Renko" ? renko_close < renko_open : na
buy_color = setupType == "Open/Close" ? closeSeriesAlt > openSeriesAlt : setupType
== "Renko" ? renko_close > renko_open : na

sel_entry = setupType == "Open/Close" ? SELLOC : setupType == "Renko" ? SELLR : na

buy_entry = setupType == "Open/Close" ? BUYOC : setupType == "Renko" ? BUYR : na

trendColour = buy_color ? color.green : color.red

bcolour = buy_color ? lime100 : red100
barcolor(scolor ? bcolour : na, title='Bar Colours')

p11=plot(almaRibbon and setupType == "Open/Close" ? closeSeriesAlt : almaRibbon and

setupType == "Renko" ? renko_close : na, style=plot.style_circles, linewidth=1,
color=color.new(trendColour, 80), title="RENKO_1")
p22=plot(almaRibbon and setupType == "Open/Close" ? openSeriesAlt : almaRibbon and
setupType == "Renko" ? renko_open : na, style=plot.style_circles, linewidth=1,
color=color.new(trendColour, 80), title="RENKO_2")
fill(p11, p22, color=color.new(trendColour, 50), title="RENKO_fill")

//<triggers>
lxTrigger = false
sxTrigger = false
leTrigger = buy_entry
seTrigger = sel_entry

// === /ALERT conditions.

buy = leTrigger //ta.crossover(closeSeriesAlt, openSeriesAlt)
sell = seTrigger //ta.crossunder(closeSeriesAlt, openSeriesAlt)

varip wasLong = false

varip wasShort = false

if barstate.isconfirmed
wasLong := false
else
if buy
wasLong := true

if barstate.isconfirmed
wasShort := false
else
if sell
wasShort := true

plotshape(wasLong, color = color.yellow)

plotshape(wasShort, color = color.yellow)

//plotshape(almaRibbon ? buy : na, title = "Buy", text = 'Buy', style =

shape.labelup, location = location.belowbar, color= #39ff14, textcolor = #FFFFFF,
size = size.tiny)
//plotshape(almaRibbon ? sell : na, title = "Exit", text = 'Exit', style =
shape.labeldown, location = location.abovebar, color= #ff1100, textcolor = #FFFFFF,
size = size.tiny)

// === STRATEGY ===

i_alert_txt_entry_long = "Short Exit" //input.text_area(defval = "Short Exit",
title = "Long Entry Message", group = "Alerts")
i_alert_txt_exit_long = "Long Exit" //input.text_area(defval = "Long Exit", title =
"Long Exit Message", group = "Alerts")
i_alert_txt_entry_short = "Go Short" //input.text_area(defval = "Go Short", title =
"Short Entry Message", group = "Alerts")
i_alert_txt_exit_short = "Go Long" //input.text_area(defval = "Go Long", title =
"Short Exit Message", group = "Alerts")
// Entries and Exits with TP/SL

//tradeType
if buy and TPSType == "Trailing" and tradeDateIsAllowed
strategy.close("Short" , alert_message = i_alert_txt_exit_short)
strategy.entry("Long" , strategy.long , alert_message = i_alert_txt_entry_long)

if sell and TPSType == "Trailing" and tradeDateIsAllowed

strategy.close("Long" , alert_message = i_alert_txt_exit_long)
strategy.entry("Short" , strategy.short, alert_message =
i_alert_txt_entry_short)

//tradeType
if buy and TPSType == "Options" and tradeDateIsAllowed
// strategy.close("Short" , alert_message = i_alert_txt_exit_short)
 strategy.entry("Long" , strategy.long , alert_message = i_alert_txt_entry_long)

if sell and TPSType == "Options" and tradeDateIsAllowed

strategy.close("Long" , alert_message = i_alert_txt_exit_long)
// strategy.entry("Short" , strategy.short, alert_message =
i_alert_txt_entry_short)

G_RISK = '■ ' + 'Risk Management'

//#region ———— <↓↓↓ G_RISK ↓↓↓> {

//ATR SL Settings
atrLength = 20 //input.int(20, minval=1, title='ATR Length')
profitFactor = 2.5 //input(2.5, title='Take Profit Factor')
stopFactor = 1 //input(1.0, title='Stop Loss Factor')

// Calculate ATR
tpatrValue = ta.atr(atrLength)

// Calculate take profit and stop loss levels for buy signals
takeProfit1_buy = 1 * profitFactor * tpatrValue //close + profitFactor * atrValue
takeProfit2_buy = 2 * profitFactor * tpatrValue //close + 2 * profitFactor *
atrValue
takeProfit3_buy = 3 * profitFactor * tpatrValue //close + 3 * profitFactor *
atrValue
stopLoss_buy = close - takeProfit1_buy //stopFactor * tpatrValue

// Calculate take profit and stop loss levels for sell signals
takeProfit1_sell = 1 * profitFactor * tpatrValue //close - profitFactor * atrValue
takeProfit2_sell = 2 * profitFactor * tpatrValue //close - 2 * profitFactor *
atrValue
takeProfit3_sell = 3 * profitFactor * tpatrValue //close - 3 * profitFactor *
atrValue
stopLoss_sell = close + takeProfit1_sell //stopFactor * tpatrValue

// ——————————— <constant_declarations>
//Tooltip
T_LVL = '(%) Exit Level'
T_QTY = '(%) Adjust trade exit volume'
T_MSG = 'Paste JSON message for your bot'
//Webhook Message
O_LEMSG = 'Long Entry'
O_LXMSGSL = 'Long SL'
O_LXMSGTP1 = 'Long TP1'
O_LXMSGTP2 = 'Long TP2'
O_LXMSGTP3 = 'Long TP3'
O_LXMSG = 'Long Exit'
O_SEMSG = 'Short Entry'
O_SXMSGSL = 'Short SL'
O_SXMSGA = 'Short TP1'
O_SXMSGB = 'Short TP2'
O_SXMSGC = 'Short TP3'
O_SXMSGX = 'Short Exit'

// on whole pips) for forex currency pairs.

pip_size = syminfo.mintick * (syminfo.type == "forex" ? 10 : 1)

// On the last historical bar, show the instrument's pip size

//if barstate.islastconfirmedhistory
// label.new(x=bar_index + 2, y=close, style=label.style_label_left,
// color=color.navy, textcolor=color.white, size=size.large,
// text=syminfo.ticker + "'s pip size is:\n" +
// str.tostring(pip_size))
// ——————————— <input> | | |
Line length guide |
i_lxLvlTP1 = leTrigger ? takeProfit1_buy : seTrigger ? takeProfit1_sell : na
//input.float (1, 'Level TP1' , group = G_RISK,
tooltip = T_LVL)
i_lxQtyTP1 = input.float (50, 'Qty TP1' , group =
G_RISK, tooltip = T_QTY)
i_lxLvlTP2 = leTrigger ? takeProfit2_buy : seTrigger ? takeProfit2_sell : na
//input.float (1.5, 'Level TP2' , group = G_RISK,
tooltip = T_LVL)
i_lxQtyTP2 = input.float (30, 'Qty TP2' , group =
G_RISK, tooltip = T_QTY)
i_lxLvlTP3 = leTrigger ? takeProfit3_buy : seTrigger ? takeProfit3_sell : na
//input.float (2, 'Level TP3' , group = G_RISK,
tooltip = T_LVL)
i_lxQtyTP3 = input.float (20, 'Qty TP3' , group =
G_RISK, tooltip = T_QTY)
i_lxLvlSL = leTrigger ? takeProfit1_buy : seTrigger ? takeProfit1_sell : na
//input.float (0.5, 'Stop Loss' , group = G_RISK,
tooltip = T_LVL)

i_sxLvlTP1 = i_lxLvlTP1
i_sxQtyTP1 = i_lxQtyTP1
i_sxLvlTP2 = i_lxLvlTP2
i_sxQtyTP2 = i_lxQtyTP2
i_sxLvlTP3 = i_lxLvlTP3
i_sxQtyTP3 = i_lxQtyTP3
i_sxLvlSL = i_lxLvlSL

G_MSG = '■ ' + 'Webhook Message'

i_leMsg = O_LEMSG //input.string (O_LEMSG ,'Long Entry'
, group = G_MSG, tooltip = T_MSG)
i_lxMsgSL = O_LXMSGSL //input.string (O_LXMSGSL ,'Long SL'
, group = G_MSG, tooltip = T_MSG)
i_lxMsgTP1 = O_LXMSGTP1 //input.string (O_LXMSGTP1,'Long TP1'
, group = G_MSG, tooltip = T_MSG)
i_lxMsgTP2 = O_LXMSGTP2 //input.string (O_LXMSGTP2,'Long TP2'
, group = G_MSG, tooltip = T_MSG)
i_lxMsgTP3 = O_LXMSGTP3 //input.string (O_LXMSGTP3,'Long TP3'
, group = G_MSG, tooltip = T_MSG)
i_lxMsg = O_LXMSG //input.string (O_LXMSG ,'Long Exit'
, group = G_MSG, tooltip = T_MSG)
i_seMsg = O_SEMSG //input.string (O_SEMSG ,'Short Entry'
, group = G_MSG, tooltip = T_MSG)
i_sxMsgSL = O_SXMSGSL //input.string (O_SXMSGSL ,'Short SL'
, group = G_MSG, tooltip = T_MSG)
i_sxMsgTP1 = O_SXMSGA //input.string (O_SXMSGA ,'Short TP1'
, group = G_MSG, tooltip = T_MSG)
i_sxMsgTP2 = O_SXMSGB //input.string (O_SXMSGB ,'Short TP2'
, group = G_MSG, tooltip = T_MSG)
i_sxMsgTP3 = O_SXMSGC //input.string (O_SXMSGC ,'Short TP3'
, group = G_MSG, tooltip = T_MSG)
i_sxMsg = O_SXMSGX //input.string (O_SXMSGX ,'Short Exit'
, group = G_MSG, tooltip = T_MSG)
i_src = close

G_DISPLAY = 'Display'
//<display>
i_alertOn = true //input.bool (true, 'Alert Labels On/Off' ,
group = G_DISPLAY)
i_barColOn = true //input.bool (true, 'Bar Color On/Off' ,
group = G_DISPLAY)

// ——————————— <function_declarations>
// @function Calculate the Take Profit line, and the crossover or crossunder
f_tp(_condition, _conditionValue, _leTrigger, _seTrigger, _src, _lxLvlTP,
_sxLvlTP)=>
var float _tpLine = 0.0
_topLvl = _src + _lxLvlTP //TPSType == "Fixed %" ? _src + (_src * (_lxLvlTP
/ 100)) : _src + _lxLvlTP
_botLvl = _src - _lxLvlTP //TPSType == "Fixed %" ? _src - (_src * (_sxLvlTP
/ 100)) : _src - _sxLvlTP
_tpLine := _condition[1] != _conditionValue and _leTrigger ? _topLvl :
_condition[1] != -_conditionValue and _seTrigger ? _botLvl :
nz(_tpLine[1])
[_tpLine]

// @function Similar to "ta.crossover" or "ta.crossunder"

f_cross(_scr1, _scr2, _over)=>
_cross = _over ? _scr1 > _scr2 and _scr1[1] < _scr2[1] :
_scr1 < _scr2 and _scr1[1] > _scr2[1]

// ——————————— <calculations>
//<set initial values>
var float condition = 0.0
var float slLine = 0.0
var float entryLine = 0.0

//<entry & exit orders>

entryLine := leTrigger and condition[1] <= 0.0 ? close :
seTrigger and condition[1] >= 0.0 ? close : nz(entryLine[1])
//<SL>
slTopLvl = TPSType == "Fixed %" ? i_src + (i_src * (i_lxLvlSL / 100)) : i_src +
i_lxLvlSL
slBotLvl = TPSType == "Fixed %" ? i_src - (i_src * (i_sxLvlSL / 100)) : i_src -
i_lxLvlSL
slLine := condition[1] <= 0.0 and leTrigger ? slBotLvl :
condition[1] >= 0.0 and seTrigger ? slTopLvl : nz(slLine[1])
slLong = f_cross(low, slLine, false)
slShort = f_cross(high, slLine, true )
//<TP1, TP2 & TP3>
[tp3Line] = f_tp(condition, 1.2,leTrigger, seTrigger, i_src, i_lxLvlTP3,
i_sxLvlTP3)
[tp2Line] = f_tp(condition, 1.1,leTrigger, seTrigger, i_src, i_lxLvlTP2,
i_sxLvlTP2)
[tp1Line] = f_tp(condition, 1.0,leTrigger, seTrigger, i_src, i_lxLvlTP1,
i_sxLvlTP1)
tp3Long = f_cross(high, tp3Line, true )
tp3Short = f_cross(low, tp3Line, false)
tp2Long = f_cross(high, tp2Line, true )
tp2Short = f_cross(low, tp2Line, false)
tp1Long = f_cross(high, tp1Line, true )
tp1Short = f_cross(low, tp1Line, false)
switch
leTrigger and condition[1] <= 0.0 => condition := 1.0
seTrigger and condition[1] >= 0.0 => condition := -1.0
tp3Long and condition[1] == 1.2 => condition := 1.3
tp3Short and condition[1] == -1.2 => condition := -1.3
tp2Long and condition[1] == 1.1 => condition := 1.2
tp2Short and condition[1] == -1.1 => condition := -1.2
tp1Long and condition[1] == 1.0 => condition := 1.1
tp1Short and condition[1] == -1.0 => condition := -1.1
slLong and condition[1] >= 1.0 => condition := 0.0
slShort and condition[1] <= -1.0 => condition := 0.0
lxTrigger and condition[1] >= 1.0 => condition := 0.0
sxTrigger and condition[1] <= -1.0 => condition := 0.0

longE = leTrigger and condition[1] <= 0.0 and condition == 1.0

shortE = seTrigger and condition[1] >= 0.0 and condition == -1.0
longX = lxTrigger and condition[1] >= 1.0 and condition == 0.0
shortX = sxTrigger and condition[1] <= -1.0 and condition == 0.0
longSL = slLong and condition[1] >= 1.0 and condition == 0.0
shortSL = slShort and condition[1] <= -1.0 and condition == 0.0
longTP3 = tp3Long and condition[1] == 1.2 and condition == 1.3
shortTP3 = tp3Short and condition[1] == -1.2 and condition == -1.3
longTP2 = tp2Long and condition[1] == 1.1 and condition == 1.2
shortTP2 = tp2Short and condition[1] == -1.1 and condition == -1.2
longTP1 = tp1Long and condition[1] == 1.0 and condition == 1.1
shortTP1 = tp1Short and condition[1] == -1.0 and condition == -1.1

// ——————————— <strategy_calls> {
//<long orders>
if strategy.position_size <= 0 and longE and TPSType == "ATR" and
tradeDateIsAllowed
strategy.entry( 'Long', strategy.long, alert_message =
i_leMsg, comment = 'LE')
if strategy.position_size > 0 and condition == 1.0 and TPSType == "ATR" and
tradeDateIsAllowed
strategy.exit( id = 'LXTP1', from_entry = 'Long',
qty_percent = i_lxQtyTP1, limit = tp1Line, stop
= slLine, comment_profit = 'LXTP1', comment_loss = 'SL',
alert_profit = i_lxMsgTP1, alert_loss = i_lxMsgSL)
if strategy.position_size > 0 and condition == 1.1 and TPSType == "ATR" and
tradeDateIsAllowed
strategy.exit( id = 'LXTP2', from_entry = 'Long',
qty_percent = i_lxQtyTP2, limit = tp2Line, stop
= slLine, comment_profit = 'LXTP2', comment_loss = 'SL',
alert_profit = i_lxMsgTP2, alert_loss = i_lxMsgSL)
if strategy.position_size > 0 and condition == 1.2 and TPSType == "ATR" and
tradeDateIsAllowed
strategy.exit( id = 'LXTP3', from_entry = 'Long',
qty_percent = i_lxQtyTP3, limit = tp3Line, stop
= slLine, comment_profit = 'LXTP3', comment_loss = 'SL',
alert_profit = i_lxMsgTP3, alert_loss = i_lxMsgSL)
if longX and tradeDateIsAllowed
strategy.close( 'Long', alert_message = i_lxMsg, comment
= 'LX')
//<short orders>
if strategy.position_size >= 0 and shortE and TPSType == "ATR" and
tradeDateIsAllowed
strategy.entry( 'Short', strategy.short, alert_message =
i_leMsg, comment = 'SE')
if strategy.position_size < 0 and condition == -1.0 and TPSType == "ATR" and
tradeDateIsAllowed
strategy.exit( id = 'SXTP1', from_entry =
'Short', qty_percent = i_sxQtyTP1, limit = tp1Line,
stop = slLine, comment_profit = 'SXTP1', comment_loss =
'SL', alert_profit = i_sxMsgTP1, alert_loss = i_sxMsgSL)
if strategy.position_size < 0 and condition == -1.1 and TPSType == "ATR" and
tradeDateIsAllowed
strategy.exit( id = 'SXTP2', from_entry =
'Short', qty_percent = i_sxQtyTP2, limit = tp2Line,
stop = slLine, comment_profit = 'SXTP2', comment_loss =
'SL', alert_profit = i_sxMsgTP2, alert_loss = i_sxMsgSL)
if strategy.position_size < 0 and condition == -1.2 and TPSType == "ATR" and
tradeDateIsAllowed
strategy.exit( id = 'SXTP3', from_entry =
'Short', qty_percent = i_sxQtyTP3, limit = tp3Line,
stop = slLine, comment_profit = 'SXTP3', comment_loss =
'SL', alert_profit = i_sxMsgTP3, alert_loss = i_sxMsgSL)
if shortX and tradeDateIsAllowed
strategy.close( 'Short', alert_message = i_sxMsg, comment
= 'SX')

// ——————————— <visuals>
c_tp = leTrigger or seTrigger ? na :
condition == 0.0 ? na : color.green
c_entry = leTrigger or seTrigger ? na :
condition == 0.0 ? na : color.blue
c_sl = leTrigger or seTrigger ? na :
condition == 0.0 ? na : color.red
p_tp1Line = plot ( condition == 1.0 or condition == -1.0 ? tp1Line : na,
title = "TP Line 1", color = c_tp, linewidth = 1, style =
plot.style_linebr)
p_tp2Line = plot ( condition == 1.0 or condition == -1.0 or condition ==
1.1 or condition == -1.1 ? tp2Line : na, title = "TP Line 2", color =
c_tp, linewidth = 1, style = plot.style_linebr)
p_tp3Line = plot ( condition == 1.0 or condition == -1.0 or condition ==
1.1 or condition == -1.1 or condition == 1.2 or condition == -1.2 ? tp3Line :
na, title = "TP Line 3", color = c_tp, linewidth = 1, style =
plot.style_linebr)
p_entryLine = plot ( condition >= 1.0 or condition <= -1.0 ? entryLine : na,
title = "Entry Line", color = c_entry, linewidth = 1, style =
plot.style_linebr)
p_slLine = plot ( condition == 1.0 or condition == -1.0 or condition ==
1.1 or condition == -1.1 or condition == 1.2 or condition == -1.2 ? slLine :
na, title = "SL Line", color = c_sl, linewidth = 1, style =
plot.style_linebr)

//fill( p_tp3Line, p_entryLine, color = leTrigger or seTrigger ?

na :color.new(color.green, 90))
fill( p_entryLine, p_slLine, color = leTrigger or seTrigger ?
na :color.new(color.red, 90))

//<alerts labels>
plotshape( i_alertOn and longE, title = 'Long', text = 'Long',
textcolor = color.white, color = color.green, style = shape.labelup,
size = size.tiny, location = location.belowbar)
plotshape( i_alertOn and shortE, title = 'Short', text = 'Short',
textcolor = color.white, color = color.red, style = shape.labeldown,
size = size.tiny, location = location.abovebar)
plotshape( i_alertOn and (longX or shortX) ? close : na, title = 'Close',
text = 'Close', textcolor = color.white, color = color.gray, style
= shape.labelup, size = size.tiny, location = location.absolute)
l_tp = i_alertOn and (longTP1 or shortTP1) ? close : na

plotshape( l_tp, title = "TP1 Cross", text = "TP1", textcolor =

color.white, color = color.olive, style = shape.labelup, size =
size.tiny, location = location.absolute)
plotshape( i_alertOn and (longTP2 or shortTP2) ? close : na, title = "TP2
Cross", text = "TP2", textcolor = color.white, color = color.olive,
style = shape.labelup, size = size.tiny, location =
location.absolute)
plotshape( i_alertOn and (longTP3 or shortTP3) ? close : na, title = "TP3
Cross", text = "TP3", textcolor = color.white, color = color.olive,
style = shape.labelup, size = size.tiny, location =
location.absolute)
plotshape( i_alertOn and (longSL or shortSL) ? close : na, title = "SL
Cross", text = "SL", textcolor = color.white, color = color.maroon,
style = shape.labelup, size = size.tiny, location =
location.absolute)

//<debug>
plot( na, title = "─── <debug> ───", editable = false, display =
display.data_window)
plot( condition, title = "condition", editable = false, display =
display.data_window)
plot( strategy.position_size * 100, title = ".position_size", editable =
false, display = display.data_window)
//#endregion }
// ——————————— <↑↑↑ G_RISK ↑↑↑>

//#region ———— <↓↓↓ G_SCRIPT02 ↓↓↓> {

// @function Queues a new element in an array and de-queues its first
element.
f_qDq(_array, _val) =>
array.push(_array, _val)
_return = array.shift(_array)
_return

var line[] a_slLine = array.new_line(1)

var line[] a_entryLine = array.new_line(1)
var line[] a_tp3Line = array.new_line(1)
var line[] a_tp2Line = array.new_line(1)
var line[] a_tp1Line = array.new_line(1)
var label[] a_slLabel = array.new_label(1)
var label[] a_tp3label = array.new_label(1)
var label[] a_tp2label = array.new_label(1)
var label[] a_tp1label = array.new_label(1)
var label[] a_entryLabel = array.new_label(1)

newEntry = longE or shortE

entryIndex = 1
entryIndex := newEntry ? bar_index : nz(entryIndex[1])
lasTrade = bar_index >= entryIndex
l_right = 10

if TPSType == "ATR"
line.delete( f_qDq(a_slLine, line.new( entryIndex, slLine,
last_bar_index + l_right, slLine, style = line.style_solid, color = c_sl)))

if TPSType == "ATR"
line.delete( f_qDq(a_entryLine, line.new( entryIndex, entryLine,
last_bar_index + l_right, entryLine, style = line.style_solid, color =
color.blue)))

if TPSType == "ATR"
line.delete( f_qDq(a_tp3Line, line.new( entryIndex, tp3Line,
last_bar_index + l_right, tp3Line, style = line.style_solid, color = c_tp)))

if TPSType == "ATR"
line.delete( f_qDq(a_tp2Line, line.new( entryIndex, tp2Line,
last_bar_index + l_right, tp2Line, style = line.style_solid, color = c_tp)))

if TPSType == "ATR"
line.delete( f_qDq(a_tp1Line, line.new( entryIndex, tp1Line,
last_bar_index + l_right, tp1Line, style = line.style_solid, color = c_tp)))

if TPSType == "ATR"
label.delete( f_qDq(a_slLabel, label.new( last_bar_index + l_right,
slLine, 'SL: ' + str.tostring(slLine, '##.###'), style =
label.style_label_left, textcolor = color.white, color = c_sl)))

if TPSType == "ATR"
label.delete( f_qDq(a_entryLabel, label.new( last_bar_index + l_right,
entryLine, 'Entry: ' + str.tostring(entryLine, '##.###'), style =
label.style_label_left, textcolor = color.white, color = color.blue)))

if TPSType == "ATR"
label.delete( f_qDq(a_tp3label, label.new( last_bar_index + l_right,
tp3Line, 'TP3: ' + str.tostring(tp3Line, '##.###') + " - Target Pips : - " +
str.tostring(longE ? tp3Line - entryLine : entryLine - tp3Line, "#.##"), style =
label.style_label_left, textcolor = color.white, color = c_tp)))

if TPSType == "ATR"
label.delete( f_qDq(a_tp2label, label.new( last_bar_index + l_right,
tp2Line, 'TP2: ' + str.tostring(tp2Line, '##.###'), style =
label.style_label_left, textcolor = color.white, color = c_tp)))

if TPSType == "ATR"
label.delete( f_qDq(a_tp1label, label.new( last_bar_index + l_right,
tp1Line, 'TP1: ' + str.tostring(tp1Line, '##.###'), style =
label.style_label_left, textcolor = color.white, color = c_tp)))

//#endregion }
// ——————————— <↑↑↑ G_SCRIPT02 ↑↑↑>

c_barCol = close > open ? color.rgb(120, 9, 139) : color.rgb(69, 155, 225)

barcolor(
i_barColOn ? c_barCol : na)

// ——————————— <alerts>
//<any_alert_function_call>
if longE or shortE or longX or shortX
alert(message = 'Any Alert', freq = alert.freq_once_per_bar_close)
if longE
alert(message = 'Long Entry', freq = alert.freq_once_per_bar_close)
if shortE
 alert(message = 'Short Entry', freq = alert.freq_once_per_bar_close)
if longX
alert(message = 'Long Exit', freq = alert.freq_once_per_bar_close)
if shortX
alert(message = 'Short Exit', freq = alert.freq_once_per_bar_close)
//#endregion }
// ——————————— <↑↑↑ G_SCRIPT03 ↑↑↑>

// This source code is subject to the terms of the Mozilla Public License 2.0 at
https://mozilla.org/MPL/2.0/
// © TraderHalai
// This script was born out of my quest to be able to display strategy back test
statistics on charts to allow for easier backtesting on devices that do not
natively support backtest engine (such as mobile phones, when I am backtesting from
away from my computer). There are already a few good ones on TradingView, but
most / many are too complicated for my needs.
//
//Found an excellent display backtest engine by 'The Art of Trading'. This script
is a snippet of his hard work, with some very minor tweaks and changes. Much
respect to the original author.
//
//Full credit to the original author of this script. It can be found here:
https://www.tradingview.com/script/t776tkZv-Hammers-Stars-Strategy/?
offer_id=10&aff_id=15271
//
// This script can be copied and airlifted onto existing strategy scripts of your
own, and integrates out of the box without implementation of additional functions.
I've also added Max Runup, Average Win and Average Loss per trade to the orignal
script.
//
//Will look to add in more performance metrics in future, as I further develop this
script.
//
//Feel free to use this display panel in your scripts and strategies.

//Thanks and enjoy! :)

//@version=5
//strategy("Strategy BackTest Display Statistics - TraderHalai", overlay=true,
default_qty_value= 5, default_qty_type = strategy.percent_of_equity,
initial_capital=10000, commission_type=strategy.commission.percent,
commission_value=0.1)

//DEMO basic strategy - Use your own strategy here - Jaws Mean Reversion from my
profile used here
//source = input(title = "Source", defval = close)

///////////////////////////// --- BEGIN TESTER CODE --- ////////////////////////

// COPY below into your strategy to enable display
////////////////////////////////////////////////////////////////////////////////

// Declare performance tracking variables

drawTester = input.bool(true, "Strategy Performance", group='Dashboards',
inline="Show Dashboards")
var balance = strategy.initial_capital
var drawdown = 0.0
var maxDrawdown = 0.0
var maxBalance = 0.0
var totalWins = 0
var totalLoss = 0

// Prepare stats table

var table testTable = table.new(position.top_right, 5, 2, border_width=1)
f_fillCell(_table, _column, _row, _title, _value, _bgcolor, _txtcolor) =>
_cellText = _title + "\n" + _value
table.cell(_table, _column, _row, _cellText, bgcolor=_bgcolor,
text_color=_txtcolor)

// Custom function to truncate (cut) excess decimal places

//truncate(_number, _decimalPlaces) =>
// _factor = math.pow(10, _decimalPlaces)
// int(_number * _factor) / _factor

// Draw stats table

var bgcolor = color.new(color.black,0)
if drawTester and tradeDateIsAllowed
if barstate.islastconfirmedhistory
// Update table
dollarReturn = strategy.netprofit
f_fillCell(testTable, 0, 0, "Total Trades:",
str.tostring(strategy.closedtrades), bgcolor, color.white)
f_fillCell(testTable, 0, 1, "Win Rate:",
str.tostring(truncate((strategy.wintrades/strategy.closedtrades)*100,2)) + "%",
bgcolor, color.white)
f_fillCell(testTable, 1, 0, "Starting:", "$" +
str.tostring(strategy.initial_capital), bgcolor, color.white)
f_fillCell(testTable, 1, 1, "Ending:", "$" +
str.tostring(truncate(strategy.initial_capital + strategy.netprofit,2)), bgcolor,
color.white)
f_fillCell(testTable, 2, 0, "Avg Win:", "$"+
str.tostring(truncate(strategy.grossprofit / strategy.wintrades, 2)), bgcolor,
color.white)
f_fillCell(testTable, 2, 1, "Avg Loss:", "$"+
str.tostring(truncate(strategy.grossloss / strategy.losstrades, 2)), bgcolor,
color.white)
f_fillCell(testTable, 3, 0, "Profit Factor:",
str.tostring(truncate(strategy.grossprofit / strategy.grossloss,2)),
strategy.grossprofit > strategy.grossloss ? color.green : color.red, color.white)
f_fillCell(testTable, 3, 1, "Max Runup:",
str.tostring(truncate(strategy.max_runup, 2 )), bgcolor, color.white)
f_fillCell(testTable, 4, 0, "Return:", (dollarReturn > 0 ? "+" : "") +
str.tostring(truncate((dollarReturn / strategy.initial_capital)*100,2)) + "%",
dollarReturn > 0 ? color.green : color.red, color.white)
f_fillCell(testTable, 4, 1, "Max DD:",
str.tostring(truncate((strategy.max_drawdown / strategy.equity) * 100 ,2)) + "%",
color.red, color.white)
// --- END TESTER CODE --- ///////////////

// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0
at https://mozilla.org/MPL/2.0/
// © niceGear68734

//@version=5
//strategy("Table to filter trades per day", overlay=true, use_bar_magnifier =
true, initial_capital = 5000, calc_on_every_tick = true, calc_on_order_fills =
true, commission_type = strategy.commission.cash_per_contract)
//~ ___________________________________________________________________________
//~ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//~ !!!!!!!!!!!!!!!_________________ START _________________!!!!!!!!!!!!!!!!!
i_showweeklyPerformance = input.bool(false, 'Weekly Performance',
group='Dashboards', inline="Show Dashboards")
//__________________________ User Inputs ___________________________________
var const string g_table = "Table Settings"
i_table_pos = "Top Left" //input.string(defval = "Top Left", title
= "Position", options = ["Bottom Right","Bottom Left", "Top Right", "Top Left"],
group = g_table, inline = "1", tooltip = "It sets the location of the table")
i_text_size = "Normal" //input.string(defval = "Normal", title =
"Set the size of text", options = ["Small", "Normal", "Large"], tooltip = "This
option is used to change the size of the text in the table")
var const string g_general = "General Settings"
i_check_open_close = "Opened" //input.string("Opened", "Check when the
trade :", ["Opened", "Closed"], group = g_general, tooltip = "This parameter
defines what to check for. If opened is selected, the results will show the trades
that opened on that day. If closed is selected, the results will show the trades
that closed on that day")
i_timezone = "Exchange" //input.string("Exchange", title = "Set
the Timezone", options = ["Exchange","UTC-10","UTC-9","UTC-8","UTC-7","UTC-6","UTC-
5","UTC-4","UTC-3","UTC-2","UTC-
1","UTC","UTC+1","UTC+2","UTC+3","UTC+4","UTC+5","UTC+6","UTC+7","UTC+8","UTC+9","U
TC+10", "UTC+11","UTC+12","UTC+13","UTC+13:45"], group = g_general, tooltip = "You
can use this setting whenever you want to change the time that the trade has
closed/opened")

//~_____________________________ Switches ___________________________________

table_pos = switch i_table_pos
"Bottom Right" => position.bottom_right
"Bottom Left" => position.bottom_left
"Top Right" => position.top_right
"Top Left" => position.top_left

timezone_setting = i_timezone == "Exchange" ? syminfo.timezone : i_timezone

text_size = switch i_text_size

"Small" => size.small
"Normal" => size.normal
"Large" => size.large

//__________________________ Array Declaration _____________________________

var string[] t_column_names = array.from( "", "Sun", "Mon", "Tue", "Wed",
"Thur", "Fri", "Sat") // Columns header names
var string[] t_row_names = array.from("", "Total Trades", "Loss",
"Win", "Win Rate" ) // Rows header names
var t_column_size = array.size(t_column_names)
var t_row_size = array.size(t_row_names)
var string[] a_closed_trades = array.new_string() // Save the total number
of trades
var string[] a_loss_trades = array.new_string() // Save the number of
losing trades
var string[] a_win_trades = array.new_string() // Save the number of
winning trades
var _a_day_week = array.new_int() // Save the day of the week
to split data

// __________________________ Custom Functions ________________________________

//~ create a counter so that it gives a number to
strategy.closed_trades.entry_time(counter)
var trade_number = -1
if strategy.closedtrades > strategy.closedtrades[1]
trade_number += 1

f_strategy_closedtrades_hour() =>
switch
i_check_open_close =="Closed" =>
dayofweek(strategy.closedtrades.exit_time(trade_number), timezone_setting)
i_check_open_close =="Opened" =>
dayofweek(strategy.closedtrades.entry_time(trade_number), timezone_setting)

f_data(_i) =>
var _closed_trades = 0
var _loss_trades = 0
var _win_trades = 0
var _txt_closed_trades = ""
var _txt_loss_trades = ""
var _txt_win_trades = ""

if strategy.closedtrades > strategy.closedtrades[1] and

f_strategy_closedtrades_hour() == _i
_closed_trades += 1
_txt_closed_trades := str.tostring(_closed_trades)
if strategy.losstrades > strategy.losstrades[1] and
f_strategy_closedtrades_hour() == _i
_loss_trades += 1
_txt_loss_trades := str.tostring(_loss_trades)
if strategy.wintrades > strategy.wintrades[1] and
f_strategy_closedtrades_hour() == _i
_win_trades += 1
_txt_win_trades := str.tostring(_win_trades)
[_txt_closed_trades, _txt_loss_trades, _txt_win_trades]

//__________________________
var string[] array1 = array.new_string(5)
var string[] array2 = array.new_string(5)
var string[] array3 = array.new_string(5)
var string[] array4 = array.new_string(5)
var string[] array5 = array.new_string(5)
var string[] array6 = array.new_string(5)
var string[] array7 = array.new_string(5)

f_pass_data_to_array(_i, _array) =>

[cl, loss, win] = f_data(_i)
array.set(_array,1 , cl)
array.set(_array,2,loss)
array.set(_array,3,win)
if cl != ""
array.set(_array,4,str.tostring(str.tonumber(win) / str.tonumber(cl) *
100 , "##") + " %")
if cl != "" and win == ""
array.set(_array,4,"0 %")
for i = 1 to 7
switch
i == 1 => f_pass_data_to_array(i,array1)
i == 2 => f_pass_data_to_array(i,array2)
i == 3 => f_pass_data_to_array(i,array3)
i == 4 => f_pass_data_to_array(i,array4)
i == 5 => f_pass_data_to_array(i,array5)
i == 6 => f_pass_data_to_array(i,array6)
i == 7 => f_pass_data_to_array(i,array7)

f_retrieve_data_to_table(_i, _j) =>

switch
_i == 1 => array.get(array1, _j)
_i == 2 => array.get(array2, _j)
_i == 3 => array.get(array3, _j)
_i == 4 => array.get(array4, _j)
_i == 5 => array.get(array5, _j)
_i == 6 => array.get(array6, _j)
_i == 7 => array.get(array7, _j)

//~ ___________________________ Create Table ________________________________

create_table(_col, _row, _txt) =>
var table _tbl = table.new(position = table_pos, columns = t_column_size , rows
= t_row_size, border_width=1)
color _color = _row == 0 or _col == 0 ? color.rgb(3, 62, 106) : color.rgb(2,
81, 155)
table.cell(_tbl, _col, _row, _txt, bgcolor = _color, text_color = color.white,
text_size = text_size)

//~___________________________ Fill With Data _______________________________

if barstate.islastconfirmedhistory and i_showweeklyPerformance and
tradeDateIsAllowed
for i = 0 to t_column_size - 1 by 1
for j = 0 to t_row_size - 1 by 1
_txt = ""
if i >= 0 and j == 0
_txt := array.get(t_column_names, i)
if j >= 0 and i == 0
_txt := array.get(t_row_names, j)
if i >= 1 and j >= 1 and j <= 5
_txt := f_retrieve_data_to_table( i , j)
create_table(i ,j , _txt)

//~ ___________________________ Notice ______________________________________

if timeframe.in_seconds() > timeframe.in_seconds("D")
x = table.new(position.middle_center,1,1,color.aqua)
table.cell_set_text(x,0,0,"Please select lower timeframes (Daily or lower)")

//~ !!!!!!!!!!!!!!!_________________ STOP _________________!!!!!!!!!!!!!!!!!!

//~ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//~ ___________________________________________________________________________
// Global Dashboard Variables
//
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░

// Dashboard Table Text Size

i_tableTextSize = "Normal" //input.string(title="Dashboard Size", defval="Normal",
options=["Auto", "Huge", "Large", "Normal", "Small", "Tiny"], group="Dashboards")
table_text_size(s) =>
switch s
"Auto" => size.auto
"Huge" => size.huge
"Large" => size.large
"Normal" => size.normal
"Small" => size.small
=> size.tiny
tableTextSize = table_text_size(i_tableTextSize)

// Monthly Table Performance Dashboard By @QuantNomad

//
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
i_showMonthlyPerformance = input.bool(false, 'Monthly Performance',
group='Dashboards', inline="Show Dashboards")
i_monthlyReturnPercision = 2

if i_showMonthlyPerformance and tradeDateIsAllowed

new_month = month(time) != month(time[1])
new_year = year(time) != year(time[1])

eq = strategy.equity

bar_pnl = eq / eq[1] - 1

cur_month_pnl = 0.0
cur_year_pnl = 0.0

// Current Monthly P&L

cur_month_pnl := new_month ? 0.0 :
(1 + cur_month_pnl[1]) * (1 + bar_pnl) - 1

// Current Yearly P&L

cur_year_pnl := new_year ? 0.0 :
(1 + cur_year_pnl[1]) * (1 + bar_pnl) - 1

// Arrays to store Yearly and Monthly P&Ls

var month_pnl = array.new_float(0)
var month_time = array.new_int(0)

var year_pnl = array.new_float(0)

var year_time = array.new_int(0)

last_computed = false

if (not na(cur_month_pnl[1]) and (new_month or

barstate.islastconfirmedhistory))
if (last_computed[1])
 array.pop(month_pnl)
array.pop(month_time)

array.push(month_pnl , cur_month_pnl[1])
array.push(month_time, time[1])

if (not na(cur_year_pnl[1]) and (new_year or barstate.islastconfirmedhistory))

if (last_computed[1])
array.pop(year_pnl)
array.pop(year_time)

array.push(year_pnl , cur_year_pnl[1])
array.push(year_time, time[1])

last_computed := barstate.islastconfirmedhistory ? true : nz(last_computed[1])

// Monthly P&L Table

var monthly_table = table(na)

if (barstate.islastconfirmedhistory)
monthly_table := table.new(position.bottom_right, columns = 14, rows =
array.size(year_pnl) + 1, border_width = 1)

table.cell(monthly_table, 0, 0, "", bgcolor = #cccccc,

text_size=tableTextSize)
table.cell(monthly_table, 1, 0, "Jan", bgcolor = #cccccc,
text_size=tableTextSize)
table.cell(monthly_table, 2, 0, "Feb", bgcolor = #cccccc,
text_size=tableTextSize)
table.cell(monthly_table, 3, 0, "Mar", bgcolor = #cccccc,
text_size=tableTextSize)
table.cell(monthly_table, 4, 0, "Apr", bgcolor = #cccccc,
text_size=tableTextSize)
table.cell(monthly_table, 5, 0, "May", bgcolor = #cccccc,
text_size=tableTextSize)
table.cell(monthly_table, 6, 0, "Jun", bgcolor = #cccccc,
text_size=tableTextSize)
table.cell(monthly_table, 7, 0, "Jul", bgcolor = #cccccc,
text_size=tableTextSize)
table.cell(monthly_table, 8, 0, "Aug", bgcolor = #cccccc,
text_size=tableTextSize)
table.cell(monthly_table, 9, 0, "Sep", bgcolor = #cccccc,
text_size=tableTextSize)
table.cell(monthly_table, 10, 0, "Oct", bgcolor = #cccccc,
text_size=tableTextSize)
table.cell(monthly_table, 11, 0, "Nov", bgcolor = #cccccc,
text_size=tableTextSize)
table.cell(monthly_table, 12, 0, "Dec", bgcolor = #cccccc,
text_size=tableTextSize)
table.cell(monthly_table, 13, 0, "Year", bgcolor = #999999,
text_size=tableTextSize)

for yi = 0 to array.size(year_pnl) - 1
table.cell(monthly_table, 0, yi + 1,
str.tostring(year(array.get(year_time, yi))), bgcolor = #cccccc,
text_size=tableTextSize)

y_color = array.get(year_pnl, yi) > 0 ? color.new(color.teal, transp =

40) : color.new(color.gray, transp = 40)
 table.cell(monthly_table, 13, yi + 1,
str.tostring(math.round(array.get(year_pnl, yi) * 100, i_monthlyReturnPercision)),
bgcolor = y_color, text_color=color.new(color.white, 0),text_size=tableTextSize)

for mi = 0 to array.size(month_time) - 1
m_row = year(array.get(month_time, mi)) - year(array.get(year_time,
0)) + 1
m_col = month(array.get(month_time, mi))
m_color = array.get(month_pnl, mi) > 0 ? color.new(color.teal, transp =
40) : color.new(color.maroon, transp = 40)

table.cell(monthly_table, m_col, m_row,

str.tostring(math.round(array.get(month_pnl, mi) * 100, i_monthlyReturnPercision)),
bgcolor = m_color, text_color=color.new(color.white, 0), text_size=tableTextSize)

hide = timeframe.isintraday

// Input for EMA period

emaPeriod = 48 //input.int(48, title="EMA Period")
emaPeriod2 = 2 //input.int(2, title="EME Period 2")
emaPeriod3 = 21 //input.int(21, title="EMA Period")

// Input to toggle EMA Cloud

showcloud = input.bool(true, title="Plot EMA?", group='EMA & ATR', inline="Show
EMA's & ATR")
useHTF = input.bool(true, title = "Use Higher Time Frame?")

matimeframe = useHTF ? my_time1 : ''

// EMA calculations
ema = request.security(syminfo.tickerid, matimeframe, ta.ema(close, emaPeriod))
ema2 = request.security(syminfo.tickerid, matimeframe, ta.ema(close,emaPeriod2))
ema3 = request.security(syminfo.tickerid, matimeframe,ta.ema(close, emaPeriod3))
emaColor = close > ema3 ? color.new(color.rgb(56, 142, 60, 63), 50) :
color.new(color.rgb(147, 40, 51, 38), 50)

// Plotting EMA's
plot_ema1 = plot(hide ? ema : na, style=plot.style_line,
color=color.new(color.rgb(255, 255, 255, 100), 50), title="EMA", linewidth=2)
plot_ema2 = plot(hide ? ema2 : na, style=plot.style_line,
color=color.new(color.rgb(255, 255, 255, 100), 50), title="EMA", linewidth=1)
plot_ema3 = plot(ema3, style=plot.style_line, color=emaColor, title="EMA",
linewidth=1)

// EMA Cloud
cloudColor = ema2 > ema ? color.new(#0f8513, 80) : color.new(#a81414, 80)
cloudColor2 = ema2 > ema3 ? color.new(#0f8513, 50) : color.new(#a81414, 50)
cloudColor := showcloud ? cloudColor : na
fill(plot_ema1, plot_ema2, color=cloudColor, title="EMA Cloud")
fill(plot_ema3, plot_ema2, color=cloudColor, title="EMA Cloud")
/////////////////////////////////////////////////////////////// ©
BackQuant ///////////////////////////////////////////////////////////////
// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0
at https://mozilla.org/MPL/2.0/
// © BackQuant

import TradingView/ta/4 as ta
//@version=5
//indicator(
// title="DEMA Adjusted Average True Range [BackQuant]",
// shorttitle = "DEMA ATR [BackQuant]",
// overlay=true,
// timeframe="",
// timeframe_gaps=true
// )

// Define User Inputs

simple bool showAtr = input.bool(true, "Plot Dema?",
group='EMA & ATR', inline="Show EMA's & ATR")
simple bool haCandles = true //input.bool(true, "Use HA
Candles?")
simple int periodDema = 7 //input.int(7, "Dema Period",
group = "Dema Atr")
series float sourceDema = close //input.source(close,
"Calculation Source", group = "Dema Atr")
simple int periodAtr = 14 //input.int(14, "Period",
group = "Dema Atr")
simple float factorAtr = 1.7 //input.float(1.7, "Factor",
step = 0.01, group = "Dema Atr")
simple color longColour = #00ff00
simple color shortColour = #ff0000
/////////////////////////////////////////////////////////////// ©
BackQuant ///////////////////////////////////////////////////////////////
// Use HA Candles?
heikinashi_close = request.security(
symbol = ticker.heikinashi(syminfo.tickerid),
timeframe = timeframe.period,
expression = close,
gaps = barmerge.gaps_off,
lookahead = barmerge.lookahead_on
)

var series float source = close

if haCandles == true
source := heikinashi_close
if haCandles == false
source := sourceDema
/////////////////////////////////////////////////////////////// ©
BackQuant ///////////////////////////////////////////////////////////////
// Function
DemaAtrWithBands(periodDema, source, lookback, atrFactor)=>
ema1 = ta.ema(source, periodDema)
ema2 = ta.ema(ema1, periodDema)
demaOut = 2 * ema1 - ema2

atr = ta.atr(lookback)
trueRange = atr * atrFactor

DemaAtr = demaOut
DemaAtr := nz(DemaAtr[1], DemaAtr)

trueRangeUpper = demaOut + trueRange

trueRangeLower = demaOut - trueRange
 if trueRangeLower > DemaAtr
DemaAtr := trueRangeLower
if trueRangeUpper < DemaAtr
DemaAtr := trueRangeUpper
DemaAtr

// Function Out
DemaAtr = DemaAtrWithBands(periodDema, source, periodAtr, factorAtr)
/////////////////////////////////////////////////////////////// ©
BackQuant ///////////////////////////////////////////////////////////////
// Conditions
DemaAtrLong = DemaAtr > DemaAtr[1]
DemaAtrShort = DemaAtr < DemaAtr[1]

// Colour Condtions
var color Trendcolor = #ffffff
if DemaAtrLong
Trendcolor := longColour
if DemaAtrShort
Trendcolor := shortColour

// Plotting
plot( showAtr ? DemaAtr : na, "ATR", color=Trendcolor, linewidth = 2 )