//@version=4
study(title="Accumulation/Distribution", shorttitle="Accum/Dist", format=format.volume, overlay=false, resolution="")
ad = cum(close==high and close==low or high==low ? 0 : ((2*close-low-high)/(high-low))*volume)
plot(ad, title = "Accumulation/Distribution", color=#999915)

//@version=4
study(title = "Advance Decline Line", shorttitle="ADL", format=format.price, precision=2)
sym(s) => security(s, timeframe.period, close)
difference = (sym("USI:ADVN.NY") - sym("USI:DECL.NY"))/(sym("USI:UNCH.NY") + 1)
adline = cum(difference > 0 ? sqrt(difference) : -sqrt(-difference))
plot(adline)

//@version=4
study("Auto Fib Retracement", overlay=true)
​
// pivots threshold
threshold_multiplier = input(title="Deviation", type=input.float, defval=3, minval=0)
dev_threshold = atr(10) / close * 100 * threshold_multiplier
​
depth = input(title="Depth", type=input.integer, defval=10, minval=1)
var extendLeft = input(false, "Extend Lines Left")
var extendRight = input(true, "Extend Lines Right")
​
var extending = extend.none
if extendLeft and extendRight
    extending := extend.both
if extendLeft and not extendRight 
    extending := extend.left
if not extendLeft and extendRight
    extending := extend.right
​
reverse = input(false, "Reverse")
prices = input(true, "Prices")
levels = input(true, "Levels")
levelsFormat = input("Values", "Levels Format", options = ["Values", "Percent"])
labelsPosition = input("Left", "Labels Position", options = ["Left", "Right"])
​
var line lineLast = na
var int iLast = 0
var int iPrev = 0
var float pLast = 0
var isHighLast = false // otherwise the last pivot is a low pivot
​
pivots(src, length, isHigh) => 
    l2 = length * 2 
    c = nz(src[length])
    ok = true
    for i = 0 to l2
        if isHigh and src[i] > c
            ok := false
        
        if not isHigh and src[i] < c
            ok := false
    if ok
        [bar_index[length], c]
    else
        [int(na), float(na)]
[iH, pH] = pivots(high, depth / 2, true)
[iL, pL] = pivots(low, depth / 2, false)
​
calc_dev(base_price, price) =>
    100 * (price - base_price) / price
    
pivotFound(dev, isHigh, index, price) => 
    if isHighLast == isHigh and not na(lineLast)
        // same direction
        if isHighLast ? price > pLast : price < pLast
            line.set_xy2(lineLast, index, price)
            [lineLast, isHighLast]
        else
            [line(na), bool(na)]
    else // reverse the direction (or create the very first line)
        if abs(dev) > dev_threshold
            // price move is significant
            id = line.new(iLast, pLast, index, price, color=color.gray, width=1, style=line.style_dashed)
            [id, isHigh]
        else
            [line(na), bool(na)]
            
if not na(iH)
    dev = calc_dev(pLast, pH)
    [id, isHigh] = pivotFound(dev, true, iH, pH)
    if not na(id)
        if id != lineLast
            line.delete(lineLast)
        lineLast := id
        isHighLast := isHigh
        iPrev := iLast
        iLast := iH
        pLast := pH
else
    if not na(iL)
        dev = calc_dev(pLast, pL)
        [id, isHigh] = pivotFound(dev, false, iL, pL)
        if not na(id)
            if id != lineLast
                line.delete(lineLast)
            lineLast := id
            isHighLast := isHigh
            iPrev := iLast
            iLast := iL
            pLast := pL
​
_draw_line(price, col) =>
    var id = line.new(iLast, price, bar_index, price, color=col, width=1, extend=extending)
    if not na(lineLast)
        line.set_xy1(id, line.get_x1(lineLast), price)
        line.set_xy2(id, line.get_x2(lineLast), price)
​
​
_draw_label(price, txt, txtColor) =>
    x = labelsPosition == "Left" ? line.get_x1(lineLast) : line.get_x2(lineLast)
    var id = label.new(x=x, y=price, text=txt, textcolor=txtColor, style=label.style_none)
    label.set_xy(id, x, price)
    label.set_text(id, txt)
    label.set_textcolor(id, txtColor)
​
_wrap(txt) =>
    "(" + tostring(txt, "#.##") + ")"
​
_label_txt(level, price) =>
    l = levelsFormat == "Values" ? tostring(level) : tostring(level * 100) + "%"
    (levels ? l : "") + (prices ? _wrap(price) : "")
​
sl1 = input(true, "0")
vall1 = 0.000
​
sl2 = input(true, "0.236")
vall2 = 0.236
​
sl3 = input(true, "0.382")
vall3 = 0.382
​
sl4 = input(true, "0.5")
vall4 = 0.5
​
sl5 = input(true, "0.618")
vall5 = 0.618
​
sl6 = input(true, "0.786")
vall6 = 0.786
​
sl7 = input(true, "1")
vall7 = 1
​
sl8 = input(true, "1.272")
vall8 = 1.272
​
sl9 = input(true, "1.414")
vall9 = 1.414
​
sl10 = input(true, "1.618")
vall10 = 1.618
​
sl11 = input(false, "2.618")
vall11 = 2.618
​
sl12 = input(false, "3.618")
vall12 = 3.618
​
sl13 = input(false, "4.236")
vall13 = 4.236
​
sl14 = input(false, "-0.236")
vall14 = -0.236
​
sl15 = input(false, "-0.382")
vall15 = -0.382
​
sl16 = input(false, "-0.618")
vall16 = -0.618
​
_draw_retracement(startPrice, endPrice) =>
    iHL = startPrice > endPrice
    diff = (iHL ? -1 : 1) * abs(startPrice - endPrice)
    if sl1
        l1 = startPrice + diff * vall1
        _draw_line(l1, #808080)
        _draw_label(l1, _label_txt(vall1, l1), #808080)
        
    if sl2
        l2 = startPrice + diff * vall2
        _draw_line(l2, #a61c00)
        _draw_label(l2, _label_txt(vall2, l2), #a61c00)
    
    if sl3
        l3 = startPrice + diff * vall3
        _draw_line(l3, #95cc28)
        _draw_label(l3, _label_txt(vall3, l3), #95cc28)
    
    if sl4
        l4 = startPrice + diff * vall4
        _draw_line(l4, #28cc28)
        _draw_label(l4, _label_txt(vall4, l4), #28cc28)
    
    if sl5
        l5 = startPrice + diff * vall5
        _draw_line(l5, #28cc95)
        _draw_label(l5, _label_txt(vall5, l5), #28cc95)
    
    if sl6
        l6 = startPrice + diff * vall6
        _draw_line(l6, #2895cc)
        _draw_label(l6, _label_txt(vall6, l6), #2895cc)
    
    if sl7
        l7 = startPrice + diff * vall7
        _draw_line(l7, #808080)
        _draw_label(l7, _label_txt(vall7, l7), #808080)
        
    if sl8
        l8 = startPrice + diff * vall8
        _draw_line(l8, #82CA89)
        _draw_label(l8, _label_txt(vall8, l8), #82CA89)
​
    if sl9
        l9 = startPrice + diff * vall9
        _draw_line(l9, #F32C42)
        _draw_label(l9, _label_txt(vall9, l9), #F32C42)
        
    if sl10
        l10 = startPrice + diff * vall10
        _draw_line(l10, #2796ED)
        _draw_label(l10, _label_txt(vall10, l10), #2796ED)
        
    if sl11
        l11 = startPrice + diff * vall11
        _draw_line(l11, #a61c00)
        _draw_label(l11, _label_txt(vall11, l11), #a61c00)
        
    if sl12
        l12 = startPrice + diff * vall12
        _draw_line(l12, #9B03AE)
        _draw_label(l12, _label_txt(vall12, l12), #9B03AE)
        
    if sl13
        l13 = startPrice + diff * vall13
        _draw_line(l13, #E80065)
        _draw_label(l13, _label_txt(vall13, l13), #E80065)
​
    if sl14
        l14 = startPrice + diff * vall14
        _draw_line(l14, #a61c00)
        _draw_label(l14, _label_txt(vall14, l14), #a61c00)
    
    if sl15
        l15 = startPrice + diff * vall15
        _draw_line(l15, #95cc28)
        _draw_label(l15, _label_txt(vall15, l15), #95cc28)
        
    if sl16
        l16 = startPrice + diff * vall16
        _draw_line(l16, #28cc95)
        _draw_label(l16, _label_txt(vall16, l16), #28cc95)
​
p1 = reverse ? line.get_y1(lineLast) : pLast
p2 = reverse ? pLast : line.get_y1(lineLast)
_draw_retracement(p1, p2)

//@version=4
study("Zig Zag", overlay=true)
​
dev_threshold = input(title="Deviation (%)", type=input.float, defval=5, minval=1, maxval=100)
depth = input(title="Depth", type=input.integer, defval=10, minval=1)
​
pivots(src, length, isHigh) =>
    p = nz(src[length])
​
    if length == 0
        [bar_index, p]
    else
        isFound = true
        for i = 0 to length - 1
            if isHigh and src[i] > p
                isFound := false
            if not isHigh and src[i] < p
                isFound := false
        
        for i = length + 1 to 2 * length
            if isHigh and src[i] >= p
                isFound := false
            if not isHigh and src[i] <= p
                isFound := false
    
        if isFound and length * 2 <= bar_index
            [bar_index[length], p]
        else
            [int(na), float(na)]
​
[iH, pH] = pivots(high, floor(depth / 2), true)
[iL, pL] = pivots(low, floor(depth / 2), false)
​
calc_dev(base_price, price) =>
    100 * (price - base_price) / base_price
​
var line lineLast = na
var int iLast = 0
var float pLast = 0
var bool isHighLast = true // otherwise the last pivot is a low pivot
var int linesCount = 0
​
pivotFound(dev, isHigh, index, price) =>
    if isHighLast == isHigh and not na(lineLast)
        // same direction
        if isHighLast ? price > pLast : price < pLast
            if linesCount <= 1
                line.set_xy1(lineLast, index, price)
            line.set_xy2(lineLast, index, price)
            [lineLast, isHighLast, false]
        else
            [line(na), bool(na), false]
    else // reverse the direction (or create the very first line)
        if na(lineLast)
            id = line.new(index, price, index, price, color=color.red, width=2)
            [id, isHigh, true]
        else
            // price move is significant
            if abs(dev) >= dev_threshold
                id = line.new(iLast, pLast, index, price, color=color.red, width=2)
                [id, isHigh, true]
            else
                [line(na), bool(na), false]
​
if not na(iH) and not na(iL) and iH == iL
    dev1 = calc_dev(pLast, pH)
    [id2, isHigh2, isNew2] = pivotFound(dev1, true, iH, pH)
    if isNew2
        linesCount := linesCount + 1
    if not na(id2)
        lineLast := id2
        isHighLast := isHigh2
        iLast := iH
        pLast := pH
    
    dev2 = calc_dev(pLast, pL)
    [id1, isHigh1, isNew1] = pivotFound(dev2, false, iL, pL)
    if isNew1
        linesCount := linesCount + 1
    if not na(id1)
        lineLast := id1
        isHighLast := isHigh1
        iLast := iL
        pLast := pL
    
else
    if not na(iH)
        dev1 = calc_dev(pLast, pH)
        [id, isHigh, isNew] = pivotFound(dev1, true, iH, pH)
        if isNew
            linesCount := linesCount + 1
        if not na(id)
            lineLast := id
            isHighLast := isHigh
            iLast := iH
            pLast := pH
    else
        if not na(iL)
            dev2 = calc_dev(pLast, pL)
            [id, isHigh, isNew] = pivotFound(dev2, false, iL, pL)
            if isNew
                linesCount := linesCount + 1
            if not na(id)
                lineLast := id
                isHighLast := isHigh
                iLast := iL
                pLast := pL
​

//@version=4
study("Linear Regression", shorttitle="LinReg", overlay=true)
​
upperMult = input(title="Upper Deviation", defval=2)
lowerMult = input(title="Lower Deviation", defval=-2)
​
useUpperDev = input(title="Use Upper Deviation", defval=true)
useLowerDev = input(title="Use Lower Deviation", defval=true)
showPearson = input(title="Show Pearson's R", defval=true)
extendLines = input(title="Extend Lines", defval=false)
​
len = input(title="Count", defval=100)
src = input(title="Source", defval=close)
​
extend = extendLines ? extend.right : extend.none
​
calcSlope(src, len) =>
    max_bars_back(src, 300)
    if not barstate.islast or len <= 1
        [float(na), float(na), float(na)]
    else
        sumX = 0.0
        sumY = 0.0
        sumXSqr = 0.0
        sumXY = 0.0
        for i = 0 to len - 1
            val = src[i]
            per = i + 1.0
            sumX := sumX + per
            sumY := sumY + val
            sumXSqr := sumXSqr + per * per
            sumXY := sumXY + val * per
        slope = (len * sumXY - sumX * sumY) / (len * sumXSqr - sumX * sumX)
        average = sumY / len
        intercept = average - slope * sumX / len + slope
        [slope, average, intercept]
​
[s, a, i] = calcSlope(src, len)
​
startPrice = i + s * (len - 1)
endPrice = i
var line baseLine = na
​
if na(baseLine) and not na(startPrice)
    baseLine := line.new(bar_index - len + 1, startPrice, bar_index, endPrice, width=1, extend=extend, color=color.red)
else
    line.set_xy1(baseLine, bar_index - len + 1, startPrice)
    line.set_xy2(baseLine, bar_index, endPrice)
    na
​
calcDev(src, len, slope, average, intercept) =>
    upDev = 0.0
    dnDev = 0.0
    stdDevAcc = 0.0
    dsxx = 0.0
    dsyy = 0.0
    dsxy = 0.0
    
    periods = len - 1
​
    daY = intercept + (slope * periods) / 2
    val = intercept
    
    for i = 0 to periods
        price = high[i] - val
        if (price > upDev)
            upDev := price
​
        price := val - low[i]
        if (price > dnDev)
            dnDev := price
​
        price := src[i]
        dxt = price - average
        dyt = val - daY
        
        price := price - val
        stdDevAcc := stdDevAcc + price * price
        dsxx := dsxx + dxt * dxt
        dsyy := dsyy + dyt * dyt
        dsxy := dsxy + dxt * dyt
        val := val + slope
    
    stdDev = sqrt(stdDevAcc / (periods == 0 ? 1 : periods))
    pearsonR = dsxx == 0 or dsyy == 0 ? 0 : dsxy / sqrt(dsxx * dsyy)
    [stdDev, pearsonR, upDev, dnDev]
​
[stdDev, pearsonR, upDev, dnDev] = calcDev(src, len, s, a, i)
​
upperStartPrice = startPrice + (useUpperDev ? upperMult * stdDev : upDev)
upperEndPrice = endPrice + (useUpperDev ? upperMult * stdDev : upDev)
var line upper = na
​
lowerStartPrice = startPrice + (useLowerDev ? lowerMult * stdDev : -dnDev)
lowerEndPrice = endPrice + (useLowerDev ? lowerMult * stdDev : -dnDev)
var line lower = na
​
if na(upper) and not na(upperStartPrice)
    upper := line.new(bar_index - len + 1, upperStartPrice, bar_index, upperEndPrice, width=1, extend=extend, color=#0000ff)
else
    line.set_xy1(upper, bar_index - len + 1, upperStartPrice)
    line.set_xy2(upper, bar_index, upperEndPrice)
    na
​
if na(lower) and not na(lowerStartPrice)
    lower := line.new(bar_index - len + 1, lowerStartPrice, bar_index, lowerEndPrice, width=1, extend=extend, color=#0000ff)
else
    line.set_xy1(lower, bar_index - len + 1, lowerStartPrice)
    line.set_xy2(lower, bar_index, lowerEndPrice)
    na
​
// Pearson's R
var label r = na
transparent = color.new(color.white, 100)
label.delete(r[1])
if showPearson and not na(pearsonR)
    r := label.new(bar_index - len + 1, lowerStartPrice, tostring(pearsonR, "#.################"), color=transparent, textcolor=#0000ff, size=size.normal, style=label.style_labelup)
​