symath 0.1.0

data/lib/symath/poly.rb

@@ -0,0 +1,142 @@
+module SyMath
+  # Abstract base class for polynomial classes
+  class Poly
+    attr_reader :arr, :p, :var
+
+    # Transform polynomial back to expression form
+    def to_m()
+      if zero?
+        return 0.to_m
+      end
+
+      exp = 0.to_m
+      d = degree
+
+      (0..d).each do |i|
+        next if @arr[i] == 0
+        
+        if d - i == 1
+          a = @var
+        elsif d - i == 0
+          a = 1.to_m
+        else
+          a = @var**(d - i)
+        end
+
+        exp += @arr[i].to_m*a
+      end
+
+      return exp
+    end
+      
+    def strip!()
+      i = @arr.index { |e| e != 0 }
+      if i.nil?
+        @arr = []
+      else
+        @arr = @arr[i..-1]
+      end
+      
+      return self
+    end
+
+    def zero?()
+      return @arr.empty?
+    end
+
+    # Return the degree of the highest power of the polynomial.
+    def degree()
+      # Hack: Degree of 0 should really be negative infinity
+      return -1 if zero?
+      return @arr.size - 1
+    end
+
+    def sort_factors(list)
+      return list.sort do |a, b|
+        [a.degree, a.arr] <=> [b.degree, b.arr]
+      end
+    end
+
+    def sort_factors_multiple(list)
+      return list.sort do |a, b|
+        [a[0].degree, a[1], a[0].arr] <=> [b[0].degree, b[1], b[0].arr]
+      end
+    end
+
+    def +(other)
+      if other.is_a?(self.class)
+        return add(other)
+      elsif other.is_a?(Integer)
+        return add_ground(other)
+      else
+        raise 'Cannot add ' + other.to_s
+      end
+    end
+
+    def -(other)
+      if other.is_a?(self.class)
+        return sub(other)
+      elsif other.is_a?(Integer)
+        return sub_ground(other)
+      else
+        raise 'Cannot subtract ' + other.to_s
+      end
+    end
+
+    def -@()
+      return neg
+    end
+
+    def *(other)
+      if other.is_a?(self.class)
+        return mul(other)
+      elsif other.is_a?(Integer)
+        return mul_ground(other)
+      else
+        raise 'Cannot multiply with ' + other.to_s
+      end
+    end
+
+    def /(other)
+      if other.is_a?(self.class)
+        return quo(other)
+      elsif other.is_a?(Integer)
+        return quo_ground(other)
+      else
+        raise 'Cannot divide by ' + other.to_s
+      end
+    end    
+    
+    def %(other)
+      if other.is_a?(self.class)
+        return rem(other)
+      elsif other.is_a?(Integer)
+        return trunc(other)
+      else
+        raise 'Cannot divide modulo ' + other.to_s
+      end
+    end
+
+    def **(other)
+      if other.is_a?(Integer) and other == 2
+        return sqr
+      else
+        raise 'Cannot raise to the power of ' + other.to_s
+      end
+    end
+    
+    def [](i)
+      return arr[i]
+    end
+
+    def ==(other)
+      return (self.class == other.class and @arr == other.arr)
+    end  
+    
+    # Returns leading coefficient (i.e coefficient of the biggest power)
+    def lc()
+      return 0 if zero?
+      return @arr[0]
+    end
+  end
+end

data/lib/symath/power.rb

@@ -0,0 +1,224 @@
+require 'symath/operator'
+
+module SyMath
+  class Power < Operator
+    def self.compose_with_simplify(a, b)
+      a = a.to_m
+      b = b.to_m
+
+      if a.is_finite?() == false or b.is_finite?() == false
+        return self.simplify_inf(a, b)
+      end
+            
+      # 0**0 = NaN
+      if a.is_zero? and b.is_zero?
+        return :nan.to_m
+      end
+
+      # n**1 = n
+      if b == 1
+        return a
+      end
+      
+      if a.is_a?(SyMath::Power)
+        return a.base**(a.exponent*b)
+      end
+
+      return self.new(a, b)
+    end
+
+    def self.simplify_inf(a, b)
+      # Indefinite factors
+      if a.is_finite?.nil? or b.is_finite?.nil?
+        return self.new(a, b)
+      end
+
+      # NaN**(..) = NaN, (..)**NaN = NaN
+      if a.is_nan? or b.is_nan?
+        return :nan.to_m
+      end
+
+      # 1**oo = 1**-oo = oo**0 = -oo**0 = NaN
+      if a == 1 or b.is_zero?
+        return :nan.to_m
+      end
+
+      if SyMath.setting(:complex_arithmetic)
+        if b.is_finite? == false
+          return :nan.to_m
+        else
+          return :oo.to_m
+        end
+      else
+        if a.is_zero? and b.is_finite? == false
+          return :nan.to_m
+        end
+
+        # n**-oo = oo**-oo = -oo**-oo = 0
+        if b.is_finite? == false and b.is_negative?
+          return 0.to_m
+        end
+        
+        if a.is_finite? == false and a.is_negative?
+          if b.is_finite? == true
+            # -oo*n = oo*(-1**n)
+            return :oo.to_m.mul(a.sign**b)
+          else
+            # -oo**oo = NaN
+            return :nan.to_m
+          end
+        end
+
+        # -n**oo => NaN
+        if a.is_finite? and a.is_negative?
+          return :nan.to_m
+        end
+        
+        # The only remaining possibilities:
+        # oo**n = n*oo = oo*oo = oo
+        return :oo.to_m
+      end
+    end
+    
+    def initialize(base, exponent)
+      super('**', [base, exponent])
+    end
+
+    def base()
+      return @args[0]
+    end
+    
+    def exponent()
+      return @args[1]
+    end
+
+    # Expression is on the form a**-n, n is a positive number
+    def is_divisor_factor?()
+      return exponent.is_negative_number?
+    end
+
+    # Simple reduction rules, allows sign to change. Returns
+    # (reduced exp, sign, changed).
+    def reduce_modulo_sign
+      # a to the power of 1 reduces to a
+      if exponent == 1
+        return base, 1, true
+      end
+      
+      # Powers of 1 reduces to 1
+      if base == 1 and exponent.is_finite?
+        return base, 1, true
+      end
+
+      # Power of 0 reduces to 0
+      if base == 0 and exponent.is_finite? and exponent != 0
+        return 0.to_m, 1, true
+      end
+      
+      if base != 0 and exponent == 0
+        return 1.to_m, 1, true
+      end
+
+      if base == :e
+        fn = fn(:exp, exponent)
+        # FIXME: Merge functions reduce and reduce_modulo_sign
+        red = fn.reduce
+        if red != fn
+          return red, 1, true
+        end
+      end
+
+      # Reduce negative number
+      if base.is_a?(SyMath::Minus)
+        if exponent.is_number?
+          exp = exponent
+        elsif exponent.is_negative_number?
+          exp = exponent.argument
+        else
+          exp = nil
+        end
+
+        if !exp.nil?
+          e, sign, changed = (base.argument**exp).reduce_modulo_sign
+          if exp.value.odd?
+            sign *= -1
+          end
+          return e, sign, true
+        end
+      end
+
+      # Number power of number reduces to number
+      if base.is_number?
+        if exponent.is_number?
+          return (base.value ** exponent.value).to_m, 1, true
+        end
+
+        if exponent.is_negative_number? and exponent.argument.value > 1
+          return (base.value ** exponent.argument.value).to_m.power(-1), 1, true
+        end
+      end
+
+      # p**q**r reduces to p**(q*r)
+      if base.is_a?(SyMath::Power)
+        return base.base.power(base.exponent.mul(exponent)), 1, true
+      end
+
+      # Reduce positive integer power of vectors and dforms to zero
+      if (base.type.is_dform? or base.type.is_vector?) and
+        exponent.is_number?
+        return 0.to_m, 1, true
+      end
+      
+      # Remaining code reduces only quaternions
+      if !base.is_unit_quaternion?
+        return self, 1, false
+      end
+      
+      # q**n for some unit quaternion
+      # Exponent is 1 or not a number
+      if !exponent.is_number? or exponent == 1
+        return self, 1, false
+      end
+
+      # e is on the form q**n for some integer n >= 2
+      x = exponent.value
+      
+      if x.odd?
+        ret = base
+        x -= 1
+      else
+        ret = 1.to_m
+      end
+
+      if (x/2).odd?
+        return ret, -1, true
+      else
+        return ret, 1, true
+      end
+    end
+
+    def to_s()
+      if base.is_sum_exp? or base.is_prod_exp? or base.is_a?(SyMath::Power)
+        base_str = '(' + base.to_s + ')'
+      else
+        base_str = base.to_s
+      end
+
+      expo_str = (exponent.is_sum_exp? or exponent.is_prod_exp?) ?
+                 '(' + exponent.to_s + ')' :
+                 exponent.to_s
+      
+      return base_str + '**' + expo_str
+    end
+
+    def to_latex()
+      if base.is_sum_exp? or base.is_prod_exp? or base.is_a?(SyMath::Power)
+        base_str = '\left(' + base.to_latex + '\right)'
+      else
+        base_str = base.to_latex
+      end
+
+      return base_str + '^' + '{' + exponent.to_latex + '}'
+    end
+  end
+end

data/lib/symath/product.rb

@@ -0,0 +1,183 @@
+require 'symath/operator'
+
+module SyMath
+  class Product < Operator
+    def self.compose_with_simplify(a, b)
+      a = a.to_m
+      b = b.to_m
+
+      # Multipling a value with an equation multiplies it with both sides,
+      # preserving the balance of the equation
+      if b.is_a?(SyMath::Equation)
+        return eq(a * b.args[0], a * b.args[1])
+      end
+
+      if a.is_finite?() == false or b.is_finite?() == false
+        return self.simplify_inf(a, b)
+      end
+
+      # First try some simple reductions
+      # a*1 => a
+      return a if b == 1
+      return b if a == 1
+
+      # -a*-b => a*b
+      if b.is_a?(SyMath::Minus) and a.is_a?(SyMath::Minus)
+        return a.argument*b.argument
+      end
+
+      # (-a)*b => -(a*b)
+      # a*(-b) => -(a*b)
+      return -(a*b.argument) if b.is_a?(SyMath::Minus)
+      return -(a.argument*b) if a.is_a?(SyMath::Minus)
+      
+      if b.is_a?(SyMath::Matrix)
+        return self.new(a, b)
+      end
+      
+      if a.base == b.base
+        return a.base ** (a.exponent + b.exponent)
+      end
+
+      # (1/a)*b => b/a
+      if a.is_a?(SyMath::Fraction) and a.dividend == 1.to_m
+        return b/a.divisor
+      end
+
+      # a*(1/b) => a*/b
+      if b.is_a?(SyMath::Fraction) and b.dividend == 1.to_m
+        return a/b.divisor
+      end
+
+      if a.type.is_subtype?(:tensor) and b.type.is_subtype?(:tensor)
+        # Expand expression if any of the parts are sum
+        if b.is_sum_exp?
+          return b.terms.map { |f| a.*(f) }.inject(:+)
+        end
+
+        if a.is_sum_exp?
+          return a.terms.map { |f| f.wedge(b) }.inject(:+)
+        end
+        
+        return a.wedge(b)
+      end
+
+      return self.new(a, b)
+    end
+
+    def self.simplify_inf(a, b)
+      # Indefinite factors
+      if a.is_finite?.nil? or b.is_finite?.nil?
+        return self.new(a, b)
+      end
+
+      # NaN multiplies to NaN
+      if a.is_nan? or b.is_nan?
+        return :nan.to_m
+      end
+
+      # oo*0 = 0*oo = NaN
+      if a.is_zero? or b.is_zero?
+        return :nan.to_m
+      end
+
+      if SyMath.setting(:complex_arithmetic)
+        return :oo.to_m
+      else
+        if (a.is_positive? and b.is_positive?) or
+          (a.is_negative? and b.is_negative?)
+          return :oo.to_m
+        end
+
+        if (a.is_negative? and b.is_positive?) or
+          (a.is_positive? and b.is_negative?)
+          return -:oo.to_m
+        end
+      end
+      
+      # :nocov:
+      raise 'Internal error'
+      # :nocov:
+    end
+    
+    def initialize(arg1, arg2)
+      super('*', [arg1, arg2])
+    end
+
+    def factor1()
+      return @args[0]
+    end
+
+    def factor1=(f)
+      @args[0] = f
+    end
+
+    def factor2()
+      return @args[1]
+    end
+    
+    def factor2=(f)
+      @args[1] = f
+    end
+
+    def is_commutative?()
+      return true
+    end
+
+    def is_associative?()
+      return true
+    end
+
+    def is_prod_exp?()
+      return true
+    end
+
+    def factors()
+      return Enumerator.new do |f|
+        factor1.factors.each { |f1| f << f1 }
+        factor2.factors.each { |f2| f << f2 }
+      end
+    end
+    
+    def evaluate()
+      if factor1.is_a?(SyMath::Matrix)
+        return factor1.matrix_mul(factor2)
+      elsif factor2.is_a?(SyMath::Matrix) and
+           factor1.type.is_scalar?
+        return factor2.matrix_mul(factor1)
+      end
+
+      return super
+    end
+
+    def type()
+      return factor1.type.product(factor2.type)
+    end
+
+    def to_s()
+      if SyMath.setting(:expl_parentheses)
+        return '('.to_s + factor1.to_s + '*' + factor2.to_s + ')'.to_s
+      else
+        return @args.map do |a|
+          if a.is_sum_exp?
+            '(' + a.to_s + ')'
+          else
+            a.to_s
+          end
+        end.join('*')
+      end
+    end
+
+    def to_latex()
+      dot = SyMath.setting(:ltx_product_sign) ? ' \cdot ' : ' ';
+      
+      return @args.map do |a|
+        if a.is_sum_exp?
+          '(' + a.to_latex + ')'
+        else
+          a.to_latex
+        end
+      end.join(dot)
+    end      
+  end
+end

data/lib/symath/sum.rb

@@ -0,0 +1,174 @@
+require 'symath/operator'
+
+module SyMath
+  class Sum < Operator
+    def self.compose_with_simplify(a, b)
+      a = a.to_m
+      b = b.to_m
+
+      # Adding a value to an equation adds it to both sides, preserving
+      # the balance of the equation
+      if b.is_a?(SyMath::Equation)
+        return eq(a + b.args[0], a + b.args[1])
+      end
+
+      if a.is_finite?() == false or b.is_finite?() == false
+        return self.simplify_inf(a, b)
+      end
+
+      return a if b == 0
+      return b if a == 0
+
+      sc = 1
+      sf = []
+      oc = 1
+      of = []
+
+      a.factors.each do |f|
+        if f == -1
+          sc *= -1
+        elsif f.is_number?
+          sc *= f.value
+        else
+          sf.push f
+        end
+      end
+
+      b.factors.each do |f|
+        if f == -1
+          oc *= -1
+        elsif f.is_number?
+          oc *= f.value
+        else
+          of.push f
+        end
+      end
+      
+      sc += oc
+
+      if sf == of
+        if sc == 0
+          return 0.to_m
+        end
+
+        if sc != 1
+          sf.unshift sc.to_m
+        end
+
+        return sf.empty? ? 1.to_m : sf.inject(:*)
+      end
+
+      return self.new(a, b)
+    end
+
+    def self.simplify_inf(a, b)
+      # Indefinite terms
+      if a.is_finite?.nil? or b.is_finite?.nil?
+        return a.add(b)
+      end
+      
+      # NaN add to NaN
+      if a.is_nan? or b.is_nan?
+        return :nan.to_m
+      end
+
+      if SyMath.setting(:complex_arithmetic)
+        # +- oo +- oo = NaN
+        if (a.is_finite? == false and b.is_finite? == false)
+          return :nan.to_m
+        end
+
+        # oo + n = n + oo = NaN
+        if (a.is_finite? == false or b.is_finite? == false)
+          return :oo.to_m
+        end
+      else
+        # oo - oo = -oo + oo = NaN
+        if (a.is_finite? == false and b.is_finite? == false)
+          if (a.is_positive? and b.is_negative?) or
+            (a.is_negative? and b.is_positive?)
+            return :nan.to_m
+          end
+        end
+
+        # oo + n = n + oo = oo + oo = oo
+        if a.is_finite? == false
+          return a
+        end
+
+        # n - oo = - oo + n = -oo - oo = -oo
+        if b.is_finite? == false
+          return b
+        end
+      end
+
+      # :nocov:
+      raise 'Internal error'
+      # :nocov:
+    end
+    
+    def initialize(arg1, arg2)
+      super('+', [arg1, arg2])
+    end
+
+    def term1()
+      return @args[0]
+    end
+
+    def term2()
+      return @args[1]
+    end
+
+    def is_commutative?()
+      return true
+    end
+    
+    def is_associative?()
+      return true
+    end
+
+    def is_sum_exp?()
+      return true
+    end
+
+    # Return all terms in the sum
+    def terms()
+      return Enumerator.new do |s|
+        term1.terms.each { |s1| s << s1 }
+        term2.terms.each { |s2| s << s2 }
+      end
+    end
+
+    def evaluate
+      if term1.type.is_matrix?
+        return term1.matrix_add(term2)
+      end
+
+      return super
+    end
+
+    def type()
+      return term1.type.sum(term2.type)
+    end
+
+    def to_s()
+      if SyMath.setting(:expl_parentheses)
+        return '('.to_s + term1.to_s + ' + ' + term2.to_s + ')'.to_s
+      else
+        if term2.is_a?(SyMath::Minus)
+          return term1.to_s + " " + term2.to_s
+        else
+          return term1.to_s + " + " + term2.to_s
+        end
+      end
+    end
+
+    def to_latex()
+      if term2.is_a?(SyMath::Minus)
+        return term1.to_latex + ' ' + term2.to_latex
+      else
+        return term1.to_latex + ' + ' + term2.to_latex
+      end
+    end
+  end
+end