symath 0.1.0

data/lib/symath/fraction.rb

@@ -0,0 +1,177 @@
+require 'symath/operator'
+
+module SyMath
+  class Fraction < Operator
+    def self.compose_with_simplify(a, b)
+      a = a.to_m
+      b = b.to_m
+
+      return a if b == 1
+
+      if a.is_finite?() == false or b.is_finite?() == false
+        return self.simplify_inf(a, b)
+      end
+      
+      # Divide by zero
+      if b.is_zero?
+        if SyMath.setting(:complex_arithmetic)
+          if a.is_zero?
+            return :nan.to_m
+          else
+            return :oo.to_m
+          end
+        else
+          return :nan.to_m
+        end
+      end
+
+      if a.is_a?(SyMath::Fraction)
+        if b.is_a?(SyMath::Fraction)
+          return self.new(a.dividend*b.divisor, a.divisor*b.dividend)
+        else
+          return self.new(a.dividend, a.divisor*b)
+        end
+      elsif b.is_a?(SyMath::Fraction)
+        return self.new(a*b.divisor, b.dividend)
+      end
+
+      return self.new(a, b)
+    end
+
+    # Divide infinite values
+    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
+      if a.is_nan? or b.is_nan?
+        return :nan.to_m
+      end
+      
+      # oo/oo = oo/-oo = -oo/oo = NaN
+      if a.is_finite? == false and b.is_finite? == false
+        return :nan.to_m
+      end
+
+      # */0 = NaN
+      if b.is_zero?
+        if SyMath.setting(:complex_arithmetic)
+          return :oo.to_m
+        else
+          return :nan.to_m
+        end
+      end
+
+      # n/oo = n/-oo = 0
+      if a.is_finite?
+        return 0.to_m
+      end
+
+      # oo/n = -oo/-n = oo, -oo/n = oo/-n = -oo
+      if b.is_finite?
+        if SyMath.setting(:complex_arithmetic)
+          return :oo.to_m
+        else
+          if a.sign == b.sign
+            return :oo.to_m
+          else
+            return -:oo.to_m
+          end
+        end
+      end
+
+      # :nocov:
+      raise 'Internal error'
+      # :nocov:
+    end
+
+    def initialize(dividend, divisor)
+      super('/', [dividend, divisor])
+    end
+
+    def dividend()
+      return @args[0]
+    end
+
+    def divisor()
+      return @args[1]
+    end
+    
+    def is_prod_exp?()
+      return true
+    end
+
+    def factors()
+      return Enumerator.new do |f|
+        dividend.factors.each { |d1| f << d1 }
+        divisor.factors.each { |d2|
+          if d2 != 1
+            f << d2**-1
+          end
+        }
+      end
+    end
+
+    def evaluate()
+      # Evaluate matrix division by divding elements
+      if dividend.is_a?(SyMath::Matrix)
+        return dividend.matrix_div(divisor)
+      end
+
+      # Evaluate df/dx expression.
+      if dividend.is_a?(SyMath::Operator) and
+        dividend.definition.is_a?(SyMath::Definition::D)
+        # Evaluate if the divisor is a simple dform. The composed form
+        # d(x) is accepted as well as the simple dx variable.
+        if divisor.is_a?(SyMath::Definition::Variable) and divisor.is_d?
+          v = divisor.undiff
+        elsif divisor.is_a?(SyMath::Definition::D) and
+             divisor.args[0].is_a?(SyMath::Definition::Variable) and
+             divisor.args[0].type.is_scalar?
+          v = divisor.args[0]
+        else
+          return super
+        end
+
+        diff = dividend.args[0].evaluate.d([v]).normalize
+        # Hack: We must divide all terms by dv since the simplification does
+        # not recognize factors common to each term
+        ret = 0
+        dv = v.to_d
+        diff.terms.each do |t|
+          ret += (t/dv).normalize
+        end
+
+        return ret
+      end
+
+      return super
+    end
+
+    def type()
+      if dividend.type.is_subtype?('rational')
+        return 'rational'.to_t
+      else
+        return dividend.type
+      end
+    end
+    
+    def to_s()
+      dividend_str = dividend.is_sum_exp? ? '(' + dividend.to_s + ')' : dividend.to_s
+      divisor_str = (divisor.is_sum_exp? or divisor.is_prod_exp?) ?
+                      '(' + divisor.to_s + ')' :
+                      divisor.to_s
+      if SyMath.setting(:expl_parentheses)
+        return '('.to_s + dividend_str + '/' + divisor_str + ')'.to_s
+      else
+        return dividend_str + '/' + divisor_str
+      end
+    end
+
+    def to_latex()
+      return '\frac{' + dividend.to_latex + '}{' + divisor.to_latex + '}'
+    end
+  end
+end

data/lib/symath/matrix.rb

@@ -0,0 +1,252 @@
+require 'symath/value'
+
+module SyMath
+  class Matrix < Value
+    attr_reader :nrows, :ncols
+    
+    def initialize(data)
+      raise 'Not an array: ' + data.to_s if !data.is_a?(Array)
+      raise 'Array is empty' if data.length == 0
+
+      if data[0].is_a?(Array) then
+        # Multidimensional array
+        @nrows = data.length
+        raise 'Number of columns is zero' if data[0].length == 0
+        @ncols = data[0].length
+        # Check that all rows contain arrays of the same length
+        data.each do |r|
+          raise 'Row is not array' if !r.is_a?(Array)
+          raise 'Row has invalid length' if r.length != @ncols
+        end
+        @elements = data.map { |r| r.map { |c| c.to_m } }
+      else
+        # Simple array. Creates a single row matrix
+        @nrows = 1
+        @ncols = data.length
+        @elements = [data.map { |c| c.to_m }]
+      end
+    end
+
+    # :nocov:
+    def is_commutative?()
+      return false
+    end
+
+    def is_associative?()
+      return true
+    end
+    # :nocov:
+
+    def hash()
+      return [0, 0].hash
+    end
+    
+    def row(i)
+      return @elements[i]
+    end
+
+    def col(i)
+      return @elements.map { |r| r[i] }
+    end
+
+    def [](i, j)
+      return @elements[i][j]
+    end
+
+    def is_square?()
+      return @ncols == @nrows
+    end
+
+    def matrix_mul(other)
+      if !other.is_a?(SyMath::Matrix)
+        data = (0..@nrows - 1).map do |r|
+          (0..@ncols - 1).map { |c| self[r, c]*other }
+        end
+
+        return SyMath::Matrix.new(data)
+      end
+      
+      raise 'Invalid dimensions' if @ncols != other.nrows
+
+      data = (0..@nrows - 1).map do |r|
+        (0..other.ncols - 1).map do |c|
+          (0..@ncols - 1).map do |c2|
+            self[r, c2]*other[c2, c]
+          end.inject(:+) 
+        end
+      end
+
+      return SyMath::Matrix.new(data)
+    end
+
+    def matrix_div(other)
+      raise 'Cannot divide matrix by matrix' if other.is_a?(SyMath::Matrix)
+
+      data = (0..@nrows - 1).map do |r|
+        (0..@ncols - 1).map { |c| self[r, c]/other }
+      end
+
+      return SyMath::Matrix.new(data)
+    end
+
+    def /(other)
+      return div(other)
+    end
+
+    def matrix_add(other)
+      if other.is_a?(SyMath::Minus) and other.argument.is_a?(SyMath::Matrix)
+        return self.matrix_sub(other.argument)
+      end
+
+      raise 'Invalid dimensions' if @ncols != other.ncols or @nrows != other.nrows
+
+      data = (0..@nrows - 1).map do |r|
+        (0..@ncols - 1).map do |c|
+          self[r, c] + other[r, c]
+        end
+      end
+
+      return SyMath::Matrix.new(data)
+    end
+
+    def +(other)
+      return add(other)
+    end
+
+    def matrix_sub(other)
+      raise 'Invalid dimensions' if @ncols != other.ncols or @nrows != other.nrows
+
+      data = (0..@nrows - 1).map do |r|
+        (0..@ncols - 1).map do |c|
+          self[r, c] - other[r, c]
+        end
+      end
+
+      return SyMath::Matrix.new(data)
+    end
+
+    def -(other)
+      return sub(other)
+    end
+
+    def matrix_neg()
+      data = @elements.map do |r|
+        r.map do |e|
+          - e
+        end
+      end
+
+      return SyMath::Matrix.new(data)
+    end
+
+    def -@()
+      return neg
+    end
+
+    def transpose()
+      return SyMath::Matrix.new(@elements.transpose)
+    end
+
+    def inverse()
+      raise 'Matrix is not square' if !is_square?
+
+      return adjugate.matrix_div(determinant)
+    end
+
+    # The adjugate of a matrix is the transpose of the cofactor matrix
+    def adjugate()
+      data = (0..@ncols - 1).map do |c|
+        (0..@nrows - 1).map { |r| cofactor(r, c) }
+      end
+
+      return SyMath::Matrix.new(data)
+    end
+
+    def determinant()
+      raise 'Matrix is not square' if !is_square?
+      
+      return minor((0..@nrows - 1).to_a, (0..@ncols - 1).to_a)
+    end
+
+    # The minor is the determinant of a submatrix. The submatrix is given by
+    # the rows and cols which are arrays of indexes to the rows and columns
+    # to be included
+    def minor(rows, cols)
+      raise 'Not square' if rows.length != cols.length
+
+      # Determinant of a single element is just the element
+      if rows.length == 1
+        return self[rows[0], cols[0]]
+      end
+
+      ret = 0.to_m
+      sign = 1
+      subrows = rows - [rows[0]]
+
+      # Loop over all elements e in first row. Calculate determinant as:
+      #   sum(sign*e*det(rows + cols except the one including e))
+      # The sign variable alternates between 1 and -1 for each summand 
+      cols.each do |c|
+        subcols = cols - [c]
+        if (sign > 0)
+          ret += self[rows[0], c]*minor(subrows, subcols)
+        else
+          ret -= self[rows[0], c]*minor(subrows, subcols)
+        end
+
+        sign *= -1
+      end
+
+      return ret
+    end
+
+    # The cofactor of an element is the minor given by the rows and columns
+    # not including the element, multiplied by a sign factor which alternates
+    # for each row and column
+    def cofactor(r, c)
+      sign = (-1)**(r + c)
+      rows = (0..@nrows - 1).to_a - [r]
+      cols = (0..@ncols - 1).to_a - [c]
+      return minor(rows, cols)*sign.to_m
+    end
+    
+    def trace()
+      raise 'Matrix is not square' if !is_square?
+      
+      return (0..@nrows - 1).map { |i| self[i, i] }.inject(:+)
+    end
+    
+    def ==(other)
+      return false if !other.is_a?(SyMath::Matrix)
+
+      return false if nrows != other.nrows
+      return false if ncols != other.ncols
+
+      (0..@nrows - 1).each do |r|
+        (0..@ncols - 1).each do |c|
+          return false if self[r, c] != other[r, c]
+        end
+      end
+
+      return true
+    end
+
+    alias eql? ==
+
+    def to_s()
+      # This will in many cases look rather messy, but we don't have the option
+      # to format the matrix over multiple lines.
+      return '[' + @elements.map { |r| r.map { |c| c.to_s }.join(', ') }.join('; ') + ']'
+    end
+
+    def type()
+      return SyMath::Type.new('matrix', dimn: ncols, dimm: nrows)
+    end
+  end
+end
+
+class Array
+  def to_m()
+    return SyMath::Matrix.new(self)
+  end
+end

data/lib/symath/minus.rb

@@ -0,0 +1,125 @@
+require 'symath/operator'
+
+module SyMath
+  class Minus < Operator
+    def self.compose_with_simplify(a)
+      a = a.to_m
+
+      if a == 0
+        return a
+      end
+      
+      if a.is_a?(SyMath::Minus)
+        # - - a => a
+        return a.argument
+      else
+        return self.new(a)
+      end
+    end
+
+    def initialize(arg)
+      super('-', [arg])
+    end
+
+    def argument()
+      return @args[0]
+    end
+
+    def is_positive?()
+      if argument.is_nan?
+        return false
+      end
+
+      if SyMath.setting(:complex_arithmetic) and (argument.is_finite? == false)
+        # Define complex infinity to be positive
+        return true
+      end
+
+      if argument.is_positive?.nil?
+        return
+      end
+
+      return (!argument.is_positive? and !argument.is_zero?)
+    end
+
+    def is_negative_number?()
+      return argument.is_number?
+    end
+
+    def is_zero?()
+      return argument.is_zero?
+    end
+
+    def is_finite?()
+      return argument.is_finite?
+    end
+    
+    def is_sum_exp?()
+      return true
+    end
+
+    def is_prod_exp?()
+      return true
+    end
+
+    def factors()
+      return Enumerator.new do |f|
+        f << -1.to_m
+        argument.factors.each { |f1| f << f1 }
+      end
+    end
+
+    def sign()
+      return -argument.sign
+    end
+    
+    def terms()
+      return Enumerator.new do |s|
+        argument.terms.each { |s1| s << s1.neg }
+      end
+    end
+
+    def reduce_constant_factors()
+      return -argument.reduce_constant_factors
+    end
+      
+    # Simple reduction rules, allows sign to change. Returns
+    # (reduced exp, sign, changed).
+    def reduce_modulo_sign
+      red, sign, changed = argument.reduce_modulo_sign
+      return red, -sign, true
+    end
+
+    def evaluate
+      if argument.is_a?(SyMath::Matrix)
+        return argument.matrix_neg
+      end
+
+      return super
+    end
+
+    def type()
+      if argument.type.is_subtype?('integer')
+        return 'integer'.to_t
+      else
+        return argument.type
+      end
+    end
+    
+    def to_s()
+      if SyMath.setting(:expl_parentheses)
+        return '(- '.to_s + argument.to_s + ')'.to_s
+      else
+        if argument.is_a?(SyMath::Sum)
+          return '- ('.to_s + argument.to_s + ')'.to_s
+        else
+          return '- '.to_s + argument.to_s
+        end
+      end
+    end
+
+    def to_latex()
+      return '- '.to_s + argument.to_latex
+    end
+  end
+end

data/lib/symath/operation/differential.rb

@@ -0,0 +1,167 @@
+require 'symath/operation'
+require 'set'
+
+module SyMath::Operation::Differential
+  class DifferentialError < StandardError
+  end
+
+  include SyMath::Operation
+
+  # The d() method provided in this operation module calculates the
+  # differential with respect to a given set of variables. Note that the
+  # operation returns the differential and not the derivative, so the
+  # resulting expression is a differential form.
+
+  # FIXME. The differential method should work on a function and return
+  # a lambda with :x/:dx as free variable, for each variable of the
+  # input function.
+
+  # Module initialization
+  def self.initialize()
+    # Map of single argument functions to their derivative.
+    # FIXME: Check whether this still works if the symbol a is defined?
+    @@functions = {
+      # Exponential and trigonometric functions
+      :exp => definition(:exp),
+      :ln  => lmd(1.to_m/:a.to_m, :a),
+      # Trigonometric functions
+      :sin => definition(:cos),
+      :cos => lmd(- fn(:sin, :a), :a),
+      :tan => lmd(1.to_m + fn(:tan, :a)**2, :a),
+      :cot => lmd(- (1.to_m + fn(:cot, :a)**2), :a),
+      :sec => lmd(fn(:sec, :a)*fn(:tan, :a), :a),
+      :csc => lmd(- fn(:cot, :a.to_m)*fn(:csc, :a.to_m), :a),
+      # Inverse trigonometric functions
+      :arcsin => lmd(1.to_m/fn(:sqrt, 1.to_m - :a.to_m**2), :a),
+      :arccos => lmd(- 1.to_m/fn(:sqrt, 1.to_m - :a.to_m**2), :a),
+      :arctan => lmd(1.to_m/fn(:sqrt, 1.to_m + :a.to_m**2), :a),
+      :arcsec => lmd(1.to_m/(fn(:abs, :a)*fn(:sqrt, :a.to_m**2 - 1)), :a),
+      :arccsc => lmd(- 1.to_m/(fn(:abs, :a)*fn(:sqrt, :a.to_m**2 - 1)), :a),
+      :arccot => lmd(- 1.to_m/(1.to_m + :a.to_m**2), :a),
+      # Hyperbolic functions
+      :sinh => definition(:cosh),
+      :cosh => definition(:sinh),
+      :tanh => lmd(fn(:sech, :a)**2, :a),
+      :sech => lmd(- fn(:tanh, :a)*fn(:sech, :a), :a),
+      :csch => lmd(- fn(:coth, :a)*fn(:csch, :a), :a),
+      :coth => lmd(- fn(:csch, :a)**2, :a),
+      # Inverse hyperbolic functions
+      :arsinh => lmd(1.to_m/fn(:sqrt, :a.to_m**2 + 1), :a),
+      :arcosh => lmd(1.to_m/fn(:sqrt, :a.to_m**2 - 1), :a),
+      :artanh => lmd(1.to_m/(1.to_m - :a.to_m**2), :a),
+      :arsech => lmd(- 1.to_m/(:a.to_m*fn(:sqrt, 1.to_m - :a.to_m**2)), :a),
+      :arcsch => lmd(- 1.to_m/(fn(:abs, :a.to_m)*fn(:sqrt, :a.to_m**2 + 1)), :a),
+      :arcoth => lmd(1.to_m/(1.to_m - :a.to_m**2), :a),
+    }
+  end
+
+  def d(vars)
+    if self.is_a?(SyMath::Definition::Function)
+      return d_function_def(vars)
+    end
+
+    # d(c) = 0 for constant c
+    if is_constant?(vars)
+      return 0.to_m
+    end
+
+    # d(v) = dv for variable v
+    if vars.member?(self)
+      return to_d
+    end
+
+    # d(a + b + ...) = d(a) + d(b) + ...
+    if is_a?(SyMath::Sum)
+      return term1.d(vars) + term2.d(vars)
+    end
+
+    # d(-a) = -d(a)
+    if is_a?(SyMath::Minus)
+      return -argument.d(vars)
+    end
+
+    # Product rule
+    if is_a?(SyMath::Product)
+      return d_product(vars)
+    end
+
+    # Fraction rule
+    if is_a?(SyMath::Fraction)
+      return d_fraction(vars)
+    end
+
+    # Power rule
+    if is_a?(SyMath::Power)
+      return d_power(vars)
+    end
+
+    # Derivative of function
+    return d_function(vars)
+  end
+
+  def d_failure()
+    raise DifferentialError, 'Cannot calculate differential of expression ' + to_s
+  end
+
+  # For simplicity, just use wedge products all the time. They will be
+  # normalized to scalar products afterwards.
+  def d_product(vars)
+    return (_d_wedge(factor1.d(vars), factor2) +
+            _d_wedge(factor1, factor2.d(vars)))
+  end
+
+  def d_fraction(vars)
+    return (_d_wedge(dividend.d(vars), divisor) -
+            _d_wedge(dividend, divisor.d(vars))) /
+           (divisor**2)
+  end
+
+  def d_power(vars)
+    if (exponent.is_constant?(vars))
+      return _d_wedge(_d_wedge(exponent, base**(exponent - 1)), base.d(vars))
+    else
+      return _d_wedge(_d_wedge(self, fn(:ln, base)), exponent.d(vars)) +
+        _d_wedge(_d_wedge(exponent, base**(exponent - 1)), base.d(vars))
+    end
+  end
+
+  def d_function_def(vars)
+    if name != '' and @@functions.key?(name.to_sym)
+      df = @@functions[name.to_sym]
+      dfcall = df.(args[0]).evaluate
+      return _d_wedge(dfcall, args[0].d(vars))
+    end
+
+    if !exp.nil?
+      return self.(*args).evaluate.d(vars)
+    end
+
+    d_failure
+  end
+
+  def d_function(vars)
+    if !self.is_a?SyMath::Operator
+      d_failure
+    end
+
+    if name != '' and @@functions.key?(name.to_sym)
+      df = @@functions[name.to_sym]
+      dfcall = df.(args[0]).evaluate
+      return _d_wedge(dfcall, args[0].d(vars))
+    end
+
+    if !definition.exp.nil?
+      return definition.(*args).evaluate.d(vars)
+    end
+
+    d_failure
+  end
+
+  # Apply wedge product or ordinary product between two expressions,
+  # depending on whether or not they have vector parts.
+  def _d_wedge(exp1, exp2)
+    # The product operator will determine whether this is a scalar
+    # or a wedge product.
+    return (exp1.factors.to_a + exp2.factors.to_a).inject(:*)
+  end
+end