PSAR using Moving Linear Regression (LSMA) For ThinkOrSwim

[DrewH]

Author states:
Works exactly as the standard PSAR with the only difference that a Moving Linear Regression Line (=Least Squares Moving Average, LSMA) is used as input.
So the PSAR flip is triggered not by price itself but by the LSMA line.

Here is the original Tradingview code:

https://www.tradingview.com/script/Sl4CIxLs-PSAR-using-Moving-Linear-Regression-LSMA/


For the new ThinkOrSwim code, you must scroll down to the next post

 

[samer800]

Hi

I'm hoping someone can help me convert the following TradingView PSAR code into thinkscript.
https://www.tradingview.com/script/Sl4CIxLs-PSAR-using-Moving-Linear-Regression-LSMA/

I've tried everything I can think of. The issue seems to be getting Thinkscipt to update SAR to NEXTSAR before evaluating if there should be a PSAR flip. Would really appreciate any help.

Thanks!

//@version=5

indicator(title='PSAR using Moving Linear Regression (LSMA)', shorttitle='PSAR using LSMA', timeframe="", overlay=true)

src = input(title='Source', defval=close)
RegressionLineLength = input.int(defval=10, title='Regression Line Length', maxval=1000, minval=1)
start = input(0.02)
increment = input(0.02)
maximum = input(0.12)


var bool uptrend = na
var float EP = na
var float SAR = na
var float AF = start
var float nextBarSAR = na

myMovingLinearRegression = ta.linreg(src, RegressionLineLength, 0)

if bar_index > RegressionLineLength
firstTrendBar = false
SAR := nextBarSAR

// calculate intial PSAR values
if bar_index == RegressionLineLength + 1
float prevSAR = na
float prevEP = na
lowPrev = myMovingLinearRegression[1]
highPrev = myMovingLinearRegression[1]
closeCur = myMovingLinearRegression
closePrev = myMovingLinearRegression[1]
if closeCur > closePrev
uptrend := true
EP := myMovingLinearRegression
prevSAR := lowPrev
prevEP := myMovingLinearRegression
prevEP
else
uptrend := false
EP := myMovingLinearRegression
prevSAR := highPrev
prevEP := myMovingLinearRegression
prevEP
firstTrendBar := true
SAR := prevSAR + start * (prevEP - prevSAR)
SAR

if uptrend
if SAR > myMovingLinearRegression
firstTrendBar := true
uptrend := false
SAR := math.max(EP, myMovingLinearRegression)
EP := myMovingLinearRegression
AF := start
AF
else
if SAR < myMovingLinearRegression
firstTrendBar := true
uptrend := true
SAR := math.min(EP, myMovingLinearRegression)
EP := myMovingLinearRegression
AF := start
AF

if not firstTrendBar
if uptrend
if myMovingLinearRegression > EP
EP := myMovingLinearRegression
AF := math.min(AF + increment, maximum)
AF
else
if myMovingLinearRegression < EP
EP := myMovingLinearRegression
AF := math.min(AF + increment, maximum)
AF

// now calculate current SAR...
if uptrend
SAR := math.min(SAR, myMovingLinearRegression[1])
if bar_index > 1
SAR := math.min(SAR, myMovingLinearRegression[2])
SAR
else
SAR := math.max(SAR, myMovingLinearRegression[1])
if bar_index > 1
SAR := math.max(SAR, myMovingLinearRegression[2])
SAR

// and the next SAR
nextBarSAR := SAR + AF * (EP - SAR)
nextBarSAR

// wait for bar to close before updating the PSAR value
// show last value for convenience
SARplotValue = barstate.isconfirmed ? SAR : SAR[1]


// plot
plot(SARplotValue, title='PSAR LSMA', style=plot.style_circles, linewidth=2, color=color.new(color.gray, 0))
//plot(nextBarSAR, style=plot.style_circles, linewidth=3, color=color.gray)
plot(myMovingLinearRegression, title='LSMA', linewidth=3, color=color.new(color.blue, 0), display=display.none)

check the below:

#// Indicator for TOS
#// © olaf1138
#indicator(title='PSAR using Moving Linear Regression (LSMA)', shorttitle='PSAR using LSMA'
# Converted by Sam4Cok@Samer800    - 03/2025

input timeframe = AggregationPeriod.MIN;
input Source = FundamentalType.CLOSE; #(title='Source', defval=close)
input RegressionLineLength = 10; #, title='Regression Line Length', maxval=1000, minval=1)
input start = 0.02;
input increment = 0.02;
input maximum = 0.12;

def na = Double.NaN;
def last = IsNaN(close);
def GAP = GetAggregationPeriod();
def tf = Max(GAP, timeframe);
def src = Fundamental(Source, Period = tf);
Script sar {
    input start = 0.02;
    input inc = 0.02;
    input max = 0.2;
    input cutoff = 1;
    input regVal = close;
    def na = Double.NaN;
    def bar = CompoundValue(1, bar[1] + 1,  1);
    def startTrend = regVal > regVal[1];
    def maxMin;
    def maxMin1;
    def maxMin2;
    def result;
    def sar2;
    def acceleration;
    def acceleration1;
    def acceleration2;
    def isBelow;
    def isBelow1;
    def isFirstTrendBar;
    def isFirstTrendBar1;
    def sar;

if bar <= cutoff  {
        if startTrend {
            isBelow1 = yes;
            maxMin2  = regVal;
            sar2  = regVal[1];
        } else {
            isBelow1 = no;
            maxMin2  = regVal;
            sar2 = 0; #h[1];
        }
    isFirstTrendBar1 = yes;
    acceleration2 = start;
    } else {
    isBelow1 = isBelow[1];
    maxMin2  = if !maxMin[1] then (if startTrend then regVal else regVal) else  maxMin[1];
    sar2  = if !sar[1] then (if startTrend then regVal[1] else 0) else sar[1];
    isFirstTrendBar1 = no;
    acceleration2 = acceleration[1];
    }
    def sar1  =  sar2 + acceleration2 * (maxMin2 - sar2);

    if isBelow1 {
        if sar1 > regVal {
            isFirstTrendBar = yes;
            isBelow = no;
            result = max(regVal, maxMin2);
            maxMin1 = regVal;
            acceleration1 = start;
            } else {
            maxMin1 = maxMin2;
            acceleration1 = acceleration2;
            isFirstTrendBar = isFirstTrendBar1;
            isBelow = isBelow1;
            result = sar1;
            }
    } else if sar1 < regVal {
            isFirstTrendBar = yes;
            isBelow = yes;
            result = min(regVal , maxMin2);
            maxMin1 = regVal;
            acceleration1 = start;
            } else {
            acceleration1  = acceleration2;
            maxMin1 = maxMin2;
            isFirstTrendBar = isFirstTrendBar1;
            isBelow = isBelow1;
            result = sar1;
            }
    if !isFirstTrendBar {
        if isBelow {
            if regVal > maxMin1 {
                maxMin = regVal;
                acceleration = min(acceleration1 + inc, max);
             } else {
                maxMin = maxMin1;
                acceleration = acceleration1;
             }
        } else {
            if regVal < maxMin1 {
                maxMin = regVal;
                acceleration = min(acceleration1 + inc, max);
            } else {
                maxMin = maxMin1;
                acceleration = acceleration1;
            }}
    } else {
           maxMin = maxMin1;
           acceleration = acceleration1;
}
        def dir = if bar > 1 then if isBelow then 1 else -1 else
                  if startTrend then 1 else -1;
        sar = if isBelow then if bar > 1 then Min(result, Min(regVal[1], regVal[2])) else Min(result, regVal[1]) else
                              if bar > 1 then Max(result, Max(regVal[1], regVal[2])) else Max(result, regVal[1]);
        plot psar  = if !isNaN(close) then sar else Double.NaN;
        plot trend = isBelow;
        }

def myMovingLinearRegression = Inertia(src, RegressionLineLength);
def dir = sar(start, increment, maximum, RegressionLineLength, myMovingLinearRegression).trend;
def sar = sar(start, increment, maximum, RegressionLineLength, myMovingLinearRegression).psar;

#-- plots
plot PSAR = sar;
psar.SetStyle(Curve.POINTS);
psar.AssignValueColor(if dir then Color.GREEN else Color.RED);

#-- END of CODe