Untitled

 avatar
3169
plain_text
a month ago
34 kB
2
Indexable
Never
//@version=5
indicator(".", overlay = true)

src33 = input(close, title="Source")
highlight = input(true, title="Highlighting?")
showSignals = input(true, title="Show Signals?")

Q1 = input.int(1, title="Q1")
Q2 = input.float(1, title="Q2")
Q3 = Q2/100
Q4 = ta.ema(src33, Q1)
Q5 = 0.0
Q5 := (Q4*(1-Q3))>nz(Q5[1],0) ? Q4*(1-Q3) : (Q4*(1+Q3))<nz(Q5[1],0) ? Q4*(1+Q3) : nz(Q5[1],0)

Z1 = input.int(5, title="Z1")
Z2 = input.float(5, title="Z2")
Z3 = Z2/100
Z4 = ta.ema(src33, Z1)
Z5 = 0.0
Z5 := (Z4*(1-Z3))>nz(Z5[1],0) ? Z4*(1-Z3) : (Z4*(1+Z3))<nz(Z5[1],0) ? Z4*(1+Z3) : nz(Z5[1],0)

BuySignal = ta.crossover(Q5,Z5)
SellSignal = ta.crossunder(Q5,Z5)
Q5pl=plot(int(Q5/1.025+1.50)*1.025, color=color.green, linewidth=1,title="Direnç")
Z5pl=plot(int(Z5/1.025+1.50)*1.025, color=color.red, linewidth=1,title="Destek")
//fill(Q5pl,Z5pl, color= highlight ? Q5>Z5 ? color.new(color.green,50) : color.new(color.red,50) : na)
//plotshape(showSignals and BuySignal, title="Buy Signal", style=shape.labelup, text="AL", textcolor=color.white, color=color.green, location=location.belowbar)
//plotshape(showSignals and SellSignal, title="Sell Signal", style=shape.labeldown, text="SAT", textcolor=color.white, color=color.red, location=location.abovebar)

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}

// ~~ ToolTips {
t1 = "Volatility Period defines the length of the look-back period for calculating volatility. Higher values make the bands adapt more slowly to volatility changes. Lower values make them adapt more quickly."
t2 = "Trend Factor adjusts the sensitivity of the trend line to price movements. A higher value makes the trend line less sensitive and smoother. Lower values make it more sensitive and reactive to price changes."
t3 = "Trend Step controls how quickly the trend line adjusts to sudden price changes. Higher values cause slower adjustments, leading to smoother trend lines. Lower values result in quicker adjustments to sudden changes."
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}

// ~~ Inputs {
volatilityPeriod   = input.int(20, title="Period", step=10, minval=2, maxval=1000, inline="vol", group="Volatility Settings", tooltip=t1)
trendFactor        = input.float(9, step=0.1, title='Factor', minval = 0.1, inline="", group="Trend Settings", tooltip=t2)
trendStep          = input.float(1, "Step", step=0.1,minval = 0.5, maxval = 5.0, inline="", group="Trend Settings", tooltip=t3)

color_trend        = input.color(color.rgb(209, 245, 3), title="Trend Line  ", inline="trend", group="Style")
colorForUpperBand  = input.color(color.new(#862458, 10), title="Upper Band", inline="band", group="Style")
colorForLowerBand  = input.color(color.new(#493893, 10), title="Lower Band", inline="band", group="Style")
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}

// ~~  Initialize Variables
var float currentTrend        = 0.0
var int trendDirection        = 0
averageTrueRange              = ta.atr(200)
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}

// ~~  Function to determine the trend direction
determineTrendDirection(direction) => direction - direction[1] > 0 ? 1 : (direction - direction[1] < 0 ? -1 : 0)
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}

// ~~  Calculate Trend Direction
closingPrice      = close
scaledStandardDev = (nz(averageTrueRange) * trendFactor)
trendDirection    := determineTrendDirection(currentTrend) * int(scaledStandardDev)
priceTrendDiff    = closingPrice - currentTrend > 0 ? closingPrice - currentTrend : currentTrend - closingPrice
reciprocalFactor  = (scaledStandardDev * (1 / trendFactor)) * 1 / math.pow(2, 100)
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}

// ~~ Calculate the Current Trend
trendAdjustment   = priceTrendDiff > scaledStandardDev * trendStep ? math.avg(closingPrice, currentTrend) : trendDirection * reciprocalFactor + currentTrend
currentTrend      := trendAdjustment
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}

// ~~  Calculate Upper and Lower Bands
upperBand = currentTrend + scaledStandardDev - averageTrueRange - ta.ema(ta.stdev(closingPrice, volatilityPeriod), 200)
lowerBand = currentTrend - scaledStandardDev + averageTrueRange + ta.ema(ta.stdev(closingPrice, volatilityPeriod), 200)
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}

// ~~ Plot
isTrendConsistent = trendDirection == trendDirection[1]
colorForPlot      = trendDirection == 1 ? color_trend : color_trend

plotTrend   = plot(isTrendConsistent ? currentTrend : na, title="VTrend ", color=colorForPlot)
plotUpper   = plot(isTrendConsistent ? upperBand : na, title="VDirenç", color = color.new(color.black, 100))
plotLower   = plot(isTrendConsistent ? lowerBand : na, title="VDestek", color = color.new(color.black, 100))

//fill(plotUpper, plotTrend, top_color = colorForLowerBand, bottom_color =color.new(na,100), top_value = upperBand, bottom_value = currentTrend, title="Background Upper")
//fill(plotTrend, plotLower, top_color = color.new(na,100), bottom_color = colorForUpperBand, top_value = currentTrend, bottom_value = lowerBand, title="Background Lower")
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}

//Trend Sar
psar(start1, inc1, maximum1) =>
    out1 = float(na)
    isUpTrend1 = bool(na)
    maxMin1 = float(na)
    acc1 = float(na)
    prev1 = float(na)

    if bar_index >= 1
        prev1 := out1[1]
        if bar_index == 1
            if close > close[1]
                isUpTrend1 := true
                maxMin1 := math.max(high, high[1])
                prev1 := math.min(low, low[1])
                prev1
            else
                isUpTrend1 := false
                maxMin1 := math.min(low, low[1])
                prev1 := math.max(high, high[1])
                prev1

            acc1 := start1
            acc1
        else
            isUpTrend1 := isUpTrend1[1]
            acc1 := acc1[1]
            maxMin1 := maxMin1[1]
            maxMin1

        if isUpTrend1
            if high > maxMin1
                maxMin1 := high
                acc1 := math.min(acc1 + inc1, maximum1)
                acc1
        else
            if low < maxMin1
                maxMin1 := low
                acc1 := math.min(acc1 + inc1, maximum1)
                acc1

        if na(out1)
            out1 := prev1 + acc1 * (maxMin1 - prev1)
            out1

        if isUpTrend1
            if low <= out1
                isUpTrend1 := false
                out1 := maxMin1
                maxMin1 := low
                acc1 := start1
                acc1
        else
            if high >= out1
                isUpTrend1 := true
                out1 := maxMin1
                maxMin1 := high
                acc1 := start1
                acc1

        if na(out1)
            if isUpTrend1
                out1 := math.min(out1, bar_index == 1 ? low[1] : math.min(low[1], low[2]))
                out1
            else
                out1 := math.max(out1, bar_index == 1 ? high[1] : math.max(high[1], high[2]))
                out1

    [out1, acc1, maxMin1, isUpTrend1]


start1 = input(0)
increment1 = input(0.01)
maximum1 = input(0.02)
[p1, AF1, EP1, isUpTrend1] = psar(start1, increment1, maximum1)

newEP1 = EP1 != EP1[1]
epNew1 = newEP1 ? EP1 : na

plot(p1, 'STrend', style=plot.style_stepline, color=isUpTrend1 ? color.rgb(25, 248, 5, 100) : color.rgb(243, 5, 5, 100), linewidth=1)
plot(EP1, 'STrend Devam', style=plot.style_circles, color=isUpTrend1 ? color.rgb(25, 248, 5, 100) : color.rgb(243, 5, 5, 100), linewidth=2)
/// sar hesaplamasını 1 dakika üzerinden bar renlendirmesi....
x1 = input.timeframe('1', title='Periyot')
z = ta.sar(0, 0.02, 0.02)
y1 = request.security(syminfo.tickerid, x1, z)
xz = input(true, title='Renk')
//Functions Sar for support and resistance
q3 = ta.sar(0.01, 0.02, 0.2)
q2 = ta.sar(0.01, 0.04, 0.4)
q1 = ta.sar(0.01, 0.06, 0.6)
plot(q3, title='UVSar', style=plot.style_circles, color=xz ? y1 > close ? color.rgb(255, 82, 82, 100) : color.rgb(0, 230, 119, 100) : color.rgb(178, 181, 190, 100), linewidth=1)
plot(q2, title='OVSar', style=plot.style_circles, color=xz ? y1 > close ? color.rgb(255, 82, 82, 100) : color.rgb(0, 230, 119, 100) : color.rgb(178, 181, 190, 100), linewidth=1)
plot(q1, title='KVSar', style=plot.style_circles, color=xz ? y1 > close ? color.rgb(255, 82, 82, 100) : color.rgb(0, 230, 119, 100) : color.rgb(178, 181, 190, 100), linewidth=1)
//Signal
xyzq = (y1) 
plot(xyzq, title='Yörük', style=plot.style_linebr, color=xz ? y1 > close ? color.rgb(255, 82, 82, 100) : color.rgb(0, 230, 119, 100) : color.rgb(178, 181, 190, 100), linewidth=1)


//bcolor = ta.crossunder(close,q3) ? color.red :  ta.crossover(close,q3) ? color.green: close>q2 ? color.green : close<q2 ? color.red: color.rgb(216, 4, 253) // : color.black 
//barcolor(bcolor)
////
//Function 
inp = input(title='Source', defval=close)
res = input.timeframe(title='Resolution', defval='60')
rep = input(title='Allow Repainting?', defval=true)
//////////////////////////////////////////////////////
src1 = request.security(syminfo.tickerid, res, inp[rep ? 0 : barstate.isrealtime ? 1 : 0])[rep ? 0 : barstate.isrealtime ? 0 : 1]
fastLength1 = input.int(title='FastLength', defval=12, minval=1)
slowLength1 = input.int(title='SlowLength', defval=26, minval=1)
signalLength1 = input.int(title='SignalLength', defval=9, minval=1)
macdLevel1 = input.float(title='MacdLevel', defval=0, minval=0)

fastAlpha1 = 2.0 / (1 + fastLength1)
slowAlpha1 = 2.0 / (1 + slowLength1)

fastEma1 = ta.ema(src1, fastLength1)
slowEma1 = ta.ema(src1, slowLength1)

pMacdEq1 = fastAlpha1 - slowAlpha1 != 0 ? ((nz(fastEma1[1]) * fastAlpha1) - (nz(slowEma1[1]) * slowAlpha1)) / (fastAlpha1 - slowAlpha1) : 0
pMacdEqSig1 = ta.ema(pMacdEq1, signalLength1)
pMacdLevel1 = fastAlpha1 - slowAlpha1 != 0 ? (macdLevel1 - (nz(fastEma1[1]) * (1 - fastAlpha1)) + (nz(slowEma1[1]) * (1 - slowAlpha1))) / (fastAlpha1 - slowAlpha1) : 0

slo1 = src1 - pMacdEq1
sig1 = slo1 > 0 ? slo1 > nz(slo1[1]) ? 2 : 1 : slo1 < 0 ? slo1 < nz(slo1[1]) ? -2 : -1 : 0

rmacdColor = sig1 > 1 ? color.rgb(0, 230, 119, 100) : sig1 > 0 ? color.rgb(0, 230, 119, 100) : sig1 < -1 ? color.rgb(255, 82, 82, 100) : sig1 < 0 ? color.rgb(255, 82, 82, 100) : color.white

plot(pMacdEq1, title='MacdTrend',style=plot.style_stepline, color=rmacdColor, linewidth=2)
plot(pMacdEqSig1, title='MacdStop', color=color.rgb(255, 255, 255, 100), linewidth=1)
///////////////////////////////////////////////////////////////////////////
lenxc20 = input(1)
lenxc50 = input(1)

z20(close, lenxc20) =>
    hcx20 = 0.0
    dxc20 = 0.0
    for i = 0 to lenxc20 - 1 by 1
        kxc20 = (lenxc20 - i) * lenxc20
        hcx20 += kxc20
        dxc20 += close[i] * kxc20
        dxc20
    dxc20 / hcx20

cxc20 = z20(close, math.floor(math.sqrt(lenxc20)))
//
z50(close, lenxc50) =>
    hxc50 = 0.0
    dxc50 = 0.0
    for i = 0 to lenxc50 - 1 by 1
        kxc50 = (lenxc50 - i) * lenxc50
        hxc50 += kxc50
        dxc50 += close[i] * kxc50
        dxc50
    dxc50 / hxc50

cxc50 = z50(close, math.floor(math.sqrt(lenxc50)))
//
//

startsx20 = 0.1
incrementsx20 = 0.1
maximumsx20 = 0.1
ssx20 = ta.sar(startsx20, incrementsx20, maximumsx20)
s1sx20 = z20(ssx20, lenxc20)
pcsx20 = close < s1sx20 ? color.rgb(255, 82, 82, 100) : color.rgb(76, 175, 79, 100)
plot(s1sx20, title="YavaşDöngü",style=plot.style_line, color=pcsx20, linewidth=1)

startsx50 = 0
incrementsx50 = 0.1
maximumsx50 = 1
ssx50 = ta.sar(startsx50, incrementsx50, maximumsx50)
s1sx50 = z50(ssx50, lenxc50)
pcsx50 = close < s1sx50 ? color.rgb(255, 82, 82, 100) : color.rgb(76, 175, 79, 100)
plot(s1sx50, title="HızlıDöngü",style=plot.style_line, color=pcsx50, linewidth=1)
////
//Stop Function
mult156 = input.float(3, 'Multiplicative Factor', minval = 0)
slope156 = input.float(100, 'Slope', minval = 0)
width156 = input.float(100, 'Width %', minval = 0, maxval = 100) / 100
//Style
bullCss156 = input.color(color.rgb(0, 230, 119, 100), 'Average Color', inline = 'avg', group = 'Style')
bearCss156 = input.color(color.rgb(255, 82, 82, 100), ''              , inline = 'avg', group = 'Style')

//Calculation
//-----------------------------------------------------------------------------{
var float upper156 = na
var float lower156 = na
var float avg156   = close

var hold156 = 0.
var os156 = 1.
    
atr156 = nz(ta.atr(200)) * mult156

avg156 := math.abs(close - avg156) > atr156 ? 
  math.avg(close, avg156)
  : avg156 + os156 * (hold156 / mult156 / slope156)

os156 := math.sign(avg156 - avg156[1])
hold156 := os156 != os156[1] ? atr156 : hold156

upper156 := avg156 + width156 * hold156
lower156 := avg156 - width156 * hold156

css156 = os156 == 1 ? bullCss156 : bearCss156
plot_avg156 = plot(avg156, 'Kırılım', os156 != os156[1] ? na : css156, style=plot.style_line,linewidth = 4)
//END
import TradingView/ta/5

lnt = input(50, "Lenght")
lnt2 = lnt * 2
off = input(1, "Offset")

reg = ta.linreg(close, lnt, 0)
reg2 = ta.linreg(close, lnt2, 0)
regavg = math.avg(reg, reg2)

barc = reg > reg[1] and reg2 > reg2[1] ? #79f504 : reg < reg[1] and reg2 < reg2[1] ? #e91e63 : color.rgb(11, 7, 236)

barcolor(barc, 0, true, title = "Bar Color")
plot(regavg, "Regression", color.rgb(255, 255, 255, 100), 1, plot.style_line, offset = off)
//End
//2 Pole Super Smoother Function
SSF(x, t) =>
    omega = 2 * math.atan(1) * 4 / t
    a = math.exp(-math.sqrt(2) * math.atan(1) * 4 / t)
    b = 2 * a * math.cos(math.sqrt(2) / 2 * omega)
    c2 = b
    c3 = -math.pow(a, 2)
    c1 = 1 - c2 - c3
    SSF = 0.0
    SSF := c1 * x + c2 * nz(SSF[1], x) + c3 * nz(SSF[2], nz(SSF[1], x))
    SSF

//Getter Function For Pseudo 2D Matrix
get_val(mat, row, col, rowsize) =>
    array.get(mat, int(rowsize * row + col))

//Setter Function For Pseudo 2D Matrix
set_val(mat, row, col, rowsize, val) =>
    array.set(mat, int(rowsize * row + col), val)

//LU Decomposition Function
LU(A, B) =>
    A_size = array.size(A)
    B_size = array.size(B)
    var L = array.new_float(A_size)
    var U = array.new_float(A_size)
    L_temp = 0.0
    U_temp = 0.0
    for c = 0 to B_size - 1 by 1
        set_val(U, 0, c, B_size, get_val(A, 0, c, B_size))
    for r = 1 to B_size - 1 by 1
        set_val(L, r, 0, B_size, get_val(A, r, 0, B_size) / get_val(U, 0, 0, B_size))
    for r = 0 to B_size - 1 by 1
        for c = 0 to B_size - 1 by 1
            if r == c
                set_val(L, r, c, B_size, 1)
            if r < c
                set_val(L, r, c, B_size, 0)
            if r > c
                set_val(U, r, c, B_size, 0)
    for r = 0 to B_size - 1 by 1
        for c = 0 to B_size - 1 by 1
            if na(get_val(L, r, c, B_size))
                L_temp := get_val(A, r, c, B_size)
                for k = 0 to math.max(c - 1, 0) by 1
                    L_temp -= get_val(U, k, c, B_size) * get_val(L, r, k, B_size)
                    L_temp
                set_val(L, r, c, B_size, L_temp / get_val(U, c, c, B_size))
            if na(get_val(U, r, c, B_size))
                U_temp := get_val(A, r, c, B_size)
                for k = 0 to math.max(r - 1, 0) by 1
                    U_temp -= get_val(U, k, c, B_size) * get_val(L, r, k, B_size)
                    U_temp
                set_val(U, r, c, B_size, U_temp)
    [L, U]

//Lower Triangular Solution Function (Forward Substitution)
LT_solve(L_, B) =>
    B_size = array.size(B)
    var Y = array.new_float(B_size)
    Y_temp = 0.0
    array.set(Y, 0, array.get(B, 0) / get_val(L_, 0, 0, B_size))
    for r = 1 to B_size - 1 by 1
        Y_temp := array.get(B, r)
        for k = 0 to math.max(r - 1, 0) by 1
            Y_temp -= get_val(L_, r, k, B_size) * array.get(Y, k)
            Y_temp
        array.set(Y, r, Y_temp / get_val(L_, r, r, B_size))
    Y

//Upper Triangular Solution Function (Backward Substitution)
UT_solve(U_, Y_) =>
    Y_size = array.size(Y_)
    U_rev = array.copy(U_)
    Y_rev = array.copy(Y_)
    array.reverse(U_rev)
    array.reverse(Y_rev)
    X_rev = LT_solve(U_rev, Y_rev)
    X = array.copy(X_rev)
    array.reverse(X)
    X

//Regression Function
regression_val(X_, index_, order_, offset_) =>
    reg = 0.0
    for i = 0 to order_ by 1
        reg += array.get(X_, i) * math.pow(index_ - offset_, i)
        reg
    reg

//Curve Segment Drawing Function
draw_curve(Y, sdev, n, step_, col, ls, lw, draw, conf) =>
    var line segment = line.new(x1=time[n * step_], y1=array.get(Y, n) + sdev, x2=time[(n - 1) * step_], y2=array.get(Y, n - 1) + sdev, xloc=xloc.bar_time)
    if draw
        if conf ? barstate.isconfirmed : 1
            line.set_xy1(segment, time[n * step_], array.get(Y, n) + sdev)
            line.set_xy2(segment, time[(n - 1) * step_], array.get(Y, n - 1) + sdev)
            line.set_color(segment, col)
            line.set_width(segment, lw)
            line.set_style(segment, ls == 'Solid' ? line.style_solid : ls == 'Dotted' ? line.style_dotted : line.style_dashed)
    else
        line.delete(segment)

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Inputs
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//Source Inputs
src44 = input(defval=close, title='Input Source Value')
use_filt = input(defval=true, title='Smooth Data Before Curve Fitting')
filt_per = input.int(defval=10, minval=2, title='Data Smoothing Period ═══════════════════')

//Calculation Inputs
per = input.int(defval=50, minval=2, title='Regression Sample Period')
order = input.int(defval=2, minval=1, title='Polynomial Order')
calc_offs = input(defval=0, title='Regression Offset')
ndev = input.float(defval=2.0, minval=0, title='Width Coefficient')
equ_from = input.int(defval=0, minval=0, title='Forecast From _ Bars Ago ═══════════════════')

//Channel Display Inputs
show_curve = input(defval=true, title='Show Fitted Curve')
show_high = input(defval=true, title='Show Fitted Channel High')
show_low = input(defval=true, title='Show Fitted Channel Low')
draw_step1 = input.int(defval=10, minval=1, title='Curve Drawing Step Size')
auto_step = input(defval=true, title='Auto Decide Step Size Instead')
draw_freq = input.string(defval='Close Only', options=['Continuous', 'Close Only'], title='Curve Update Frequency')
poly_col_h = input(defval=color.yellow, title='Channel High Line Color')
poly_lw_h = input.int(defval=1, minval=1, title='Channel High Line Width')
poly_ls_h = input.string(defval='Dashed', options=['Solid', 'Dotted', 'Dashed'], title='Channel High Line Style')
poly_col_m = input(defval=color.rgb(255, 235, 59, 100), title='Channel Middle Line Color')
poly_lw_m = input.int(defval=1, minval=1, title='Channel Middle Line Width')
poly_ls_m = input.string(defval='Dotted', options=['Solid', 'Dotted', 'Dashed'], title='Channel Middle Line Style')
poly_col_l = input(defval=color.yellow, title='Channel Low Line Color')
poly_lw_l = input.int(defval=1, minval=1, title='Channel Low Line Width')
poly_ls_l = input.string(defval='Dashed', options=['Solid', 'Dotted', 'Dashed'], title='Channel Low Line Style ═══════════════════')

//Smooth data and determine source type for calculation.
filt = SSF(src44, filt_per)
src144 = use_filt ? filt : src44

//Populate a period sized array with bar values.
var x_vals = array.new_float(per)
for i = 0 to per - 1 by 1
    array.set(x_vals, i, i + 1)

//Populate a period sized array with historical source values.
var src_vals = array.new_float(per)
for i = 0 to per - 1 by 1
    array.set(src_vals, i, src144[per - 1 - i + equ_from])

//Populate an order*2 + 1 sized array with bar power sums.
var xp_sums = array.new_float(order * 2 + 1)
xp_sums_temp = 0.0
for i = 0 to order * 2 by 1
    xp_sums_temp := 0
    for j = 0 to per - 1 by 1
        xp_sums_temp += math.pow(array.get(x_vals, j), i)
        xp_sums_temp
    array.set(xp_sums, i, xp_sums_temp)

//Populate an order + 1 sized array with (bar power)*(source value) sums.
var xpy_sums = array.new_float(order + 1)
xpy_sums_temp = 0.0
for i = 0 to order by 1
    xpy_sums_temp := 0
    for j = 0 to per - 1 by 1
        xpy_sums_temp += math.pow(array.get(x_vals, j), i) * array.get(src_vals, j)
        xpy_sums_temp
    array.set(xpy_sums, i, xpy_sums_temp)

//Generate a pseudo square matrix with row and column sizes of order + 1 using bar power sums.
var xp_matrix = array.new_float(int(math.pow(order + 1, 2)))
for r = 0 to order by 1
    for c = 0 to order by 1
        set_val(xp_matrix, r, c, order + 1, array.get(xp_sums, r + c))

//Factor the power sum matrix into lower and upper triangular matrices with order + 1 rows and columns.
[lower, upper] = LU(xp_matrix, xpy_sums)

//Find lower triangular matrix solutions using (bar power)*(source value) sums.
l_solutions = LT_solve(lower, xpy_sums)

//Find upper triangular matrix solutions using lower matrix solutions. This gives us our regression coefficients.
reg_coefs = UT_solve(upper, l_solutions)

//Define curve drawing step size.
draw_step = auto_step ? math.ceil(per / 10) : draw_step1

//Calculate curve values.
var inter_vals = array.new_float(11)
for i = 0 to 10 by 1
    array.set(inter_vals, i, regression_val(reg_coefs, per, order, calc_offs - equ_from + draw_step * i))

//Calculate standard deviation for channel.
Stdev = array.stdev(src_vals) * ndev
//Draw interpolated segments.
draw_curve(inter_vals, 0, 1, draw_step, poly_col_m, poly_ls_m, poly_lw_m, show_curve, draw_freq == 'Close Only')
draw_curve(inter_vals, 0, 2, draw_step, poly_col_m, poly_ls_m, poly_lw_m, show_curve, draw_freq == 'Close Only')
draw_curve(inter_vals, 0, 3, draw_step, poly_col_m, poly_ls_m, poly_lw_m, show_curve, draw_freq == 'Close Only')
draw_curve(inter_vals, 0, 4, draw_step, poly_col_m, poly_ls_m, poly_lw_m, show_curve, draw_freq == 'Close Only')
draw_curve(inter_vals, 0, 5, draw_step, poly_col_m, poly_ls_m, poly_lw_m, show_curve, draw_freq == 'Close Only')
draw_curve(inter_vals, 0, 6, draw_step, poly_col_m, poly_ls_m, poly_lw_m, show_curve, draw_freq == 'Close Only')
draw_curve(inter_vals, 0, 7, draw_step, poly_col_m, poly_ls_m, poly_lw_m, show_curve, draw_freq == 'Close Only')
draw_curve(inter_vals, 0, 8, draw_step, poly_col_m, poly_ls_m, poly_lw_m, show_curve, draw_freq == 'Close Only')
draw_curve(inter_vals, 0, 9, draw_step, poly_col_m, poly_ls_m, poly_lw_m, show_curve, draw_freq == 'Close Only')
draw_curve(inter_vals, 0, 10, draw_step, poly_col_m, poly_ls_m, poly_lw_m, show_curve, draw_freq == 'Close Only')

//Draw channel high segments.
draw_curve(inter_vals, Stdev, 1, draw_step, poly_col_h, poly_ls_h, poly_lw_h, show_high, draw_freq == 'Close Only')
draw_curve(inter_vals, Stdev, 2, draw_step, poly_col_h, poly_ls_h, poly_lw_h, show_high, draw_freq == 'Close Only')
draw_curve(inter_vals, Stdev, 3, draw_step, poly_col_h, poly_ls_h, poly_lw_h, show_high, draw_freq == 'Close Only')
draw_curve(inter_vals, Stdev, 4, draw_step, poly_col_h, poly_ls_h, poly_lw_h, show_high, draw_freq == 'Close Only')
draw_curve(inter_vals, Stdev, 5, draw_step, poly_col_h, poly_ls_h, poly_lw_h, show_high, draw_freq == 'Close Only')
draw_curve(inter_vals, Stdev, 6, draw_step, poly_col_h, poly_ls_h, poly_lw_h, show_high, draw_freq == 'Close Only')
draw_curve(inter_vals, Stdev, 7, draw_step, poly_col_h, poly_ls_h, poly_lw_h, show_high, draw_freq == 'Close Only')
draw_curve(inter_vals, Stdev, 8, draw_step, poly_col_h, poly_ls_h, poly_lw_h, show_high, draw_freq == 'Close Only')
draw_curve(inter_vals, Stdev, 9, draw_step, poly_col_h, poly_ls_h, poly_lw_h, show_high, draw_freq == 'Close Only')
draw_curve(inter_vals, Stdev, 10, draw_step, poly_col_h, poly_ls_h, poly_lw_h, show_high, draw_freq == 'Close Only')

//Draw channel low segments.
draw_curve(inter_vals, -Stdev, 1, draw_step, poly_col_l, poly_ls_l, poly_lw_l, show_low, draw_freq == 'Close Only')
draw_curve(inter_vals, -Stdev, 2, draw_step, poly_col_l, poly_ls_l, poly_lw_l, show_low, draw_freq == 'Close Only')
draw_curve(inter_vals, -Stdev, 3, draw_step, poly_col_l, poly_ls_l, poly_lw_l, show_low, draw_freq == 'Close Only')
draw_curve(inter_vals, -Stdev, 4, draw_step, poly_col_l, poly_ls_l, poly_lw_l, show_low, draw_freq == 'Close Only')
draw_curve(inter_vals, -Stdev, 5, draw_step, poly_col_l, poly_ls_l, poly_lw_l, show_low, draw_freq == 'Close Only')
draw_curve(inter_vals, -Stdev, 6, draw_step, poly_col_l, poly_ls_l, poly_lw_l, show_low, draw_freq == 'Close Only')
draw_curve(inter_vals, -Stdev, 7, draw_step, poly_col_l, poly_ls_l, poly_lw_l, show_low, draw_freq == 'Close Only')
draw_curve(inter_vals, -Stdev, 8, draw_step, poly_col_l, poly_ls_l, poly_lw_l, show_low, draw_freq == 'Close Only')
draw_curve(inter_vals, -Stdev, 9, draw_step, poly_col_l, poly_ls_l, poly_lw_l, show_low, draw_freq == 'Close Only')
draw_curve(inter_vals, -Stdev, 10, draw_step, poly_col_l, poly_ls_l, poly_lw_l, show_low, draw_freq == 'Close Only')
//END 

//Reverse
requestSecurity(string _symbol, string _res, bool _repaints) => 
    repIndex = _repaints ? 0 : barstate.isrealtime ? 1 : 0
    resIndex = _repaints ? 0 : barstate.isrealtime ? 0 : 1
    [h, l, t] = request.security(_symbol, _res, [high[repIndex], low[repIndex], time[repIndex]])
    [h[resIndex], l[resIndex], t[resIndex]]

var GRP1 = "General Settings"
string res88 =         input.timeframe(title = "Resolution", defval = "", group = GRP1)
bool ignoreInsideBars = input.bool(title = "Ignore Inside Bars?", defval = true, group = GRP1)
bool rep88 =           input.bool(title = "Allow Repainting?", defval = false, group = GRP1)
var string GRP2 = "Short Term Settings"
bool showSTHighs =   input.bool(title = "Show Short Term Highs?", defval = true, group = GRP2)
color stHighsColor =    input.color(color.red, "Short Term Highs Color", group = GRP2)
bool showSTLows =       input.bool(title = "Show Short Term Lows?", defval = true, group = GRP2)
color stLowsColor =     input.color(color.yellow, "Short Term Lows Color", group = GRP2)
var string GRP3 = "Mid Term Settings"
bool showMTHighs =      input.bool(title = "Show Mid Term Highs?", defval = true, group = GRP3)
color mtHighsColor =    input.color(color.red, "Mid Term Highs Color", group = GRP3)
bool showMTLows =       input.bool(title = "Show Mid Term Lows?", defval = true, group = GRP3)
color mtLowsColor =     input.color(color.aqua, "Mid Term Lows Color", group = GRP3)
var string GRP4 = "Long Term Settings"
bool showLTHighs =      input.bool(title = "Show Long Term Highs?", defval = true, group = GRP4)
color ltHighsColor =    input.color(color.red, "Long Term Highs Color", group = GRP4)
bool showLTLows =       input.bool(title = "Show Long Term Lows?", defval = true, group = GRP4)
color ltLowsColor =     input.color(color.white, "Long Term Lows Color", group = GRP4)
[h, l, t] = requestSecurity(syminfo.ticker, res88, rep88)

type ReversalPoint
    int     bar_time
    float   price

var lowShortRevPoints  = array.new<ReversalPoint>()
var highShortRevPoints = array.new<ReversalPoint>()
var lowMediumRevPoints  = array.new<ReversalPoint>()
var highMediumRevPoints = array.new<ReversalPoint>()

isReversalPoint(bool isLow, float firstSrc, float midSrc, float lastSrc, bool isInsideBar) =>
    bool isReversalPoint = false

    if not (isInsideBar and ignoreInsideBars)
        if isLow
            isReversalPoint := lastSrc > midSrc and midSrc < firstSrc
        else
            isReversalPoint := lastSrc < midSrc and midSrc > firstSrc

    isReversalPoint

plotReversalPoint(bool isLow, ReversalPoint revPoint, color revPointColor, string labelSize, bool createLabel) =>
    if createLabel
        label.new(revPoint.bar_time, revPoint.price, isLow ? '▲' : '▼', 
         xloc = xloc.bar_time, yloc = isLow ? yloc.belowbar : yloc.abovebar, size = labelSize, color = color(na), 
         textcolor = revPointColor, style = label.style_text_outline)

getReversalPoints(bool isLow, ReversalPoint[] sourceArray, color plotColor, ReversalPoint newRp, string labelSize, 
 bool createLabel, bool isInsideBar) =>
    ReversalPoint result = na
    sourceArray.push(newRp)
    plotReversalPoint(isLow, newRp, plotColor, labelSize, createLabel)
    int arraySize = sourceArray.size()
    float midArrayValue = arraySize >= 2 ? sourceArray.get(arraySize - 2).price : na
    float firstArrayValue = arraySize >= 3 ? sourceArray.get(arraySize - 3).price : na

    if not na(firstArrayValue) and not na(midArrayValue) and isReversalPoint(isLow, firstArrayValue, midArrayValue, newRp.price, isInsideBar)
        result := sourceArray.get(arraySize - 2)

    result

bool isInsideBar = h < nz(h[1]) and l > nz(l[1])
ReversalPoint shortTermLow = isReversalPoint(true, nz(l[2]), nz(l[1]), l, isInsideBar) ? ReversalPoint.new(nz(t[1]), nz(l[1])) : na
ReversalPoint midTermLow = na
ReversalPoint longTermLow = na

if not na(shortTermLow)
    midTermLow := getReversalPoints(true, lowShortRevPoints, stLowsColor, shortTermLow, size.tiny, showSTLows, isInsideBar)

if not na(midTermLow)
    longTermLow := getReversalPoints(true, lowMediumRevPoints, mtLowsColor, midTermLow, size.small, showMTLows, isInsideBar)

if not na(longTermLow)
    plotReversalPoint(true, longTermLow, ltLowsColor, size.normal, showLTLows)

ReversalPoint shortTermHigh = isReversalPoint(false, nz(h[2]), nz(h[1]), h, isInsideBar) ? ReversalPoint.new(nz(t[1]), nz(h[1])) : na
ReversalPoint midTermHigh = na
ReversalPoint longTermHigh = na

if not na(shortTermHigh)
    midTermHigh := getReversalPoints(false, highShortRevPoints, stHighsColor, shortTermHigh, size.tiny, showSTHighs, isInsideBar)

if not na(midTermHigh)
    longTermHigh := getReversalPoints(false, highMediumRevPoints, mtHighsColor, midTermHigh, size.small, showMTHighs, isInsideBar)

if not na(longTermHigh)
    plotReversalPoint(false, longTermHigh, ltHighsColor, size.normal, showLTHighs)

//TrailingStop

//Stop

//Top-Bottom
plot = input.bool(true, title="Display past dots")
OverSold = input(0)
OverBought = input(100)
length1 = input.int(2, title = "Length")
tr = input.int(1, title = "Trigger Length")

// Define the function
func(source, int len, int tr) =>
    HP = 0.00, a1 = 0.00, b1 = 0.00, c1 = 0.00, c2 = 0.00, c3 = 0.00, ag = 0.00, Sp = 0.00, X = 0.00, Quotient1 = 0.00, Quotient2 = 0.00, w = math.sqrt(.5)
    HP := 2500 * (source - 2 * nz(source[1]) + nz(source[2])) + 1.92 * nz(HP[1]) - .9216 * nz(HP[2])
    a1 := math.exp(-math.sqrt(2) * math.pi / len)
    b1 := 2 * a1 * math.cos(math.sqrt(2) * math.pi / len)
    c2 := b1
    c3 := -a1 * a1
    c1 := 1 - c2 - c3
    ag := c1 * (HP + nz(HP[1])) / 2 + c2 * nz(ag[1]) + c3 * nz(ag[2])
    Sp := .991 * nz(Sp[1])
    if math.abs(ag) > Sp
        Sp := math.abs(ag)
        Sp
    if Sp != 0
        X := ag / Sp
        X
    q1 = X * 60 + 50
    out= ta.sma(q1, tr)
    [out]

[k] = func(close, length1,tr)
OverboughtCond = k > OverBought
OversoldCond = k < OverSold

//plotshape(plot? OverboughtCond:na, style=shape.cross, location=location.abovebar, color=color.new(color.red, 50), size=size.tiny)
//plotshape(plot? OversoldCond:na, style=shape.cross, location=location.belowbar, color=color.new(color.lime, 50), size=size.tiny)
var label myLabel_Overbought = na
if OverboughtCond
    // Delete the previous label if there is one
    if not na(myLabel_Overbought)
        label.delete(myLabel_Overbought[1])
    // Create a new label
    myLabel_Overbought := label.new(bar_index, high, 'Tepe',yloc=yloc.abovebar,style=label.style_circle, size=size.normal, color=color.rgb(255, 82, 82, 50), textcolor=color.white)
    myLabel_Overbought
var label myLabel_Oversold = na
if OversoldCond
    // Delete the previous label if there is one
    if not na(myLabel_Oversold)
        label.delete(myLabel_Oversold[1])
    // Create a new label
    myLabel_Oversold := label.new(bar_index, low, 'Dip',yloc=yloc.belowbar,style=label.style_circle, size=size.normal, color=color.rgb(0, 230, 119, 50), textcolor=color.white)
    myLabel_Oversold


//

startsa = input.float(0, "Starting value")
incsa = input.float(0.01, "Increment")
maxsa = input.float(1, "Max Value")
widthsa = input.float(9.00, "Zone width")

atrs = ta.atr(100) * widthsa
sarone = ta.sar(startsa, incsa, maxsa)
sarzone = if close > sarone
    sarone + atrs
else if close < sarone
    sarone - atrs
sartwo = ta.sar(startsa/2, incsa/2, maxsa/2)

//p1sa = plot(sarone, "BT", color = close > sarone ? #2962ff00 : #e91e6200, style=plot.style_circles)
//p3sa = plot(sarzone, "TB", color = close > sarone ? #2962ff00 : #e91e6200, style=plot.style_circles)
//fill(p1sa, p3sa, color = close > sarone ? color.new(#848486, 80) : color.new(#e91e62, 100))

//plot(sartwo, "Second SAR", color = close > sartwo ? color.new(#2962ff, 50) : color.new(#e91e63, 50), style=plot.style_linebr)
////Emas
q156 = ta.ema(ohlc4, 1)
q5 = ta.ema(ohlc4, 5)
q9 = ta.ema(ohlc4, 9)
q13 = ta.ema(ohlc4, 13)
q26 = ta.ema(ohlc4, 26)
q50 = ta.ema(ohlc4, 50)
q100 = ta.ema(ohlc4, 100)
q200 = ta.ema(ohlc4, 200)

qeq=(q156+q5+q9+q13+q26+q50+q100+q200)/8
plot(qeq,"AVG-EMA",color.rgb(255, 235, 59, 100), linewidth=1) 
Leave a Comment