polynomial 0.7.0

data/History.txt

@@ -0,0 +1,176 @@
+== 0.7.0 2010-11-18
+
+* 1 important bugfix:
+  * Basic operations no longer alter the operands
+
+* Lots fo small improvements:
+  * new method #dup
+  * requires no longer alter $:
+  * README.txt finally written
+  * fixed typo in HandyHash LoadError message
+  * removed redundant #zero?
+  * improved test handling of differences between Ruby 1.8 and 1.9
+  * test coverage reached 100% (except for Multivariate which is currently at 93.71%)
+  * All tests run flawlessly (100% pass) with the following Ruby versions:
+    * MRI 1.8.7 (2008-06-20 patchlevel 22) [x86_64-linux]
+    * MRI 1.8.7 (2010-08-16 patchlevel 302) [x86_64-linux]
+    * MRI ruby 1.9.2p0 (2010-08-18 revision 29036) [x86_64-linux]
+    * jruby 1.5.3 (ruby 1.8.7 patchlevel 249) (2010-09-28 7ca06d7) (Java HotSpot(TM) 64-Bit Server VM 1.6.0_17) [amd64-java]
+    * rubinius 1.1.0 (1.8.7 release 2010-09-23 JI) [x86_64-unknown-linux-gnu]
+    * But they fail with the following Ruby version:
+      * ruby 1.8.6 (2010-02-05 patchlevel 399) [x86_64-linux]
+
+== 0.6.0 2009-07-10
+
+* 1 new feature:
+  * Polynomial::Multivariate
+
+== 0.5.3 2009-07-10
+
+* 1 new feature:
+  * Polynomial::Unity and Polynomial::Zero
+
+* additional tests for substitute with BigDecimal coefficients and x
+
+== 0.5.2 2009-06-22
+
+* 1 bugfix: Polynomial[0]#to_s evaluates to "0" instead of ""
+
+== 0.5.1 2009-06-22
+
+* 1 minor enhancement:
+  * comments rearranging for correct RDoc output
+  * fixing some comments content
+  * new comments added
+
+== 0.5.0 2009-06-22
+
+* 1 bugfix:
+  * division by degree 1 polynomial now works as expected
+
+* 5 new features:
+  * Polynomial#%(d) gives the remainder of the division by d
+  * Polynomial#**(n) raises to non-negative integer power
+  * Polynomial#quodiv and #quo
+    * like #divmod and #div but using #quo instead of #div, therefore if
+      dividend and divisor are integers or rationals the quotient and rest
+      will also be rational
+  * Polynomial#new accepts degree + block, e.g. Polynomial.new(2) {|n| n+1 }
+  * new module: Polynomials::Legendre
+
+* 4 minor enhancements:
+  * class variables changed to instance module variables
+  * Ultraspherical particular alphas values of 0, 1 and 0.5 delegates
+    respectively to Chebyshev first kind, second kind and Legendre.
+  * coefs attr_reader access changed from protected to public
+  * more tests: according to rcov, test coverage is 98.1% for polynomial class
+    and 100% for Chebyshev, Legendre and Ultraspherical
+
+* removed feature:
+  * substitute(*xs) removed, and substitute_single(x) renamed to substitute(x)
+
+== 0.4.3 2009-06-17
+
+* 1 minor enhancement:
+  * Ultraspherical alpha values no longer restricted to some predefined range
+    - RangeError exception is only raised if degree of generated polynomial is not the required
+
+== 0.4.2 2009-06-16
+
+* 1 minor enhancement:
+  * Polynomial.from_string now accepts numbers in scientific notation (e.g. '1e-2*x')
+
+== 0.4.1 2009-06-15
+
+* bugfixes
+  * #to_s no longer spaces "1e-3" to "1e - 3"
+
+* minor enhancements:
+  * ultrasph. alpha range extended down to -0.99999999999999 (Polynomial::Ultraspherical::MinAlpha)
+  * better tests for Chebyshev polynomials (concise, randomized)
+
+== 0.4.0 2009-06-15
+
+* 2 bugfixes:
+  * Polynomial#coerce now works as expected, returning two Polynomial objects
+  * Polynomial.from_string parsing is now faster and stricter
+
+* 5 new methods:
+  * to_num, to_f, to_i
+  * divmod
+  * /
+
+* 3 new features:
+  * Complex coefficients should work, though most tests are focused on Integer and Float
+  * if HandyHash gem is installed, abbreviations are enabled
+  * 2 new Polynomial#to_s parameters
+    - :spaced to allow spaces between terms (default to true)
+    - :decreasing, to allow greatest to smallest degree monomials
+  * to_s
+
+* 1 change:
+  * default Polynomial#to_s parameters changed to match those of Polynomial.from_string
+
+* 1 new module:
+  * Polynomial::Ultraspherical - generates ultraspherical (Gegenbauer) polynomials
+
+== 0.3.0 2009-06-12
+
+* 2 minor enhancements:
+  * Chebyshev module is now defined inside Polynomial class, thus
+    it is now necessary to prepend Polynomial:: to method calls.
+
+  * uncached interactive versions available:
+    - Polynomial::Chebyshev.uncached_first_kind and ...second_kind
+    - Default is cached.
+
+Uncached versions have O(1) memory consumption versus O(n^2) of the cached
+version, however its amortized (average of many calss) time consumption
+is higher.
+
+== 0.2.1 2009-06-09
+
+* 1 minor enhancement:
+  * interactive versions of Chebyshev.first_kind and Chebyshev.second_kind (2x faster)
+
+== 0.2.0 2009-06-09
+
+* 2 new features:
+  * new initializer: Polynomial.new(pow_coef_hash)
+  * new constructor: Polynomial.from_string
+
+== 0.1.3 2009-06-09
+
+* 1 compatibility change:
+  * abandoned colons in favor of linebreaks in case statements, so that the gem is now Ruby 1.9 compatible
+
+== 0.1.2 2009-02-14
+
+* 1 minor enhancement:
+  * to_s has a parameter to change the multiplication symbol from the default '*', e.g. to ''
+
+== 0.1.1 2009-02-10
+
+* 1 bugfix:
+  * to_s no longer doubles plus signal when omitting a zero coefficient
+
+* 1 minor enhancement:
+  * to_s has a verbose flag to disable omitting powers with zero coefficient
+  * to_s has a parameter to change the power symbol from the default '**', e.g. to '^'
+
+== 0.1.0 2009-01-06
+
+* 1 minor enhancement:
+  * Substitute now accepts an array of x-values
+  * New method #zero? (null polynomial)
+  * New method #derivatives
+
+== 0.0.2 2008-06-17
+
+* 1 minor enhancement:
+  * Simplifications due to Chebyshev not being a class anymore (it is now a module).
+
+== 0.0.1 2008-05-06
+
+* 1 major enhancement:
+  * Initial release

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008 FIXME full name
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,34 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+config/hoe.rb
+config/requirements.rb
+lib/polynomial.rb
+lib/polynomial/chebyshev.rb
+lib/polynomial/legendre.rb
+lib/polynomial/multivariate.rb
+lib/polynomial/ultraspherical.rb
+lib/polynomial/version.rb
+script/console
+script/destroy
+script/generate
+script/txt2html
+setup.rb
+tasks/deployment.rake
+tasks/environment.rake
+tasks/website.rake
+test/bench_cheby_pol_vs_trig.rb
+test/test_chebyshev.rb
+test/test_helper.rb
+test/test_legendre.rb
+test/test_multivariate.rb
+test/test_polynomial.rb
+test/test_suite.rb*
+test/test_ultraspherical.rb
+website/index.html
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.html.erb

data/README.txt

@@ -0,0 +1,72 @@
+= polynomial
+
+Website:
+* http://adrianomitre.github.com/Polynomial
+
+Repository:
+* http://github.com/adrianomitre/Polynomial
+
+== DESCRIPTION:
+
+Rich-featured single and multiple variables polynomials classes for Ruby.
+
+== FEATURES:
+
+* Implements all basic operations (+, -, *, /, quo), plus integral and derivatives.
+* Rich, configurable and robust conversion from and to strings.
+* Very flexible constructor interface.
+* Integration with EasyPlot for easy plotting.
+* Coefficients can be complex numbers.
+* Avoid changing coefficients types as much as possible, i.e., does not convert integers or rationals to float unless needed
+* Constructors for Legendre, Ultraspherical, and first and second kind Chebyshev polynomials.
+
+== SYNOPSIS:
+
+  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"
+  
+== REQUIREMENTS:
+
+MRI, JRuby or Rubinius as long as RUBY_VERSION >= 1.8.7.
+
+The following gems are soft requirements, i.e., Polynomial can be used without
+them, though with slightly reduced functionality:
+* HandyHash
+* EasyPlot
+
+== INSTALL:
+
+* sudo gem install polynomial
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008-2010 Adriano Mitre
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/polynomial/chebyshev.rb

@@ -0,0 +1,95 @@
+my_path = File.dirname(File.expand_path(__FILE__))
+require File.join(my_path, '../polynomial')
+
+class Polynomial
+
+  # Generate Chebyshev polynomials of first and second kinds.
+  # For the mathematics, see {Wikipedia entry}[http://en.wikipedia.org/wiki/Chebyshev_polynomials].
+  #
+  module Chebyshev
+
+    @fk = [Polynomial.new(1), Polynomial.new(0,1)]
+    @sk = [Polynomial.new(1), Polynomial.new(0,2)]
+    @fact = Polynomial.new(0,2)
+
+    # Generate the n-th Chebyshev polynomial of the first kind using
+    # a cached interactive implementation of the recurrence relation.
+    # Caching reduces amortized (average after many calls) time consumption
+    # to O(1) in the hypothetical case of infinite calls with uniform
+    # distribution in a bounded range.
+    #
+    # Warning: due to caching, memory usage is proportional to the square of
+    # the greatest degree computed. Use the uncached_first_kind method
+    # if no caching is wanted.
+    #
+    def self.first_kind(n)
+      n >= 0 or raise RangeError, 'degree should be non-negative'
+
+      (@fk.size).upto(n) do |m|
+        @fk[m] = (@fact * @fk[m-1] - @fk[m-2])
+      end
+      @fk[n]
+    end
+
+    # Same as second_kind, but uncached. It saves memory but the amortized time
+    # consumption is higher, namely O(n^2).
+    #
+    def self.uncached_first_kind(n)
+      n >= 0 or raise RangeError, 'degree should be non-negative'
+
+      case n
+      when 0 then Polynomial.new(1)
+      when 1 then Polynomial.new(0,1)
+      else
+        prev2 = self.first_kind(0)
+        prev1 = self.first_kind(1)
+        curr = nil # scope
+        (n-1).times do
+          curr = (@fact * prev1 - prev2)
+          prev1, prev2 = curr, prev1
+        end
+        curr
+      end
+    end
+
+    # Generate the n-th Chebyshev polynomial of the second kind using
+    # an cached-interactive implementation of the recurrence relation.
+    # Caching reduces amortized (average after many calls) time consumption.
+    #
+    # Warning: due to caching, memory usage is proportional to the square of
+    # the greatest degree computed. Use the uncached_second_kind method
+    # if no caching is wanted.
+    #
+    def self.second_kind(n)
+      n >= 0 or raise RangeError, 'degree should be non-negative'
+
+      (@sk.size).upto(n) do |m|
+        @sk[m] = (@fact * @sk[m-1] - @sk[m-2])
+      end
+      @sk[n]
+    end
+
+    # Same as second_kind, but uncached (saves memory but the amortized time
+    # consumption is higher).
+    #
+    def self.uncached_second_kind(n)
+      n >= 0 or raise RangeError, 'degree should be non-negative'
+
+      case n
+      when 0 then Polynomial.new(1)
+      when 1 then Polynomial.new(0,2)
+      else
+        prev2 = self.second_kind(0)
+        prev1 = self.second_kind(1)
+        curr = nil # scope
+        (n-1).times do
+          curr = (@fact * prev1 - prev2)
+          prev1, prev2 = curr, prev1
+        end
+        curr
+      end
+    end
+
+  end
+
+end

data/lib/polynomial/legendre.rb

@@ -0,0 +1,57 @@
+my_path = File.dirname(File.expand_path(__FILE__))
+require File.join(my_path, '../polynomial')
+
+class Polynomial
+
+  # Generate Legendre polynomials.
+  # For the mathematics, see {Wikipedia entry}[http://en.wikipedia.org/wiki/Legendre_polynomials].
+  #
+  module Legendre
+
+    @cache = [Polynomial.new(1), Polynomial.new(0,1)]
+
+    # Generate the n-th Legendre polynomial using a cached interactive
+    # implementation of the recurrence relation.
+    # Caching reduces amortized (average after many calls) time consumption
+    # to O(1) in the hypothetical case of infinite calls with uniform
+    # distribution in a bounded range.
+    #
+    # Warning: due to caching, memory usage is proportional to the square of
+    # the greatest degree computed. Use the uncached_first_kind method
+    # if no caching is wanted.
+    #
+    def self.cached_legendre(n)
+      n >= 0 or raise RangeError, 'degree should be non-negative'
+
+      for m in @cache.size-1 ... n
+        @cache[m+1] = (Polynomial.new(0,2*m+1)*@cache[m] - m*@cache[m-1]).quo(m+1)
+      end
+      @cache[n]
+    end
+    class <<self; alias legendre cached_legendre; end
+
+    # Generate the n-th Legendre polynomial, but uncached.
+    # It saves memory but the amortized time consumption is higher,
+    # namely O(n^2).
+    #
+    def self.uncached_legendre(n)
+      n >= 0 or raise RangeError, 'degree should be non-negative'
+
+      case n
+      when 0 then @cache[0]
+      when 1 then @cache[1]
+      else
+        prev2 = @cache[0]
+        prev1 = @cache[1]
+        curr = nil # scope
+        for m in 1 ... n
+          curr = (Polynomial.new(0,2*m+1)*prev1 - m*prev2).quo(m+1)
+          prev1, prev2 = curr, prev1
+        end
+        curr
+      end
+    end
+
+  end
+
+end

data/lib/polynomial/multivariate.rb

@@ -0,0 +1,143 @@
+my_path = File.dirname(File.expand_path(__FILE__))
+require File.join(my_path, '../polynomial')
+
+# TODO: consider building an writer for @terms which sorts the value
+#       prior to actually setting it.
+
+class Multivariate < Polynomial
+
+  attr_reader :vars, :terms
+
+  class << self
+    alias [] new
+  end
+
+  # Creates a new multivariate polynomial from supplied string representation,
+  # basically delegating to Multivariate.from_string.
+  #
+  # Examples:
+  #   Polynomial::Multivariate[[1,1,0],[2,0,1]].to_s #=> "x + 2*y"
+  #--
+  #   Polynomial::Multivariate['x+y'].to_s #=> "x + y"
+  #   Polynomial::Multivariate['xy+y^3', :power_symbol=>'^'].to_s #=> "x*y + y**3"
+  #++
+  #
+  def initialize(*terms)
+    !terms.empty? or raise ArgumentError, 'at least one coefficient should be supplied'
+    arg = terms[0]
+    case arg
+    when Array
+      terms.flatten.all? {|a| a.is_a? Numeric } or raise TypeError, 'coefficient-power should be Numeric'
+      sz = arg.size
+      sz > 2 or raise ArgumentError, 'coefficient-power tuplets should have length > 2'
+      terms.all? {|ary| ary.size == sz } or raise ArgumentError, 'inconsistent data'
+    when String
+      raise NotImplementedError
+#      coefs = self.class.coefs_from_string(coefs[0], coefs[1] || {})
+    else
+      raise TypeError, 'coefficient-power should be Numeric'
+    end
+    @vars = sz - 1
+    @terms = self.class.reduce_terms(terms).sort
+  end
+
+  # Evaluates Multivariate polynomial
+  #--
+  # FIXME: replace current straightforward but slow implementation
+  #        by some efficient Horner's rule inspired algorithm.
+  #++
+  def substitute(*xs)
+    xs.size == @vars or raise ArgumentError, "wrong number of arguments (#{xs.size} for #{@vars})"
+    total = 0
+    @terms.each do |coef, *powers|
+      result = coef
+      for i in 0 ... @vars
+        result *= xs[i] ** powers[i]
+      end
+      total += result
+    end
+    total
+  end
+
+  def *(other)
+    @vars == other.vars or raise ArgumentError, "number of variables must be the same for both multiplicands"
+    new_terms = []
+    @terms.each do |my_term|
+      other.terms.each do |other_term|
+        new_coef = my_term[0] * other_term[0]
+        new_powers = my_term[1..-1].zip(other_term[1..-1]).map {|a,b| a + b }
+        new_term = [new_coef] + new_powers
+        new_terms << new_term
+      end
+    end
+    self.class.new(*new_terms.sort)
+  end
+
+  # FIXME: implement efficiently, i.e., O(m) where m is the number of terms
+  def **(n)
+    n >= 0 or raise RangeError, "negative argument"
+    n.is_a?(Integer) or raise TypeError, "non-integer argument"
+    ([self]*n).inject(Unity) {|s,k| s*k }
+  end
+
+  def ==(other)
+    self.instance_variables.all? do |var_name|
+      self.instance_variable_get(var_name) == other.instance_variable_get(var_name)
+    end
+  end
+
+  def degree(index)
+    if index == 0
+      0
+    elsif index > 0 && index <= @vars
+      @terms.map {|cp| cp[index] }.max
+    else
+      raise RangeError, 'invalid variable index'
+    end
+  end
+
+  def coerce(other)
+    case other
+    when Numeric
+      [self.class.new([other]), self]
+    when Polynomial
+      [other, self]
+    else
+      raise TypeError, "#{other.class} can't be coerced into Polynomial"
+    end
+  end
+
+#  private
+=begin
+  def self.remove_trailing_zeroes(ary)
+    m = 0
+    ary.reverse.each.with_index do |a,n|
+      unless a.all? {|z| z.zero? }
+        m = n+1
+        break
+      end
+    end
+    ary[0..-m]
+  end
+=end
+
+  # Group same powered terms.
+  #
+  # The result is always non-empty, the base case being [[0,..,0]]
+  #
+  def self.reduce_terms(terms)
+    new_terms = []
+    terms.group_by {|a,*powers| powers }.each_pair do |powers, terms|
+      new_coef = 0
+      terms.each {|coef, *rest| new_coef += coef }
+      new_terms << [new_coef, *powers] unless new_coef.zero?
+    end
+    new_terms.empty? ? [terms[0].map { 0 }] : new_terms
+  end
+
+  public
+
+  Unity = new([1,0,0])
+  Zero = new([0,0,0])
+  
+end

data/lib/polynomial/ultraspherical.rb

@@ -0,0 +1,47 @@
+my_path = File.dirname(File.expand_path(__FILE__))
+require File.join(my_path, 'chebyshev')
+require File.join(my_path, 'legendre')
+
+class Polynomial
+
+  # Generate ultraspherical (or Gegenbauer) polynomials.
+  # For the mathematics, see {Wikipedia}[http://en.wikipedia.org/wiki/Gegenbauer_polynomials]
+  # or {Mathworld entry}[http://mathworld.wolfram.com/GegenbauerPolynomial.html].
+  #
+  module Ultraspherical
+
+    # Generates the ultraspherical (or Gegenbauer) polynomial of given degree
+    # and parameter using an interactive implementation of the recurrence
+    # relation which takes O(r^2) time.
+    #
+    def self.ultraspherical(degree, alpha)
+      degree >= 0 or raise RangeError, 'degree should be non-negative'
+      case alpha
+      when 0   then Polynomial::Chebyshev.first_kind(degree)
+      when 0.5 then Polynomial::Legendre.legendre(degree)
+      when 1   then Polynomial::Chebyshev.second_kind(degree)
+      else
+        case degree
+        when 0
+          Polynomial.new(1)
+        when 1
+          Polynomial.new(0, 2*alpha)
+        else
+          prev2, prev1 = self.ultraspherical(0, alpha), self.ultraspherical(1, alpha)
+          curr = nil # scope reasons
+          2.upto(degree) do |m|
+            a = Polynomial.new(0, 2*(m+alpha-1)) * prev1
+            b = Polynomial.new(m+2*alpha-2) * prev2
+            curr = (a - b).quo(m)
+            raise RangeError, "alpha #{alpha} is degenerate for specified degree #{degree}" if curr.degree < m
+            prev1, prev2 = curr, prev1
+          end
+          curr
+        end
+      end
+    end
+    class <<self; alias us ultraspherical; end
+
+  end
+
+end

data/lib/polynomial/version.rb

@@ -0,0 +1,9 @@
+class Polynomial #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 7
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end