polymath 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a894f774d02bd9b398ece719980e9ed6dd6e5911
+  data.tar.gz: 8b6581fa9da8d754368e8f8b5ba7c6507d0f433a
+SHA512:
+  metadata.gz: 62c2c0ae2ee2bfe42acec1cee9ad48a186d5f4fc4a58bb20614025725dcfe4d78628f44024f556c5b314252e0015f439157d8758f4af679c829dd655c5ac6dff
+  data.tar.gz: 24e54d6c6f213b6016c8839f4dce86a4b76a9b9cff10f23341c4052ffd25e2e0cef0b2ff76c33f53ce70a892d3576c1a4d6732d6ccd79d6b66243c535f0ea245

data/README.md

@@ -0,0 +1,28 @@
+# Polymath
+[![Gem Version](https://d25lcipzij17d.cloudfront.net/badge.svg?id=rb&type=6&v=1.0.0&x2=0)](https://rubygems.org/gems/polymath)
+A library for polynomials with integer coefficients
+
+## install:
+    gem install polymath
+
+## usage:
+
+### lib:
+```ruby
+require 'polymath'
+polynomial = Polymath.polynomial("x^2 - 3x + 2")
+polynomial.cleanup!
+polynomial.to_s #=> "x^2-3x+2"
+```
+
+### command line:
+```
+$ polymath -af "x^2 - 3x + 2"
+x^2-3x+2
+deg: 2
+class: normal quadratic trinomial
+zeroes: [(1/1), (2/1)]
+```
+
+## docs:
+http://www.rubydoc.info/gems/polymath

data/lib/polymath.rb

@@ -0,0 +1,106 @@
+require 'optparse'
+require 'json'
+
+require_relative 'polymath/nomial/polynomial'
+require_relative 'polymath/math/math'
+
+module Polymath
+  ::Version = [1, 0, 0]
+
+  ##
+  ## @brief      parses command line arguments
+  ##
+  ## @param      args  The arguments
+  ##
+  ## @return     a hash of parsed options
+  ##
+  def self.parse_options(args)
+
+    options = {
+      :polynomial => nil,
+      :verbose    => true,
+      :analyze    => false,
+      :factor     => false
+    }
+
+    parser = OptionParser.new { |opts|
+      opts.banner = "Usage: polymath [options] <polynomial>"
+
+      opts.on("-f", "--factor", "factor the polynomial expression") { |f|
+        options[:factor] = f
+      }
+
+      opts.on("-a", "--analyze", "analyze the polynomial expression") { |a|
+        options[:analyze] = a
+      }
+
+      opts.on("-q", "--quiet", "only output what is specified") { |q|
+        options[:verbose] = ! q
+      }
+
+      opts.on("-r", "--random [N]", "generate a random polynomial") { |n|
+        options[:polynomial] =  if n
+                                  Nomial::random_polynomial(Integer(n))
+                                else
+                                  Nomial::random_polynomial
+                                end
+      }
+
+      opts.on_tail("-h", "--help", "Show this message") {
+        puts opts
+        exit
+      }
+
+      opts.on_tail("--version", "Show version") {
+        puts self::Version.join('.')
+        exit
+      }
+    }
+
+    parser.parse!(args)
+    options[:polynomial] = args.pop unless options[:polynomial]
+    options
+  end
+
+  def self.polynomial(exp)
+    Polymath::Nomial::Polynomial.new(exp)
+  end
+
+  ##
+  ## @brief      preforms actions specified by command line arguments
+  ##
+  ## @param      options  The parsed options
+  ##
+  ## @return     nil
+  ##
+  def self.command_line(options)
+    raise "No polynomial given" unless options[:polynomial]
+
+    polynomial = Polymath.polynomial(options[:polynomial])
+    math       = Polymath::Math.new
+
+    polynomial.cleanup!
+
+    if options[:factor]
+      zeroes = math.factor_rational_zeroes(polynomial: polynomial)
+    end
+
+    #output
+    puts options.map { |opt, value|
+      next unless value
+      case opt
+      when :verbose
+        polynomial.to_s
+      when :factor
+        "zeroes: #{zeroes}" if options[:factor]
+      when :analyze
+        {
+          deg:   polynomial.deg,
+          class: polynomial.classification.map { |t, c| c }.compact.join(" ")
+        }.map { |a,b| "#{a}: #{b}" }.join("\n")
+      end
+    }.compact.join("\n")
+
+  end
+
+end

data/lib/polymath/error.rb

@@ -0,0 +1,8 @@
+module Polymath
+  class TooManyVariablesError < StandardError
+      def initialize(msg="There are too many variables in this polynomial")
+        super
+      end
+    end
+  end
+end

data/lib/polymath/math/math.rb

@@ -0,0 +1,92 @@
+require 'prime'
+
+module Polymath
+
+  class Math
+
+    ::ZeroRoot = Rational(0)
+
+    ##
+    ## @brief      calculates possible rational zeroes for a given polynomial
+    ##
+    ## @param      polynomial  The polynomial
+    ##
+    ## @return     an array of Rational numbers
+    ##
+    def rational_zeroes(polynomial:)
+      cnf = factors_of(polynomial.constant)
+      lcf = factors_of(polynomial.leading_coefficient)
+
+      cnf.map { |x|
+        lcf.map { |y| [ Rational(x, y), -Rational(x, y) ] }
+      }.flatten.uniq
+    end
+
+    ##
+    ## @brief      Determines if a rational number is a zero for a given
+    ##             polynomial
+    ##
+    ## @param      polynomial  The polynomial
+    ## @param      test_value  The test value
+    ##
+    ## @return     True if a zero, False otherwise.
+    ##
+    def is_a_zero?(test_value:, polynomial:)
+      synthetic_remainder(polynomial: polynomial, divisor: test_value) == 0
+    end
+
+    ##
+    ## @brief      determines the zeroes of a polynomial
+    ##
+    ## @param      polynomial  The polynomial
+    ##
+    ## @return     an array of Rational numbers
+    ##
+    def factor_rational_zeroes(polynomial:)
+      rational_zeroes(polynomial: polynomial).select { |test_value|
+        is_a_zero?(test_value: test_value, polynomial: polynomial)
+      }
+    end
+
+    def factor_zeroes(polynomial:)
+      case polynomial.classification[:len]
+      when :monomial
+        case polynomial.classification[:special]
+        when :zero
+          [Float::INFINITY]
+        else
+          [::ZeroRoot]
+        end
+      else
+        factor_rational_zeroes(polynomial: polynomial)
+      end
+    end
+
+    ##
+    ## @brief      calculates the remainder of the synthetic quotient of a
+    ##             polynomial and a test value
+    ##
+    ## @param      polynomial  The polynomial
+    ## @param      value       The value
+    ##
+    ## @return     a Rational number
+    ##
+    def synthetic_remainder(polynomial:, divisor:)
+      polynomial.coefficients.reduce { |carry, next_cof|
+        (carry * divisor) + next_cof
+      }
+    end
+
+    ##
+    ## @brief      determine the prime factors of x
+    ##
+    ## @param      x     the integer to factor
+    ##
+    ## @return     an array of integers
+    ##
+    def factors_of(x)
+      (x.prime_division.map { |f| f[0] } + [1, x]).uniq.sort
+    end
+
+  end
+end

data/lib/polymath/nomial/monomial.rb

@@ -0,0 +1,58 @@
+module Polymath
+  module Nomial
+    class Monomial
+
+      attr_accessor :cof, :deg, :var
+
+      ::PlaceholderVar = "x"
+
+      def initialize(cof:1, deg:0, var: ::PlaceholderVar)
+        @cof, @deg, @var = cof, deg, var
+      end
+
+      def homogenize!(new_var)
+        @cof = 1       unless cof
+        @deg = 0       unless deg
+        @var = new_var
+      end
+
+      def merge!(other)
+        @cof *= other.cof if other.cof
+        @deg += other.deg if other.deg
+        @var = other.var  if other.var != ::PlaceholderVar
+        self
+      end
+
+      def gcd(other)
+        Monomial.new(
+          cof: cof.gcd(other.cof),
+          deg: [deg, other.deg].min,
+          var: var
+        )
+      end
+
+      def /(other)
+        Monomial.new(
+          cof: cof / other.cof,
+          deg: deg - other.deg,
+          var: var
+        )
+      end
+
+      def +(other)
+        raise "error" unless deg == other.deg
+        raise "error" unless var == other.var
+        Monomial.new(cof:@cof + other.cof, deg:deg, var:var)
+      end
+
+      def to_s
+        if deg > 0
+          "#{cof == 1 ? "" : cof}" + "#{var}" + (deg > 1 ? "^#{deg}" : "")
+        else
+          "#{cof}"
+        end
+      end
+
+    end
+  end
+end

data/lib/polymath/nomial/parser.rb

@@ -0,0 +1,69 @@
+require_relative 'monomial'
+module Polymath
+  module Nomial
+    class Parser
+
+      ::AllowedCharacters = / [[:alnum:]] | \^ | \s | \+ | \- /x
+
+      def self.sanitize(exp)
+        exp.gsub(/(?!#{AllowedCharacters})./, '')
+      end
+
+      def self.set_variable(exp, variable)
+        exp.gsub(/[[:alpha:]]/, variable)
+      end
+
+      def self.strip(exp)
+        exp.gsub(/\s/, '')
+      end
+
+      ##
+      ## @brief      parses a string polynomial expression
+      ##
+      ## @param      exp   the string polynomial expression
+      ##
+      ## @return     an array of monomials
+      ##
+      def self.parse(exp)
+        self.strip(exp).split(/\+|(?=-)/).map { |monomial|
+          monomial.split(/(?=[[:alpha:]])/).map { |token|
+            if /[[:alpha:]]/.match?(token)
+              Monomial.new(
+                var: token.scan(/[[:alpha:]]/).join,
+                deg: /\^/.match?(token) ? Integer(token.scan(/\^(.*)/).join) : 1,
+                cof: /\-/.match?(token) ? -1 : nil
+              )
+            elsif /\d/.match?(token)
+              Monomial.new(cof: Integer(token))
+            elsif token == "-"
+              Monomial.new(cof: -1)
+            end
+          }.compact.reduce(:merge!)
+        }
+      end
+
+      ##
+      ## @brief      guesses which variable the user meant by frequency
+      ##
+      ## @return     string of length 1
+      ##
+      def self.guess_variable(polynomial)
+        variables = polynomial.monomials.select { |monomial|
+          monomial.var != "?"
+        }.map { |monomial| monomial.var }
+
+        if variables.length == 0
+          "x"
+        else
+          variables.uniq.map { |char|
+            {
+              count: variables.count(char),
+              char:  char
+            }
+          }.sort_by { |c| -c[:count] }.first[:char]
+        end
+      end
+
+    end
+  end
+end

data/lib/polymath/nomial/polynomial.rb

@@ -0,0 +1,231 @@
+require_relative 'monomial'
+require_relative 'parser'
+
+module Polymath
+  module Nomial
+    def self.random_polynomial(n=3, cof_max: 100, skip_chance: 0.25)
+      degree = Integer(Random.rand() * n) + 1
+      (0..degree).map { |deg|
+        if Random.rand <= 1.0 - skip_chance
+          "#{Integer(Random.rand * cof_max) - (cof_max / 2)}x^#{deg}"
+        else
+          "0"
+        end
+      }.compact.shuffle.join("+")
+    end
+
+    ##
+    ## @brief      Class for a polynomial with integer coefficients and degrees
+    ##
+    class Polynomial
+
+      attr_reader :exp, :monomials, :homogenized_exp
+      attr_accessor :variable
+
+      ::DefaultVar   = "x"
+      ::ZeroMonomial = Monomial.new(cof: 0, var: ::DefaultVar)
+      ::UnitMonomial = Monomial.new(var: ::DefaultVar)
+
+      ##
+      ## @brief      Constructs a Polynomial object
+      ##
+      ## @param      exp   the string polynomial expression
+      ##
+      ## @return     a new Polynomial object
+      ##
+      def initialize(exp)
+        @exp             = Parser.sanitize(exp)
+        @monomials       = Parser.parse(@exp)
+        @monomials      << ::ZeroMonomial if @monomials.length == 0
+
+        @variable        = Parser.guess_variable(self)
+        @homogenized_exp = Parser.set_variable(exp, @variable)
+
+        @gcd             = ::UnitMonomial
+      end
+
+      ##
+      ## @brief      checks if the supplied expression string was auto-corrected
+      ##
+      ## @return     boolean
+      ##
+      def modified_expression?
+        homogenized_exp != exp
+      end
+
+      ##
+      ## @brief      homogenizes each monomial in place
+      ##
+      ## @return     an array of monomials
+      ##
+      def homogenize!
+        monomials.each { |monomial| monomial.homogenize!(variable) }
+      end
+
+      ##
+      ## @brief      orders a polynomial expression in descending order by degree
+      ##
+      ## @return     an array of monomials in descending order
+      ##
+      def order
+        monomials.sort_by { |monomial| -monomial.deg }
+      end
+
+      ##
+      ## @brief      collects terms of the same degree
+      ##
+      ## @return     an array of monomials where all like degrees are merged
+      ##
+      def collect_terms
+        c = (0..deg).map { |n|
+          collected = monomials_where_deg(n).reduce(:+)
+          collected.cof == 0 ? nil : collected if collected
+        }.compact.reverse
+
+        c.empty? ? [::ZeroMonomial] : c
+      end
+
+      ##
+      ## @brief      homogenizes, collects terms, and orders a polynomial in place
+      ##
+      ## @return     nil
+      ##
+      def cleanup!
+        homogenize!
+
+        @monomials = order
+
+        @monomials = collect_terms
+
+        @monomials = factor_gcd
+      end
+
+      ##
+      ## @brief      returns all monomials with the specified degree
+      ##
+      ## @param      n     the specified degree
+      ##
+      ## @return     an array of monomials with degree == n
+      ##
+      def monomials_where_deg(n)
+        monomials.select { |monomial| monomial.deg == n }
+      end
+
+      ##
+      ## @brief      returns the degree of the polynomial
+      ##
+      ## @return     an integer degree
+      ##
+      def deg
+        order.first.deg
+      end
+
+      ##
+      ## @brief      returns the value of the polynomial's constant
+      ##
+      ## @param      cof   The cof
+      ##
+      ## @return     an integer
+      ##
+      def constant
+        (monomials_where_deg(0).first || Monomial.new(cof: 0)).cof
+      end
+
+      ##
+      ## @brief      returns the value of the polynomial's leading coefficient
+      ##
+      ## @return     an integer
+      ##
+      def leading_coefficient
+        monomials_where_deg(deg).first.cof
+      end
+
+      ##
+      ## @brief      returns an array of the polynomial's coefficients
+      ##
+      ## @return     an array of integers
+      ##
+      def coefficients
+        monomials.map { |monomial| monomial.cof }
+      end
+
+      ##
+      ## @brief      facotrs the gcd out of the polynomial
+      ##
+      ## @return     nil
+      ##
+      def factor_gcd
+        cls = classification
+        if cls[:special] == :zero or cls[:len] == :monomial
+          return monomials
+        end
+        @gcd = monomials.reduce(:gcd)
+        monomials.map { |monomial|
+          monomial / @gcd
+        }
+      end
+
+      ##
+      ## @brief      uses a symbol classification method to classify a polynomial
+      ##
+      ## @return     a hash
+      ##
+      def classification
+        if (1..3).include?(monomials.length)
+          basic = [
+            :monomial,
+            :binomial,
+            :trinomial
+          ][monomials.length - 1]
+
+          if basic == :monomial
+            if monomials.first.cof == 0
+              special = :zero
+            elsif monomials.first.deg == 0
+              special = :constant
+            end
+          end
+        end
+
+        if (0..10).include?(deg)
+          degree = [
+            :undefinded,
+            :linear,
+            :quadratic,
+            :qubic,
+            :quartic,
+            :quintic,
+            :hexic,
+            :heptic,
+            :octic,
+            :nonic,
+            :decic
+          ][deg]
+        end
+
+        basic   ||= :polynomial
+        special ||= :normal
+        degree  ||= :"#{deg}th_degree"
+
+        { :special => special, :deg => degree, :len => basic }
+      end
+
+      ##
+      ## @brief      displys a string form of the polynomial
+      ##
+      ## @return     a string
+      ##
+      def to_s
+        expression = monomials.collect { |monomial| monomial.to_s }.reduce { |m, t|
+          joiner = t[0] == "-" ? "" : "+"
+          m += joiner + t
+        }
+        if @gcd.cof == 1 and @gcd.deg == 0
+          expression
+        else
+          "#{@gcd}(#{expression})"
+        end
+      end
+    end
+  end
+end

data/test/test_polynomial.rb

@@ -0,0 +1,18 @@
+require 'test/unit'
+require_relative '../lib/polymath/polynomial'
+
+class TestPolynomial < Test::Unit::TestCase
+  include Polymath
+
+  # the parser will guess the polynomial's variable
+  #
+  # @return     { description_of_the_return_value }
+  #
+  def test_parsing
+    polynomial = Polynomial.new("15x^3+15x^332-4xx^2-3y-2")
+    assert_equal polynomial.to_s, "15x^332+11x^3-3x^1-2"
+    assert_equal polynomial.deg, 332
+    assert_equal polynomial.variable, "x"
+  end
+
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: polymath
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- annacrombie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-10 00:00:00.000000000 Z
+dependencies: []
+description: polynomial library
+email: stone.tickle@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "./README.md"
+- "./lib/polymath.rb"
+- "./lib/polymath/error.rb"
+- "./lib/polymath/math/math.rb"
+- "./lib/polymath/nomial/monomial.rb"
+- "./lib/polymath/nomial/parser.rb"
+- "./lib/polymath/nomial/polynomial.rb"
+- "./test/test_polynomial.rb"
+homepage: https://github.com/uab-cs/polymath/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: polynomial library
+test_files: []