Untitled
3169
plain_text
10 months ago
34 kB
7
Indexable
//@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)
Editor is loading...
Leave a Comment