Standard Deviation Channel

//@version=5

indicator("Standard Deviation Channel", overlay=true)

length = input.int(128, title="Length", minval = 1, maxval = 5000)

src = input.source(close, title="Source")

// ----------------------------------------------------------------------
upper_1_bool_input  = input.bool(true, title="Upper +1", inline="abc",     group = "channel")
upper_1_float_input = input.float(1.0, title="",         inline="abc",     group = "channel")

upper_2_bool_input  = input.bool(true, title="Upper +2", inline="cde",     group = "channel")
upper_2_float_input = input.float(2.0, title="",         inline="cde",     group = "channel")

upper_3_bool_input  = input.bool(true, title="Upper +3", inline="ghi",     group = "channel")
upper_3_float_input = input.float(3.0, title="",         inline="ghi",     group = "channel")

lower_1_bool_input  = input.bool(true, title="Lower -1", inline="bcd",     group = "channel")
lower_1_float_input = input.float(1.0, title="",         inline="bcd",     group = "channel")

lower_2_bool_input  = input.bool(true, title="Lower -2", inline="def",     group = "channel")
lower_2_float_input = input.float(2.0, title="",         inline="def",     group = "channel")

lower_3_bool_input  = input.bool(true, title="Lower +3", inline="hij",     group = "channel")
lower_3_float_input = input.float(3.0, title="",         inline="hij",     group = "channel")
// ----------------------------------------------------------------------
color_upper_1 = input.color(color.new(color.blue, 95),   "", inline = "colors", group = "colors")
color_upper_2 = input.color(color.new(color.green, 95),  "", inline = "colors", group = "colors")
color_upper_3 = input.color(color.new(color.red, 95),    "", inline = "colors", group = "colors")

color_lower_1 = input.color(color.new(color.blue, 95), "", inline = "colors", group = "colors")
color_lower_2 = input.color(color.new(color.green, 95),  "", inline = "colors", group = "colors")
color_lower_3 = input.color(color.new(color.red, 95),    "", inline = "colors", group = "colors")
// ----------------------------------------------------------------------
visual_settings_group = "Visual Settings"

prinp = input.bool(false, "Show Pearson's R",   group = visual_settings_group)
exl   = input.bool(false, "Extend Lines Left",  group = visual_settings_group)
exr   = input.bool(true,  "Extend Lines Right", group = visual_settings_group)

exs = switch
    exl and exr => extend.both
    exl         => extend.left
    exr         => extend.right
    => extend.none
// ----------------------------------------------------------------------
slpclc(source, length) =>

    max_bars_back(source, 5000)

    if not barstate.islast or length <= 1
        [float(na), float(na), float(na)]

    else
        sumX = 0.0
        sumY = 0.0
        sumXSqr = 0.0
        sumXY = 0.0

        for i = 0 to length - 1 by 1
            val = source[i]
            per = i + 1.0
            sumX += per
            sumY += val
            sumXSqr += per * per
            sumXY += val * per

        slope = (length * sumXY - sumX * sumY) / (length * sumXSqr - sumX * sumX)

        average = sumY / length

        intercept = average - slope * sumX / length + slope

        [slope, average, intercept]
// ----------------------------------------------------------------------
[s, a, i] = slpclc(src, length)

st_price  = i + s * (length - 1)
end_price = i

base_line = line.new(bar_index - length + 1, st_price, bar_index, end_price, width=1, extend=exs, style=line.style_dashed, color=color.new(color.orange, 0))
// ----------------------------------------------------------------------
devcalc(source, length, slope, average, intercept) =>
    upDev = 0.0
    dnDev = 0.0
    stdDevAcc = 0.0
    dsxx = 0.0
    dsyy = 0.0
    dsxy = 0.0
    periods = length - 1
    daY = intercept + slope * periods / 2
    val = intercept
    for j = 0 to periods by 1
        price = high[j] - val
        if price > upDev
            upDev := price
        price := val - low[j]
        if price > dnDev
            dnDev := price
        price := source[j]
        dxt = price - average
        dyt = val - daY
        price -= val
        stdDevAcc += price * price
        dsxx += dxt * dxt
        dsyy += dyt * dyt
        dsxy += dxt * dyt
        val += slope
    stdDev = math.sqrt(stdDevAcc / (periods == 0 ? 1 : periods))
    pearsonR = dsxx == 0 or dsyy == 0 ? 0 : dsxy / math.sqrt(dsxx * dsyy)
    [stdDev, pearsonR, upDev, dnDev]
// ----------------------------------------------------------------------
[stdDev, pearsonR, upDev, dnDev] = devcalc(src, length, s, a, i)
// ----------------------------------------------------------------------
create_line(bool_input, float_input, color, dev) =>
    line_start_price = st_price  + (bool_input ? float_input * stdDev : dev)
    line_end_price   = end_price + (bool_input ? float_input * stdDev : dev)

    line.new(bar_index - length + 1, line_start_price, bar_index, line_end_price, width=1, style=line.style_dashed, extend=exs, color=color.new(color, 0))
// ----------------------------------------------------------------------
upper_1_line = create_line(upper_1_bool_input,  upper_1_float_input, color_upper_1,  upDev)
upper_2_line = create_line(upper_2_bool_input,  upper_2_float_input, color_upper_2,  upDev)
upper_3_line = create_line(upper_3_bool_input,  upper_3_float_input, color_upper_3,  upDev)

lower_1_line = create_line(lower_1_bool_input, -lower_1_float_input, color_lower_1, -dnDev)
lower_2_line = create_line(lower_2_bool_input, -lower_2_float_input, color_lower_2, -dnDev)
lower_3_line = create_line(lower_3_bool_input, -lower_3_float_input, color_upper_3, -dnDev)
// ----------------------------------------------------------------------
linefill.new(upper_1_line, base_line, color = color_upper_1)
linefill.new(lower_1_line, base_line, color = color_lower_1)
// ----------------------------------------------------------------------