symath 0.1.0

data/lib/symath/definition/arccos.rb

@@ -0,0 +1,25 @@
+require 'symath/definition/function'
+
+module SyMath
+  class Definition::Arccos < Definition::Function
+    def initialize()
+      super(:arccos)
+
+      @reductions = {
+        -1.to_m         => :pi,
+        -fn(:sqrt, 3)/2 => 5*:pi/6,
+        -fn(:sqrt, 2)/2 => 3*:pi/4,
+        -1.to_m/2       => 2*:pi/3,
+        0.to_m          => :pi/2,
+        1.to_m/2        => :pi/3,
+        fn(:sqrt, 2)/2  => :pi/4,
+        fn(:sqrt, 3)/2  => :pi/6,
+        1.to_m          => 0.to_m,
+      }
+    end
+
+    def description()
+      return 'arccos(x) - inverse trigonometric cosine'
+    end
+  end
+end

data/lib/symath/definition/arccot.rb

@@ -0,0 +1,23 @@
+require 'symath/definition/function'
+
+module SyMath
+  class Definition::Arccot < Definition::Function
+    def initialize()
+      super(:arccot)
+
+      @reductions = {
+        -fn(:sqrt, 3)   => 5*:pi/6,
+        -1.to_m         => 3*:pi/4,
+        -fn(:sqrt, 3)/3 => 2*:pi/3,
+        0.to_m          => :pi/2,
+        fn(:sqrt, 3)/3  => :pi/3,
+        1.to_m          => :pi/4,
+        fn(:sqrt, 3)    => :pi/6,
+      }
+    end
+
+    def description()
+      return 'arccot(x) - inverse trigonometric cotangent'
+    end
+  end
+end

data/lib/symath/definition/arccsc.rb

@@ -0,0 +1,24 @@
+require 'symath/definition/function'
+
+module SyMath
+  class Definition::Arccsc < Definition::Function
+    def initialize()
+      super(:arccsc)
+
+      @reductions = {
+        -2.to_m           => -:pi/6,
+        -fn(:sqrt, 2)     => -:pi/4,
+        -2*fn(:sqrt, 3)/3 => -:pi/3,
+        -1.to_m           => -:pi/2,
+        1.to_m            => :pi/2,
+        2*fn(:sqrt, 3)/3  => :pi/3,
+        fn(:sqrt, 2)      => :pi/4,
+        2.to_m            => :pi/6,
+      }
+    end
+
+    def description()
+      return 'arccsc(x) - inverse trigonometric cosecant'
+    end
+  end
+end

data/lib/symath/definition/arcsec.rb

@@ -0,0 +1,24 @@
+require 'symath/definition/function'
+
+module SyMath
+  class Definition::Arcsec < Definition::Function
+    def initialize()
+      super(:arcsec)
+
+      @reductions = {
+        -2.to_m           => 2*:pi/3,
+        -fn(:sqrt, 2)     => 3*:pi/4,
+        -2*fn(:sqrt, 3)/3 => 5*:pi/6,
+        -1.to_m           => :pi,
+        1.to_m            => 0.to_m,
+        2*fn(:sqrt, 3)/3  => :pi/6,
+        fn(:sqrt, 2)      => :pi/4,
+        2.to_m            => :pi/3
+      }
+    end
+
+    def description()
+      return 'arcsec(x) - inverse trigonometric secant'
+    end
+  end
+end

data/lib/symath/definition/arcsin.rb

@@ -0,0 +1,25 @@
+require 'symath/definition/function'
+
+module SyMath
+  class Definition::Arcsin < Definition::Function
+    def initialize()
+      super(:arcsin)
+
+      @reductions = {
+        -1.to_m         => -:pi/2,
+        -fn(:sqrt, 3)/2 => -:pi/3,
+        -fn(:sqrt, 2)/2 => -:pi/4,
+        -1.to_m/2       => -:pi/6,
+        0.to_m          => 0.to_m,
+        1.to_m/2        => :pi/6,
+        fn(:sqrt, 2)/2  => :pi/4,
+        fn(:sqrt, 3)/2  => :pi/3,
+        1.to_m          => :pi/2,
+      }
+    end
+
+    def description()
+      return 'arcsin(x) - inverse trigonometric sine'
+    end
+  end
+end

data/lib/symath/definition/arctan.rb

@@ -0,0 +1,23 @@
+require 'symath/definition/function'
+
+module SyMath
+  class Definition::Arctan < Definition::Function
+    def initialize()
+      super(:arctan)
+
+      @reductions = {
+        -fn(:sqrt, 3)   => -:pi/3,
+        -1.to_m         => -:pi/4,
+        -fn(:sqrt, 3)/3 => -:pi/6,
+        0.to_m          => 0.to_m,
+        fn(:sqrt, 3)/3  => :pi/6,
+        1.to_m          => :pi/4,
+        fn(:sqrt, 3)    => :pi/3,
+      }
+    end
+
+    def description()
+      return 'arctan(x) - inverse trigonometric tangent'
+    end
+  end
+end

data/lib/symath/definition/bounds.rb

@@ -0,0 +1,39 @@
+require 'symath/value'
+require 'symath/definition/operator'
+
+module SyMath
+  class Definition::Bounds < Definition::Operator
+    def initialize()
+      super(:bounds, args: [:f, :a, :b],
+            exp: :f.to_m.(:b) - :f.to_m.(:a))
+    end
+
+    def description()
+      return 'bounds(ex, x, a, b) - bounds operator, (ex)[x=b] - (ex)[x=a]'
+    end
+
+    def to_s(args = nil)
+      if !args
+        args = @args
+      end
+
+      exp = args[0]
+      a = args[2]
+      b = args[3]
+
+      return "[#{exp}](#{a},#{b})"
+    end
+
+    def to_latex(args = nil)
+      if !args
+        args = @args
+      end
+
+      exp = args[0].to_latex
+      a = args[2].to_latex
+      b = args[3].to_latex
+
+      return "\\left[#{exp}\\right]^{#{b}}_{#{a}}"
+    end
+  end
+end

data/lib/symath/definition/codiff.rb

@@ -0,0 +1,31 @@
+require 'symath/value'
+require 'symath/definition/operator'
+
+module SyMath
+  class Definition::CoDiff < Definition::Operator
+    def initialize()
+      # The co-differential is defined as: (-1)**(n*k+ 1)*d*(F).
+      # n : Dimension of the basis vector space
+      # k : Grade of input function F
+      # (the sign is calculated by the overridden evaluate method)
+      super(:codiff, args: [:f], exp: 'hodge(xd(hodge(f)))')
+    end
+
+    def description()
+      return 'codiff(f) - codifferential of function f'
+    end
+
+    def evaluate_call(c)
+      vars = SyMath.get_variable(:basis.to_m).row(0)
+      n = vars.length
+      k = c.args[0].type.degree
+      sign = ((-1)**(n*k + 1)).to_m
+
+      return sign*super(c)
+    end
+
+    def latex_format()
+      return '\delta %s'
+    end
+  end
+end

data/lib/symath/definition/constant.rb

@@ -0,0 +1,111 @@
+require 'symath/definition'
+require 'set'
+
+module SyMath
+  class Definition::Constant < Definition
+    @@ltx_symbol = {
+      :pi  => '\pi',
+      :e   => '\mathrm{e}',
+      :phi => '\varphi',
+      :nan => '\mathrm{NaN}',
+      :oo  => '\infty',
+    };
+
+    @@descriptions = {
+      :pi  => 'ratio of cirle cirumference/diameter (3.14159265...)',
+      :e   => 'eulers number (2.71828182...)',
+      :phi => 'golden ratio (1.61803398...)',
+      :nan => "'not a number', i.e. an invalid value",
+      :oo  => 'positive infinity',
+      :i   => 'imaginary unit, first basic quaternion',
+      :j   => 'second basic quaternion',
+      :k   => 'third basic quaternion',
+    }
+
+    @@unit_quaternions = [:i, :j, :k].to_set
+
+    def self.init_builtin()
+      # Define the builtin constants
+      self.new(:pi)
+      self.new(:e)
+      self.new(:phi)
+      self.new(:nan)
+      self.new(:oo)
+      self.new(:i)
+      self.new(:j)
+      self.new(:k)
+    end
+
+    def self.constants()
+      return self.definitions.grep(SyMath::Definition::Constant)
+    end
+
+    def description()
+      return "#{@name} - #{@@descriptions[@name]}"
+    end
+
+    def is_nan?()
+      return @name == :nan
+    end
+
+    def is_finite?()
+      return (@name != :oo and @name != :nan)
+    end
+
+    def is_positive?()
+      return (!is_zero? and !is_nan?)
+    end
+    
+    def is_zero?()
+      return false
+    end
+
+    def is_unit_quaternion?()
+      return @@unit_quaternions.member?(@name)
+    end
+
+    def calc_unit_quaternions(q)
+      # Calculation map for unit quaternions
+      qmap = {
+        :i => {
+          :i => -1.to_m,
+          :j => :k.to_m,
+          :k => -:j.to_m,
+        },
+        :j => {
+          :i => -:k.to_m,
+          :j => -1.to_m,
+          :k => :i.to_m,
+        },
+        :k => {
+          :i => :j.to_m,
+          :j => -:i.to_m,
+          :k => -1.to_m,
+        },
+      }
+    
+      return qmap[@name][q.name]
+    end
+
+    def type()
+      n = @name
+      if n == :e or n == :pi or n == :phi
+        return 'real'.to_t
+      elsif n == :i
+        return 'imaginary'.to_t
+      elsif is_unit_quaternion?
+        return 'quaternion'.to_t
+      else
+        return 'nonfinite'.to_t
+      end
+    end
+
+    def to_latex()
+      if @@ltx_symbol.key?(@name)
+        return @@ltx_symbol[@name]
+      else
+        return @name.to_s
+      end
+    end
+  end
+end

data/lib/symath/definition/cos.rb

@@ -0,0 +1,17 @@
+require 'symath/definition/trig'
+
+module SyMath
+  class Definition::Cos < Definition::Trig
+    def initialize()
+      super(:cos)
+    end
+    
+    def description()
+      return "cos(x) - trigonometric cosine"
+    end
+
+    def reduce_call(c)
+      return reduce_sin_and_cos(c, 1)
+    end
+  end
+end

data/lib/symath/definition/cot.rb

@@ -0,0 +1,17 @@
+require 'symath/definition/trig'
+
+module SyMath
+  class Definition::Cot < Definition::Trig
+    def initialize()
+      super(:cot)
+    end
+    
+    def description()
+      return 'cot(x) - trigonometric cotangent'
+    end
+
+    def reduce_call(c)
+      return reduce_tan_and_cot(c, 1, -1)
+    end
+  end
+end

data/lib/symath/definition/csc.rb

@@ -0,0 +1,17 @@
+require 'symath/definition/trig'
+
+module SyMath
+  class Definition::Csc < Definition::Trig
+    def initialize()
+      super(:csc)
+    end
+    
+    def description()
+      return 'csc(x) - trigonometric cosecant'
+    end
+
+    def reduce_call(c)
+      return reduce_sec_and_csc(c, 0)
+    end
+  end
+end

data/lib/symath/definition/curl.rb

@@ -0,0 +1,27 @@
+require 'symath/value'
+require 'symath/definition/operator'
+
+module SyMath
+  class Definition::Curl < Definition::Operator
+    def initialize()
+      # Curl is defined as (*(d(Fb)))#
+      super(:curl, args: [:f], exp: '#(hodge(xd(b(f))))')
+    end
+
+    def description()
+      return 'curl(f) - curl of vector field f'
+    end
+
+    def evaluate_call(c)
+      if SyMath.get_variable(:basis.to_m).row(0).length != 3
+        raise 'Curl is only defined for 3 dimensions'
+      end
+
+      return super(c)
+    end
+
+    def latex_format()
+      return '\nabla\times %s'
+    end
+  end
+end

data/lib/symath/definition/d.rb

@@ -0,0 +1,62 @@
+require 'symath/value'
+require 'symath/definition/operator'
+require 'symath/definition/function'
+
+module SyMath
+  class Definition::D < Definition::Operator
+    def initialize()
+      super(:d)
+    end
+
+    def description()
+      return 'd(f) - differential of f with respect to its input variables'
+    end
+    
+    def validate_args(e)
+      # Arguments 1, 2, ... are supposed to be variables to differentiate
+      # over.
+      e.args[1..-1].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 be differential, got #{v}"
+        end
+      end
+    end
+
+    def compose_with_simplify(name, args)
+      exp = args[0]
+      vars = args[1..-1]
+
+      if exp.is_a?(SyMath::Definition::Variable) and
+        exp.type.is_scalar? and
+        vars.length == 0
+        return exp.to_d
+      end
+
+      return
+    end
+
+    def evaluate_call(c)
+      e = c.args[0]
+
+      # If argument is a function, differentiate on all function
+      # arguments.
+      if e.is_a?(SyMath::Definition::Function)
+        vars = e.args
+      else
+        # Find first free variable in expression.
+        vars = [(e.variables)[0].to_m]
+        e = lmd(e, *vars)
+      end
+
+      return lmd(e.d(vars), *vars)
+    end
+
+    def latex_format()
+      return '\mathrm{d}(%s)'
+    end
+  end
+end

data/lib/symath/definition/div.rb

@@ -0,0 +1,27 @@
+require 'symath/value'
+require 'symath/definition/operator'
+
+module SyMath
+  class Definition::Div < Definition::Operator
+    def initialize()
+      # Div is defined as *d*(Fb)
+      super(:div, args: [:f], exp: 'hodge(xd(hodge(b(f))))')
+    end
+
+    def description()
+      return 'div(f) - divergence of vector field f'
+    end
+
+    def evaluate_call(c)
+      if SyMath.get_variable(:basis.to_m).row(0).length != 3
+        raise 'Div is only defined for 3 dimensions'
+      end
+
+      super(c)
+    end
+
+    def latex_format()
+      return '\nabla\cdot %s'
+    end
+  end
+end

data/lib/symath/definition/exp.rb

@@ -0,0 +1,112 @@
+require 'symath/definition/function'
+
+module SyMath
+  class Definition::Exp < Definition::Function
+    def initialize()
+      super(:exp)
+    end
+
+    def description()
+      return 'exp(x) - exponential function (e**x)'
+    end
+
+    def reduce_call(call)
+      arg = call.args[0]
+      
+      if arg.is_nan?
+        return :nan.to_m
+      end
+
+      if arg == 0
+        return 1.to_m
+     elsif arg == 1
+        return :e.to_m
+      end
+
+      if arg.is_finite? == false
+        if SyMath.setting(:complex_arithmetic)
+          return :nan.to_m
+        else
+          if arg.is_positive? == true
+            return :oo.to_m
+          else
+            return 0.to_m
+          end
+        end
+      end
+
+      if SyMath.setting(:complex_arithmetic)
+        ret = 1.to_m
+      
+        arg.terms.each do |t|
+          if t.is_a?(SyMath::Minus)
+            t = t.args[0]
+            minus = true
+          else
+            minus = false
+          end
+
+          if t.class.method_defined?('definition') and
+            t.definition.is_a?(SyMath::Definition::Ln)
+            # exp(ln(c)) = c
+            t2 = t.args[0]
+          else
+            # Euler's formula
+            c, dc = check_pi_fraction(t, true)
+            if !c.nil?
+              if dc == 1
+                c *= 2
+              elsif dc != 2
+                # Not reducible
+                return call
+              end
+
+              case c % 4
+              when 0
+                t2 = 1
+              when 1
+                t2 = :i
+              when 2
+                t2 = -1
+              when 3
+                t2 = -:i
+              end
+            else
+              # Cannot reduce
+              return call
+            end
+          end
+
+          ret = minus ? ret/t2 : ret*t2
+        end
+
+        return ret
+      else
+        ret = 1.to_m
+
+        call.args[0].terms.each do |t|
+          if t.is_a?(SyMath::Minus)
+            t = t.args[0]
+            minus = true
+          else
+            minus = false
+          end
+
+          # exp(ln(c)) = c for positive c
+          if t.class.method_defined?('definition') and
+            t.definition.is_a?(SyMath::Definition::Ln)
+            if t.args[0].is_number?
+              ret = minus ? ret/t.args[0] : ret*t.args[0]
+              next
+            end
+          end
+
+          # Cannot reduce
+          return call
+        end
+
+        return ret
+      end
+    end
+  end
+end

data/lib/symath/definition/fact.rb

@@ -0,0 +1,55 @@
+require 'symath/definition/function'
+
+module SyMath
+  class Definition::Fact < Definition::Function
+    def initialize()
+      super(:fact)
+    end
+
+    def description()
+      return 'fact(x) - factorial'
+    end
+
+    def reduce_call(c)
+      arg = c.args[0]
+      
+      if arg.is_number?
+        if arg.value <= SyMath.setting(:max_calculated_factorial)
+          return (2..arg.value).reduce(1, :*).to_m
+        end
+      end
+
+      return c
+    end
+
+    def to_s(args = nil)
+      if args
+        if args[0].is_a?(SyMath::Definition::Variable) or
+          args[0].is_a?(SyMath::Definition::Constant)
+          arg = args[0].to_s
+        else
+          arg = "(#{args[0].to_s})"
+        end
+      else
+        arg = '(...)'
+      end
+
+      return "#{arg}!"
+    end
+
+    def to_latex(args = nil)
+      if args
+        if args[0].is_a?(SyMath::Definition::Variable) or
+          args[0].is_a?(SyMath::Definition::Constant)
+          arg = args[0].to_latex
+        else
+          arg = "(#{args[0].to_latex})"
+        end
+      else
+        arg = '(...)'
+      end
+      
+      return "#{arg}!"
+    end
+  end
+end