Tradingview

Göstergeye yorum TREND çizgiyi otomatik çekiyor anladığım kadarıyla

https://tr.tradingview.com/script/ObBduzr0/


BİST ve NASDAQ borsalarının durumunu "RSİ MOMENTUM TREND" indikatörü ile takip edebilirsiniz.

İndikatör linki
https://tr.tradingview.com/script/g6...omentum-Trend/


Pullback, trend ve trend dönüşümleri ile işlem alanlar için belki de YORUMCULARA GÖRE tradingview'in en iyi indikatörü;

https://tr.tradingview.com/script/Xe...s-and-Retests/

Lux Algo'nun ÜCRETLİ satılan indikatörünün benzeri free

https://tr.tradingview.com/script/34...ks-ChartPrime/

Alım satım stratejisi;
1 saatlik grafikte supertrend indikatörünün ayarları 3, 3 yapılır. ikinci verdiğim indikatörde çıkan mavi çizgiye stop loss konur ve fiyat yükseldikçe çıkan mavi çizginin 1 altındaki çizgiye kâr seviyesi alınır.


https://tr.tradingview.com/v/r6dAP7yi/
https://tr.tradingview.com/script/96...h-1-line-plot/

ellerine sağlık rosense hocam....
örnekler çok güzel....

son yazdığın örneğin birleştirilmesi çok güzel....

zaten amaç....
birbirine uygun kodlarla... sistem kurgulamak.....

hayırlı bayramlar.....

Alıntı:

---

Originally Posted by @yörük@

ellerine sağlık rosense hocam....
örnekler çok güzel....

son yazdığın örneğin birleştirilmesi çok güzel....

zaten amaç....
birbirine uygun kodlarla... sistem kurgulamak.....

hayırlı bayramlar.....

---

Sanada hayırlı bayramlar kardeş

amaç paylaştıkça daha yeniyi doğruyu güzeli bulmak bulabilirsek haz duyarım inşaallah .
bazen sosyal medyaya da ling atıyorum daha çok kişi yararlanılsın diye

sistem kurgulama örneği....
https://i.hizliresim.com/m1zpk86.png

üç bölüm tasarlandı....


ana kısmı bu....https://i.hizliresim.com/o75ombm.png
sadeleştirildi....hesaplamalardaki çizgilerin çoğu gizlendi.... agresif tasarlandı...değerler değiştirildi...
testleri tamamlanmadı henüz.....
kodu....

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)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 


---

ikinci kısım bu.....olasılık hesaplaması rakamsal olarak.....
ana sistemdeki olasılık ise oluşabilecek bar mantığı...ileriye yönelik...
bu kısım ise o an olabilecekler için...periyotlar küçüldükçe...
kullanımı daha iyi....https://i.hizliresim.com/8i9h1pz.png

kodu...

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) 


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 


---

son kısım ise alan belirleme.....
https://i.hizliresim.com/sjjkw0w.png

ana kısım trend yönü ve gücünü bulurken...
ikinci kısım olasılık bakarken....
son kısım ise olasılıklara uygun alan belirlemiş oluyor....
belirlenen alan olasılığa tam uymaz....
bu alan pullback alanı....destek direnç alanı gibi düşünülebilir....
kodu...

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
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 


---

ozgurhan @ozgurtrade der ki : İndikatör satan hanzolardan indikatör satın almayın.

Lux Algo'nun ücretli satılan indikatörünün free ve alarm eklenmiş hali, 2 defadan fazla buy veya sell gelirse kademeli olarak alın.
Kodları saklayın.


https://tr.tradingview.com/script/SJ...CT-Algo-Alert/

iyi bir strateji

Pine script bilenler stratejiyi resimde görüldüğü üzere indikatöre çevirebilir.
Strateji linki: https://tradingview.com/script/w91kw...eakout-Alerts/

https://www.tradingview.com/script/w...eakout-Alerts/


Strateji;
Supertrend indikatörünün gereksiz buy sinyallerini önleyen 2 indikatör.

https://tr.tradingview.com/v/2raJpSpw/
https://tr.tradingview.com/v/4IYKX938/

Alıntı:

---

Originally Posted by rosense

ozgurhan @ozgurtrade der ki : İndikatör satan hanzolardan indikatör satın almayın.

---

bu yazdığınız çok doğru....
açık kaynak kodlar varken...
indikatör almak....ne bileyim....

strajeilerde hep şunu gördüm...
en iyisi yüzde elli ile çalışabilir.....
o da....stratejiye uygulanan zaman dilimini geniş tutanlar için.....

en iyi strateji...tüm periyotlarda...
aynı yüzdesel değere yakın olanlar.....

yüzdesel değer aynı...ancak işlem sayısı değişiyor sadece.....


sistemler ise....
en güzeli....kişinin kendi tasarladığı...
ve ya birleştirdiği sistemler.....

çünkü el elin eşeğini türkü söyleyerek arar....

ne olursa olsun....
insanın kendi emek verdiği....
sistem çalışması...kendi için evla olandır.....

her şey ralli moduna mı alındı acaba.....

https://www.tradingview.com/x/pjNneNWD/ 100
https://www.tradingview.com/x/ombIMw8N/ usd
https://www.tradingview.com/x/J5R5OK5f/ gr
https://www.tradingview.com/x/AZpHQpgZ/ ons ralli siyali yok ....
https://www.tradingview.com/x/fvNROy2I/ sa sertikakada da yok