Tradingview

PHP Code:

---

  // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © daytraderph


//@version=5
indicator('Dynamic Range', overlay=true)
res = input.timeframe(defval='D')


dayrange = high - low
r1 = request.security(syminfo.tickerid, res, dayrange[1])
r2 = request.security(syminfo.tickerid, res, dayrange[2])
r3 = request.security(syminfo.tickerid, res, dayrange[3])
r4 = request.security(syminfo.tickerid, res, dayrange[4])
r5 = request.security(syminfo.tickerid, res, dayrange[5])
r6 = request.security(syminfo.tickerid, res, dayrange[6])
r7 = request.security(syminfo.tickerid, res, dayrange[7])
r8 = request.security(syminfo.tickerid, res, dayrange[8])
r9 = request.security(syminfo.tickerid, res, dayrange[9])
r10 = request.security(syminfo.tickerid, res, dayrange[10])
r11 = request.security(syminfo.tickerid, res, dayrange[11])
r12 = request.security(syminfo.tickerid, res, dayrange[12])
oo = request.security(syminfo.tickerid, res, open, barmerge.gaps_off, barmerge.lookahead_on)
zone1 = oo + (r1 + r2 + r3 + r4 + r5) / 10
zone2 = oo + (r1 + r2 + r3 + r4 + r5 + r6 + r7 + r8 + r9 + r10) / 10 / 2
zone3 = oo - (r1 + r2 + r3 + r4 + r5) / 10
zone4 = oo - (r1 + r2 + r3 + r4 + r5 + r6 + r7 + r8 + r9 + r10) / 10 / 2
z1 = plot(zone1, title='D-Range', color=color.new(color.yellow, 0), linewidth=1, style=plot.style_cross)
//z2 = plot(zone2, title='Z2', color=color.new(color.green, 0), linewidth=1, style=plot.style_circles)
//z3 = plot(zone3, title='Z3', color=color.new(color.red, 0), linewidth=1, style=plot.style_circles)
z4 = plot(zone4, title='D-Range', color=color.new(color.aqua, 0), linewidth=1, style=plot.style_cross) 


---

https://tr.tradingview.com/v/6KCUXygZ/

https://tr.tradingview.com/v/bUdYv5cD/

ohlc değerleri kullanarak range hesaplama...
2 farklı zaman dilimi kullanabilirsiniz....

https://tr.tradingview.com/v/oYw1zztt/
güzel range kodu...
alternatif time frame yi işaretleyin

PHP Code:

---

 //@version=5
indicator(title='Range Adaptive Channel', shorttitle='RAC', overlay=true)

string reversal_type = input.string(defval='ATR', options=['ATR', 'Traditional'], title='Reversal Type:', inline='rt')
float reversal_modifier = input.float(defval=14, title='', inline='rt')
float reversal_multiplier = input.float(defval=3, title='', inline='rt', tooltip='-The type of range to use for the width of the channel. \n-Price modifier or atr length parameter depending on type. \n-Multiplier to apply to range.')
string ALT_TF = input.string(defval='D', title='Timeframe:', inline='itf')
bool USE_ALT_TF = input.bool(defval=true, title='Use Alternative Timeframe?', inline='itf')
float expansion_rate = input.float(defval=0.25, title='Expansion Rate:', inline='er')
bool expand_range = input.bool(defval=true, title='Expand Range', inline='er', tooltip='Expand Channel by rate when price touches extremes.')

float atr_1 = ta.atr(math.max(1, math.round(reversal_modifier)))
float reversal_block = 
 switch (reversal_type)
    ('ATR') => reversal_multiplier * atr_1 
    ('Traditional') => reversal_multiplier * reversal_modifier 
    => 0.0

bot_function() =>
    float _bot_base = high - reversal_block
    float _previous = nz(_bot_base[1], _bot_base)
    if _previous + reversal_block < high
        _bot_base := high - reversal_block
    else if low < _previous
        if expand_range
            _bot_base := low - reversal_block * expansion_rate 
        else
            _bot_base := low
    else
        _bot_base := _previous

top_function() =>
    float _top_base = low + reversal_block
    float _previous = nz(_top_base[1], _top_base)
    if _previous - reversal_block > low
        _top_base := low + reversal_block
    else if high > _previous
        if expand_range
            _top_base := high + reversal_block * expansion_rate 
        else
            _top_base := high
    else
        _top_base := _previous

bot_function_1 = bot_function()
security_1 = request.security(syminfo.tickerid, ALT_TF, bot_function_1)
bot_function_2 = bot_function()
bot = USE_ALT_TF ? security_1 : bot_function_2
top_function_1 = top_function()
security_2 = request.security(syminfo.tickerid, ALT_TF, top_function_1)
top_function_2 = top_function()
top = USE_ALT_TF ? security_2 : top_function_2

top_f = ta.change(bot) < 0 or ta.change(top) < 0 ? top : na
bot_f = ta.change(bot) < 0 or ta.change(top) < 0 ? bot : na
top_r = ta.change(bot) > 0 or ta.change(top) > 0 ? top : na
bot_r = ta.change(bot) > 0 or ta.change(top) > 0 ? bot : na

top_border = top - (top - bot) * 0.25
bot_border = bot + (top - bot) * 0.25
mid_border = bot + (top - bot) * 0.50

p_top_f = plot(series=top_f, title='0', color=color.new(color.lime, 0), style=plot.style_linebr)
//p_bot_f = plot(series=bot_f, title='tf', color=color.new(color.lime, 0), style=plot.style_linebr)
p_top_r = plot(series=top_r, title='1', color=color.new(color.red, 0), style=plot.style_linebr)
//p_bot_r = plot(series=bot_r, title='tr', color=color.new(color.red, 0), style=plot.style_linebr)
//fill(p_top_f, p_bot_f, color.new(color.lime, 90), title='direction fill')
//fill(p_top_r, p_bot_r, color.new(color.red, 90), title='direction fill')

plot(title='0', series=bot, color=color.new(color.lime, 0))
plot(title='1', series=top, color=color.new(color.red, 0))

plot(title='1', series=top_border, style=plot.style_circles, color=color.new(color.red, 0))
plot(title='0', series=bot_border, style=plot.style_circles, color=color.new(color.lime, 0))
plot(title='01', series=mid_border, style=plot.style_circles, color=color.new(#537cee, 0)) 


---

PHP Code:

---

 // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © arunbabumvk_23

//@version=5
indicator(title='Range Breakout', overlay=true)
range_length = input.int(5, minval=3, title='Range Length')
rangeHighest = ta.highest(high, range_length)
rangeBreakout = close > rangeHighest[1] ? 1 : 0

rangeSmallest = ta.lowest(low, range_length)
rangeBreakdown = close < rangeSmallest[1] ? 1 : 0

plotshape(rangeBreakout, style=shape.labelup, location=location.belowbar, color=color.rgb(87, 146, 100))
plotshape(rangeBreakdown, style=shape.labeldown, location=location.abovebar, color=color.rgb(193, 74, 80)) 


---

istediğiniz uzunluğa range kırılımları hesaplatabilirsiniz.....

https://tr.tradingview.com/v/O9eCvZR0/
5 dakkalık grafiklerde denenebilir...

etiket sinyalli ve bar renklendirmeli range kodu... v5 çevrildi....

PHP Code:

---

  // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © DonovanWall

//██████╗ ██╗    ██╗
//██╔══██╗██║    ██║
//██║  ██║██║ █╗ ██║
//██║  ██║██║███╗██║
//██████╔╝╚███╔███╔╝
//╚═════╝  ╚══╝╚══╝ 

//@version=5
indicator(title='Range Filter [DW] & Labels', shorttitle='RF [DW] & Labels', overlay=true)

//This is an experimental study designed to filter out minor price action for a clearer view of trends.

//Inspired by the QQE's volatility filter, this filter applies the process directly to price rather than to a smoothed RSI.

//First, a smooth average price range is calculated for the basis of the filter and multiplied by a specified amount.
//Next, the filter is calculated by gating price movements that do not exceed the specified range.
//Lastly the target ranges are plotted to display the prices that will trigger filter movement.

//Custom bar colors are included. The color scheme is based on the filtered price trend.

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Updates:

// -> Migrated to v4.
// -> Range Filter and the bands are now calculated in a singular function.
// -> There are now two different calculation methods for the filter. Select the type you want to use via the "Filter Type" input. Type 1 is the original formula.
// -> Multiple range sizing methods are now available. You can choose from the following scales:
//    - Points
//    - Pips (Works best with forex pairs, obviously)
//    - Ticks
//    - % of Price
//    - ATR
//    - Average Change (Default. This is the original sizing method.)
//    - Standard Deviation
//    - Absolute (Absolute numerical value)
// -> Range smoothing is now optional, and you can specify your smoothing length. Smoothing only affects dynamic scales (ATR, Average Change, and Standard Deviation).
// -> Filter movement can now be determined using wicks or close. This can be specified via the "Movement Source" input.
// -> Stability Fix: Added correction for NaN values to stabilize initial states.
// -> Reorganized the script structure.
// -> Revamped the color scheme.

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Updates:

// - The Range Filter functions have now been rebuilt using Pine's awesome new array functions.

// - Standard deviation calculation has been adjusted to calculate the same as TV's built in stdev() function.

// - Rewritten filter direction and bar color variables.

// - Included an external output variable for trend information that can easily be sent to other scripts without hardcoding.
//   The output format is 1 for bullish, and -1 for bearish.
//   To use this external variable with another script, simply select it from your other script's source dropdown tab.

// - Added the ability to average range filter values based on a user defined number of filter changes.
//   This averaging method utilized the Conditional Sampling EMA function I introduced in my Resampling Filter Pack and only takes a new sample when the filter changes its value.
//   This opens up a whole new world of possible filter outputs.

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Functions
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//Conditional Sampling EMA Function 
Cond_EMA(x, cond, n) =>
    var val = array.new_float(0)
    var ema_val = array.new_float(1)
    if cond
        array.push(val, x)
        if array.size(val) > 1
            array.remove(val, 0)
        if na(array.get(ema_val, 0))
            array.fill(ema_val, array.get(val, 0))
        array.set(ema_val, 0, (array.get(val, 0) - array.get(ema_val, 0)) * (2 / (n + 1)) + array.get(ema_val, 0))
    EMA = array.get(ema_val, 0)
    EMA

//Conditional Sampling SMA Function
Cond_SMA(x, cond, n) =>
    var vals = array.new_float(0)
    if cond
        array.push(vals, x)
        if array.size(vals) > n
            array.remove(vals, 0)
    SMA = array.avg(vals)
    SMA

//Standard Deviation Function
Stdev(x, n) =>
    math.sqrt(Cond_SMA(math.pow(x, 2), 1, n) - math.pow(Cond_SMA(x, 1, n), 2))

//Range Size Function
rng_size(x, scale, qty, n) =>
    ATR = Cond_EMA(ta.tr(true), 1, n)
    AC = Cond_EMA(math.abs(x - x[1]), 1, n)
    SD = Stdev(x, n)
    rng_size = scale == 'Pips' ? qty * 0.0001 : scale == 'Points' ? qty * syminfo.pointvalue : scale == '% of Price' ? close * qty / 100 : scale == 'ATR' ? qty * ATR : scale == 'Average Change' ? qty * AC : scale == 'Standard Deviation' ? qty * SD : scale == 'Ticks' ? qty * syminfo.mintick : qty
    rng_size

//Two Type Range Filter Function
rng_filt(h, l, rng_, n, type, smooth, sn, av_rf, av_n) =>
    rng_smooth = Cond_EMA(rng_, 1, sn)
    r = smooth ? rng_smooth : rng_
    var rfilt = array.new_float(2, (h + l) / 2)
    array.set(rfilt, 1, array.get(rfilt, 0))
    if type == 'Type 1'
        if h - r > array.get(rfilt, 1)
            array.set(rfilt, 0, h - r)
        if l + r < array.get(rfilt, 1)
            array.set(rfilt, 0, l + r)
    if type == 'Type 2'
        if h >= array.get(rfilt, 1) + r
            array.set(rfilt, 0, array.get(rfilt, 1) + math.floor(math.abs(h - array.get(rfilt, 1)) / r) * r)
        if l <= array.get(rfilt, 1) - r
            array.set(rfilt, 0, array.get(rfilt, 1) - math.floor(math.abs(l - array.get(rfilt, 1)) / r) * r)
    rng_filt1 = array.get(rfilt, 0)
    hi_band1 = rng_filt1 + r
    lo_band1 = rng_filt1 - r
    rng_filt2 = Cond_EMA(rng_filt1, rng_filt1 != rng_filt1[1], av_n)
    hi_band2 = Cond_EMA(hi_band1, rng_filt1 != rng_filt1[1], av_n)
    lo_band2 = Cond_EMA(lo_band1, rng_filt1 != rng_filt1[1], av_n)
    rng_filt = av_rf ? rng_filt2 : rng_filt1
    hi_band = av_rf ? hi_band2 : hi_band1
    lo_band = av_rf ? lo_band2 : lo_band1
    [hi_band, lo_band, rng_filt]

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Inputs
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//Filter Type
f_type = input.string(defval='Type 1', options=['Type 1', 'Type 2'], title='Filter Type')

//Movement Source
mov_src = input.string(defval='Close', options=['Wicks', 'Close'], title='Movement Source')

//Range Size Inputs
rng_qty = input.float(defval=2.618, minval=0.0000001, title='Range Size')
rng_scale = input.string(defval='Average Change', options=['Points', 'Pips', 'Ticks', '% of Price', 'ATR', 'Average Change', 'Standard Deviation', 'Absolute'], title='Range Scale')

//Range Period
rng_per = input.int(defval=14, minval=1, title='Range Period (for ATR, Average Change, and Standard Deviation)')

//Range Smoothing Inputs
smooth_range = input(defval=true, title='Smooth Range')
smooth_per = input.int(defval=27, minval=1, title='Smoothing Period')

//Filter Value Averaging Inputs
av_vals = input(defval=true, title='Average Filter Changes')
av_samples = input.int(defval=2, minval=1, title='Number Of Changes To Average')

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Definitions
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//High And Low Values
h_val = mov_src == 'Wicks' ? high : close
l_val = mov_src == 'Wicks' ? low : close

//Range Filter Values
[h_band, l_band, filt] = rng_filt(h_val, l_val, rng_size((h_val + l_val) / 2, rng_scale, rng_qty, rng_per), rng_per, f_type, smooth_range, smooth_per, av_vals, av_samples)

//Direction Conditions
var fdir = 0.0
fdir := filt > filt[1] ? 1 : filt < filt[1] ? -1 : fdir
upward = fdir == 1 ? 1 : 0
downward = fdir == -1 ? 1 : 0

//Colors
filt_color = upward ? #05ff9b : downward ? #ff0583 : #cccccc
bar_color = upward and close > filt ? close > close[1] ? #05ff9b : #00b36b : downward and close < filt ? close < close[1] ? #ff0583 : #b8005d : #cccccc

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
//Outputs
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//Filter Plot
filt_plot = plot(filt, color=filt_color, linewidth=3, title='Filter', transp=0)

//Band Plots
h_band_plot = plot(h_band, color=color.new(#05ff9b, 100), title='High Band')
l_band_plot = plot(l_band, color=color.new(#ff0583, 100), title='Low Band')

//Band Fills
fill(h_band_plot, filt_plot, color=color.new(#00b36b, 85), title='High Band Fill')
fill(l_band_plot, filt_plot, color=color.new(#b8005d, 85), title='Low Band Fill')

//Bar Color
barcolor(bar_color)

//External Trend Output
plot(fdir, editable=false, display=display.none, title='External Output - Trend Signal', transp=100)

// Trading Conditions Logic
longCond = close > filt and close > close[1] and upward > 0 or close > filt and close < close[1] and upward > 0
shortCond = close < filt and close < close[1] and downward > 0 or close < filt and close > close[1] and downward > 0

CondIni = 0
CondIni := longCond ? 1 : shortCond ? -1 : CondIni[1]
longCondition = longCond and CondIni[1] == -1
shortCondition = shortCond and CondIni[1] == 1

// Plot Buy and Sell Labels
plotshape(longCondition, title='Buy Signal', text='BUY', textcolor=color.new(color.white, 0), style=shape.labelup, size=size.normal, location=location.belowbar, color=color.new(color.green, 0))
plotshape(shortCondition, title='Sell Signal', text='SELL', textcolor=color.new(color.white, 0), style=shape.labeldown, size=size.normal, location=location.abovebar, color=color.new(color.red, 0))

// Alerts
alertcondition(longCondition, title='Buy Alert', message='BUY')
alertcondition(shortCondition, title='Sell Alert', message='SELL') 


---

https://tr.tradingview.com/v/QgVDxphm/
5 dakkalık grafiklerde kullanmak için range...strateji kodu... v3 versiyon...

PHP Code:

---

   //@version=5
strategy(title='Range Filter Buy and Sell 5min [Strategy]', overlay=true, commission_type=strategy.commission.percent, commission_value=0.025, default_qty_type=strategy.cash, default_qty_value=10000, initial_capital=10000, slippage=0)

// === INPUT BACKTEST RANGE ===
useDate = input(true, title='---------------- Use Date ----------------')
FromMonth = input.int(defval=7, title='From Month', minval=1, maxval=12)
FromDay = input.int(defval=25, title='From Day', minval=1, maxval=31)
FromYear = input.int(defval=2019, title='From Year', minval=2017)
ToMonth = input.int(defval=1, title='To Month', minval=1, maxval=12)
ToDay = input.int(defval=1, title='To Day', minval=1, maxval=31)
ToYear = input.int(defval=9999, title='To Year', minval=2017)
start = timestamp(FromYear, FromMonth, FromDay, 00, 00)  // backtest start window
finish = timestamp(ToYear, ToMonth, ToDay, 23, 59)  // backtest finish window
window() =>  // create function "within window of time"
    time >= start and time <= finish ? true : false
// === INPUT BACKTEST RANGE ===


sources = input(defval=close, title='Source')
isHA = input(false, 'Use HA Candles')
heikenashi_1 = ticker.heikinashi(syminfo.tickerid)
security_1 = request.security(heikenashi_1, timeframe.period, sources)
src = isHA ? security_1 : sources
// Sampling Period
// Settings for 5min chart, BTCUSDC. For Other coin, change the paremeters

per = input.int(defval=50, minval=1, title='Sampling Period')

// Range Multiplier

mult = input.float(defval=3.0, minval=0.1, title='Range Multiplier')

// Smooth Average Range

smoothrng(x, t, m) =>
    wper = t * 2 - 1
    avrng = ta.ema(math.abs(x - x[1]), t)
    smoothrng = ta.ema(avrng, wper) * m
    smoothrng
smrng = smoothrng(src, per, mult)

// Range Filter

rngfilt(x, r) =>
    rngfilt = x
    rngfilt := x > nz(rngfilt[1]) ? x - r < nz(rngfilt[1]) ? nz(rngfilt[1]) : x - r : x + r > nz(rngfilt[1]) ? nz(rngfilt[1]) : x + r
    rngfilt
filt = rngfilt(src, smrng)

// Filter Direction

upward = 0.0
upward := filt > filt[1] ? nz(upward[1]) + 1 : filt < filt[1] ? 0 : nz(upward[1])
downward = 0.0
downward := filt < filt[1] ? nz(downward[1]) + 1 : filt > filt[1] ? 0 : nz(downward[1])

// Target Bands

hband = filt + smrng
lband = filt - smrng

// Colors

filtcolor = upward > 0 ? color.lime : downward > 0 ? color.red : color.orange
barcolor = src > filt and src > src[1] and upward > 0 ? color.lime : src > filt and src < src[1] and upward > 0 ? color.green : src < filt and src < src[1] and downward > 0 ? color.red : src < filt and src > src[1] and downward > 0 ? color.maroon : color.orange

filtplot = plot(filt, color=filtcolor, linewidth=3, title='Range Filter')

// Target

hbandplot = plot(hband, color=color.new(color.aqua, 100), title='High Target')
lbandplot = plot(lband, color=color.new(color.fuchsia, 100), title='Low Target')

// Fills

fill(hbandplot, filtplot, color=color.new(color.aqua, 90), title='High Target Range')
fill(lbandplot, filtplot, color=color.new(color.fuchsia, 90), title='Low Target Range')

// Bar Color

//barcolor(barcolor)

// Break Outs 

longCond = bool(na)
shortCond = bool(na)
longCond := src > filt and src > src[1] and upward > 0 or src > filt and src < src[1] and upward > 0
shortCond := src < filt and src < src[1] and downward > 0 or src < filt and src > src[1] and downward > 0

CondIni = 0
CondIni := longCond ? 1 : shortCond ? -1 : CondIni[1]
longCondition = longCond and CondIni[1] == -1
shortCondition = shortCond and CondIni[1] == 1

//Alerts

plotshape(longCondition, title='Buy Signal', text='BUY', textcolor=color.new(color.white, 0), style=shape.labelup, size=size.normal, location=location.belowbar, color=color.new(color.green, 0))
plotshape(shortCondition, title='Sell Signal', text='SELL', textcolor=color.new(color.white, 0), style=shape.labeldown, size=size.normal, location=location.abovebar, color=color.new(color.red, 0))

//strategy.entry("Long", strategy.long, stop = hband, when = window() , comment="Long")
//strategy.entry("Short", strategy.short, stop = lband, when = window() , comment="Short")

strategy.entry('Long', strategy.long, when=longCondition and window(), comment='Long')
strategy.entry('Short', strategy.short, when=shortCondition and window(), comment='Short')



// === Stop LOSS ===
useStopLoss = input(false, title='----- Use Stop Loss / Take profit -----')
sl_inp = input.float(100, title='Stop Loss %', step=0.25) / 100
tp_inp = input.float(1.5, title='Take Profit %', step=0.25) / 100
stop_level = strategy.position_avg_price * (1 - sl_inp)
take_level = strategy.position_avg_price * (1 + tp_inp)
stop_level_short = strategy.position_avg_price * (1 + sl_inp)
take_level_short = strategy.position_avg_price * (1 - tp_inp)
// === Stop LOSS ===

if useStopLoss
    strategy.exit('Stop Loss/Profit Long', 'Long', stop=stop_level, limit=take_level)
    strategy.exit('Stop Loss/Profit Short', 'Short', stop=stop_level_short, limit=take_level_short) 


---

v5 hali...

https://tr.tradingview.com/v/5UuBjDYO/

sade hali....https://www.tradingview.com/x/nX6T8FZw/

farklı range hesaplamaları ile kombine.....
https://www.tradingview.com/x/tZLTQo0c/

https://tr.tradingview.com/v/v8XgnKnE/

https://tr.tradingview.com/v/8e1f2wFW/

https://tr.tradingview.com/v/r2aZvj57/
2 farklı uuznluğa.. belirleyeceğiniz 2 farklı oranla...
range hesaplatıp....sinyal oluşturuyor... v4


v5 hali...

PHP Code:

---

  // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © colinmck

//@version=5

indicator(title='Twin Range Filter', overlay=true)

source = input(defval=close, title='Source')

// Smooth Average Range

per1 = input.int(defval=27, minval=1, title='Fast period')
mult1 = input.float(defval=1.6, minval=0.1, title='Fast range')

per2 = input.int(defval=55, minval=1, title='Slow period')
mult2 = input.float(defval=2, minval=0.1, title='Slow range')

smoothrng(x, t, m) =>
    wper = t * 2 - 1
    avrng = ta.ema(math.abs(x - x[1]), t)
    smoothrng = ta.ema(avrng, wper) * m
    smoothrng
smrng1 = smoothrng(source, per1, mult1)
smrng2 = smoothrng(source, per2, mult2)
smrng = (smrng1 + smrng2) / 2

// Range Filter

rngfilt(x, r) =>
    rngfilt = x
    rngfilt := x > nz(rngfilt[1]) ? x - r < nz(rngfilt[1]) ? nz(rngfilt[1]) : x - r : x + r > nz(rngfilt[1]) ? nz(rngfilt[1]) : x + r
    rngfilt
filt = rngfilt(source, smrng)

upward = 0.0
upward := filt > filt[1] ? nz(upward[1]) + 1 : filt < filt[1] ? 0 : nz(upward[1])
downward = 0.0
downward := filt < filt[1] ? nz(downward[1]) + 1 : filt > filt[1] ? 0 : nz(downward[1])

hband = filt + smrng
lband = filt - smrng

longCond = bool(na)
shortCond = bool(na)
longCond := source > filt and source > source[1] and upward > 0 or source > filt and source < source[1] and upward > 0
shortCond := source < filt and source < source[1] and downward > 0 or source < filt and source > source[1] and downward > 0

CondIni = 0
CondIni := longCond ? 1 : shortCond ? -1 : CondIni[1]

long = longCond and CondIni[1] == -1
short = shortCond and CondIni[1] == 1

// Plotting

plotshape(long, title='Long', text='Long', style=shape.labelup, textcolor=color.new(color.black, 0), size=size.tiny, location=location.belowbar, color=color.new(color.lime, 0))
plotshape(short, title='Short', text='Short', style=shape.labeldown, textcolor=color.new(color.white, 0), size=size.tiny, location=location.abovebar, color=color.new(color.red, 0))

// Alerts

alertcondition(long, title='Long', message='Long')
alertcondition(short, title='Short', message='Short') 


---

bunu algo olarak kullanmak isteyenler için...
algo...v5 hali....

PHP Code:

---

  // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © colinmck, greenmask9

//@version=5

strategy(title='Twin Range Filter Algo v.3', shorttitle='Twin Range Strategy', overlay=true)

source = input(defval=close, title='Source')

// Smooth Average Range

per1 = input.int(defval=27, minval=1, title='Fast period', group='Twin Range Filter @colinmck')
mult1 = input.float(defval=1.6, minval=0.1, title='Fast range', group='Twin Range Filter @colinmck')

per2 = input.int(defval=55, minval=1, title='Slow period', group='Twin Range Filter @colinmck')
mult2 = input.float(defval=2, minval=0.1, title='Slow range', group='Twin Range Filter @colinmck')

smoothrng(x, t, m) =>
    wper = t * 2 - 1
    avrng = ta.ema(math.abs(x - x[1]), t)
    smoothrng = ta.ema(avrng, wper) * m
    smoothrng
smrng1 = smoothrng(source, per1, mult1)
smrng2 = smoothrng(source, per2, mult2)
smrng = (smrng1 + smrng2) / 2

// Range Filter

rngfilt(x, r) =>
    rngfilt = x
    rngfilt := x > nz(rngfilt[1]) ? x - r < nz(rngfilt[1]) ? nz(rngfilt[1]) : x - r : x + r > nz(rngfilt[1]) ? nz(rngfilt[1]) : x + r
    rngfilt
filt = rngfilt(source, smrng)

upward = 0.0
upward := filt > filt[1] ? nz(upward[1]) + 1 : filt < filt[1] ? 0 : nz(upward[1])
downward = 0.0
downward := filt < filt[1] ? nz(downward[1]) + 1 : filt > filt[1] ? 0 : nz(downward[1])

hband = filt + smrng
lband = filt - smrng

longCond = bool(na)
shortCond = bool(na)
longCond := source > filt and source > source[1] and upward > 0 or source > filt and source < source[1] and upward > 0
shortCond := source < filt and source < source[1] and downward > 0 or source < filt and source > source[1] and downward > 0

CondIni = 0
CondIni := longCond ? 1 : shortCond ? -1 : CondIni[1]

long = longCond and CondIni[1] == -1
short = shortCond and CondIni[1] == 1

// Plotting

// Strategy
// From this part on, programmer is greenmaks9
//
Separator = input.bool(title='Following conditions and backtest algorithm are added by @greenmask9 🎯, original script is written by @colinmck 👍. Read both of their\'s release notes for more info on how this script works.', defval=false, group='Greenmask\'s testing resources & ATR condition')
disabler = input.bool(title='Disable @greenmask9\'s ATR conditions', defval=false, group='Greenmask\'s testing resources & ATR condition')

//second
l2 = input.int(title='ATR1', defval=32, minval=1, group='ATR condition', tooltip='C: Short-range volatility must be low than long-term volatility measurement for the entry.')
s2 = input.string(title='Smoothing', defval='SMA', options=['RMA', 'SMA', 'EMA', 'WMA'], tooltip='C: Short-range volatility must be low than long-term volatility measurement for the entry.', group='ATR condition')
atr2(source, l2) =>
    if s2 == 'SMA'
        ta.sma(source, l2)
    else
        if s2 == 'RMA'
            ta.rma(source, l2)
        else
            if s2 == 'EMA'
                ta.ema(source, l2)
            else
                ta.wma(source, l2)

//third
l3 = input.int(title='ATR2', defval=64, minval=1, group='ATR condition', tooltip='C: Short-range volatility must be low than long-term volatility measurement for the entry.')
s3 = input.string(title='Smoothing', defval='RMA', options=['RMA', 'SMA', 'EMA', 'WMA'], tooltip='C: Short-range volatility must be low than long-term volatility measurement for the entry.', group='ATR condition')
atr3(source, l3) =>
    if s3 == 'RMA'
        ta.rma(source, l3)
    else
        if s3 == 'SMA'
            ta.sma(source, l3)
        else
            if s3 == 'EMA'
                ta.ema(source, l3)
            else
                ta.wma(source, l3)

atr20 = atr2(ta.tr(true), l2)
atr30 = atr3(ta.tr(true), l3)

ordersize = math.floor(strategy.initial_capital / close)
maxcandles_till_close = input.int(title='Time-based Close', defval=17, group='Alternative Exit')
i_time = input.bool(true, 'Enable Time Base Close', group='Alternative Exit')


//stop
varip stop_long = 0.0
varip entry = 0.0
varip stop_short = 0.0
i_sl_type = input.string('Low - (close - lowest low[len]) * %', options=['Low - (ATR[len] * %)', 'Low - (close - lowest low[len]) * %', 'Low - (close - average low[len]) * %', 'Close - (ATR[len] * %)', 'Low - TicksNumber'], title='Calculation (Long)', group='Stop-loss', tooltip='This is a stop-loss calculation for long positions. Reversed logic is used for short stop-loss. *Calculation Low - TicksNumber doesn\'t use Percentage-based multiplier. **Number of ticks is always substracted (added) after the initial calculation. ')

i_sl_atr = input.int(10, 'Calculation Length', group='Stop-loss')
i_sl_perc = input.float(80, 'Percentage', group='Stop-loss') / 100
i_sl_ticks = input.int(defval=10, minval=1, title='Number of ticks', group='Stop-loss') * syminfo.mintick
i_stoploss = input.bool(true, 'Enable Stop-loss', group='Stop-loss')

f_stop_long(calculation, length, mult, ticks) =>
    stop_0 = calculation == 'Low - (ATR[len] * %)' ? low - ta.atr(length) * mult - ticks : calculation == 'Low - (close - lowest low[len]) * %' ? low - (close - ta.lowest(low, length)) * mult - ticks : calculation == 'Low - (close - average low[len]) * %' ? low - (close - ta.sma(low, length)) * mult - ticks : calculation == 'Close - (ATR[len] * %)' ? close - ta.atr(length) * mult - ticks : low - ticks
    stop_0
f_stop_short(calculation, length, mult, ticks) =>
    stop_0 = calculation == 'Low - (ATR[len] * %)' ? high + ta.atr(length) * mult + ticks : calculation == 'Low - (close - lowest low[len]) * %' ? high + math.abs(close - ta.lowest(high, length)) * mult + ticks : calculation == 'Low - (close - average low[len]) * %' ? high + math.abs(close - ta.sma(high, length)) * mult + ticks : calculation == 'Close - (ATR[len] * %)' ? close + ta.atr(length) * mult + ticks : high + ticks
    stop_0

//target
varip target_long = 0.0
varip target_short = 0.0
i_tr_type = input.string('Close + (ATR[len] * %)', options=['High + (ATR[len] * %)', 'Close + (ATR[len] * %)', 'Close + abs(close - highest high[len]) * %', 'Close + abs(close - average high[len]) * %', 'High + TicksNumber', 'Close + TicksNumber'], title='Calculation (Long)', group='Target', tooltip='Raw number of ticks is always added to the target.')
i_tr_atr = input.int(10, 'Calculation Length', group='Target')
i_tr_perc = input.float(500, 'Percentage', group='Target') / 100
i_tr_ticks = input.int(defval=10, minval=1, title='Number of ticks', group='Target') * syminfo.mintick
i_target = input.bool(true, 'Enable Target', group='Target')

f_target_long(calculation, length, mult, ticks) =>
    stop_0 = calculation == 'High + (ATR[len] * %)' ? high + ta.atr(length) * mult + ticks : calculation == 'Close + (ATR[len] * %)' ? close + ta.atr(length) * mult + ticks : calculation == 'Close + abs(close - highest high[len]) * %' ? close + math.abs(close - ta.highest(high, length)) * mult + ticks : calculation == 'Close + abs(close - average high[len]) * %' ? close + math.abs(close - ta.sma(high, length)) * mult + ticks : calculation == 'High + TicksNumber' ? high + ticks : close + ticks
    stop_0
f_target_short(calculation, length, mult, ticks) =>
    stop_0 = calculation == 'High + (ATR[len] * %)' ? low - ta.atr(length) * mult - ticks : calculation == 'Close + (ATR[len] * %)' ? close - ta.atr(length) * mult - ticks : calculation == 'Close + abs(close - highest high[len]) * %' ? close - math.abs(close - ta.lowest(low, length)) * mult - ticks : calculation == 'Close + abs(close - average high[len]) * %' ? close - math.abs(close - ta.sma(low, length)) * mult - ticks : calculation == 'High + TicksNumber' ? low - ticks : close - ticks
    stop_0





if strategy.position_size >= 0 or strategy.position_size[1] != strategy.position_size
    stop_short := i_stoploss ? f_stop_short(i_sl_type, i_sl_atr, i_sl_perc, i_sl_ticks) : na
    target_short := i_target ? f_target_short(i_tr_type, i_tr_atr, i_tr_perc, i_tr_ticks) : na
    target_short


if strategy.position_size <= 0 or strategy.position_size[1] != strategy.position_size
    stop_long := i_stoploss ? f_stop_long(i_sl_type, i_sl_atr, i_sl_perc, i_sl_ticks) : na
    target_long := i_target ? f_target_long(i_tr_type, i_tr_atr, i_tr_perc, i_tr_ticks) : na
    target_long


if strategy.position_size == 0 or strategy.position_size[1] != strategy.position_size
    entry := open
    entry






bull = long and (atr20 < atr30 or disabler)
bear = short and (atr20 < atr30 or disabler)

bullclock = ta.barssince(bull)
bearclock = ta.barssince(bear)

if bull
    strategy.entry('Twin Long', strategy.long, ordersize)

strategy.exit('Exit', from_entry='Twin Long', limit=target_long, stop=stop_long)

if bear
    strategy.entry('Twin Short', strategy.short, ordersize)

strategy.exit('Exit', from_entry='Twin Short', limit=target_short, stop=stop_short)


i_message_long = input.string('Long entry default message: x', 'Long Entry Alert Message', group='Alert')
i_long_alert = input.bool(true, 'Enable Long Alert', group='Alert')
i_message_short = input.string('Long entry default message: x', 'Short Entry Alert Message', group='Alert')
i_short_alert = input.bool(true, 'Enable Short Alert', group='Alert')

if bull and strategy.position_size[1] == 0 and i_long_alert
    alert(i_message_long, alert.freq_once_per_bar_close)
if bear and strategy.position_size[1] == 0 and i_short_alert
    alert(i_message_short, alert.freq_once_per_bar_close)


//time stoploss
if i_time
    strategy.close('Twin Long', when=bullclock == maxcandles_till_close, comment='Time')
    strategy.close('Twin Short', when=bearclock == maxcandles_till_close, comment='Time')



c_fill_stop = color.new(color.red, 90)
c_fill_target = color.new(color.green, 90)

p_longstop = plot(strategy.position_size > 0 and i_stoploss ? stop_long : na, linewidth=2, color=color.new(color.red, 0), style=plot.style_linebr)
p_shortstop = plot(strategy.position_size < 0 and i_stoploss ? stop_short : na, linewidth=2, color=color.new(color.red, 0), style=plot.style_linebr)
p_entry = plot(strategy.position_size != 0 ? entry : na, linewidth=2, color=color.new(color.blue, 0), style=plot.style_linebr)

p_longtarget = plot(strategy.position_size > 0 and i_target ? target_long : na, linewidth=2, color=color.new(color.green, 0), style=plot.style_linebr)
p_shorttarget = plot(strategy.position_size < 0 and i_target ? target_short : na, linewidth=2, color=color.new(color.green, 0), style=plot.style_linebr)

fill(p_entry, p_longstop, c_fill_stop)
fill(p_entry, p_shortstop, c_fill_stop)

fill(p_entry, p_longtarget, c_fill_target)
fill(p_entry, p_shorttarget, c_fill_target) 


---

https://tr.tradingview.com/v/r9iTBjn1/
değişik bir imza kodu...

https://tr.tradingview.com/v/Bwd3wDPL/
linear bakış için kullanılabilecek bir kod....

https://i.hizliresim.com/5opi1hv.png

range hesaplamalrı ile tasarlanmmış sade ve agresif bir sistem oldu...
z score ile hedefleme yapıldı...

btcusdt ye farklı sistemlerle günlükte bakış açıları....
https://i.hizliresim.com/hymtsop.png
https://i.hizliresim.com/9308eo5.png
https://i.hizliresim.com/mham1lh.png
https://i.hizliresim.com/1f5pdya.png
https://i.hizliresim.com/pj516um.png
https://i.hizliresim.com/faa0477.png

z score ile sade tasarım....

PHP Code:

---

  // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © Steversteves

//@version=5
indicator("Z-Score", overlay=true, max_labels_count = 500)

lengthInput = input.int(50, "Length", minval = 2)
// Calculating High Z Score

a = ta.sma(close, lengthInput)
b = ta.stdev(close, lengthInput)
c = (close - a) / b 



// Highest and Lowest

highz = ta.highest(c, lengthInput)

lowz = ta.lowest(c, lengthInput) 

// Condition Alerts

var wait = 0

wait := wait + 1

if (c <= lowz) and (wait > 30)
    wait := 10
    label.new(x=bar_index, y=high, text="sat", size = size.tiny, color=color.rgb(247, 7, 7))
    alert("sat tepe "+syminfo.ticker, alert.freq_once_per_bar)
    

if (c >= highz) and (wait > 30)
    wait := 10
    label.new(x=bar_index, y=high, text="al", size = size.tiny, color=color.rgb(66, 248, 11))
    alert("al ralli "+syminfo.ticker, alert.freq_once_per_bar)

// Colors

color bear = color.new(color.orange, 0) 
color bull = color.new(color.lime, 0) 

bool overbought = c >= 2 
bool oversold = c <= -2 

brcolor = overbought ? bear : oversold ? bull : na

//barcolor(brcolor)
//////////////////////////
Length22 = input(50)
stddevs = input(1.69)
src22 = close

basis = ta.ema(src22, Length22)

zscore = (src22-basis)/ta.stdev(src22, Length22)

diff = math.abs(src22 - basis)
absZscore = math.abs(zscore)
bounds = diff / absZscore * stddevs
upper = basis + bounds
lower = basis - bounds

zscoreColor = zscore > 0.0 ? zscore >= zscore[1] ? zscore >= stddevs ? color.blue : color.green : color.new(color.green, 70) : zscore <= zscore[1] ? zscore <= -stddevs ? color.blue : color.red : color.new(color.red, 70)

plot(ta.ema(upper, 5), title="Upper ", linewidth=2)
//plot(ta.ema(basis, 5), title="Median", color=color.new(color.white, 60), linewidth=2)
plot(ta.ema(lower, 5), title="Lower ", linewidth=2) 


---

https://www.tradingview.com/x/Yy4GFVZx/

sar stratejisi...

PHP Code:

---

  //@version=5
strategy(title='Parabolic SAR Strategy (on close) [QuantNomad]', shorttitle='SAR Strategy [QN]', overlay=true)

start = input(0.02)
increment = input(0.02)
maximum = input(0.2)
entry_bars = input(1, title='Entry on Nth trend bar')

psar = 0.0  // PSAR
af = 0.0  // Acceleration Factor
trend_dir = 0  // Current direction of PSAR
ep = 0.0  // Extreme point
trend_bars = 0

sar_long_to_short = trend_dir[1] == 1 and close <= psar[1]  // PSAR switches from long to short
sar_short_to_long = trend_dir[1] == -1 and close >= psar[1]  // PSAR switches from short to long

trend_change = barstate.isfirst[1] or sar_long_to_short or sar_short_to_long

// Calculate trend direction
trend_dir := barstate.isfirst[1] and close[1] > open[1] ? 1 : barstate.isfirst[1] and close[1] <= open[1] ? -1 : sar_long_to_short ? -1 : sar_short_to_long ? 1 : nz(trend_dir[1])

trend_bars := sar_long_to_short ? -1 : sar_short_to_long ? 1 : trend_dir == 1 ? nz(trend_bars[1]) + 1 : trend_dir == -1 ? nz(trend_bars[1]) - 1 : nz(trend_bars[1])

// Calculate  Acceleration Factor
af := trend_change ? start : trend_dir == 1 and high > ep[1] or trend_dir == -1 and low < ep[1] ? math.min(maximum, af[1] + increment) : af[1]

// Calculate extreme point
ep := trend_change and trend_dir == 1 ? high : trend_change and trend_dir == -1 ? low : trend_dir == 1 ? math.max(ep[1], high) : math.min(ep[1], low)

// Calculate PSAR
psar := barstate.isfirst[1] and close[1] > open[1] ? low[1] : barstate.isfirst[1] and close[1] <= open[1] ? high[1] : trend_change ? ep[1] : trend_dir == 1 ? psar[1] + af * (ep - psar[1]) : psar[1] - af * (psar[1] - ep)

plot(psar, style=plot.style_cross, color=trend_dir == 1 ? color.green : color.red, linewidth=2)

// Strategy 
strategy.entry('Long', strategy.long, when=trend_bars == entry_bars)
strategy.entry('Short', strategy.short, when=trend_bars == -entry_bars) 


---

sar...

PHP Code:

---

  // This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © LonesomeTheBlue

//@version=5
indicator('Parabolic SAR', 'SAR', overlay=true)

start = input.float(title='Start', defval=0.02, step=0.001)
increment = input.float(title='Increment', defval=0.02, step=0.001)
maximum = input.float(title='Max Value', defval=0.2, step=0.01)
putlabel = input(title='Put Labels', defval=true)
colup = input.color(title='Colors', defval=color.lime, inline='col')
coldn = input.color(title='', defval=color.red, 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 := start
    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 := start
            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 := start
            af
    sar := nextsar
    sar

plot(sar, title='Parabolic SAR', color=trend > 0 ? colup : coldn, linewidth=2, style=plot.style_circles)

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.tiny)
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.tiny) 


---