pSAR does not have any look-ahead peeking implemented
Upon a slight code-review of Joshua ULRICH's pSAR implementation one may confirm a zero look-ahead peeking in the source code.
The issues may come on a first look from the function call-signature, but the R-wrapper fixes these.
#'@export
"SAR" <-
function(HL, accel=c(.02,.2)) {
# Parabolic Stop-and-Reverse (SAR)
# ----------------------------------------------
# HL = HL vector, matrix, or dataframe
# accel[1] = acceleration factor
# accel[2] = maximum acceleration factor
...
# Gap for inital SAR
initGap <- sd(drop(coredata(HL[,1] - HL[,2])), na.rm=TRUE)
# Call C routine
sar <- .Call("sar", HL[,1], HL[,2], accel, initGap, PACKAGE = "TTR")
reclass( sar, HL )
}
SAR() implementation uses the published calling interface of sar():
SEXP sar (
SEXP hi, /* HIGH[]-s */
SEXP lo, /* LOW[]-s */
SEXP xl, /* [initial AF value, max AF value] */
SEXP ig /* initial GAP */
)
where there is no peeking into the future ( zero look-ahead ) in any of the for(){...} scanners ( all are purely a look-back only ).
UPDATE
Test outputs from both given data-sets:
|>>> sar( ( 2, 3, 4, 5, 6 ), ( 1, 2, 3, 4, 5 ), ( 0.02, 0.2 ) )
[1.0, 1, 1.08, 1.2552, 1.5547840000000002]
|
|>>> sar( ( 2, 3, 4, 5, 7 ), ( 1, 2, 3, 4, 5 ), ( 0.02, 0.2 ) )
[1.0, 1, 1.08, 1.2552, 1.5547840000000002]
There is zero look-ahead peeking in the Joshua ULRICH's implementation of the pSAR algorithm observed.
Q.E.D.
Ex-post
as noted from the very beginning, the sar() function was proved to be correctly implemented pSAR technical indicator. The R wrapper was the issue, as it decides on what parameters the underlying, correctly working, function sar() is being invoked. Upon a case the call-signature is loaded with parameters, that carry a forward looking bias, the function is not to be blamed for a such behaviour, but rather the user. Q.E.D.
#----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
# CRAN - R-Project TTR lib: indicators:: # Joshua ULRICH: >>> https://github.com/joshuaulrich/TTR/tree/master/src + https://cran.r-project.org/web/packages/TTR/TTR.pdf
def sar( Hi, Lo, acceleration_factor = ( 0.02, 0.2 ), initGap = 0. ):
""" __doc__
USAGE: calculate parabolic SAR on given inputs
sar( Hi,
Lo,
acceleration_factor = ( 0.02, 0.2 ),
initGap = 0.
)
PARAMS: Hi: High[]s in []-alike representation
Lo: Low[]-s in []-alike representation
acceleration_factor: [ afSTEP, afMAX ], ref. pSAR rules
initGap: initial gap under first valid Low[]
RETURNS: pSAR[]
THROWS: n/a
EXAMPLE: |>>> QuantFX.sar( (2,3,4,5,6), (1,2,3,4,5) )
[1.0, 1, 1.08, 1.2552, 1.5547840000000002]
|
|>>> QuantFX.sar( (2,3,4,5,7), (1,2,3,4,5) )
[1.0, 1, 1.08, 1.2552, 1.5547840000000002]
"""
"""
#___________________________________________________________/* Initalize loop and PROTECT counters */
int i, P=0;
#___________________________________________________________/* Ensure all arguments are double */
if(TYPEOF(hi) != REALSXP) {
PROTECT(hi = coerceVector(hi, REALSXP)); P++;
}
if(TYPEOF(lo) != REALSXP) {
PROTECT(lo = coerceVector(lo, REALSXP)); P++;
}
if(TYPEOF(xl) != REALSXP) {
PROTECT(xl = coerceVector(xl, REALSXP)); P++;
}
double initGap = asReal( ig ); ### ------------------------ extern ( ig )
#___________________________________________________________/* Pointers to function arguments */
double *d_hi = REAL(hi);
double *d_lo = REAL(lo);
double *d_xl = REAL(xl);
"""
#___________________________________________________________/* Input object length */
#int nr = nrows(hi);
nRows = len( Hi )
#___________________________________________________________/* Initalize result R object */
#SEXP sar; PROTECT(sar = allocVector(REALSXP,nr)); P++;
#double *d_sar = REAL(sar);
sar = [None] * nRows
#___________________________________________________________/* Find first non-NA value */
#int beg = 1;
begFrom = 1
#for(i=0; i < nr; i++) {
for i in xrange( nRows ):
if ( np.isnan( Hi[i] )
or np.isnan( Lo[i] )
):
sar[i] = None # NA_REAL; /* skip-it */
begFrom += 1
else:
break # /* break */
pass
pass
#___________________________________________________________/* Initialize values needed by the routine */
#int sig0 = 1, sig1 = 0;
sig0 = 1
sig1 = 0
xpt0 = Hi[begFrom-1]
xpt1 = 0
afStp = acceleration_factor[0]
afMAX = acceleration_factor[1]
af0 = afStp
af1 = 0
sar[begFrom-1] = Lo[begFrom-1] - initGap # /* SUB initGap from 1st Lo[] to begin from */
for i in xrange( begFrom, nRows ):
#_________________________________________________________/* Increment signal, extreme point, and acceleration factor */
sig1 = sig0
xpt1 = xpt0
af1 = af0
#_________________________________________________________/* Local extrema */
lmin = min( Lo[i-1], Lo[i] ) #?? pSAR_RULE_Exc 2 ?? 2 last bars checked
lmax = max( Hi[i-1], Hi[i] )
#_________________________________________________________/* Create signal and extreme price vectors */
if ( sig1 == 1 ): #/* Previous buy signal */
#ig0 = ( Lo[i] > d_sar[i-1]) ? 1 : -1 #/* New signal */
sig0 = 1 if ( Lo[i] > sar[i-1] ) else -1 #/* New signal */
xpt0 = max( lmax, xpt1 ) #/* New extreme price */
else: #/* Previous sell signal */
#ig0 = ( Hi[i] < d_sar[i-1]) ? -1 : 1 #/* New signal */
sig0 = -1 if ( Hi[i] < sar[i-1] ) else 1 #/* New signal */
xpt0 = min( lmin, xpt1 ) #/* New extreme price */
pass
"""
/*
* Calculate acceleration factor (af)
* and stop-and-reverse (sar) vector
*/
"""
#_________________________________________________________/* No signal change */
if ( sig0 == sig1 ):
#_______________________________________________________/* Initial calculations */
sar[i] = sar[i-1] + ( xpt1 - sar[i-1] ) * af1
#f0 = ( af1 == afMAX ) ? afMAX : ( afStp + af1 )
af0 = afMAX if ( af1 == afMAX ) else ( afStp + af1 )
#_______________________________________________________/* Current buy signal */
if ( sig0 == 1 ):
#f0 = (xpt0 > xpt1) ? af0 : af1 #/* Update acceleration factor */
af0 = af0 if (xpt0 > xpt1) else af1 #/* Update acceleration factor */
sar[i]= min( sar[i], lmin ) #/* Determine sar value */
#_______________________________________________________/* Current sell signal */
else:
#f0 = (xpt0 < xpt1) ? af0 : af1 #/* Update acceleration factor */
af0 = af0 if (xpt0 < xpt1) else af1 #/* Update acceleration factor */
sar[i]= max( sar[i], lmax ) #/* Determine sar value */
#_________________________________________________________/* New signal */
else:
af0 = afStp #/* reset acceleration factor */
sar[i] = xpt0 #/* set sar value */
pass
pass
#___________________________________________________________/* UNPROTECT R objects and return result */
#UNPROTECT(P);
#return(sar);
return sar
