Tradingview indicator and strategies

Please post your trading view indicators and scripts. With the AI explosion, its easier then ever to create scripts and strategies.

The purpose for me is to learn, teach and help each other with shared knowledge, testing and oversight.

Please try and post original scripts, modified or otherwise, not just copy and paste. Modifying available scripts with enhancements and improvements is acceptable and share your views on improvements and strategy testing.

Below is a modified ADR indicator. ADR line based on daily data, has a multiplied ADR line value set at 1.30 (130%), it also paints arrows showing candles that hit the ADR lines (customisable).

//@version=2
study(title="ADR.v2 - Average Daily Range [CK]", shorttitle="ADR [CK]", overlay=true)

length = input(defval=5, title="Length", type=integer, minval=1)
offset = input(defval=0, title="Offset", type=integer, minval=0)
use_av = input(defval="EMA", title="EMA/SMA", type=string)
today_only = input(defval=false, title="Show Today Only", type=bool)
multiplier = input(1.30, title="ADR Multiplier", minval=0.1, step=0.05)

// Used to calculate true range
high0 = security(tickerid, 'D', high[offset])
low0 = security(tickerid, 'D', low[offset])
close1 = security(tickerid, 'D', close[1 + offset])
open0 = security(tickerid, 'D', open)

datr = max(max(high0 - low0, abs(high0 - close1)), abs(low0 - close1))
smooth = security(tickerid, 'D', use_av=="SMA" ? sma(datr, length) : ema(datr, length))

milliseconds_in_1day = 1000 * 60 * 60 * 24 * 1
midnight_today = timenow - (timenow % milliseconds_in_1day)

leftborder = time >= midnight_today or (not today_only)
rightborder = false

// Original ADR levels
p1 = plot(open0 + smooth, color=leftborder and not rightborder ? green : na, title='Upper ADR', linewidth=3, style=line)
p2 = plot(open0 - smooth, color=leftborder and not rightborder ? red : na, title='Lower ADR', linewidth=3, style=line)

// Variable multiplier levels
upper_mult = open0 + smooth * multiplier
lower_mult = open0 - smooth * multiplier
p3 = plot(upper_mult, color=leftborder and not rightborder ? blue : na, title='Upper ' + tostring(multiplier * 100) + '% ADR', linewidth=2, style=line)
p4 = plot(lower_mult, color=leftborder and not rightborder ? orange : na, title='Lower ' + tostring(multiplier * 100) + '% ADR', linewidth=2, style=line)

// Draw arrows when ADR and ADR multiplier levels are touched
plotarrow(series=high >= open0 + smooth ? 1 : na, colorup=green, offset=-1, title='Upper ADR Arrow')
plotarrow(series=low <= open0 - smooth ? -1 : na, colordown=red, offset=-1, title='Lower ADR Arrow')
plotarrow(series=high >= upper_mult ? 1 : na, colorup=blue, offset=-1, title='Upper Multiplier Arrow')
plotarrow(series=low <= lower_mult ? -1 : na, colordown=orange, offset=-1, title='Lower Multiplier Arrow')

Gaussian strategy, buys and sells when candles close above or below bands. can set S/l and T/P or just allow trades in opposite directions on candle closes.

//@version=4
strategy(title="Gaussian Channel Strategy [DW]", shorttitle="GC Strategy [DW]", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=10)

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

// Source
src = input(defval=hlc3, title="Source")

// Poles
int N = input(defval=4, title="Poles", minval=1, maxval=9)

// Sampling Period
int per = input(defval=144, title="Sampling Period", minval=2)

// True Range Multiplier
float mult = input(defval=1.414, title="Filtered True Range Multiplier", minval=0)

// Lag Reduction
bool modeLag = input(defval=false, title="Reduced Lag Mode")
bool modeFast = input(defval=false, title="Fast Response Mode")

// Stop-Loss and Take-Profit Settings
bool useManualSLTP = input(defval=true, title="Enable Manual Stop-Loss and Take-Profit")
float stopLossPercent = input(defval=2.0, title="Stop Loss (%)", minval=0.0) / 100
float takeProfitPercent = input(defval=4.0, title="Take Profit (%)", minval=0.0) / 100

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Functions (Same as the original script)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

// Filter function
f_filt9x (_a, _s, _i) =>
int _m2 = 0, int _m3 = 0, int _m4 = 0, int _m5 = 0, int _m6 = 0,
int _m7 = 0, int _m8 = 0, int _m9 = 0, float _f = .0, _x = (1 - _a)
// Weights.
_m2 := _i == 9 ? 36 : _i == 8 ? 28 : _i == 7 ? 21 : _i == 6 ? 15 : _i == 5 ? 10 : _i == 4 ? 6 : _i == 3 ? 3 : _i == 2 ? 1 : 0
_m3 := _i == 9 ? 84 : _i == 8 ? 56 : _i == 7 ? 35 : _i == 6 ? 20 : _i == 5 ? 10 : _i == 4 ? 4 : _i == 3 ? 1 : 0
_m4 := _i == 9 ? 126 : _i == 8 ? 70 : _i == 7 ? 35 : _i == 6 ? 15 : _i == 5 ? 5 : _i == 4 ? 1 : 0
_m5 := _i == 9 ? 126 : _i == 8 ? 56 : _i == 7 ? 21 : _i == 6 ? 6 : _i == 5 ? 1 : 0
_m6 := _i == 9 ? 84 : _i == 8 ? 28 : _i == 7 ? 7 : _i == 6 ? 1 : 0
_m7 := _i == 9 ? 36 : _i == 8 ? 8 : _i == 7 ? 1 : 0
_m8 := _i == 9 ? 9 : _i == 8 ? 1 : 0
_m9 := _i == 9 ? 1 : 0
// filter
_f := pow(_a, _i) * nz(_s) +
_i * _x * nz(_f[1]) - (_i >= 2 ?
_m2 * pow(_x, 2) * nz(_f[2]) : 0) + (_i >= 3 ?
_m3 * pow(_x, 3) * nz(_f[3]) : 0) - (_i >= 4 ?
_m4 * pow(_x, 4) * nz(_f[4]) : 0) + (_i >= 5 ?
_m5 * pow(_x, 5) * nz(_f[5]) : 0) - (_i >= 6 ?
_m6 * pow(_x, 6) * nz(_f[6]) : 0) + (_i >= 7 ?
_m7 * pow(_x, 7) * nz(_f[7]) : 0) - (_i >= 8 ?
_m8 * pow(_x, 8) * nz(_f[8]) : 0) + (_i == 9 ?
_m9 * pow(_x, 9) * nz(_f[9]) : 0)

// Pole function
f_pole (_a, _s, _i) =>
_f1 = f_filt9x(_a, _s, 1), _f2 = (_i >= 2 ? f_filt9x(_a, _s, 2) : 0), _f3 = (_i >= 3 ? f_filt9x(_a, _s, 3) : 0)
_f4 = (_i >= 4 ? f_filt9x(_a, _s, 4) : 0), _f5 = (_i >= 5 ? f_filt9x(_a, _s, 5) : 0), _f6 = (_i >= 6 ? f_filt9x(_a, _s, 6) : 0)
_f7 = (_i >= 2 ? f_filt9x(_a, _s, 7) : 0), _f8 = (_i >= 8 ? f_filt9x(_a, _s, 8) : 0), _f9 = (_i == 9 ? f_filt9x(_a, _s, 9) : 0)
_fn = _i == 1 ? _f1 : _i == 2 ? _f2 : _i == 3 ? _f3 :
_i == 4 ? _f4 : _i == 5 ? _f5 : _i == 6 ? _f6 :
_i == 7 ? _f7 : _i == 8 ? _f8 : _i == 9 ? _f9 : na
[_fn, _f1]

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

// Beta and Alpha Components
beta = (1 - cos(4*asin(1)/per)) / (pow(1.414, 2/N) - 1)
alpha = - beta + sqrt(pow(beta, 2) + 2*beta)

// Lag
lag = (per - 1)/(2*N)

// Data
srcdata = modeLag ? src + (src - src[lag]) : src
trdata = modeLag ? tr(true) + (tr(true) - tr(true)[lag]) : tr(true)

// Filtered Values
[filtn, filt1] = f_pole(alpha, srcdata, N)
[filtntr, filt1tr] = f_pole(alpha, trdata, N)

// Lag Reduction
filt = modeFast ? (filtn + filt1)/2 : filtn
filttr = modeFast ? (filtntr + filt1tr)/2 : filtntr

// Bands
hband = filt + filttr * mult
lband = filt - filttr * mult

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Strategy Logic
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

// Entry Conditions
longCondition = close > lband and close[1] <= lband[1]
shortCondition = close < hband and close[1] >= hband[1]

// Exit Conditions (Stop-Loss and Take-Profit)
var float longStopLoss = na
var float longTakeProfit = na
var float shortStopLoss = na
var float shortTakeProfit = na

if (longCondition)
strategy.entry("Buy", strategy.long)
if (useManualSLTP)
longStopLoss := close * (1 - stopLossPercent)
longTakeProfit := close * (1 + takeProfitPercent)

if (shortCondition)
strategy.entry("Sell", strategy.short)
if (useManualSLTP)
shortStopLoss := close * (1 + stopLossPercent)
shortTakeProfit := close * (1 - takeProfitPercent)

// Exit on Stop-Loss or Take-Profit (only if enabled)
if (useManualSLTP)
strategy.exit("Long Exit", from_entry="Buy", stop=longStopLoss, limit=longTakeProfit)
strategy.exit("Short Exit", from_entry="Sell", stop=shortStopLoss, limit=shortTakeProfit)

// Exit on Opposite Signal (always active)
strategy.close("Buy", when=shortCondition)
strategy.close("Sell", when=longCondition)

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Plotting
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

// Filter Plot
filtplot = plot(filt, title="Filter", color=color.blue, linewidth=2)

// Band Plots
hbandplot = plot(hband, title="Upper Band", color=color.red)
lbandplot = plot(lband, title="Lower Band", color=color.green)

// Channel Fill
fill(hbandplot, lbandplot, title="Channel Fill", color=color.new(color.gray, 80))

Another modified script of the above Gaussian indicator strategy.

This one has a longs only logic and does not place short trades. stoploss/take profit function.

The best result I managed after a short 5 min test was on NAS100 as shown in the screenshot

//@version=4
strategy(title="Gaussian Channel Long-Only Strategy [DW]", shorttitle="GC Long-Only Strategy [DW]", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=10)

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

// Source
src = input(defval=hlc3, title="Source")

// Poles
int N = input(defval=4, title="Poles", minval=1, maxval=9)

// Sampling Period
int per = input(defval=144, title="Sampling Period", minval=2)

// True Range Multiplier
float mult = input(defval=1.414, title="Filtered True Range Multiplier", minval=0)

// Lag Reduction
bool modeLag = input(defval=false, title="Reduced Lag Mode")
bool modeFast = input(defval=false, title="Fast Response Mode")

// Stop-Loss and Take-Profit Settings
bool useManualSLTP = input(defval=true, title="Enable Manual Stop-Loss and Take-Profit")
float stopLossPercent = input(defval=2.0, title="Stop Loss (%)", minval=0.0) / 100
float takeProfitPercent = input(defval=4.0, title="Take Profit (%)", minval=0.0) / 100

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Functions (Same as the original script)
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

// Filter function
f_filt9x (_a, _s, _i) =>
int _m2 = 0, int _m3 = 0, int _m4 = 0, int _m5 = 0, int _m6 = 0,
int _m7 = 0, int _m8 = 0, int _m9 = 0, float _f = .0, _x = (1 - _a)
// Weights.
_m2 := _i == 9 ? 36 : _i == 8 ? 28 : _i == 7 ? 21 : _i == 6 ? 15 : _i == 5 ? 10 : _i == 4 ? 6 : _i == 3 ? 3 : _i == 2 ? 1 : 0
_m3 := _i == 9 ? 84 : _i == 8 ? 56 : _i == 7 ? 35 : _i == 6 ? 20 : _i == 5 ? 10 : _i == 4 ? 4 : _i == 3 ? 1 : 0
_m4 := _i == 9 ? 126 : _i == 8 ? 70 : _i == 7 ? 35 : _i == 6 ? 15 : _i == 5 ? 5 : _i == 4 ? 1 : 0
_m5 := _i == 9 ? 126 : _i == 8 ? 56 : _i == 7 ? 21 : _i == 6 ? 6 : _i == 5 ? 1 : 0
_m6 := _i == 9 ? 84 : _i == 8 ? 28 : _i == 7 ? 7 : _i == 6 ? 1 : 0
_m7 := _i == 9 ? 36 : _i == 8 ? 8 : _i == 7 ? 1 : 0
_m8 := _i == 9 ? 9 : _i == 8 ? 1 : 0
_m9 := _i == 9 ? 1 : 0
// filter
_f := pow(_a, _i) * nz(_s) +
_i * _x * nz(_f[1]) - (_i >= 2 ?
_m2 * pow(_x, 2) * nz(_f[2]) : 0) + (_i >= 3 ?
_m3 * pow(_x, 3) * nz(_f[3]) : 0) - (_i >= 4 ?
_m4 * pow(_x, 4) * nz(_f[4]) : 0) + (_i >= 5 ?
_m5 * pow(_x, 5) * nz(_f[5]) : 0) - (_i >= 6 ?
_m6 * pow(_x, 6) * nz(_f[6]) : 0) + (_i >= 7 ?
_m7 * pow(_x, 7) * nz(_f[7]) : 0) - (_i >= 8 ?
_m8 * pow(_x, 8) * nz(_f[8]) : 0) + (_i == 9 ?
_m9 * pow(_x, 9) * nz(_f[9]) : 0)

// Pole function
f_pole (_a, _s, _i) =>
_f1 = f_filt9x(_a, _s, 1), _f2 = (_i >= 2 ? f_filt9x(_a, _s, 2) : 0), _f3 = (_i >= 3 ? f_filt9x(_a, _s, 3) : 0)
_f4 = (_i >= 4 ? f_filt9x(_a, _s, 4) : 0), _f5 = (_i >= 5 ? f_filt9x(_a, _s, 5) : 0), _f6 = (_i >= 6 ? f_filt9x(_a, _s, 6) : 0)
_f7 = (_i >= 2 ? f_filt9x(_a, _s, 7) : 0), _f8 = (_i >= 8 ? f_filt9x(_a, _s, 8) : 0), _f9 = (_i == 9 ? f_filt9x(_a, _s, 9) : 0)
_fn = _i == 1 ? _f1 : _i == 2 ? _f2 : _i == 3 ? _f3 :
_i == 4 ? _f4 : _i == 5 ? _f5 : _i == 6 ? _f6 :
_i == 7 ? _f7 : _i == 8 ? _f8 : _i == 9 ? _f9 : na
[_fn, _f1]

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

// Beta and Alpha Components
beta = (1 - cos(4*asin(1)/per)) / (pow(1.414, 2/N) - 1)
alpha = - beta + sqrt(pow(beta, 2) + 2*beta)

// Lag
lag = (per - 1)/(2*N)

// Data
srcdata = modeLag ? src + (src - src[lag]) : src
trdata = modeLag ? tr(true) + (tr(true) - tr(true)[lag]) : tr(true)

// Filtered Values
[filtn, filt1] = f_pole(alpha, srcdata, N)
[filtntr, filt1tr] = f_pole(alpha, trdata, N)

// Lag Reduction
filt = modeFast ? (filtn + filt1)/2 : filtn
filttr = modeFast ? (filtntr + filt1tr)/2 : filtntr

// Bands
hband = filt + filttr * mult
lband = filt - filttr * mult

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Strategy Logic
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

// Entry Condition
longCondition = close > lband and close[1] <= lband[1]

// Exit Conditions (Stop-Loss and Take-Profit)
var float longStopLoss = na
var float longTakeProfit = na

if (longCondition)
strategy.entry("Buy", strategy.long)
if (useManualSLTP)
longStopLoss := close * (1 - stopLossPercent)
longTakeProfit := close * (1 + takeProfitPercent)

// Exit on Stop-Loss or Take-Profit (only if enabled)
if (useManualSLTP)
strategy.exit("Long Exit", from_entry="Buy", stop=longStopLoss, limit=longTakeProfit)

// Exit on Price Closing Below Lower Band (if manual SL/TP is disabled)
if (not useManualSLTP)
strategy.close("Buy", when=close < lband)

//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Plotting
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------

// Filter Plot
filtplot = plot(filt, title="Filter", color=color.blue, linewidth=2)

// Band Plots
hbandplot = plot(hband, title="Upper Band", color=color.red)
lbandplot = plot(lband, title="Lower Band", color=color.green)

// Channel Fill
fill(hbandplot, lbandplot, title="Channel Fill", color=color.new(color.gray, 80))

An ADR buy and sell strategy. Can trade both reversal and breakouts, can use multiplier ADR for trades.


//@version=5
strategy("ADR Reversal Strategy [cryptoking]", overlay=true)

// Inputs
length = input.int(5, title="Length", minval=1)
offset = input.int(0, title="Offset", minval=0)
use_av = input.string("EMA", title="EMA/SMA", options=["EMA", "SMA"])
today_only = input.bool(false, title="Show Today Only")
adr_multiplier = input.float(2.0, title="ADR Multiplier (e.g., 1.25 for 125%)", minval=0.1, step=0.05)

// Visibility Inputs
show_standard_adr_lines = input.bool(true, title="Show Standard ADR Lines")
show_multiplied_adr_lines = input.bool(true, title="Show Multiplied ADR Lines")
use_multiplied_adr_for_trades = input.bool(false, title="Use Multiplied ADR Levels for Trades")

// Input for Reversing Trading Method
reverse_trading_method = input.bool(false, title="Reverse Trading Method")

// Inputs for Stop Loss and Take Profit
use_stop_loss = input.bool(true, title="Use Stop Loss")
stop_loss_type = input.string("Percentage", title="Stop Loss Type", options=["Percentage", "Pips"])
stop_loss_value = input.float(1.0, title="Stop Loss Value", minval=0.0, step=0.1)
use_take_profit = input.bool(true, title="Use Take Profit")
take_profit_type = input.string("Percentage", title="Take Profit Type", options=["Percentage", "Pips"])
take_profit_value = input.float(2.0, title="Take Profit Value", minval=0.0, step=0.1)

// Calculate True Range
high0 = request.security(syminfo.tickerid, "D", high[offset])
low0 = request.security(syminfo.tickerid, "D", low[offset])
close1 = request.security(syminfo.tickerid, "D", close[1 + offset])
open0 = request.security(syminfo.tickerid, "D", open)

// Average Daily Range (ADR) Calculation
datr = math.max(math.max(high0 - low0, math.abs(high0 - close1)), math.abs(low0 - close1))
smooth = request.security(syminfo.tickerid, "D", use_av == "SMA" ? ta.sma(datr, length) : ta.ema(datr, length))

// Time Calculations for Today's Range
midnight_today = timestamp('GMT+0', year, month, dayofmonth, 0, 0)

// Determine Plot Boundaries
leftborder = time >= midnight_today or (not today_only)
rightborder = false // Use `false` to avoid repainting issues

// Compute ADR Levels
upper_adr = leftborder and not rightborder ? open0 + smooth : na
lower_adr = leftborder and not rightborder ? open0 - smooth : na

// Compute Additional ADR Levels at Multiplier
upper_adr_mult = leftborder and not rightborder ? open0 + smooth * adr_multiplier : na
lower_adr_mult = leftborder and not rightborder ? open0 - smooth * adr_multiplier : na

// Plot ADR Levels
plot(show_standard_adr_lines ? upper_adr : na, color=color.new(color.green, 0), title='Upper ADR', linewidth=2)
plot(show_standard_adr_lines ? lower_adr : na, color=color.new(color.red, 0), title='Lower ADR', linewidth=2)
plot(show_multiplied_adr_lines ? upper_adr_mult : na, color=color.new(color.green, 50), title='Upper ADR Multiplied', linewidth=2)
plot(show_multiplied_adr_lines ? lower_adr_mult : na, color=color.new(color.red, 50), title='Lower ADR Multiplied', linewidth=2)

// Optional: Highlight Today's Range
bgcolor(today_only and time >= midnight_today ? color.new(color.blue, 90) : na, title="Today's Range Highlight")

// Variables to track touches
var bool upper_touched = false
var bool lower_touched = false

// Reset touches at the start of each new day
new_day = ta.change(time('D')) != 0 // Ensuring new_day is a boolean
if new_day
upper_touched := false
lower_touched := false

// Determine which ADR levels to use for trading
trade_upper_level = use_multiplied_adr_for_trades ? upper_adr_mult : upper_adr
trade_lower_level = use_multiplied_adr_for_trades ? lower_adr_mult : lower_adr

// Trading Logic with Stop Loss and Take Profit Options
if reverse_trading_method
// Reversed Trading Method
if not na(trade_upper_level) and not upper_touched and high >= trade_upper_level
// Place Buy Order at Market
strategy.entry("Long Trade", strategy.long, comment="Buy at Upper ADR (Reversed)")
upper_touched := true
// Set Stop Loss and Take Profit for Long Trade
if use_stop_loss or use_take_profit
// Declare variables with explicit types
float long_stop_price = na
float long_take_profit_price = na
// Calculate Stop Loss for Long
if use_stop_loss
if stop_loss_type == "Percentage"
long_stop_price := strategy.position_avg_price * (1 - stop_loss_value / 100)
else
long_stop_price := strategy.position_avg_price - stop_loss_value * syminfo.mintick
// Calculate Take Profit for Long
if use_take_profit
if take_profit_type == "Percentage"
long_take_profit_price := strategy.position_avg_price * (1 + take_profit_value / 100)
else
long_take_profit_price := strategy.position_avg_price + take_profit_value * syminfo.mintick
// Exit Orders
strategy.exit("Exit Long", from_entry="Long Trade", stop=long_stop_price, limit=long_take_profit_price)
if not na(trade_lower_level) and not lower_touched and low <= trade_lower_level
// Place Sell Order at Market
strategy.entry("Short Trade", strategy.short, comment="Sell at Lower ADR (Reversed)")
lower_touched := true
// Set Stop Loss and Take Profit for Short Trade
if use_stop_loss or use_take_profit
// Declare variables with explicit types
float short_stop_price = na
float short_take_profit_price = na
// Calculate Stop Loss for Short
if use_stop_loss
if stop_loss_type == "Percentage"
short_stop_price := strategy.position_avg_price * (1 + stop_loss_value / 100)
else
short_stop_price := strategy.position_avg_price + stop_loss_value * syminfo.mintick
// Calculate Take Profit for Short
if use_take_profit
if take_profit_type == "Percentage"
short_take_profit_price := strategy.position_avg_price * (1 - take_profit_value / 100)
else
short_take_profit_price := strategy.position_avg_price - take_profit_value * syminfo.mintick
// Exit Orders
strategy.exit("Exit Short", from_entry="Short Trade", stop=short_stop_price, limit=short_take_profit_price)
else
// Standard Trading Method
if not na(trade_upper_level) and not upper_touched and high >= trade_upper_level
// Place Sell Order at Market
strategy.entry("Short Trade", strategy.short, comment="Sell at Upper ADR")
upper_touched := true
// Set Stop Loss and Take Profit for Short Trade
if use_stop_loss or use_take_profit
// Declare variables with explicit types
float short_stop_price = na
float short_take_profit_price = na
// Calculate Stop Loss for Short
if use_stop_loss
if stop_loss_type == "Percentage"
short_stop_price := strategy.position_avg_price * (1 + stop_loss_value / 100)
else
short_stop_price := strategy.position_avg_price + stop_loss_value * syminfo.mintick
// Calculate Take Profit for Short
if use_take_profit
if take_profit_type == "Percentage"
short_take_profit_price := strategy.position_avg_price * (1 - take_profit_value / 100)
else
short_take_profit_price := strategy.position_avg_price - take_profit_value * syminfo.mintick
// Exit Orders
strategy.exit("Exit Short", from_entry="Short Trade", stop=short_stop_price, limit=short_take_profit_price)
if not na(trade_lower_level) and not lower_touched and low <= trade_lower_level
// Place Buy Order at Market
strategy.entry("Long Trade", strategy.long, comment="Buy at Lower ADR")
lower_touched := true
// Set Stop Loss and Take Profit for Long Trade
if use_stop_loss or use_take_profit
// Declare variables with explicit types
float long_stop_price = na
float long_take_profit_price = na
// Calculate Stop Loss for Long
if use_stop_loss
if stop_loss_type == "Percentage"
long_stop_price := strategy.position_avg_price * (1 - stop_loss_value / 100)
else
long_stop_price := strategy.position_avg_price - stop_loss_value * syminfo.mintick
// Calculate Take Profit for Long
if use_take_profit
if take_profit_type == "Percentage"
long_take_profit_price := strategy.position_avg_price * (1 + take_profit_value / 100)
else
long_take_profit_price := strategy.position_avg_price + take_profit_value * syminfo.mintick
// Exit Orders
strategy.exit("Exit Long", from_entry="Long Trade", stop=long_stop_price, limit=long_take_profit_price)

CK ADR version 2 indicator for trading view

This one is now customisable from the style setting with choice of icons etc and looks visually better. NOW has a table with all related ADR information and values






//@version=5
indicator(title="ADR.v2 - Average Daily Range [cryptoking]", shorttitle="ADR [cryptoking]", overlay=true)
// Inputs
length = input.int(defval=5, title="Length", minval=1)
offset = input.int(defval=0, title="Offset", minval=0)
use_av = input.string(defval="EMA", title="EMA/SMA", options=["EMA", "SMA"])
today_only = input.bool(defval=false, title="Show Today Only")
adr_multiplier = input.float(defval=1.25, title="ADR Multiplier", minval=0.1, step=0.05)

// Security function calls for daily data
high0 = request.security(syminfo.tickerid, 'D', high[offset], lookahead=barmerge.lookahead_on)
low0 = request.security(syminfo.tickerid, 'D', low[offset], lookahead=barmerge.lookahead_on)
close1 = request.security(syminfo.tickerid, 'D', close[1 + offset], lookahead=barmerge.lookahead_on)
open0 = request.security(syminfo.tickerid, 'D', open, lookahead=barmerge.lookahead_on)

// True Range Calculation for Current Day
datr_current = math.max(math.max(high0 - low0, math.abs(high0 - close1)), math.abs(low0 - close1))

// Previous Day's Data
prev_high = request.security(syminfo.tickerid, 'D', high[1 + offset], lookahead=barmerge.lookahead_on)
prev_low = request.security(syminfo.tickerid, 'D', low[1 + offset], lookahead=barmerge.lookahead_on)
prev_close = request.security(syminfo.tickerid, 'D', close[2 + offset], lookahead=barmerge.lookahead_on)

// True Range Calculation for Previous Day
datr_prev = math.max(math.max(prev_high - prev_low, math.abs(prev_high - prev_close)), math.abs(prev_low - prev_close))

// Smoothed ADR using EMA or SMA
smooth_current = request.security(syminfo.tickerid, 'D', use_av == "SMA" ? ta.sma(datr_current, length) : ta.ema(datr_current, length), lookahead=barmerge.lookahead_on)
smooth_prev = request.security(syminfo.tickerid, 'D', use_av == "SMA" ? ta.sma(datr_prev, length) : ta.ema(datr_prev, length), lookahead=barmerge.lookahead_on)

// Apply ADR Multiplier
scaled_smooth = smooth_current * adr_multiplier

// Calculate ADR Levels
lower_adr = open0 - smooth_current
upper_adr = open0 + smooth_current
lower_scaled_adr = open0 - scaled_smooth
upper_scaled_adr = open0 + scaled_smooth

// Current Price
current_price = close

// Time Filtering for Today Only
milliseconds_in_1day = 1000 * 60 * 60 * 24 * 1
midnight_today = timenow - (timenow % milliseconds_in_1day)
leftborder = time >= midnight_today or not today_only

// Touch Detection Logic
touch_upper = ta.crossover(high, upper_adr) and leftborder
touch_lower = ta.crossunder(low, lower_adr) and leftborder
touch_upper_scaled = ta.crossover(high, upper_scaled_adr) and leftborder
touch_lower_scaled = ta.crossunder(low, lower_scaled_adr) and leftborder

// Define Colors
dark_green = color.new(#00fd08, 0) // Darker green for original ADR
dark_red = color.new(#ff0000, 0) // Darker red for original ADR
light_green = color.new(#00ff08, 0) // Lighter green for multiplier ADR
light_red = color.new(#ff0000, 0) // Lighter red for multiplier ADR

// Plotting Original ADR Levels
plot(upper_adr, color=leftborder ? dark_green : na, title="Upper ADR", linewidth=2)
plot(lower_adr, color=leftborder ? dark_red : na, title="Lower ADR", linewidth=2)

// Plotting Multiplier-Adjusted ADR Levels
plot(upper_scaled_adr, color=leftborder ? light_green : na, title="Upper ADR (Multiplied)", linewidth=2)
plot(lower_scaled_adr, color=leftborder ? light_red : na, title="Lower ADR (Multiplied)", linewidth=2)

// Plot Touch Markers
plotshape(touch_upper, style=shape.triangleup, color=dark_green, location=location.belowbar, size=size.small, title="Upper ADR Touch")
plotshape(touch_lower, style=shape.triangledown, color=dark_red, location=location.abovebar, size=size.small, title="Lower ADR Touch")
plotshape(touch_upper_scaled, style=shape.triangleup, color=light_green, location=location.belowbar, size=size.small, title="Upper Scaled ADR Touch")
plotshape(touch_lower_scaled, style=shape.triangledown, color=light_red, location=location.abovebar, size=size.small, title="Lower Scaled ADR Touch")

// Create and Populate Table
var table adr_table = table.new(position.top_right, 3, 11, border_width=1)
if barstate.islast
table.clear(adr_table, 0, 0, 2, 10)

// Table Headers
table.cell(adr_table, 0, 0, "Metric", bgcolor=color.new(color.gray, 80), text_color=color.white)
table.cell(adr_table, 1, 0, "Value", bgcolor=color.new(color.gray, 80), text_color=color.white)
table.cell(adr_table, 2, 0, "Percentage", bgcolor=color.new(color.gray, 80), text_color=color.white)

// Open Price Row
table.cell(adr_table, 0, 1, "Open Price", bgcolor=color.new(color.gray, 80))
table.cell(adr_table, 1, 1, str.tostring(open0, "#.#####"), text_color=color.white)
table.cell(adr_table, 2, 1, "", text_color=color.white)

// Current Price Row
table.cell(adr_table, 0, 2, "Current Price", bgcolor=color.new(color.gray, 80))
table.cell(adr_table, 1, 2, str.tostring(current_price, "#.#####"), text_color=color.white)
table.cell(adr_table, 2, 2, "", text_color=color.white)

// Current Day's Smoothed ADR Value
table.cell(adr_table, 0, 3, "Current Day ADR", bgcolor=color.new(color.gray, 80))
table.cell(adr_table, 1, 3, str.tostring(smooth_current, "#.#####"), text_color=color.white)
table.cell(adr_table, 2, 3, str.tostring(smooth_current / open0 * 100, "#.##") + "%", text_color=color.white)

// Previous Day's Smoothed ADR Value
table.cell(adr_table, 0, 4, "Previous Day ADR", bgcolor=color.new(color.gray, 80))
table.cell(adr_table, 1, 4, str.tostring(smooth_prev, "#.#####"), text_color=color.white)
table.cell(adr_table, 2, 4, str.tostring(smooth_prev / open0 * 100, "#.##") + "%", text_color=color.white)

// Upper ADR Row
dist_upper_adr = upper_adr - open0
table.cell(adr_table, 0, 5, "Upper ADR", bgcolor=color.new(color.gray, 80))
table.cell(adr_table, 1, 5, str.tostring(upper_adr, "#.#####"), text_color=dark_green)
table.cell(adr_table, 2, 5, str.tostring(dist_upper_adr / open0 * 100, "#.##") + "%", text_color=dark_green) // Percentage

// Lower ADR Row
dist_lower_adr = open0 - lower_adr
table.cell(adr_table, 0, 6, "Lower ADR", bgcolor=color.new(color.gray, 80))
table.cell(adr_table, 1, 6, str.tostring(lower_adr, "#.#####"), text_color=dark_red)
table.cell(adr_table, 2, 6, str.tostring(dist_lower_adr / open0 * 100, "#.##") + "%", text_color=dark_red) // Percentage

// Upper Scaled ADR Row
dist_upper_scaled_adr = upper_scaled_adr - open0
table.cell(adr_table, 0, 7, "Upper Scaled ADR", bgcolor=color.new(color.gray, 80))
table.cell(adr_table, 1, 7, str.tostring(upper_scaled_adr, "#.#####"), text_color=light_green)
table.cell(adr_table, 2, 7, str.tostring(dist_upper_scaled_adr / open0 * 100, "#.##") + "%", text_color=light_green) // Percentage

// Lower Scaled ADR Row
dist_lower_scaled_adr = open0 - lower_scaled_adr
table.cell(adr_table, 0, 8, "Lower Scaled ADR", bgcolor=color.new(color.gray, 80))
table.cell(adr_table, 1, 8, str.tostring(lower_scaled_adr, "#.#####"), text_color=light_red)
table.cell(adr_table, 2, 8, str.tostring(dist_lower_scaled_adr / open0 * 100, "#.##") + "%", text_color=light_red) // Percentage

// Distance Metrics for Closing Price
dist_close_to_upper_adr = upper_adr - close
table.cell(adr_table, 0, 9, "Dist: Close to Upper ADR", bgcolor=color.new(color.gray, 80))
table.cell(adr_table, 1, 9, str.tostring(dist_close_to_upper_adr, "#.#####"), text_color=dark_green)
table.cell(adr_table, 2, 9, str.tostring(dist_close_to_upper_adr / close * 100, "#.##") + "%", text_color=dark_green) // Percentage

// Distance Metrics for Closing Price to Lower ADR
dist_close_to_lower_adr = close - lower_adr
table.cell(adr_table, 0, 10, "Dist: Close to Lower ADR", bgcolor=color.new(color.gray, 80))
table.cell(adr_table, 1, 10, str.tostring(dist_close_to_lower_adr, "#.#####"), text_color=dark_red)
table.cell(adr_table, 2, 10, str.tostring(dist_close_to_lower_adr / close * 100, "#.##") + "%", text_color=dark_red) // Percentage

// Alert Conditions
alertcondition(touch_upper, title="Upper ADR Touch", message="Price touched Upper ADR")
alertcondition(touch_lower, title="Lower ADR Touch", message="Price touched Lower ADR")
alertcondition(touch_upper_scaled, title="Upper Scaled ADR Touch", message="Price touched Upper Scaled ADR")
alertcondition(touch_lower_scaled, title="Lower Scaled ADR Touch", message="Price touched Lower Scaled ADR")

MOVING AVERAGE STRATEGY enhanced WITH D ALEMBERT ORDERING METHOD STRATEGY

Below is a strategy script moving average cross over with rsi, atr functions. This script has a D Alembert ordering variation incorporated.

seems to perform reasonably on DAX and gold.

//@version=5
strategy("Simplified MA Crossover Strategy with D'Alembert", overlay=true, default_qty_type=strategy.fixed, default_qty_value=0.1)

// Inputs
shortLength = input.int(9, title="Short MA Length", minval=1)
longLength = input.int(21, title="Long MA Length", minval=1)
enableRSI = input.bool(true, title="Enable RSI Filter")
rsiLength = input.int(14, title="RSI Length", minval=1)
rsiOverbought = input.int(70, title="RSI Overbought Level", minval=50, maxval=100)
rsiOversold = input.int(30, title="RSI Oversold Level", minval=0, maxval=50)
showRSILevels = input.bool(false, title="Show RSI Overbought/Oversold Levels") // Hide RSI levels
enableATR = input.bool(true, title="Enable ATR Filter")
atrLength = input.int(14, title="ATR Length", minval=1)
minATR = input.float(0.005, title="Minimum ATR Threshold", minval=0)
showATR = input.bool(false, title="Show ATR Plot") // Hide ATR plot
stopLossPerc = input.float(0.5, title="Stop Loss (%)", minval=0.1) / 100
riskRewardRatio = input.float(2, title="Risk-Reward Ratio", minval=1)

// Indicators
shortMA = ta.sma(close, shortLength)
longMA = ta.sma(close, longLength)
rsi = ta.rsi(close, rsiLength)
atr = ta.atr(atrLength)

// D'Alembert Variables
var float cumulativeLoss = 0.0 // Tracks cumulative losses
var float basePositionSize = strategy.equity * 0.001 // Base position size: 0.1% of account balance
var float currentUnit = 1.0 // Tracks the current multiplier for fractional progression
var float maxLossPerTrade = strategy.equity * 0.005 // Cap losses at 0.5% of account balance

// Conditions
longCondition = ta.crossover(shortMA, longMA)
shortCondition = ta.crossunder(shortMA, longMA)

// Apply RSI Filter (if enabled)
if (enableRSI)
longCondition := longCondition and rsi < rsiOverbought
shortCondition := shortCondition and rsi > rsiOversold

// Apply ATR Filter (if enabled)
if (enableATR)
longCondition := longCondition and atr > minATR
shortCondition := shortCondition and atr > minATR

// Risk Management
positionSize = math.min(basePositionSize * currentUnit, maxLossPerTrade / (stopLossPerc * close))
takeProfitLevel = strategy.position_avg_price * (1 + stopLossPerc * riskRewardRatio)
stopLossLevel = strategy.position_avg_price * (1 - stopLossPerc)

// Execute Trades
if (longCondition)
strategy.entry("Long", strategy.long, qty=positionSize)
strategy.exit("Take Profit/Stop Loss", "Long", limit=takeProfitLevel, stop=stopLossLevel)
if (shortCondition)
strategy.entry("Short", strategy.short, qty=positionSize)
strategy.exit("Take Profit/Stop Loss", "Short", limit=strategy.position_avg_price * (1 - stopLossPerc * riskRewardRatio), stop=strategy.position_avg_price * (1 + stopLossPerc))

// Update D'Alembert Unit Based on Trade Result
if (strategy.closedtrades > 0)
lastTradeResult = strategy.closedtrades.profit(strategy.closedtrades - 1)
if (lastTradeResult > 0) // If the last trade was a win
cumulativeLoss := math.max(cumulativeLoss - lastTradeResult, 0) // Reduce cumulative loss
if (cumulativeLoss == 0) // Reset to base position size if all losses are recovered
currentUnit := 1.0
// Do not decrease currentUnit after a win unless all losses are recovered
else if (lastTradeResult < 0) // If the last trade was a loss
cumulativeLoss := cumulativeLoss + math.abs(lastTradeResult) // Add to cumulative loss
currentUnit := currentUnit + 0.1 // Increase unit fractionally

// Plotting
plot(shortMA, color=color.blue, title="Short MA")
plot(longMA, color=color.red, title="Long MA")

// Hide RSI Levels
hline(showRSILevels ? rsiOverbought : na, "Overbought", color=color.red)
hline(showRSILevels ? rsiOversold : na, "Oversold", color=color.green)

// Hide ATR Plot
plot(showATR ? atr : na, color=color.orange, title="ATR")

// Entry Signals
plotshape(series=longCondition, title="Long Entry", location=location.belowbar, color=color.green, style=shape.labelup, text="BUY")
plotshape(series=shortCondition, title="Short Entry", location=location.abovebar, color=color.red, style=shape.labeldown, text="SELL")

Great to see someone strated a thread included included source code and pics.

Thanks!
I wish you good effort with your thread!

Guido

DYNAMIC MOVING AVERAGE

Select both ema/sma. You can assign a length value to a particular time frame. ie, set daily at 5 days, 4hr at 14 days, 1hr at 30 days etc. No need to manually adjust for time frame of choice, custom timeframe with DMA length of choice.

Please check it out, and let me know of any issues.

//@version=5
indicator("Dynamic Moving Average (DMA) by CryptoKING - Enhanced with Custom Timeframe", overlay=true)

// Step 1: Add an input to choose between SMA and EMA
ma_type = input.string("SMA", title="Moving Average Type", options=["SMA", "EMA"])

// Step 2: Define manual input fields for standard timeframes
var int dma_length = na

// Input fields for custom lengths
length_1min = input.int(780, title="1-Minute DMA Length")
length_5min = input.int(390, title="5-Minute DMA Length")
length_15min = input.int(90, title="15-Minute DMA Length")
length_1hr = input.int(60, title="1-Hour DMA Length")
length_4hr = input.int(30, title="4-Hour DMA Length")
length_daily = input.int(5, title="Daily DMA Length")

// Step 3: Add inputs for the custom timeframe
custom_timeframe = input.timeframe("", title="Custom Timeframe (e.g., 3H, 12H)")
custom_length = input.int(20, title="Custom Timeframe DMA Length")
custom_ma_type = input.string("SMA", title="Custom Timeframe MA Type", options=["SMA", "EMA"])

// Step 4: Assign the appropriate length based on the detected timeframe
if timeframe.period == "D" // Daily
dma_length := length_daily
else if timeframe.period == "240" // 4-hour
dma_length := length_4hr
else if timeframe.period == "60" // 1-hour
dma_length := length_1hr
else if timeframe.period == "15" // 15-minute
dma_length := length_15min
else if timeframe.period == "5" // 5-minute
dma_length := length_5min
else if timeframe.period == "1" // 1-minute
dma_length := length_1min
else if timeframe.period == custom_timeframe // Custom timeframe
dma_length := custom_length
else
// Default to a reasonable value if timeframe is not explicitly defined
dma_length := 20

// Step 5: Calculate the selected moving average (SMA or EMA)
var float dma = na
if ma_type == "SMA"
dma := ta.sma(close, dma_length)
else if ma_type == "EMA"
dma := ta.ema(close, dma_length)

// Step 6: Handle the custom timeframe separately
var float custom_dma = na
if timeframe.period == custom_timeframe
if custom_ma_type == "SMA"
custom_dma := ta.sma(close, custom_length)
else if custom_ma_type == "EMA"
custom_dma := ta.ema(close, custom_length)

// Step 7: Plot the Dynamic Moving Average
plot(dma, color=color.blue, linewidth=2, title="Dynamic MA")
plot(timeframe.period == custom_timeframe ? custom_dma : na, color=color.red, linewidth=2, title="Custom Timeframe DMA")

// Optional: Add a label to display the current DMA length, type, and detected timeframe for debugging
if barstate.islast
label_text = "Timeframe: " + timeframe.period +
"\nDMA Length: " + str.tostring(dma_length) +
"\nMA Type: " + ma_type
if timeframe.period == custom_timeframe
label_text := label_text +
"\nCustom DMA Length: " + str.tostring(custom_length) +
"\nCustom MA Type: " + custom_ma_type
label.new(bar_index, high,
text=label_text,
style=label.style_label_down, color=color.new(color.blue, 80), textcolor=color.white)

Not so much interest for Tradingview (TV)

Here is an interesting indicator that I found, looks great but I would need to see it in live market action before committing.

The first 2.5 days of week March 9 to 13 gave no signals.

I like the way it shows HH, LH, LL, and HL - no matter how long you look at a chart, they may not register in your brain.


The last 2.5 days gave 4 signals, which I clearly marked, IF you could hang on after the first 2, you are rewarded.


When the market is open, you have hopefully, a feel for the state of what the heck is going on!


OH, the name is Market Structure Breakout which might help if that is your style!


And it's in the FREE section

Just wanted to explain a bit more about my comment about knowing or having a feel for what the market is doing.

I will zoom down to 5M chart, I watch things like Inside Days and previous day's Highs and Lows, mainly for breakout levels.

And sessions time of course, and New York can be continuation or retracement, even reversals; just know the context, news etc.

These are marked on the chart, and in this case, they worked, and seeing price trending, they give confidence to hold the trade.

Hope that helps someone, sometime in the future.

Commentary on chart, doesn't look like much but check the price scale

If you ever traded Gold, you know

Do you like to know the trading sessions?

Do you use 1st hour for breakout strategy?

Check this out = FREE

https://www.tradingview.com/script/Y...ons-Zeiierman/



Good Luck

This may be of interest to some, A.I. and all that jazz...



Good Luck, Have Fun, Don't Die

I wrote a TV script but cannot publish it as I do not have a paid subscription, maybe on Black Friday sales in November. I could share here by copy & paste if anyone is interested and can use Pine Editor to compile. Here is what it looks like, can you see the function of slightly different color coding from regular Strat indicators?
Learn more about STRAT - https://www.forexfactory.com/thread/...9#post15779269

Trade accordingly

ok. i wanna see it.