advanced_math 0.0.5 → 0.0.7

data/Manifest.txt

@@ -1,8 +1,13 @@
-advanced_math-0.0.4.gem
 advanced_math.gemspec
+gem_publish.sh
 History.txt
+lib/advanced_math/rsi.rb
+lib/advanced_math/sma.rb
 lib/advanced_math.rb
 Manifest.txt
 PostInstall.txt
 README.rdoc
+test/rsi.pl
+test/RSI.pm
+test/test_rsi.rb
 test/test_simple_moving_average.rb

data/advanced_math.gemspec

@@ -1,16 +1,37 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{advanced_math}
-  s.version = "0.0.5"
+  s.version = "0.0.7"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = [%q{Glenn Nagel}]
   s.date = %q{2011-08-28}
   s.description = %q{A simple gem for advanced and financial math calcualtions.}
   s.email = [%q{glenn@mercury-wireless.com}]
-  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "PostInstall.txt"]
-  s.files = ["History.txt", "Manifest.txt", "PostInstall.txt", "README.rdoc", "advanced_math-0.0.4.gem", "advanced_math.gemspec", "lib/advanced_math.rb", "test/test_simple_moving_average.rb"]
+  s.extra_rdoc_files = [
+    "History.txt",
+    "Manifest.txt",
+    "PostInstall.txt"
+  ]
+  s.files = [
+    "History.txt",
+    "Manifest.txt",
+    "PostInstall.txt",
+    "README.rdoc",
+    "advanced_math.gemspec",
+    "gem_publish.sh",
+    "lib/advanced_math.rb",
+    "lib/advanced_math/rsi.rb",
+    "lib/advanced_math/sma.rb",
+    "test/RSI.pm",
+    "test/rsi.pl",
+    "test/test_rsi.rb",
+    "test/test_simple_moving_average.rb"
+  ]
   s.homepage = %q{https://github.com/gnagel/mercury-wireless-public/tree/master/ruby/advanced_math}
   s.post_install_message = %q{PostInstall.txt}
   s.rdoc_options = [%q{--main}, %q{README.rdoc}]
@@ -18,7 +39,7 @@ Gem::Specification.new do |s|
   s.rubyforge_project = %q{advanced_math}
   s.rubygems_version = %q{1.8.6}
   s.summary = %q{A simple gem for advanced and financial math calcualtions.}
-  s.test_files = [%q{test/test_simple_moving_average.rb}]
+  s.test_files = [%q{test/test_rsi.rb}, %q{test/test_simple_moving_average.rb}]
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
@@ -32,3 +53,4 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<hoe>, ["~> 2.9"])
   end
 end
+

data/gem_publish.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+rm *.gem;
+rake gemspec:generate &&
+gem build ./*gemspec && 
+gem push ./*gemspec

data/lib/advanced_math/rsi.rb

@@ -0,0 +1,113 @@
+require File.dirname(__FILE__) + "/sma.rb"
+
+module AdvancedMath
+  ###
+  # Relative Strength Index (RSI) calculator
+  # Created: 2011-08-28
+  # Author:  G Nagel
+  # Company: Mercury Wireless Software LLC
+  # Source: http://en.wikipedia.org/wiki/Relative_Strength_Index#Cutler.27s_RSI
+  # Source: http://www.aspenres.com/Documents/AspenGraphics4.0/Aspen_Graphics_4.htm#CutlersRSI.htm
+  # Source: http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:relative_strength_index_rsi
+  ###
+  class RelativeStrengthIndex
+    attr_accessor :values_up, :values_down, :range, :last_value
+    attr_accessor :verbose
+    ###
+    # Initialize the members
+    ###
+    def initialize(range)
+      raise ArgumentError, "Range is nil" unless (range)
+      raise ArgumentError, "Range must be > 1" unless range.to_i > 1
+
+      @verbose = false
+      @values_up = []
+      @values_down = []
+      @range = range.to_i()
+      @last_value = nil
+    end
+
+    ###
+    # Add a value to the list.
+    # If the list is < @range, then return nil.
+    # Otherwise compute the RSI and return the value.
+    ###
+    def add(value)
+      raise ArgumentError, "Value is nil" unless (value)
+      puts "==================" if verbose()
+      puts "value = #{value}" if verbose()
+
+      if (nil == @last_value)
+        @last_value = value.to_f()
+        puts "Setting intial last_value = #{@last_value}" if verbose()
+        return nil
+      end
+
+      @values_up.shift() if (range() == @values_up.length())
+      @values_down.shift() if (range() == @values_down.length())
+
+      diff = value.to_f - @last_value
+      @last_value = value.to_f()
+      if (0 > diff)
+      @values_up << 0
+      @values_down << diff.abs()
+      elsif (0 < diff)
+      @values_up << diff
+      @values_down << 0
+      else
+      @values_up << 0
+      @values_down << 0
+      end
+      puts "diff = #{diff}, values_up = #{@values_up.inspect()}, values_down = #{@values_down.inspect()}" if verbose()
+
+      if (@values_up.length() < range())
+        puts "#{@values_up.length()} < #{range()}" if verbose()
+        return nil
+      end
+      if (@values_up.length() > range())
+        puts "#{@values_up.length()} > #{range()}" if verbose()
+      @values_up.shift()
+      @values_down.shift()
+      else
+        puts "#{@values_up.length()} == #{range()}" if verbose()
+      end
+
+      sum = {:up => 0, :down => 0, :i_up => 0, :i_down => 0}
+      @values_up.each()   { |value| sum[:up]   = sum[:up] + value }
+      @values_down.each() { |value| sum[:down] = sum[:down] + value }
+
+      rs = (0 == sum[:down]) ? 100.0 : (sum[:up] / sum[:down])
+      puts "rs = #{rs}" if verbose()
+
+      rsi = 100.0 - (100.0 / (1.0 + rs))
+      puts "rsi = #{rsi}" if verbose()
+      return rsi
+    end
+
+    ###
+    # Compute the RSI values for an array
+    # Return an array with the RSI values
+    ###
+    def add_array(values)
+      raise ArgumentError, "Value is nil" unless (values);
+      raise ArgumentError, "Value is not an array" unless values.kind_of?(Array);
+
+      output = []
+
+      # Calculate the sum of the array
+      values.each() { |value| output << add(value) }
+
+      # Return the RSI array
+      return output
+    end
+  end
+
+  ###
+  # RSI is just an alias to RelativeStrengthIndex
+  ###
+  class RSI < RelativeStrengthIndex
+    def initialize(range)
+      super(range)
+    end
+  end
+end

data/lib/advanced_math/sma.rb

@@ -0,0 +1,74 @@
+module AdvancedMath
+  # Simple Moving Average (SMA) calculator
+  # Created: 2011-06-24
+  # Author:  G Nagel
+  # Company: Mercury Wireless Software LLC
+  class SimpleMovingAverage
+    ###
+    # Initialize the members:
+    # range:
+    #   number of values to average
+    # sum:
+    #   current sum of all values in the array
+    # values:
+    #   array of values used as temporary storage
+    ###
+    def initialize(range)
+      raise ArgumentError, "Range is nil" unless (range);
+      raise ArgumentError, "Range must be >= 1" unless range.to_i >= 1;
+      @range = range.to_i;
+      @sum = 0;
+      @values = Array.new();
+    end
+
+    ###
+    # Add a value to the list.
+    # If the list is < @range, then return nil.
+    # Otherwise compute the SMA and return the value.
+    ###
+    def add(value)
+      raise ArgumentError, "Value is nil" unless (value);
+
+      # add the value to the end of the array.
+      @values.push(value);
+
+      # Calculate the sum of the array
+      @sum += value.to_f;
+
+      # Is the array less than the range?
+      return nil if (@values.length() < @range)
+
+      # Is the array larger than the range?
+      @sum -= @values.shift.to_f() if (@values.length() > @range)
+
+      # Compute the average
+      return @sum.to_f / @range.to_f;
+    end
+
+    ###
+    # Compute the SMA values for an array
+    # Return an array with the SMA values
+    ###
+    def add_array(values)
+      raise ArgumentError, "Value is nil" unless (values);
+      raise ArgumentError, "Value is not an array" unless values.kind_of?(Array);
+
+      output = []
+
+      # Calculate the sum of the array
+      values.each() { |value| output << add(value) }
+
+      # Return the SMA array
+      return output
+    end
+  end
+
+  ###
+  # SMA is just an alias to SimpleMovingAverage
+  ###
+  class SMA < SimpleMovingAverage
+    def initialize(range)
+      super(range)
+    end
+  end
+end

data/lib/advanced_math.rb

@@ -1,59 +1,6 @@
-
 module AdvancedMath
-  VERSION = '0.0.5'
-
-
-  # Simple Moving Average (SMA) calculator
-  # Created: 2011-06-24
-  # Author:  G Nagel
-  # Company: Mercury Wireless Software LLC
-  class SimpleMovingAverage
-    ###
-    # Initialize the members: 
-    # range: 
-    #   number of values to average
-    # sum: 
-    #   current sum of all values in the array
-    # values: 
-    #   array of values used as temporary storage
-    ###
-    def initialize(range)
-      raise ArgumentError, "Range is nil" unless (range);
-      raise ArgumentError, "Range must be >= 1" unless range.to_i >= 1;
-      @range = range.to_i;
-      @sum = 0;
-      @values = Array.new();
-    end
-    
-    ###
-    # Add a value to the list.
-    # If the list is < @range, then return nil.
-    # Otherwise compute the SMA and return the value.
-    ###
-    def add(value) 
-      raise ArgumentError, "Value is nil" unless (value);
-      
-      # add the value to the end of the array.
-      @values.push(value);
-      
-      # Calculate the sum of the array
-      @sum += value.to_f;
-
-      # Is the array less than the range?
-      return nil if (@values.length() < @range)
-
-      # Is the array larger than the range?
-      @sum -= @values.shift.to_f() if (@values.length() > @range)
-      
-      # Compute the average
-      return @sum.to_f / @range.to_f;
-    end
-  end
-
-  ###
-  # SMA is just an alias to SimpleMovingAverage
-  ###  
-  class SMA < SimpleMovingAverage
-  end
-  
+  VERSION = '0.0.7'
 end
+
+require File.dirname(__FILE__) + "/advanced_math/sma.rb"
+require File.dirname(__FILE__) + "/advanced_math/rsi.rb"

data/test/RSI.pm

@@ -0,0 +1,247 @@
+package Math::Business::RSI;
+
+use strict;
+use warnings;
+use Carp;
+
+our $VERSION = 2.5; # local revision: b
+
+use Math::Business::SMA;
+use Math::Business::EMA;
+
+1;
+
+sub recommended {
+    my $class = shift;
+
+    $class->new(14);
+}
+
+sub new {
+    my $class = shift;
+    my $this  = bless {
+        U   => Math::Business::EMA->new,
+        D   => Math::Business::EMA->new,
+        RSI => undef,
+        cy  => undef,
+    }, $class;
+
+    my $alpha = shift;
+    if( defined $alpha ) {
+        $this->set_alpha( $alpha );
+    }
+
+    return $this;
+}
+
+sub set_alpha {
+    my $this  = shift;
+    my $alpha = shift;
+
+    # NOTE: this alpha is different than you might think ... it's really inverse alpha
+    # Wilder uses alpha=14 instead of alpha=(1/14) like you might expect
+
+    my $days = 2*$alpha - 1; # so days is 2*$alpha-1 instead of the expected 2*(1/$alpha)-1
+
+    eval { $this->set_days( $days ) };
+    croak "set_alpha() is basically set_days(2*$alpha-1), which complained: $@" if $@;
+}
+
+sub set_standard {
+    my $this = shift;
+    my $rm   = ref $this->{U};
+
+    if( $rm =~ m/SMA/ ) {
+        $this->{U} = Math::Business::EMA->new;
+        $this->{D} = Math::Business::EMA->new;
+
+        if( my $d = $this->{days} ) {
+            $this->set_days($d);
+        }
+    }
+}
+
+sub set_cutler {
+    my $this = shift;
+    my $rm   = ref $this->{U};
+
+    if( $rm =~ m/EMA/ ) {
+        $this->{U} = Math::Business::SMA->new;
+        $this->{D} = Math::Business::SMA->new;
+
+        if( my $d = $this->{days} ) {
+            $this->set_days($d);
+        }
+    }
+}
+
+sub set_days {
+    my $this = shift;
+    my $arg  = int(shift);
+
+    croak "days must be a positive non-zero integer" if $arg <= 0;
+
+    $this->{U}->set_days($this->{days} = $arg);
+    $this->{D}->set_days($arg);
+    delete $this->{cy};
+    delete $this->{RSI};
+}
+
+sub insert {
+    my $this = shift;
+    my $close_yesterday = $this->{cy};
+
+    my $EMA_U = $this->{U};
+    my $EMA_D = $this->{D};
+
+    croak "You must set the number of days before you try to insert" if not $this->{days};
+    while( defined( my $close_today = shift ) ) {
+        if( defined $close_yesterday ) {
+            my $delta = $close_today - $close_yesterday;
+
+            my ($U,$D) = (0,0);
+            if( $delta > 0 ) {
+                $U = $delta;
+                $D = 0;
+
+            } elsif( $delta < 0 ) {
+                $U = 0;
+                $D = abs $delta;
+            }
+
+            $EMA_U->insert($U);
+            $EMA_D->insert($D);
+        }
+
+        if( defined(my $eu = $EMA_U->query) ) {
+            my $ed = $EMA_D->query;
+            my $rs = (($ed == 0) ? 100 : $eu/$ed ); # NOTE: This is by definition apparently.
+
+            $this->{RSI} = 100 - 100/(1+$rs);
+        }
+
+        $close_yesterday = $close_today;
+    }
+
+    $this->{cy} = $close_yesterday;
+}
+
+sub query {
+    my $this = shift;
+
+    return $this->{RSI};
+}
+
+__END__
+
+=head1 NAME
+
+Math::Business::RSI - Technical Analysis: Relative Strength Index
+
+=head1 SYNOPSIS
+
+  use Math::Business::RSI;
+
+  my $rsi = new Math::Business::RSI;
+     $rsi->set_alpha(14); # issues a set days of 2*14-1
+     $rsi->set_days(27);  # equivilent to set_alpha(14)
+
+  # equivelent to set_days(27)/set_alpha(14):
+  my $rsi = new Math::Business::RSI(14);
+
+  # or to just get the recommended model ... set_alpha(14)
+  my $rsi = Math::Business::RSI->recommended;
+
+  my @closing_values = qw(
+      3 4 4 5 6 5 6 5 5 5 5
+      6 6 6 6 7 7 7 8 8 8 8
+  );
+
+  # choose one:
+  $rsi->insert( @closing_values );
+  $rsi->insert( $_ ) for @closing_values;
+
+  if( defined(my $q = $rsi->query) ) {
+      print "RSI: $q.\n";
+
+  } else {
+      print "RSI: n/a.\n";
+  }
+
+=head1 RESEARCHER
+
+The RSI was designed by J. Welles Wilder Jr in 1978.
+
+According to Wilder, a security is "overbought" it the RSI reaches an upper
+bound of 70 and is "oversold" when it moves below 30.  Some sources also
+use thresholds of 80 and 20.
+
+Therefore, moving above the upper threshold is a selling signal, whlie moving
+below the lower threshold is a signal to buy.
+
+Oddly, RSI(14) uses a "smoothing period" of 14 days -- referring to an alpha of
+1/14.  This means the EMA[N]u/EMA[N]d has N set to 27.  This also means the
+alpha is upside of other alpha you might see.  RSI(14) actually uses an alpha
+of ~0.0714, but set_alpha() takes the inverse to make C<$rsi->set_alpha(14)>
+work.
+
+If all of the above seems really confusing, no worries: RSI(14) means
+C<set_alpha(14)> (or C<new(14)> and is equivelent to C<set_days(27)>.
+
+=head2 Cutler
+
+There are differing schools of thought on how to calculate this and how
+important it is to stick to precisely the formula Wilder used.  Cutler used
+simple moving averages instead of exponential moving averages.
+
+You can switch between Wilder and Cutler mode with these:
+
+    $rsi->set_cutler; # for simple moving averages
+    $rsi->set_standard; # for exponential moving averages
+
+WARNING: Both of these clear out the value queue!  If you need to track
+both, you'll need two objects.
+
+=head1 THANKS
+
+Todd Litteken C<< <cl@xganon.com> >>
+
+Amit Dutt C<< <amit_dutt@hotmail.com> >>
+
+=head1 AUTHOR
+
+Paul Miller C<< <jettero@cpan.org> >>
+
+I am using this software in my own projects...  If you find bugs, please please
+please let me know.
+
+I normally hang out on #perl on freenode, so you can try to get immediate
+gratification there if you like.  L<irc://irc.freenode.net/perl>
+
+There is also a mailing list with very light traffic that you might want to
+join: L<http://groups.google.com/group/stockmonkey/>.
+
+=head1 COPYRIGHT
+
+Copyright (c) 2010 Paul Miller
+
+=head1 LICENSE
+
+This module is free software.  You can redistribute it and/or
+modify it under the terms of the Artistic License 2.0.
+
+This program is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.
+
+[This software may have had previous licenses, of which the current maintainer
+is completely unaware.  If this is so, it is possible the above license is
+incorrect or invalid.]
+
+=head1 SEE ALSO
+
+perl(1), L<Math::Business::StockMonkey>, L<Math::Business::StockMonkey::FAQ>, L<Math::Business::StockMonkey::CookBook>
+
+L<http://en.wikipedia.org/wiki/Relative_Strength_Index>
+
+=cut

data/test/rsi.pl

@@ -0,0 +1,8 @@
+#!/usr/bin/env perl
+use Math::Business::RSI;
+
+my $rsi = new Math::Business::RSI(shift @ARGV);
+$rsi->set_cutler;
+$rsi->insert( $_ ) for @ARGV;
+$rsi = int($rsi->query);
+print "$rsi\n";

data/test/test_rsi.rb

@@ -0,0 +1,127 @@
+require 'test/unit'
+require File.dirname(__FILE__) + "/../lib/advanced_math.rb"
+
+module AdvancedMath
+  class RelativeStrengthIndexTest < Test::Unit::TestCase
+    # Verify the constructor raises an ArgumentError if the "range" is invalid
+    def test_sma_initialize_nil
+      assert_raise(ArgumentError) { RelativeStrengthIndex.new(nil) }
+    end
+
+    # Verify the constructor raises an ArgumentError if the "range" is invalid
+    def test_sma_initialize_negative
+      assert_raise(ArgumentError) { RelativeStrengthIndex.new(-1) }
+      (-1...-1000).each do |i|
+        assert_raise(ArgumentError) { RelativeStrengthIndex.new(i) }
+      end
+    end
+
+    # Verify the constructor raises an ArgumentError if the "range" is invalid
+    def test_sma_initialize_zero
+      assert_raise(ArgumentError) { RelativeStrengthIndex.new(0) }
+    end
+
+    # Verify the constructor raises an ArgumentError if the "range" is invalid
+    def test_sma_initialize_one
+      assert_raise(ArgumentError) { RelativeStrengthIndex.new(1) }
+    end
+
+    # Verify the constructor doesn't raise an exception if the value is positive
+    def test_sma_initialize_positive
+      (2...1000).each do |i|
+        assert_nothing_raised(ArgumentError) { RelativeStrengthIndex.new(i) }
+      end
+    end
+
+    # Verify "add" raises an ArgumentError if the "value" is invalid
+    def test_sma_add_nil
+      assert_raise(ArgumentError) { RelativeStrengthIndex.new(1).add(nil) }
+    end
+
+    # # Verify SMA of 1, always returns the same value
+    # def test_sma_add_0
+    # sma = RelativeStrengthIndex.new(2)
+    # assert_nil(value = sma.add(0))
+    # assert_nil(value = sma.add(0))
+    # assert_not_nil(value = sma.add(0))
+    # assert_equal(50, value)
+    # (0...1000).each { |i| assert_equal(50, sma.add(0)) }
+    # end
+
+    def test_sma_add_range
+      sma = RelativeStrengthIndex.new(2)
+      (0...1000).each do |i|
+        value = sma.add(i)
+        if (i < 2)
+          assert_nil(value, "#{i}")
+        else
+          assert_not_nil(value, "#{i}")
+          assert_equal(99, sma.add(i).to_i(), "#{i}")
+        end
+      end
+    end
+
+    def RelativeStrengthIndexTest.rsi_values(period, values)
+      cmd = "#{File.dirname(__FILE__)}/rsi.pl #{period} #{values.join(" ")}"
+      cmd = `#{cmd}`.strip()
+      return cmd.to_i()
+    end
+
+    def RelativeStrengthIndexTest.rsi_range(period, prefix, range)
+      values = []
+      prefix.each() { |i| values << i }
+      range.each() { |i| values << i }
+      return RelativeStrengthIndexTest.rsi_values(period, values)
+    end
+
+    # Verify SMA of 2, always returns the same value - 0.5
+    def test_sma_add_2
+      sma = RelativeStrengthIndex.new(2)
+      assert_equal(nil, sma.add(0))
+      assert_equal(nil, sma.add(0))
+      assert_equal(99, sma.add(0).to_i())
+      (1...1000).each do |i|
+        value = sma.add(i).to_i()
+        cmp = RelativeStrengthIndexTest.rsi_range(sma.range(), [0, 0, 0], Range.new(0, i+1))
+        assert_equal(cmp, value, "#{i}")
+        assert_equal(99, value, "#{i}")
+      end
+
+    # (0..1000).to_a().each() do |i|
+    # sma = RelativeStrengthIndex.new(2)
+    # value = sma.add(i)
+    # assert_nil(value, i)
+    #
+    # value = sma.add(i+1)
+    # assert_not_nil(value = sma.add(i+1), i)
+    # assert_equal(99, sma.add(i).to_i(), "#{i}")
+    # end
+    end
+
+    def test_sma_array
+      assert_raise(ArgumentError) { RelativeStrengthIndex.new(2).add_array(nil) }
+      assert_raise(ArgumentError) { RelativeStrengthIndex.new(2).add_array("") }
+      assert_raise(ArgumentError) { RelativeStrengthIndex.new(2).add_array(1) }
+      assert_nothing_raised(ArgumentError) { RelativeStrengthIndex.new(2).add_array(Array.new) }
+      assert_not_nil( RelativeStrengthIndex.new(2).add_array(Array.new) )
+      assert_not_nil( RelativeStrengthIndex.new(2).add_array([]) )
+      assert_equal( 0, RelativeStrengthIndex.new(2).add_array([]).length() )
+      assert_equal( 1, RelativeStrengthIndex.new(2).add_array([1]).length() )
+      assert_equal( 2, RelativeStrengthIndex.new(2).add_array((1..2).to_a).length() )
+      assert_equal( 1000, RelativeStrengthIndex.new(2).add_array((1..1000).to_a).length() )
+
+      values = RelativeStrengthIndex.new(2).add_array((0..1000).to_a)
+      assert_nil(values[0])
+      assert_nil(values[1])
+      2.upto(values.length() -1) do |i|
+        assert_not_nil(values[i])
+        assert_equal(99, values[i].to_i())
+      end
+
+      values = RelativeStrengthIndex.new(14).add_array((0..14000).to_a)
+      values.slice!(0, 14).each() { |value| assert_nil(value) }
+
+      values.each() { |value| assert_not_nil(value); assert_equal(99, value.to_i()) }
+    end
+  end
+end

data/test/test_simple_moving_average.rb

@@ -5,48 +5,88 @@ module AdvancedMath
   class SimpleMovingAverageTest < Test::Unit::TestCase
     # Verify the constructor raises an ArgumentError if the "range" is invalid
     def test_sma_initialize_nil
-      assert_raise(ArgumentError) { SimpleMovingAverage.new(nil); }
+      assert_raise(ArgumentError) { SimpleMovingAverage.new(nil) }
     end
 
     # Verify the constructor raises an ArgumentError if the "range" is invalid
     def test_sma_initialize_negative
-      assert_raise(ArgumentError) { SimpleMovingAverage.new(-1); }
+      assert_raise(ArgumentError) { SimpleMovingAverage.new(-1) }
       (-1...-1000).each do |i|
-        assert_raise(ArgumentError) { SimpleMovingAverage.new(i); }
+        assert_raise(ArgumentError) { SimpleMovingAverage.new(i) }
       end
     end
 
     # Verify the constructor raises an ArgumentError if the "range" is invalid
     def test_sma_initialize_zero
-      assert_raise(ArgumentError) { SimpleMovingAverage.new(0); }
+      assert_raise(ArgumentError) { SimpleMovingAverage.new(0) }
     end
 
     # Verify the constructor doesn't raise an exception if the value is positive
     def test_sma_initialize_positive
       (1...1000).each do |i|
-        assert_nothing_raised(ArgumentError) { SimpleMovingAverage.new(i); }
+        assert_nothing_raised(ArgumentError) { SimpleMovingAverage.new(i) }
       end
     end
 
     # Verify "add" raises an ArgumentError if the "value" is invalid
     def test_sma_add_nil
-      assert_raise(ArgumentError) { SimpleMovingAverage.new(1).add(nil); }
+      assert_raise(ArgumentError) { SimpleMovingAverage.new(1).add(nil) }
     end
 
     # Verify SMA of 1, always returns the same value
     def test_sma_add_1
-      sma = SimpleMovingAverage.new(1);
+      sma = SimpleMovingAverage.new(1)
       (1...1000).each do |i|
-        assert_equal(i, sma.add(i));
+        assert_equal(i, sma.add(i))
       end
     end
 
     # Verify SMA of 2, always returns the same value - 0.5
     def test_sma_add_2
-      sma = SimpleMovingAverage.new(2);
-      assert_equal(nil, sma.add(1));
+      sma = SimpleMovingAverage.new(2)
+      assert_equal(nil, sma.add(1))
       (2...1000).each do |i|
-        assert_equal(i - 0.5, sma.add(i));
+        assert_equal(i - 0.5, sma.add(i))
+      end
+      
+      (0..1000).to_a().each() do |i|
+        sma = SimpleMovingAverage.new(2)
+        assert_nil(value = sma.add(i))
+        assert_not_nil(value = sma.add(i+1))
+        assert_equal(i+0.5, value)
+      end
+    end
+    
+    def test_sma_array
+      assert_raise(ArgumentError) { SimpleMovingAverage.new(2).add_array(nil) }
+      assert_raise(ArgumentError) { SimpleMovingAverage.new(2).add_array("") }
+      assert_raise(ArgumentError) { SimpleMovingAverage.new(2).add_array(1) }
+      assert_nothing_raised(ArgumentError) { SimpleMovingAverage.new(2).add_array(Array.new) }
+      assert_not_nil( SimpleMovingAverage.new(2).add_array(Array.new) )
+      assert_not_nil( SimpleMovingAverage.new(2).add_array([]) )
+      assert_equal( 0, SimpleMovingAverage.new(2).add_array([]).length() )
+      assert_equal( 1, SimpleMovingAverage.new(2).add_array([1]).length() )
+      assert_equal( 2, SimpleMovingAverage.new(2).add_array((1..2).to_a).length() )
+      assert_equal( 1000, SimpleMovingAverage.new(2).add_array((1..1000).to_a).length() )
+      
+      values = SimpleMovingAverage.new(2).add_array((0..1000).to_a)
+      assert_nil(values[0])
+      1.upto(values.length() -1) do |i|
+        assert_not_nil(values[i])
+        assert_equal(i - 0.5, values[i])
+      end
+      
+      values = SimpleMovingAverage.new(14).add_array((0..14000).to_a)
+      0.upto(12) { |i| assert_nil(values[i], "#{i}") }
+
+      13.upto(values.length() -1) do |i|
+        assert_not_nil(values[i], "#{i}")
+
+        sum = 0.0
+        Range.new(i-13, i).each() { |value| sum = sum + value.to_f}
+        sum = sum / 14
+        
+        assert_equal(sum, values[i], "#{i}")
       end
     end
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: advanced_math
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 17
   prerelease: 
   segments: 
   - 0
   - 0
-  - 5
-  version: 0.0.5
+  - 7
+  version: 0.0.7
 platform: ruby
 authors: 
 - Glenn Nagel
@@ -48,9 +48,14 @@ files:
 - Manifest.txt
 - PostInstall.txt
 - README.rdoc
-- advanced_math-0.0.4.gem
 - advanced_math.gemspec
+- gem_publish.sh
 - lib/advanced_math.rb
+- lib/advanced_math/rsi.rb
+- lib/advanced_math/sma.rb
+- test/RSI.pm
+- test/rsi.pl
+- test/test_rsi.rb
 - test/test_simple_moving_average.rb
 homepage: https://github.com/gnagel/mercury-wireless-public/tree/master/ruby/advanced_math
 licenses: []
@@ -87,4 +92,5 @@ signing_key:
 specification_version: 3
 summary: A simple gem for advanced and financial math calcualtions.
 test_files: 
+- test/test_rsi.rb
 - test/test_simple_moving_average.rb