Davo Indicator

//@version=4
//Davo version 3.5.4
study(title="Davo Indicator v3.5.4", shorttitle="Davo v3.5.4", overlay=true, precision=8)
// ################################################################################################################################################################
// General info and acknowledgements
// ################################################################################################################################################################
// Author: maqpie (a.k.a sanne)
// Date: 4th of December 2016
// 
// This script is based upon Davinci's dav-o meter and his original script, which searches for W's and M's in price, OBV, RSI and/or Willy.
// Although the original script is elegant, a W or M has to occur within 5 bars. 
// However, often what you will see is that a W or M forms over more than 5 bars.
// This script tries to remove that limit.
//  
// It took me several different approaches to find a good solution. For the most part because of the lack of any real debugging tool in Pine script.
// Let me know what you think, because I feel like I need tone down the number of options so it is easier to use.
// If you have any questions, or things you would like to see different please contact me at TRI.
// 
// Have fun playing and goofing around with it!
// 
// ################################################################################################################################################################
// How it works
// ################################################################################################################################################################
//
// Now, trading is more of an art form than a science and this indicator is no exception.
// When talking about M's and W's, it begs the question: what exactly counts as a W or M?
// My personal experience is that for a W to count as such, it has to adhere to the following rules:
//  
//      1. A 'W'  has 5 points, A, B, C, D and E                                E
//      2. Point A can be any point                                        C   /
//      3. Point B should be lower than A                             A   / \ /
//      4. Point C should be higher than B                             \ /   D
//      5. Point D should be lower than C, but higher than B            B
//      6. Point E should be higher than C
//
//      1. A 'M'  has 5 points, A, B, C, D and E                        B
//      2. Point A can be any point                                    / \   D
//      3. Point B should be higher than A                            A   \ / \
//      4. Point C should be lower than B                                  C   \
//      5. Point D should be higher than C, but lower than B                    E
//      6. Point E should be lower than C
//
// ######################################################################################################################################################################################################
// Script input parameters
// ######################################################################################################################################################################################################
// 
// You can use the following indicators to search for W's or M's:
//      - price (close)
//      - OBV
//      - RSI
//      - Willy
//      - MFI
//      - DMI (only DI+ and DI-; ADX isn't used)
// 
// For each of these indicators you set the following options:
//      - Use:                  whether you want to use it
//      - The maximum width:    over how many bars a W / M is allowed to form
//      - The maximum offset:   how many bars back a W / M is allowed to form
//      - Strict:               when not set, rule 5 (see 'How it works') changes: point D no longer has to be above B (for W), and no longer has to be below B (for M)
//      - Length:               lenght of the indicator, for example a 14 bar RSI
// 
// Other options:
//      - Period:               you can limit the period for backtesting. Useful to identify under what market conditions the script works best.
//
// ######################################################################################################################################################################################################
// Changelog
// ######################################################################################################################################################################################################
//
// v3.2
// - added title to plotshapes so that alerts are identifiable
// - set the default value for the allowed width of all indicators to 7
// - set the default value for "limit period" to true
// - set the default period for "limit period" to 1/1/2017 - 1/1/2018
// - moved indicator label to the bottom of the chart so it is easier to find
// - removed option "Show Dav-O" (this can now be done via the style tab)
// - removed option "Show Potential Dav-O". This was added to detect intra-bar signals. However, this can now be handled from within the Create Alert dialog. Use the option 'Once per bar (on condition)'.
//
// v3.3
// - migrated to Pine Version 3
// - added source
// - reinstated 'potential' dav-o based upon barstate.isrealtime as it is useful to have it on the chart
//
// v3.4
// - added MFI
// - fixed the offset; the offset wasn't working as intended
// - tidied up code
// - set the default period for "limit period" to 1/7/2017 - 1/1/2019
//
// v3.5
// - added DMI (only DI+ and DI-; ADX is not used)
//
// ######################################################################################################################################################################################################
// List of future improvements
// ######################################################################################################################################################################################################
//
// List of future improvements (in no particluar order):
//      - find a way to get rid of the "width" option, i.e. find W's and M's dynamically
//      - add option rsi overbought / oversold
//      - add option willy stupid
//      - add option to incorporate RLZ (this might become a separate indicator though)
//      - add option find divergences (this might become a separate indicator though)
//
//  Please share ideas with me to further improve this indicator. Thanks 
//
// ######################################################################################################################################################################################################


src = input(title = "Source", type = source, defval = close)
//option_potential = input(defval = false, title = "Show unconfirmed")

includePrice = input(defval = true, title = "Use price")
strictPrice = input(defval = true, title = "Strict")
rangePrice = input(9, minval=5, title = "Max. width of price W/M") // e.g. allow an price W/M to form over 7 bars. 
offsetPrice = input(0, minval=0, title = "Max. offset of price W/M") // e.g. allow an price W/M to form 1 bar in history. Keep this number low. The goal is to synch the market structure over multiple indicators.

includeOBV = input(defval = true, title = "Use OBV")
strictOBV = input(defval = true, title = "Strict")
rangeOBV = input(9, minval=5, title = "Max. width of OBV W/M") 
offsetOBV = input(0, minval=0, title = "Max. offset of OBV W/M")

includeWly = input(defval = true, title = "Use Willy")
includeWillyStupid = input(defval=false, title = "Use Willy stupid")
strictWly = input(defval = true, title = "Strict")
rangeWly = input(9, minval=5, title = "Max. width of Willy W/M")
offsetWly = input(0, minval=0, title = "Max. offset of Willy W/M")
lengthWly = input(21, minval=1, title = "Willy length")
lengthWlyEma = input(13, minval=1, title = "Willy length ema")


includeMFI = input(defval = false, title = "Use MFI")
strictMFI = input(defval = true, title = "Strict")
rangeMFI = input(9, minval=5, title = "Max. width of MFI W/M") 
offsetMFI = input(0, minval=0, title = "Max. offset of MFI W/M")
lengthMFI = input(14, minval=1, title = "MFI length")

includeRSI = input(defval = false, title = "Use RSI")
strictRSI = input(defval = true, title = "Strict")
rangeRSI = input(9, minval=5, title = "Max. width of RSI W/M")
offsetRSI = input(0, minval=0, title = "Max. offset of RSI W/M")
lengthRSI = input(14, minval=1, title = "RSI length")

includeDMI = input(defval = false, title = "Use DMI (DI+ & DI-)")
strictDMI = input(defval = true, title = "Strict")
rangeDMI = input(9, minval=5, title = "Max. width of DMI W/M")
offsetDMI = input(0, minval=0, title = "Max. offset of DMI W/M")
lengthDMI = input(14, minval=1, title = "DMI length")

includeWithinRLZ = input(defval = false, title = "Price within RLZ")
includeBelowRLZ = input(defval = false, title = "Price above/below RLZ")
upperBoundRLZ = input(defval = 61.8, minval=0.0, maxval=100.0, title = "Upper bound of RLZ (fib)")
lowerBoundRLZ = input(defval = 78.6, minval=0.0, maxval=100.0, title = "Lower bound of RLZ (fib)")
lengthPeriodRLZ = input(defval = 200, minval=5, title = "Lookback period (bars)")
showRLZLong = input(defval = false, title = "Draw RLZ long")
showRLZShort = input(defval = false, title = "Draw RLZ short")

ATH = highest(high, lengthPeriodRLZ)
ATL = lowest(low, lengthPeriodRLZ)
range = ATH - ATL

is_rlz_long = barssince(highest(high, lengthPeriodRLZ)) >= barssince(lowest(low, lengthPeriodRLZ))
is_rlz_short = barssince(highest(high, lengthPeriodRLZ)) < barssince(lowest(low, lengthPeriodRLZ))

longUpperRLZ = showRLZLong ? ((1-upperBoundRLZ/100) * range) + ATL : na
longLowerRLZ = showRLZLong ? ((1-lowerBoundRLZ/100) * range) + ATL : na
longWithinRLZ = longUpperRLZ >= src and src >= longLowerRLZ
longBelowRLZ = longLowerRLZ > src
p1 = plot(longUpperRLZ, color=green, title="61.8 (long)")
p2 = plot(longLowerRLZ, color=green, title="78.6 (long)")
fill(p1, p2, color=#7DCEA0, transp=90, title="RLZ long")

shortUpperRLZ = showRLZShort ? ATH - ((1-upperBoundRLZ/100) * range) : na
shortLowerRLZ = showRLZShort ? ATH - ((1-lowerBoundRLZ/100) * range) : na
shortWithinRLZ = shortUpperRLZ <= src and src <= shortLowerRLZ
shortAboveRLZ = shortLowerRLZ < src
p3 = plot(shortUpperRLZ, color=red, title="78.6 (short)")
p4 = plot(shortLowerRLZ, color=red, title="61.8 (short)")
fill(p3, p4, color=#cd6155, transp=90, title="RLZ short")

includeSMA = input(defval = false, title = "Price above/below SMA")
lengthSMA = input(20, minval=1, title = "SMA length")

// limit by period option
limitPeriod = input(defval = true, title = "Limit period (increases perfomance)")
lengthPeriod = input(240, minval=1, title = "Length of period (hours)")

hours_in_milliseconds = 1000 * 60 * 60
withinPeriod = (not limitPeriod) or (timenow - time) < (hours_in_milliseconds * lengthPeriod)

// quickLook = input(defval = true, title = "Quick Look") // ignores historic data and will plot a signal on the chart
// show_order_details = input(defval = true, title = "Show entry / stoploss / target") // show entry, stoploss and target (toggling this doesn't work)
show_order_details = true
entrySource = input(title="Source for stoploss", type=source, defval=close)
stopLossSource = input(title="Source for entry", type=source, defval=close)
stopLossPercentage = input(defval = 0.01, minval = 0, maxval=100, step=0.01, title = "Stop loss %")
riskRewardRatio = input(defval = 2.0, minval = 0.0, title = "Risk to Reward 1-to-")

show = not barstate.isrealtime and (includePrice or includeOBV or includeRSI or includeWly or includeMFI or includeDMI)
//showPotential = barstate.isrealtime and (includePrice or includeOBV or includeRSI or includeWly or includeMFI or includeDMI) and option_potential

// create a series of obv, mfi, rsi, sma and willy values
OBVs = cum(change(src) > 0 ? volume : change(src) < 0 ? -volume : 0*volume)
// caclulate mfi series
upper_s = sum(volume * (change(hlc3) <= 0 ? 0 : hlc3), lengthMFI)
lower_s = sum(volume * (change(hlc3) >= 0 ? 0 : hlc3), lengthMFI)
MFIs = rsi(upper_s, lower_s)
RSIs = rsi(lengthRSI,src)
SMAs = sma(src,lengthSMA)
// make willy series
upperWly = highest(lengthWly)
lowerWly = lowest(lengthWly)
WLYs = 100 * (src - upperWly) / (upperWly - lowerWly)
emaWly = ema(WLYs, lengthWlyEma)

series_a_above_series_b(seriesA, seriesB, aRange) =>
    result = true
    for i = 0 to aRange-1
        if (seriesB[i] > seriesA[i])
            result := false
            break
    result := result

series_a_below_series_b(seriesA, seriesB, aRange) =>
    result = true
    for i = 0 to aRange-1
        if (seriesB[i] < seriesA[i])
            result := false
            break
    result := result    

dirmov(len) =>
    up = change(high)
    down = -change(low)
    truerange = rma(tr, len)
    plus = fixnan(100 * rma(up > down and up > 0 ? up : 0, len) / truerange)
    minus = fixnan(100 * rma(down > up and down > 0 ? down : 0, len) / truerange)
    [plus, minus]

data_W(aSeries, aRange, anOffset, strict) =>
    e = 0, d = 0, c = 0, b = 0, a = 0
    valueE = aSeries[0], valueD = aSeries[0], valueC = aSeries[0], valueB = aSeries[0], valueA = aSeries[0]
    found = false
    
    for offset=0 to anOffset
        if (found)
            break
        e := 0, d := 0, c := 0, b := 0, a := 0
        valueE := aSeries[0], valueC := aSeries[0], valueD := aSeries[0], valueB := aSeries[0], valueA := aSeries[0]
        
        for i = 1 to aRange-1
            // find d
            if (aSeries[i+offset] < aSeries[i+offset-1] and valueC == aSeries[0])
                d := i+offset
                valueD := aSeries[i+offset]
                continue
            if (d == 0)
                break
            // find c
            if (aSeries[i+offset] > aSeries[i+offset-1] and valueB == aSeries[0])
                c := i+offset
                valueC := aSeries[i+offset]
                continue
            if (c == 0)
                break
            if (aSeries[i+offset] < aSeries[i+offset-1] and valueA == aSeries[0])
                b := i+offset
                valueB := aSeries[i+offset]
                continue
            if (b == 0)
                break
            if (aSeries[i+offset] > aSeries[i+offset-1])
                a := i+offset
                valueA := aSeries[i+offset]
                continue
            if (a == 0)
                break
        // W found if we have found point A, and point B has a lower value than point D                
        found := (a > 0 and a != b and c != 0 and d != 0 and aSeries[e] > aSeries[c] and (aSeries[d] < aSeries[e] and aSeries[d] < aSeries[c]) and ((aSeries[b] <= aSeries[d] or not strict) and aSeries[b] < aSeries[a]))
    entry = found ? aSeries[c] : na
    stopLoss = found ? aSeries[b] * ((100 - stopLossPercentage) / 100) : na
    target = found ? entry + ((entry - stopLoss) * riskRewardRatio) : na
    [found, entry, stopLoss, target, a, b, c, d, e]
        
data_M(aSeries, aRange, anOffset, strict) =>
    e = 0, d = 0, c = 0, b = 0, a = 0
    valueE = aSeries[0], valueD = aSeries[0], valueC = aSeries[0], valueB = aSeries[0], valueA = aSeries[0]
    found = false
    
    for offset=0 to anOffset
        if (found)
            break
        e := 0, d := 0, c := 0, b := 0, a := 0
        valueE := aSeries[0], valueC := aSeries[0], valueD := aSeries[0], valueB := aSeries[0], valueA := aSeries[0]
        
        for i = 1 to aRange-1
            // find d
            if (aSeries[i+offset] > aSeries[i+offset-1] and valueC == aSeries[0])
                d := i+offset
                valueD := aSeries[i+offset]
                continue
            if (d == 0)
                break
            // find c
            if (aSeries[i+offset] < aSeries[i+offset-1] and valueB == aSeries[0])
                c := i+offset
                valueC := aSeries[i+offset]
                continue
            if (c == 0)
                break
            if (aSeries[i+offset] > aSeries[i+offset-1] and valueA == aSeries[0])
                b := i+offset
                valueB := aSeries[i+offset]
                continue
            if (b == 0)
                break
            if (aSeries[i+offset] < aSeries[i+offset-1])
                a := i+offset
                valueA := aSeries[i+offset]
                continue
            if (a == 0)
                break
        // M found if we have found point A, and point B has a greater value than point D                
        found := a > 0 and a != b and c != 0 and d != 0 and aSeries[e] < aSeries[c] and (aSeries[d] > aSeries[e] and aSeries[d] > aSeries[c]) and ((aSeries[b] >= aSeries[d] or not strict) and aSeries[b] > aSeries[a])
    entry = found ? aSeries[c] : na
    stopLoss = found ? aSeries[b] * ((100 + stopLossPercentage) / 100) : na
    target = found ? entry - ((stopLoss - entry) * riskRewardRatio) : na
    [found, entry, stopLoss, target, a, b, c, d, e]


find_W(aSeries, aRange, anOffset, strict) =>
    [found, entry, stopLoss, target, a, b, c, d, e] = data_W(aSeries, aRange, anOffset, strict)
    found

find_M(aSeries, aRange, anOffset, strict) =>
    [found, entry, stopLoss, target, a, b, c, d, e] = data_M(aSeries, aRange, anOffset, strict)
    found

// Direction Movement Index
[DIplus, DIminus] = dirmov(lengthDMI)

// calculate if price is below/above SMA
HighAboveSMA = includeSMA == false or series_a_above_series_b(high, SMAs, rangePrice)
LowBelowSMA = includeSMA == false or series_a_below_series_b(low, SMAs, rangePrice)

label = 'davo'
label_entry = 'entry'

// PLOT DAV-O
[W_found, W_entry, W_stopLoss, W_target, W_pointA, W_pointB, W_pointC, W_pointD, W_pointE] = data_W(src, rangePrice, offsetPrice, strictPrice)
[M_found, M_entry, M_stopLoss, M_target, M_pointA, M_pointB, M_pointC, M_pointD, M_pointE] = data_M(src, rangePrice, offsetPrice, strictPrice)
priceW = includePrice == false or W_found
priceM = includePrice == false or M_found

OBVw = includeOBV == false or find_W(OBVs, rangeOBV, offsetOBV, strictOBV)
OBVm = includeOBV == false or find_M(OBVs, rangeOBV, offsetOBV, strictOBV)
MFIw = includeMFI == false or find_W(MFIs, rangeMFI, offsetMFI, strictMFI)
MFIm = includeMFI == false or find_M(MFIs, rangeMFI, offsetMFI, strictMFI)
RSIw = includeRSI == false or find_M(RSIs, rangeRSI, offsetRSI, strictRSI) // we are searching for M's here to be a bull
RSIm = includeRSI == false or find_W(RSIs, rangeRSI, offsetRSI, strictRSI) // we are searching for W's here to be a bear
Wlyw = includeWly == false or find_W(WLYs, rangeWly, offsetWly, strictWly)
Wlym = includeWly == false or find_M(WLYs, rangeWly, offsetWly, strictWly)
DMIw = includeDMI == false or (find_W(DIplus, rangeDMI, offsetDMI, strictDMI) and find_M(DIminus, rangeDMI, offsetDMI, strictDMI))
DMIm = includeDMI == false or (find_M(DIplus, rangeDMI, offsetDMI, strictDMI) and find_W(DIminus, rangeDMI, offsetDMI, strictDMI))
RLZw = (includeWithinRLZ == false and includeBelowRLZ == false) or (includeWithinRLZ == true and longWithinRLZ) or (includeBelowRLZ == true and longBelowRLZ)
RLZm = (includeWithinRLZ == false and includeBelowRLZ == false) or (includeWithinRLZ == true and shortWithinRLZ) or (includeBelowRLZ == true and shortAboveRLZ)

longCondition = LowBelowSMA and priceW and OBVw and MFIw and RSIw and Wlyw and DMIw and withinPeriod and (includeWillyStupid == false or emaWly < -80) and RLZw
shortCondition = HighAboveSMA and priceM and OBVm and MFIm and RSIm and Wlym and DMIm and withinPeriod and (includeWillyStupid == false or emaWly > -20) and RLZm

// calculate entry, stoploss and target
entrySourceLong = (entrySource == low) ? high : entrySource
entrySourceShort = (entrySource == high) ? low : entrySource
stopSourceLong = (stopLossSource == high) ? low : stopLossSource
stopSourceShort = (stopLossSource == low) ? high : stopLossSource

long_entry = show and longCondition and not longCondition[1]? entrySourceLong[W_pointC] : na
long_stoploss = show and longCondition and not longCondition[1]? lowest(stopSourceLong, rangePrice) * ((100 - stopLossPercentage) / 100) : na
long_target = show and longCondition and not longCondition[1]? long_entry + ((long_entry - long_stoploss) * riskRewardRatio) : na
short_entry = show and shortCondition and not shortCondition[1]? entrySourceShort[M_pointC] : na
short_stoploss = show and shortCondition and not shortCondition[1]? highest(stopSourceShort, rangePrice) * ((100 + stopLossPercentage) / 100) : na
short_target = show and shortCondition and not shortCondition[1]? short_entry - ((short_stoploss - short_entry) * riskRewardRatio) : na

entry = long_entry? long_entry : short_entry? short_entry : na
stoploss = long_stoploss? long_stoploss : short_stoploss? short_stoploss : na
target = long_target? long_target : short_target ? short_target : na

// define plot settings for entry, stoploss and target
transparency = show_order_details ? 0 : 100
clr_entry = show and (longCondition or shortCondition)? white : na
clr_stoploss = show and (longCondition or shortCondition) ? red : na
clr_target = show and (longCondition or shortCondition) ? lime : na

// plot davo
plotshape(show and longCondition and not longCondition[1], title="Davo long", style=shape.triangleup, location=location.belowbar, color=lime, text=label)
plotshape(show and shortCondition and not shortCondition[1], title="Davo short", style=shape.triangledown, location=location.abovebar, color=red, text=label)
plotshape(show and longCondition[1], title="Davo long confirmed", style=shape.cross, location=location.bottom, color=lime, text="alert", transp=100)
plotshape(show and shortCondition[1], title="Davo short confirmed", style=shape.cross, location=location.top, color=red, text="alert", transp=100)
//plotshape(showPotential and longCondition, title="Davo long (potential)", style=shape.triangleup, location=location.belowbar, color=orange, text=label)
//plotshape(showPotential and shortCondition, title="Davo short (potential)", style=shape.triangledown, location=location.abovebar, color=orange, text=label)

// plot entry, stoploss target
plotshape(entry[1], title="Entry", color=clr_entry[1], style=shape.circle, location=location.absolute, transp=transparency[1])
plotshape(stoploss[1], title="Stop loss", color=clr_stoploss[1], style=shape.circle, location=location.absolute, transp=transparency[1])
plotshape(target[1], title="Target", color=clr_target[1], style=shape.circle, location=location.absolute, transp=transparency[1])

// plot long entry, stoploss target
// plotshape(long_entry, title="Long entry", color=clr_entry, style=shape.circle, location=location.absolute, transp=transparency)
// plotshape(long_stoploss, title="Long stop loss", color=clr_stoploss, style=shape.circle, location=location.absolute, transp=transparency)
// plotshape(long_target, title="Long target", color=clr_target, style=shape.circle, location=location.absolute, transp=transparency)
// plot short entry, stoploss target
// plotshape(short_entry, title="Short entry", color=clr_entry, style=shape.circle, location=location.absolute, transp=transparency)
// plotshape(short_stoploss, title="Short stop loss", color=clr_stoploss, style=shape.circle, location=location.absolute, transp=transparency)
// plotshape(short_target, title="Short target", color=clr_target, style=shape.circle, location=location.absolute, transp=transparency)

// alerts
alertcondition(longCondition[1] and not longCondition[2], title='Davo long confirmed', message='Davo long')
alertcondition(shortCondition[1] and not longCondition[2], title='Davo short confirmed', message='Davo short')