symath 0.1.0

data/lib/symath/definition/flat.rb

@@ -0,0 +1,31 @@
+require 'symath/value'
+require 'symath/definition/operator'
+
+module SyMath
+  class Definition::Flat < Definition::Operator
+    def initialize()
+      super(:flat)
+    end
+
+    def description()
+      return 'flat(f) - musical lower/flat/b isomorphic operator'
+    end
+
+    def evaluate_call(c)
+      # Must normalize input, operation depends on factorized vectors
+      return c.args[0].evaluate.normalize.flat
+    end
+
+    def to_s(args = nil)
+      if !args
+        args = @args
+      end
+
+      return "b(#{args[0]})"
+    end
+    
+    def latex_format()
+      return '%s^\flat'
+    end
+  end
+end

data/lib/symath/definition/function.rb

@@ -0,0 +1,197 @@
+require 'symath/definition'
+
+module SyMath
+  class Definition::Function < Definition::Operator
+    def self.init_builtin()
+      # Define the builtin functions
+      SyMath::Definition::Sqrt.new
+      SyMath::Definition::Sin.new
+      SyMath::Definition::Cos.new
+      SyMath::Definition::Tan.new
+      SyMath::Definition::Sec.new
+      SyMath::Definition::Csc.new
+      SyMath::Definition::Cot.new
+      SyMath::Definition::Arcsin.new
+      SyMath::Definition::Arccos.new
+      SyMath::Definition::Arctan.new
+      SyMath::Definition::Arcsec.new
+      SyMath::Definition::Arccsc.new
+      SyMath::Definition::Arccot.new
+      SyMath::Definition::Ln.new
+      SyMath::Definition::Exp.new
+      SyMath::Definition::Abs.new
+      SyMath::Definition::Fact.new
+
+      # Functions defined by an expression
+      expressions = [
+        { :name => 'sinh',
+          :exp  => '(e**x - e**-x)/2',
+          :desc => 'hyperbolic sine',
+        },
+        { :name => 'cosh',
+          :exp  => '(e**x + e**-x)/2',
+          :desc => 'hyperbolic cosine',
+        },
+        { :name => 'tanh',
+          :exp  => '(e**x - e**-x)/(e**x + e**-x)',
+          :desc => 'hyperbolic tangent',
+        },
+        { :name => 'coth',
+          :exp  => '(e**x + e**-x)/(e**x - e**-x)',
+          :desc => 'hyperbolic cotangent',
+        },
+        { :name => 'sech',
+          :exp  => '2/(e**x + e**-x)',
+          :desc => 'hyperbolic secant',
+        },
+        { :name => 'csch',
+          :exp  => '2/(e**x - e**-x)',
+          :desc => 'hyperbolic cosecant',
+        },
+        { :name => 'arsinh',
+          :exp  => 'ln(x + sqrt(x**2 + 1))',
+          :desc => 'inverse hyperbolic sine',
+        },
+        { :name => 'arcosh',
+          :exp  => 'ln(x + sqrt(x**2 - 1))',
+          :desc => 'inverse hyperbolic cosine',
+        },
+        { :name => 'artanh',
+          :exp  => 'ln((1 + x)/(1 - x))/2',
+          :desc => 'inverse hyperbolic tangent',
+        },
+        { :name => 'arcoth',
+          :exp  => 'ln((x + 1)/(x - 1))/2',
+          :desc => 'inverse hyperbolic cotangent',
+        },
+        { :name => 'arsech',
+          :exp  => 'ln((1/x + sqrt(x**-2 - 1)))',
+          :desc => 'inverse hyperbolic secant',
+        },
+        { :name => 'arcsch',
+          :exp  => 'ln((1/x + sqrt(x**-2 + 1)))',
+          :desc => 'inverse hyperbolic cosecant',
+        },
+      ]
+
+      expressions.each do |e|
+        self.new(e[:name], args: [:x], exp: e[:exp],
+                 description: "#{e[:name]}(x) - #{e[:desc]}")
+      end
+    end
+
+    @@not_mentioned_funcs = {
+      :+   => true,
+      :-   => true,
+      :*   => true,
+      :/   => true,
+      :**  => true,
+      :'=' => true,
+    }
+
+    def self.functions()
+      return self.definitions.select { |f|
+        f.is_function? and !@@not_mentioned_funcs[f.name]
+      }
+    end
+
+    @reductions = {}
+
+    def reduce_call(c, reductions = nil)
+      if reductions.nil?
+        reductions = @reductions
+      end
+
+      if reductions.has_key?(c.args[0])
+        return reductions[c.args[0]]
+      end
+
+      return c
+    end
+
+    # Check if expression is a constant fraction of pi and optionally
+    # i (imaginary unit)
+    def check_pi_fraction(e, im)
+      gotpi = false
+      gotim = !im
+      c = 1
+      dc = 1
+
+      # Check that factors are only constant, divisor constant and pi.
+      # Note: This code is similar to 'reduce_constant_factors'. Refactor?
+      e.factors.each do |f|
+        if f.is_divisor_factor?
+          if f.base.is_number?
+            dc *= f.base.value**f.exponent.argument.value
+            next
+          end
+        end
+
+        if f.is_negative_number?
+          c *= - f.argument.value
+          next
+        end
+
+        if f.is_number?
+          c *= f.value
+          next
+        end
+
+        if !gotpi and f == :pi
+          gotpi = true
+          next
+        end
+
+        if !gotim and f == :i
+          gotim = true
+          next
+        end
+
+        return nil
+      end
+
+      return nil if !gotpi and !gotim and c != 0
+
+      return c, dc
+    end
+    
+    def is_function?()
+      return true
+    end
+
+    def latex_format()
+      return "#{name}(%s)"
+    end
+  end
+end
+
+def fn(f, *args)
+  return SyMath::Operator.create(f, args.map { |a| a.nil? ? a : a.to_m })
+end
+
+def define_fn(name, args, exp = nil)
+  if exp
+    return SyMath::Definition::Function.new(name, args: args, exp: exp)
+  else
+    return SyMath::Definition::Function.new(name, args: args)
+  end
+end
+
+require 'symath/definition/sin'
+require 'symath/definition/cos'
+require 'symath/definition/tan'
+require 'symath/definition/sec'
+require 'symath/definition/csc'
+require 'symath/definition/cot'
+require 'symath/definition/arcsin'
+require 'symath/definition/arccos'
+require 'symath/definition/arctan'
+require 'symath/definition/arcsec'
+require 'symath/definition/arccsc'
+require 'symath/definition/arccot'
+require 'symath/definition/ln'
+require 'symath/definition/exp'
+require 'symath/definition/abs'
+require 'symath/definition/sqrt'
+require 'symath/definition/fact'
+require 'symath/definition/lmd'

data/lib/symath/definition/grad.rb

@@ -0,0 +1,23 @@
+require 'symath/value'
+require 'symath/definition/operator'
+
+module SyMath
+  class Definition::Grad < Definition::Operator
+    def initialize()
+      # Grad is defined as (dF)#
+      super(:grad, args: [:f], exp: '#(xd(f))')
+    end
+
+    def description()
+      return 'grad(f) - gradient of scalar field f'
+    end
+
+    def to_latex(args)
+      if !args
+        args = @args
+      end
+
+      return "\\nabla #{args[0].to_latex}"
+    end
+  end
+end

data/lib/symath/definition/hodge.rb

@@ -0,0 +1,23 @@
+require 'symath/value'
+require 'symath/definition/operator'
+
+module SyMath
+  class Definition::Hodge < Definition::Operator
+    def initialize()
+      super(:hodge)
+    end
+
+    def description()
+      return 'hodge(f) - hodge star operator'
+    end
+
+    def evaluate_call(c)
+      # Must normalize input, operation depends on factorized vectors
+      return c.args[0].evaluate.normalize.hodge
+    end
+
+    def latex_format()
+      return '\star %s'
+    end
+  end
+end

data/lib/symath/definition/int.rb

@@ -0,0 +1,75 @@
+require 'symath/value'
+require 'symath/definition/operator'
+
+module SyMath
+  class Definition::Int < Definition::Operator
+    def initialize()
+      super(:int)
+    end
+
+    def description()
+      return 'int(f, a, b) - integral of f [from a to b]'
+    end
+    
+    def validate_args(e)
+      a = e.args[1]
+      b = e.args[2]
+
+      if (!a.nil? and b.nil?) or (a.nil? and !b.nil?)
+        raise "A cannot be defined without b and vica versa."
+      end
+    end
+
+    def get_variable(exp)
+      if exp.is_a?(SyMath::Operator) and
+        exp.definition.is_function? and
+        exp.definition.args.length > 0
+        v = exp.definition.args[0]
+      else
+        v = (exp.variables)[0].to_m
+      end
+
+      return v.to_d
+    end
+
+    def evaluate_call(c)
+      exp = c.args[0]
+      var = get_variable(exp)
+      a = c.args[1]
+      b = c.args[2]
+
+      exp = exp.evaluate
+
+      if a.nil?
+        ret = exp.normalize.anti_derivative(var)
+        return ret.nil? ? nil : ret + :C.to_m
+      else
+        int = exp.normalize.anti_derivative(var)
+        # TODO: Setting for evaluating the bounds expression?
+        return op(:bounds, lmd(int, var.undiff), a, b).evaluate
+      end
+    end
+
+    def to_latex(args)
+      if !args
+        args = @args
+      end
+      
+      if args[0].is_sum_exp?
+        exp = "\\left(#{args[0].to_latex}\\right)"
+      else
+        exp = args[0].to_latex
+      end
+
+      var = get_variable(args[0])
+      a = args[1]
+      b = args[2]
+
+      if a.nil?
+        return "\\int #{exp}\\,#{var.to_latex}"
+      else
+        return "\\int_{#{a.to_latex}}^{#{b.to_latex}} #{exp}\\,#{var.to_latex}"
+      end
+    end
+  end
+end

data/lib/symath/definition/laplacian.rb

@@ -0,0 +1,23 @@
+require 'symath/value'
+require 'symath/definition/operator'
+
+module SyMath
+  class Definition::Laplacian < Definition::Operator
+    def initialize()
+      # The laplacian is defined as *d*dF
+      super(:laplacian, args: [:f], exp: 'hodge(xd(hodge(xd(f))))')
+    end
+
+    def description()
+      return 'laplacian(f) - laplacian of function f'
+    end
+
+    def to_latex(args)
+      if !args
+        args = @args
+      end
+
+      return "\\nabla^2 #{args[0].to_latex}"
+    end
+  end
+end

data/lib/symath/definition/lmd.rb

@@ -0,0 +1,97 @@
+require 'symath/value'
+require 'symath/definition/function'
+
+module SyMath
+  class Definition::Lmd < Definition::Function
+    def initialize(exp, *vars)
+      super('', args: vars, exp: exp, define_symbol: false)
+    end
+
+    def description()
+      return "{self.to_s} - Lambda function of expression #{exp}"
+    end
+
+    def compose_with_simplify(exp, vars)
+      vars.each do |v|
+        if !v.is_a?(SyMath::Definition::Variable)
+          raise "Expected variable, got #{v.class.name}"
+        end
+
+        if v.is_d?
+          raise "Var is not allowed to br differential, got #{v}"
+        end
+      end
+
+      # Simplify lmd(f(*args), *args) to f(*args)
+      if !exp.is_a?(SyMath::Operator)
+        return
+      end
+
+      if !exp.definition.is_function?
+        return
+      end
+
+      if exp.arity != vars.length
+        return
+      end
+
+      exp.args.each do |a|
+        if !a.is_a?(SyMath::Definition::Variable)
+          return
+        end
+
+        if a.is_d?
+          return
+        end
+      end
+
+      return exp
+    end
+
+    # Evaluate the operator definition
+    # FIXME: Is it right to evaluate the definition exp?
+    def evaluate()
+      if name == '' and !exp.nil?
+        e = exp.evaluate
+        return lmd(e, self.args)
+      end
+
+      return self
+    end
+
+    # For a lambda function, the call returns a function with a reference
+    # to our own lambda function definition.
+    def call(*args)
+      args = args.map { |a| a.nil? ? a : a.to_m }
+      return SyMath::Operator.new(self, args)
+    end
+
+    def reduce()
+      # FIXME: Reduce if lmd is just a wrapper around a function.
+      return self
+    end
+    
+    def to_s(args = nil)
+      if !args
+        args = @args
+      end
+
+      if args.length > 0
+        arglist = args.map { |a| a.to_s }.join(',')
+      else
+        arglist = "..."
+      end
+
+      return "(#{exp}).(#{arglist})"
+    end
+
+    def latex_format()
+      return "(#{exp}).(%s)"
+    end
+  end
+end
+
+def lmd(exp, *args)
+  # Create a lamda (nameless) function.
+  return SyMath::Definition::Lmd.new(exp, *args)
+end

data/lib/symath/definition/ln.rb

@@ -0,0 +1,45 @@
+require 'symath/definition/function'
+
+module SyMath
+  class Definition::Ln < Definition::Function
+    def initialize()
+      super(:ln)
+
+      @reductions_real = {
+        1.to_m   => 0.to_m,
+        :e.to_m  => 1.to_m,
+        0.to_m   => -:oo.to_m,
+        :oo.to_m => :oo.to_m,
+      }
+
+      @reductions_complex = {
+        1.to_m      => 0.to_m,
+        :e.to_m     => 1.to_m,
+        -1.to_m     => :pi.to_m*:i,
+        -:e.to_m    => 1.to_m + :pi.to_m*:i,
+        :i.to_m     => :pi.to_m*:i/2,
+        :e.to_m*:i  => 1.to_m + :pi.to_m*:i/2,
+        -:i.to_m    => -:pi.to_m*:i/2,
+        -:e.to_m*:i => 1.to_m - :pi.to_m*:i/2,
+      }
+    end
+
+    def description()
+      return 'ln(x) - natural logarithm'
+    end
+
+    def reduce_call(c)
+      arg = c.args[0]
+
+      if SyMath.setting(:complex_arithmetic)
+        return super(c, @reductions_complex)
+      else
+        if arg.is_a?(SyMath::Minus)
+          return :nan.to_m
+        end
+
+        return super(c, @reductions_real)
+      end
+    end
+  end
+end

data/lib/symath/definition/number.rb

@@ -0,0 +1,51 @@
+require 'symath/definition'
+
+module SyMath
+  class Definition::Number < Definition
+    def initialize(name)
+      super(name.to_s, define_symbol: false)
+    end
+
+    def description()
+      return "#{name} - natural number"
+    end
+
+    def value()
+      return self.name.to_s.to_i
+    end
+
+    def is_nan?()
+      return false
+    end
+    
+    def is_finite?()
+      return true
+    end
+
+    def is_positive?()
+      return value() > 0
+    end
+
+    def is_number?()
+      return true
+    end
+
+    def is_zero?()
+      return value() == 0
+    end
+
+    def type()
+      return :natural.to_t
+    end
+  end
+end
+
+class Integer
+  def to_m()
+    if self < 0
+      return SyMath::Definition::Number.new(-self).neg
+    else
+      return SyMath::Definition::Number.new(self)
+    end
+  end
+end