symath 0.1.0

data/lib/symath/operation/integration.rb

@@ -0,0 +1,329 @@
+require 'symath/operation'
+require 'set'
+
+module SyMath::Operation::Integration
+  class IntegrationError < StandardError
+  end
+  
+  # This operation provides methods for calculating some simple indefinite
+  # integrals (anti derivatives), and definite integrals from the boundaries
+  # of the anti-derivatives.
+  # NB: The algorithm is home made and extermely limited. It should be
+  # replaced with some of the known integration algorithm
+
+  @@functions = {}
+
+  def self.initialize()
+    # Anti-derivatives of simple functions with one variable
+    # FIXME: Clean up formulas
+    @@functions = {
+      # Logarithm
+      :ln  => :a.to_m*fn(:ln, :a.to_m) - :a.to_m,
+      # Trigonometric functions
+      :sin => - fn(:cos, :a.to_m),
+      :cos => fn(:sin, :a.to_m),
+      :tan => - fn(:ln, fn(:abs, fn(:cos, :a.to_m))),
+      :cot => fn(:ln, fn(:abs, fn(:sin, :a.to_m))),
+      :sec => fn(:ln, fn(:abs, fn(:sec, :a.to_m) + fn(:tan, :a.to_m))),
+      :csc => - fn(:ln, fn(:abs, fn(:csc, :a.to_m) + fn(:cot, :a.to_m))),
+      # Inverse trigonometric functions
+      :arcsin => :a.to_m*fn(:arcsin, :a.to_m) + fn(:sqrt, 1.to_m - :a.to_m**2),
+      :arccos => :a.to_m*fn(:arccos, :a.to_m) - fn(:sqrt, 1.to_m - :a.to_m**2),
+      :arctan => :a.to_m*fn(:arctan, :a.to_m) -
+                 fn(:ln, fn(:abs, 1.to_m + :a.to_m**2))/2,
+      :arccot => :a.to_m*fn(:arccot, :a.to_m) +
+                 fn(:ln, fn(:abs, 1.to_m + :a.to_m**2))/2,
+      :arcsec => :a.to_m*fn(:arcsec, :a.to_m) -
+                 fn(:ln, fn(:abs, 1.to_m + fn(:sqrt, 1.to_m - :a.to_m**-2))),
+      :arccsc => :a.to_m*fn(:arccsc, :a.to_m) +
+                 fn(:ln, fn(:abs, 1.to_m + fn(:sqrt, 1.to_m - :a.to_m**-2))),
+      # Hyperbolic functions
+      :sinh => fn(:cosh, :a.to_m),
+      :cosh => fn(:sinh, :a.to_m),
+      :tanh => fn(:ln, fn(:cosh, :a.to_m)),
+      :coth => fn(:ln, fn(:abs, fn(:sinh, :a.to_m))),
+      :sech => fn(:arctan, fn(:sinh, :a.to_m)),
+      :csch => fn(:ln, fn(:abs, fn(:tanh, :a.to_m/2))),
+      # Inverse hyperbolic functions
+      :arsinh => :a.to_m*fn(:arsinh, :a.to_m) - fn(:sqrt, :a.to_m**2 + 1),
+      :arcosh => :a.to_m*fn(:arcosh, :a.to_m) - fn(:sqrt, :a.to_m**2 - 1),
+      :artanh => :a.to_m*fn(:artanh, :a.to_m) + fn(:ln, 1.to_m - :a.to_m**2)/2,
+      :arcoth => :a.to_m*fn(:arcoth, :a.to_m) + fn(:ln, :a.to_m**2 - 1)/2,
+      :arsech => :a.to_m*fn(:arsech, :a.to_m) + fn(:arcsin, :a.to_m),
+      :arcsch => :a.to_m*fn(:arcsch, :a.to_m) + fn(:abs, fn(:arsinh, :a.to_m)),
+    }
+
+    @@patterns = {
+      # Polynomial functions
+      (1 - :a**2)**(-1.to_m/2)   => fn(:arcsin, :a),
+      (1 + :a**2)**-1            => fn(:arctan, :a),
+      # Logarithmic functions
+      fn(:ln, :a)**2             => :a*fn(:ln, :a)**2 - 2*:a*fn(:ln, :a) + 2*:a,
+      1/(:a*fn(:ln, :a))         => fn(:ln, fn(:abs, fn(:ln, :a))),
+      # Trigonometric functions
+      fn(:sin, :a)**2            => (:a - fn(:sin, :a)*fn(:cos, :a))/2,
+      fn(:sin, :a)**3            => fn(:cos, 3*:a)/12 - 3*fn(:cos, :a)/4,
+      fn(:cos, :a)**2            => (:a + fn(:sin, :a)*fn(:cos, :a))/2,
+      fn(:cos, :a)**3            => fn(:sin, 3*:a)/12 + 3*fn(:sin, :a)/4,
+      fn(:sec, :a)**2            => fn(:tan, :a),
+      fn(:sec, :a)**3            => fn(:sec, :a)*fn(:tan, :a)/2 +
+                                    fn(:ln, fn(:abs, fn(:sec, :a) + fn(:tan, :a)))/2,    
+      fn(:csc, :a)**2            => - fn(:cot, :a),
+      fn(:csc, :a)**3            => - fn(:csc, :a)*fn(:cot, :a)/2 -
+                                    fn(:ln, fn(:abs, fn(:csc, :a) + fn(:cot, :a)))/2,
+      # Hyperbolic functions
+      fn(:sinh, :x)**2           => fn(:sinh, 2*:a)/4 - :a/2,
+      fn(:cosh, :x)**2           => fn(:sinh, 2*:a)/4 + :a/2,
+      fn(:tanh, :x)**2           => :a - fn(:tanh, :a),
+      # Combined trigonometric functions
+      fn(:sin, :a)*fn(:cos, :a)     => fn(:sin, :a)**2/2,
+      fn(:sec, :a)*fn(:tan, :a)     => fn(:sec, :a),
+      fn(:csc, :a)*fn(:cot, :a)     => - fn(:csc, :a),
+      1/(fn(:sin, :a)*fn(:cos, :a)) => fn(:ln, fn(:abs, fn(:tan, :a))),
+      fn(:sin, fn(:ln, :a))         => :a*(fn(:sin, fn(:ln, :a)) -
+                                           fn(:cos, fn(:ln, :a)))/2,
+      fn(:cos, fn(:ln, :a))         => :a*(fn(:sin, fn(:ln, :a)) +
+                                           fn(:cos, fn(:ln, :a)))/2,
+    }
+  end
+
+  def anti_derivative(var)
+    raise 'Var is not a differential' if !var.is_d?
+
+    if is_constant?([var.undiff].to_set)
+      return int_constant(var)
+    end
+
+    if self.is_a?(SyMath::Minus)
+      return - self.argument.anti_derivative(var)
+    end
+
+    if is_sum_exp?
+      return int_sum(var)
+    end
+
+    if is_prod_exp?
+      return int_product(var)
+    end
+
+    if is_a?(SyMath::Operator) and @@functions.key?(name.to_sym)
+      return int_function(var)
+    end
+
+    return int_power(var)
+  end
+
+  def int_failure()    
+    raise IntegrationError, 'Cannot find an antiderivative for expression ' + to_s
+  end
+
+  def int_pattern(var)
+    # Try to match expression against various patterns
+    vu = var.undiff
+    a = :a.to_m
+
+    @@patterns.each do |f, f_int|
+      m = match(f, [a])
+      next if m.nil?
+
+      m.each do |mi|
+        # We must check that variable a maps to c1*x + c2
+        (c1, c2) = get_linear_constants(mi[a], var)
+        next if c1.nil?
+
+        # We have found a match, and the argument is a linear function.
+        # Substitute the argument into the free variable of the pattern
+        # function.
+        ret = f_int.deep_clone
+        ret.replace({ a => mi[a] })
+        return c1.inv*ret
+      end
+    end
+
+    # Give up!
+    int_failure
+  end
+
+  def int_constant(var)
+    # c => c*x
+    return mul(var.undiff)
+  end
+    
+  def int_product(var)
+    vu = var.undiff
+    vset = [vu].to_set
+
+    prodc = 1.to_m
+    proda = []
+    diva = []
+    
+    factors.each do |f|
+      if !f.type.is_subtype?(:scalar)
+        int_failure
+      end
+
+      if f.is_constant?(vset)
+        prodc *= f
+        next
+      end
+
+      if f.is_divisor_factor?
+        diva.push f.base**f.exponent.argument
+        next
+      end
+
+      proda.push f
+    end
+
+    # c/exp
+    if proda.length == 0 and diva.length == 1
+      return prodc*diva[0].int_inv(var)
+    end
+
+    # c*exp
+    if proda.length == 1 and diva.length == 0
+      return prodc*proda[0].anti_derivative(var)
+    end
+
+    exp = proda.inject(1.to_m, :*)/diva.inject(1.to_m, :*)
+    return prodc*exp.int_pattern(var)
+  end
+
+  def get_linear_constants(arg, var)
+    # If arg is on the form c1*var + c2, return the two constants.
+    vu = var.undiff
+    vset = [vu].to_set
+    c1 = 0.to_m
+    c2 = 0.to_m
+
+    arg.terms.each do |t|
+      if t.is_constant?(vset)
+        c2 += t
+      else
+        # Split term into a constant part and (hopefully) a single factor
+        # which equals to var
+        prodc = 1.to_m
+        has_var = false
+
+        t.factors.each do |f|
+          if !f.type.is_subtype?(:scalar)
+            # Non-scalar factor. Don't know what to do
+            return
+          end
+
+          if f.is_constant?(vset)
+            prodc *= f
+            next
+          end
+
+          # Found more than one var. Return negative
+          if has_var
+            return
+          end
+
+          # Factor is var. Remember it, but continue to examine the other
+          # factors.
+          if f == vu
+            has_var = true
+            next
+          end
+
+          # Factor is a function of var. Return negative
+          return
+        end
+
+        c1 += prodc
+      end
+
+      # Return negative if the whole expression is constant
+      return if c1 == 0
+    end
+
+    return [c1, c2]
+  end
+
+  def int_inv(var)
+    # Hack: integrate 1/exp (by convention of the sibling functions,
+    # it should have integrated exp)
+    xp = exponent
+    vu = var.undiff
+    vset = [vu].to_set
+
+    if base == vu and xp.is_constant?(vset)
+      if xp == 1.to_m
+        # 1/x => ln|x|
+        return fn(:ln, fn(:abs, vu))
+      else
+        # 1/x**n => x**(1 - n)/(1 - n)
+        return vu**(1.to_m - xp)/(1.to_m - xp)
+      end
+    end
+
+    (self**-1).int_pattern(var)
+  end
+
+  def int_function(var)
+    # At this point exp is a single argument function which we know how
+    # to integrate. Check that the argument is a linear function
+    arg = args[0]
+    (c1, c2) = get_linear_constants(arg, var)
+    if c1.nil?
+      # Argument is not linear. Try pattern match as a last resort.
+      return int_pattern(var)
+    else
+      # The function argument is linear. Do the integration.
+      # int(func(c1*x + c2)) -> Func(c1*x+ c2)/c1
+      fexp = @@functions[name.to_sym].deep_clone
+      fexp.replace({ :a.to_m =>  arg })
+      return c1.inv*fexp
+    end
+  end
+
+  def int_power(var)
+    # At this point, exp should not be a constant, a sum or a product.
+    vu = var.undiff
+    vset = [vu].to_set
+
+    b = base
+    xp = exponent
+
+    if b == vu
+      if !xp.is_constant?(vset)
+        # Cannot integrate x**f(x)
+        int_failure
+      end
+
+      # x**n => x**(n + 1)/(n + 1)
+      return vu**(xp + 1)/(xp + 1)
+    end
+
+    # Check exponential functions
+    if b.is_constant?(vset)
+      (c1, c2) = get_linear_constants(xp, var)
+      # b**(c1*x + c2) => b**(c1*x + c2)/(b*ln(c1))
+      if c1.nil?
+        int_failure
+      end
+
+      return b**(xp)/(c1*fn(:ln, b))
+    end
+
+    # Try pattern match as last resort
+    int_pattern(var)
+  end
+    
+  def int_sum(var)
+    ret = 0.to_m
+    terms.each { |s| ret += s.anti_derivative(var) }
+    return ret
+  end
+
+  # This method calculates the difference of two boundary values of an
+  # expression (typically used for calculating the definite integral from
+  # the anti-derivative, using the fundamental theorem of calculus)
+  def integral_bounds(var, a, b)
+    bexp = deep_clone.replace({ var =>  b })
+    aexp = deep_clone.replace({ var =>  a })
+    return bexp - aexp
+  end
+end

data/lib/symath/operation/match.rb

@@ -0,0 +1,166 @@
+require 'symath/operation'
+
+module SyMath::Operation::Match
+  include SyMath::Operation
+
+  def build_assoc_op(args, opclass)
+    e = args[-1]
+    if args.length > 1
+      args[0..-2].each do |a|
+        e = opclass.new(a, e)
+      end
+    end
+
+    return e
+  end
+
+  # Match the lists of arguments of two associative operators, binding the
+  # free variables in args2 to expressions in args1. Because of the
+  # associativity property, multiple matches may be possible. E.g.
+  # [x, y, z] == [a, b] gives two possible matches: a = (x op y), b = z or
+  # a = x, b = (y op z)
+  # A list of hashes is returned, each hash representing a match.
+  def match_assoc(args1, args2, freevars, boundvars, opclass)
+    # If args1 is shorter than args2 we do not have enough arguments for a
+    # match
+    return if args1.length < args2.length
+
+    # If args2 has only one argument, it must match the whole list of args1
+    if args2.length == 1
+      return build_assoc_op(args1, opclass).match(
+               args2[0], freevars, boundvars)
+    end
+
+    ret = []
+    all = (0..args1.length - 1).to_a
+    fv = freevars
+    bv = boundvars
+
+    (1..args1.length - args2.length + 1).each do |n|
+      # Match args1[0..m] with args2[0]
+      if is_commutative?
+        # Select all combinations of n arguments
+        sel = all.combination(n)
+      else
+        # Non-commutative operation. Make one selection of the
+        # first n arguments
+        sel = [(0..n - 1).to_a]
+      end
+
+      # Iterate over all selections and find all possible matches
+      sel.each do |s|
+        select1 = s.map { |i| args1[i] }
+        remain1 = (all - s).map { |i| args1[i] }
+
+        if n == 1
+          m0 = select1[0].match(args2[0], freevars, boundvars)
+        else
+          if args2[0].is_a?(SyMath::Definition::Variable) and
+            freevars.include?(args2[0])
+            # Register match.
+            m0 = [{ args2[0] => build_assoc_op(select1, opclass) }]
+          else
+            # No match. Skip to the next argument combination
+            next
+          end
+        end
+
+        # Set of matches is empty. Return negative
+        next if m0.nil?
+
+        # For each possible first argument match, we build new lists of free
+        # and bound variables and try to match the rest of the remaining list
+        # of the argument recursively.
+        m0.each do |m|
+          fv = freevars - m.keys
+          bv = boundvars.merge(m)
+          mn = match_assoc(remain1, args2[1..-1], fv, bv, opclass)
+          if mn.nil?
+            # No match. Skip to the next argument combination
+            next
+          else
+            # We have a complete match. Store it in res, and continue
+            m0.each do |m0i|
+              mn.each do |mni|
+                ret << m0i.merge(mni)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    return if ret.empty?
+    
+    return ret
+  end
+  
+  # Match self with an expression and a set of free variables. A match is
+  # found if each of the free variables can be replaced with subexpressions
+  # making the expression equal to self. In that case, a hash is returned
+  # mapping each of the variables to the corresponding subexpression. If no
+  # match is found, nil is returned. An optional boundvars hash contains a
+  # map of variables to expressions which are required to match exactly.
+  def match(exp, freevars, boundvars = {})
+    # Traverse self and exp in parallel. Match subexpressions recursively,
+    # and match end nodes one by one. The two value nodes are compared for
+    # equality and each argument are matched recursively.
+    # Constant or operator: Just match nodes by exact comparison
+    if exp.is_a?(SyMath::Definition) and
+      !exp.is_a?(SyMath::Definition::Variable)
+      # Node is a definition. Exact match is required
+      if (self == exp)
+        # Return match with no variable bindings
+        return [{}]
+      else
+        return
+      end
+    end
+
+    # Variable: If it is a free variable, it is a match. We remove it from
+    # the freevars set and add it to the boundvars set together with the
+    # expression it matches. If it is a bound variable, we require that
+    # the expression matches the binding.
+    if exp.is_a?(SyMath::Definition::Variable)
+      # Node is a variable
+      if freevars.include?(exp)
+        # Node is a free variable. Return binding.
+        return [{ exp => self }]
+      elsif boundvars.key?(exp)
+        # Node is a bound variable. Check that self matches the binding.
+        if boundvars[exp] == self
+          return [{}]
+        else
+          return
+        end
+      else
+        # Node is an unknown variable. Exact match is required
+        return (exp == self)? [{}] : nil
+      end
+    end
+
+    # Operator. Compare class and name. Then compare each argument
+    if exp.is_a?(SyMath::Operator)
+      # Node is an operator. Check class and name.
+      if self.class != exp.class or self.name != exp.name
+        return
+      end
+
+      # The args_assoc method takes care of associativity by returning the
+      # argument list of all directly connected arguments.
+      self_args = self.args_assoc
+      exp_args = exp.args_assoc
+      ret = {}
+      m = match_assoc(self_args, exp_args, freevars, boundvars, self.class)
+      
+      return if m.nil?
+
+      return m.map { |r| boundvars.merge(r) }
+    end
+
+    # :nocov:
+    # All value types should be covered at this point, but one never knows.
+    raise 'Don\'t know how to compare value type ' + exp.class.to_s
+    # :nocov:
+  end
+end