şu an için kullandığım sistemvari kodların görüntüsü böyle.....
ayarların çoğu 1-5-15 dakkalık kullanmak için...
https://www.tradingview.com/x/yC0lrXwp/
tatil arası veriyorum.....
ara vermeden önce...deneyip...yorumlamanız....
hatalarımı bildirmeniz.......önerileriniz için....
kodlar
1. kod.....
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(20, "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 red = color.red
//color green = color.green
//color orange = color.orange
//color yellow = color.yellow
color labelcolor = color.new(color.white, 100)
//color gray = color.new(color.gray, 25)
//color white = color.white
// Colour for Probability Distribution
//color greenfill = color.new(color.green, 75)
//color yellowfill = color.new(color.yellow, 75)
//color redfill = color.new(color.red, 75)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// 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 ///
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//color z_color_plot = z > 0 ? green : z <= 0 ? red : orange
//plot(z, "Z-Score", color=z_color_plot, style=plot.style_area)
//plot(z_sma, "Z-SMA", color=showsma ? white : labelcolor, linewidth=2)
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)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © wbburgin
//@version=5
import jdehorty/KernelFunctions/2 as k
threshold = input.int(20,"Range Threshold",minval=0,maxval=100,
tooltip="Stochastic threshold (0-100) to identify ranging markets. A higher threshold will identify more ranges but will be slower at catching the trend.",
group="General")
l = input.int(14,"ATR Length",group="Stoch ATR")
lengthStoch = input.int(14, "Stochastic Length", minval=1,group="Stoch ATR")
lb = input.int(14,"Lookback",group="Stoch ATR",tooltip="The number of bars used for the estimation of the rational quadratic kernel.")
rw = input.int(1,"Relative Weighting",group="Stoch ATR")
smoothK = input.int(3, "Stochastic Smoothing", minval=1,group="Stoch ATR")
rsisrc = input.source(close,"RSI Source",group="RSI")
rsilen = input.int(14,"RSI Length",group="RSI")
stochatr(atr,smoothK,lookback,weighting,lengthStoch)=>
y = k.rationalQuadratic(ta.stoch(atr,atr,atr,lengthStoch),lookback,weighting,smoothK)
y
atr = ta.atr(l)
k = stochatr(atr,smoothK,lb,rw,lengthStoch)
rsi = ta.rsi(rsisrc,rsilen)
bull = math.sqrt(rsi * k)
bear = math.sqrt((100 - rsi) * k)
barcolor(bull > bear and math.min(bull,bear) > threshold ? color.lime : bear > bull and math.min(bull,bear) > threshold ? color.red : color.rgb(230, 226, 14))
/////////////////////////////////////////////////////////////////////////////////////////////////////
//@version=5
len22=input(1)
o22=ta.ema(open,len22)
c22=ta.ema(close,len22)
h22=ta.ema(high,len22)
l22=ta.ema(low,len22)
haclose = (o22+h22+l22+c22)/4
haopen = o22 // initialize haopen variable
haopen := na(haopen[1]) ? (o22 + c22)/2 : (haopen[1] + haclose[1]) / 2
hahigh = math.max (h22, math.max(haopen,haclose))
halow = math.min (l22, math.min(haopen,haclose))
len233=input(1)
o233=ta.ema(haopen, len233)
c233=ta.ema(haclose, len233)
h233=ta.ema(hahigh, len233)
l233=ta.ema(halow, len233)
// calculate Sancho indicator
sebastine = ((c233 / o233) - 1) * 200
// plot the Sebastine, signal, upper and lower bands
color_sebastine = sebastine >= 0 ? color.rgb(213, 228, 11) : color.red
plot(sebastine, color=color_sebastine, linewidth=2, title="TR",style=plot.style_cross)
hline(0, title="Zero Line", color=color.rgb(122, 121, 121, 52), linestyle=hline.style_dashed, linewidth=1)
//////////////////////////////
2.kod...
PHP Code:
//@version=5
indicator("*", overlay = true, max_lines_count = 100, max_labels_count = 100, format=format.price)
////////////////////////////////////////
// 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(true, "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, style = plot.style_stepline_diamond)
//plotshape(cross, "Trend Is Getting Ready To Change", shape.xcross, location.belowbar, color = close > offset ? up_color : down_color)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © Gedhusek
//@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, 20))
UpperFibLine = plot(upperFib,title="0.618",color=color.rgb(189, 75, 255, 20))
float LowerRetracement = (max-min)*0.318
float UpperRetracement = (max-min)*0.618
//////////////////////////////////////////////////////
//@version=5
////////////////////////////////
length1=(1)
src1=close
start1 = input(0)
increment1 = input(0.001)
maximum1 = input(1, "Max Value")
out1 = ta.sar(start1, increment1, maximum1)
momo1 = src1 - src1[length1]
smdo1 = out1 - momo1
//plot(smdo1, "1.Döngü", style=plot.style_line, color=#f0ce0e)
color33 = smdo1 >= out1 ? color.red : color.lime
plot(smdo1, color=color33, linewidth=2, title="0",style=plot.style_stepline)
//////////////////////////////////////////////////////////////////////////////////////
start21 = input(0)
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=color33, linewidth=2, title="1",style=plot.style_stepline)
//////////////////////////////////////////////////////////////////////////////////////////
//@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(1,"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")
smoothing = 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,smoothing)
//======================================================================================================================
// DISPLAY
//======================================================================================================================
plot(dfts, "Stop", color = dfts > dft ? color.rgb(255, 82, 82, 100) : color.rgb(0, 230, 119, 100))
////////////////////////////////////////////////////////////////
3.kod....
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=4
study(title = "Trend Type Indicator by BobRivera990", overlay = false, 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(14, minval = 1, title = "ATR Length") // length of the Average True Range (ATR) used to detect Sideways Movements
atrMaType = input("EMA", options = ["SMA", "EMA"],
title = "ATR Moving Average Type") // Type of the moving average of the ATR used to detect Sideways Movements
atrMaLen = input(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(14, minval = 1, maxval = 50, title = "ADX Smoothing") // length of the Average Directional Index (ADX) used to detect Sideways Movements
diLen = input(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(25, minval = 1, title = "ADX Limit") // A level of ADX used as the boundary between Trend Market and Sideways Market
smooth = input(3, minval = 1, maxval = 5, title = "Smoothing Factor") // Factor used for smoothing the oscillator
lag = input(8, minval = 0, maxval = 15, title = "Lag") // lag used to match indicator and chart
//============================================================================================================================================================
//===================================================================[Initial Calculations]===================================================================
atr = atr(atrLen) // Calculate the Average True Range (ATR)
atrMa = atrMaType == "EMA" ? ema(atr, atrMaLen) : sma(atr, atrMaLen) // Calculate the moving average of the ATR
up = change(high) // Calculate parameter related to ADX, +DI and -DI
down = -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 = rma(tr, diLen) // Calculate parameter related to ADX, +DI and -DI
plus = fixnan(100 * rma(plusDM, diLen) / trur) // Calculate Plus Directional Indicator (+DI)
minus = fixnan(100 * rma(minusDM, diLen) / trur) // Calculate Minus Directional Indicator (-DI)
sum = plus + minus // Calculate parameter related to ADX
adx = 100 * rma(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 : round(sma(trendType, smooth) / 2) * 2 // Calculate the smoothed trend type oscillator
//============================================================================================================================================================
//=========================================================================[Drawing]==========================================================================
colGreen30 = color.new(color.green, 30) // Define the color used in the drawings
colGreen90 = color.new(color.green, 90) // Define the color used in the drawings
colGray = color.new(color.gray, 20) // Define the color used in the drawings
colWhite90 = color.new(color.white, 90) // 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, 90) // Define the color used in the drawings
band3 = plot(+3, title = "3", color=color.black,transp=100) // Draw the upper limit of the uptrend area
band2 = plot(+1, title = "2", color=color.black,transp=100) // Draw the boundary between Sideways and Uptrend areas
band1 = plot(-1, title = "1", color=color.black,transp=100) // Draw the boundary between Sideways and Downtrend areas
band0 = plot(-3, title = "0", color=color.black,transp=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 = "Trend POZİTİF",
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 = "Trend YOK",
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 = "Trend NEGATİF",
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
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
altta gözüken kodları...fiyat grafiğinin üstüne sürükleyin geçin....
selamlar....bol nasipler.......
Gümüş Üye
Gönderi Kuralları
Alıntı yaparak yanıtla
Yer İmleri