PHP Code:
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © fondDealer96636
//@version=5
indicator('*', overlay=true, max_bars_back=201)
// input
start = 20
lookback = input(1, "Sensitivity", tooltip="Low (High Sensitivity), High (Low Sensitivity).\n\nAdjust according to timeframe and asset.")
resp = 1
smoothing = input(3, "Smoothing")
source = input(close, "Source")
// global
var ix = -1
var mal = array.new_int(0)
// functions
avg(source, len) =>
sum = 0.0
for i = 0 to len-1
sum += source[i]
sum/len
bull = close > open
wick_touch(x) =>
bull ? ((close <= x and x <= high) or (low <= x and x <= open)) : ((open <= x and x <= high) or (low <= x and x <= close))
body_touch(x) =>
bull ? (open < x and x < close) : (close < x and x < open)
touches(t) =>
touches = 0
for i = 0 to lookback-1
touches += t[i] ? 1 : 0
touches
// local
ix := ix+1
prev_mal = ix >= 1 ? array.get(mal, ix-1) : start
cma = avg(source, prev_mal)
cma_p1 = avg(source, prev_mal+1)
cma_m1 = avg(source, prev_mal-1)
d = touches(wick_touch(cma))
d_p1 = touches(wick_touch(cma_p1))
d_m1 = touches(wick_touch(cma_m1))
d_b = touches(body_touch(cma))
d_p1_b = touches(body_touch(cma_p1))
d_m1_b = touches(body_touch(cma_m1))
any_body_touch = d_b > 0 or d_p1_b > 0 or d_m1_b > 0
no_wick_touch = d <= 0 and d_p1 <= 0 and d_m1 <= 0
wick_maximized = d >= d_p1 and d >= d_m1 ? prev_mal : (d_p1 >= d and d_p1 >= d_m1 ? prev_mal+resp : (d_m1 >= d and d_m1 >= d_p1 ? prev_mal-resp : na))
uptrend = cma > cma[1]
downtrend = cma < cma[1]
against_trend = (uptrend and close < cma) or (downtrend and close > cma)
new_mal = no_wick_touch or against_trend ? prev_mal-resp : (any_body_touch ? prev_mal+resp : wick_maximized)
next_mal = na(new_mal) ? prev_mal : new_mal
array.push(mal, next_mal < 2 ? 2 : (next_mal > 200 ? 200 : next_mal))
// graph
scma = ta.ema(cma, smoothing)
plot(scma, "Automatic MA", style=plot.style_line, color=#ffeb3b00)
////////////////////////////////////////
start213 = input(0.1)
increment213 = input(0.1)
maximum213 = input(1, "Max Value")
out213 = ta.sar(start213, increment213, maximum213)
plot(out213, "Döngü", style=plot.style_line, color=#ffeb3b00)
////////////////////////////////////////////////////////////////////
//@version=5
start22 = input.float(title='Start', defval=0.05, step=0.1)
increment = input.float(title='Increment', defval=0.075, step=0.1)
maximum = input.float(title='Max Value', defval=0.35, step=0.1)
putlabel = input(title='Put Labels', defval=true)
colup = input.color(title='Colors', defval=color.rgb(0, 230, 119, 100), inline='col')
coldn = input.color(title='', defval=color.rgb(255, 82, 82, 100), inline='col')
int trend = 0
float sar = 0.0
float ep = 0.0
float af = 0.0
trend := nz(trend[1])
ep := nz(ep[1])
af := nz(af[1])
sar := sar[1]
if trend == 0 and not na(high[1])
trend := high >= high[1] or low >= low[1] ? 1 : -1
sar := trend > 0 ? low[1] : high[1]
ep := trend > 0 ? high[1] : low[1]
af := start22
af
else
nextsar = sar
if trend > 0
if high[1] > ep
ep := high[1]
af := math.min(maximum, af + increment)
af
nextsar := sar + af * (ep - sar)
nextsar := math.min(math.min(low[1], low[2]), nextsar)
//Reversal
if nextsar > low
trend := -1
nextsar := ep
ep := low
af := start22
af
else
if low[1] < ep
ep := low[1]
af := math.min(maximum, af + increment)
af
nextsar := sar + af * (ep - sar)
nextsar := math.max(math.max(high[1], high[2]), nextsar)
//Reversal
if nextsar < high
trend := 1
nextsar := ep
ep := high
af := start22
af
sar := nextsar
sar
plot(sar, title='@@', color=trend > 0 ? colup : coldn, linewidth=1, style=plot.style_line)
alertcondition(ta.change(trend) > 0, title='PSAR Trend UP', message='PSAR Trend UP')
alertcondition(ta.change(trend) < 0, title='PSAR Trend DOWN', message='PSAR Trend DOWN')
if ta.change(trend) > 0 and putlabel
label.new(bar_index, sar, text=str.tostring(math.round_to_mintick(sar)), color=colup, style=label.style_label_up, size=size.huge)
if ta.change(trend) < 0 and putlabel
label.new(bar_index, sar, text=str.tostring(math.round_to_mintick(sar)), color=coldn, style=label.style_label_down, size=size.huge)
////////////////////////////////////////////////////////
length=(1)
src=close
start1 = input(0.1)
increment1 = input(0.1)
maximum1 = input(1, "Max Value")
out1 = ta.sar(start1, increment1, maximum1)
momo1 = src - src[length]
smdo1 = out1 - momo1
plot(smdo1, "1.Döngü", style=plot.style_line, color=#f0ce0e00)
/////////////////////////////////////////////////////////
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © fondDealer96636
//@version=5
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © starbolt
//@version=5
len44 = input.int(10, 'Length', step=1, minval=1)
displace = input.int(0, 'Displace', step=1, minval=0)
ma_type = input.string('HMA', 'MA Type', options=['SMA', 'HMA'])
//Hilo Activator
float hilo = na
hi = ta.sma(high, len44)
lo = ta.sma(low, len44)
// Hull Moving Average (HMA)
if ma_type == 'HMA'
hi := ta.wma(2 * ta.wma(high, len44 / 2) - ta.wma(high, len44), math.round(math.sqrt(len44)))
lo := ta.wma(2 * ta.wma(low, len44 / 2) - ta.wma(low, len44), math.round(math.sqrt(len44)))
hilo := close > hi[displace] ? 1 : close < lo[displace] ? -1 : hilo[1]
ghla = hilo == -1 ? hi[displace] : lo[displace]
color44 = hilo == -1 ? color.red : color.green
//Alerts
buyCondition = hilo == 1 and hilo[1] == -1
sellCondition = hilo == -1 and hilo[1] == 1
if buyCondition
alert('Long', alert.freq_once_per_bar)
if sellCondition
alert('Short', alert.freq_once_per_bar)
//Plots
plot(ghla, color=color44, style=plot.style_cross, linewidth = 3)
////////////////////////////////////////////////////////////////////////////
//@version=5
import jdehorty/KernelFunctions/2 as kernel
DFT(x, y, Nx, _dir) =>
float _arg = 0.0
float _cos = 0.0
float _sin = 0.0
float xArr_i = 0.0
float yArr_i = 0.0
xArr = array.new_float(array.size(x))
yArr = array.new_float(array.size(y))
for i = 0 to Nx - 1 by 1
xArr_i := 0.0
yArr_i := 0.0
kx = float(i) / float(Nx)
_arg := -_dir * 2 * math.pi * kx
for k = 0 to Nx - 1 by 1
_cos := math.cos(k * _arg)
_sin := math.sin(k * _arg)
xArr_i += array.get(x, k) * _cos - array.get(y, k) * _sin
yArr_i += array.get(x, k) * _sin + array.get(y, k) * _cos
yArr_i
array.set(xArr, i, xArr_i)
array.set(yArr, i, yArr_i)
if _dir == 1
for i = 0 to Nx - 1 by 1
array.set(x, i, array.get(xArr, i) / float(Nx))
array.set(y, i, array.get(yArr, i) / float(Nx))
else
for i = 0 to Nx - 1 by 1
array.set(x, i, array.get(xArr, i))
array.set(y, i, array.get(yArr, i))
//======================================================================================================================
// INPUTS
//======================================================================================================================
N = input.int(5,"Fourier Period")
xval = input.source(close,"Fourier X Series",tooltip = "i.e. the source of the discrete Fourier"+
" transform (with the Y Series being the bars through time.)")
highlighting = input.bool(true,"Highlighting")
smoothing66 = input.int(10,"Kernel Smoothing")
//======================================================================================================================
// CALCULATIONS
//======================================================================================================================
// Fourier transform
x = array.new_float(N, 0.0)
y = array.new_float(N, 0.0)
for i = 0 to N - 1
array.set(x, i, xval[i])
array.set(y, i, 0.0)
DFT(x, y, N, 1)
mag = array.new_float(N, 0.0)
for i = 0 to N - 1
mag_i = math.sqrt(math.pow(array.get(x, i), 2) + math.pow(array.get(y, i), 2))
array.set(mag, i, mag_i)
dft = array.get(mag,0)
dfts = kernel.rationalQuadratic(dft,25,1,smoothing66)
//======================================================================================================================
// DISPLAY
//======================================================================================================================
plot(dfts, "Stop", color=color.rgb(0, 187, 212, 100) )
///////////////////////////////
// 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/
// © Zeiierman
//@version=5
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Tooltips {
string t1 = "The candle lookback length refers to the number of bars, starting from the current one, that will be examined in order to find a similar event in the past."
string t2 = "The amount of Forecast candles that should be displayed in the future."
string t3 = "Background color divider between price and forecast."
string t4 = "Displays the current events found"
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Inputs {
Series = input.int(1,"Candle Series",1,20,tooltip=t1)
Forecast = input.int(166,"Forecast Candles",1,166,tooltip=t2)
Divider = input.bool(true,"Forecast Divider",t3)
Display = input.bool(true,"Display Event",t4)
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Types {
type Event
box currentEvent
box pastEvent
box prediction
array<box> candle
array<line> wick
type Data
array<int> b
array<int> d
array<float> o
array<float> h
array<float> l
array<float> c
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Variables & Arrays {
b = bar_index
var data = Data.new(array.new<int>(),
array.new<int>(),
array.new<float>(),
array.new<float>(),
array.new<float>(),
array.new<float>())
var event = Event.new(box.new(na,na,na,na,chart.fg_color,border_style=line.style_dashed,bgcolor=color(na)),
box.new(na,na,na,na,chart.fg_color,border_style=line.style_dashed,bgcolor=color(na)),
box.new(na,na,na,na,chart.fg_color,border_style=line.style_dotted,
bgcolor=color.new(color.teal,75)),
array.new<box>(Forecast),
array.new<line>(Forecast))
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Methods {
//Store Data
method Store(Data x)=>
int B = b
int bin = close>open?1:close<open?-1:0
float O = open
float H = high
float L = low
float C = close
x.b.unshift(B)
x.d.unshift(bin)
x.o.unshift(O)
x.h.unshift(H)
x.l.unshift(L)
x.c.unshift(C)
//Candle Plots
method Candle(Event e,x,i)=>
int dist = 1
float prev = x.c.get(i)
float diff = ((close-prev)/prev)+1
for j=i-1 to i-Forecast
idx = j-i+Forecast
if j<0
break
else
pos = x.d.get(j)
top = (pos>0?x.c.get(j):x.o.get(j))*diff
bot = (pos>0?x.o.get(j):x.c.get(j))*diff
hi = (x.h.get(j))*diff
lo = (x.l.get(j))*diff
col = pos==1?#26a69a:pos==-1?#ef5350:chart.fg_color
candle = e.candle.get(idx)
if na(candle)
e.candle.set(idx,box.new(b+dist,top,b+dist+2,bot,na,bgcolor=col))
e.wick.set(idx,line.new(b+dist+1,hi,b+dist+1,lo,color=col))
else
box.set_lefttop(e.candle.get(idx),b+dist,top)
box.set_rightbottom(e.candle.get(idx),b+dist+2,bot)
box.set_bgcolor(e.candle.get(idx),col)
line.set_xy1(e.wick.get(idx),b+dist+1,hi)
line.set_xy2(e.wick.get(idx),b+dist+1,lo)
line.set_color(e.wick.get(idx),col)
dist += 3
//Events Display
method Events(Event e,idx,h1,l1,h2,l2,fh,fl)=>
int start = idx.get(Series-1)
int end = idx.get(0)
e.currentEvent.set_lefttop(b-Series+1,h1.max())
e.currentEvent.set_rightbottom(b,l1.min())
e.pastEvent.set_lefttop(start,h2.max())
e.pastEvent.set_rightbottom(end,l2.min())
e.prediction.set_lefttop(end+1,fh.max())
e.prediction.set_rightbottom(math.min(b,end+Forecast),fl.min())
//Current Event
method Series(Data x)=>
data.Store()
bool found = false
if barstate.islast
events = x.d.slice(0,Series)
for i=Series to x.d.size()-Series
elements = x.d.slice(i,i+Series)
equal = 0
for [k,this] in elements
if this==events.get(k)
equal += 1
if equal==Series
found := true
event.Candle(data,i)
if Display
bar = x.b.slice(i,i+Series)
h1 = x.h.slice(0,Series)
l1 = x.l.slice(0,Series)
h2 = x.h.slice(i,i+Series)
l2 = x.l.slice(i,i+Series)
fh = i-Forecast<0?x.h.slice(0,i-1):x.h.slice(i-Forecast,i-1)
fl = i-Forecast<0?x.l.slice(0,i-1):x.l.slice(i-Forecast,i-1)
event.Events(bar,h1,l1,h2,l2,fh,fl)
break
if barstate.islast and not found
runtime.error("Couldn't find similar candle series event. \nFix: Decrease Candle Series length")
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Divider {
bgcolor(Divider and barstate.islast?color.new(chart.fg_color,80):na,1)
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//~~ Run Code {
data.Series()
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}
//@version=5
start21 = input(0.1)
increment21 = input(0.001)
maximum21 = input(1, "Max Value")
out21 = ta.sar(start21, increment21, maximum21)
//plot(out21, "Döngü", style=plot.style_line, color=#f0ce0e)
plot(out21, color=color.aqua, linewidth=3, title="1",style=plot.style_cross)
//////////////////////////////////////////////////////////////////////////////////////
//@version=5
BackStep = input.int(27,"Analysis Period")
lowerValue = input.float(0.382,"Lower Fibonacci Level",options=[0.236, 0.382, 0.50, 0.618, 0.786])
upperValue = input.float(0.618,"Upper Fibonacci Level",options=[0.236, 0.382, 0.50, 0.618, 0.786])
showFill = input.bool(true,"Show Filling")
changeCandle = input.bool(true,"Change Candle Color")
atr77 = ta.atr(200)
max = ta.highest(close,BackStep)
min = ta.lowest(close,BackStep)
lowerFib = min + (max-min)*lowerValue
upperFib = min + (max-min)*upperValue
ma = ta.wma(close,6)
float closeVal = ma
float openVal = ma
color clrToUse = closeVal>upperFib and openVal>upperFib?color.green:closeVal<lowerFib and openVal<lowerFib?color.red:color.yellow
LowerFibLine = plot(lowerFib,title="0.382",color=color.rgb(189, 75, 255, 100))
UpperFibLine = plot(upperFib,title="0.618",color=color.rgb(189, 75, 255, 100))
float LowerRetracement = (max-min)*0.318
float UpperRetracement = (max-min)*0.618
///////////////////////////////////////////////////////////////////////////////////////
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © peacefulLizard50262
//@version=5
// Custom cosh function
cosh(float x) =>
(math.exp(x) + math.exp(-x)) / 2
// Custom acosh function
acosh(float x) =>
x < 1 ? na : math.log(x + math.sqrt(x * x - 1))
// Custom sinh function
sinh(float x) =>
(math.exp(x) - math.exp(-x)) / 2
// Custom asinh function
asinh(float x) =>
math.log(x + math.sqrt(x * x + 1))
// Custom inverse tangent function
atan(float x) =>
math.pi / 2 - math.atan(1 / x)
// Chebyshev Type I Moving Average
chebyshevI(float src, float len, float ripple) =>
a = 0.
b = 0.
g = 0.
chebyshev = 0.
a := cosh(1 / len * acosh(1 / (1 - ripple)))
b := sinh(1 / len * asinh(1 / ripple))
g := (a - b) / (a + b)
chebyshev := (1 - g) * src + g * nz(chebyshev[1])
chebyshev
// Chebyshev Type II Moving Average
chebyshevII(float src, float len, float ripple) =>
a = 0.
b = 0.
g = 0.
chebyshev = 0.
a := cosh(1 / len * acosh(1 / ripple))
b := sinh(1 / len * asinh(ripple))
g := (a - b) / (a + b)
chebyshev := (1 - g) * src + g * nz(chebyshev[1], src)
chebyshev
chebyshev(float src, float length, float ripple, bool style) =>
style ?
chebyshevI(src, length, ripple) :
chebyshevII(src, length, ripple)
source44 = input.source(hl2, "Source")
up_color = input.color(color.new(color.green, 20), "Up Color")
down_color = input.color(color.new(color.red, 20), "Down Color")
text_color = input.color(color.black, "Text Color")
mean_length = input.float(24, "Mean Length", 5, 1000, 0.5)
mean_ripple = input.float(0.5, "Mean Ripple", 0.01, 0.99, 0.01)
style44 = input.bool(false, "True Chebyshev I | False : Chebyshev II")
atr_style = input.bool(true, "True: |Open-Close| False: High-Low")
atr_length = input.float(64, "ATR Length", 6, 1000, 0.5)
atr_ripple = input.float(0.05, "Mean Ripple", 0.01, 0.99, 0.01)
multiplier = input.float(1.5, "Multiplier", 0.125, 10, 0.125)
alerts = input.bool(false, "Alerts")
labels = input.bool(false, "Labels")
atr = chebyshev(atr_style ? high - low : math.abs(open - close), atr_length, atr_ripple, style44)
mean = chebyshevI(source44, mean_length, mean_ripple)
var float offset = 0.0
var bool state = na
var float newOffset = 0.0
crossover = ta.crossover(source44, offset)
position = source44 > offset
crossunder = ta.crossunder(source44, offset)
prevOffset = nz(offset[1])
if crossover[2] and position[1] and position or (position and position[1] and position[2])
newOffset := mean - atr * multiplier
offset := newOffset < nz(prevOffset) or close[1] > nz(prevOffset) ? newOffset : nz(prevOffset)
state := true
if crossunder[2] and not position[1] and not position or (not position and not position[1] and not position[2])
newOffset := mean + atr * multiplier
offset := newOffset > nz(prevOffset) or close[1] < nz(prevOffset) ? newOffset : nz(prevOffset)
state := false
cross = ta.cross(close, offset)
down_trend = not state and not state[1]
up_trend = state and state[1]
colour = up_trend ? up_color : down_trend ? down_color : color.new(color.white, 100)
if up_trend and not up_trend[1] and labels
label.new(bar_index, offset, "Up Trend \n" + str.tostring(close), color = up_color, style = label.style_label_up, textcolor = text_color)
alert("Up Trend at " + str.tostring(close))
else
alert("Up Trend at " + str.tostring(close))
if down_trend and not down_trend[1] and labels
label.new(bar_index, offset, "Down Trend \n" + str.tostring(close), color = down_color, style = label.style_label_down, textcolor = text_color)
alert("Down Trend at " + str.tostring(close))
else
alert("Down Trend at " + str.tostring(close))
plot(offset, "Trend", colour, linewidth=3, style = plot.style_cross)
plotshape(cross, "Trend Is Getting Ready To Change", shape.xcross, location.belowbar, color = close > offset ? up_color : down_color)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PHP Code:
//@version=5
indicator('Risk-Adjusted Return Oscillator', shorttitle='*', scale=scale.left, overlay=true)
//@version=5
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Tooltips ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
t1 = "Determines the Length of Z-Score Assessment. Defaults to a 75 lookback period"
t2 = "Determines the length of the SMA if the user selects Show SMA. Default is 75, but for a more responsive SMA you can reduce it to 14. Optional."
t3 = "Shows the probability zones in colour."
t4 = "Will Display a summarized Z-Table."
t5 = "Display's the SMA."
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// User Inputs ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
len = input.int(20, "Lookback Length", tooltip=t1)
smalen = input.int(1, "SMA Length", tooltip=t2)
//probfill = input.bool(true, "Distribution Probaiblity Fills", tooltip=t3)
//showztable = input.bool(true, "Show Z-Table", tooltip=t4)
showsma = input.bool(true, "Show SMA", tooltip=t5)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Z-Score/SMA Calculations ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
z = (close - ta.sma(close, len)) / ta.stdev(close, len)
cl_sma = ta.sma(close, len)
cl_sd = ta.stdev(close, len)
// SMA
var float z_sma = 0.0
if showsma
z_sma := ta.sma(z, smalen)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Colours ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
color labelcolor = color.new(color.white, 100)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Logical Assessments ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool zero_one = z >= 0 and z < 1
bool one_two = z >= 1 and z < 2.01
bool two_three = z >= 2 and z < 3.01
bool three = z >= 3
bool zero = z >= 0.99 and z <= -0.99
bool neg_zero_one = z < 0 and z > -1
bool neg_one_two = z <= -1 and z > -2
bool neg_two_three = z <= -2 and z > -3
bool neg_three = z <= -3
falling = ta.falling(z_sma, 3)
rising = ta.rising(z_sma, 3)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Plots ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
neutral = 0
onesd = 1
twosd = 2
threesd = 3
neg_onesd = -1
neg_twosd = -2
neg_threesd = -3
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Price Level Calculations ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
neutral_price = (cl_sma) + (0 * cl_sd)
onesd_price = (cl_sma) + (1 * cl_sd)
twosd_price = (cl_sma) + (2 * cl_sd)
threesd_price = (cl_sma) + (3 * cl_sd)
neg_onesd_price = (cl_sma) + (-1 * cl_sd)
neg_twosd_price = (cl_sma) + (-2 * cl_sd)
neg_threesd_price = (cl_sma) + (-3 * cl_sd)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Line Plots ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
var label neutral_price_line = na
var label onesd_price_line = na
var label twosd_price_line = na
var label threesd_price_line = na
var label neg_onesd_price_line = na
var label neg_twosd_price_line = na
var label neg_threesd_price_line = na
if bar_index >= 75
label.delete(neutral_price_line)
label.delete(onesd_price_line)
label.delete(twosd_price_line)
label.delete(threesd_price_line)
label.delete(neg_onesd_price_line)
label.delete(neg_twosd_price_line)
label.delete(neg_threesd_price_line)
neutral_price_line := label.new(bar_index, y=neutral, text=str.tostring(math.round(neutral_price,2)), color=labelcolor, style=label.style_label_left, textcolor = color.white, size=size.normal, textalign = text.align_right)
onesd_price_line := label.new(bar_index - 5, onesd, str.tostring(math.round(onesd_price,2)), color=labelcolor, style=label.style_label_left, textcolor = color.white, size=size.normal, textalign = text.align_right)
twosd_price_line := label.new(bar_index - 5, twosd, str.tostring(math.round(twosd_price,2)), color=labelcolor, style=label.style_label_left, textcolor = color.white, size=size.normal, textalign = text.align_right)
threesd_price_line := label.new(bar_index - 5, threesd, str.tostring(math.round(threesd_price,2)), color=labelcolor, style=label.style_label_left, textcolor = color.white, size=size.normal, textalign = text.align_right)
neg_onesd_price_line := label.new(bar_index - 5, neg_onesd, str.tostring(math.round(neg_onesd_price,2)), color=labelcolor, style=label.style_label_left, textcolor = color.white, size=size.normal, textalign = text.align_right)
neg_twosd_price_line := label.new(bar_index - 5, neg_twosd, str.tostring(math.round(neg_twosd_price,2)), color=labelcolor, style=label.style_label_left, textcolor = color.white, size=size.normal, textalign = text.align_right)
neg_threesd_price_line := label.new(bar_index - 5, neg_threesd, str.tostring(math.round(neg_threesd_price,2)), color=labelcolor, style=label.style_label_left, textcolor = color.white, size=size.normal, textalign = text.align_right)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
PHP Code:
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © BobRivera990
//@version=5
indicator(title='*', overlay=true, scale=scale.left, format=format.price, precision=2, max_bars_back=200)
//==========================================================================[Inputs]==========================================================================
useAtr = input(true, title='Use ATR to detect Sideways Movements') // Use Average True Range (ATR) to detect Sideways Movements
atrLen = input.int(14, minval=1, title='ATR Length') // length of the Average True Range (ATR) used to detect Sideways Movements
atrMaType = input.string('EMA', options=['SMA', 'EMA'], title='ATR Moving Average Type') // Type of the moving average of the ATR used to detect Sideways Movements
atrMaLen = input.int(27, minval=1, title='ATR MA Length') // length of the moving average of the ATR used to detect Sideways Movements
useAdx = input(true, title='Use ADX to detect Sideways Movements') // Use Average Directional Index (ADX) to detect Sideways Movements
adxLen = input.int(14, minval=1, maxval=50, title='ADX Smoothing') // length of the Average Directional Index (ADX) used to detect Sideways Movements
diLen = input.int(14, minval=1, title='DI Length') // length of the Plus and Minus Directional Indicators (+DI & -DI) used to determine the direction of the trend
adxLim = input.int(25, minval=1, title='ADX Limit') // A level of ADX used as the boundary between Trend Market and Sideways Market
smooth = input.int(3, minval=1, maxval=5, title='Smoothing Factor') // Factor used for smoothing the oscillator
lag = input.int(8, minval=0, maxval=15, title='Lag') // lag used to match indicator and chart
//============================================================================================================================================================
//===================================================================[Initial Calculations]===================================================================
atr = ta.atr(atrLen) // Calculate the Average True Range (ATR)
atrMa = atrMaType == 'EMA' ? ta.ema(atr, atrMaLen) : ta.sma(atr, atrMaLen) // Calculate the moving average of the ATR
up = ta.change(high) // Calculate parameter related to ADX, +DI and -DI
down = -ta.change(low) // Calculate parameter related to ADX, +DI and -DI
plusDM = na(up) ? na : up > down and up > 0 ? up : 0 // Calculate parameter related to ADX, +DI and -DI
minusDM = na(down) ? na : down > up and down > 0 ? down : 0 // Calculate parameter related to ADX, +DI and -DI
trur = ta.rma(ta.tr, diLen) // Calculate parameter related to ADX, +DI and -DI
plus = fixnan(100 * ta.rma(plusDM, diLen) / trur) // Calculate Plus Directional Indicator (+DI)
minus = fixnan(100 * ta.rma(minusDM, diLen) / trur) // Calculate Minus Directional Indicator (-DI)
sum = plus + minus // Calculate parameter related to ADX
adx = 100 * ta.rma(math.abs(plus - minus) / (sum == 0 ? 1 : sum), adxLen) // Calculate Average Directional Index (ADX)
//============================================================================================================================================================
//========================================================================[Conditions]========================================================================
cndNa = na(atr) or na(adx) or na(plus) or na(minus) or na(atrMaLen) // Conditions for lack of sufficient data for calculations
cndSidwayss1 = useAtr and atr <= atrMa // Sideways Movement condition (based on ATR)
cndSidwayss2 = useAdx and adx <= adxLim // Sideways Movement condition (based on ADX)
cndSidways = cndSidwayss1 or cndSidwayss2 // General Sideways Movement condition
cndUp = plus > minus // uptrend condition
cndDown = minus >= plus // downtrend condition
trendType = cndNa ? na : cndSidways ? 0 : cndUp ? 2 : -2 // Determine the type of trend
smoothType = na(trendType) ? na : math.round(ta.sma(trendType, smooth) / 2) * 2 // Calculate the smoothed trend type oscillator
//============================================================================================================================================================
//=========================================================================[Drawing]==========================================================================
colGreen30 = color.new(color.green, 10) // Define the color used in the drawings
colGreen90 = color.new(color.green, 70) // Define the color used in the drawings
colGray = color.new(color.gray, 20) // Define the color used in the drawings
colWhite90 = color.new(color.black, 100) // Define the color used in the drawings
colRed30 = color.new(color.red, 30) // Define the color used in the drawings
colRed90 = color.new(color.red, 70) // Define the color used in the drawings
band3 = plot(+3, title='3', color=color.new(color.black, 100)) // Draw the upper limit of the uptrend area
band2 = plot(+1, title='2', color=color.new(color.black, 100)) // Draw the boundary between Sideways and Uptrend areas
band1 = plot(-1, title='1', color=color.new(color.black, 100)) // Draw the boundary between Sideways and Downtrend areas
band0 = plot(-3, title='0', color=color.new(color.black, 100)) // Draw the lower limit of the downtrend area
fill(band2, band3, title='Uptrend area', color=colGreen90) // Highlight the Uptrend area
fill(band1, band2, title='Sideways area', color=colWhite90) // Highlight the Sideways area
fill(band0, band1, title='Downtrend area', color=colRed90) // Highlight the Downtrend area
var label lblUp = na
label.delete(lblUp)
lblUp := label.new(x=time, y=2, text='', color=color.new(color.green, 100), textcolor=color.black, style=label.style_label_left, xloc=xloc.bar_time, yloc=yloc.price, size=size.normal, textalign=text.align_left) // Show Uptrend area label
var label lblSideways = na
label.delete(lblSideways)
lblSideways := label.new(x=time, y=0, text='', color=color.new(color.green, 100), textcolor=color.black, style=label.style_label_left, xloc=xloc.bar_time, yloc=yloc.price, size=size.normal, textalign=text.align_left) // Show Sideways area label
var label lblDown = na
label.delete(lblDown)
lblDown := label.new(x=time, y=-2, text='', color=color.new(color.green, 100), textcolor=color.black, style=label.style_label_left, xloc=xloc.bar_time, yloc=yloc.price, size=size.normal, textalign=text.align_left) // Show Downtrend area label
var label lblCurrentType = na
label.delete(lblCurrentType)
lblCurrentType := label.new(x=time, y=smoothType, color=color.new(color.blue, 30), style=label.style_label_right, xloc=xloc.bar_time, yloc=yloc.price, size=size.small) // Show the latest status label
trendCol = smoothType == 2 ? colGreen30 : smoothType == 0 ? colGray : colRed30 // Determine the color of the oscillator in different conditions
//plot(smoothType, title = "Tr", color = trendCol,
// linewidth = 3, offset = -lag, style = plot.style_stepline) // Draw the trend type oscillator
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Alıntı yaparak yanıtla
Originally Posted by @yörük@
Yer İmleri