#include "octave oct.h"
#include "octave dcolvector.h"
#include "octave dmatrix.h"
#include "GenFact.h"
#include "GramPoly.h"
#include "Weight.h"
DEFUN_DLD ( double_smooth_proj_2_5, args, nargout,
"-*- texinfo -*-\n\
@deftypefn {Function File} {} double_smooth_proj_2_5 (@var{input_vector})\n\
This function takes an input series and smooths it by projecting a 5 bar rolling linear fit\n\
3 bars into the future and using these 3 bars plus the last 3 bars of the rolling input\n\
to fit a FIR filter with a 2.5 bar lag from the last projected point, i.e. a 0.5 bar\n\
lead over the last actual rolling point in the series. This is averaged with the previously\n\
calculated such smoothed point for a theoretical zero-lagged smooth. This smooth is\n\
again smoothed as above for a smooth of the smooth, i.e. a double-smooth of the\n\
original input series. The double_smooth and smooth are the function outputs.\n\
@end deftypefn" )
{
octave_value_list retval_list ;
int nargin = args.length () ;
// check the input arguments
if ( nargin > 1 ) // there must be a single, input price vector
{
error ("Invalid arguments. Inputs are a single, input price vector.") ;
return retval_list ;
}
if ( args(0).length () < 5 )
{
error ("Invalid 1st argument length. Input is a price vector of length >= 5.") ;
return retval_list ;
}
// end of input checking
ColumnVector input = args(0).column_vector_value () ;
ColumnVector smooth = args(0).column_vector_value () ;
ColumnVector double_smooth = args(0).column_vector_value () ;
// create the fit coefficients matrix
int p = 5 ; // the number of points in calculations
int m = ( p - 1 ) / 2 ; // value to be passed to call_GenPoly_routine_from_octfile
int n = 1 ; // value to be passed to call_GenPoly_routine_from_octfile
int s = 0 ; // value to be passed to call_GenPoly_routine_from_octfile
// create matrix for fit coefficients
Matrix fit_coefficients_matrix ( 2 * m + 1 , 2 * m + 1 ) ;
// and assign values in loop using the Weight.h recursive Gram Polynomial C++ headers
for ( int tt = -m ; tt < (m+1) ; tt ++ )
{
for ( int ii = -m ; ii < (m+1) ; ii ++ )
{
fit_coefficients_matrix ( ii + m , tt + m ) = Weight( ii , tt , m , n , s ) ;
}
}
// create matrix for slope coefficients
Matrix slope_coefficients_matrix ( 2 * m + 1 , 2 * m + 1 ) ;
s = 1 ;
// and assign values in loop using the Weight.h recursive Gram Polynomial C++ headers
for ( int tt = -m ; tt < (m+1) ; tt ++ )
{
for ( int ii = -m ; ii < (m+1) ; ii ++ )
{
slope_coefficients_matrix ( ii + m , tt + m ) = Weight( ii , tt , m , n , s ) ;
}
}
Matrix smooth_coefficients ( 1 , 5 ) ;
// fill the smooth_coefficients matrix, smooth_coeffs = ( 9/24 ) .* fit_coeffs + ( 7/12 ) .* slope_coeffs + [ 0 ; 1/24 ; 1/8 ; 5/24 ; 1/4 ] ;
smooth_coefficients( 0 , 0 ) = ( 9.0 / 24.0 ) * fit_coefficients_matrix( 0 , 4 ) + ( 7.0 / 12.0 ) * slope_coefficients_matrix( 0 , 4 ) ;
smooth_coefficients( 0 , 1 ) = ( 9.0 / 24.0 ) * fit_coefficients_matrix( 1 , 4 ) + ( 7.0 / 12.0 ) * slope_coefficients_matrix( 1 , 4 ) + ( 1.0 / 24.0 ) ;
smooth_coefficients( 0 , 2 ) = ( 9.0 / 24.0 ) * fit_coefficients_matrix( 2 , 4 ) + ( 7.0 / 12.0 ) * slope_coefficients_matrix( 2 , 4 ) + ( 1.0 / 8.0 ) ;
smooth_coefficients( 0 , 3 ) = ( 9.0 / 24.0 ) * fit_coefficients_matrix( 3 , 4 ) + ( 7.0 / 12.0 ) * slope_coefficients_matrix( 3 , 4 ) + ( 5.0 / 24.0 ) ;
smooth_coefficients( 0 , 4 ) = ( 9.0 / 24.0 ) * fit_coefficients_matrix( 4 , 4 ) + ( 7.0 / 12.0 ) * slope_coefficients_matrix( 4 , 4 ) + ( 1.0 / 4.0 ) ;
for ( octave_idx_type ii (4) ; ii < args(0).length () ; ii++ )
{
smooth( ii ) = smooth_coefficients( 0 , 0 ) * input( ii - 4 ) + smooth_coefficients( 0 , 1 ) * input( ii - 3 ) + smooth_coefficients( 0 , 2 ) * input( ii - 2 ) +
smooth_coefficients( 0 , 3 ) * input( ii - 1 ) + smooth_coefficients( 0 , 4 ) * input( ii ) ;
double_smooth( ii ) = smooth_coefficients( 0 , 0 ) * smooth( ii - 4 ) + smooth_coefficients( 0 , 1 ) * smooth( ii - 3 ) + smooth_coefficients( 0 , 2 ) * smooth( ii - 2 ) +
smooth_coefficients( 0 , 3 ) * smooth( ii - 1 ) + smooth_coefficients( 0 , 4 ) * smooth( ii ) ;
}
retval_list( 0 ) = double_smooth ;
retval_list( 1 ) = smooth ;
return retval_list ;
} // end of functionRather than describe it, I'll just paste the "help" description below:-
"This function takes an input series and smooths it by projecting a 5 bar rolling linear fit 3 bars into the future and using these 3 bars plus the last 3 bars of the rolling input to fit a FIR filter with a 2.5 bar lag from the last projected point, i.e. a 0.5 bar lead over the last actual rolling point in the series. This is averaged with the previously calculated such smoothed point for a theoretical zero-lagged smooth. This smooth is again smoothed as above for a smooth of the smooth, i.e. a double-smooth of the original input series. The double_smooth and smooth are the function outputs."
The above function calls previous code of mine to calculate savitzky golay filter convolution coefficients for internal calculations, but for the benefit of readers I will simply post the final coefficients for a 5 tap FIR filter.
-0.191667 -0.016667 0.200000 0.416667 0.591667These coefficients are for a "single" smooth. Run the output from a function using these through the same function to get the "double" smooth.
Testing on a sinewave looks like this:-
I will not discuss this any further in this post other than to say I intend to combine this with the ideas contained in my new use for kalman filter post.
More in due course.
