polynomial 0.7.0

data/lib/polynomial.rb

@@ -0,0 +1,532 @@
+begin
+  require 'handy_hash'
+rescue LoadError
+  unless defined? HandyHash
+    $stderr.puts 'HandyHash not be loaded, abbreviations not enabled'
+    HandyHash = Hash
+    Hash.class_eval { alias merge_abbrv merge }
+  end
+end
+
+# Polynomials on a single variable.
+#
+class Polynomial
+
+  attr_reader :coefs
+  
+  class << self
+    alias [] new
+  end
+  
+  def dup
+    Marshal.load(Marshal.dump(self))
+  end
+
+  # Creates a new polynomial with provided coefficients, which are interpreted
+  # as corresponding to increasing powers of _x_. Alternatively, a hash
+  # of power=>coefficients may be supplied, as well as the polynomial
+  # degree plus a block to compute each coefficient from correspoding degree.
+  # If a string, optionally followed by a arguments hash, is supplied,
+  # from_string is called.
+  #
+  # Examples:
+  #   Polynomial.new(1, 2).to_s #=> "1 + 2*x"
+  #   Polynomial.new(1, Complex(2,3)).to_s #=> "1 + (2+3i)*x"
+  #   Polynomial.new(3) {|n| n+1 }.to_s #=> "1 + 2*x + 3*x**2 + 4*x**3"
+  #   Polynomial[3, 4, 5].to_s #=> "3 + 4*x + 5x**2"
+  #   Polynomial[1 => 2, 3 => 4].to_s #=> "2*x + 4x**3"
+  #   Polynomial.new('x^2-1', :power_symbol=>'^').to_s #=> "-1 + x**2"
+  #
+  def initialize(*coefs)
+    case coefs[0]
+    when Integer
+      if block_given?
+        coefs = 0.upto(coefs[0]).map {|degree| yield(degree) }
+      end
+    when Hash
+      coefs = self.class.coefs_from_pow_coefs(coefs[0])
+    when String
+      coefs = self.class.coefs_from_string(coefs[0], coefs[1] || {})
+    else
+      coefs.flatten!
+      if coefs.empty?
+        raise ArgumentError, 'at least one coefficient should be supplied'
+      elsif !coefs.all? {|c| c.is_a? Numeric }
+        raise TypeError, 'non-Numeric coefficient supplied'
+      end
+    end
+    @coefs = Polynomial.remove_trailing_zeroes(coefs)
+    @coefs.freeze    
+  end
+  
+  FromStringDefaults = HandyHash[
+    :power_symbol => '**',
+    :multiplication_symbol => '*',
+    :variable_name => 'x',
+  ]
+  # Creates Polynomial from a String in appropriate format.
+  # Coefficients must be integers or decimals (interpreted as floats).
+  #
+  # Warning: complex coefficients are not currently accepted.
+  #
+  # Examples:
+  #   Polynomial.from_string("1 - 7*x**2") == Polynomial.new(1,0,-7) #=> true
+  #   Polynomial.from_string("3 + 4.1x + 5x^2", :multiplication_symbol=>'', :power_symbol=>'^') == Polynomial.new(3,4.1,5) #=> true
+  #   Polynomial.from_string("-3*y", :variable_name=>'y') == Polynomial.new(0,-3) #=> true
+  #   Polynomial.from_string('x^2-1', :power_symbol=>'^').to_s #=> -1 + x**2
+  #
+  def self.from_string(s, params={})
+    Polynomial.new(self.coefs_from_string(s, FromStringDefaults.merge_abbrv(params)))
+  end
+  
+  # Degree of the polynomial (i.e., highest not null power of the variable).
+  #
+  def degree
+    @coefs.size-1
+  end
+  
+  # Evaluates Polynomial of degree _n_ at point _x_ in O(_n_) time using Horner's rule.
+  #
+  def substitute(x)
+    total = @coefs.last
+    @coefs[0..-2].reverse.each do |a|
+      total = total * x + a
+    end
+    total
+  end
+
+  # Returns an array with the 1st, 2nd, ..., +degree+ derivatives.
+  # These are the only possibly non null derivatives, subsequent ones would
+  # necesseraly be zero.
+  #
+  def derivatives
+    ds = []
+    d = self
+    begin
+      d = d.derivative
+      ds << d
+    end until d.zero?
+    ds
+  end
+
+  def coerce(other)
+    case other
+    when Numeric
+      [Polynomial.new(other), self]
+    when Polynomial
+      [other, self]
+    else
+      raise TypeError, "#{other.class} can't be coerced into Polynomial"
+    end
+  end
+  
+  # Add another Polynomial or Numeric object.
+  #
+  def +(other)
+    case other
+      when Numeric
+        self + Polynomial.new(other)
+      else
+        small, big = [self, other].sort
+        a = big.coefs.dup
+        for n in 0 .. small.degree
+          a[n] += small.coefs[n]
+        end
+        Polynomial.new(a)
+    end
+  end
+  
+  # Generates a Polynomial object with negated coefficients.
+  #
+  def -@
+    Polynomial.new(coefs.map {|x| -x})
+  end
+  
+  # Subtract another Polynomial or Numeric object.
+  #
+  def -(other)
+    self + (-other)
+  end
+  
+  # Multiply by another Polynomial or Numeric object.
+  # As the straightforward algorithm is used, multipling two polynomials of
+  # degree _m_ and _n_ takes O(_m_ _n_) operations. It is well-known, though,
+  # that the Fast Fourier Transform may be employed to reduce the time
+  # complexity to O(_K_ log _K_), where _K_ = max{_m_, _n_}.
+  #
+  def *(other)
+    case other
+    when Numeric
+      result_coefs = @coefs.map {|a| a * other}
+    else
+      result_coefs = [0] * (self.degree + other.degree + 2)
+      for m in 0 .. self.degree
+        for n in 0 .. other.degree
+          result_coefs[m+n] += @coefs[m] * other.coefs[n]
+        end
+      end
+    end
+    Polynomial.new(result_coefs)
+  end
+
+  # Divides by +divisor+ (using coefficients' #quo), returning quotient and rest.
+  # If dividend and divisor have Intenger or Rational coefficients,
+  # then both quotient and rest will have Rational coefficients.
+  # If +divisor+ is a polynomial, uses polynomial long division.
+  # Otherwise, performs the division direclty on the coefficients.
+  #
+  def quomod(divisor)
+    case divisor
+    when Numeric
+      new_coefs = @coefs.map {|a| a.quo(divisor) }
+      q, r = Polynomial.new(new_coefs), 0
+    when Polynomial
+      a = self; b = divisor; q = 0; r = self
+      (a.degree - b.degree + 1).times do
+        dd = r.degree - b.degree
+        qqa = r.coefs[-1].quo(b.coefs[-1])
+        qq = Polynomial[dd => qqa]
+        q += qq
+        r -= qq * divisor
+        break if r.zero?
+      end
+    else
+      raise ArgumentError, 'divisor should be Numeric or Polynomial'
+    end
+    [q, r]
+  end
+
+  # Divides by +divisor+ (using coefficients' #quo), which may be a number
+  # or another polynomial, which need not be divisible by the former.
+  # If dividend and divisor have Intenger or Rational coefficients,
+  # then the quotient will have Rational coefficients.
+  #
+  #
+  def quo(divisor)
+    quomod(divisor).first
+  end
+
+  # Divides by +divisor+, returing quotient and rest.
+  # If +divisor+ is a polynomial, uses polynomial long division.
+  # Otherwise, performs the division direclty on the coefficients.
+  #
+  def divmod(divisor)
+    case divisor
+    when Numeric
+      new_coefs = @coefs.map do |a|
+        if divisor.is_a?(Integer)
+          qq, rr = a.divmod(divisor)
+          if rr.zero? then qq else a / divisor.to_f end
+        else
+          a / divisor
+        end
+      end
+      q, r = Polynomial.new(new_coefs), 0
+    when Polynomial
+      a = self; b = divisor; q = 0; r = self
+      (a.degree - b.degree + 1).times do
+        dd = r.degree - b.degree
+        qqa = r.coefs[-1] / (b.coefs[-1].to_f rescue b.coefs[-1]) # rescue for complex numbers
+        qq = Polynomial[dd => qqa]
+        q += qq
+        r -= qq * divisor
+        break if r.zero?
+      end
+    else
+      raise ArgumentError, 'divisor should be Numeric or Polynomial'
+    end
+    [q, r]
+  end
+
+  # Divides polynomial by a number or another polynomial,
+  # which need not be divisible by the former.
+  #
+  def div(other)
+    divmod(other).first
+  end
+  alias / div
+
+  # Remainder of division by supplied divisor, which may be another polynomial
+  # or a number.
+  #
+  def %(other)
+    divmod(other).last
+  end
+
+  # Raises to non-negative integer power.
+  #
+  def **(n)
+    raise ArgumentError, "negative argument" if n < 0
+    result = Polynomial[1]
+    n.times do
+      result *= self
+    end
+    result
+  end
+
+  # Computes polynomial's indefinite integral (which is itself a polynomial).
+  #
+  def integral
+    a = Array.new(@coefs.size+1)
+    a[0] = 0
+    @coefs.each.with_index do |coef, n|
+      if coef.is_a?(Integer) && coef.modulo(n+1).zero?
+        a[n+1] = coef / (n + 1)
+      else
+        a[n+1] = coef / (n + 1.0)
+      end
+    end
+    Polynomial.new(a)
+  end
+  
+  # Computes polynomial's derivative (which is itself a polynomial).
+  #
+  def derivative
+    if degree > 0
+      a = Array.new(@coefs.size-1)
+      a.each_index { |n| a[n] = (n+1) * @coefs[n+1] }
+    else
+      a = [0]
+    end
+    Polynomial.new(a)
+  end
+  
+  ToSDefaults = HandyHash[
+    :verbose => false,
+    :spaced => true,
+    :power_symbol => '**',
+    :multiplication_symbol => '*',
+    :variable_name => 'x',
+    :decreasing => false
+  ]
+  # Generate the string corresponding to the polynomial.
+  # If :verbose is false (default), omits zero-coefficiented monomials.
+  # If :spaced is true (default), monomials are spaced.
+  # If :decreasing is false (default), monomials are present from
+  # lowest to greatest degree.
+  #
+  # Examples:
+  #   Polynomial[1,-2,3].to_s #=> "1 - 2*x + 3*x**2"
+  #   Polynomial[1,-2,3].to_s(:spaced=>false) #=> "1-2*x+3*x**2"
+  #   Polynomial[1,-2,3].to_s(:decreasing=>true) #=> "3*x**2 - 2*x + 1"
+  #   Polynomial[1,0,3].to_s(:verbose=>true) #=> "1 + 0*x + 3*x**2"
+  #
+  def to_s(params={})
+    params = ToSDefaults.merge_abbrv(params)
+    mult = params[:multiplication_symbol]
+    pow = params[:power_symbol]
+    var = params[:variable_name]
+    coefs_index_enumerator = if params[:decreasing]
+                               @coefs.each.with_index.reverse_each
+                             else
+                               @coefs.each.with_index
+                             end
+    result = ''
+    coefs_index_enumerator.each do |a,n|
+      next if a.zero? && degree > 0 && !params[:verbose]
+      result += '+' unless result.empty?
+      coef_str = a.to_s
+      coef_str = '(' + coef_str + ')' if coef_str[/[+\/]/]
+      result += coef_str unless a == 1 && n > 0
+      result += "#{mult}" if a != 1 && n > 0
+      result += "#{var}" if n >= 1
+      result += "#{pow}#{n}" if n >= 2
+    end
+    result.gsub!(/\+-/,'-')
+    result.gsub!(/([^e\(])(\+|-)(.)/,'\1 \2 \3') if params[:spaced]
+    result
+  end
+
+  # Converts a zero-degree polynomial to a number, i.e., returns its only
+  # coefficient. If degree is positive, an exception is raised.
+  #
+  def to_num
+    if self.degree == 0
+      @coefs[0]
+    else
+      raise ArgumentError, "can't convert Polynomial of positive degree to Numeric"
+    end
+  end
+
+  # Returns the only coefficient of a zero-degree polynomial converted to a
+  # Float. If degree is positive, an exception is raised.
+  #
+  def to_f; to_num.to_f; end
+  
+  # Returns the only coefficient of a zero-degree polynomial converted to an
+  # Integer. If degree is positive, an exception is raised.
+  #
+  def to_i; to_num.to_i; end
+  
+  # If EasyPlot can be loaded, plot method is defined.
+  begin
+    require 'easy_plot'
+
+    # Plots polynomial using EasyPlot.
+    #
+    def plot(params={})
+      EasyPlot.plot(self.to_s, params)
+    end
+  rescue LoadError
+    $stderr.puts 'EasyPlot could not be loaded, thus plotting convenience methods were not defined.'
+  end
+
+  # Compares with another Polynomial by degrees then coefficients.
+  #
+  def <=>(other)
+    case other
+    when Numeric
+      [self.degree, @coefs[0]] <=> [0, other]
+    when Polynomial
+      [self.degree, @coefs] <=> [other.degree, other.coefs]
+    else
+      raise TypeError, "can't compare #{other.class} to Polynomial"
+    end
+  end
+  include Comparable
+  
+  # Returns true if the other Polynomial has same degree and close-enough
+  # (up to delta absolute difference) coefficients. Returns false otherwise.
+  #
+  def equal_in_delta(other, delta)
+    return false unless self.degree == other.degree
+    for n in 0 .. degree
+      return false unless (@coefs[n] - other.coefs[n]).abs <= delta
+    end  
+    true
+  end
+  
+  private
+
+  def self.remove_trailing_zeroes(ary)
+    m = 0
+    ary.reverse.each.with_index do |a,n|
+      unless a.zero?
+        m = n+1
+        break
+      end
+    end
+    ary[0..-m]
+  end
+
+  # Converts a power-to-coefficient Hash into the Array of coefficients.
+  #
+  def self.coefs_from_pow_coefs(hash, params={})
+    power_coefs = Hash.new(0).merge(hash)
+    (0..power_coefs.keys.max).map {|p| power_coefs[p] }
+  end
+  
+  # Extracts the Array of coefficients from a String.
+  #
+  def self.coefs_from_string(s, params={})
+    h = pow_coefs_from_string(s, params)
+    coefs_from_pow_coefs(h, params)
+  end
+  
+  # Extracts a power-to-coefficient Hash from a String.
+  #
+  def self.pow_coefs_from_string(s, params={})
+    h = Hash.new(0)
+    begin
+      power, coef, s = parse_term(s, params)
+      h[power] += coef
+    end until s.strip.empty?
+    h
+  end
+
+  # Parses a single polynomial term (i.e., a monomial). Returns an array with
+  # degree (power), coeficient and the remainder of the string, which may
+  # contains other terms.
+  #
+  # Example:
+  #   Polynomial.parse_term('x**2-3') #=> [2, 1, '-3']
+  #   Polynomial.parse_term('4') #=> [0, 4, '']
+  #
+  def self.parse_term(string, params={})
+    params = FromStringDefaults.merge(params)
+    mult = Regexp.escape(params[:multiplication_symbol])
+    pow_sym = Regexp.escape(params[:power_symbol])
+    var = Regexp.escape(params[:variable_name])
+    opt_sign = '(\+|-)?'
+    int = '(\d+)'
+    decimal = '(\d+(?:\.\d+)?(?:[eE]\-?\d+)?)'
+    opt_space = '\s*'
+    anything = '(.*)'
+    tbp = string.strip # tbp stands for 'to be parsed'
+    power, coef = nil, nil # scope reasons
+    make_regex = lambda {|core| Regexp.new('^' + core + '$') }
+
+    # matches terms starting with numbers, possibly signed, such as '1', '2.5', '- 3.3', '3*x', '4*x**2'
+    if md = make_regex[opt_sign + opt_space + decimal + anything].match(tbp)
+      sn = md[1] ? md[1]+md[2] : md[2]
+      coef = Integer(sn) rescue Float(sn)
+      tbp = md[-1]
+      if md = make_regex[mult + var + anything].match(tbp)
+        tbp = md[-1]
+        if md = make_regex[pow_sym + int + anything].match(tbp)
+          power = Integer(md[1])
+          tbp = md[-1]
+        else
+          power = 1
+        end
+      else
+        power = 0
+      end
+    # matches terms starting with variable, such as 'x', 'x**2'
+    elsif md = make_regex.call(opt_sign + opt_space + var + anything).match(tbp)
+      power, coef, tbp = 1, 1, md[-1].strip
+      if md = make_regex[pow_sym + int + anything].match(tbp)
+        power = Integer(md[1])
+        tbp = md[-1]
+      end
+    end
+    unless [power, coef].none? {|val| val.nil? } && (tbp[/^\s*\+|-/] || tbp.empty?)
+      raise ArgumentError, "invalid value for Polynomial: \"#{string}\""
+    end
+    [power, coef, tbp]
+  end
+
+  public
+
+  Zero = new([0])
+  Unity = new([1])
+
+  # Returns true if and only if the polynomial is null.
+  #
+  def zero?
+    self == Zero
+  end
+
+  # Returns true if and only if the polynomial is unity.
+  #
+  def unity?
+    self == Unity
+  end
+  
+=begin
+
+#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+#OBSOLETE CODE:
+#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
+  # Evaluates Polynomial at n equidistant points: x0, x0 + dx, ... , x0 + n*dx
+  # using forward differencing algorithm (approximate if degree > 1)
+  #
+  # TODO: implement it
+  #
+  # ref: http://www.cosc.brocku.ca/~cspress/HelloWorld/1999/04-apr/rendering_bezier_forms.html
+  #      http://www.niksula.cs.hut.fi/~hkankaan/Homepages/bezierfast.html
+  #
+  def sub_fd(x0, dx, n)
+    ds = self.derivatives.map {|d| d.substitute_single(x0)}
+
+    total = @coefs.last
+    @coefs[0..-2].reverse.each do |a|
+      total = total * x + a
+    end
+    total
+  end
+
+=end
+ 
+end

data/test/test_chebyshev.rb

@@ -0,0 +1,103 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+require 'polynomial/chebyshev'
+
+class TestChebyshev < Test::Unit::TestCase
+
+  @@epsilon = 1e-11
+
+  @@first_kind_in_out = {
+    0 => [1],
+    1 => [0,1],
+    2 => [-1,0,2],
+    3 => [0,-3,0,4],
+    4 => [1,0,-8,0,8],
+    5 => [0,5,0,-20,0,16],
+    6 => [-1,0,18,0,-48,0,32],
+    7 => [0,-7,0,56,0,-112,0,64],
+    8 => [1,0,-32,0,160,0,-256,0,128],
+    9 => [0,9,0,-120,0,432,0,-576,0,256],
+    10 => [-1,0,50,0,-400,0,1120,0,-1280,0,512],
+    33 => [0, 33, 0, -5984, 0, 323136, 0, -8186112, 0, 118243840, 0, -1083543552, 0, 6723526656, 0, -29455450112, 0, 93564370944, 0, -218864025600, 0, 379364311040, 0, -485826232320, 0, 453437816832, 0, -299708186624, 0, 132875550720, 0, -35433480192, 0, 4294967296],
+    117 => [0, 117, 0, -266916, 0, 182570544, 0, -59396283648, 0, 11252295957760, 0, -1392011303574528, 0, 121069290813456384, 0, -7794556246656811008, 0, 385830534209512144896, 0, -15117336720489657139200, 0, 479723485263538453217280, 0, -12560033068718097684234240, 0, 275483391973883609207537664, 0, -5126659590807429445423464448, 0, 81824517606975721197891747840, 0, -1130410109907982866613455028224, 0, 13624867309572732884712173862912, 0, -144263300924887759955775958548480, 0, 1349923260306156937003597257768960, 0, -11222034120763733781298460334489600, 0, 83262019013081166250511991067115520, 0, -553604830735923944815142850904719360, 0, 3310445048441080558894591593288826880, 0, -17859866348296375411168601454264975360, 0, 87173157176208499030703888050579046400, 0, -385886509100016289042582544437229912064, 0, 1552507116437220831968125998809871286272, 0, -5687298796914802239667747766683972927488, 0, 19000424301472259111471448052605854416896, 0, -57967396173983163390929841516424640593920, 0, 161675185831699489588691754699361401962496, 0, -412590438394874683108059244967545943359488, 0, 964033428172639884569792274299169848426496, 0, -2063232104076405216546475369508671064113152, 0, 4045553145247853365777402685311119733555200, 0, -7267343758706807816833129008945206636052480, 0, 11957379913488674657529090500258399350947840, 0, -18011476770588345970620395780569408752058368, 0, 24819642631241357126979301362698515409534976, 0, -31256154952683046300772375620665446215188480, 0, 35925284272775205069159360126962383242395648, 0, -37624952438486873601670279016307356413722624, 0, 35833288036654165334924075253626053727354880, 0, -30957815272511698038619249189981129550069760, 0, 24190734099562256383599311164796286114201600, 0, -17036893075247264324859685811788153639403520, 0, 10768527086364797273123092668320515998351360, 0, -6077645746391778080239684999813594695598080, 0, 3044044218338837303075374875336190470389760, 0, -1342868403884789080309483041273850259046400, 0, 516937856861788113291412877670567307640832, 0, -171623762110595558648434048859217472782336, 0, 48406702133757721670071141985933133348864, 0, -11369727956650552859202038639616105381888, 0, 2163454860932487122376194916134902824960, 0, -320354331577881795025074562520221483008, 0, 34627427749568765454669880019568820224, 0, -2429994929794299330152272282075004928, 0, 83076749736557242056487941267521536],
+  }
+
+  @@second_kind_in_out = {
+    0 => [1],
+    1 => [0,2],
+    2 => [-1,0,4],
+    3 => [0,-4,0,8],
+    4 => [1,0,-12,0,16],
+    5 => [0,6,0,-32,0,32],
+    6 => [-1,0,24,0,-80,0,64],
+    7 => [0,-8,0,80,0,-192,0,128],
+    8 => [1,0,-40,0,240,0,-448,0,256],
+    9 => [0,10,0,-160,0,672,0,-1024,0,512],
+  }
+  
+  def test_first_kind_invalid_degree
+    assert_raise(RangeError) { Polynomial::Chebyshev.first_kind(-1) }
+  end
+
+  def my_test_in_out_rand(in_out_hash, method_name)
+    keys, size = in_out_hash.keys, in_out_hash.size
+    100.times do
+      degree = keys[rand(size)]
+      coefs = in_out_hash[degree]
+      assert_equal Polynomial[*coefs], Polynomial::Chebyshev.send(method_name, degree)
+    end
+  end
+  
+  def my_test_in_out_seq(in_out_hash, method_name)
+    in_out_hash.each_pair do |degree, coefs|
+      assert_equal Polynomial[*coefs], Polynomial::Chebyshev.send(method_name, degree)
+    end
+  end
+  
+  def test_cached_first_kind
+    my_test_in_out_rand(@@first_kind_in_out, :first_kind)
+    my_test_in_out_seq(@@first_kind_in_out, :first_kind)
+  end
+  
+  def test_uncached_first_kind
+    my_test_in_out_rand(@@first_kind_in_out, :uncached_first_kind)
+    my_test_in_out_seq(@@first_kind_in_out, :uncached_first_kind)
+  end
+    
+  # See {Wikipedia entry}[http://en.wikipedia.org/wiki/Chebyshev_polynomials] for trigonometric definitions.
+  #
+  def test_first_kind_evaluation
+    9.downto(0) do |n|
+      10.times do
+        x = 2*rand-1
+        expected = Math.cos(n*Math.acos(x))
+        actual = Polynomial::Chebyshev.first_kind(n).substitute(x)
+        assert_in_delta expected, actual, @@epsilon
+      end
+    end
+  end
+  
+  def test_cached_second_kind
+    my_test_in_out_rand(@@second_kind_in_out, :second_kind)
+    my_test_in_out_seq(@@second_kind_in_out, :second_kind)
+  end
+
+  def test_uncached_second_kind
+    my_test_in_out_rand(@@second_kind_in_out, :uncached_second_kind)
+    my_test_in_out_seq(@@second_kind_in_out, :uncached_second_kind)
+  end
+  
+  # See {Wikipedia entry}[http://en.wikipedia.org/wiki/Chebyshev_polynomials] for trigonometric definitions.
+  #
+  def test_second_kind_evaluation
+    9.downto(0) do |n|
+      10.times do
+        theta = 2*Math::PI*rand - Math::PI
+        expected = Math.sin((n+1)*theta)/Math.sin(theta)
+        actual = Polynomial::Chebyshev.second_kind(n).substitute(Math.cos(theta))
+        assert_in_delta expected, actual, @@epsilon
+      end
+    end
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+
+require 'rubygems'
+require 'rational'
+
+$:.unshift(File.join(File.dirname(__FILE__), '../lib/'))

data/test/test_legendre.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+require 'polynomial/legendre'
+
+class TestLegendre < Test::Unit::TestCase
+
+  @@epsilon = 1e-12
+
+  @@in_out = {
+    0=>[1],
+    1=>[0, 1],
+    2=>[Rational(-1, 2), Rational(0, 1), Rational(3, 2)],
+    3=>[Rational(0, 1), Rational(-3, 2), Rational(0, 1), Rational(5, 2)],
+    4=>[Rational(3, 8), Rational(0, 1), Rational(-15, 4), Rational(0, 1), Rational(35, 8)],
+    5=>[Rational(0, 1), Rational(15, 8), Rational(0, 1), Rational(-35, 4), Rational(0, 1), Rational(63, 8)],
+    6=>[Rational(-5, 16), Rational(0, 1), Rational(105, 16), Rational(0, 1), Rational(-315, 16), Rational(0, 1), Rational(231, 16)],
+    7=>[Rational(0, 1), Rational(-35, 16), Rational(0, 1), Rational(315, 16), Rational(0, 1), Rational(-693, 16), Rational(0, 1), Rational(429, 16)],
+    8=>[Rational(35, 128), Rational(0, 1), Rational(-315, 32), Rational(0, 1), Rational(3465, 64), Rational(0, 1), Rational(-3003, 32), Rational(0, 1), Rational(6435, 128)],
+    9=>[Rational(0, 1), Rational(315, 128), Rational(0, 1), Rational(-1155, 32), Rational(0, 1), Rational(9009, 64), Rational(0, 1), Rational(-6435, 32), Rational(0, 1), Rational(12155, 128)],
+    10=>[Rational(-63, 256), Rational(0, 1), Rational(3465, 256), Rational(0, 1), Rational(-15015, 128), Rational(0, 1), Rational(45045, 128), Rational(0, 1), Rational(-109395, 256), Rational(0, 1), Rational(46189, 256)]
+  }
+
+  def test_invalid_degree
+    assert_raise(RangeError) { Polynomial::Legendre.uncached_legendre(-1) }
+    assert_raise(RangeError) { Polynomial::Legendre.cached_legendre(-1) }
+  end
+
+  def my_test_in_out_rand(in_out_hash, method_name)
+    keys, size = in_out_hash.keys, in_out_hash.size
+    100.times do
+      degree = keys[rand(size)]
+      coefs = in_out_hash[degree]
+      assert_equal Polynomial[*coefs], Polynomial::Legendre.send(method_name, degree)
+    end
+  end
+  
+  def my_test_in_out_seq(in_out_hash, method_name)
+    in_out_hash.each_pair do |degree, coefs|
+      assert_equal Polynomial[*coefs], Polynomial::Legendre.send(method_name, degree)
+    end
+  end
+  
+  def test_cached
+    my_test_in_out_rand(@@in_out, :cached_legendre)
+    my_test_in_out_seq(@@in_out, :cached_legendre)
+  end
+  
+  def test_uncached
+    my_test_in_out_rand(@@in_out, :uncached_legendre)
+    my_test_in_out_seq(@@in_out, :uncached_legendre)
+  end
+    
+end