PHP Code:
// This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
// © LuxAlgo
//@version=5
indicator("Master Pattern [LuxAlgo]","*", overlay = true, max_boxes_count = 500, max_lines_count = 500)
mult1 = input.float(5, 'Multiplicative Factor', minval = 0)
slope1 = input.float(14, 'Slope', minval = 0)
width1 = input.float(100, 'Width %', minval = 0, maxval = 100) / 100
//Style
bullCss1 = input.color(color.rgb(0, 255, 229), 'Average Color', inline = 'avg', group = 'Style')
bearCss1 = input.color(color.rgb(250, 3, 3), '' , inline = 'avg', group = 'Style')
//Calculation
//-----------------------------------------------------------------------------{
var float upper1 = na
var float lower1 = na
var float avg1 = close
var hold1 = 0.
var os1 = 1.
atr1 = nz(ta.atr(200)) * mult1
avg1 := math.abs(close - avg1) > atr1 ?
math.avg(close, avg1)
: avg1 + os1 * (hold1 / mult1 / slope1)
os1 := math.sign(avg1 - avg1[1])
hold1 := os1 != os1[1] ? atr1 : hold1
upper1 := avg1 + width1 * hold1
lower1 := avg1 - width1 * hold1
//-----------------------------------------------------------------------------}
//Plots
//-----------------------------------------------------------------------------{
css1 = os1 == 1 ? bullCss1 : bearCss1
plot_upper = plot(upper1, 'Tepe', na)
plot_avg = plot(avg1, 'Stop', os1 != os1[1] ? na : css1)
plot_lower = plot(lower1, 'Dip', na)
//-----------------------------------------------------------------------------}
tf1 = input.timeframe('', 'Timeframe')
//Hold variables
var y1 = array.new<float>(0)
var x1 = array.new<int>(0)
var float a1 = na
var float b1 = na
var color css12 = na
var up_per = 0
var up_den = 0
var dn_per = 0
var dn_den = 0
n1 = bar_index
dtf = timeframe.change(tf1)
//Test for timeframe change
if dtf
if y1.size() > 0
//Calculate regression coefficients
slope1 = x1.covariance(y1) / x1.variance()
up_per += slope1 > 0 and a1 > 0 ? 1 : 0
up_den += a1 > 0 ? 1 : 0
dn_per += slope1 < 0 and a1 < 0 ? 1 : 0
dn_den += a1 < 0 ? 1 : 0
a1:= slope1
b1 := y1.avg() - a1 * x1.avg()
css12 := a1 > 0 ? #f70808 : #67f807
//Clear arrays and push data
y1.clear(), x1.clear()
y1.push(close), x1.push(n1)
else
y1.push(close)
x1.push(n1)
//output
epdt = a1 * n1 + b1
//-----------------------------------------------------------------------------}
//-----------------------------------------------------------------------------}
//Plots
//-----------------------------------------------------------------------------{
//plot(epdt, 'Önceki-Trend', dtf ? na : css1)
//-----------------------------------------------------------------------------}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Functions
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//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
src = 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=3, 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=3, 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=3, minval=1, title='Channel Low Line Width')
poly_ls_l = input.string(defval='Dashed', options=['Solid', 'Dotted', 'Dashed'], title='Channel Low Line Style ═══════════════════')
//Equation Display Inputs
//show_equation = input(defval=true, title='Show Regression Equation')
//label_bcol = input(defval=#000000, title='Equation Label Background Color')
//label_tcol = input(defval=#ffffff, title='Equation Label Text Color')
//label_size = input.string(defval='Large', options=['Auto', 'Tiny', 'Small', 'Normal', 'Large', 'Huge'], title='Equation Label Size')
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Definitions
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Smooth data and determine source type for calculation.
filt = SSF(src, filt_per)
src1 = use_filt ? filt : src
//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, src1[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
//Define a string for regression equation display.
//equation_txt = ''
//if show_equation
//equation_txt := (equ_from != 0 ? 'Forecast From ' + str.tostring(equ_from) + (equ_from == 1 ? ' Bar ' : ' Bars ') + 'Ago Using\n\n' : '') + str.tostring(array.get(reg_coefs, 0))
//for i = 1 to array.size(reg_coefs) - 1 by 1
//equation_txt += (array.get(reg_coefs, i) < 0 ? ' - ' : ' + ') + str.tostring(math.abs(array.get(reg_coefs, i))) + 'x' + (i > 1 ? '^' + str.tostring(i) : '')
//equation_txt
//equation_txt += '\n\n' + 'Offset ' + str.tostring(math.abs(calc_offs)) + (math.abs(calc_offs) == 1 ? ' Bar ' : ' Bars ') + (calc_offs > 0 ? 'To The Right' : calc_offs < 0 ? 'To The Left' : '')
//equation_txt
//Define bar colors based on LSMA.
//bar_color = src > array.get(inter_vals, 0) and src > src[1] ? #00ff00 : src > array.get(inter_vals, 0) and src <= src[1] ? #008b00 : src < array.get(inter_vals, 0) and src < src[1] ? #ff0000 : src < array.get(inter_vals, 0) and src >= src[1] ? #8b0000 : #cccccc
//Define LSMA colors.
//lsma_color = array.get(inter_vals, 0) > array.get(inter_vals, 0)[1] ? #00ff00 : array.get(inter_vals, 0) < array.get(inter_vals, 0)[1] ? #ff0000 : #cccccc
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Outputs
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Plot source / smoothed source
//plot(src1, color=color.new(#cccccc, 0), title='Source / Smoothed Source Value')
//Plot current channel endpoints (LSMA & band values).
////lsma_plot = plot(array.get(inter_vals, 0), color=lsma_color, linewidth=2, title='Polynomial LSMA')
//hband_plot = plot(array.get(inter_vals, 0) + Stdev, color=color.new(#00ff00, 0), title='High Band')
//lband_plot = plot(array.get(inter_vals, 0) - Stdev, color=color.new(#ff0000, 0), title='Low Band')
//Fill bands.
//fill(hband_plot, lsma_plot, color=color.new(#00ff00, 90), title='High Band Fill')
//fill(lband_plot, lsma_plot, color=color.new(#ff0000, 90), title='Low Band Fill')
//Color bars.
//barcolor(bar_color)
//Color background.
//bgcolor(color.new(#000000, 0))
//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')
//Settings
//-----------------------------------------------------------------------------{
length74 = input.int(2, 'Length', minval = 2)
mult74 = input.float(5., 'Factor', minval = 0, step = .5)
tf74 = input.timeframe('', 'Timeframe')
src74 = input(close, 'Source')
//-----------------------------------------------------------------------------}
//Function
//-----------------------------------------------------------------------------{
pred_ranges(length74, mult74)=>
var avg = src74
var hold_atr = 0.
atr = nz(ta.atr(length74)) * mult74
avg := src74 - avg > atr ? avg + atr :
avg - src74 > atr ? avg - atr :
avg
hold_atr := avg != avg[1] ? atr / 2 : hold_atr
[avg + hold_atr * 2, avg + hold_atr, avg, avg - hold_atr, avg - hold_atr * 2]
//-----------------------------------------------------------------------------}
//Calculation
//-----------------------------------------------------------------------------{
[prR2
, prR1
, avg
, prS1
, prS2] = request.security(syminfo.tickerid, tf74, pred_ranges(length74, mult74))
//-----------------------------------------------------------------------------}
//Plots
//-----------------------------------------------------------------------------{
plot_pru2 = plot(prR2, '+2', avg != avg[1] ? na : color.rgb(14, 13, 14))
plot_pru1 = plot(prR1, '+1', avg != avg[1] ? na : color.rgb(10, 10, 10))
plot_pravg = plot(avg , '0', avg != avg[1] ? na : color.rgb(7, 7, 7))
plot_prl1 = plot(prS1, '-1', avg != avg[1] ? na : color.rgb(8, 8, 8))
plot_prl2 = plot(prS2, '-2', avg != avg[1] ? na : color.rgb(8, 8, 8))
//Fills
fill(plot_pru2, plot_pru1, avg != avg[1] ? na : color.new(color.yellow, 50))
fill(plot_prl1, plot_prl2, avg != avg[1] ? na : color.new(color.orange, 50))
parabol range stop kodu...
Alıntı yaparak yanıtla
Originally Posted by @yörük@
Yer İmleri