//@version=5

// This source code is subject to the terms of the Mozilla Public License 2.0 at
[Link]
// © reees
//@version=5

indicator("ChartPattern Pattern Detection, Prediction, and Backtesting

System","ChartPattern",overlay=true,max_lines_count=500,max_labels_count=500,max_ba
rs_back=500)

import reees/TA/85 as t
import reees/Draw/27 as draw
import reees/Utilities/5 as u
import reees/Pattern/1 as p
import reees/Obj_XABCD_Harmonic/10 as h
//import reees/Algebra/3 as alg

//-----------------------------------------
// inputs and vars
//-----------------------------------------

// Pattern Type Inputs

var bullOn = [Link](true, "Bullish", inline="type_b", group="Include")
var bearOn = [Link](true, "Bearish", inline="type_b", group="Include")
var incOn = [Link](true, "Potential/Incomplete", inline="type_b",
group="Include")
var hsOn = [Link](true, "Only high scoring", inline="type_b",
group="Include",tooltip="Only show patterns that meet your 'If score is above'
entry requirement.")
var i_lb = [Link](false,"Lookback bars",group="Include",inline="h")
var i_lbn = [Link](100,"",group="Include",inline="h")
var gartOn = [Link](true, "Gartley: ", inline="gart", group="Types &
Targets")
var gart_t1 = [Link](".618 AD", "Target 1", inline="gart", group="Types &
Targets", options=[".382 AD",".5 AD",".618 AD",".382 XA",".5 XA",".618 XA","1.272
XA","1.618 XA",".382 CD",".5 CD",".618 CD","1.272 CD","1.618 CD","A","B","C"])
var gart_t2 = [Link]("1.272 AD", " Target 2", inline="gart", group="Types &
Targets", options=["None",".618 AD","1.272 AD","1.618 AD",".618 XA","1.272
XA","1.618 XA",".618 CD","1.272 CD","1.618 CD","A","B","C"])
var batOn = [Link](true, "Bat: ", inline="bat", group="Types &
Targets")
var bat_t1 = [Link](".618 AD", "Target 1", inline="bat", group="Types &
Targets", options=[".382 AD",".5 AD",".618 AD",".382 XA",".5 XA",".618 XA","1.272
XA","1.618 XA",".382 CD",".5 CD",".618 CD","1.272 CD","1.618 CD","A","B","C"])
var bat_t2 = [Link]("1.272 AD", " Target 2", inline="bat", group="Types &
Targets", options=["None",".618 AD","1.272 AD","1.618 AD",".618 XA","1.272
XA","1.618 XA",".618 CD","1.272 CD","1.618 CD","A","B","C"])
var bflyOn = [Link](true, "Butterfly: ", inline="bfly", group="Types &
Targets")
var bfly_t1 = [Link](".618 AD", "Target 1", inline="bfly", group="Types &
Targets", options=[".382 AD",".5 AD",".618 AD",".382 XA",".5 XA",".618 XA","1.272
XA","1.618 XA",".382 CD",".5 CD",".618 CD","1.272 CD","1.618 CD","A","B","C"])
var bfly_t2 = [Link]("1.272 AD", " Target 2", inline="bfly", group="Types &
Targets", options=["None",".618 AD","1.272 AD","1.618 AD",".618 XA","1.272
XA","1.618 XA",".618 CD","1.272 CD","1.618 CD","A","B","C"])
var crabOn = [Link](true, "Crab: ", inline="crab", group="Types &
Targets")
var crab_t1 = [Link](".618 AD", "Target 1", inline="crab", group="Types &
Targets", options=[".382 AD",".5 AD",".618 AD",".382 XA",".5 XA",".618 XA","1.272
XA","1.618 XA",".382 CD",".5 CD",".618 CD","1.272 CD","1.618 CD","A","B","C"])
var crab_t2 = [Link]("1.618 AD", " Target 2", inline="crab", group="Types &
Targets", options=["None",".618 AD","1.272 AD","1.618 AD",".618 XA","1.272
XA","1.618 XA",".618 CD","1.272 CD","1.618 CD","A","B","C"])
var sharkOn = [Link](true, "Shark: ", inline="shark", group="Types &
Targets")
var shark_t1 = [Link](".382 AD", "Target 1", inline="shark", group="Types &
Targets", options=[".382 AD",".5 AD",".618 AD",".382 XA",".5 XA",".618 XA","1.272
XA","1.618 XA",".382 CD",".5 CD",".618 CD","1.272 CD","1.618 CD","A","B","C"])
var shark_t2 = [Link]("C", " Target 2", inline="shark", group="Types &
Targets", options=["None",".618 AD","1.272 AD","1.618 AD",".618 XA","1.272
XA","1.618 XA",".618 CD","1.272 CD","1.618 CD","A","B","C"])
var cyphOn = [Link](true, "Cypher: ", inline="cyph", group="Types &
Targets")
var cyph_t1 = [Link](".618 CD", "Target 1", inline="cyph", group="Types &
Targets", options=[".382 AD",".5 AD",".618 AD",".382 XA",".5 XA",".618 XA","1.272
XA","1.618 XA",".382 CD",".5 CD",".618 CD","1.272 CD","1.618 CD","A","B","C"])
var cyph_t2 = [Link]("1.618 XA", " Target 2", inline="cyph", group="Types &
Targets", options=["None",".618 AD","1.272 AD","1.618 AD",".618 XA","1.272
XA","1.618 XA",".618 CD","1.272 CD","1.618 CD","A","B","C"])
// Entry/Stop Inputs
var e_afterC = [Link](true,"Enter after Point C",group="Entry/Stop")
var e_lvlc = [Link]("Nearest confluent PRZ level"," Enter
at",options=["Nearest confluent PRZ level","Farthest confluent PRZ level","Between
the two confluent PRZ levels","Nearest PRZ level","Farthest PRZ
level"],group="Entry/Stop")
var e_aboveC = [Link](90," If score is
above",group="Entry/Stop",tooltip="A trade will only be entered if the pattern's
score is above the specified value. Note that when entering a trade after Point C,
we have an incomplete score because we can't yet measure Point D's confluence with
the PRZ. Therefore the final pattern score may differ from the incomplete score at
the time of entry. Set this to 0 if you wish to enter a trade on every pattern.")
var e_afterD = [Link](true,"Enter after Point D",group="Entry/Stop")
var e_lvldPct = [Link](1.0," Enter at limit % away from
D",minval=0.0,step=.1,group="Entry/Stop",tooltip="Enter the trade after a valid
point D has been confirmed, up to the limit of this % away from Point D. E.g. for a
bullish pattern (long entry), if this value is set to 5%, an entry will be placed
at the best possible price up to 5% above point D. If 'Entry after Point C' is also
set, the entry will be at whichever level is reached first. \n\nIf the entry level
is not reached, the pattern will not be included in the Success Rate and Return %
statistics.")
var e_aboveD = [Link](90," If score is
above",group="Entry/Stop",tooltip="A trade will only be entered if the pattern's
score is above the specified value. Set this to 0 if you wish to enter a trade on
every pattern.")
var e_tLimit = [Link](.5," Entry window (time
limit)",group="Entry/Stop",tooltip="Time limit for order entry, specified in
pattern lengths (e.g. '0.5' means half the total pattern length). If the time limit
expires before the order is filled, it will be cancelled and no trade will be
entered for the pattern.")
var stopPct =
[Link](75,"Stop",step=1.0,minval=0.0,group="Entry/Stop",inline="stop")
var stopB = [Link]("% of distance to target 1, beyond entry","",options=["%
beyond X or D","% beyond Farthest PRZ level","% beyond Point D","% beyond entry","%
of distance to target 1, beyond
entry"],group="Entry/Stop",inline="stop",tooltip="Set stop-loss % beyond the
specified level. If price reaches this level before the first target is hit, or
before the target timeout period expires, the pattern will be considered a
failure.\n\n'% beyond X or D' = percentage below Point X or Point D, whichever is
farther from entry\n\n'% of distance to target 1' = a percentage of the distance
from the entry level to target 1. \n\n'% beyond entry' = percentage above/below the
entry level. \n\n'% beyond Point D' = percentage above/below Point D. \n\n'beyond
Farthest PRZ level' = percentage above/below the Farthest PRZ level")
// Pattern Inputs
var t_b = [Link](1,"Pattern validation length (# trailing
bars)",minval=1,group="Pattern",tooltip="The number of bars after pivot point D (or
point C for incomplete patterns) before a pattern is considered valid. This affects
how soon patterns will be drawn and entries can be placed.")
var pctErr = [Link](15.0,"Allowed fib ratio error
%",step=1.0,minval=0.0,maxval=50.0,group="Pattern",inline="err")
var pctAsym = [Link](250.0,"Allowed leg length asymmetry
%",step=1.0,minval=0.0,maxval=1000.0,group="Pattern",inline="asym",tooltip="A leg
is considered valid if its length (ΔX/number of bars) is within this % of the
average length of the other legs in the pattern.")
var w_e =
[Link](4.0,"Weight",step=.1,minval=0.0,group="Pattern",inline="err",tooltip="A
leg is considered valid if its retracement (ΔY) ratio is within this % of the
defined harmonic ratio. Weight determines the weight of retracement % error in the
total score calculation for a pattern.")
//var w_a =
[Link](0.0,"Weight",step=.1,minval=0.0,group="Pattern",inline="asym",tooltip="
A leg is considered valid if its length (ΔX/number of bars) is within this % of the
average length of the other legs in the pattern. Weight determines the weight of
length asymmetry in the total score calculation for a pattern.")
var tLimitMult = [Link](3,"Pattern time
limit",group="Pattern",step=.1,minval=.1,tooltip="Time limit for a completed
pattern to reach the projected targets. Value is specified in terms of total
pattern length (point X to point D), i.e. a value of 1 will allow one pattern
length to elapse before the pattern times out and can no longer be considered
successful. Patterns that time out will not count towards the success rates in the
results table.")
var w_p = [Link](2.0,"Weight of PRZ level
confluence",step=.1,minval=0.0,group="Pattern",tooltip="Weight applied to Potential
Reversal Zone fib level confluence in the total score calculation for a pattern.
The closer together the two closest PRZ fib levels are, the higher the score.")
var w_d = [Link](3.0,"Weight of point D / PRZ level
confluence",step=.1,minval=0.0,group="Pattern",tooltip="Weight applied to the
confluence of point D with the Potential Reversal Zone levels in the total score
calculation for a pattern. The closer point D is to either of the two confluent PRZ
fib levels, the higher the score. ")

// Alert Inputs
//var a_on = [Link](true, "Alert", inline="alert", group="Alerts")
var a_type = [Link]("Both", "Alert for", options=["Potential
patterns","Complete patterns","Both"], inline="alert", group="Alerts")

// Display Inputs
var c_bline = [Link]([Link]([Link],20), "Bullish lines",
group="Display")
var c_beline = [Link]([Link]([Link],20), "Bearish lines",
group="Display")
var c_blab = [Link]([Link]([Link],75), "Bullish labels",
group="Display")
var c_belab = [Link]([Link]([Link],75), "Bearish labels",
group="Display")
var l_txt = [Link]([Link]([Link],20), "Label text", group="Display")

var int[] includeTps = array.new_int()

if [Link]
if gartOn
[Link](includeTps,1)
if batOn
[Link](includeTps,2)
if bflyOn
[Link](includeTps,3)
if crabOn
[Link](includeTps,4)
if sharkOn
[Link](includeTps,5)
if cyphOn
[Link](includeTps,6)
var h.harmonic_params params = h.init_params(pctErr,pctAsym,includeTps,w_e,w_p,w_d)
// scoring and validation parameters for xabcd_harmonic objects

// xabcd_harmonic object pointers

var h.xabcd_harmonic[] bullGart = [Link]<h.xabcd_harmonic>()
var h.xabcd_harmonic[] bullBat = [Link]<h.xabcd_harmonic>()
var h.xabcd_harmonic[] bullBfly = [Link]<h.xabcd_harmonic>()
var h.xabcd_harmonic[] bullCrab = [Link]<h.xabcd_harmonic>()
var h.xabcd_harmonic[] bullShark = [Link]<h.xabcd_harmonic>()
var h.xabcd_harmonic[] bullCyph = [Link]<h.xabcd_harmonic>()
var h.xabcd_harmonic[] bearGart = [Link]<h.xabcd_harmonic>()
var h.xabcd_harmonic[] bearBat = [Link]<h.xabcd_harmonic>()
var h.xabcd_harmonic[] bearBfly = [Link]<h.xabcd_harmonic>()
var h.xabcd_harmonic[] bearCrab = [Link]<h.xabcd_harmonic>()
var h.xabcd_harmonic[] bearShark = [Link]<h.xabcd_harmonic>()
var h.xabcd_harmonic[] bearCyph = [Link]<h.xabcd_harmonic>()
// var int[] lastX = array.new_int(5,0)

// temp/last/incomplete pattern structures

var h.xabcd_harmonic[] pending = [Link]<h.xabcd_harmonic>()
var label[] fullIpL = array.new_label(0)
var line[] fullIpLn = array.new_line(0)
var linefill[] fullIpLf = array.new_linefill(0)
var h.xabcd_harmonic[] inc = [Link]<h.xabcd_harmonic>()
var int[] inc_lastX = array.new_int(4,0)

// Stat totals
var int[] pTot = array.new_int(0)
var int[] tTot = array.new_int(0)
var float[] t1Tot = array.new_float(0)
var float[] t2Tot = array.new_float(0)
var float[] arTot = array.new_float(0)
var float[] trTot = array.new_float(0)

//-----------------------------------------
// functions
//-----------------------------------------

// Type of harmonic pat

// Assumes pattern is complete, and therefore only one can be true
tp(h1,h2,h3,h4,h5,h6) =>
switch
h1 => 1
h2 => 2
h3 => 3
h4 => 4
 h5 => 5
=> 6

nToArray(n) =>
switch n
"a1" => bullGart
"a2" => bullBat
"a3" => bullBfly
"a4" => bullCrab
"a5" => bullShark
"a6" => bullCyph
"b1" => bearGart
"b2" => bearBat
"b3" => bearBfly
"b4" => bearCrab
"b5" => bearShark
"b6" => bearCyph

typeToArray(t,tp) =>
n = (t ? "a" : "b") + [Link](tp)
nToArray(n)

t1(tp) =>
switch tp
6 => cyph_t1
5 => shark_t1
4 => crab_t1
3 => bfly_t1
2 => bat_t1
=> gart_t1

t2(tp) =>
switch tp
6 => cyph_t2
5 => shark_t2
4 => crab_t2
3 => bfly_t2
2 => bat_t2
=> gart_t2

// get target
targets(tp) =>
[t1(tp),t2(tp)]

harmonic_xabcd_targets(tp,xY,aY,bY,cY,dY) =>
tgt1 = t1(tp)
tgt2 = t2(tp)
[t1,t2,_] = t.harmonic_xabcd_targets(xY,aY,bY,cY,dY,tgt1,tgt2)
[t1,t2]

// Timeout period
tLimit(xX,dX) =>
int((dX - xX)*tLimitMult)

incTLimit(xX,cX) =>
avg = (cX-xX)/3
int(avg * (1 + pctAsym/100)) // time out after max possible bars based on
asymmetry parameter
// Entry has timed out
eTimeout(xX,dX) =>
bar_index - dX > int((dX - xX)*e_tLimit)

// Pattern still active within timeout period

stillActive(xX,dX) =>
bar_index - tLimit(xX,dX) <= dX and eTimeout(xX,dX) == false

// make sure score is high enough to enter a trade

noEntry(h.xabcd_harmonic p) =>
not na(p.d.x) ? [Link] < (e_aboveD/100) : [Link] < (e_aboveC/100)

entry(p) =>
if noEntry(p)
[na,na,na]
else

t.harmonic_xabcd_entry([Link],[Link],p.x.y,p.a.y,p.b.y,p.c.y,p.d.y,e_afterC,e_lvlc,e_
afterD,e_lvldPct)

// Determine if entry level was reached

entryHit(p) =>
if [Link] or [Link] == false
[[Link],p.e.x,p.e.y]
else if (not na(p.d.x) and eTimeout(p.x.x,p.d.x)) or noEntry(p)
[false,na,na]
else
[_,afterC,afterD] = entry(p)
[eH,eX,eY] = t.xabcd_entryHit([Link], afterC, afterD, p.d.x, e_afterC,
e_afterD, t_b)
if not na(eY) and (([Link] and p.t1<eY) or ([Link]==false and p.t1>eY))
[na,na,na]
else
[eH==false?na:eH,eX,eY]

// Determine if pattern has succeeded or failed, or neither (na)

success(p) =>
// if stop or target 2 already hit, nothing to check
if [Link] or p.t2Hit
[p.t1Hit,p.t2Hit,[Link],na,na,na,na]
// if within time limit and trade active / entry hit, check targets/stop
else if bar_index <= (p.d.x + tLimit(p.x.x,p.d.x)) and [Link]
[Link](p.e.x,p.e.y,[Link],p.t1Hit,p.t2Hit,p.t1,p.t2)
// else nothing to update
else
[p.t1Hit,p.t2Hit,[Link],na,na,na,na]

alertMsg(p) =>
if na(p.d.x)
"Potential " + h.get_name(p) + " is forming."
else
h.get_name(p) + " has formed."

deleteFip() =>
for lbl in fullIpL
[Link](lbl)
[Link](fullIpL)
//
for ln in fullIpLn
 [Link](ln)
[Link](fullIpLn)
//
for lf in fullIpLf
[Link](lf)
[Link](fullIpLf)

removePending(pid) =>
if [Link](pending) > 0
for i=0 to [Link](pending)-1
p = [Link](pending,i)
if [Link] == pid
if i == [Link](pending)-1
deleteFip()
[Link](pending,i)
break

successTxt(p) =>
if p.t2Hit
" (Success - Target 1, Target 2)"
else if p.t1Hit
" (Success - Target 1)"
else if [Link]
" (Failed)"
else if noEntry(p) and stillActive(p.x.x,p.d.x)
" (No entry)"
else if ([Link]==false or na([Link])) and stillActive(p.x.x,p.d.x) == false
" (Missed entry)"
else if na([Link]) and stillActive(p.x.x,p.d.x)
" (Entry pending)"
else if na(p.t1Hit) and stillActive(p.x.x,p.d.x)
" (Targets pending)"
else
" (Timed out)"

ratToStr(r) =>
na(r) ? "NA " : [Link](r, "0.000")

reToStr(r) =>
na(r) ? "NA " : [Link](r, "0.0") + "%"

// Pattern tooltip
ttTxt(p) =>
[rb,rc,rd1,rd2] = t.harmonic_xabcd_fibDispTxt([Link])
[_,_,e] = entry(p)
l1 = h.get_name(p) + successTxt(p) + "\n\n"
l2 = (p.invalid_d?"Incomplete":"Total") + " Score: " +
[Link]([Link]*100,"#.###") + "\n"
l3 = " Leg retracement accuracy: " + [Link]((1-p.score_eAvg)*100,
"#.##") + "%\n"
l42 = " PRZ level confluence: " + ([Link]==6 ? "NA" :
([Link](p.score_prz*100, "#.##") + "%")) + "\n"
l43 = " Point D confluence with PRZ: " + (p.invalid_d?"NA (D
unconfirmed)":[Link]((1-p.score_eD)*100, "#.##") + "%") +"\n"
l5 = "\n Actual % Err Theoretical\n"
l6 = "AB/XA " + [Link](p.r_xb, "0.000") + " " + ([Link]==5 ? "NA
" : ([Link](p.re_xb*100, "00.0")+"%")) + " " + rb + "\n"
l7 = "BC/AB " + [Link](p.r_ac, "0.000") + " " +
[Link](p.re_ac*100, "00.0") + "% " + rc + "\n"
 l8 = "CD/BC " + ratToStr(p.r_bd) + " " + ([Link]==6 ? "NA " :
reToStr(p.re_bd*100)) + " " + rd1 + "\n"
l9 = ([Link]==6 ? "CD/XC " : "AD/XA ") + ratToStr(p.r_xd) + " " +
reToStr(p.re_xd*100) + " " + rd2 + "\n"
l91 = "\nTarget 1: " + [Link](p.t1,"#.#####") + "\nTarget 2: " +
[Link](p.t2,"#.#####")
l92 = "\nEntry: " + [Link](na(p.e.y)?e:p.e.y,"#.#####")
l93 = na([Link]) ? "" : "\nStop: " + [Link]([Link],"#.#####")
l1 + l2 + l3 + l42 + l43 + l5 + l6 + l7 + l8 + l9 + l92 + l93 + l91

status(p) =>
if p.t2Hit
" ✅✅"
else if p.t1Hit
" ✅"
else if [Link]
" ❌"
else if stillActive(p.x.x,p.d.x) == false and ([Link] == false or na([Link]))
" ⛔"
else if stillActive(p.x.x,p.d.x) and noEntry(p)
" ⛔"
else if stillActive(p.x.x,p.d.x)
" ⏳"
else
" 🕝"

lbTxt(p,status) =>
t.harmonic_xabcd_symbol([Link]) + " " + [Link]([Link]([Link],3)*100) +
status

incLbTxt(p) =>
"Potential " + t.harmonic_xabcd_symbol([Link]) + " (" +
[Link]([Link]*100,"#.##") + ")"

erasePattern(p) =>
h.erase_pattern(p)
h.erase_label(p)

deleteInc(string pid) =>

n = [Link](inc)
if not na(pid) and n > 0
for j=0 to n-1
p = [Link](inc,j)
if pid == [Link]
[Link](inc,j)
erasePattern(p)
break

drawPattern(p) =>
if incOn or not na(p.d.x)
status = status(p)
lbTxt = not na(p.d.x) ? lbTxt(p,status) : incLbTxt(p)
[_,e,_] = entry(p)
tt = not na(p.d.x) ? ttTxt(p) :
[Link]([Link],h.get_name(p),p.r_xb,p.re_xb,p.r_ac,p.re_ac,p.prz_bN,p.prz_bF,p.
prz_xN,p.prz_xF,[Link],e)
h.draw_pattern(p, [Link]?c_bline:c_beline)
if p.invalid_d
line.set_style([Link]([Link],3),line.style_dashed)
 h.draw_label(p, [Link]?c_blab:c_belab, l_txt, lbTxt, tt)

lowest(n, o=0) =>

if n >= o
v = low[o]
for i=o to n
if low[i] < v
v := low[i]
v

highest(n, o=0) =>

if n >= o
v = high[o]
for i=o to n
if high[i] > v
v := high[i]
v

notLast(p) => // check if not same pattern as last completed pattern of same type
comp = typeToArray([Link],[Link])
h.xabcd_harmonic last = [Link](comp) == 0 ? na :
[Link](comp,[Link](comp)-1)
na(last) ? true : last.x.x!=p.x.x or last.a.x!=p.a.x or last.b.x!=p.b.x

addIncompletePattern(t,h1,h2,h3,h4,h5,h6,xX,xY,aX,aY,bX,bY,cX,cY) =>
btps = [Link](h1,h2,h3,h4,h5,h6)
tps = [Link](btps)
lowest = lowest(bar_index-cX)
highest = highest(bar_index-cX)
int dX = na
float dY = na
// check if pattern already exists (incomplete or pending)
exists = false
iN = [Link](inc)
iP = [Link](pending)
if iN > 0
for i=0 to iN-1
p = [Link](inc,iN-1-i) // more likely to find it at top of
stack
if p.x.x==xX and p.a.x==aX and p.b.x==bX
if p.c.x == cX
exists := true
else
// if new point C, delete the old inc pattern in favor of this
one
[Link](inc,iN-1-i)
erasePattern(p)
break
if exists==false and iP > 0
for i=0 to iP-1
p = [Link](pending,iP-1-i)
if p.x.x==xX and p.a.x==aX and p.b.x==bX and p.c.x==cX
exists := true
break

if exists == false
// add separate incomplete pattern for each potential harmonic type
for tpe in tps
tp = tpe+1
 if exists == false
pat = [Link](xX,xY,aX,aY,bX,bY,cX,cY,dX,dY,params,tp)
if not na(pat)
[_,eC,_] = entry(pat)
if na(eC) or (not na(eC) and ((t and eC < lowest) or (t==false
and eC > highest)))
if notLast(pat)
[Link](inc,pat)
if incOn and (not na(eC) or not e_afterC)
drawPattern(pat)
if a_type == "Potential patterns" or a_type == "Both"

alert(alertMsg(pat),alert.freq_once_per_bar_close) // temporarily changing to fire

on bar close until real-time bar multiple alert issue is resolved

setTargets(p) =>
[t1,t2] = targets([Link])
h.set_target(p,1,calc_target=t1)
h.set_target(p,2,calc_target=t2)

incPid(p) =>
[Link]([Link]) + "_"
+ [Link](p.x.x) + "_"
+ [Link](p.a.x) + "_"
+ [Link](p.b.x) + "_"
+ [Link](p.c.x) + "_"
+ [Link](na)

// Draw completed pattern and update data structures

addCompleted(p,force=false) =>
if hsOn==false or noEntry(p)==false
a = typeToArray([Link],[Link])
[Link](a,p) // add pattern
// check if we need to delete incomplete pattern, only if not already
adding from an incomplete pattern and allowing entry after D
// (otherwise keep incomplete pattern to continue checking for entry after
C)
if force == false
if e_afterD
deleteInc(incPid(p))
p.invalid_d := false
setTargets(p)
drawPattern(p)
[upper,lower] =
t.harmonic_xabcd_przRange(p.prz_bN,p.prz_bF,p.prz_xN,p.prz_xF)
[Link] :=
t.harmonic_xabcd_stop(stopB,stopPct,[Link],p.x.y,p.d.y,upper,lower,p.t1,p.e.y)
if noEntry(p)==false
[Link](pending,p)
// fire alert if appropriate
if a_type == "Complete patterns" or a_type == "Both"
alert(alertMsg(p),alert.freq_once_per_bar_close) // temporarily
changing to fire on bar close until real-time bar multiple alert issue is resolved

// Add pattern to completed pattern structures

addValidPattern(p,force=false) =>
bool lasteH = na
float lastScore = na
h.xabcd_harmonic pat = na
 a = typeToArray([Link],[Link])
if [Link](a) > 0
// check last pattern of same type
last = [Link](a,[Link](a)-1)
lastScore := [Link]
// if A, B or C is different = new pattern
if p.a.x!=last.a.x or p.b.x!=last.b.x or p.c.x!=last.c.x
addCompleted(p,force)
pat := p
// if ABC are same but D is beyond last pattern's D, replace it with this
one. We want to draw the
// new/updated pattern and calculate its updated score, but maintain any
entry/targets that have
// already been hit.
else if ([Link] and p.d.y < last.d.y) or ([Link]==false and p.d.y >
last.d.y)
if ([Link] <= [Link]) or force or last.invalid_d // update if new
pattern has a higher score, last pattern had invalid D, or forcing from entry After
Point C
if [Link] // IF last
pattern entry was already hit, use the last pattern
lasteH := true
if force==false
last.invalid_d := false

[Link](last.x.x,last.x.y,last.a.x,last.a.y,last.b.x,last.b.y,last.c.x,last.c.y,p.d.
x,p.d.y,params,[Link],last)
[upper,lower] =
t.harmonic_xabcd_przRange(last.prz_bN,last.prz_bF,last.prz_xN,last.prz_xF)
[Link] :=
t.harmonic_xabcd_stop(stopB,stopPct,[Link],last.x.y,last.d.y,upper,lower,last.t1
,last.e.y)
drawPattern(last) // redraw with new D
setTargets(last) // reset targets for new D
pat := last
else // ELSE, replace last pattern
with the new pattern
removePending([Link])
erasePattern([Link](a))
addCompleted(p,force)
pat := p
else
addCompleted(p,force)
pat := p

// Update newly added pattern

if not na(pat)
// update entry, if necessary
if lasteH
[Link](pat.e.x,pat.e.y,pat.d.x,pat.d.y,[Link],true)
else
[eHit,eX,eY] = entryHit(p)
if eHit
[Link] := true
pat.e.x := eX
pat.e.y := eY
[Link](eX,eY,pat.d.x,pat.d.y,[Link])
h.draw_label(p, [Link]?c_blab:c_belab, l_txt, lbTxt(p,status(p)),
ttTxt(p))
 ""

updatePendingPatterns() =>
h.xabcd_harmonic[] new = [Link]<h.xabcd_harmonic>()
if [Link](pending) > 0
for i=0 to [Link](pending)-1
ip = [Link](pending,i)
[eH,eHx,eHy] = entryHit(ip)
tLimit = tLimit(ip.x.x,ip.d.x)
expired = bar_index == (ip.d.x + tLimit + 1) or eH==false
[t1h,t2h,sH,t1x,t1y,t2x,t2y] = success(ip)
// if time has expired or there's nothing left to update, no longer
pending
if not (expired or (eH and (not na(t2h) or t1h == false or sH)))
[Link](new,ip)
// if anything to update, update completed array entry and label if
necessary
if expired
or (eH
and ((not na(t1h) and na(ip.t1Hit)) or (not na(t2h) and
na(ip.t2Hit))))
or (eH != [Link]) or (eH and na([Link])) or (eH==false and
na([Link]))
or sH
if (eH or eH==false) and na([Link])
[Link] := eH
ip.e.x := eHx
ip.e.y := eHy
[Link](eHx,eHy,ip.d.x,ip.d.y,[Link])
// targets will be na if eH==false, so no need to also check eH
if t1h and na(ip.t1Hit)
ip.t1Hit := true
[Link](t1x,t1y,eHx,eHy,[Link])
else if t1h == false
ip.t1Hit := false
[Link](t1x,t1y,eHx,eHy,[Link]) // only draw stop X if
no target was already hit
if sH
[Link] := true
//[Link](bar_index,[Link],eHx,eHy,[Link])
if t2h
ip.t2Hit := true
[Link](t2x,t2y,eHx,eHy,[Link])
h.draw_label(ip, [Link]?c_blab:c_belab, l_txt,
lbTxt(ip,status(ip)), ttTxt(ip))
new

updateIncompletePatterns() =>
h.xabcd_harmonic[] new = [Link]<h.xabcd_harmonic>()
if [Link](inc) > 0
for p in inc
[upper,lower] =
t.harmonic_xabcd_przRange(p.prz_bN,p.prz_bF,p.prz_xN,p.prz_xF)
tLimit = incTLimit(p.x.x,p.c.x)
[eH,eHx,eHy] = entryHit(p)
if eH and e_afterC
if notLast(p)
p.d.x := eHx
p.d.y := eHy
 p.invalid_d := true
erasePattern(p)
addValidPattern(p,true)
else
erasePattern(p)
// Don't keep incomplete pattern if it's timed out or has been
invalidated
else if bar_index == (p.c.x + tLimit + 1)
or ([Link] and (high > p.c.y or low < lower))
or ([Link]==false and (low < p.c.y or high > upper))
erasePattern(p)
else
[Link](new,p)
new

drawFullInProgress() =>
if [Link](pending) > 0
last = [Link](pending,[Link](pending)-1)
if not na(last.d.x)
bb = last_bar_index - last.d.x
tLimit = tLimit(last.x.x,last.d.x)
// Only
draw if...
if bb <= tLimit //
within pattern time limit and
and noEntry(last)==false //
entry is possible and
and (eTimeout(last.x.x,last.d.x)==false or [Link]) //
entry has not timed out and
//and (na(last.t1Hit) or (last.t1Hit and na(last.t2Hit)))
and not last.t2Hit //
targets remain to be hit and
and not [Link] // stop
has not been hit
deleteFip() // delete previously drawn completed
pattern in progress
[highest,lowest] =
t.harmonic_xabcd_przRange(last.prz_bN,last.prz_bF,last.prz_xN,last.prz_xF)
[bcNt,_] =
harmonic_xabcd_targets([Link],last.x.y,last.a.y,last.b.y,last.c.y,last.prz_bN)
[bcFt,_] =
harmonic_xabcd_targets([Link],last.x.y,last.a.y,last.b.y,last.c.y,last.prz_bF)
[xaNt,_] =
harmonic_xabcd_targets([Link],last.x.y,last.a.y,last.b.y,last.c.y,last.prz_xN)
[xaFt,_] =
harmonic_xabcd_targets([Link],last.x.y,last.a.y,last.b.y,last.c.y,last.prz_xF)
stop = [Link]
[e,_,_] = entry(last)
entry = na(last.e.y) ? e : last.e.y
[ln,lb,lf] = draw.xabcd_inProgress([Link],[Link],tLimit>500?
500:tLimit,entry,stop,last.t1,last.t2,bcNt,bcFt,xaNt,xaFt,

last.x.x,last.x.y,last.a.y,last.b.x,last.b.y,last.c.y,last.d.x,last.d.y,c_bline,c_b
eline,l_txt)
for l in ln
[Link](fullIpLn,l)
for l in lb
[Link](fullIpL,l)
for l in lf
 [Link](fullIpLf,l)
else
deleteFip()
else
deleteFip()

rowValues(tp) =>
a1 = typeToArray(true,tp)
a2 = typeToArray(false,tp)
float[] ra = array.new_float(0)
t1_tot = 0
t2_tot = 0
closed = 0
if [Link](a1) > 0
for p in a1
if (not na(p.t1Hit) or [Link]) and [Link]
if p.t2Hit
r = (p.t2/p.e.y) - 1
[Link](ra,r)
t2_tot+=1
t1_tot+=1
closed+=1
else if p.t1Hit
r = (p.t1/p.e.y) - 1
[Link](ra,r)
t1_tot+=1
closed+=1
else if [Link]
r = ([Link]/p.e.y) - 1
[Link](ra,r)
closed+=1
//for p in a2
if [Link](a2) > 0
for p in a2
if (not na(p.t1Hit) or [Link]) and [Link]
if p.t2Hit
r = (p.e.y/p.t2) - 1
[Link](ra,r)
t2_tot+=1
t1_tot+=1
closed+=1
else if p.t1Hit
r = (p.e.y/p.t1) - 1
[Link](ra,r)
t1_tot+=1
closed+=1
else if [Link]
r = (p.e.y/[Link]) - 1
[Link](ra,r)
closed+=1
tot = [Link](a1) + [Link](a2)
[Link](pTot,tot)
[Link](tTot,closed)
if closed > 0
[Link](t1Tot,(t1_tot/closed)*100)
[Link](t2Tot,(t2_tot/closed)*100)
if not na([Link](ra))
[Link](arTot,[Link](ra)*100)
if not na([Link](ra))
 [Link](trTot,[Link](ra)*100)
st1 = closed>0 ? [Link]((t1_tot/closed)*100,"#.##")+"%" : "NA"
st2 = closed>0 ? [Link]((t2_tot/closed)*100,"#.##")+"%" : "NA"
ravg = not na([Link](ra)) ? [Link]([Link](ra)*100,"#.##")+"%" :
"NA"
rtot = not na([Link](ra)) ? [Link]([Link](ra)*100,"#.##")+"%" :
"NA"

[[Link](tot),[Link](closed),st1,st2,ravg,rtot]

printStats() =>
if [Link]
nR = [Link](includeTps) + 3
r = 0
t = [Link](position.bottom_left, 7, nR, bgcolor =
[Link]([Link],30), border_width = 1)
[Link](t, 0, 0, " ", text_color=[Link],
text_halign=text.align_center)
[Link](t, 1, 0, "Patterns", text_color=[Link],
text_halign=text.align_center,text_size=[Link])
[Link](t, 2, 0, "Trades", text_color=[Link],
text_halign=text.align_center,text_size=[Link])
[Link](t, 3, 0, "T1 Success", text_color=[Link],
text_halign=text.align_center,text_size=[Link])
[Link](t, 4, 0, "T2 Success", text_color=[Link],
text_halign=text.align_center,text_size=[Link])
[Link](t, 5, 0, "Avg Return %", text_color=[Link],
text_halign=text.align_center,text_size=[Link])
[Link](t, 6, 0, "Total Return %", text_color=[Link],
text_halign=text.align_center,text_size=[Link])
for tp in includeTps
r+=1
[tot,trd,st1,st2,ar,tr] = rowValues(tp)
[Link](t, 0, r, " "+t.harmonic_xabcd_symbol(tp)+" ",
text_color=[Link], text_halign=text.align_center,text_size=[Link])
[Link](t, 1, r, tot, text_color=[Link],
text_halign=text.align_center,text_size=[Link])
[Link](t, 2, r, trd, text_color=[Link],
text_halign=text.align_center,text_size=[Link])
[Link](t, 3, r, st1, text_color=[Link],
text_halign=text.align_center,text_size=[Link])
[Link](t, 4, r, st2, text_color=[Link],
text_halign=text.align_center,text_size=[Link])
[Link](t, 5, r, ar, text_color=[Link],
text_halign=text.align_center,text_size=[Link])
[Link](t, 6, r, tr, text_color=[Link],
text_halign=text.align_center,text_size=[Link])

r+=1
t1Total = not na([Link](t1Tot)) ? ([Link]([Link](t1Tot),"#.##")
+ "%") : "NA"
t2Total = not na([Link](t2Tot)) ? ([Link]([Link](t2Tot),"#.##")
+ "%") : "NA"
arTotal = not na([Link](arTot)) ? ([Link]([Link](arTot),"#.##")
+ "%") : "NA"
trTotal = not na([Link](trTot)) ? ([Link]([Link](trTot),"#.##")
+ "%") : "NA"
[Link](t, 0, r, "Total", text_color=[Link],
text_halign=text.align_center,text_size=[Link])
 [Link](t, 1, r, [Link]([Link](pTot)), text_color=[Link],
text_halign=text.align_center,text_size=[Link])
[Link](t, 2, r, [Link]([Link](tTot)), text_color=[Link],
text_halign=text.align_center,text_size=[Link])
[Link](t, 3, r, t1Total, text_color=[Link],
text_halign=text.align_center,text_size=[Link])
[Link](t, 4, r, t2Total, text_color=[Link],
text_halign=text.align_center,text_size=[Link])
[Link](t, 5, r, arTotal, text_color=[Link],
text_halign=text.align_center,text_size=[Link])
[Link](t, 6, r, trTotal, text_color=[Link],
text_halign=text.align_center,text_size=[Link])
r+=1
keyTxt = "✅ = Success | ❌ = Failure | 🕝 = Timed out* | ⛔ = No entry* | ⏳ =
In progress* \n*Not included in Success Rate/Return % statistics"
[Link](t, 0, r, keyTxt, text_color=[Link],
text_halign=text.align_right, text_size=[Link])
table.merge_cells(t,0,r,6,r)

[Link](pTot),[Link](tTot),[Link](t1Tot),[Link](t2Tot),[Link]
ar(arTot),[Link](trTot)

validD(p,dX,dY) =>
// If CD has valid length symmetry...
if dX <= (incTLimit(p.x.x,p.c.x) + p.c.x)
if t.pat_xabcd_testSym(p.a.x-p.x.x, p.b.x-p.a.x, p.c.x-p.b.x, p.d.x-p.c.x,
pctAsym)
highest = highest(bar_index-p.c.x,1)
lowest = lowest(bar_index-p.c.x,1)
// If no intermediate high/low invalidates the CD leg...
if (([Link] and dY <= lowest) or ([Link]==false and dY >= highest))
and (([Link] and p.c.y >= highest) or ([Link]==false and p.c.y <=
lowest))
// validate CD retracement for this pattern type
xa = [Link](p.x.y - p.a.y)
bc = [Link](p.b.y - p.c.y)
cd = [Link](p.c.y - dY)
ad = [Link](p.a.y - dY)
xc = [Link](p.x.y - p.c.y)
tp = [Link]
p_types = switch tp
1 => [Link](true,false,false,false,false,false)
2 => [Link](false,true,false,false,false,false)
3 => [Link](false,false,true,false,false,false)
4 => [Link](false,false,false,true,false,false)
5 => [Link](false,false,false,false,true,false)
6 => [Link](false,false,false,false,false,true)
[t1,t2,t3,t4,t5,t6] = t.test_cd(cd,bc,xa,xc,ad,pctErr,p_types)
t1 or t2 or t3 or t4 or t5 or t6
else
false
else
false
else
false

// Check for a valid pivot point D based on the pattern confirmation length
parameter (i.e. checking bar_index[t_b])
checkForValidD() =>
 x = bar_index[t_b] // bar of interest
bool isLow = true
bool isHigh = true
l = low
h = high

// Validate pivot
for i=0 to t_b-1 // check bars after potential pivot point
if l[i] < l[t_b]
isLow := false
break
if isLow // check bars before potential pivot point
for i=t_b+1 to t_b+3 // need at least 3 bars before
if l[i] < l[t_b]
isLow := false
break

for i=0 to t_b-1

if h[i] > h[t_b]
isHigh := false
break
if isHigh
for i=t_b+1 to t_b+3
if h[i] > h[t_b]
isHigh := false
break

// Validate pattern (CD leg)

if isLow or isHigh
h.xabcd_harmonic[] new = [Link]<h.xabcd_harmonic>()
// Check incomplete patterns
for p in inc
if isLow and [Link]
if validD(p, x, l[t_b])
[Link](new, [Link](p.x.x, p.x.y, p.a.x, p.a.y, p.b.x,
p.b.y, p.c.x, p.c.y, x, l[t_b], params, [Link]))
if isHigh and [Link]==false
if validD(p, x, h[t_b])
[Link](new, [Link](p.x.x, p.x.y, p.a.x, p.a.y, p.b.x,
p.b.y, p.c.x, p.c.y, x, h[t_b], params, [Link]))
// Check completed pending patterns
for p2 in pending
if isLow and [Link]
if validD(p2, x, l[t_b])
[Link](new, [Link](p2.x.x, p2.x.y, p2.a.x, p2.a.y, p2.b.x,
p2.b.y, p2.c.x, p2.c.y, x, l[t_b], params, [Link]))
if isHigh and [Link]==false
if validD(p2, x, h[t_b])
[Link](new, [Link](p2.x.x, p2.x.y, p2.a.x, p2.a.y, p2.b.x,
p2.b.y, p2.c.x, p2.c.y, x, h[t_b], params, [Link]))

for n in new
if not na(n)
addValidPattern(n)

// find new XABC (potential) pattern

find_pattern(pl,t=true) =>
if ((t and bullOn) or (t==false and bearOn))
[f,xX,xY,aX,aY,bX,bY,cX,cY] = t.pat_xabcdIncomplete(t,pl)
 if f and (i_lb==false or bar_index >= last_bar_index-i_lbn)
[h,h1,h2,h3,h4,h5,h6] =
t.harmonic_xabcd_validateIncomplete(xX,xY,aX,aY,bX,bY,cX,cY,pctErr,pctAsym,gartOn,b
atOn,bflyOn,crabOn,sharkOn,cyphOn)
if h
addIncompletePattern(t,h1,h2,h3,h4,h5,h6,xX,xY,aX,aY,bX,bY,cX,cY)

// Find XABCD patterns of various pivot lengths

find(bull=true) =>
// Could probably do this more efficiently with recursion, but Pine prohibits
it. Loops are all
// top-tested though, so it's probably not as expensive as it looks.
find_pattern(3,bull)
find_pattern(4,bull)
find_pattern(5,bull)
find_pattern(6,bull)
find_pattern(7,bull)
find_pattern(8,bull)
find_pattern(9,bull)
find_pattern(10,bull)
find_pattern(11,bull)
find_pattern(12,bull)
find_pattern(13,bull)
find_pattern(14,bull)
find_pattern(15,bull)
find_pattern(16,bull)
find_pattern(17,bull)
find_pattern(18,bull)
find_pattern(19,bull)
find_pattern(20,bull)

//-----------------------------------------
// Main
//-----------------------------------------

// update patterns in progress

inc := updateIncompletePatterns() // update potential/incomplete pattern
pending := updatePendingPatterns() // update any completed patterns pending
results

// find new patterns

find() // find bullish patterns
find(false) // find bearish patterns

checkForValidD()

// last bar business

if [Link]
drawFullInProgress() // draw most recent complete pattern, if still in
progress
printStats() // compile stats and draw results table