Please Convert Swing Breakout Sequence to PRORTime

Viewing 6 posts - 1 through 6 (of 6 total)

Author

Posts
02/27/2025 at 9:44 AM #244403 quote

yas
Participant

Junior

// This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
// © LuxAlgo

//@version=5
indicator(‘Swing Breakout Sequence [LuxAlgo]’, ‘LuxAlgo – Swing Breakout Sequence’, overlay = true, max_lines_count = 500, max_labels_count = 500, max_polylines_count = 100, max_boxes_count = 500)
//———————————————————————————————————————}
//CONSTANTS & STRINGS & INPUTS
//———————————————————————————————————————{
BULLISH_LEG = 1
BEARISH_LEG = 0

HIGH = 1
LOW = 0

GREEN = #089981
RED = #F23645
GRAY = color.gray
BULLISH_BOX_COLOR = color.new(GREEN,90)
BEARISH_BOX_COLOR = color.new(RED,90)

DOUBLE_GROUP = ‘DETECTION’
STYLE_GROUP = ‘STYLE’

pivotLengthTooltip = ‘Number of candles to confirm a swing high or swing low. A higher number detects larger swings.’
internalLengthTooltip = ‘Number of candles to confirm a internal high or internal low. A lower number detects smaller swings. It must be the same size or smaller than the swing length.’
point4Beyond2Tooltip = ‘It only detects sequences where Point 4 is beyond Point 2.’
detectPoint5Tooltip = ‘Enable/disable Point 5 detection.’
strictThresholdTooltip = ‘Enable/Disable double top/bottom detection at Point 5 within a given threshold. A bigger value detects more sequences.’
showPathTooltip = ‘Enable/disable a line between sequence points.’
bearishBoxColorTooltip = ‘Enable/disable colored boxes for each sequence.’
showLinesTooltip = ‘Enable/disable horizontal lines from each point of the sequence.’
autoColorTooltip = ‘Define the color or enable/disable auto color.’

pivotLengthInput = input.int( 5, ‘Swing Length’, group = ”, tooltip = pivotLengthTooltip, minval = 2)
internalLengthInput = input.int( 2, ‘Internal Length’, group = ”, tooltip = internalLengthTooltip, minval = 2)
point4Beyond2Input = input.bool( false, ‘Point 4 Beyond Point 2’, group = DOUBLE_GROUP, tooltip = point4Beyond2Tooltip)
detectPoint5Input = input.bool( true, ‘Show Point 5’, group = DOUBLE_GROUP, tooltip = detectPoint5Tooltip)
strictModeInput = input.bool( true, ‘Require Equal H/L at Point 5’, group = DOUBLE_GROUP, tooltip = ”, inline = ‘strict’)
strictThresholdInput = input.float( 0.50, ”, group = DOUBLE_GROUP, tooltip = strictThresholdTooltip, inline = ‘strict’, step = 0.05) * ta.atr(200)
showPathInput = input.bool( false, ‘Show Sequence Path’, group = STYLE_GROUP, tooltip = showPathTooltip)
showBoxInput = input.bool( true, ‘Show Boxes’, group = STYLE_GROUP, tooltip = ”, inline = ‘box’)
bullishBoxColorInput = input.color( BULLISH_BOX_COLOR, ”, group = STYLE_GROUP, tooltip = ”, inline = ‘box’)
bearishBoxColorInput = input.color( BEARISH_BOX_COLOR, ”, group = STYLE_GROUP, tooltip = bearishBoxColorTooltip, inline = ‘box’)
showLinesInput = input.bool( true, ‘Show Lines’, group = STYLE_GROUP, tooltip = showLinesTooltip)
defaultColorInput = input.color( GRAY, ‘Default Color’, group = STYLE_GROUP, tooltip = ”, inline = ‘color’)
autoColorInput = input.bool( true, ‘Auto’, group = STYLE_GROUP, tooltip = autoColorTooltip, inline = ‘color’)

//———————————————————————————————————————}
//DATA STRUCTURES & VARIABLES
//———————————————————————————————————————{
// @type Storage UDT for pivot points
// @field barTime Time index of the privot point
// @field barIndex Bar index of the privot point
// @field priceLevel Price level of the pivot point
// @field leg Bullish or bearish bias (1 or 0)
type swingPoint
int barTime
int barIndex
float priceLevel
int swing

// @type Storage UDT for sequences
// @field points storage array for chart.point
type sbs
array<chart.point> points

// @variable storage array for sbs UDTs
var array<sbs> sequences = array.new<sbs>()
// @variable storage array for swingPoint UDTs
var array<swingPoint> swingPoints = array.new<swingPoint>()
// @variable storage array for swingPoint UDTs
var array<swingPoint> internalPoints = array.new<swingPoint>()

// @variable current leg bullish or bearish bias (1 or 0)
int currentLeg = na
// @variable true if there is a new pivot
bool newPivot = na
// @variable true if there is a new pivot low
bool pivotLow = na
// @variable true if there is a new pivot high
bool pivotHigh = na

// @variable current internal leg bullish or bearish bias (1 or 0)
int internalLeg = na
// @variable true if there is a new internal pivot
bool newInternalPivot = na
// @variable true if there is a new internal pivot low
bool internalLow = na
// @variable true if there is a new internal pivot high
bool internalHigh = na

// @variable last swing bar index
var int legIndex = bar_index
// @variable last swing high
var float legHigh = high
// @variable last swing low
var float legLow = low
// @variable last swing bar time
var int legTime = time

// @variable last internal bar index
var int internalLegIndex = bar_index
// @variable last internal high
var float internalLegHigh = high
// @variable last internal low
var float internalLegLow = low
// @variable last internal bar time
var int internalLegTime = time

//———————————————————————————————————————}
//USER-DEFINED FUNCTIONS
//———————————————————————————————————————{
// @function Get the value of the current leg, it can be 0 (bearish) or 1 (bullish)
// @returns int
leg(int length) =>
var leg = 0
newLegHigh = high == ta.highest( length)
newLegLow = low == ta.lowest( length)

if newLegHigh
leg := BULLISH_LEG
else if newLegLow
leg := BEARISH_LEG
leg

// @function Identify whether the current value is the start of a new leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfNewLeg(int leg) => ta.change(leg) != 0

// @function Identify whether the current level is the start of a new bearish leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfBearishLeg(int leg) => ta.change(leg) == -1

// @function Identify whether the current level is the start of a new bullish leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfBullishLeg(int leg) => ta.change(leg) == +1

// @function Parses swingPoint to chart.point
// @param point swingPoint to parse
// @returns chart.point ID
chartPoint(swingPoint point) => chart.point.new(point.barTime, point.barIndex, point.priceLevel)

// @function True if point price is between top and bottom prices
// @param point swingPoint to check
// @param top top swingPoint
// @param bottom bottom swingPoint
// @returns bool
inside(swingPoint point, swingPoint top, swingPoint bottom) => point.priceLevel <= top.priceLevel and point.priceLevel >= bottom.priceLevel

// @function True if point price is between top and bottom prices
// @param point swingPoint to check
// @param top top price
// @param bottom bottom price
// @returns bool
insideLevel(swingPoint point, float top, float bottom) => point.priceLevel <= top and point.priceLevel >= bottom

// @function Detects and returns a swingPoint after point4 with similar price within top and bottom swingPoints
// @param point4 swingPoint to check
// @param top top swingPoint
// @param bottom bottom swingPoint
// @returns swingPoint ID
doubleTopBottom(swingPoint point4,swingPoint top,swingPoint bottom) =>
swingPoint point5 = na
for eachPoint in internalPoints
if eachPoint.barIndex > point4.barIndex and eachPoint.swing == point4.swing and (strictModeInput ? insideLevel(eachPoint,point4.priceLevel+strictThresholdInput,point4.priceLevel-strictThresholdInput) : inside(eachPoint,top,bottom))
point5 := eachPoint
break
point5

// @function Draws last detected SBS
// @returns void
plotLastSBS() =>
color defaultColor = autoColorInput ? chart.fg_color : defaultColorInput
int concurrentSequences = 0
string textFix = ”
sbs lastSBS = sequences.last()
bool bullishSequence = lastSBS.points.first().price > lastSBS.points.get(1).price

for [index,eachSBS] in sequences
if index >= 1
if eachSBS.points.first().index < sequences.get(index – 1).points.last().index
concurrentSequences += 1
else
concurrentSequences := 0

if concurrentSequences > 0
baseString = str.tostring(array.new<string>(concurrentSequences,’\n’))
textFix := str.replace_all(str.substring(baseString,1,str.length(baseString)-1),’, ‘,”)

if showBoxInput
color boxColor = bullishSequence ? BULLISH_BOX_COLOR : BEARISH_BOX_COLOR
float top = bullishSequence ? lastSBS.points.first().price : lastSBS.points.get(1).price
float bottom = bullishSequence ? lastSBS.points.get(1).price : lastSBS.points.first().price

box.new(lastSBS.points.first().time,top,lastSBS.points.last().time,bottom,xloc = xloc.bar_time,bgcolor = boxColor,border_width = 0)

if showPathInput
polyline.new(lastSBS.points, false, false, xloc.bar_time, color.new(defaultColor,50), line_style = line.style_solid, line_width = 2)

if showLinesInput
line.new(lastSBS.points.first().time,lastSBS.points.first().price,lastSBS.points.get(2).time,lastSBS.points.first().price,xloc.bar_time,color = defaultColor,style = line.style_dotted)
line.new(lastSBS.points.get(1).time,lastSBS.points.get(1).price,lastSBS.points.last().time,lastSBS.points.get(1).price,xloc.bar_time,color = defaultColor,style = line.style_dotted)
line.new(lastSBS.points.get(2).time,lastSBS.points.get(2).price,lastSBS.points.last().time,lastSBS.points.get(2).price,xloc.bar_time,color = defaultColor,style = line.style_dotted)
line.new(lastSBS.points.get(3).time,lastSBS.points.get(3).price,lastSBS.points.last().time,lastSBS.points.get(3).price,xloc.bar_time,color = defaultColor,style = line.style_dotted)
line.new(lastSBS.points.get(4).time,lastSBS.points.get(4).price,lastSBS.points.last().time,lastSBS.points.get(4).price,xloc.bar_time,color = defaultColor,style = line.style_dotted)

if detectPoint5Input
line.new(lastSBS.points.get(5).time,lastSBS.points.get(5).price,lastSBS.points.last().time,lastSBS.points.get(5).price,xloc.bar_time,color = defaultColor,style = line.style_dotted)

label.new(lastSBS.points.first(),bullishSequence ? ‘Swing High’ + textFix : textFix + ‘Swing Low’,xloc.bar_time,color = color(na),style = bullishSequence ? label.style_label_down : label.style_label_up,textcolor = defaultColor)
label.new(lastSBS.points.get(1),bullishSequence ? textFix + ‘Swing Low’ : ‘Swing High’ + textFix,xloc.bar_time,color = color(na),style = bullishSequence ? label.style_label_up : label.style_label_down,textcolor = defaultColor)
label.new(lastSBS.points.get(2),bullishSequence ? ‘1’ + textFix : textFix + ‘1’,xloc.bar_time,color = color(na),style = bullishSequence ? label.style_label_down : label.style_label_up,textcolor = defaultColor)
label.new(lastSBS.points.get(3),bullishSequence ? textFix + ‘2’ : ‘2’ + textFix,xloc.bar_time,color = color(na),style = bullishSequence ? label.style_label_up : label.style_label_down,textcolor = defaultColor)
label.new(lastSBS.points.get(4),bullishSequence ? ‘3’ + textFix : textFix + ‘3’,xloc.bar_time,color = color(na),style = bullishSequence ? label.style_label_down : label.style_label_up,textcolor = defaultColor)
label.new(lastSBS.points.get(5),bullishSequence ? textFix + ‘4’ : ‘4’ + textFix,xloc.bar_time,color = color(na),style = bullishSequence ? label.style_label_up : label.style_label_down,textcolor = defaultColor)

if detectPoint5Input
label.new(lastSBS.points.last(),bullishSequence ? textFix + ‘5’ : ‘5’ + textFix,xloc.bar_time,color = color(na),style = bullishSequence ? label.style_label_up : label.style_label_down,textcolor = defaultColor)

// @function Finds and plots sequences with internal swing detector
// @returns void
gatherInternalSBS() =>
size = array.size(swingPoints)

if size >= 6
A = array.get(swingPoints, size – 6)
B = array.get(swingPoints, size – 5)
point1 = array.get(swingPoints, size – 4)
point2 = array.get(swingPoints, size – 3)
point3 = array.get(swingPoints, size – 2)
point4 = array.get(swingPoints, size – 1)

swingPoint doubleTopPoint = na
swingPoint doubleBottomPoint = na

if detectPoint5Input
doubleTopPoint := doubleTopBottom(point4,B,A)
doubleBottomPoint := doubleTopBottom(point4,A,B)

bearishSBS = point1.swing == LOW and inside(point1,A,point3) and inside(point2,B,A) and (point4Beyond2Input ? inside(point4,B,point2) : inside(point4,B,A)) and (detectPoint5Input ? not na(doubleTopPoint) : true)
bullishSBS = point1.swing == HIGH and inside(point1,point3,A) and inside(point2,A,B) and (point4Beyond2Input ? inside(point4,point2,B) : inside(point4,A,B)) and (detectPoint5Input ? not na(doubleBottomPoint) : true)

if bullishSBS or bearishSBS
bool addSequence = false

if sequences.size() == 0
addSequence := true
else if sequences.last().points.first().time < A.barTime
addSequence := true

if addSequence
sequences.push(sbs.new(array.from(chartPoint(A),chartPoint(B),chartPoint(point1),chartPoint(point2),chartPoint(point3),chartPoint(point4))))

if detectPoint5Input
sequences.last().points.push(chartPoint(bullishSBS ? doubleBottomPoint : doubleTopPoint))

plotLastSBS()

// @function Finds and plots sequences with swing detector
// @returns void
gatherSwingSBS() =>
size = array.size(swingPoints)

if size >= 8
A = array.get(swingPoints, size – 8)
B = array.get(swingPoints, size – 7)
point1 = array.get(swingPoints, size – 6)
point2 = array.get(swingPoints, size – 5)
point3 = array.get(swingPoints, size – 4)
point4 = array.get(swingPoints, size – 3)
point5 = array.get(swingPoints, size – 2)
point6 = array.get(swingPoints, size – 1)

bearishSBS = point1.swing == LOW and inside(point1,A,point3) and inside(point2,B,A) and (point4Beyond2Input ? inside(point4,B,point2) : inside(point4,B,A)) and (detectPoint5Input ? (strictModeInput ? insideLevel(point6,point4.priceLevel+strictThresholdInput,point4.priceLevel-strictThresholdInput) : inside(point6,B,A)) : true)
bullishSBS = point1.swing == HIGH and inside(point1,point3,A) and inside(point2,A,B) and (point4Beyond2Input ? inside(point4,point2,B) : inside(point4,A,B)) and (detectPoint5Input ? (strictModeInput ? insideLevel(point6,point4.priceLevel+strictThresholdInput,point4.priceLevel-strictThresholdInput) : inside(point6,A,B)) : true)

if bullishSBS or bearishSBS
bool addSequence = false

if sequences.size() == 0
addSequence := true
else if sequences.last().points.first().time < A.barTime
addSequence := true

if addSequence
sequences.push(sbs.new(array.from(chartPoint(A),chartPoint(B),chartPoint(point1),chartPoint(point2),chartPoint(point3),chartPoint(point4))))

if detectPoint5Input
sequences.last().points.push(chartPoint(point6))

plotLastSBS()

// @function Add a swingPoint point to an array points with a provided max number of elements
// @param point swingPoint to add
// @param points array of swingPoint
// @param size max size of array
// @returns void
addPoint(swingPoint point, array<swingPoint> points, int size) =>
if points.size() >= size
points.shift()

points.push(point)

//———————————————————————————————————————}
//MUTABLE VARIABLES & EXECUTION
//———————————————————————————————————————{
currentLeg := leg(pivotLengthInput)
newPivot := startOfNewLeg(currentLeg)
pivotLow := startOfBullishLeg(currentLeg)
pivotHigh := startOfBearishLeg(currentLeg)

internalLeg := leg(internalLengthInput)
newInternalPivot := startOfNewLeg(internalLeg)
internalLow := startOfBullishLeg(internalLeg)
internalHigh := startOfBearishLeg(internalLeg)

// we execute the logic only once per bar close
if barstate.isconfirmed

// if there is a new swing point execute the logic
if newInternalPivot
priceLevel = internalLegHigh
legBias = HIGH

// if the new swing point is a pivot low change the values
if internalLow
priceLevel := internalLegLow
legBias := LOW

// we store the new swing point
addPoint(swingPoint.new(internalLegTime,internalLegIndex,priceLevel,legBias),internalPoints,pivotLengthInput)

// we check and plot new sequence
gatherInternalSBS()

// we update the current leg values: high, low, index and time
internalLegHigh := internalLow ? high : math.max(high,internalLegHigh)
internalLegLow := internalHigh ? low : math.min(low, internalLegLow)
internalLegIndex := (internalLeg == BULLISH_LEG and internalLegHigh == high) or (internalLeg == BEARISH_LEG and internalLegLow == low) ? bar_index : internalLegIndex
internalLegTime := (internalLeg == BULLISH_LEG and internalLegHigh == high) or (internalLeg == BEARISH_LEG and internalLegLow == low) ? time : internalLegTime

// if there is a new swing point execute the logic
if newPivot
priceLevel = legHigh
legBias = HIGH

// if the new swing point is a pivot low change the values
if pivotLow
priceLevel := legLow
legBias := LOW

// we store the new swing point
addPoint(swingPoint.new(legTime,legIndex,priceLevel,legBias),swingPoints,8)

// we check and plot new sequence
gatherSwingSBS()

// we update the current leg values: high, low, index and time
legHigh := pivotLow ? high : math.max(high,legHigh)
legLow := pivotHigh ? low : math.min(low, legLow)
legIndex := (currentLeg == BULLISH_LEG and legHigh == high) or (currentLeg == BEARISH_LEG and legLow == low) ? bar_index : legIndex
legTime := (currentLeg == BULLISH_LEG and legHigh == high) or (currentLeg == BEARISH_LEG and legLow == low) ? time : legTime

//———————————————————————————————————————}

03/11/2025 at 11:12 AM #244828 quote

yas
Participant

Junior

hi any update on this please

03/12/2025 at 11:30 AM #244865 quote

Iván González
Moderator

Master

Bonjour. Ce n'est pas une traduction facile. J'ai besoin de temps libre pour le faire.

04/12/2025 at 9:30 AM #245847 quote

yas
Participant

Junior

Hi mate

Can this one be converted instead the one above please

// This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
// © LuxAlgo

//@version=5
indicator(“Ultimate RSI [LuxAlgo]”, “LuxAlgo – Ultimate RSI”)
//——————————————————————————
//Settings
//—————————————————————————–{
length = input.int(14, minval = 2)
smoType1 = input.string(‘RMA’, ‘Method’, options = [‘EMA’, ‘SMA’, ‘RMA’, ‘TMA’])
src = input(close, ‘Source’)

arsiCss = input(color.silver, ‘Color’, inline = ‘rsicss’)
autoCss = input(true, ‘Auto’, inline = ‘rsicss’)

//Signal Line
smooth = input.int(14, minval = 1, group = ‘Signal Line’)
smoType2 = input.string(‘EMA’, ‘Method’, options = [‘EMA’, ‘SMA’, ‘RMA’, ‘TMA’], group = ‘Signal Line’)

signalCss = input(#ff5d00, ‘Color’, group = ‘Signal Line’)

//OB/OS Style
obValue = input.float(80, ‘Overbought’, inline = ‘ob’, group = ‘OB/OS Style’)
obCss = input(#089981, ”, inline = ‘ob’, group = ‘OB/OS Style’)
obAreaCss = input(color.new(#089981, 80), ”, inline = ‘ob’, group = ‘OB/OS Style’)

osValue = input.float(20, ‘Oversold ’, inline = ‘os’, group = ‘OB/OS Style’)
osCss = input(#f23645, ”, inline = ‘os’, group = ‘OB/OS Style’)
osAreaCss = input(color.new(#f23645, 80), ”, inline = ‘os’, group = ‘OB/OS Style’)

//—————————————————————————–}
//Functions
//—————————————————————————–{
ma(x, len, maType)=>
switch maType
‘EMA’ => ta.ema(x, len)
‘SMA’ => ta.sma(x, len)
‘RMA’ => ta.rma(x, len)
‘TMA’ => ta.sma(ta.sma(x, len), len)

//—————————————————————————–}
//Augmented RSI
//—————————————————————————–{
upper = ta.highest(src, length)
lower = ta.lowest(src, length)
r = upper – lower

d = src – src[1]
diff = upper > upper[1] ? r
: lower < lower[1] ? -r
: d

num = ma(diff, length, smoType1)
den = ma(math.abs(diff), length, smoType1)
arsi = num / den * 50 + 50

signal = ma(arsi, smooth, smoType2)

//—————————————————————————–}
//Plots
//—————————————————————————–{
plot_rsi = plot(arsi, ‘Ultimate RSI’
, arsi > obValue ? obCss
: arsi < osValue ? osCss
: autoCss ? chart.fg_color : arsiCss)

plot(signal, ‘Signal Line’, signalCss)

//Levels
plot_up = plot(obValue, color = na, editable = false)
plot_avg = plot(50, color = na, editable = false)
plot_dn = plot(osValue, color = na, editable = false)

//OB-OS
fill(plot_rsi, plot_up, arsi > obValue ? obAreaCss : na)
fill(plot_dn, plot_rsi, arsi < osValue ? osAreaCss : na)

//Gradient
fill(plot_rsi, plot_avg, obValue, 50, obAreaCss, color.new(chart.bg_color, 100))
fill(plot_avg, plot_rsi, 50, osValue, color.new(chart.bg_color, 100), osAreaCss)

hline(obValue, ‘Overbought’)
hline(50, ‘Midline’)
hline(osValue, ‘Oversold’)

//—————————————————————————–}

04/14/2025 at 2:55 PM #245891 quote
Iván González
Moderator

Master
Ici vous avez :
```
//---------------------------------------------//
//PRC_Ultimate RSI
//version = 0
//14.03.25
//Iván González @ www.prorealcode.com
//Sharing ProRealTime knowledge
//---------------------------------------------//
// inputs
//---------------------------------------------//
length=14
smotype1=3
src=close
smooth=14
smotype2=1
obValue=80
osValue=20
//---------------------------------------------//
// Augmented RSI
//---------------------------------------------//
upper=highest[length](src)
lower=lowest[length](src)
r=upper-lower

d=src-src[1]
if upper>upper[1] then
diff=r
else 
if lower<lower[1] then
diff=-r
else
diff=d
endif
endif
//---------------------------------------------//
// Moving average
//---------------------------------------------//
if smotype1=1 then
num=average[length,1](diff)
den=average[length,1](abs(diff))
elsif smotype1=2 then
num=average[length,0](diff)
den=average[length,0](abs(diff))
elsif smotype1=3 then 
alpha = 1/length
if barindex = length then
num = average[length](diff)
den = average[length](abs(diff))
else
num = alpha*diff + (1-alpha)*num[1]
den = alpha*abs(diff) + (1-alpha)*den[1]
endif
elsif smotype1=4 then
num=average[length](average[length](diff))
den=average[length](average[length](abs(diff)))
endif
arsi=num/den*50+50
//---------------------------------------------//
// Signal
//---------------------------------------------//
if smotype2=1 then
signal=average[smooth,1](arsi)
elsif smotype2=2 then
signal=average[smooth,0](arsi)
elsif smotype2=2 then
alpha = 1/smooth
if barindex = smooth then
signal = average[smooth](arsi)
else
signal = alpha*arsi + (1-alpha)*signal[1]
endif
elsif smotype1=3 then
signal=average[smooth](average[smooth](arsi))
endif
//---------------------------------------------//
// Plot
//---------------------------------------------//
if arsi>obvalue then
r1=0
g1=255
b1=0
a1=255
a3=0
elsif arsi<osvalue then
r3=255
g3=0
b3=0
a3=255
a1=0
else
a1=0
a3=0
endif
colorbetween(obvalue,arsi,r1,g1,b1,a1*0.3)
colorbetween(osvalue,arsi,r3,g3,b3,a3*0.3)
//---------------------------------------------//
return obValue style(dottedline),osValue style(dottedline),50 style(dottedline), arsi, signal as "Signal line"coloured("orange")style(line,2)
```
04/15/2025 at 8:50 AM #245907 quote

yas
Participant

Junior

Thanks ivan much appreciated mate
Author

Posts

Viewing 6 posts - 1 through 6 (of 6 total)

You must be logged in to reply to this topic.

Please Convert Swing Breakout Sequence to PRORTime

ProBuilder: Indicators & Custom Tools

New Reply

Author

yas @yas Participant

Summary

This topic contains 5 replies,
has 2 voices, and was last updated by yas
9 months, 3 weeks ago.

Topic Details

Forum:	ProBuilder: Indicators & Custom Tools
Language:	English
Started:	02/27/2025
Status:	Active
Attachments:	No files

Expert Services

No recent search

Please Convert Swing Breakout Sequence to PRORTime

Please Convert Swing Breakout Sequence to PRORTime ProBuilder: Indicators & Custom Tools

Author

Summary

Topic Details

About personal data collected

Get Assistance

Assistance Type

Your Need

Proposed Solutions

Choose Assistance Type

Your Need

Programming Help

Download Codes

Trading Help

ProRealTime Information

Account Assistance

Paid Programming Help

Please Convert Swing Breakout Sequence to PRORTime

ProBuilder: Indicators & Custom Tools