win-99.txt

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © binancash

//@version=5
indicator("Snag - NEW SWING FAST", overlay=true)

pctHigh = input.float(title='Highest %', defval=10.0)
pctLow = input.float(title='Lowest %', defval=-8.0)

f_RoundUp(number, decimals) =>
    factor = math.pow(10, decimals)
    math.ceil(number * factor) / factor
    
f_nDecimals(_in) =>
    n  = int(na), s = str.tostring(_in), p = str.pos(s, ".")
    n := na(str.tonumber(s)) ? int(na) : na(p) ? 0 :
     str.length(str.substring(s, p + 1))

_n = f_nDecimals(close)

// Trend Up Strong
// Close Cross Up EMA 13, or Close Cross Up EMA 50 or Close Cross Up EMA 200
// Mark as Begin Up Trend
// Wait for EMA 13 Cross Up EMA 48 🡪 Confirm Strong Uptrend 🡪 BUY
// EMA 48 CROSS UP EMA 200 🡪 STRONGER UPTREND
// Trend Down Strong
// Close Cross Down EMA 13, or Close Cross Down EMA 50 or Close Cross Down EMA 200
// Mark as Begin Down Trend
// Wait for EMA 13 Cross Down EMA 48 🡪 Confirm Strong Downtrend 🡪 SELL
// EMA 48 CROSS DOWN EMA 200 🡪 STRONGER DOWNTREND

wma11 = ta.wma(close, 11)
plot(wma11, title="WMA11", color=color.blue)

wma48 = ta.wma(close, 48)
plot(wma48, title="WMA48", color=color.yellow)

wma200 = ta.wma(close, 200)
plot(wma200, title="WMA200", color=color.white)

crossUpWMA13 = ta.crossover(close, wma11)
crossDownWMA13 = ta.crossunder(close, wma11)
crossUpWMA48 = ta.crossover(close, wma48)
crossDownWMA48 = ta.crossunder(close, wma48)
crossUpWMA200 = ta.crossover(close, wma200)
crossDownWMA200 = ta.crossunder(close, wma200)

crossUpWMA13_48 = ta.crossover(wma11, wma48)
crossDownWMA13_48 = ta.crossunder(wma11, wma48)
crossUpWMA48_200 = ta.crossover(wma48, wma200)
crossDownWMA48_200 = ta.crossunder(wma48, wma200)

var price_wmacrossup_arr = array.new_float()
var price_wmacrossdown_arr = array.new_float()

if crossUpWMA48_200
    price_wmacrossdown_arr := array.new_float()
    array.push(price_wmacrossup_arr, close)
else if crossDownWMA48_200
    price_wmacrossup_arr := array.new_float()
    array.push(price_wmacrossdown_arr, close)
        
//price_up = 0.0
//price_down = 0.0
//if array.size(price_wmacrossup_arr) > 0
//    price_up := array.get(price_wmacrossup_arr, array.size(price_wmacrossup_arr)-1)
//else if array.size(price_wmacrossdown_arr) > 0
//    price_down := array.get(price_wmacrossdown_arr, array.size(price_wmacrossdown_arr)-1)

var bool isUpTrend = false
var bool isDownTrend = false

if crossUpWMA13 and isUpTrend == false
    isUpTrend := true
    isDownTrend := false
else if crossUpWMA48 and isUpTrend == false
    isUpTrend := true
    isDownTrend := false
else if crossUpWMA200 and isUpTrend == false
    isUpTrend := true
    isDownTrend := false

if crossDownWMA13 and isDownTrend == false
    isUpTrend := false
    isDownTrend := true
else if crossDownWMA48 and isDownTrend == false
    isUpTrend := false
    isDownTrend := true
else if crossDownWMA200 and isDownTrend == false
    isUpTrend := false
    isDownTrend := true
    
var int trendUp = 0
var int trendDown = 0

txtMarkTrend = ''
txtOrder = 'N/A'
if isUpTrend
    if crossUpWMA13_48
        trendUp := 1
        trendDown := 0
    if crossUpWMA48_200
        trendUp := 2
        trendDown := 0
        
if isDownTrend
    if crossDownWMA13_48
        trendUp := 0
        trendDown := 1
    if crossDownWMA48_200
        trendUp := 0
        trendDown := 2
        
if isUpTrend
    txtMarkTrend := 'Begin Up Trend'
    if trendUp == 1
        txtMarkTrend := 'Confirm Strong Uptrend'
        txtOrder := 'BUY'
    else if trendUp == 2
        txtMarkTrend := 'STRONGER UPTREND'
        txtOrder := 'BUY'

else if isDownTrend
    txtMarkTrend := 'Begin Down Trend'
    if trendDown == 1
        txtMarkTrend := 'Confirm Strong Downtrend'
        txtOrder := 'SELL'
    else if trendDown == 2
        txtMarkTrend := 'STRONGER DOWNTREND'
    txtOrder := 'SELL'
    
// setting % period
pctTop = 5.0
pctBottom = -5.0
if str.format("{0}", timeframe.period) == '5'
    pctTop := 2.5
    pctBottom := -2.5
    
else if str.format("{0}", timeframe.period) == '180'
    pctTop := 10.0
    pctBottom := -10.0  

else if str.format("{0}", timeframe.period) == 'D'
    pctTop := 15.0
    pctBottom := -15.0
    
txtBottom = ''
txtTop = ''
is_bottom_wma200 = false
is_top_wma200 = false
pct_low_wma200 = 0.0
pct_high_wma200 = 0.0
if low < wma200
    pct_low_wma200 := f_RoundUp((low - wma200)/wma200*100, 2)
    if pct_low_wma200 <= pctBottom
        txtBottom := 'BOTTOM'
        is_bottom_wma200 := true
else if high > wma200
    pct_high_wma200 := f_RoundUp((high - wma200)/wma200*100, 2)
    
    if pct_high_wma200 >= pctTop
        txtTop := 'TOP'
        is_top_wma200 := true

    
// Alert CALL PUT
var time_wmacrossup_arr = array.new_int()
var time_wmacrossdown_arr = array.new_int()

if trendUp == 1 or trendUp == 2
    time_wmacrossdown_arr := array.new_int()
    if array.size(time_wmacrossup_arr) == 0
        array.push(time_wmacrossup_arr, time)
else if trendDown == 1 or trendDown == 2
    time_wmacrossup_arr := array.new_int()
    if array.size(time_wmacrossdown_arr) == 0
        array.push(time_wmacrossdown_arr, time)
        
is_alert_wmacrossup = false
is_alert_wmacrossdown = false

var has_wmacrossup_arr = array.new_bool()
var has_wmacrossdown_arr = array.new_bool()

if array.size(time_wmacrossup_arr) > 0
    if time == array.get(time_wmacrossup_arr, array.size(time_wmacrossup_arr)-1)
        is_alert_wmacrossup := true
        array.push(has_wmacrossup_arr, true)
else if array.size(time_wmacrossdown_arr) > 0
    if time == array.get(time_wmacrossdown_arr, array.size(time_wmacrossdown_arr)-1)
        is_alert_wmacrossdown := true
        array.push(has_wmacrossdown_arr, true)
        
alertcondition(is_alert_wmacrossdown, title='ENTER PUT', message='Get out Call and Enter PUT')
alertcondition(is_alert_wmacrossup, title='ENTER CALL', message='Get out Put and Enter CALL')


/////////////////////////////////////////////////////////////////////////////////////////////
// alert TOP - BOTTOM START
var time_top_arr = array.new_int()
var time_bottom_arr = array.new_int()

if is_top_wma200
    time_bottom_arr := array.new_int()
    if array.size(time_top_arr) == 0
        array.push(time_top_arr, time)
else if is_bottom_wma200
    time_top_arr := array.new_int()
    if array.size(time_bottom_arr) == 0
        array.push(time_bottom_arr, time)
        
is_alert_top = false
is_alert_bottom = false

var has_top_arr = array.new_bool()
var has_bottom_arr = array.new_bool()

if array.size(time_top_arr) > 0
    if time == array.get(time_top_arr, array.size(time_top_arr)-1)
        is_alert_top := true
        array.push(has_top_arr, true)
else if array.size(time_bottom_arr) > 0
    if time == array.get(time_bottom_arr, array.size(time_bottom_arr)-1)
        is_alert_bottom := true
        array.push(has_bottom_arr, true)
        
alertcondition(is_alert_bottom, title='ENTER BOTTOM', message='BOTTOM - Get out PUT and Enter CALL')
alertcondition(is_alert_top, title='ENTER TOP', message='TOP - Get out CALL and Enter PUT')
// alert TOP - BOTTOM END
/////////////////////////////////////////////////////////////////////////////////////////////
// RSI
rsi = ta.rsi(close, 9)
rsiWMA = ta.wma(rsi, 125)
cci = ta.cci(close, 10)

////////////////////////////////BEGIN SUP RES
// Time Frame 1 = TF1
TF1 = timeframe.period
stockschart = syminfo.type == 'stock'
futureschart = syminfo.type == 'futures'
indexchart = syminfo.type == 'index'

f_resInMinutes() =>
    if stockschart or futureschart or indexchart
        _resInMinutes = timeframe.multiplier * (timeframe.isseconds ? 1. / 60 : timeframe.isminutes ? 1. : timeframe.isdaily ? 60. * 16 : timeframe.isweekly ? 60. * 7 * 5 : timeframe.ismonthly ? 60. * 7 * 21 : na)
        _resInMinutes
    else
        _resInMinutes = timeframe.multiplier * (timeframe.isseconds ? 1. / 60 : timeframe.isminutes ? 1. : timeframe.isdaily ? 60. * 24 : timeframe.isweekly ? 60. * 24 * 7 : timeframe.ismonthly ? 60. * 24 * 30.4375 : na)
        _resInMinutes

f_tfResInMinutes(_res) =>
    request.security(syminfo.tickerid, _res, f_resInMinutes())

TF1InMinutes = f_tfResInMinutes(TF1)

currentTFInMinutes = f_resInMinutes()
chartOnLowerTF1 = currentTFInMinutes <= TF1InMinutes

TF1_inH = str.tostring(TF1InMinutes / 60)
TF1_text = if stockschart or futureschart
    TF1InMinutes >= 60 and TF1InMinutes < 960 ? TF1_inH + 'h' : TF1InMinutes < 60 ? TF1 + 'm' : TF1
else
    TF1InMinutes >= 60 and TF1InMinutes < 1440 ? TF1_inH + 'h' : TF1InMinutes < 60 ? TF1 + 'm' : TF1

barsinTF1 = TF1InMinutes / currentTFInMinutes

TF1_bar_index = math.ceil(1 * barsinTF1)

TF1_bar_index_range = math.ceil(3 * barsinTF1)

var TF1_High_index =  math.abs(ta.highestbars(high, nz(TF1_bar_index_range, 1)))[TF1_bar_index] + TF1_bar_index
var TF1_Low_index = math.abs(ta.lowestbars(low, nz(TF1_bar_index_range, 1)))[TF1_bar_index] + TF1_bar_index
    
if TF1_bar_index + TF1_bar_index_range > 4999
    TF1_High_index := 4999
    TF1_Low_index := 4999

f_tfUp(_TF_High, _TF_Vol, _TF_VolMA) =>
    _TF_High[3] > _TF_High[4] and _TF_High[4] > _TF_High[5] and _TF_High[2] < _TF_High[3] and _TF_High[1] < _TF_High[2] and _TF_Vol[3] > _TF_VolMA[3]

f_tfDown(_TF_Low, _TF_Vol, _TF_VolMA) =>
    _TF_Low[3] < _TF_Low[4] and _TF_Low[4] < _TF_Low[5] and _TF_Low[2] > _TF_Low[3] and _TF_Low[1] > _TF_Low[2] and _TF_Vol[3] > _TF_VolMA[3]

f_tfSources(_res, _source) =>
    request.security(syminfo.tickerid, _res, _source)

// S/R  = Time Frame 1 = TF1
TF1_Vol = f_tfSources(TF1, volume)
TF1_VolMA = ta.wma(TF1_Vol, 6)
TF1_High = f_tfSources(TF1, high)
TF1_Low = f_tfSources(TF1, low)
TF1_Open = f_tfSources(TF1, open)
TF1_Close = f_tfSources(TF1, close)

TF1_Up = f_tfUp(TF1_High, TF1_Vol, TF1_VolMA)
TF1_Down = f_tfDown(TF1_Low, TF1_Vol, TF1_VolMA)

TF1_CalcFractalUp() =>
    TF1_FractalUp = 0.0
    TF1_FractalUp := TF1_Up ? TF1_High[3] : TF1_FractalUp[1]
    TF1_FractalUp

TF1_CalcFractalDown() =>
    TF1_FractalDown = 0.0
    TF1_FractalDown := TF1_Down ? TF1_Low[3] : TF1_FractalDown[1]
    TF1_FractalDown

TF1_FractalUp = request.security(syminfo.tickerid, TF1, TF1_CalcFractalUp())
TF1_FractalDown = request.security(syminfo.tickerid, TF1, TF1_CalcFractalDown())

// Zones - Current Time Frame = Time Frame 1 = TF1
// Fractal Up Zones
TF1_CalcFractalUpZone() =>
    TF1_FractalUpZone = 0.0
    TF1_FractalUpZone := TF1_Up and TF1_Close[3] >= TF1_Open[3] ? TF1_Close[3] : TF1_Up and TF1_Close[3] < TF1_Open[3] ? TF1_Open[3] : TF1_FractalUpZone[1]
    TF1_FractalUpZone

TF1_FractalUpZone = request.security(syminfo.tickerid, TF1, TF1_CalcFractalUpZone())
TF1_ResistanceZone = TF1_FractalUpZone

// Fractal Down Zones
TF1_CalcFractalDownZone() =>
    TF1_FractalDownZone = 0.0
    TF1_FractalDownZone := TF1_Down and TF1_Close[3] >= TF1_Open[3] ? TF1_Open[3] : TF1_Down and TF1_Close[3] < TF1_Open[3] ? TF1_Close[3] : TF1_FractalDownZone[1]
    TF1_FractalDownZone

TF1_FractalDownZone = request.security(syminfo.tickerid, TF1, TF1_CalcFractalDownZone())
TF1_SupportZone = TF1_FractalDownZone
//////////////////////////////////END SUP RES


/////////////////////////////////BEGIN cross
bigdrop = rsi + 8 < rsi[1] and close > wma48
plotshape(bigdrop, title="Big Drop", style=shape.square, location=location.abovebar, color=color.white, size=size.tiny)

bottomsupport = close > TF1_SupportZone[0] and close > close[1] and rsi > rsi[1] + 10 
plotshape(bottomsupport, title="Big Bottom", style=shape.xcross, location=location.belowbar, color=color.yellow, size=size.tiny)


// Alert Exit CALL PUT
var time_exitup_arr = array.new_int()
var time_exitdown_arr = array.new_int()

if bigdrop
    time_exitdown_arr := array.new_int()
    if array.size(time_exitup_arr) == 0
        array.push(time_exitup_arr, time)
else if bottomsupport
    time_exitup_arr := array.new_int()
    if array.size(time_exitdown_arr) == 0
        array.push(time_exitdown_arr, time)
        
is_alert_exitup = false
is_alert_exitdown = false

if array.size(time_exitup_arr) > 0 and array.size(has_wmacrossup_arr) > 0
    if time == array.get(time_exitup_arr, array.size(time_exitup_arr)-1)
        is_alert_exitup := true
        has_wmacrossup_arr := array.new_bool()
else if array.size(time_exitdown_arr) > 0 and array.size(has_wmacrossdown_arr) > 0 
    if time == array.get(time_exitdown_arr, array.size(time_exitdown_arr)-1)
        is_alert_exitdown := true
        has_wmacrossdown_arr := array.new_bool()
        
alertcondition(is_alert_exitdown, title='EXIT PUT', message='Exit PUT')
alertcondition(is_alert_exitup, title='EXIT CALL', message='Exit CALL')


fast_length = 12
slow_length = 26
signal_length = 9
fast_ma = ta.ema(close, fast_length)
slow_ma = ta.ema(close, slow_length)
macd = fast_ma - slow_ma
signal = ta.ema(macd, signal_length)
macd_crossover = ta.crossover(macd, -40)
var bool is_macd_corssover = false
var bool is_macd_corssunder = false
if macd_crossover
    is_macd_corssover := true
    is_macd_corssunder := false
    
macd_crossunder = ta.crossunder(macd, 55)
if macd_crossunder
    is_macd_corssover := false
    is_macd_corssunder := true
    
highest = ta.highest(high, 48)
pct_low = f_RoundUp((close - highest)/highest*100, 2)
var bool is_lowest = false
var bool is_highest = false
if pct_low <= pctLow and close < wma200
    pct_lowest = f_RoundUp((close - wma200)/wma200*100, 2)
    if pct_lowest <= pctBottom and is_macd_corssover
        is_lowest := true
        is_highest := false
if close > wma200
    is_lowest := false
is_bottom = false
if is_lowest and bottomsupport
    is_bottom := true
plotshape(is_bottom, title="Bottom", style=shape.diamond, location=location.belowbar, color=color.yellow, size=size.tiny)

lowest = ta.lowest(low, 48)
pct_high = f_RoundUp((close - lowest)/lowest*100, 2)
if pct_high >= pctHigh and close > wma200
    pct_highest = f_RoundUp((close - wma200)/wma200*100, 2)
    if pct_highest >= pctTop and is_macd_corssunder
        is_highest := true
        is_lowest := false
//if close < wma200
//    is_highest := false
is_top = false
if is_highest and bigdrop
    is_top := true
plotshape(is_top, title="TOP", style=shape.diamond, location=location.abovebar, color=color.white, size=size.tiny)



// UPTREND
bool check_gap              = input.bool(title = "Gap Size Filter",  defval = true)
float gap                   = input.float(title = "Gap Size", defval = 0.05, minval = 0.01, maxval = 0.5)
bool check_strong_trend     = input.bool(title = "Strong Trend Filter", defval = true)
bool check_upward_trend     = input.bool(title = "Upward Trend Filter", defval = true)

// -- inline function(s)
uptrend(opens, closes, len, total) => 
    count = 0
    for i = 0 to (len - 1)
        if (opens[i] < closes[i])
            count := count + 1
    flag = count >= total
    flag

// -- study logic and calculation(s)
src2 = true                                                              // initializing a series
src2 := src2 and (close[1] > open[1])                                     // checks if previous candle is a bullish candle
src2 := src2 and (open > close)                                           // checks if current candle is a bearish candle
src2 := src2 and (open > close[1])                                        // checks if current candle open is greater than previous bullish candle close
src2 := src2 and (close < (open[1] - ((open[1] - close[1]) / 2.0)))       // checks if current candle close is below mid line of previous candle

// these filters are applied to reduce noises
if (check_gap)                                                          //
    src2 := src2 and (math.abs(open - close[1]) > (gap * math.abs(open - close)))   // checks if there is a gap between previous candle close and current candle open
if (check_strong_trend)                                                 //
    src2 := src2 and (math.abs(open[1] - close[1]) > math.abs(open - close))        // checks if previous bullish candle is strong enough
if (check_upward_trend)                                                 //
    src2 := src2 and uptrend(open[1], close[1], 3, 2)                     // checks if previous candle belongs to a series of up trend candles

plotshape(src2, title = "Dark Cloud Cover", location = location.abovebar, color = color.yellow, style = shape.arrowdown, text = "D")

    
// Bullish
length = input(21)
//------------------------------------------------------------------------------
o = open[length],h = high[length]
l = low[length],c = close[length]
//------------------------------------------------------------------------------
ph = ta.pivothigh(close,length,length)
pl = ta.pivotlow(open,length,length)
valH = ta.valuewhen(ph,c,0)
valL = ta.valuewhen(pl,c,0)
valpH = ta.valuewhen(ph,c,1)
valpL = ta.valuewhen(pl,c,1)
//------------------------------------------------------------------------------
d = math.abs(c - o)
hammer = pl and math.min(o,c) - l > d and h - math.max(c,o) < d
ihammer = pl and h - math.max(c,o) > d and math.min(c,o) - l < d
bulleng = c > o and c[1] < o[1] and c > o[1] and o < c[1]
hanging = ph and math.min(c,o) - l > d and h - math.max(o,c) < d
shooting = ph and h - math.max(o,c) > d and math.min(c,o) - l < d
beareng = c > o and c[1] < o[1] and c > o[1] and o < c[1]
//------------------------------------------------------------------------------
//Descriptions
//------------------------------------------------------------------------------
hammer_ = "The hammer candlestick pattern is formed of a short body with a long lower wick, and is found at the bottom of a downward trend."
  + "\n" + "\n A hammer shows that although there were selling pressures during the day, ultimately a strong buying pressure drove the price back up." 
ihammer_ = "The inverted hammer is a similar pattern than the hammer pattern. The only difference being that the upper wick is long, while the lower wick is short."
  + "\n" + "\n It indicates a buying pressure, followed by a selling pressure that was not strong enough to drive the market price down. The inverse hammer suggests that buyers will soon have control of the market."
bulleng_ = "The bullish engulfing pattern is formed of two candlesticks. The first candle is a short red body that is completely engulfed by a larger green candle"
  + "\n" + "\n Though the second day opens lower than the first, the bullish market pushes the price up, culminating in an obvious win for buyers"
hanging_ = "The hanging man is the bearish equivalent of a hammer; it has the same shape but forms at the end of an uptrend."
  + "\n" + "It indicates that there was a significant sell-off during the day, but that buyers were able to push the price up again. The large sell-off is often seen as an indication that the bulls are losing control of the market."
shotting_ = "The shooting star is the same shape as the inverted hammer, but is formed in an uptrend: it has a small lower body, and a long upper wick."
  + "\n" + "Usually, the market will gap slightly higher on opening and rally to an intra-day high before closing at a price just above the open – like a star falling to the ground."
beareng_ = "A bearish engulfing pattern occurs at the end of an uptrend. The first candle has a small green body that is engulfed by a subsequent long red candle."
  + "\n" + "It signifies a peak or slowdown of price movement, and is a sign of an impending market downturn. The lower the second candle goes, the more significant the trend is likely to be."
//------------------------------------------------------------------------------
n = bar_index
label lbl = na
H = valH > valpH ? "HH" : valH < valpH ? "LH" : na
L = valL < valpL ? "LL" : valL > valpL ? "HL" : na
txt = hammer ? "Hammer" : ihammer ? "Inverse Hammer" :
  bulleng ? "Bullish Engulfing" : hanging ? "Hanging Man" :
  shooting ? "Shooting Star" : beareng ? "Bearish Engulfing" : "None"
des = hammer ? hammer_ : ihammer ? ihammer_ :
  bulleng ? bulleng_ : hanging ? hanging_ :
  shooting ? shotting_ : beareng ? beareng_ : ""
if ph
    lbl := label.new(n[length],math.max(c,o),H + "\n" + txt,color=#ff1100,
      style=label.style_label_down,textcolor=color.white,tooltip=des)
    label.delete(lbl[1])
else if pl
    lbl := label.new(n[length],math.min(c,o),L + "\n" + txt,color=#2157f3,
      style=label.style_label_up,textcolor=color.white,tooltip=des)
    label.delete(lbl[1])
    
    
/////////////////////////////////////////////////////////////
// pattern DOJI - HAMARI

pctDw = input.int(60,minval=0,maxval=90,title="Doji, Min % of Range of Candle for Wicks")
pipMin= input.int(0,minval=0,title="Doji, Previous Candle Min Pip Body Size")
sname=input.bool(true,title="Show Price Action Bar Names")
cbar = input.bool(false,title="Highlight Harami & Doji Bars")
sHm    = input.bool(false,title="Show Only Harami Style Doji's")
setalm = input.bool(true, title="Generate Alert for Harami & Doji Bars")
uha   =input.bool(true, title="Use Heikin Ashi Candles for Calculations")
bars = input.int(3,minval=1,maxval=3,step=1,title="Doji, Number of Lookback Bars")
//
// Use only Heikinashi Candles for all calculations
srcclose = uha ? request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, close) : close
srcopen = uha ? request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, open) : open
srchigh = uha ? request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, high) : high
srclow = uha ? request.security(ticker.heikinashi(syminfo.tickerid), timeframe.period, low) : low

//
pip = syminfo.mintick
hl_range = srchigh - srclow


// Calculate Doji/Harami Candles
pctCDw = (pctDw/2) * 0.01
pctCDb = (100-pctDw) * 0.01

//Lookback Candles for bulls or bears
lbBull = bars==1? srcopen[1]>srcclose[1]: bars==2? (srcopen[1]>srcclose[1] and srcopen[2]>srcclose[2]): bars==3?(srcopen[1]>srcclose[1] and srcopen[2]>srcclose[2] and srcopen[3]>srcclose[3]):false
lbBear = bars==1? srcopen[1]<srcclose[1]: bars==2? (srcopen[1]<srcclose[1] and srcopen[2]<srcclose[2]): bars==3?(srcopen[1]<srcclose[1] and srcopen[2]<srcclose[2] and srcopen[3]<srcclose[3]):false

//Lookback Candle Size only if mininum size is > 0
lbSize = pipMin==0? true : bars==1 ? (math.abs(srcopen[1]-srcclose[1])>pipMin*pip) :
  bars==2 ? (math.abs(srcopen[1]-srcclose[1])>pipMin*pip and math.abs(srcopen[2]-srcclose[2])>pipMin*pip) :
  bars==3 ? (math.abs(srcopen[1]-srcclose[1])>pipMin*pip and math.abs(srcopen[2]-srcclose[2])>pipMin*pip and math.abs(srcopen[3]-srcclose[3])>pipMin*pip) :
  false

dojiBu = (srcopen[1] >= math.max(srcclose,srcopen) and srcclose[1]<=math.min(srcclose,srcopen)) and lbSize and
  (math.abs(srcclose-srcopen)<hl_range*pctCDb and (srchigh-math.max(srcclose,srcopen))>(pctCDw*hl_range) and (math.min(srcclose,srcopen)-srclow)>(pctCDw*hl_range))? 1 : 0

dojiBe = (srcclose[1] >= math.max(srcclose,srcopen) and srcopen[1]<=math.min(srcclose,srcopen)) and lbSize and
  (math.abs(srcclose-srcopen)<hl_range*pctCDb and (srchigh-math.max(srcclose,srcopen))>(pctCDw*hl_range) and (math.min(srcclose,srcopen)-srclow)>(pctCDw*hl_range))? 1 : 0
  
haramiBull = (srcopen<=srcclose or (math.max(srcclose,srcopen)-math.min(srcclose,srcopen))<pip*0.5) and lbBull and dojiBu
haramiBear = (srcopen>=srcclose or (math.max(srcclose,srcopen)-math.min(srcclose,srcopen))<pip*0.5) and lbBear and dojiBe

dojiBull = not sHm and not haramiBull and not haramiBear and lbBull and dojiBu
dojiBear = not sHm and not haramiBull and not haramiBear and lbBear and dojiBe

//
//plotshape(haramiBear and sname?srchigh:na,title="Bearish Harami",text='Bearish\nHarami',color=color.red, style=shape.arrowdown,location=location.abovebar)
//plotshape(haramiBear and cbar?math.max(srcopen,srcclose):na,title="Bear Colour Harami",color=color.red, style=shape.circle,location=location.absolute,size=size.normal)
//
//plotshape(haramiBull and sname?srclow:na,title="Bullish Harami",text='Bullish\nHarami',color=color.green, style=shape.arrowup,location=location.belowbar)
//plotshape(haramiBull and cbar?math.max(srcopen,srcclose):na,title="Bull Colour Harami",color=color.green, style=shape.circle,location=location.absolute,size=size.normal)
//
//plotshape(dojiBear and sname?srchigh:na,title="Bearish Doji",text='Bearish\nDoji',color=color.fuchsia, style=shape.arrowdown,location=location.abovebar)
//plotshape(dojiBear and cbar?math.max(srcopen,srcclose):na,title="Bear Colour Doji",color=color.fuchsia, style=shape.circle,location=location.absolute,size=size.normal)
//
//plotshape(dojiBull and sname?srclow:na,title="Bullish Doji",text='Bullish\nDoji',color=color.aqua, style=shape.arrowup,location=location.belowbar)
//plotshape(dojiBull and cbar?math.max(srcopen,srcclose):na,title="Bull Colour Doji",color=color.aqua, style=shape.circle,location=location.absolute,size=size.normal)


//
//plotshape(na(baralert[1])?na:baralert[1], transp=0,style=shape.circle,location=location.bottom, offset=-1,title="Bar Alert Confirmed", 
//  color=bcolor[1]==1 ? green : bcolor[1]==2? red : bcolor[1]==3? aqua : bcolor[1]==4? fuchsia : na)

/////////////////////////////////////////////////////////////
src = close
di = (6 - 1.0) / 2.0 + 1.0
c1 = 2 / (di + 1.0)
c2 = 1 - c1
c3 = 3.0 * (0.4 * 0.4 + 0.4 * 0.4 * 0.4)
c4 = -3.0 * (2.0 * 0.4 * 0.4 + 0.4 + 0.4 * 0.4 * 0.4)
c5 = 3.0 * 0.4 + 1.0 + 0.4 * 0.4 * 0.4 + 3.0 * 0.4 * 0.4
var float i1 = na
var float i2 = na
var float i3 = na
var float i4 = na
var float i5 = na
var float i6 = na
i1 := c1 * src + c2 * nz(i1[1])
i2 := c1 * i1 + c2 * nz(i2[1])
i3 := c1 * i2 + c2 * nz(i3[1])
i4 := c1 * i3 + c2 * nz(i4[1])
i5 := c1 * i4 + c2 * nz(i5[1])
i6 := c1 * i5 + c2 * nz(i6[1])
cto = -0.4 * 0.4 * 0.4 * i6 + c3 * i5 + c4 * i4 + c5 * i3
ema3 = ta.ema(close, 3)
long = (close > cto and close[1] < cto[1] and close > close[1] or close[1] > cto[1] and close > close[1] and close [1] < close[2] and close > ema3) ? true : false
profit_long = close < close[1] and low < ema3 and close[1] > ema3[1] and close[2] > ema3[2]
        
short = (close < cto and close[1] > cto[1] and close < close[1] or close[1] < cto[1] and close < close[1] and close [1] > close[2] and close < ema3) ? true : false
profit_short = close > close[1] and high > ema3 and close[1] < ema3[1] and close[2] < ema3[2]




gain1 = math.abs(close-close[1])
gain2 = math.abs(close[1]-close[2])

pattern_call = close[1]<close[2] and close[2]<close[3] and low <= low[1] and close >= close[1]and (gain1-gain2)/gain2 >= 0.5
plotshape(pattern_call?low:na, title = "Inside pattern CALL", location = location.belowbar, color = color.green, style = shape.labelup, text = "IC", textcolor=color.white)

plotshape(pattern_call and long?close:na, title = "LET CALL", location = location.belowbar, color = color.green, style = shape.circle, textcolor=color.yellow, text = "CALL 100% WIN", size=size.normal)

plotshape(pattern_call and profit_short?close:na, title = "OUT PUT", location = location.belowbar, color = color.green, style = shape.circle, textcolor=color.white, size=size.normal)


pattern_put = close[1]>close[2] and close[2]>close[3] and high<=high[1]  and close <= close[1] and (gain1-gain2)/gain2 <= -0.5
plotshape(pattern_put?high:na, title = "Inside pattern PUT", location = location.abovebar, color = color.red, style = shape.labeldown, text = "IP", textcolor=color.white)
    
plotshape(pattern_put and short?close:na, title = "LET PUT", location = location.abovebar, color = color.red, style = shape.circle, textcolor=color.yellow, text = "PUT 100% WIN", size=size.normal)


plotshape(pattern_put and profit_long?close:na, title = "OUT CALL", location = location.abovebar, color = color.red, style = shape.diamond, textcolor=color.white, size=size.normal)
    
if barstate.islast
    var table panel = table.new("bottom_right", 6, 30)

    table.cell(panel, 0, 1, "TREND", bgcolor = color.yellow, text_color=color.black, width=18, text_halign=text.align_left)
    table.cell(panel, 1, 1, txtMarkTrend+(haramiBull and sname?'BULL':''), bgcolor = color.yellow, text_color=color.black, width=30, text_halign=text.align_left)    
    table.cell(panel, 0, 3, "EMA11", bgcolor = color.yellow, text_color=color.black, width=18, text_halign=text.align_left)
    table.cell(panel, 1, 3, str.format("{0}", wma11), bgcolor = color.yellow, text_color=color.black, width=30, text_halign=text.align_left)    
    table.cell(panel, 0, 5, "EMA48", bgcolor = color.yellow, text_color=color.black, width=18, text_halign=text.align_left)
    table.cell(panel, 1, 5, str.format("{0}", wma48), bgcolor = color.yellow, text_color=color.black, width=30, text_halign=text.align_left)    
    table.cell(panel, 0, 6, "DIFF 11 48", bgcolor = color.yellow, text_color=color.black, width=18, text_halign=text.align_left)
    table.cell(panel, 1, 6, str.format("{0}", f_RoundUp(wma11-wma48,0)), bgcolor = color.yellow, text_color=color.black, width=30, text_halign=text.align_left)    
    
    if low < wma200
        table.cell(panel, 0, 7, "EMA200%", bgcolor = color.yellow, text_color=color.black, width=18, text_halign=text.align_left)
        table.cell(panel, 1, 7, str.format("{0}%   {1}", pct_low_wma200, txtBottom), bgcolor = color.yellow, text_color=color.black, width=30, text_halign=text.align_left) 
    
        predictBottomPrice = wma200 + pctBottom/100*wma200
        table.cell(panel, 0, 9, "PREDICT BOTTOM PRICE", bgcolor = color.yellow, text_color=color.black, width=18, text_halign=text.align_left)
        table.cell(panel, 1, 9, str.format("{0}", predictBottomPrice), bgcolor = color.yellow, text_color=color.black, width=30, text_halign=text.align_left)    
    
    else if high > wma200
        table.cell(panel, 0, 7, "EMA200%", bgcolor = color.yellow, text_color=color.black, width=18, text_halign=text.align_left)
        table.cell(panel, 1, 7, str.format("{0}%   {1}", pct_high_wma200, txtTop), bgcolor = color.yellow, text_color=color.black, width=30, text_halign=text.align_left) 
    
        predictTopPrice = wma200 + pctTop/100*wma200
        table.cell(panel, 0, 9, "PREDICT TOP PRICE", bgcolor = color.yellow, text_color=color.black, width=18, text_halign=text.align_left)
        table.cell(panel, 1, 9, str.format("{0}", predictTopPrice), bgcolor = color.yellow, text_color=color.black, width=30, text_halign=text.align_left)