File Coverage

blib/lib/Math/Business/ParabolicSAR.pm

Criterion	Covered	Total	%
statement	82	89	92.1
branch	34	44	77.2
condition	5	15	33.3
subroutine	9	12	75.0
pod	0	8	0.0
total	130	168	77.3

package Math::Business::ParabolicSAR;

use strict;
use warnings;
use Carp;
use constant {
    LONG  => 7,
    SHORT => 9,
    HP    => 1,
    LP    => 0,
};

1;

sub tag { (shift)->{tag} }

sub recommended {
    my $class = shift;
       $class->new(0.02, 0.20);
}

sub new {
    my $class = shift;
    my $this  = bless {e=>[], y=>[]}, $class;

    if( @_ ) {
       eval { $this->set_alpha(@_) };
       croak $@ if $@;
    }

    return $this;
}

sub set_alpha {
    my $this = shift;
    my ($as,$am) = @_;

    croak "set_alpha(as,am) takes two arguments, the alpha start (0
        unless 0 < $as and $as < $am and $am < 1;

    $this->{as} = $as;
    $this->{am} = $am;

    $this->{tag} = "PSAR($as,$am)";

    return;
}

sub insert {
    my $this = shift;

    my ($as,$am);
    croak "must set_alpha(as,am) before inserting data" unless defined( $am = $this->{am} ) and defined( $as = $this->{as} );

    my ($y_low, $y_high) = @{$this->{y}};
    my ($open,$high,$low,$close);

    my $S;
    my $P = $this->{S};
    my $A = $this->{A};
    my $e = $this->{e};

    my $ls = $this->{ls};

    while( defined( my $ar = shift ) ) {
        croak "arguments to insert must be four tuple (open,high,low,close) with high greater than or equal to low"
            unless ref($ar) eq "ARRAY" and @$ar==4 and $ar->[2]<=$ar->[1];

        # NOTE: we really only use open and close to initialize ...
        ($open,$high,$low,$close) = @$ar;

        if( defined $ls ) {
            # calculate sar_t
            # The Encyclopedia of Technical Market Indicators - Page 495

            my @oe = @$e;
            $e->[HP] = $high if $high > $e->[HP]; # the highest point during the trend
            $e->[LP] = $low  if $low  < $e->[LP]; # the  lowest point during the trend

            if( $ls == LONG ) {
                $S = $P + $A*($e->[HP] - $P); # adjusted upwards from the reset like so

                # NOTE: many sources say you should flop short/long if you get
                # inside the price range for the last *two* periods.  Amazon,
                # Yahoo! and stockcharts dont' seem to do it that way.

                if( $S > $low ) {
                    $ls = SHORT; # new short position

                    $S  = $e->[HP];
                    $A  = $as;

                    $e->[HP] = ($high>$y_high ? $high : $y_high);
                    $e->[LP] = ($low <$y_low  ? $low  : $y_low );

                } elsif( $S > $y_low ) {
                    $S = $y_low;

                } elsif( $oe[HP] != $e->[HP] ) {
                    $A += $as;
                    $A = $am if $A > $am;
                }

            } else {
                $S = $P + $A*($e->[LP] - $P); # adjusted downwards from the reset like so

                # NOTE: many sources say you should flop short/long if you get
                # inside the price range for the last *two* periods.  Amazon,
                # Yahoo! and stockcharts dont' seem to do it that way.

                if( $S < $high ) {
                    $ls = LONG; # new long position

                    $S  = $e->[LP];
                    $A  = $as;

                    $e->[HP] = ($high>$y_high ? $high : $y_high);
                    $e->[LP] = ($low <$y_low  ? $low  : $y_low );

                } elsif( $S < $y_high ) {
                    $S = $y_high;

                } elsif( $oe[LP] != $e->[LP] ) {
                    $A += $as;
                    $A = $am if $A > $am;
                }
            }

        } else {
            # circa 2010: initialize somehow
            # (never did find a good description of how to initialize this mess.
            #   I think you're supposed to tell it how to start)
            # this is the only time we use open/close and it's not even in the definition
            #
            # 2011-01-03: I did look this up, it's the "SIP" or significant
            # point.  It should be the lowest (or the highest) point we have
            # from our recent-ish data or "long trade" as he calls it.  This'll
            # do as an approximation of that imo — otherwise we'll have to
            # start asking for a few days previous trades just to initialize.

            $A = $as;

            if( $open < $close ) {
                $ls = LONG;
                $S  = $low;

            } else {
                $ls = SHORT;
                $S  = $high;
            }

            $e->[HP] = $high;
            $e->[LP] = $low;
        }

        $P = $S;

        ($y_low, $y_high) = ($low, $high);
    }

    ## DEBUG ## warn "{S}=$S; {A}=$A";

    $this->{S}  = $S;
    $this->{A}  = $A;
    $this->{ls} = $ls;

    @{$this->{y}} = ($y_low, $y_high);
}

sub query {
    my $this = shift;

    $this->{S};
}

sub long {
    my $this = shift;
    $this->{ls} == LONG;
}

sub short {
    my $this = shift;
    $this->{ls} == SHORT;
}

__END__