Prompts to find the best AI for

creating trading strategies in

PineScript
My Michael Ionita

Easy Prompt
ChatGPT o1 Code
Claude 3.5 Code
HorizonAI Code
Gemini 1.5 Pro
DeepSeek R1 Code
Grok3 + Think Code
Medium Prompt
ChatGPT o1 Code
Claude 3.5 Code
HorizonAI Code
Gemini 1.5 Pro Code
DeepSeek R1 Code
Grok3 + Think Code
Hard Prompt v1
ChatGPT o1 Code
Claude 3.5 Code
HorizonAI Code
Gemini 1.5 Pro Code
DeepSeek R1 Code
Grok3 + Think Code
Hard Prompt v2
ChatGPT o1 Code
Claude 3.5 Code
HorizonAI Code
Gemini 1.5 Pro Code
DeepSeek R1 Code
Grok3 + Think Code

Easy Prompt
You are a professional PineScript v6 developer.
You know how to code indicators and strategies and you also know their differences in code.
I need your help to turn a TradingView indicator into a strategy please.

When to buy and when to sell:

- Go long when price closes above the upper Bollinger Band.
- Close long when price closed below the lower Bollinger Band.
Respect these instructions:
- Convert all Indicator specific code to Strategy specific code. Don't use any code that a TradingView Strategy
won't support. Especially timeframes and gaps. Define those in code so they are semantically the same as
before.
- Preserve the timeframe logic if there is one. Fill gaps.
- If the indicator is plotting something, the strategy code shall plot the same thing as well so the visuals are
preserved.
- Don't trigger a short. Simply go Long and Flat.
- Always use 100% of capital.
- Set commission to 0.1%.
- Set slippage to 0.
- strategy.commission.percent and strategy.slippage don't exist in PineScript. Please avoid this mistake. Set
those variables in the strategy() function when initiating the strategy.
- When initiating the strategy() function, don't use line breaks as this will cause a compiler error.
- Leave all other strategy settings to default values (aka. don't set them at all).
- Never use lookahead_on because that’s cheating.
- Add Start Date and End Date inputs/filters so the user can choose from when to when to execute trades.
Start with 1st January 2018 and go to 31st December 2069.
- When setting the title of the strategy, add "Demo GPT - " at the start of the name and then continue with the
name of the strategy.

This is the code of the Indicator you shall migrate to a TradingView Strategy:
//@version=5
indicator(shorttitle="BB", title="Bollinger Bands", overlay=true, timeframe="", timeframe_gaps=true)
length = input.int(20, minval=1)
maType = input.string("SMA", "Basis MA Type", options = ["SMA", "EMA", "SMMA (RMA)", "WMA", "VWMA"])
src = input(close, title="Source")
mult = input.float(2.0, minval=0.001, maxval=50, title="StdDev")

ma(source, length, _type) =>

switch _type
"SMA" => ta.sma(source, length)
"EMA" => ta.ema(source, length)
"SMMA (RMA)" => ta.rma(source, length)
"WMA" => ta.wma(source, length)
"VWMA" => ta.vwma(source, length)

basis = ma(src, length, maType)

dev = mult * ta.stdev(src, length)
upper = basis + dev
lower = basis - dev
offset = input.int(0, "Offset", minval = -500, maxval = 500, display = display.data_window)
plot(basis, "Basis", color=#2962FF, offset = offset)
p1 = plot(upper, "Upper", color=#F23645, offset = offset)
p2 = plot(lower, "Lower", color=#089981, offset = offset)
fill(p1, p2, title = "Background", color=color.rgb(33, 150, 243, 95))

ChatGPT o1 Code
//@version=5
strategy(title="Demo GPT - Bollinger Bands", overlay=true, margin_long=100, margin_short=100,
initial_capital=100000, commission_type=strategy.commission.percent, commission_value=0.1,
default_qty_type=strategy.percent_of_equity, default_qty_value=100, pyramiding=1)
// Inputs
length = input.int(20, minval=1, title="Length")
maType = input.string("SMA", "Basis MA Type", options = ["SMA", "EMA", "SMMA (RMA)", "WMA", "VWMA"])
src = input(close, title="Source")
mult = input.float(2.0, minval=0.001, maxval=50, title="StdDev")
offset = input.int(0, "Offset", minval = -500, maxval = 500, display = display.data_window)

// Date range inputs

startDate = input.time(timestamp("2018-01-01"), title="Start Date")
endDate = input.time(timestamp("2069-12-31"), title="End Date")

// Basis MA function
ma(source, length, _type) =>
switch _type
"SMA" => ta.sma(source, length)
"EMA" => ta.ema(source, length)
"SMMA (RMA)" => ta.rma(source, length)
"WMA" => ta.wma(source, length)
"VWMA" => ta.vwma(source, length)

// Calculate Bollinger Bands

basis = ma(src, length, maType)
dev = mult * ta.stdev(src, length)
upper = basis + dev
lower = basis - dev

// Plot the bands

plot(basis, "Basis", color=#2962FF, offset=offset)
p1 = plot(upper, "Upper", color=#F23645, offset=offset)
p2 = plot(lower, "Lower", color=#089981, offset=offset)
fill(p1, p2, title="Background", color=color.rgb(33, 150, 243, 95))

// Trading logic: Only execute trades within the selected date range
inDateRange = time >= startDate and time <= endDate

longCondition = close > upper and inDateRange

exitCondition = close < lower and inDateRange

if longCondition and strategy.position_size <= 0

strategy.entry("Long", strategy.long)

if exitCondition and strategy.position_size > 0

strategy.close("Long")

Claude 3.5 Code

//@version=5
strategy("Demo GPT - Bollinger Bands Strategy", overlay=true, margin_long=100, margin_short=100,
initial_capital=100000, commission_type=strategy.commission.percent, commission_value=0.1,
default_qty_type=strategy.percent_of_equity, default_qty_value=100, pyramiding=1)

// Date Range Inputs

startDate = input.time(timestamp("2018-01-01"), "Start Date")
endDate = input.time(timestamp("2069-12-31"), "End Date")

// BB Inputs
length = input.int(20, minval=1)
maType = input.string("SMA", "Basis MA Type", options=["SMA", "EMA", "SMMA (RMA)", "WMA", "VWMA"])
src = input(close, title="Source")
mult = input.float(2.0, minval=0.001, maxval=50, title="StdDev")

// MA Function
ma(source, length, _type) =>
switch _type
"SMA" => ta.sma(source, length)
"EMA" => ta.ema(source, length)
"SMMA (RMA)" => ta.rma(source, length)
"WMA" => ta.wma(source, length)
"VWMA" => ta.vwma(source, length)

// Calculate BB values
basis = ma(src, length, maType)
dev = mult * ta.stdev(src, length)
upper = basis + dev
lower = basis - dev

// Plotting (preserved from indicator)

offset = input.int(0, "Offset", minval=-500, maxval=500, display=display.data_window)
plot(basis, "Basis", color=#2962FF, offset=offset)
p1 = plot(upper, "Upper", color=#F23645, offset=offset)
p2 = plot(lower, "Lower", color=#089981, offset=offset)
fill(p1, p2, title="Background", color=color.rgb(33, 150, 243, 95))

// Trading conditions
longCondition = ta.crossover(close, upper)
exitLongCondition = ta.crossunder(close, lower)

// Execute trades within date range

if time >= startDate and time <= endDate
if longCondition
strategy.entry("Long", strategy.long)
if exitLongCondition
strategy.close("Long")

HorizonAI Code
//@version=5
strategy("Demo GPT - Bollinger Bands Strategy", overlay=true, margin_long=100, margin_short=100,
initial_capital=100000, commission_type=strategy.commission.percent, commission_value=0.1,
default_qty_type=strategy.percent_of_equity, default_qty_value=100, pyramiding=1)

// Date Inputs
startDate = input.time(timestamp("1 January 2018 00:00 +0000"), "Start Date")
endDate = input.time(timestamp("31 Dec 2069 23:59 +0000"), "End Date")
timeCondition = time >= startDate and time <= endDate

// BB Inputs
length = input.int(20, minval=1)
maType = input.string("SMA", "Basis MA Type", options = ["SMA", "EMA", "SMMA (RMA)", "WMA", "VWMA"])
src = input(close, title="Source")
mult = input.float(2.0, minval=0.001, maxval=50, title="StdDev")
offset = input.int(0, "Offset", minval = -500, maxval = 500, display = display.data_window)

// MA Function
ma(source, length, _type) =>
switch _type
"SMA" => ta.sma(source, length)
"EMA" => ta.ema(source, length)
"SMMA (RMA)" => ta.rma(source, length)
"WMA" => ta.wma(source, length)
"VWMA" => ta.vwma(source, length)

// Calculate BB
basis = ma(src, length, maType)
dev = mult * ta.stdev(src, length)
upper = basis + dev
lower = basis - dev

// Plotting
plot(basis, "Basis", color=#2962FF, offset = offset)
p1 = plot(upper, "Upper", color=#F23645, offset = offset)
p2 = plot(lower, "Lower", color=#089981, offset = offset)
fill(p1, p2, title = "Background", color=color.rgb(33, 150, 243, 95))

// Strategy Logic
longCondition = close > upper and timeCondition
exitLongCondition = close < lower and timeCondition

if (longCondition)
strategy.entry("BB Long", strategy.long)

if (exitLongCondition)
strategy.close("BB Long")

Gemini 1.5 Pro

//@version=5
strategy(title="Demo GPT - Bollinger Bands Strategy", overlay=true, margin_long=100, margin_short=100,
initial_capital=100000, commission_type=strategy.commission.percent, commission_value=0.1,
default_qty_type=strategy.percent_of_equity, default_qty_value=100, pyramiding=1)

// Inputs
length = input.int(20, minval=1)
maType = input.string("SMA", "Basis MA Type", options = ["SMA", "EMA", "SMMA (RMA)", "WMA", "VWMA"])
src = input(close, title="Source")
mult = input.float(2.0, minval=0.001, maxval=50, title="StdDev")
offset = input.int(0, "Offset", minval = -500, maxval = 500, display = display.data_window)
startDate = input.time(timestamp("2018-01-01"), title="Start Date")
endDate = input.time(timestamp("2069-12-31"), title="End Date")

// Time filter
time_cond = time >= startDate and time <= endDate

// MA function
ma(source, length, _type) =>
switch _type
"SMA" => ta.sma(source, length)
"EMA" => ta.ema(source, length)
"SMMA (RMA)" => ta.rma(source, length)
"WMA" => ta.wma(source, length)
"VWMA" => ta.vwma(source, length)

// Bollinger Band calculations

basis = ma(src, length, maType)
dev = mult * ta.stdev(src, length)
upper = basis + dev
lower = basis - dev

// Entry and exit conditions

longCondition = ta.crossover(close, upper)
closeLongCondition = ta.crossunder(close, lower)

// Entry and exit orders

if time_cond
if (longCondition)
strategy.entry("Long", strategy.long)
if (strategy.position_size > 0 and closeLongCondition)
strategy.close("Long")

// Plotting
plot(basis, "Basis", color=#2962FF, offset = offset)
p1 = plot(upper, "Upper", color=#F23645, offset = offset)
p2 = plot(lower, "Lower", color=#089981, offset = offset)
fill(p1, p2, title = "Background", color=color.rgb(33, 150, 243, 95))

DeepSeek R1 Code
//@version=5
strategy(shorttitle="BB Strategy", title="Demo GPT - Bollinger Bands Strategy", overlay=true,
commission_type=strategy.commission.percent, commission_value=0.1, slippage=0,
default_qty_type=strategy.percent_of_equity, default_qty_value=100)

// Inputs
length = input.int(20, minval=1, title="Length")
maType = input.string("SMA", "Basis MA Type", options = ["SMA", "EMA", "SMMA (RMA)", "WMA", "VWMA"])
src = input(close, title="Source")
mult = input.float(2.0, minval=0.001, maxval=50, title="StdDev")
offset = input.int(0, "Offset", minval = -500, maxval = 500)

// Date Range Filter

startDate = input.time(title="Start Date", defval=timestamp("2018-01-01"), confirm=false)
endDate = input.time(title="End Date", defval=timestamp("2069-12-31"), confirm=false)
timeAllowed = time >= startDate and time <= endDate
// MA Type Selector
ma(source, length, _type) =>
switch _type
"SMA" => ta.sma(source, length)
"EMA" => ta.ema(source, length)
"SMMA (RMA)" => ta.rma(source, length)
"WMA" => ta.wma(source, length)
"VWMA" => ta.vwma(source, length)

// Calculations
basis = ma(src, length, maType)
dev = mult * ta.stdev(src, length)
upper = basis + dev
lower = basis - dev

// Preserve Indicator Plots

plot(basis, "Basis", color=#2962FF, offset=offset)
p1 = plot(upper, "Upper", color=#F23645, offset=offset)
p2 = plot(lower, "Lower", color=#089981, offset=offset)
fill(p1, p2, title="Background", color=color.rgb(33, 150, 243, 95))

// Strategy Logic
enterLong = ta.crossover(close, upper) and timeAllowed
exitLong = ta.crossunder(close, lower) and timeAllowed

if enterLong
strategy.entry("Long", strategy.long)
if exitLong
strategy.close("Long")

Grok3 + Think Code

//@version=5
strategy(title="Demo GPT - Bollinger Bands Strategy", overlay=true, process_orders_on_close=true,
default_qty_type=strategy.percent_of_equity, default_qty_value=100,
commission_type=strategy.commission.percent, commission_value=0.1)

// Inputs
length = input.int(20, minval=1)
maType = input.string("SMA", "Basis MA Type", options = ["SMA", "EMA", "SMMA (RMA)", "WMA", "VWMA"])
src = input(close, title="Source")
mult = input.float(2.0, minval=0.001, maxval=50, title="StdDev")
offset = input.int(0, "Offset", minval = -500, maxval = 500, display = display.data_window)

// Moving Average Function

ma(source, length, _type) =>
switch _type
"SMA" => ta.sma(source, length)
"EMA" => ta.ema(source, length)
"SMMA (RMA)" => ta.rma(source, length)
"WMA" => ta.wma(source, length)
"VWMA" => ta.vwma(source, length)
// Calculate Bollinger Bands
basis = ma(src, length, maType)
dev = mult * ta.stdev(src, length)
upper = basis + dev
lower = basis - dev

// Plotting
plot(basis, "Basis", color=#2962FF, offset = offset)
p1 = plot(upper, "Upper", color=#F23645, offset = offset)
p2 = plot(lower, "Lower", color=#089981, offset = offset)
fill(p1, p2, title = "Background", color=color.rgb(33, 150, 243, 95))

// Date Range Inputs

start_year = input.int(2018, "Start Year")
start_month = input.int(1, "Start Month")
start_day = input.int(1, "Start Day")
end_year = input.int(2069, "End Year")
end_month = input.int(12, "End Month")
end_day = input.int(31, "End Day")

// Calculate Timestamps
start_timestamp = timestamp(start_year, start_month, start_day, 0, 0)
end_timestamp = timestamp(end_year, end_month, end_day, 23, 59)

// Check if current bar is within the date range

in_date_range = time >= start_timestamp and time <= end_timestamp

// Trading Logic
if in_date_range and src > upper
strategy.entry("Long", strategy.long)

if in_date_range and src < lower

strategy.close("Long")

Medium Prompt
You are a professional PineScript v6 developer.
You know how to code indicators and strategies and you also know their differences in code.
I need your help to improve this TradingView strategy please.

Add this indicator to this strategy and remove the plots and fills it has:
//@version=5
indicator(title="Stochastic RSI", shorttitle="Stoch RSI", format=format.price, precision=2, timeframe="",
timeframe_gaps=true)
smoothK = input.int(3, "K", minval=1)
smoothD = input.int(3, "D", minval=1)
lengthRSI = input.int(14, "RSI Length", minval=1)
lengthStoch = input.int(14, "Stochastic Length", minval=1)
src = input(close, title="RSI Source")
rsi1 = ta.rsi(src, lengthRSI)
k = ta.sma(ta.stoch(rsi1, rsi1, rsi1, lengthStoch), smoothK)
d = ta.sma(k, smoothD)
plot(k, "K", color=#2962FF)
plot(d, "D", color=#FF6D00)
h0 = hline(80, "Upper Band", color=#787B86)
hline(50, "Middle Band", color=color.new(#787B86, 50))
h1 = hline(20, "Lower Band", color=#787B86)
fill(h0, h1, color=color.rgb(33, 150, 243, 90), title="Background")

Now improve the strategy like so:

- Open long position as soon as the gaussian channel is green, the close price is above the high gaussian
channel band and when the Stochastic RSI is above 80 or below 20.
- Close long positions when the close price crosses the high gaussian channel band to the downside.

Respect these instructions:

- For the indicator we are adding, preserve the timeframe logic it has if there is one, fill gaps whenever
possible.
- Keep all existing plots & visuals (don't remove them).
- Don't trigger a short. Simply go Long and Flat.
- Always use 100% of capital.
- Set commission to 0.1%.
- Set slippage to 0.
- strategy.commission.percent and strategy.slippage don't exist in PineScript. Please avoid this mistake. Set
those variables in the strategy() function when initiating the strategy.
- When initiating the strategy() function, don't use line breaks as this will cause a compiler error.
- Leave all other strategy settings to default values (aka. don't set them at all).
- Never use lookahead_on because that’s cheating.
- Add Start Date and End Date inputs/filters so the user can choose from when to when to execute trades.
Start with 1st January 2018 and go to 31st December 2069.
- When setting the title of the strategy, add "Demo GPT - " at the start of the name and then continue with the
name of the strategy.

This is the code of the TradingView Strategy to improve with the instructions above:
//@version=5
strategy(title="Gaussian Channel Strategy v3.0", overlay=true, calc_on_every_tick=false, initial_capital=1000,
default_qty_type=strategy.percent_of_equity, default_qty_value=100,
commission_type=strategy.commission.percent, commission_value=0.1, slippage=3,
fill_orders_on_standard_ohlc=true)

//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Gaussian Channel Indicator - courtesy of @DonovanWall
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------

// Date condition inputs

startDate = input.time(timestamp("1 January 2018 00:00 +0000"), "Start Date", group="Main Algo Settings")
endDate = input.time(timestamp("31 Dec 2069 23:59 +0000"), "End Date", group="Main Algo Settings")
timeCondition = time >= startDate and time <= endDate

// This study is an experiment utilizing the Ehlers Gaussian Filter technique combined with lag reduction
techniques and true range to analyze trend activity.
// Gaussian filters, as Ehlers explains it, are simply exponential moving averages applied multiple times.
// First, beta and alpha are calculated based on the sampling period and number of poles specified. The
maximum number of poles available in this script is 9.
// Next, the data being analyzed is given a truncation option for reduced lag, which can be enabled with
"Reduced Lag Mode".
// Then the alpha and source values are used to calculate the filter and filtered true range of the dataset.
// Filtered true range with a specified multiplier is then added to and subtracted from the filter, generating a
channel.
// Lastly, a one pole filter with a N pole alpha is averaged with the filter to generate a faster filter, which can be
enabled with "Fast Response Mode".

// Custom bar colors are included.

// Note: Both the sampling period and number of poles directly affect how much lag the indicator has, and how
smooth the output is.
// Larger inputs will result in smoother outputs with increased lag, and smaller inputs will have noisier
outputs with reduced lag.
// For the best results, I recommend not setting the sampling period any lower than the number of poles + 1.
Going lower truncates the equation.

//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Updates:
// Huge shoutout to @e2e4mfck for taking the time to improve the calculation method!
// -> migrated to v4
// -> pi is now calculated using trig identities rather than being explicitly defined.
// -> The filter calculations are now organized into functions rather than being individually defined.
// -> Revamped color scheme.

//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Functions - courtesy of @e2e4mfck
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------

// 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.
// Initial weight _m1 is a pole number and equal to _i
_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 := math.pow(_a, _i) * nz(_s) +
_i * _x * nz(_f[1]) - (_i >= 2 ?
_m2 * math.pow(_x, 2) * nz(_f[2]) : 0) + (_i >= 3 ?
_m3 * math.pow(_x, 3) * nz(_f[3]) : 0) - (_i >= 4 ?
_m4 * math.pow(_x, 4) * nz(_f[4]) : 0) + (_i >= 5 ?
_m5 * math.pow(_x, 5) * nz(_f[5]) : 0) - (_i >= 6 ?
_m6 * math.pow(_x, 6) * nz(_f[6]) : 0) + (_i >= 7 ?
_m7 * math.pow(_x, 7) * nz(_f[7]) : 0) - (_i >= 8 ?
 _m8 * math.pow(_x, 8) * nz(_f[8]) : 0) + (_i == 9 ?
_m9 * math.pow(_x, 9) * nz(_f[9]) : 0)

// 9 var declaration fun

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]

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

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

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

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

// True Range Multiplier

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

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

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

// Beta and Alpha Components

beta = (1 - math.cos(4*math.asin(1)/per)) / (math.pow(1.414, 2/N) - 1)
alpha = - beta + math.sqrt(math.pow(beta, 2) + 2*beta)

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

// Data
srcdata = modeLag ? src + (src - src[lag]) : src
trdata = modeLag ? ta.tr(true) + (ta.tr(true) - ta.tr(true)[lag]) : ta.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

// Colors
color1 = #0aff68
color2 = #00752d
color3 = #ff0a5a
color4 = #990032
fcolor = filt > filt[1] ? #0aff68 : filt < filt[1] ? #ff0a5a : #cccccc
barcolor = (src > src[1]) and (src > filt) and (src < hband) ? #0aff68 : (src > src[1]) and (src >= hband) ? #0aff1b
: (src <= src[1]) and (src > filt) ? #00752d :
(src < src[1]) and (src < filt) and (src > lband) ? #ff0a5a : (src < src[1]) and (src <= lband) ? #ff0a11 :
(src >= src[1]) and (src < filt) ? #990032 : #cccccc

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

// Filter Plot
filtplot = plot(filt, title="Filter", color=fcolor, linewidth=3)

// Band Plots
hbandplot = plot(hband, title="Filtered True Range High Band", color=fcolor)
lbandplot = plot(lband, title="Filtered True Range Low Band", color=fcolor)

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

// Bar Color
barcolor(barcolor)

// Trading Logic
longCondition = ta.crossover(close, hband) and timeCondition
closeAllCondition = ta.crossunder(close, hband) and timeCondition

if longCondition
strategy.entry("long", strategy.long)

if closeAllCondition
strategy.close("long")
ChatGPT o1 Code
//@version=5
strategy(title="Demo GPT - Gaussian Channel Strategy v3.0", overlay=true, margin_long=100,
margin_short=100, initial_capital=100000, commission_type=strategy.commission.percent,
commission_value=0.1, default_qty_type=strategy.percent_of_equity, default_qty_value=100, pyramiding=1)

//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Date condition inputs
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
startDate = input.time(timestamp("1 January 2018 00:00 +0000"), "Start Date", inline="dt")
endDate = input.time(timestamp("31 Dec 2069 23:59 +0000"), "End Date", inline="dt")
timeCondition = time >= startDate and time <= endDate

//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Stochastic RSI Integration (from provided indicator) - without its plots/fills
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
smoothK = input.int(3, "K", minval=1)
smoothD = input.int(3, "D", minval=1)
lengthRSI = input.int(14, "RSI Length", minval=1)
lengthStoch = input.int(14, "Stochastic Length", minval=1)
rsiSrc = input.source(close, "RSI Source")

rsi1 = ta.rsi(rsiSrc, lengthRSI)

k = ta.sma(ta.stoch(rsi1, rsi1, rsi1, lengthStoch), smoothK)
d = ta.sma(k, smoothD)
// Stoch RSI plots and fills removed as instructed

//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Gaussian Channel Indicator - courtesy of @DonovanWall
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------

// This study uses Ehlers Gaussian Filter technique combined with lag reduction and true range to analyze
trend activity.

// Functions - courtesy of @e2e4mfck

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)
_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
 _f := math.pow(_a, _i)*nz(_s)
+ _i * _x * nz(_f[1])
- (_i >= 2 ? _m2*math.pow(_x, 2)*nz(_f[2]) : 0)
+ (_i >= 3 ? _m3*math.pow(_x, 3)*nz(_f[3]) : 0)
- (_i >= 4 ? _m4*math.pow(_x, 4)*nz(_f[4]) : 0)
+ (_i >= 5 ? _m5*math.pow(_x, 5)*nz(_f[5]) : 0)
- (_i >= 6 ? _m6*math.pow(_x, 6)*nz(_f[6]) : 0)
+ (_i >= 7 ? _m7*math.pow(_x, 7)*nz(_f[7]) : 0)
- (_i >= 8 ? _m8*math.pow(_x, 8)*nz(_f[8]) : 0)
+ (_i == 9 ? _m9*math.pow(_x, 9)*nz(_f[9]) : 0)

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 >= 7 ? 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]

//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Inputs
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
src = input(defval=hlc3, title="Source")
int N = input.int(defval=4, title="Poles", minval=1, maxval=9)
int per = input.int(defval=144, title="Sampling Period", minval=2)
float mult = input.float(defval=1.414, title="Filtered True Range Multiplier", minval=0)
bool modeLag = input.bool(defval=false, title="Reduced Lag Mode")
bool modeFast = input.bool(defval=false, title="Fast Response Mode")

//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Definitions
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
beta = (1 - math.cos(4*math.asin(1)/per)) / (math.pow(1.414, 2/N) - 1)
alpha = -beta + math.sqrt(math.pow(beta, 2) + 2*beta)
lag = (per - 1)/(2*N)

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

// Filtered Values
[filtn, filt1] = f_pole(alpha, srcdata, N)
[filtntr, filt1tr] = f_pole(alpha, trdata, N)
filt = modeFast ? (filtn + filt1)/2 : filtn
filttr = modeFast ? (filtntr + filt1tr)/2 : filtntr

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

// Colors
fcolor = filt > filt[1] ? #0aff68 : filt < filt[1] ? #ff0a5a : #cccccc
barcolor = (src > src[1]) and (src > filt) and (src < hband) ? #0aff68 :
(src > src[1]) and (src >= hband) ? #0aff1b :
(src <= src[1]) and (src > filt) ? #00752d :
(src < src[1]) and (src < filt) and (src > lband) ? #ff0a5a :
(src < src[1]) and (src <= lband) ? #ff0a11 :
(src >= src[1]) and (src < filt) ? #990032 : #cccccc

//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Outputs
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
filtplot = plot(filt, title="Filter", color=fcolor, linewidth=3)
hbandplot = plot(hband, title="Filtered True Range High Band", color=fcolor)
lbandplot = plot(lband, title="Filtered True Range Low Band", color=fcolor)
fill(hbandplot, lbandplot, title="Channel Fill", color=color.new(fcolor, 80))
barcolor(barcolor)

//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Trading Logic
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Conditions:
// - Open long if timeCondition, gaussian channel is green (filt > filt[1]), close > hband, and Stoch RSI > 80 or <
20
// - Close long if close crosses hband to the downside
longCondition = timeCondition and (filt > filt[1]) and (close > hband) and ((k > 80) or (k < 20))
closeAllCondition = timeCondition and ta.crossunder(close, hband)

if longCondition
strategy.entry("long", strategy.long)

if closeAllCondition
strategy.close("long")

Claude 3.5 Code

//@version=5
strategy(title="Demo GPT - Gaussian Channel with Stoch RSI Strategy", overlay=true, margin_long=100,
margin_short=100, initial_capital=100000, commission_type=strategy.commission.percent,
commission_value=0.1, default_qty_type=strategy.percent_of_equity, default_qty_value=100, pyramiding=1)

// Date inputs
startDate = input.time(timestamp("1 January 2018 00:00 +0000"), "Start Date", group="Main Algo Settings")
endDate = input.time(timestamp("31 Dec 2069 23:59 +0000"), "End Date", group="Main Algo Settings")
timeCondition = time >= startDate and time <= endDate

// Stochastic RSI Inputs

smoothK = input.int(3, "Stoch RSI K", minval=1, group="Stoch RSI Settings")
smoothD = input.int(3, "Stoch RSI D", minval=1, group="Stoch RSI Settings")
lengthRSI = input.int(14, "RSI Length", minval=1, group="Stoch RSI Settings")
lengthStoch = input.int(14, "Stochastic Length", minval=1, group="Stoch RSI Settings")
rsiSource = input(close, title="RSI Source", group="Stoch RSI Settings")

// Calculate Stochastic RSI

rsi1 = ta.rsi(rsiSource, lengthRSI)
k = ta.sma(ta.stoch(rsi1, rsi1, rsi1, lengthStoch), smoothK)
d = ta.sma(k, smoothD)

// Gaussian Channel Functions

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)
_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
_f := math.pow(_a, _i) * nz(_s) +
_i * _x * nz(_f[1]) - (_i >= 2 ?
_m2 * math.pow(_x, 2) * nz(_f[2]) : 0) + (_i >= 3 ?
_m3 * math.pow(_x, 3) * nz(_f[3]) : 0) - (_i >= 4 ?
_m4 * math.pow(_x, 4) * nz(_f[4]) : 0) + (_i >= 5 ?
_m5 * math.pow(_x, 5) * nz(_f[5]) : 0) - (_i >= 6 ?
_m6 * math.pow(_x, 6) * nz(_f[6]) : 0) + (_i >= 7 ?
_m7 * math.pow(_x, 7) * nz(_f[7]) : 0) - (_i >= 8 ?
_m8 * math.pow(_x, 8) * nz(_f[8]) : 0) + (_i == 9 ?
_m9 * math.pow(_x, 9) * nz(_f[9]) : 0)

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]

// Gaussian Channel Inputs

src = input(hlc3, title="Source", group="Gaussian Channel Settings")
N = input.int(4, title="Poles", minval=1, maxval=9, group="Gaussian Channel Settings")
per = input.int(144, title="Sampling Period", minval=2, group="Gaussian Channel Settings")
mult = input.float(1.414, title="Filtered True Range Multiplier", minval=0, group="Gaussian Channel Settings")
modeLag = input.bool(false, title="Reduced Lag Mode", group="Gaussian Channel Settings")
modeFast = input.bool(false, title="Fast Response Mode", group="Gaussian Channel Settings")
// Gaussian Channel Calculations
beta = (1 - math.cos(4*math.asin(1)/per)) / (math.pow(1.414, 2/N) - 1)
alpha = -beta + math.sqrt(math.pow(beta, 2) + 2*beta)
lag = (per - 1)/(2*N)
srcdata = modeLag ? src + (src - src[lag]) : src
trdata = modeLag ? ta.tr(true) + (ta.tr(true) - ta.tr(true)[lag]) : ta.tr(true)
[filtn, filt1] = f_pole(alpha, srcdata, N)
[filtntr, filt1tr] = f_pole(alpha, trdata, N)
filt = modeFast ? (filtn + filt1)/2 : filtn
filttr = modeFast ? (filtntr + filt1tr)/2 : filtntr
hband = filt + filttr*mult
lband = filt - filttr*mult

// Colors
color1 = #0aff68
color2 = #00752d
color3 = #ff0a5a
color4 = #990032
fcolor = filt > filt[1] ? #0aff68 : filt < filt[1] ? #ff0a5a : #cccccc
barcolor = (src > src[1]) and (src > filt) and (src < hband) ? #0aff68 : (src > src[1]) and (src >= hband) ? #0aff1b
: (src <= src[1]) and (src > filt) ? #00752d :
(src < src[1]) and (src < filt) and (src > lband) ? #ff0a5a : (src < src[1]) and (src <= lband) ? #ff0a11 :
(src >= src[1]) and (src < filt) ? #990032 : #cccccc

// Plotting
filtplot = plot(filt, title="Filter", color=fcolor, linewidth=3)
hbandplot = plot(hband, title="Filtered True Range High Band", color=fcolor)
lbandplot = plot(lband, title="Filtered True Range Low Band", color=fcolor)
fill(hbandplot, lbandplot, title="Channel Fill", color=color.new(fcolor, 80))
barcolor(barcolor)

// Trading Conditions
isGreenChannel = filt > filt[1]
isPriceAboveHighBand = close > hband
isStochExtreme = k >= 80 or k <= 20
longCondition = isGreenChannel and isPriceAboveHighBand and isStochExtreme and timeCondition
closeAllCondition = ta.crossunder(close, hband) and timeCondition

// Strategy Execution
if longCondition
strategy.entry("long", strategy.long)

if closeAllCondition
strategy.close("long")

HorizonAI Code
//@version=5
strategy(title="Demo GPT - Gaussian Channel with Stoch RSI Strategy", overlay=true, margin_long=100,
margin_short=100, initial_capital=100000, commission_type=strategy.commission.percent,
commission_value=0.1, default_qty_type=strategy.percent_of_equity, default_qty_value=100, pyramiding=1)

// Date condition inputs

startDate = input.time(timestamp("1 January 2018 00:00 +0000"), "Start Date", group="Main Algo Settings")
endDate = input.time(timestamp("31 Dec 2069 23:59 +0000"), "End Date", group="Main Algo Settings")
timeCondition = time >= startDate and time <= endDate

// Stochastic RSI Inputs

smoothK = input.int(3, "K", minval=1, group="Stoch RSI Settings")
smoothD = input.int(3, "D", minval=1, group="Stoch RSI Settings")
lengthRSI = input.int(14, "RSI Length", minval=1, group="Stoch RSI Settings")
lengthStoch = input.int(14, "Stochastic Length", minval=1, group="Stoch RSI Settings")
rsiSource = input(close, title="RSI Source", group="Stoch RSI Settings")

// Calculate Stochastic RSI

rsi1 = ta.rsi(rsiSource, lengthRSI)
k = ta.sma(ta.stoch(rsi1, rsi1, rsi1, lengthStoch), smoothK)
d = ta.sma(k, smoothD)

// Gaussian Channel Settings

src = input(hlc3, title="Source", group="Gaussian Channel Settings")
N = input.int(4, "Poles", minval=1, maxval=9, group="Gaussian Channel Settings")
per = input.int(144, "Sampling Period", minval=2, group="Gaussian Channel Settings")
mult = input.float(1.414, "Filtered True Range Multiplier", minval=0, group="Gaussian Channel Settings")
modeLag = input.bool(false, "Reduced Lag Mode", group="Gaussian Channel Settings")
modeFast = input.bool(false, "Fast Response Mode", group="Gaussian Channel Settings")

// Gaussian Channel Functions

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)
_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
_f := math.pow(_a, _i) * nz(_s) +
_i * _x * nz(_f[1]) - (_i >= 2 ?
_m2 * math.pow(_x, 2) * nz(_f[2]) : 0) + (_i >= 3 ?
_m3 * math.pow(_x, 3) * nz(_f[3]) : 0) - (_i >= 4 ?
_m4 * math.pow(_x, 4) * nz(_f[4]) : 0) + (_i >= 5 ?
_m5 * math.pow(_x, 5) * nz(_f[5]) : 0) - (_i >= 6 ?
_m6 * math.pow(_x, 6) * nz(_f[6]) : 0) + (_i >= 7 ?
_m7 * math.pow(_x, 7) * nz(_f[7]) : 0) - (_i >= 8 ?
_m8 * math.pow(_x, 8) * nz(_f[8]) : 0) + (_i == 9 ?
_m9 * math.pow(_x, 9) * nz(_f[9]) : 0)

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]

// Gaussian Channel Calculations

beta = (1 - math.cos(4*math.asin(1)/per)) / (math.pow(1.414, 2/N) - 1)
alpha = -beta + math.sqrt(math.pow(beta, 2) + 2*beta)
lag = (per - 1)/(2*N)

srcdata = modeLag ? src + (src - src[lag]) : src

trdata = modeLag ? ta.tr(true) + (ta.tr(true) - ta.tr(true)[lag]) : ta.tr(true)

[filtn, filt1] = f_pole(alpha, srcdata, N)

[filtntr, filt1tr] = f_pole(alpha, trdata, N)

filt = modeFast ? (filtn + filt1)/2 : filtn

filttr = modeFast ? (filtntr + filt1tr)/2 : filtntr

hband = filt + filttr*mult

lband = filt - filttr*mult

// Colors
fcolor = filt > filt[1] ? #0aff68 : filt < filt[1] ? #ff0a5a : #cccccc
isGreen = filt > filt[1]

// Plots
plot(filt, "Filter", color=fcolor, linewidth=3)
hbandplot = plot(hband, "High Band", color=fcolor)
lbandplot = plot(lband, "Low Band", color=fcolor)
fill(hbandplot, lbandplot, color=color.new(fcolor, 80))

// Trading Conditions
stochSignal = k > 80 or k < 20
longCondition = isGreen and close > hband and stochSignal and timeCondition
closeCondition = ta.crossunder(close, hband) and timeCondition

// Execute Strategy
if longCondition
strategy.entry("Long", strategy.long)

if closeCondition
strategy.close("Long")

Gemini 1.5 Pro Code

Only got errors :(

DeepSeek R1 Code
//@version=5
strategy(title="Demo GPT - Gaussian Channel Strategy v3.0", overlay=true, calc_on_every_tick=false,
initial_capital=1000, default_qty_type=strategy.percent_of_equity, default_qty_value=100,
commission_type=strategy.commission.percent, commission_value=0.1, slippage=0,
fill_orders_on_standard_ohlc=true)
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Gaussian Filter Functions (Must be declared first)
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
f_filt9x(_a, _s, _i) =>
var int _m2 = 0, var int _m3 = 0, var int _m4 = 0, var int _m5 = 0, var int _m6 = 0,
var int _m7 = 0, var int _m8 = 0, var int _m9 = 0, var float _f = .0
_x = 1 - _a
_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
_f := math.pow(_a, _i) * nz(_s) + _i * _x * nz(_f[1]) - (_i >= 2 ? _m2 * math.pow(_x, 2) * nz(_f[2]) : 0) + (_i >=
3 ? _m3 * math.pow(_x, 3) * nz(_f[3]) : 0) - (_i >= 4 ? _m4 * math.pow(_x, 4) * nz(_f[4]) : 0) + (_i >= 5 ? _m5 *
math.pow(_x, 5) * nz(_f[5]) : 0) - (_i >= 6 ? _m6 * math.pow(_x, 6) * nz(_f[6]) : 0) + (_i >= 7 ? _m7 *
math.pow(_x, 7) * nz(_f[7]) : 0) - (_i >= 8 ? _m8 * math.pow(_x, 8) * nz(_f[8]) : 0) + (_i == 9 ? _m9 *
math.pow(_x, 9) * nz(_f[9]) : 0)

f_pole(_a, _s, _i) =>

_f1 = f_filt9x(_a, _s, 1)
_f2 = _i >= 2 ? f_filt9x(_a, _s, 2) : 0.0
_f3 = _i >= 3 ? f_filt9x(_a, _s, 3) : 0.0
_f4 = _i >= 4 ? f_filt9x(_a, _s, 4) : 0.0
_f5 = _i >= 5 ? f_filt9x(_a, _s, 5) : 0.0
_f6 = _i >= 6 ? f_filt9x(_a, _s, 6) : 0.0
_f7 = _i >= 7 ? f_filt9x(_a, _s, 7) : 0.0
_f8 = _i >= 8 ? f_filt9x(_a, _s, 8) : 0.0
_f9 = _i == 9 ? f_filt9x(_a, _s, 9) : 0.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]

//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Inputs
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Date Range
startDate = input.time(timestamp("1 January 2018 00:00 +0000"), "Start Date", group="Main Settings")
endDate = input.time(timestamp("31 Dec 2069 23:59 +0000"), "End Date", group="Main Settings")
timeCondition = time >= startDate and time <= endDate

// Gaussian Channel
int poles = input.int(4, "Poles", 1, 9, group="Gaussian Channel")
int period = input.int(144, "Sampling Period", 2, group="Gaussian Channel")
float mult = input.float(1.414, "True Range Multiplier", group="Gaussian Channel")
bool reducedLag = input.bool(false, "Reduced Lag Mode", group="Gaussian Channel")
bool fastResponse = input.bool(false, "Fast Response Mode", group="Gaussian Channel")
// Stochastic RSI
smoothK = input.int(3, "K", 1, group="Stochastic RSI")
smoothD = input.int(3, "D", 1, group="Stochastic RSI")
lengthRSI = input.int(14, "RSI Length", 1, group="Stochastic RSI")
lengthStoch = input.int(14, "Stochastic Length", 1, group="Stochastic RSI")

//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Calculations
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Gaussian Channel
beta = (1 - math.cos(4*math.asin(1)/period)) / (math.pow(1.414, 2/poles) - 1)
alpha = -beta + math.sqrt(math.pow(beta, 2) + 2*beta)
lag = (period - 1)/(2*poles)

src = hlc3
srcData = reducedLag ? src + (src - src[lag]) : src
trData = reducedLag ? ta.tr + (ta.tr - ta.tr[lag]) : ta.tr

[filterMain, filter1] = f_pole(alpha, srcData, poles)

[filterTRMain, filterTR1] = f_pole(alpha, trData, poles)

finalFilter = fastResponse ? (filterMain + filter1)/2 : filterMain

finalTR = fastResponse ? (filterTRMain + filterTR1)/2 : filterTRMain

hband = finalFilter + finalTR * mult

lband = finalFilter - finalTR * mult

// Stochastic RSI
rsi = ta.rsi(close, lengthRSI)
k = ta.sma(ta.stoch(rsi, rsi, rsi, lengthStoch), smoothK)
d = ta.sma(k, smoothD)

//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Trading Logic
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
gaussianGreen = finalFilter > finalFilter[1]
priceAbove = close > hband
stochCondition = k > 80 or k < 20

longCondition = gaussianGreen and priceAbove and stochCondition and timeCondition

exitCondition = ta.crossunder(close, hband) and timeCondition

strategy.entry("Long", strategy.long, when=longCondition)

strategy.close("Long", when=exitCondition)

//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Visuals
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
filterColor = finalFilter > finalFilter[1] ? #0aff68 : #ff0a5a
plot(finalFilter, "Filter", filterColor, 2)
plot(hband, "High Band", filterColor)
plot(lband, "Low Band", filterColor)
fill(plot(hband), plot(lband), color.new(filterColor, 90), "Channel Fill")

Grok3 + Think Code

//@version=5
strategy(title="Demo GPT - Gaussian Channel Strategy v3.0", overlay=true, calc_on_every_tick=false,
initial_capital=1000, default_qty_type=strategy.percent_of_equity, default_qty_value=100,
commission_type=strategy.commission.percent, commission_value=0.1, slippage=0,
fill_orders_on_standard_ohlc=true)

//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Date Condition Inputs
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
startDate = input.time(timestamp("1 January 2018 00:00 +0000"), "Start Date", group="Main Algo Settings")
endDate = input.time(timestamp("31 Dec 2069 23:59 +0000"), "End Date", group="Main Algo Settings")
timeCondition = time >= startDate and time <= endDate

//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Gaussian Channel Indicator - courtesy of @DonovanWall
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------

// This study is an experiment utilizing the Ehlers Gaussian Filter technique combined with lag reduction
techniques and true range to analyze trend activity.
// Gaussian filters, as Ehlers explains it, are simply exponential moving averages applied multiple times.
// First, beta and alpha are calculated based on the sampling period and number of poles specified. The
maximum number of poles available in this script is 9.
// Next, the data being analyzed is given a truncation option for reduced lag, which can be enabled with
"Reduced Lag Mode".
// Then the alpha and source values are used to calculate the filter and filtered true range of the dataset.
// Filtered true range with a specified multiplier is then added to and subtracted from the filter, generating a
channel.
// Lastly, a one pole filter with a N pole alpha is averaged with the filter to generate a faster filter, which can be
enabled with "Fast Response Mode".

// Custom bar colors are included.

// Note: Both the sampling period and number of poles directly affect how much lag the indicator has, and how
smooth the output is.
// Larger inputs will result in smoother outputs with increased lag, and smaller inputs will have noisier
outputs with reduced lag.
// For the best results, I recommend not setting the sampling period any lower than the number of poles + 1.
Going lower truncates the equation.
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Updates:
// Huge shoutout to @e2e4mfck for taking the time to improve the calculation method!
// -> migrated to v4
// -> pi is now calculated using trig identities rather than being explicitly defined.
// -> The filter calculations are now organized into functions rather than being individually defined.
// -> Revamped color scheme.

//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Functions - courtesy of @e2e4mfck
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------

// 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.
// Initial weight _m1 is a pole number and equal to _i
_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 := math.pow(_a, _i) * nz(_s) +
_i * _x * nz(_f[1]) - (_i >= 2 ?
_m2 * math.pow(_x, 2) * nz(_f[2]) : 0) + (_i >= 3 ?
_m3 * math.pow(_x, 3) * nz(_f[3]) : 0) - (_i >= 4 ?
_m4 * math.pow(_x, 4) * nz(_f[4]) : 0) + (_i >= 5 ?
_m5 * math.pow(_x, 5) * nz(_f[5]) : 0) - (_i >= 6 ?
_m6 * math.pow(_x, 6) * nz(_f[6]) : 0) + (_i >= 7 ?
_m7 * math.pow(_x, 7) * nz(_f[7]) : 0) - (_i >= 8 ?
_m8 * math.pow(_x, 8) * nz(_f[8]) : 0) + (_i == 9 ?
_m9 * math.pow(_x, 9) * nz(_f[9]) : 0)

// 9 var declaration fun

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

// Source
src = input(defval=hlc3, title="Source", group="Gaussian Channel Settings")

// Poles
int N = input.int(defval=4, title="Poles", minval=1, maxval=9, group="Gaussian Channel Settings")

// Period
int per = input.int(defval=144, title="Sampling Period", minval=2, group="Gaussian Channel Settings")

// True Range Multiplier

float mult = input.float(defval=1.414, title="Filtered True Range Multiplier", minval=0, group="Gaussian
Channel Settings")

// Lag Reduction
bool modeLag = input.bool(defval=false, title="Reduced Lag Mode", group="Gaussian Channel Settings")
bool modeFast = input.bool(defval=false, title="Fast Response Mode", group="Gaussian Channel Settings")

//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Stochastic RSI Inputs
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
smoothK = input.int(3, "K", minval=1, group="Stochastic RSI Settings")
smoothD = input.int(3, "D", minval=1, group="Stochastic RSI Settings")
lengthRSI = input.int(14, "RSI Length", minval=1, group="Stochastic RSI Settings")
lengthStoch = input.int(14, "Stochastic Length", minval=1, group="Stochastic RSI Settings")
srcStoch = input(close, title="RSI Source", group="Stochastic RSI Settings")

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

// Beta and Alpha Components

beta = (1 - math.cos(4*math.asin(1)/per)) / (math.pow(1.414, 2/N) - 1)
alpha = - beta + math.sqrt(math.pow(beta, 2) + 2*beta)

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

// Data
srcdata = modeLag ? src + (src - src[lag]) : src
trdata = modeLag ? ta.tr(true) + (ta.tr(true) - ta.tr(true)[lag]) : ta.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

// Colors
color1 = #0aff68
color2 = #00752d
color3 = #ff0a5a
color4 = #990032
fcolor = filt > filt[1] ? #0aff68 : filt < filt[1] ? #ff0a5a : #cccccc
barcolor = (src > src[1]) and (src > filt) and (src < hband) ? #0aff68 : (src > src[1]) and (src >= hband) ? #0aff1b
: (src <= src[1]) and (src > filt) ? #00752d :
(src < src[1]) and (src < filt) and (src > lband) ? #ff0a5a : (src < src[1]) and (src <= lband) ? #ff0a11 :
(src >= src[1]) and (src < filt) ? #990032 : #cccccc

// Stochastic RSI Calculations

rsi1 = ta.rsi(srcStoch, lengthRSI)
k = ta.sma(ta.stoch(rsi1, rsi1, rsi1, lengthStoch), smoothK)
d = ta.sma(k, smoothD)

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

// Filter Plot
filtplot = plot(filt, title="Filter", color=fcolor, linewidth=3)

// Band Plots
hbandplot = plot(hband, title="Filtered True Range High Band", color=fcolor)
lbandplot = plot(lband, title="Filtered True Range Low Band", color=fcolor)

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

// Bar Color
barcolor(barcolor)

//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
// Trading Logic
//-------------------------------------------------------------------------------------------------------------------------------------------------
----------------
longCondition = (filt > filt[1]) and (close > hband) and (k > 80 or k < 20) and timeCondition
closeAllCondition = ta.crossunder(close, hband) and timeCondition

if longCondition
strategy.entry("long", strategy.long)
if closeAllCondition
strategy.close("long")

Hard Prompt v1
I’d like you to create a PineScript v6 trading strategy based on the Gaussian Channel and add Stochastic RSI
to avoid bad trades. I want to be able to copy paste it into TradingView, save it and it runs.

Long only, no shorting. Never use lookahead_on. Always trade with 100% of equity. 0.1% commission. 0 ticks
slippage. Start trading on 2018-01-01 until 2069-01-01. Avoid compiler errors. Use only functions that exist
and PineScript v6 supports.

ChatGPT o1 Code
//@version=5
strategy("Gaussian Channel Stoch RSI Strategy", overlay=true, margin_long=100, margin_short=100,
initial_capital=100000, commission_type=strategy.commission.percent, commission_value=0.1,
default_qty_type=strategy.percent_of_equity, default_qty_value=100, pyramiding=1)

// User inputs
length = input.int(50, "Gaussian Length")
mult = input.float(2.0, "Channel Multiplier", step=0.1)
rsiLength = input.int(14, "RSI Length")
stochLength = input.int(14, "Stoch RSI Length")
kLength = input.int(3, "K Smoothing")
dLength = input.int(3, "D Smoothing")

// Calculate Gaussian-based moving average (approximation by cascaded SMAs)

f_gaussian(src, len) =>
sm1 = ta.sma(src, len)
sm2 = ta.sma(sm1, len)
sm3 = ta.sma(sm2, len)
sm4 = ta.sma(sm3, len)
// Weighted sum to approximate gaussian curve
(sm1 + 2*sm2 + 3*sm3 + 4*sm4) / (1+2+3+4)

gauss = f_gaussian(close, length)

std = ta.stdev(close, length)
up = gauss + std * mult
down = gauss - std * mult

// Stoch RSI Calculation

rsi = ta.rsi(close, rsiLength)
lowestRSI = ta.lowest(rsi, stochLength)
highestRSI = ta.highest(rsi, stochLength)
stochRsi = (rsi - lowestRSI) / (highestRSI - lowestRSI) * 100.0
k = ta.sma(stochRsi, kLength)
d = ta.sma(k, dLength)

// Conditions
bar_time = time
inDateRange = bar_time >= timestamp("2018-01-01T00:00:00") and bar_time < timestamp("2069-01-
01T00:00:00")
// Entry condition: For example, enter long when price breaks above upper band and Stoch RSI is oversold (k
< 20 and k < d)
enterLong = inDateRange and close > up and k < 20 and k < d

// Exit condition: For example, exit when price crosses below the gaussian midline
exitLong = inDateRange and close < gauss

// Strategy logic
if enterLong
strategy.entry("Long", strategy.long)

if exitLong
strategy.close("Long")

Claude 3.5 Code

//@version=5
strategy("Gaussian Channel with Stoch RSI Strategy", overlay=true, margin_long=100, margin_short=100,
initial_capital=100000, commission_type=strategy.commission.percent, commission_value=0.1,
default_qty_type=strategy.percent_of_equity, default_qty_value=100, pyramiding=1)

// Input parameters
len = input.int(20, "Gaussian Channel Length")
mult = input.float(2.0, "Channel Multiplier")
srcInput = input(close, "Source")

// Stoch RSI Parameters

rsiPeriod = input.int(14, "RSI Length")
stochPeriod = input.int(14, "Stochastic Length")
smoothK = input.int(3, "Smooth K")
smoothD = input.int(3, "Smooth D")
oversoldLevel = input.float(20, "Oversold Level")
overboughtLevel = input.float(80, "Overbought Level")

// Calculate Gaussian Channel

basis = ta.sma(srcInput, len)
dev = ta.stdev(srcInput, len)
upper = basis + dev * mult
lower = basis - dev * mult

// Calculate Stochastic RSI

rsi1 = ta.rsi(close, rsiPeriod)
stoch_rsi = ta.stoch(rsi1, rsi1, rsi1, stochPeriod)
k = ta.sma(stoch_rsi, smoothK)
d = ta.sma(k, smoothD)

// Plot indicators
plot(basis, "Basis", color=color.blue)
plot(upper, "Upper", color=color.red)
plot(lower, "Lower", color=color.red)

// Trading conditions
longCondition = ta.crossover(close, lower) and k < oversoldLevel
exitCondition = ta.crossunder(close, upper) or k > overboughtLevel

// Date range filter

inDateRange = time >= timestamp("2018-01-01") and time <= timestamp("2069-01-01")

// Execute trades
if inDateRange
if longCondition
strategy.entry("Long", strategy.long)
if exitCondition
strategy.close("Long")

// Plot trade signals

plotshape(longCondition, "Buy Signal", location=location.belowbar, color=color.green, style=shape.triangleup,
size=size.small)
plotshape(exitCondition, "Sell Signal", location=location.abovebar, color=color.red, style=shape.triangledown,
size=size.small)

HorizonAI Code
//@version=5
strategy("Gaussian Channel Strategy", overlay=true, initial_capital=10000,
default_qty_type=strategy.percent_of_equity, default_qty_value=100,
commission_type=strategy.commission.percent, commission_value=0.1)

// Date Range
start_date = timestamp("2018-01-01")
end_date = timestamp("2069-01-01")

// Gaussian Channel Parameters

length = input(20, "Channel Length")
mult = input(2.0, "Channel Multiplier")

// Calculate Gaussian Channel

basis = ta.sma(close, length)
dev = mult * ta.stdev(close, length)
upper = basis + dev
lower = basis - dev

// Stochastic RSI Parameters

rsi_length = input(14, "RSI Length")
stoch_length = input(14, "Stochastic Length")
smooth_k = input(3, "Smooth K")
smooth_d = input(3, "Smooth D")
oversold = input(20, "Oversold Level")
overbought = input(80, "Overbought Level")

// Calculate Stochastic RSI

rsi1 = ta.rsi(close, rsi_length)
k = ta.sma(ta.stoch(rsi1, rsi1, rsi1, stoch_length), smooth_k)
d = ta.sma(k, smooth_d)

// Entry Conditions
long_condition = close > lower and close < upper and k < oversold and k > k[1]
// Plot Gaussian Channel
plot(basis, "Basis", color=color.blue)
plot(upper, "Upper", color=color.red)
plot(lower, "Lower", color=color.red)

// Trading Logic
if time >= start_date and time <= end_date
if long_condition
strategy.entry("Long", strategy.long)

if k > overbought
strategy.close("Long")

// Plot entry signals

plotshape(long_condition, "Long Entry", shape.triangleup, location.belowbar, color.green, size=size.small)

Gemini 1.5 Pro Code

//@version=5
strategy("Gaussian Channel with Stochastic RSI", overlay=true, margin_long=100, margin_short=100,
initial_capital=100000, commission_type=strategy.commission.percent, commission_value=0.1,
default_qty_type=strategy.percent_of_equity, default_qty_value=100, pyramiding=1)

// Date range for trading

start_date = timestamp(2018, 1, 1, 0, 0)
end_date = timestamp(2069, 1, 1, 0, 0)

// Gaussian Channel Calculation

period = 20
mult = 2.0
src = close
basis = ta.sma(src, period)
dev = mult * ta.stdev(src, period)
upper = basis + dev
lower = basis - dev

// Stochastic RSI Calculation

lengthRSI = 14
lengthStoch = 14
smoothK = 3
smoothD = 3
rsi = ta.rsi(close, lengthRSI)
k = ta.sma(ta.stoch(rsi, rsi, rsi, lengthStoch), smoothK)
d = ta.sma(k, smoothD)

// Entry and Exit Conditions

longCondition = close > lower and k > 20 and d > 20 and time >= start_date and time <= end_date
exitCondition = close < basis or k < 80 and d < 80

// Check for date range

if time >= start_date and time <= end_date
// Entry
if longCondition
 strategy.entry("Long", strategy.long)

// Exit
if strategy.position_size > 0 and exitCondition
strategy.close("Long")

// Plot Gaussian Channel

plot(basis, color=color.blue)
plot(upper, color=color.gray)
plot(lower, color=color.gray)

// Plot Stochastic RSI

plot(k, color=color.orange)
plot(d, color=color.purple)

// Plot Buy/Sell Signals for visualization

plotshape(longCondition, style=shape.triangleup, color=color.green, location=location.belowbar,
size=size.small)
plotshape(exitCondition and strategy.position_size > 0, style=shape.triangledown, color=color.red,
location=location.abovebar, size=size.small)

DeepSeek R1 Code
//@version=5
strategy("Gaussian Channel with Stochastic RSI", overlay=true, initial_capital=10000,
default_qty_type=strategy.percent_of_equity, default_qty_value=100,
commission_type=strategy.commission.percent, commission_value=0.1, slippage=0)

// Gaussian Channel Parameters

gc_length = input.int(20, "Gaussian Channel Length", minval=1)
gc_mult = input.float(2.0, "Gaussian Channel Multiplier", minval=0.1)

middle = ta.ema(close, gc_length)

stdev = ta.stdev(close, gc_length)
upper = middle + gc_mult * stdev
lower = middle - gc_mult * stdev

// Plot Channels
plot(middle, "Middle Line", color=color.blue)
plot(upper, "Upper Channel", color=color.red)
plot(lower, "Lower Channel", color=color.green)

// Stochastic RSI Parameters

rsi_length = input.int(14, "RSI Length", minval=1)
stoch_length = input.int(14, "Stochastic Length", minval=1)
smooth_k = input.int(3, "Smooth %K", minval=1)
oversold = input.int(20, "Oversold Level", minval=0, maxval=100)
overbought = input.int(80, "Overbought Level", minval=0, maxval=100)

// Calculate Stochastic RSI

rsi = ta.rsi(close, rsi_length)
lowest_rsi = ta.lowest(rsi, stoch_length)
highest_rsi = ta.highest(rsi, stoch_length)
stoch_rsi = highest_rsi != lowest_rsi ? (rsi - lowest_rsi) / (highest_rsi - lowest_rsi) * 100 : 0
k = ta.sma(stoch_rsi, smooth_k)

// Entry/Exit Conditions
enterLong = ta.crossover(close, lower) and ta.crossover(k, oversold)
exitLong = ta.crossover(close, upper) or ta.crossunder(k, overbought)

// Strategy Execution
if (time >= timestamp(2018, 01, 01, 0, 0) and time < timestamp(2069, 01, 01, 0, 0))
if enterLong
strategy.entry("Long", strategy.long)
if exitLong
strategy.close("Long")

Grok3 + Think Code

//@version=5
strategy("Gaussian Channel Strategy", overlay=true, default_qty_type=strategy.percent_of_equity,
default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.1)

// Input parameters
length = input.int(20, "Gaussian Channel Length", minval=1)
sigmaFactor = input.float(4.0, "Sigma Factor", minval=0.1)
multiplier = input.float(2.0, "Band Multiplier", minval=0.1)
rsiLength = input.int(14, "RSI Length", minval=1)
stochLength = input.int(14, "Stochastic Length", minval=1)
overboughtLevel = input.float(80.0, "Overbought Level", minval=0, maxval=100)

// Calculate sigma for Gaussian filter

sigma = length / sigmaFactor

// Function to calculate Gaussian-weighted mean and standard deviation

gaussianMeanStdev(series float src, int length, float sigma) =>
float[] weights = array.new_float(length)
float center = (length - 1) / 2.0
for i = 0 to length - 1
float dist = i - center
float w = math.exp(- (dist * dist) / (2 * sigma * sigma))
array.set(weights, i, w)
float sumWeights = array.sum(weights)
for i = 0 to length - 1
array.set(weights, i, array.get(weights, i) / sumWeights)
float mean = 0.0
for i = 0 to length - 1
mean += src[i] * array.get(weights, i)
float variance = 0.0
for i = 0 to length - 1
variance += array.get(weights, i) * math.pow(src[i] - mean, 2)
float stdev = math.sqrt(variance)
[mean, stdev]

// Calculate Gaussian Channel

[mean, stdev] = gaussianMeanStdev(close, length, sigma)
upper = mean + multiplier * stdev
lower = mean - multiplier * stdev
// Calculate Stochastic RSI
rsi = ta.rsi(close, rsiLength)
stochRSI = ta.stoch(rsi, rsi, rsi, stochLength)

// Define trading window (2018-01-01 to 2069-01-01)

inTradeWindow = time >= timestamp("2018-01-01T00:00:00") and time <= timestamp("2069-01-01T00:00:00")

// Define buy and sell conditions

buyCondition = close > mean and stochRSI < overboughtLevel
sellCondition = close < mean

// Execute strategy
if inTradeWindow and buyCondition
strategy.entry("Long", strategy.long)
if inTradeWindow and sellCondition
strategy.close("Long")

// Plot Gaussian Channel for visualization

plot(mean, color=color.blue, title="Midline")
plot(upper, color=color.green, title="Upper Band")
plot(lower, color=color.red, title="Lower Band")

Hard Prompt v2
I’d like you to create a PineScript v6 trading strategy based on the Gaussian Channel and add Stochastic RSI
to avoid bad trades. I want to be able to copy paste it into TradingView, save it and it runs. Gaussian Channel
shall indicate the overall trend, up or down. StochasticRSI shall help to avoid unnecessary trades. Buy when
price closed above the upper Gaussian Channel line AND when Stochastic is up. Sell when price closes below
the upper Gaussian Channel line.

Long only, no shorting. Never use lookahead_on. Always trade with 100% of equity. 0.1% commission. 0 ticks
slippage. Start trading on 2018-01-01 until 2069-01-01. Avoid compiler errors. Use only functions that exist
and PineScript v6 supports.

ChatGPT o1 Code
//@version=5
strategy("Gaussian Channel + Stoch RSI Strategy", overlay=true, margin_long=100, margin_short=100,
initial_capital=100000, commission_type=strategy.commission.percent, commission_value=0.1,
default_qty_type=strategy.percent_of_equity, default_qty_value=100, pyramiding=1)

// User Inputs
length = input.int(20, "Gaussian Length", minval=5)
multiplier = input.float(2.0, "Channel Multiplier", step=0.1)
rsiLength = input.int(14, "RSI Length", minval=1)
stochLength= input.int(14, "Stoch RSI Length", minval=1)
kLength = input.int(3, "Stoch K Smoothing", minval=1)
dLength = input.int(3, "Stoch D Smoothing", minval=1)

// Gaussian Weighted Moving Average Function

f_gaussian(source, length) =>
half = (length - 1) / 2.0
sum = 0.0
 norm = 0.0
// Gaussian standard deviation chosen as length/6 for a smooth curve
denom = (length / 6.0) * (length / 6.0)
for i = 0 to length - 1
x = i - half
w = math.exp(-(x * x) / (2 * denom))
sum += source[i] * w
norm += w
sum / norm

// Gaussian Weighted Standard Deviation Function

f_gaussian_std(source, length) =>
half = (length - 1) / 2.0
gavg = f_gaussian(source, length)
sum = 0.0
norm = 0.0
denom = (length / 6.0) * (length / 6.0)
for i = 0 to length - 1
x = i - half
w = math.exp(-(x * x)/(2*denom))
diff = source[i] - gavg
sum += diff * diff * w
norm += w
math.sqrt(sum/norm)

// Compute Gaussian Channel

gaussMid = f_gaussian(close, length)
gaussStd = f_gaussian_std(close, length)
gaussUpper = gaussMid + gaussStd * multiplier
gaussLower = gaussMid - gaussStd * multiplier

// Stochastic RSI Calculation

rsi = ta.rsi(close, rsiLength)
rsiLowest = ta.lowest(rsi, stochLength)
rsiHighest = ta.highest(rsi, stochLength)
stoch = 100 * (rsi - rsiLowest) / math.max(rsiHighest - rsiLowest, 1e-10)
k = ta.sma(stoch, kLength)
d = ta.sma(k, dLength)

// Conditions
// Long entry: Price closes above upper Gaussian line AND Stoch RSI K > D (stochastic is "up")
longCondition = close > gaussUpper and k > d

// Exit condition: Price closes below upper Gaussian line

exitCondition = close < gaussUpper

// Only trade in the specified date range

inDateRange = time >= timestamp("2018-01-01T00:00:00") and time < timestamp("2069-01-01T00:00:00")

// Submit Orders
if inDateRange
if longCondition and strategy.position_size <= 0
strategy.entry("Long", strategy.long)
if exitCondition and strategy.position_size > 0
 strategy.close("Long")

// Plot Gaussian Channel

plot(gaussMid, "Gaussian Mid", color=color.new(color.yellow, 0))
plot(gaussUpper, "Gaussian Upper", color=color.new(color.green, 0))
plot(gaussLower, "Gaussian Lower", color=color.new(color.red, 0))

Claude 3.5 Code

//@version=5
strategy("Gaussian Channel with Stochastic RSI Strategy", overlay=true, margin_long=100,
margin_short=100, initial_capital=100000, commission_type=strategy.commission.percent,
commission_value=0.1, default_qty_type=strategy.percent_of_equity, default_qty_value=100, pyramiding=1)

// Input parameters
channelLen = input.int(20, "Gaussian Channel Length")
mult = input.float(2.0, "Channel Multiplier")
stochLen = input.int(14, "Stochastic RSI Length")
smoothK = input.int(3, "Stoch RSI Smooth K")
smoothD = input.int(3, "Stoch RSI Smooth D")
rsiLen = input.int(14, "RSI Length")

// Calculate Gaussian Channel

basis = ta.sma(close, channelLen)
dev = mult * ta.stdev(close, channelLen)
upper = basis + dev
lower = basis - dev

// Calculate Stochastic RSI

rsi1 = ta.rsi(close, rsiLen)
stoch_rsi = ta.stoch(rsi1, rsi1, rsi1, stochLen)
k = ta.sma(stoch_rsi, smoothK)
d = ta.sma(k, smoothD)

// Plot indicators
plot(basis, "Basis", color=color.blue)
plot(upper, "Upper", color=color.red)
plot(lower, "Lower", color=color.red)

// Plot Stochastic RSI on separate pane

plot(k, "Stoch RSI %K", color=color.blue, display=display.none)
plot(d, "Stoch RSI %D", color=color.red, display=display.none)

// Trading conditions
stochRising = k > d
closedAboveUpper = close > upper
closedBelowUpper = close < upper

// Set date range

startDate = timestamp("2018-01-01T00:00:00")
endDate = timestamp("2069-01-01T00:00:00")
inDateRange = time >= startDate and time <= endDate

// Entry conditions
longCondition = closedAboveUpper and stochRising and inDateRange and strategy.position_size == 0

// Exit conditions
exitLong = closedBelowUpper and strategy.position_size > 0

// Execute trades
if (longCondition)
strategy.entry("Long", strategy.long)

if (exitLong)
strategy.close("Long")

HorizonAI Code
//@version=5
strategy("Gaussian Channel with StochRSI Strategy", overlay=true, margin_long=100, margin_short=100,
initial_capital=100000, commission_type=strategy.commission.percent, commission_value=0.1,
default_qty_type=strategy.percent_of_equity, default_qty_value=100, pyramiding=1)

// Input parameters
length = input.int(20, "Gaussian Channel Length")
mult = input.float(2.0, "Gaussian Channel Multiplier")
stochLength = input.int(14, "Stoch RSI Length")
stochRsiOverbought = input.int(80, "Stoch RSI Overbought")
stochRsiOversold = input.int(20, "Stoch RSI Oversold")

// Calculate Gaussian Channel

basis = ta.sma(close, length)
dev = ta.stdev(close, length)
upper = basis + dev * mult
lower = basis - dev * mult

// Calculate Stochastic RSI

rsi = ta.rsi(close, stochLength)
stoch = ta.stoch(rsi, rsi, rsi, stochLength)
stochK = ta.sma(stoch, 3)
stochD = ta.sma(stochK, 3)

// Trading conditions
longCondition = close > upper and stochK > stochD and stochK > stochRsiOversold
exitLong = close < upper

// Date range
inDateRange = time >= timestamp("2018-01-01") and time <= timestamp("2069-01-01")

// Plot indicators
plot(basis, "Basis", color=color.blue)
plot(upper, "Upper", color=color.green)
plot(lower, "Lower", color=color.red)

// Strategy entries and exits

if inDateRange
if longCondition
 strategy.entry("Long", strategy.long)
if exitLong
strategy.close("Long")

// Plot signals
plotshape(longCondition, "Buy", shape.triangleup, location.belowbar, color.green, size=size.small)
plotshape(exitLong, "Sell", shape.triangledown, location.abovebar, color.red, size=size.small)

// Additional indicator values in Data Window

plotchar(stochK, "Stoch K", "", location.top)
plotchar(stochD, "Stoch D", "", location.top)

Gemini 1.5 Pro Code

Errors. No useful code given.

DeepSeek R1 Code
//@version=5
strategy("Gaussian Channel with Stochastic RSI Strategy", overlay=true,
commission_type=strategy.commission.percent, commission_value=0.1, slippage=0,
default_qty_type=strategy.percent_of_equity, default_qty_value=100, process_orders_on_close=true)

// Gaussian Channel Inputs

lengthGC = input.int(20, "Gaussian Channel Length", minval=1)
multiplier = input.float(2.0, "Standard Deviation Multiplier", minval=0.1)

// Calculate Gaussian Channel

basis = ta.ema(close, lengthGC)
deviation = multiplier * ta.stdev(close, lengthGC)
upperChannel = basis + deviation
lowerChannel = basis - deviation

// Plot Gaussian Channel

plot(basis, "Basis", color=color.blue)
plot(upperChannel, "Upper Channel", color=color.green)
plot(lowerChannel, "Lower Channel", color=color.red)

// Stochastic RSI Inputs

rsiLength = input.int(14, "RSI Length", minval=1)
stochLength = input.int(14, "Stochastic Length", minval=1)
smoothK = input.int(3, "Smooth K", minval=1)
smoothD = input.int(3, "Smooth D", minval=1)

// Calculate RSI
rsi = ta.rsi(close, rsiLength)

// Calculate Stochastic RSI

lowestRSI = ta.lowest(rsi, stochLength)
highestRSI = ta.highest(rsi, stochLength)
stochRSI = (rsi - lowestRSI) / (highestRSI - lowestRSI) * 100
k = ta.sma(stochRSI, smoothK)
d = ta.sma(k, smoothD)

// Trading Conditions
stochUp = k > d
priceAboveUpper = ta.crossover(close, upperChannel)
priceBelowUpper = ta.crossunder(close, upperChannel)

// Date Range Filter

startDate = input.time(timestamp("2018-01-01"), "Start Date")
endDate = input.time(timestamp("2069-01-01"), "End Date")
timeInRange = time >= startDate and time <= endDate

// Strategy Execution
if timeInRange
strategy.entry("Long", strategy.long, when=priceAboveUpper and stochUp)
strategy.close("Long", when=priceBelowUpper)

Grok3 + Think Code

//@version=5
strategy("Gaussian Channel with Stochastic RSI", overlay=true, default_qty_type=strategy.percent_of_equity,
default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.1)

// Define the trading period

start_time = timestamp("1 January 2018 00:00 +0000")
end_time = timestamp("1 January 2060 00:00 +0000")

// Input parameters
length = input.int(20, title="Gaussian Length", minval=1)
sigma = input.float(5.0, title="Gaussian Sigma", minval=0.1)
multiplier = input.float(2.0, title="Band Multiplier", minval=0.1)
rsi_length = input.int(14, title="RSI Length", minval=1)
stoch_length = input.int(14, title="Stochastic Length", minval=1)

// Gaussian MA calculation
gaussma(src, length, sigma) =>
float sum = 0.0
float sum_weights = 0.0
for i = 0 to length - 1
x = i - (length - 1) / 2.0
weight = math.exp(- (x * x) / (2 * sigma * sigma))
sum += weight * src[i]
sum_weights += weight
sum / sum_weights

basis = gaussma(close, length, sigma)

stdev = ta.stdev(close, length)
upper_band = basis + multiplier * stdev
lower_band = basis - multiplier * stdev

// RSI and Stochastic RSI

rsi_value = ta.rsi(close, rsi_length)
stoch_rsi = ta.stoch(rsi_value, rsi_value, rsi_value, stoch_length)

// Buy signal with time constraint

buy_signal = close > upper_band and stoch_rsi > stoch_rsi[1] and time >= start_time and time <= end_time
if buy_signal
 strategy.entry("Long", strategy.long)

// Sell signal with time constraint

sell_signal = close < upper_band and time >= start_time and time <= end_time
if sell_signal
strategy.close("Long")

// Close any open positions if time exceeds end_time

if time > end_time and strategy.position_size > 0
strategy.close("Long")

// Plotting
plot(basis, color=color.blue, title="Gaussian MA")
plot(upper_band, color=color.red, title="Upper Band")
plot(lower_band, color=color.green, title="Lower Band")