polynomials 0.2.0 → 0.3.0

data/Gemfile

@@ -8,8 +8,10 @@ source "http://rubygems.org"
 group :development do
   gem "bundler", "~> 1.0.0"
   gem "jeweler", "~> 1.6.0"
-  gem "rcov", ">= 0"
-end
-group :development, :tests do
+  gem "simplecov", ">= 0"
   gem 'awesome_print'
 end
+group :production, :development, :tests do
+	gem "activesupport"
+	gem 'i18n'
+end

data/Gemfile.lock

@@ -1,20 +1,26 @@
 GEM
   remote: http://rubygems.org/
   specs:
+    activesupport (3.0.7)
     awesome_print (0.3.2)
     git (1.2.5)
+    i18n (0.5.0)
     jeweler (1.6.0)
       bundler (~> 1.0.0)
       git (>= 1.2.5)
       rake
     rake (0.8.7)
-    rcov (0.9.9)
+    simplecov (0.4.2)
+      simplecov-html (~> 0.4.4)
+    simplecov-html (0.4.5)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  activesupport
   awesome_print
   bundler (~> 1.0.0)
+  i18n
   jeweler (~> 1.6.0)
-  rcov
+  simplecov

data/README.markdown

@@ -0,0 +1,73 @@
+# Polynomials
+
+## Usage
+
+<pre><code>
+require 'polynomials'
+  require 'gnuplot'
+  include Polynomials
+
+
+  polynomial = Polynomial.parse(ARGV[0])
+
+  points =  polynomial.roots | polynomial.local_extrema | polynomial.inflection_points
+
+  max_x =  points.max_by(&amp;:x).x
+  min_x =  points.min_by(&amp;:x).x
+
+  start = (min_x - 0.1)
+  stop = (max_x + 0.1)
+
+  x = start
+  data_x,data_y = [],[]
+  while x &lt; stop
+    data_x &lt;&lt; x
+    data_y &lt;&lt; polynomial.(x)
+    x += 0.005
+  end
+
+  Gnuplot.open do |gp|
+    Gnuplot::Plot.new(gp) do |plot|
+      plot.xrange &quot;[#{start}:#{stop}]&quot;
+      plot.title  &quot;Polynomial&quot;
+      plot.ylabel &quot;f(x)&quot;
+      plot.xlabel &quot;x&quot;
+      plot.grid
+      plot.data &lt;&lt; Gnuplot::DataSet.new( [data_x,data_y] ) do |ds|
+        ds.with = &quot;lines&quot;
+        ds.linewidth = 0.1
+        ds.title =  &quot;f(x) = #{polynomial}&quot;
+      end
+
+      [:inflection_point,:root, :maximum, :minimum].each do |kind_of_point|
+        selected_points = points.select(&amp;:&quot;#{kind_of_point}?&quot;)
+        plot.data &lt;&lt; Gnuplot::DataSet.new([selected_points.map(&amp;:x), selected_points.map(&amp;:y)]) do |ds|
+          ds.with = &quot;points&quot;
+          ds.linewidth = 2
+          ds.title = kind_of_point.to_s.pluralize.titleize
+        end
+      end
+    end
+  end
+</code></pre>
+
+### Bash Command
+<pre><code> % ruby examples/plot_only_mutual_data.rb '20.432 x^4 - 17.75 x^3 - 20x^2 + 5 x -50'</code></pre>
+
+### Output:
+<img src="https://img.skitch.com/20110515-cwgqkt2mnbeit3c9y5djsp1cjh.jpg">
+
+## Contributing to polynomials
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2011 Manuel Korfmann. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -35,14 +35,14 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
-require 'rcov/rcovtask'
-Rcov::RcovTask.new do |test|
-  test.libs << 'test'
-  test.pattern = 'test/**/*_test.rb'
-  test.verbose = true
-  test.rcov_opts << '--exclude "gems/*"'
-end
-
+#require 'rcov/rcovtask'
+#Rcov::RcovTask.new do |test|
+#  test.libs << 'test'
+#  test.pattern = 'test/**/*_test.rb'
+#  test.verbose = true
+#  test.rcov_opts << '--exclude "gems/*"'
+#end
+#
 task :default => :test
 
 require 'rake/rdoctask'

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/examples/plot_only_mutual_data.rb

@@ -0,0 +1,47 @@
+require 'polynomials'
+require 'gnuplot'
+include Polynomials
+
+
+polynomial = Polynomial.parse(ARGV[0])
+
+points =  polynomial.roots | polynomial.local_extrema | polynomial.inflection_points
+
+max_x =  points.max_by(&:x).x
+min_x =  points.min_by(&:x).x
+
+start = (min_x - 0.1)
+stop = (max_x + 0.1)
+
+x = start
+data_x,data_y = [],[]
+while x < stop
+  data_x << x
+  data_y << polynomial.(x)
+  x += 0.005
+end
+
+Gnuplot.open do |gp|
+  Gnuplot::Plot.new(gp) do |plot|
+    plot.xrange "[#{start}:#{stop}]"
+    plot.title  "Polynomial"
+    plot.ylabel "f(x)"
+    plot.xlabel "x"
+    plot.grid
+    plot.data << Gnuplot::DataSet.new( [data_x,data_y] ) do |ds|
+      ds.with = "lines"
+      ds.linewidth = 0.1
+      ds.title =  "f(x) = #{polynomial}"
+    end
+
+    [:inflection_point,:root, :maximum, :minimum].each do |kind_of_point|
+      selected_points = points.select(&:"#{kind_of_point}?")
+      plot.data << Gnuplot::DataSet.new([selected_points.map(&:x), selected_points.map(&:y)]) do |ds|
+        ds.with = "points"
+        ds.linewidth = 2
+        ds.title = kind_of_point.to_s.pluralize.titleize
+      end
+    end
+  end
+end
+

data/lib/polynomials/exceptions.rb

@@ -0,0 +1,3 @@
+module Polynomials
+  class NotParsableError < ArgumentError;end
+end

data/lib/polynomials/formulas.rb

@@ -0,0 +1,64 @@
+require 'mathn'
+module Polynomials
+  module Formulas
+    extend self
+
+    def roots_of_cubic_function(a,b,c,d,with_complex = false)
+      f = ((3*c/a) - (b**2/a**2))/3
+      g = (((2*b**3)/a**3) - (9*b*c/a**2) + (27*d/a))/27
+      h = (g**2/4) + (f**3/27)
+      if f == 0 && g == 0 && h == 0
+        f = (3*c/a) - (b**2/a**2)
+        g = (2*b**3/a**3) - (9*b*c/a**2) + (27*d/a)
+        h = (g**2/4) + (f**3/27)
+        [-Math.cbrt(d/a)]
+      elsif h <= 0
+        i = Math.sqrt((g**2/4) - h)
+        j = Math.cbrt(i)
+        k = Math.acos(-(g / (2*i)))
+        l = j * -1
+        m = Math.cos(k/3)
+        n = Math.sqrt(3) * Math.sin(k/3)
+        p = (b/(3*a))*-1
+        [2*j*Math.cos(k/3) - (b/(3*a)), l*(m+n)+p, l*(m-n)+p]
+      else
+        f = (((3*c)/a) - (b**2/a**2))/3
+        g = ((2*b**3/a**3) - (9*b*c/a**2) + ((27*d)/a))/27
+        h = (g**2/4) + (f**3/27)
+        r = -(g/2) + Math.sqrt(h)
+        s = Math.cbrt(r)
+        t = -(g/2) - Math.sqrt(h)
+        u = Math.cbrt(t)
+        roots = [(s + u) - (b/(3*a))]
+        roots |= [1,-1].map do |algebraic_sign|
+          Complex((-(s + u)/2) - (b/(3*a)),algebraic_sign * (s-u)*Math.sqrt(3)/2)
+        end if with_complex
+        roots
+      end.map { |n| n.respond_to?(:round) ? n.round(10) : n }.to_set
+    end
+
+    def roots_of_quadratic_function(a,b,c)
+      p = b/a
+      q = c/a
+      denom = (p/2.0)**2 - q
+      return Set[] if denom < 0
+      root = Math.sqrt(denom)
+      Set.new([:+,:-].map{ |operator| (-(p/2.0)).send(operator, root)}.map { |n| n.round(10) })
+    end
+
+    def roots_of_quartic_function(*args)
+      a,b,c,d,e = args.map { |n| n/args.first }
+      f = c - (3*b**2/8)
+      g = d + (b**3/8) - (b*c/2)
+      h = e - (3*b**4/256) + (b**2 * c/16) - ( b*d/4)
+      roots = self.roots_of_cubic_function(1,(f/2),(((f**2)-(4*h))/16),-(g**2)/64,true)
+      combs = roots.reject{ |n| n == 0}.combination(2)
+      only_complex = combs.select { |comb| comb.all? { |n| n.is_a? Complex }}
+      p,q = (only_complex.empty? ? combs.first : only_complex.first).map { |n| Math.sqrt(n) }
+      r = (-g/(8*p*q))
+      s = b/(4*a)
+      roots = Set.new([p + q + r -s, p - q - r -s, -p + q - r -s, -p - q + r -s].map { |n| n.is_a?(Complex) ? (n.real if n.imaginary == 0) : n }.compact )
+      roots.map { |n| n.respond_to?(:round) ? n.round(10) : n }.to_set
+    end
+  end
+end

data/lib/polynomials/point.rb

@@ -0,0 +1,71 @@
+module Polynomials
+  class Point
+    include Comparable
+    attr_accessor :x, :y
+
+    def self.inherited(subclass)
+      self.class_eval do 
+        define_method :"#{subclass.name.demodulize.underscore}?" do
+          self.is_a? subclass
+        end
+      end
+    end
+    def initialize(x,y)
+      @x,@y = x,y
+    end
+
+    def to_s
+      "(#{self.x.inspect},#{self.y.inspect})"
+    end
+
+    def <=>(other)
+      if self.x < other.x
+        -1
+      elsif self.x > other.x
+        1
+      elsif self.x == other.x && self.y == other.y
+        0
+      end
+    end
+
+    def eql?(other)
+      self.x == other.x &&
+        self.y == other.y &&
+        other.class == self.class
+    end
+  end
+
+  class Extremum < Point
+    attr_accessor :kind_of_extremum
+
+    [:maximum,:minimum].each do |extremum|
+      self.superclass.class_eval do
+        define_method :"#{extremum}?" do
+          self.extremum? && self.kind_of_extremum == extremum
+        end
+      end
+    end
+
+    def initialize(*args,kind_of_extremum)
+      @kind_of_extremum = kind_of_extremum
+      super(*args)
+    end
+
+    def to_s
+      super + kind_of_extremum.to_s
+    end
+
+    def eql?(other)
+      super && self.kind_of_extremum == other.kind_of_extremum
+    end
+  end
+
+  class Root < Point
+    def initialize(x)
+      super(x,0)
+    end
+  end
+
+  class InflectionPoint < Point
+  end
+end

data/lib/polynomials/polynomial.rb

@@ -0,0 +1,144 @@
+module Polynomials
+  class Polynomial
+
+    MinMaxMapping = { 1.0 => :maximum, -1.0  => :minimum }
+    AfterExtremaCurvatureMapping = { maximum: :right, minimum: :left }
+    NegPosMinMaxExtremumMapping = {[1.0,-1.0] => :maximum,[-1.0,1.0] => :minimum}
+
+    attr_accessor :terms
+
+    def self.parse(string)
+      polynomial = self.new
+      string.split(/(?=[-+])/).each do |term|
+        parsed = Term.parse(term)
+        polynomial.terms[parsed.exponent].coefficient += parsed.coefficient
+      end
+      return polynomial
+    end
+
+    def initialize(*args)
+      self.terms = Hash.new { |hash, key| hash[key] = Term.new(key) }
+      unless args.empty?
+        args.reverse.each.with_index do |coefficient,exponent|
+          self.terms[exponent].coefficient += coefficient
+        end
+      end
+    end
+
+    def calculate(x)
+      self.terms.values.inject(0.0) do |acc,t|
+        acc + (t.coefficient.to_f * (x**t.exponent))
+      end
+    end
+    alias call calculate
+
+    def derivative
+      new_function = self.alter do |nf, term|
+        nf.terms[term.exponent - 1].coefficient += term.exponent * term.coefficient
+      end
+      new_function.terms.reject! { |_,t| t.coefficient == 0 }
+      return new_function
+    end
+
+    def roots
+      if !terms.empty? and terms.keys.none?(&:zero?)
+        self.alter { |nf, term| nf.terms[term.exponent-self.lt.exponent].coefficient = term.coefficient }.roots << Root.new(0.0)
+      else
+        case self.degree
+        when 1
+          Set[-self.terms[0].coefficient / self.terms[1].coefficient]
+        when 2
+          Formulas.roots_of_quadratic_function(*coefficients_till(2))
+        when 3
+          Formulas.roots_of_cubic_function(*coefficients_till(3))
+        when 4
+          Formulas.roots_of_quartic_function(*coefficients_till(4))
+        else
+          Set[]
+        end.map { |x| Root.new(x) }.to_set
+      end
+    end
+
+    def local_extrema
+      derivative = self.derivative
+      possible_extrema = derivative.roots.sort.map(&:x)
+      return Set[] if possible_extrema.empty?
+      samples = ([possible_extrema.first - 1] + possible_extrema.sort + [possible_extrema.last + 1]).each_cons(2).map do |before,after|
+        (before + after)/2
+      end
+      possible_extrema.zip(samples.each_cons(2)).inject(Set[]) do |set,(pe,(after,before))|
+        yafter = derivative.calculate(after)
+        ybefore = derivative.calculate(before)
+        kind_of_extremum = NegPosMinMaxExtremumMapping[[yafter/yafter.abs,ybefore/ybefore.abs]]
+        set <<  Extremum.new(pe,self.calculate(pe), kind_of_extremum) if kind_of_extremum
+        set
+      end
+    end
+
+    def curvature_behaviour
+      hash = Hash.new {|h,k|h[k]=Set.new}
+      return hash if self.degree > 5
+      self.derivative.extrema.sort.each_cons(2).group_by do |start,_|
+        kind_of_curvature = AfterExtremaCurvatureMapping[start.kind_of_extremum]
+      end.tap { |h| h.values.each { |v| v.map! { |s,e| Range.new(s.x,e.x) }}}
+    end
+
+    def degree
+      self.terms.keys.max || 0
+    end
+
+    def to_s
+      terms.sort_by { |_,t| -t.exponent }.inject("") do |string,(_,term)|
+        string << term.to_s unless term.coefficient.zero? && !term.exponent.zero?
+      string
+      end.strip.sub(/\A\+\s/, '')
+    end
+
+    def ==(other)
+      delete_zeros = proc{ |_,t| t.coefficient.zero? }
+      self.terms.delete_if(&delete_zeros) == other.terms.delete_if(&delete_zeros)
+    end
+
+    def extrema
+      extrema = local_extrema
+      unless self.degree == 0
+        a = self.gt.coefficient
+        max_or_min = (self.degree.even? ? [1.0,1.0] : [-1.0,1.0]).map { |n| (n * a)/a.abs  }
+        max_or_min.zip([-Infinity,Infinity]).each do |kind_of_extremum, x|
+          extrema << Extremum.new(x,nil,MinMaxMapping[kind_of_extremum])
+        end
+      end
+      return extrema
+    end
+
+    def inflection_points
+      self.derivative.local_extrema.map { |p| InflectionPoint.new(p.x,self.calculate(p.x)) }.to_set
+    end
+
+    def gt
+      self.terms[self.degree]
+    end
+
+    def lt
+      self.terms[self.terms.min_by{ |_,t| t.exponent}.first]
+    end
+
+    def coefficients_till(n)
+      coefficients = []
+      (0..n).each do |e|
+        coefficients << self.terms[e].coefficient
+      end
+      return coefficients.reverse
+    end
+    private :coefficients_till
+
+    def alter
+      new_function = self.class.new
+      self.terms.values.each do |term|
+        yield new_function, term
+      end
+      return new_function
+    end
+    protected :alter
+  end
+end

data/lib/polynomials/term.rb

@@ -0,0 +1,48 @@
+module Polynomials
+  class Term
+    attr_accessor :coefficient, :exponent
+
+    def initialize(exponent = 0, coefficient = 0)
+      @coefficient, @exponent = coefficient, exponent
+    end
+
+    def self.parse(string)
+      term = self.new
+      float = /\d+(?:\.\d+)?/
+      integer = /\d+/
+      polynomial_regex = /
+        \A\s*
+          (?<algebraic_sign>[-+]?)
+        \s*
+          (?<coefficient>#{float})?
+        \s*
+          (?<power>x(?:\^(?<exponent>#{integer}))?)?
+        \s*\Z
+      /x
+
+      raw_data = string.match(polynomial_regex)
+      raise NotParsableError unless raw_data
+      term.coefficient = (raw_data[:algebraic_sign] + ( raw_data[:coefficient] || "1")).to_f
+      term.exponent = raw_data[:power] ? (raw_data[:exponent] || 1).to_i : 0
+      term
+    end
+
+    def to_s
+      pretty_coeffiecent = coefficient.denominator == 1 ? coefficient.abs.to_i : coefficient.abs
+      algebraic_sign =  coefficient < 0 ? '-' : '+'
+      power = "x#{"^#{exponent}" unless exponent == 1}"
+      "#{algebraic_sign} #{pretty_coeffiecent}#{ power unless exponent.zero?} "
+    end
+
+    def dup
+      duplicate = self.class.new
+      duplicate.coefficient = self.coefficient
+      duplicate.exponent = self.exponent
+      duplicate
+    end
+
+    def ==(other)
+      self.coefficient == other.coefficient && self.exponent == other.exponent
+    end
+  end
+end

data/lib/polynomials.rb

@@ -1,145 +1,19 @@
-require 'set'
-require_relative 'term'
-require_relative 'core_ext/math'
-
-class Polynomial
-
-  MinMaxMapping = { 1.0 => :max, -1.0  => :min }
-  AfterextremaCurvatureMapping = { max: :right, min: :left }
-  NegPosMinMaxExtremumMapping = {[1.0,-1.0] => :max,[-1.0,1.0] => :min}
-
-  attr_accessor :terms
-
-  def self.parse(string)
-    polynomial = self.new
-    string.split(/(?=[-+])/).each do |term|
-      parsed = Term.parse(term)
-      polynomial.terms[parsed.exponent].coefficient += parsed.coefficient
-    end
-    return polynomial
-  end
-
-  def initialize(*args)
-    self.terms = Hash.new { |hash, key| hash[key] = Term.new(key) }
-    unless args.empty?
-      args.reverse.each.with_index do |coefficient,exponent|
-        self.terms[exponent].coefficient += coefficient
-      end
-    end
-  end
-
-  def calculate(x)
-    self.terms.values.inject(0.0) do |acc,t|
-      acc + (t.coefficient.to_f * (x**t.exponent))
-    end
-  end
-
-  def derivative
-    new_function = self.alter do |nf, term|
-      nf.terms[term.exponent - 1].coefficient += term.exponent * term.coefficient
-    end
-    new_function.terms.reject! { |_,t| t.coefficient == 0 }
-    return new_function
-  end
-
-  def roots
-    if !terms.empty? and terms.keys.none?(&:zero?)
-      self.alter { |nf, term| nf.terms[term.exponent-self.lt.exponent].coefficient = term.coefficient }.roots << 0.0
-    else
-      case self.degree
-      when 1
-        Set[-self.terms[0].coefficient / self.terms[1].coefficient]
-      when 2
-        Math.roots_of_quadratic_function(*coefficients_till(2))
-      when 3
-        Math.roots_of_cubic_function(*coefficients_till(3))
-      when 4
-        Math.roots_of_quartic_function(*coefficients_till(4))
-      else
-        Set[]
-      end
-    end
-  end
+$LOAD_PATH << File.join(File.dirname(File.expand_path(__FILE__)), 'polynomials')
 
-  def local_extrema
-    derivative = self.derivative
-    max_min_extremum =  Hash.new { |hash,key| hash[key] = Set.new }
-    possible_extrema = derivative.roots.sort
-    unless possible_extrema.empty?
-      samples = ([possible_extrema.first - 1] + possible_extrema.sort + [possible_extrema.last + 1]).each_cons(2).map do |before,after|
-        (before + after)/2
-      end
+require 'active_support/inflector'
 
-      possible_extrema.zip(samples.each_cons(2)).each do |pe,(after,before)|
-        yafter = derivative.calculate(after)
-      ybefore = derivative.calculate(before)
-      kind_of_extremum = NegPosMinMaxExtremumMapping[[yafter/yafter.abs,ybefore/ybefore.abs]]
-      max_min_extremum[kind_of_extremum] << pe if kind_of_extremum
-      end
-    end
-    return max_min_extremum
-  end
-
-  def curvature_behaviour
-    hash = Hash.new {|h,k|h[k]=Set.new}
-    return hash if self.degree > 5
-    extrema = self.derivative.extrema
-    all_extremas = extrema.values.inject(Set[],&:|).sort
-    all_extremas.each_cons(2).map { |s,e| Range.new(s,e) }.group_by do |range|
-      kind_of_curvature = AfterextremaCurvatureMapping[extrema.find { |k,v| v.include?(range.begin) }.first]
-    end
-  end
-
-  def degree
-    self.terms.keys.max || 0
-  end
-
-  def to_s
-    terms.sort_by { |_,t| -t.exponent }.inject("") do |string,(_,term)|
-      string << term.to_s unless term.coefficient.zero? && !term.exponent.zero?
-      string
-    end.strip.sub(/\A\+\s/, '')
-  end
-
-  def ==(other)
-    delete_zeros = proc{ |_,t| t.coefficient.zero? }
-    self.terms.delete_if(&delete_zeros) == other.terms.delete_if(&delete_zeros)
-  end
-
-  def extrema
-    extrema = local_extrema
-    unless self.degree == 0
-      a = self.gt.coefficient
-      max_or_min = (self.degree.even? ? [1.0,1.0] : [-1.0,1.0]).map { |n| (n * a)/a.abs  }
-      extrema[MinMaxMapping[max_or_min.first]] << -1.0/0
-      extrema[MinMaxMapping[max_or_min.last]] << 1.0/0
-    end
-    return extrema
-  end
-
-  def gt
-    self.terms[self.degree]
-  end
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.plural /mum$/, '\1ma'
+  inflect.singular /ma$/, '\1mum'
+end
 
-  def lt
-    self.terms[self.terms.min_by{ |_,t| t.exponent}.first]
-  end
+require 'polynomial'
+require 'set'
+require 'term'
+require 'point'
+require 'formulas'
+require 'exceptions'
 
-  def coefficients_till(n)
-    coefficients = []
-    (0..n).each do |e|
-      coefficients << self.terms[e].coefficient
-    end
-    return coefficients.reverse
-  end
-  private :coefficients_till
 
-  def alter
-    new_function = self.class.new
-    self.terms.values.each do |term|
-      yield new_function, term
-    end
-    return new_function
-  end
-  protected :alter
+module Polynomials
 end

data/polynomials.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{polynomials}
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Manuel Korfmann"]
-  s.date = %q{2011-05-14}
+  s.date = %q{2011-05-15}
   s.description = %q{
 This is a gem dedicated to parsing, manipulating and finding roots,extrema and inflection points of polynomials.
 It can solve polynomial equations with a degree up to 4 by implementing formulas for solving quadratic, cubic and quartic functions.
@@ -17,22 +17,26 @@ It can solve polynomial equations with a degree up to 4 by implementing formulas
   s.email = %q{manu@korfmann.info}
   s.extra_rdoc_files = [
     "LICENSE.txt",
-    "README.rdoc"
+    "README.markdown"
   ]
   s.files = [
     ".document",
     "Gemfile",
     "Gemfile.lock",
     "LICENSE.txt",
-    "README.rdoc",
+    "README.markdown",
     "Rakefile",
     "VERSION",
-    "lib/core_ext/math.rb",
+    "examples/plot_only_mutual_data.rb",
     "lib/polynomials.rb",
-    "lib/term.rb",
+    "lib/polynomials/exceptions.rb",
+    "lib/polynomials/formulas.rb",
+    "lib/polynomials/point.rb",
+    "lib/polynomials/polynomial.rb",
+    "lib/polynomials/term.rb",
     "polynomials.gemspec",
-    "test/helper.rb",
-    "test/math_test.rb",
+    "test/formulas_test.rb",
+    "test/point_test.rb",
     "test/polynomial_test.rb",
     "test/term_test.rb",
     "test/test_helper.rb"
@@ -50,19 +54,25 @@ It can solve polynomial equations with a degree up to 4 by implementing formulas
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.6.0"])
-      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
       s.add_development_dependency(%q<awesome_print>, [">= 0"])
+      s.add_development_dependency(%q<activesupport>, [">= 0"])
+      s.add_development_dependency(%q<i18n>, [">= 0"])
     else
       s.add_dependency(%q<bundler>, ["~> 1.0.0"])
       s.add_dependency(%q<jeweler>, ["~> 1.6.0"])
-      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
       s.add_dependency(%q<awesome_print>, [">= 0"])
+      s.add_dependency(%q<activesupport>, [">= 0"])
+      s.add_dependency(%q<i18n>, [">= 0"])
     end
   else
     s.add_dependency(%q<bundler>, ["~> 1.0.0"])
     s.add_dependency(%q<jeweler>, ["~> 1.6.0"])
-    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
     s.add_dependency(%q<awesome_print>, [">= 0"])
+    s.add_dependency(%q<activesupport>, [">= 0"])
+    s.add_dependency(%q<i18n>, [">= 0"])
   end
 end
 

data/test/{math_test.rb → formulas_test.rb}

@@ -1,13 +1,15 @@
-require_relative 'test_helper'
+require "#{File.dirname(File.expand_path(__FILE__))}/test_helper"
+
 class TestMath < MiniTest::Unit::TestCase
+  include Polynomials
   def test_roots_for_constant_functions
     polynomial = Polynomial.parse('5')
-    assert_equal Set[],polynomial.roots
+    assert_set_eql Set[],polynomial.roots
   end
 
   def test_roots_for_linear_functions
     polynomial = Polynomial.parse('5x + 2')
-    assert_equal Set[-2.0/5.0],polynomial.roots
+    assert_set_eql Set[Root.new(-2.0/5.0)],polynomial.roots
   end
 
   def test_roots_quadratic_functions
@@ -16,50 +18,50 @@ class TestMath < MiniTest::Unit::TestCase
     q = -40.0/3.0
     root = Math.sqrt((p/2)**2 - q)
     fraction = -(p/2)
-    assert_equal Set[(fraction - root).round(10), (fraction + root).round(10)],polynomial.roots
+    assert_set_eql Set[Root.new((fraction - root).round(10)), Root.new((fraction + root).round(10))],polynomial.roots
 
     polynomial = Polynomial.parse('3x^2 - 40')
-    assert_equal Set[Math.sqrt(40.0/3).round(10), -Math.sqrt(40.0/3).round(10)], polynomial.roots
+    assert_set_eql Set[Root.new(Math.sqrt(40.0/3).round(10)), Root.new(-Math.sqrt(40.0/3).round(10))], polynomial.roots
   end
 
   def test_roots_for_cubic_functions
     polynomial = Polynomial.parse('1x^3  + 1x^2  + 2x - 1')
     assert_equal(1, polynomial.roots.size)
-    assert_equal Set[0.3926467817], polynomial.roots
+    assert_set_eql Set[Root.new(0.3926467817)], polynomial.roots
 
     polynomial = Polynomial.parse('2x^3  - 4x^2  - 22x + 24')
-    assert_equal Set[4.0,-3.0,1.0], polynomial.roots
+    assert_set_eql Set[Root.new(4.0),Root.new(-3.0),Root.new(1.0)], polynomial.roots
   end
 
   def test_roots_for_cubic_functions_with_complex
     coefficients = Polynomial.parse('3x^3   - 10x^2   + 14x + 27').terms.first(4).map{ |t| t.last.coefficient }
-    assert_equal Set[-1.0, Complex(2.1666666666666634,2.0749832663314605), Complex(2.1666666666666634,-2.0749832663314605)],Math.roots_of_cubic_function(*coefficients, true)
+    assert_equal Set[-1.0, Complex(2.1666666666666634,2.0749832663314605), Complex(2.1666666666666634,-2.0749832663314605)],Formulas.roots_of_cubic_function(*coefficients, true)
   end
 
   def test_roots_for_cubic_functions_one_real_all_equal
     polynomial = Polynomial.parse('1x^3   + 6x^2   + 12x + 8')
     assert_equal(1, polynomial.roots.size)
-    assert_equal(-2, polynomial.roots.first)
+    assert_equal(Root.new(-2), polynomial.roots.first)
   end
 
   def test_roots_for_quartic_functions
     polynomial = Polynomial.parse('3x^4   + 6x^3   - 123x^2   - 126x + 1080')
-    assert_equal Set[5.0, 3.0, -4.0, -6.0], polynomial.roots
+    assert_set_eql Set[Root.new(5.0), Root.new(3.0), Root.new(-4.0), Root.new(-6.0)], polynomial.roots
 
     polynomial = Polynomial.parse('-20x^4   + 5x^3   + 17x^2   - 29x + 87')
-    assert_equal Set[-1.6820039266,1.4875831103], polynomial.roots
+    assert_set_eql Set[Root.new(-1.6820039266),Root.new(1.4875831103)], polynomial.roots
   end
 
   def test_roots_without_term_with_exponent_of_zero
     polynomial = Polynomial.parse('3x^3 + 3x^2')
-    assert_equal Set[0.0,-1.0], polynomial.roots
+    assert_set_eql Set[Root.new(0.0),Root.new(-1.0)], polynomial.roots
 
     polynomial = Polynomial.parse('1 x^4')
-    assert_equal Set[0.0], polynomial.roots
+    assert_set_eql Set[Root.new(0.0)], polynomial.roots
   end
 
   def test_roots_biquadratic_equation
     polynomial = Polynomial.parse('4x^4 + 2x^2 - 1')
-    assert_equal Set[0.5558929703, -0.5558929703], polynomial.roots
+    assert_set_eql Set[Root.new(0.5558929703), Root.new(-0.5558929703)], polynomial.roots
   end
 end

data/test/point_test.rb

@@ -0,0 +1,51 @@
+require "#{File.dirname(File.expand_path(__FILE__))}/test_helper"
+class PointTest < MiniTest::Unit::TestCase
+  def test_initalizer
+    point = Point.new(2,Polynomial.new(7).calculate(2))
+    assert_equal 2, point.x
+    assert_equal 7, point.y
+  end
+
+  def test_to_s
+    point = Point.new(1,Polynomial.new(1).calculate(1))
+    assert_equal "(1,1.0)", point.to_s
+  end
+
+  def test_equality
+    point1 = Extremum.new(5,Polynomial.new(0.0).calculate(0), :maximum)
+    point2 = Extremum.new(5,Polynomial.new(0).calculate(0), :maximum)
+    point3 = Point.new(5,Polynomial.new(0).calculate(0))
+    assert point1.eql?(point2)
+    refute point3.eql?(point2)
+  end
+
+  def test_comparison
+    point1 = Point.new(1,Polynomial.new(5).calculate(1))
+    point2 = Point.new(3,Polynomial.new(5).calculate(3))
+    point3 = Point.new(0.5,Polynomial.new(5).calculate(0.5))
+    point4 = Point.new(0.5,Polynomial.new(5).calculate(0.5))
+    assert point1 < point2
+    assert point1 > point3
+    assert point4 <= point3
+    assert point4 <= point2
+  end
+
+  def test_root
+    assert_equal '(50,0)', Root.new(50).to_s
+  end
+
+  def test_boolean_max_min_meths
+    assert_equal true,Extremum.new(2,3,:maximum).maximum?
+    assert_equal true,Extremum.new(2,3,:minimum).minimum?
+    assert_equal false,Extremum.new(2,3,:maximum).minimum?
+    assert_equal false, Root.new(2).minimum?
+  end
+
+	def test_bolean_check_methods
+		assert_equal true, InflectionPoint.new(2,3).inflection_point?
+		assert_equal true, Extremum.new(2,3, :maximum).extremum?
+		assert_equal true, Root.new(2).root?
+		assert_equal false, Root.new(3).extremum?
+	end
+end
+

data/test/polynomial_test.rb

@@ -1,7 +1,8 @@
-require_relative 'test_helper'
+require "#{File.dirname(File.expand_path(__FILE__))}/test_helper"
 
 Infinity = 1.0/0
 class TestPolynomial < MiniTest::Unit::TestCase
+  include Polynomials
   def test_to_s
     polynomial = Polynomial.parse('5x + 2x^2 + 20')
     assert_equal '2x^2 + 5x + 20', polynomial.to_s
@@ -45,23 +46,23 @@ class TestPolynomial < MiniTest::Unit::TestCase
 
   def test_extrema
     polynomial = Polynomial.parse('3x^2 + 2x + 1')
-    assert_equal({ min: Set[-2.0/6.0] }, polynomial.local_extrema)
+    assert_set_eql(Set[ Extremum.new(-2.0/6.0,polynomial.calculate(-2.0/6.0), :minimum) ], polynomial.local_extrema)
     polynomial = Polynomial.parse('5x^3 - 5x^2 + 2x - 2')
   end
 
   def test_extrema_with_slope_of_derivative_equal_to_zero
     polynomial = Polynomial.parse('1x^4')
-    assert_equal({ min: Set[0.0] }, polynomial.local_extrema)
-    assert_equal({ max: Set[1.0/0, -1.0/0], min: Set[0.0]}, polynomial.extrema)
+    assert_set_eql(Set[ Extremum.new(0.0,polynomial.calculate(0.0), :minimum) ], polynomial.local_extrema)
+    assert_set_eql(Set[*[Infinity,-Infinity].map { |x| Extremum.new(x,nil, :maximum)}, Extremum.new(0.0,polynomial.calculate(0.0), :minimum) ], polynomial.extrema)
   end
 
   def test_no_local_extrema
     polynomial = Polynomial.parse('6x^6 - 5x + 50')
-    assert_equal({}, polynomial.local_extrema)
-    assert_equal({max: Set[ -1.0/0, 1.0/0 ]}, polynomial.extrema)
+    assert_equal(Set[], polynomial.local_extrema)
+    assert_set_eql(Set[*[ -1.0/0, 1.0/0 ].map { |x| Extremum.new(x, nil, :maximum)}], polynomial.extrema)
   end
 
-  def test_no_inflection_points
+  def test_curvature_behaviour_no_inflection_points
     polynomial = Polynomial.parse('1 x^4')
     assert_equal({ left: [-1.0/0..+1.0/0] }, polynomial.curvature_behaviour)
 
@@ -74,7 +75,7 @@ class TestPolynomial < MiniTest::Unit::TestCase
 
   def test_no_extremums
     polynomial = Polynomial.parse('5')
-    assert_equal({}, polynomial.extrema)
+    assert_equal(Set[], polynomial.extrema)
   end
 
   def test_no_curvature
@@ -91,12 +92,12 @@ class TestPolynomial < MiniTest::Unit::TestCase
     assert_equal({}, polynomial.curvature_behaviour)
   end
 
-  def test_two_inflection_points
+  def test_curvature_behaviour_two_inflection_points
     polynomial = Polynomial.parse('+ 1.0 x^4 + 5.0 x^3 - 1.0 x^2 + 3.0 x + 5.0')
     assert_equal({left:[-1.0/0..-2.5649778198, 0.0649778198..1.0/0], right: [-2.5649778198..0.0649778198] } , polynomial.curvature_behaviour)
   end
 
-  def test_three_inflection_points
+  def test_curvature_behaviour_three_inflection_points
     polynomial = Polynomial.new(20,4,0,-1,-200)
     assert_equal( {:right=>[(-1/10)..0.0], :left=>[-Infinity..(-1/10), 0.0..Infinity]}, polynomial.curvature_behaviour)
   end
@@ -104,7 +105,7 @@ class TestPolynomial < MiniTest::Unit::TestCase
 
   def test_efficient_roots_calculation
     polynomial = Polynomial.parse('200x^2342435 + 6x^20')
-    assert_equal(Set[0.0], polynomial.roots)
+    assert_set_eql(Set[Root.new(0.0)], polynomial.roots)
   end
 
   def test_lt
@@ -121,4 +122,9 @@ class TestPolynomial < MiniTest::Unit::TestCase
     polynomial = Polynomial.new(5,0,2,-1)
     assert_equal '5x^3 + 2x - 1', polynomial.to_s
   end
+
+  def test_inflection_points
+    polynomial = Polynomial.new(20,4,0,-1,-200)
+    assert_set_eql Set[InflectionPoint.new(-1/10,polynomial.(-1/10)),InflectionPoint.new(0,polynomial.(0))], polynomial.inflection_points
+  end
 end

data/test/term_test.rb

@@ -1,4 +1,5 @@
-require_relative 'test_helper'
+require "#{File.dirname(File.expand_path(__FILE__))}/test_helper"
+
 class TestTerm < MiniTest::Unit::TestCase
   def test_initializer
     assert_equal 0, Term.new.coefficient
@@ -25,6 +26,12 @@ class TestTerm < MiniTest::Unit::TestCase
     assert_equal 0, Term.parse('6').exponent
   end
 
+  def test_dup
+    term = Term.new(2,10)
+    assert_equal term.coefficient, term.dup.coefficient
+    assert_equal term.exponent, term.dup.exponent
+  end
+
   def test_invalid_string_raises_not_parsable_error
     ['6x^ -5', '6^20',  '2 2', 'xx', '2 ^ x'].each do |not_parsable_string|
       assert_raises NotParsableError do

data/test/test_helper.rb

@@ -1,3 +1,21 @@
 require 'awesome_print'
+require 'simplecov'
+SimpleCov.start
 require 'minitest/autorun'
-require_relative '../lib/polynomials.rb'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'polynomials'
+
+class MiniTest::Unit::TestCase
+  include Polynomials
+  def assert_set_eql(actual,computed)
+    test = lambda do 
+        actual.all? do |a|
+          computed.any? do |c|
+            a.eql?(c) && c.eql?(a)
+          end
+      end
+    end
+    assert test.call, "Expected #{actual.inspect}, not #{computed.inspect}"
+  end
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Manuel Korfmann
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-14 00:00:00 +02:00
+date: 2011-05-15 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -48,7 +48,7 @@ dependencies:
   prerelease: false
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: rcov
+  name: simplecov
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -73,6 +73,32 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id006
 description: "\n\
   This is a gem dedicated to parsing, manipulating and finding roots,extrema and inflection points of polynomials.\n\
   It can solve polynomial equations with a degree up to 4 by implementing formulas for solving quadratic, cubic and quartic functions.\n  "
@@ -83,21 +109,25 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE.txt
-- README.rdoc
+- README.markdown
 files: 
 - .document
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
-- README.rdoc
+- README.markdown
 - Rakefile
 - VERSION
-- lib/core_ext/math.rb
+- examples/plot_only_mutual_data.rb
 - lib/polynomials.rb
-- lib/term.rb
+- lib/polynomials/exceptions.rb
+- lib/polynomials/formulas.rb
+- lib/polynomials/point.rb
+- lib/polynomials/polynomial.rb
+- lib/polynomials/term.rb
 - polynomials.gemspec
-- test/helper.rb
-- test/math_test.rb
+- test/formulas_test.rb
+- test/point_test.rb
 - test/polynomial_test.rb
 - test/term_test.rb
 - test/test_helper.rb
@@ -115,7 +145,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -2290630464224354984
+      hash: -1053346155644578569
       segments: 
       - 0
       version: "0"

data/README.rdoc

@@ -1,19 +0,0 @@
-= polynomials
-
-Description goes here.
-
-== Contributing to polynomials
- 
-* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
-* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
-* Fork the project
-* Start a feature/bugfix branch
-* Commit and push until you are happy with your contribution
-* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
-* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
-
-== Copyright
-
-Copyright (c) 2011 Manuel Korfmann. See LICENSE.txt for
-further details.
-

data/lib/core_ext/math.rb

@@ -1,60 +0,0 @@
-require 'mathn'
-module Math
-  def self.roots_of_cubic_function(a,b,c,d,with_complex = false)
-    f = ((3*c/a) - (b**2/a**2))/3
-    g = (((2*b**3)/a**3) - (9*b*c/a**2) + (27*d/a))/27
-    h = (g**2/4) + (f**3/27)
-    if f == 0 && g == 0 && h == 0
-      f = (3*c/a) - (b**2/a**2)
-      g = (2*b**3/a**3) - (9*b*c/a**2) + (27*d/a)
-      h = (g**2/4) + (f**3/27)
-      [-Math.cbrt(d/a)]
-    elsif h <= 0
-      i = Math.sqrt((g**2/4) - h)
-      j = Math.cbrt(i)
-      k = Math.acos(-(g / (2*i)))
-      l = j * -1
-      m = Math.cos(k/3)
-      n = Math.sqrt(3) * Math.sin(k/3)
-      p = (b/(3*a))*-1
-      [2*j*Math.cos(k/3) - (b/(3*a)), l*(m+n)+p, l*(m-n)+p]
-    else
-      f = (((3*c)/a) - (b**2/a**2))/3
-      g = ((2*b**3/a**3) - (9*b*c/a**2) + ((27*d)/a))/27
-      h = (g**2/4) + (f**3/27)
-      r = -(g/2) + Math.sqrt(h)
-      s = Math.cbrt(r)
-      t = -(g/2) - Math.sqrt(h)
-      u = Math.cbrt(t)
-      roots = [(s + u) - (b/(3*a))]
-      roots |= [1,-1].map do |algebraic_sign|
-        Complex((-(s + u)/2) - (b/(3*a)),algebraic_sign * (s-u)*Math.sqrt(3)/2)
-      end if with_complex
-      roots
-    end.map { |n| n.respond_to?(:round) ? n.round(10) : n }.to_set
-  end
-
-  def self.roots_of_quadratic_function(a,b,c)
-    p = b/a
-    q = c/a
-    denom = (p/2.0)**2 - q
-    return Set[] if denom < 0
-    root = Math.sqrt(denom)
-    Set.new([:+,:-].map{ |operator| (-(p/2.0)).send(operator, root)}.map { |n| n.round(10) })
-  end
-
-  def self.roots_of_quartic_function(*args)
-    a,b,c,d,e = args.map { |n| n/args.first }
-    f = c - (3*b**2/8)
-    g = d + (b**3/8) - (b*c/2)
-    h = e - (3*b**4/256) + (b**2 * c/16) - ( b*d/4)
-    roots = self.roots_of_cubic_function(1,(f/2),(((f**2)-(4*h))/16),-(g**2)/64,true)
-    combs = roots.reject{ |n| n == 0}.combination(2)
-    only_complex = combs.select { |comb| comb.all? { |n| n.is_a? Complex }}
-    p,q = (only_complex.empty? ? combs.first : only_complex.first).map { |n| Math.sqrt(n) }
-    r = (-g/(8*p*q))
-    s = b/(4*a)
-    roots = Set.new([p + q + r -s, p - q - r -s, -p + q - r -s, -p - q + r -s].map { |n| n.is_a?(Complex) ? (n.real if n.imaginary == 0) : n }.compact )
-    roots.map { |n| n.respond_to?(:round) ? n.round(10) : n }.to_set
-  end
-end

data/lib/term.rb

@@ -1,47 +0,0 @@
-class NotParsableError < ArgumentError;end
-class Term
-  attr_accessor :coefficient, :exponent
-
-  def initialize(exponent = 0, coefficient = 0)
-    @coefficient, @exponent = coefficient, exponent
-  end
-
-  def self.parse(string)
-    term = self.new
-    float = /\d+(?:\.\d+)?/
-    integer = /\d+/
-    polynomial_regex = /
-      \A\s*
-        (?<algebraic_sign>[-+]?)
-      \s*
-        (?<coefficient>#{float})?
-      \s*
-        (?<power>x(?:\^(?<exponent>#{integer}))?)?
-      \s*\Z
-    /x
-
-    raw_data = string.match(polynomial_regex)
-    raise NotParsableError unless raw_data
-    term.coefficient = (raw_data[:algebraic_sign] + ( raw_data[:coefficient] || "1")).to_f
-    term.exponent = raw_data[:power] ? (raw_data[:exponent] || 1).to_i : 0
-    term
-  end
-
-  def to_s
-    pretty_coeffiecent = coefficient.denominator == 1 ? coefficient.abs.to_i : coefficient.abs
-    algebraic_sign =  coefficient < 0 ? '-' : '+'
-    power = "x#{"^#{exponent}" unless exponent == 1}"
-    "#{algebraic_sign} #{pretty_coeffiecent}#{ power unless exponent.zero?} "
-  end
-
-  def dup
-    duplicate = self.class.new
-    duplicate.coefficient = self.coefficient
-    duplicate.exponent = self.exponent
-    duplicate
-  end
-
-  def ==(other)
-    self.coefficient == other.coefficient && self.exponent == other.exponent
-  end
-end

data/test/helper.rb

@@ -1,18 +0,0 @@
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'test/unit'
-require 'shoulda'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'polynomials'
-
-class Test::Unit::TestCase
-end