polynomial 0.7.0

data/test/test_polynomial.rb

@@ -0,0 +1,404 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+require 'complex'
+require 'bigdecimal'
+require 'polynomial'
+
+Poly = Polynomial
+
+class TestPoly < Test::Unit::TestCase
+
+  @@epsilon = 1e-7
+
+  def setup
+    @one = Poly::Unity
+    @zero = Poly::Zero
+  end
+
+  def test_incorrect_initialization
+    assert_raise(ArgumentError) { Poly.new }
+    assert_raise(ArgumentError) { Poly.new [] }
+    assert_raise(TypeError) { Poly.new :oops }
+    assert_raise(TypeError) { Poly.new ['foo'] }
+  end
+  
+  def test_new_from_coefficients
+    assert_nothing_raised { Poly.new 0 }
+    assert_nothing_raised { Poly.new [0] }
+    assert_nothing_raised { Poly.new [1,2] }
+    assert_nothing_raised { Poly.new [1, 2.2] }
+    assert_nothing_raised { Poly.new [1, Complex(0,1)] }
+    assert_nothing_raised { Poly.new [1, BigDecimal('1e-2')] }
+    assert_nothing_raised { Poly.new 1,2 }
+    assert_equal Poly.new(1,2), Poly.new([1,2])
+    assert_equal Poly.new(1), Poly.new(1,0)
+    assert_equal Poly.new(1), Poly.new([1,0,0])
+    assert_equal Poly.new(1,2,3), Poly[1,2,3]
+  end
+
+  def test_new_from_block
+    assert_equal Poly.new(0,1,2), Poly.new(2) {|n| n }
+    assert_equal Poly.new(1,2,3), Poly.new(2) {|n| n+1 }
+    assert_equal Poly.new(0,1,4,9), Poly.new(3) {|n| n**2 }
+    assert_equal Poly.new(3.2), Poly.new(3.2) {|n| n**2 }
+  end
+  
+  def test_new_from_power_coefficients_hash
+    assert_equal Poly[0,2], Poly.new({1=>2})
+    assert_equal Poly[0,0,3], Poly.new({2=>3})
+    assert_equal Poly[0,2,3], Poly[1=>2, 2=>3]
+  end
+  
+  def test_new_from_valid_strings
+    assert_equal Poly[0], Poly['0']
+    assert_equal Poly[1], Poly['  1  ']
+    assert_equal Poly[-1], Poly['-1']
+    assert_equal Poly[-1.3], Poly['-1.3']
+    assert_equal Poly[0,1], Poly['x']
+    assert_equal Poly[0,1], Poly['+x']
+    assert_equal Poly[0,1], Poly['+1x', {:multiplication_symbol=>''}]
+    assert_equal Poly[1,1], Poly['1+x']
+    assert_equal Poly[1,1], Poly['1+1x', {:multiplication_symbol=>''}]
+    assert_equal Poly[0,0,3], Poly['3*x**2']
+    assert_equal Poly[0,0,1], Poly['x**2']
+    assert_equal Poly[3,0,1], Poly['3+x**2']
+    assert_equal Poly[3,0,1], Poly['3+x^2', {:power_symbol=>'^'}]
+    assert_equal Poly[3,2], Poly['3+2*x']
+    assert_equal Poly[2,1], Poly['2+y', {:variable_name=>'y'}]
+    assert_equal Poly['4*x**2+2'], Poly[2,0,4]
+    assert_equal Poly['  4*x**2  +  2  '], Poly[2,0,4]
+    assert_equal Poly[1,0,-7], Poly.from_string("1 - 7*x**2")
+    assert_equal Poly[3,4.1,5], Poly.from_string("3 + 4.1x + 5x^2", :multiplication_symbol=>'', :power_symbol=>'^')
+    assert_equal Poly[0,-3], Poly.from_string("-3*y", :variable_name=>'y')
+    assert_equal Poly[1e-2], Poly.from_string('1e-2')
+    assert_equal Poly[0,1e-2], Poly.from_string('1e-2*x')
+    assert_equal Poly[BigDecimal('1.1')], Poly.from_string(BigDecimal('1.1').to_s)
+  end
+  
+  def test_from_invalid_strings_misc
+    assert_raise(ArgumentError) { Poly[''] }
+    assert_raise(ArgumentError) { Poly['1..'] }
+    assert_raise(ArgumentError) { Poly['1..1'] }
+    assert_raise(ArgumentError) { Poly['+'] }
+    assert_raise(ArgumentError) { Poly['++1'] }
+    assert_raise(ArgumentError) { Poly['-+1'] }
+    assert_raise(ArgumentError) { Poly['--1'] }
+    assert_raise(ArgumentError) { Poly['1-'] }
+    assert_raise(ArgumentError) { Poly['1.2-'] }
+    assert_raise(ArgumentError) { Poly['xx'] }
+    assert_raise(ArgumentError) { Poly['xx**2'] }
+    assert_raise(ArgumentError) { Poly['x*x'] }
+    assert_raise(ArgumentError) { Poly['x**x'] }
+    assert_raise(ArgumentError) { Poly['2**3'] }
+    assert_raise(ArgumentError) { Poly['x**3*4'] }
+    assert_raise(ArgumentError) { Poly['e2'] }
+    assert_raise(ArgumentError) { Poly['1e--2'] }
+    assert_raise(ArgumentError) { Poly['1ee2'] }
+  end
+  
+  def test_from_invalid_strings_incomplete
+    assert_raise(ArgumentError) { Poly['1+'] }
+    assert_raise(ArgumentError) { Poly['1.2+'] }
+    assert_raise(ArgumentError) { Poly['1*'] }
+    assert_raise(ArgumentError) { Poly['1.2*'] }
+    assert_raise(ArgumentError) { Poly['2*x**'] }
+  end
+
+  def test_from_invalid_strings_symbol_omission
+    assert_raise(ArgumentError) { Poly['1x'] }
+    assert_raise(ArgumentError) { Poly['1.2x'] }
+    assert_raise(ArgumentError) { Poly['2*x3'] }
+  end
+
+  def test_from_invalid_strings_spaces
+    assert_raise(ArgumentError) { Poly['1 * x'] }
+    assert_raise(ArgumentError) { Poly['1 *x'] }
+    assert_raise(ArgumentError) { Poly['1* x'] }
+    assert_raise(ArgumentError) { Poly['1*x ** 2'] }
+    assert_raise(ArgumentError) { Poly['1*x **2'] }
+    assert_raise(ArgumentError) { Poly['1*x** 2'] }
+  end
+  
+  def test_from_string_repeated
+    assert_equal Poly['1+2'], Poly[3]
+    assert_equal Poly['x+3*x'], Poly[0,4]
+    assert_equal Poly['1+x+x**2+2*x**2'], Poly[1,1,3]
+  end
+  
+  def test_substitute
+    poly = Poly[0]
+    pairs = [[0,0], [1,0], [-1,0], [2,0], [0.33, 0]]
+    assert_in_out_pairs(poly, pairs)
+
+    poly = Poly[0, 1]
+    pairs = [[0,0], [1,1], [-1,-1], [2,2], [0.33, 0.33]]
+    assert_in_out_pairs(poly, pairs)
+
+    poly = Poly[0, 0, 1]
+    pairs = [[0,0], [1,1], [-1,1], [2,4], [0.33, 0.33**2]]
+    assert_in_out_pairs(poly, pairs)
+
+    poly = Poly[1, 1]
+    pairs = [[0,1], [1,2], [-1,0], [2,3], [0.33, 1.33]]
+    assert_in_out_pairs(poly, pairs)
+
+    poly = Poly[1, -1]
+    pairs = [[0,1], [1,0], [-1,2], [2,-1], [0.33, 1-0.33]]
+    assert_in_out_pairs(poly, pairs)
+    
+    poly = Poly[Complex(0,1), 1]
+    pairs = [[0,Complex(0,1)], [1,Complex(1,1)], [-1,Complex(-1,1)], [2,Complex(2,1)], [0.33, Complex(0.33,1)]]
+    assert_in_out_pairs(poly, pairs)
+
+    poly = Poly[BigDecimal('0'), BigDecimal('1.11')]
+    pairs = [[0,BigDecimal('0')], [1,BigDecimal('1.11')], [-1,BigDecimal('-1.11')], [2,BigDecimal('2.22')], [BigDecimal('0.33'), BigDecimal('0.3663')]]
+    assert_in_out_pairs(poly, pairs)
+end
+  
+  def test_degree
+    assert_equal 0, Poly[0].degree
+    assert_equal 0, Poly[1].degree
+    assert_equal 1, Poly[1,2].degree
+    assert_equal 1, Poly[0,-1].degree
+    assert_equal 2, Poly[1,0,1].degree
+  end
+  
+  def test_multiplication
+    assert_equal Poly[0], Poly[1] * 0
+    assert_equal Poly[0], 0 * Poly[1]
+    assert_equal Poly[1], Poly[1] * 1
+    assert_equal Poly[1], 1 * Poly[1]
+    assert_equal Poly[2], Poly[1] * 2
+    assert_equal Poly[2], Poly[1] * Poly[2]
+    assert_equal Poly[2,4,6], Poly[1,2,3] * 2
+    assert_equal Poly[2,4,6], 2 * Poly[1,2,3]
+    assert_equal Poly[0,0,1,2], Poly[0,1,2] * Poly[0,1]
+  end
+  
+  def test_division_by_numeric
+    assert_equal Poly[0], Poly[0] / 1
+    assert_equal Poly[1], Poly[1] / 1
+    assert_equal Poly[0.5], Poly[1] / 2
+    assert_equal Poly[0.5], Poly[1] / 2.0
+    assert_equal Poly[1,2,3], Poly[2,4,6] / 2
+  end
+
+  def test_divmod
+    assert_equal [Poly[3], Poly[-8,-4]], Poly[1,2,3].divmod(Poly[3,2,1])
+    assert_equal [Poly[0], Poly[1,2]], Poly[1,2].divmod(Poly[1,2,3])
+    assert_equal [Poly[-27,-9,1], Poly[-123]], Poly[-42,0,-12,1].divmod(Poly[-3,1])
+    assert_equal [Poly[4,6], Poly[2]], Poly[2,4,6].divmod(Poly[0,1])
+    assert_equal [Poly[1,2,3], 0], Poly[2,4,6].divmod(2)
+    assert_raise(ArgumentError) { Poly[1,2,3].divmod(:foo) }
+    assert_raise(ArgumentError) { Poly[1,2,3].divmod(nil) }
+  end
+
+  def test_division_by_polynomial
+    assert_equal Poly[2], Poly[2,4,6] / Poly[1,2,3]
+    assert_equal Poly[0.5], Poly[1,2,3] / Poly[2,4,6]
+    assert_equal Poly[3], Poly[1,2,3] / Poly[3,2,1]
+    assert_equal Poly[1,2,3], Poly[2,4,6] / Poly[2]
+  end
+
+  @@quomod_data = [
+    [Poly[1,2,3], Poly[3,2,1], Poly[3], Poly[-8,-4]],
+    [Poly[1,2], Poly[1,2,3], Poly[0], Poly[1,2]],
+    [Poly[-42,0,-12,1], Poly[-3,1], Poly[-27,-9,1], Poly[-123]],
+    [Poly[1,3.quo(2)], 2, Poly[1.quo(2), 3.quo(4)], 0],
+    [Poly[2,4,6], Poly[0,3], Poly[4.quo(3),6.quo(3)], Poly[2]],
+    [Poly[1,3.quo(2)], Poly[2], Poly[1.quo(2), 3.quo(4)], 0],
+    [Poly[2,4,6], 2, Poly[1,2,3], 0],
+  ]
+  def test_quomod
+    @@quomod_data.each do |dividend, divisor, quotient, rest|
+      dividend_bak = dividend.dup
+      divisor_bak = begin divisor.dup rescue divisor end
+      assert_equal [quotient, rest], dividend.quomod(divisor)
+      assert_equal dividend_bak, dividend
+      assert_equal divisor_bak, divisor
+    end
+    assert_raise(ArgumentError) { Poly[1,2,3].quomod(:foo) }
+    assert_raise(ArgumentError) { Poly[1,2,3].quomod(nil) }
+  end
+
+  def test_quo_by_numeric
+    assert_equal Poly[1.quo(2), 3.quo(4)], Poly[1,3.quo(2)].quo(2)
+    assert_equal Poly[1/2.0, 3.quo(2)/2.0], Poly[1,3.quo(2)].quo(2.0)
+  end
+
+  def test_quo_by_polynomial
+    assert_equal Poly[4.quo(3),6.quo(3)], Poly[2,4,6].quo(Poly[0,3])
+    assert_equal Poly[1.quo(2), 3.quo(4)], Poly[1,3.quo(2)].quo(2)
+  end
+
+  def test_remainder
+    @@quomod_data.each do |dividend, divisor, quotient, rest|
+      assert_equal rest, dividend % divisor
+    end
+  end
+
+  @@power_data = [
+    [Poly[1], 0, Poly[1]],
+    [Poly[1], 1, Poly[1]],
+    [Poly[1], 2, Poly[1]],
+    [Poly[0,1], 1, Poly[0,1]],
+    [Poly[0,1], 2, Poly[0,0,1]],
+    [Poly[3,4], 2, Poly[9,24,16]],
+  ]
+  def test_power
+    @@power_data.each do |polynomial, power, result|
+      assert_equal result, polynomial**power
+    end
+    assert_raise(ArgumentError) { Poly[1,2,3]**(-1) }
+    assert_raise(NoMethodError) { Poly[1,2,3]**(1.1) }
+    # Exceptions raised in Ruby 1.8 and 1.9 are different for the following
+    assert_raise(ArgumentError, NoMethodError) { Poly[1,2,3]**(:foo) }
+  end
+
+  def test_addition
+    assert_equal Poly[1], Poly[1] + 0
+    assert_equal Poly[2], Poly[1] + 1
+    assert_equal Poly[1,1], Poly[1] + Poly[0,1]
+    assert_equal Poly[2,3,4], Poly[2] + Poly[0,3,4]
+  end
+  
+  def test_subtraction
+    assert_equal Poly[1], Poly[1] - 0
+    assert_equal Poly[0], Poly[1] - 1
+    assert_equal Poly[1,-1], Poly[1] - Poly[0,1]
+    assert_equal Poly[2,-3,-4], Poly[2] - Poly[0,3,4]
+  end
+  
+  def test_to_s
+    assert_equal "0", Poly[0].to_s
+    assert_equal "1", Poly[1].to_s
+    assert_equal "x", Poly[0,1].to_s
+    assert_equal "1 + x", Poly[1,Complex(1,0)].to_s
+    assert_equal "0 + x", Poly[0,1].to_s(:verbose=>true)
+    assert_equal "1 - 2*x + 3*x**2", Poly[1,-2,3].to_s
+    assert_equal "3*x**2 - 2*x + 1", Poly[1,-2,3].to_s(:decreasing=>true)
+    assert_equal "1 + 0*x + 3*x**2", Poly[1,0,3].to_s(:verbose=>true)
+    assert_equal "-1 - 3*x^2", Poly[-1,0,-3].to_s(:power_symbol=>'^')
+    assert_equal "-1*y - 3*y**2", Poly[0,-1,-3].to_s(:variable_name=>'y')
+    assert_equal "0+x", Poly[0,1].to_s(:verbose=>true, :spaced=>false)
+    assert_equal "1-2*x+3*x**2", Poly[1,-2,3].to_s(:spaced=>false)
+    assert_equal "1+0*x+3*x**2", Poly[1,0,3].to_s(:verbose=>true, :spaced=>false)
+    assert_equal "-1-3*x^2", Poly[-1,0,-3].to_s(:power_symbol=>'^', :spaced=>false)
+
+    case RUBY_VERSION # Complex#to_s results in Ruby 1.8 and 1.9 are different
+    when /^1[.]9/
+      assert_equal "1 + (0 + 1i)*x", Poly[1,Complex(0,1)].to_s
+    else
+      assert_equal "1 + 1i*x", Poly[1,Complex(0,1)].to_s
+    end
+    
+    assert_equal "1 + (1 + 1i)*x", Poly[1,Complex(1,1)].to_s
+    assert_equal "1 + x", Poly[1,Complex(1,0)].to_s
+    assert_equal "-3.33694235763727e-05", Poly[-3.33694235763727e-05].to_s
+    assert_equal "1 + 3.33694235763727e-05*x", Poly[1,3.33694235763727e-05].to_s
+    assert_equal "1 + (2/3)*x", Poly[1,2.quo(3)].to_s
+    assert_equal "(-1/2) + (3/2)*x**2", Poly[-1.quo(2), 0, 3.quo(2)].to_s
+  end
+
+  def test_to_i
+    assert_raise(ArgumentError) { Poly[1,2].to_i }
+    assert_equal 0, Poly[0].to_i
+    assert_equal 3, Poly[3].to_i
+    assert_equal(-2, Poly[-2].to_i)
+    assert_equal 3, Poly[3.3].to_i
+  end
+  
+  def test_to_f
+    assert_raise(ArgumentError) { Poly[1,2].to_f }
+    assert_equal 0.0, Poly[0].to_f
+    assert_equal 3.1, Poly[3.1].to_f
+    assert_equal(-2.2, Poly[-2.2].to_f)
+  end
+
+  def test_integral
+    assert_equal Poly[0], Poly[0].integral
+    assert_equal Poly[0,1], Poly[1].integral
+    assert_equal Poly[0,1], Poly[1].integral
+    assert_equal Poly[0,1,1/2.0], Poly[1,1].integral
+    assert_equal Poly[0,1,1/2.0,1/3.0], Poly[1,1,1].integral
+  end
+
+  def test_derivative
+    assert_equal Poly[0], Poly[0].derivative
+    assert_equal Poly[0], Poly[1].derivative
+    assert_equal Poly[0], Poly[2].derivative
+    assert_equal Poly[1], Poly[0,1].derivative
+    assert_equal Poly[1,2], Poly[1,1,1].derivative
+  end
+
+  def test_derivatives
+    z = Poly[0]
+    assert_equal [z], z.derivatives
+    assert_equal [Poly[1], z], Poly[0,1].derivatives
+    assert_equal [Poly[2], z], Poly[1,2].derivatives
+    assert_equal [Poly[4,10], Poly[10], z], Poly[3,4,5].derivatives
+    assert_equal [Poly[2,6,12], Poly[6,24], Poly[24], z], Poly[1,2,3,4].derivatives
+  end
+
+  def test_integral_derivative_cascading
+    coefs = Array.new(16) { rand }
+    assert Poly[coefs].equal_in_delta Poly[coefs].integral.derivative, @@epsilon
+    assert Poly[0, *coefs[1..-1]].equal_in_delta Poly[coefs].derivative.integral, @@epsilon
+  end
+  
+  def test_equal_in_delta
+    assert Poly[0].equal_in_delta(Poly[@@epsilon], @@epsilon)
+    assert Poly[1].equal_in_delta(Poly[1-@@epsilon], @@epsilon)
+    assert Poly[-@@epsilon,@@epsilon].equal_in_delta(Poly[@@epsilon, -@@epsilon], 2*@@epsilon)
+  end
+  
+  def test_derivative_integral
+    [ [0], [1], [0, 42], [1,11], [3,4,5] ].each do |coefs|
+      poly = Poly.new(coefs)
+      assert poly.equal_in_delta(poly.integral.derivative, @@epsilon)
+    end
+    1.upto(10) do |n|
+      poly = Poly.new( Array.new(n) {|m| 2*m + rand } )
+      assert poly.equal_in_delta(poly.integral.derivative, @@epsilon)
+    end
+  end
+
+  def test_compare
+    a = Poly[2]
+    b = Poly[2,1]
+    c = Poly[2,2]
+    d = Poly[2,1,2]
+    assert_equal [a,b,c,d], [d,b,c,a].sort
+    assert_equal 0, Poly[0]
+    assert_equal Poly[1], 1
+    assert_equal Poly[0.5], 0.5
+    assert_equal 0.5, Poly[0.5]
+    assert_not_equal 1, Poly[1,2]
+    assert_raise(TypeError) { Poly[1] <=> 'foo' }
+  end
+
+  def test_coerce
+    assert_equal [Poly[2],Poly[1]], Poly[1].coerce(2)
+    assert_equal [Poly[2],Poly[1]], Poly[1].coerce(Poly[2])
+    assert_raise(TypeError) { Poly[1].coerce('foo') }
+  end
+
+  def test_unity_and_zero
+    assert_equal @one, @one*@one
+    assert_not_equal @zero, @one
+    assert_equal @zero, @one*@zero
+    q = Poly.new(2,3,5,7)
+    assert_equal q, @one*q
+    assert_equal @zero, q*@zero
+    assert @zero.zero?
+  end
+  
+  # HELPER FUNCTIONS
+  
+  def assert_in_out_pairs(polynomial, input_output_pairs, delta=@@epsilon)
+    input_output_pairs.each do |x, y|
+      assert_equal y, polynomial.substitute(x)
+    end
+  end
+  
+end

data/test/test_suite.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+class String
+  def same_file?(other)
+    File.expand_path(self) == File.expand_path(other)
+  end
+end
+
+candidates = Dir.glob('test_*.rb')
+to_exclude = [__FILE__, 'test_helper.rb']
+
+test_files = candidates.reject {|f| to_exclude.any? {|ex| f.same_file?(ex) } }
+
+test_files.each do |tf|
+  system "ruby #{tf}"
+end

data/test/test_ultraspherical.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+require 'polynomial/ultraspherical'
+
+class TestUltraspherical < Test::Unit::TestCase
+
+  @@epsilon = 1e-12
+
+  def test_invalid_range
+    assert_raise(RangeError) { Polynomial::Ultraspherical.us(-3,-3) }
+    assert_raise(RangeError) { Polynomial::Ultraspherical.us(-2,1) }
+    assert_raise(RangeError) { Polynomial::Ultraspherical.us(-1,0) }
+    assert_raise(RangeError) { Polynomial::Ultraspherical.us(2,-1) }
+  end
+
+  def test_ok_range
+    assert_nothing_raised { Polynomial::Ultraspherical.us(1,-0.5) }
+    assert_nothing_raised { Polynomial::Ultraspherical.us(2,-0.99) }
+    assert_nothing_raised { Polynomial::Ultraspherical.us(3,0.1) }
+    assert_nothing_raised { Polynomial::Ultraspherical.us(0,-3) }
+    assert_nothing_raised { Polynomial::Ultraspherical.us(7,1) }
+  end
+
+  def test_coefficients
+    in_out = {
+      [0,3] => [1],
+      [1,3] => [0,6],
+      [2,3] => [-3,0,24],
+      [3,3] => [0,-24,0,80],
+      [4,3] => [6, 0, -120, 0, 240],
+      [5,2] => [0, 24, 0, -160, 0, 192],
+      [6,1] => [-1, 0, 24, 0, -80, 0, 64],
+      [2,-0.5] => [0.5, 0, -0.5],
+      [4,0] => [1, 0, -8, 0, 8],
+      [4,1.quo(2)] => [Rational(3, 8), Rational(0, 1), Rational(-15, 4), Rational(0, 1), Rational(35, 8)],
+      [4,0.5] => [Rational(3, 8), Rational(0, 1), Rational(-15, 4), Rational(0, 1), Rational(35, 8)],
+      [4,1] => [1, 0, -12, 0, 16],
+    }
+    in_out.each_pair do |args, coefs|
+      assert_equal Polynomial[*coefs], Polynomial::Ultraspherical.us(*args)
+    end
+    
+  end
+
+end

data/website/index.txt

@@ -0,0 +1,57 @@
+h1. Polynomials in Ruby
+
+h1. polynomial
+
+
+h2. What
+
+Rich-featured single and multiple variables polynomials classes for Ruby.
+
+h2. Installing
+
+<pre syntax="ruby">sudo gem install polynomial</pre>
+
+h2. The basics
+
+<pre syntax="ruby">Polynomial.new(1, 2) #=> #<Polynomial:0x7f25286cea68 @coefs=[1, 2]></pre>
+
+h2. Demonstration of usage
+
+<pre syntax="ruby">
+foo = Polynomial.new(1, 2) #=> #<Polynomial:0x7f25286cea68 @coefs=[1, 2]>
+foo.to_s #=> "1 + 2*x"
+foo.plot # open gnuplot window with 'foo' plotted (require EasyPlot gem)
+
+bar = Polynomial.new(3) {|n| n+1 } #=> #<Polynomial:0x7f25287461a8 @coefs=[1, 2, 3, 4]>
+bar.to_s(:power_symbol=>'^') #=> "1 + 2*x + 3*x^2 + 4*x^3"
+
+require 'rational'
+baz = bar.quo(foo) #=> #<Polynomial:0x7f00a1ff0570 @coefs=[Rational(3, 4), Rational(1, 2), Rational(2, 1)]>
+baz.to_s #=> "(3/4) + (1/2)*x"
+</pre>
+
+h2. How to submit patches
+
+Read the "8 steps for fixing other people's code":http://drnicwilliams.com/2007/06/01/8-steps-for-fixing-other-peoples-code/ and for section "8b: Submit patch to Google Groups":http://drnicwilliams.com/2007/06/01/8-steps-for-fixing-other-peoples-code/#8b-google-groups, use the Google Group above.
+
+You can fetch the source from:
+
+* github: "http://github.com/adrianomitre/Polynomial/tree/master":http://github.com/adrianomitre/Polynomial/tree/master
+
+<pre>git clone git@github.com:adrianomitre/Polynomial.git</pre>
+
+h3. Build and test instructions
+
+<pre>cd polynomial
+rake test
+rake install_gem</pre>
+
+
+h2. License
+
+This code is free to use under the terms of the MIT license. 
+
+h2. Contact
+
+Comments are welcome. Send an email to "Adriano Mitre":mailto:adriano.mitre@gmail.com.
+

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification 
+name: polynomial
+version: !ruby/object:Gem::Version 
+  hash: 3
+  prerelease: false
+  segments: 
+  - 0
+  - 7
+  - 0
+  version: 0.7.0
+platform: ruby
+authors: 
+- Adriano Brito Mitre
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-18 00:00:00 -02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 2
+        - 6
+        - 2
+        version: 2.6.2
+  type: :development
+  version_requirements: *id002
+description: description of gem
+email: 
+- adriano@mitre.com.br
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- README.txt
+- website/index.txt
+files: 
+- lib/polynomial.rb
+- lib/polynomial/ultraspherical.rb
+- lib/polynomial/version.rb
+- lib/polynomial/legendre.rb
+- lib/polynomial/multivariate.rb
+- lib/polynomial/chebyshev.rb
+- test/test_chebyshev.rb
+- test/test_polynomial.rb
+- test/test_helper.rb
+- test/test_suite.rb
+- test/test_ultraspherical.rb
+- test/test_multivariate.rb
+- test/test_legendre.rb
+- History.txt
+- License.txt
+- Manifest.txt
+- README.txt
+- website/index.txt
+has_rdoc: true
+homepage: http://polynomial.rubyforge.org
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: polynomial
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: description of gem
+test_files: 
+- test/test_chebyshev.rb
+- test/test_polynomial.rb
+- test/test_helper.rb
+- test/test_suite.rb
+- test/test_ultraspherical.rb
+- test/test_multivariate.rb
+- test/test_legendre.rb