symath 0.1.0

data/lib/symath/definition/operator.rb

@@ -0,0 +1,228 @@
+require 'symath/definition'
+
+module SyMath
+  class Definition::Operator < Definition
+    attr_reader :args
+    attr_reader :exp
+
+    def self.init_builtin()
+      SyMath::Definition::D.new
+      SyMath::Definition::Xd.new
+      SyMath::Definition::Int.new
+      SyMath::Definition::Bounds.new
+      SyMath::Definition::Sharp.new
+      SyMath::Definition::Flat.new
+      SyMath::Definition::Hodge.new
+      SyMath::Definition::Grad.new
+      SyMath::Definition::Curl.new
+      SyMath::Definition::Div.new
+      SyMath::Definition::Laplacian.new
+      SyMath::Definition::CoDiff.new
+
+      expressions = [
+        { :name => 'laplace',
+          :exp  => 'lmd(int(f.(t)*e**(-s*t),d(t),0,oo),s)',
+          :desc => 'laplace transform',
+        },
+        { :name => 'fourier',
+          :exp  => 'lmd(int(f.(x)*e**(-2*pi*i*x*w),d(x),-oo,oo),w)',
+          :desc => 'fourier transform',
+        },
+        { :name => 'invfourier',
+          :exp  => 'lmd(int(f.(w)*e**(2*pi*i*x*w),d(w),-oo,oo),x)',
+          :desc => 'inverse fourier transform',
+        },
+      ]
+
+      expressions.each do |e|
+        self.new(e[:name], args: [:f], exp: e[:exp],
+                 description: "#{e[:name]}(f) - #{e[:desc]}")
+      end
+
+      e = op(:d, lmd(:f, :t))/op(:d, :t)
+      self.new('dpart', args: [:f, :t], exp: e,
+               description: 'dpart - partial derivative')
+    end
+
+    def self.operators()
+      return self.definitions.select do |d|
+        d.is_operator? and !d.is_function?
+      end
+    end
+
+    def initialize(name, args: [], exp: nil, define_symbol: true,
+                   description: nil)
+      if exp and !exp.is_a?(SyMath::Value)
+        exp = exp.to_m
+      end
+
+      @args = args.map { |a| a.to_m }
+      @exp = exp
+
+      super(name, define_symbol: define_symbol, description: description)
+    end
+
+    def compose_with_simplify(*args)
+      return
+    end
+
+    def validate_args(e)
+      return
+    end
+    
+    def arity()
+      return @args.length
+    end
+    
+    def ==(other)
+      if !super(other)
+        return false
+      end
+
+      o = other.to_m
+      return false if self.args.length != o.args.length
+      return false if self.exp != o.exp
+      return false if self.args != o.args
+      return true
+    end
+
+    alias eql? ==
+
+    def <=>(other)
+      s = super(other)
+      return s if s != 0
+
+      if arity != other.arity
+        return arity <=> other.arity
+      end
+
+      (0...arity).to_a.each do |i|
+        diff = args[i] <=> other.args[i]
+        if diff != 0
+          return diff
+        end
+      end
+
+      return 0
+    end
+
+    # The call method, or the .() operator, returns an operator or function
+    # object representing the operator or function being applied to a list of
+    # arguments.
+    def call(*args)
+      return SyMath::Operator.create(name, args.map { |a| a.nil? ? a : a.to_m })
+    end
+
+    def is_operator?()
+      return true
+    end
+
+    # Evaluate the operator in use
+    def evaluate_call(c)
+      if !exp
+        # Operator has no expression, return it unchanged.
+        return c
+      end
+
+      # Operator has expression. Exand it.
+      res = exp.deep_clone
+      if arity != c.arity
+        raise "Cannot evaluate #{name} with #{c.arity} arguments. Expected #{arity}."
+      end
+
+      map = {}
+      args.each_with_index do |a, i|
+        map[a] = c.args[i]
+      end
+      res.replace(map)
+
+      # Recursively evaluate the expanded formula.
+      res = res.evaluate
+      return res
+    end
+
+    def replace(map)
+      # FIXME: We probably need to filter out the local variables before
+      # replacing
+      if !exp.nil?
+        @exp = exp.replace(map)
+      end
+
+      # Replace all arguments
+      @args = @args.map do |a|
+        a.replace(map)
+      end
+
+      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 "#{@name}(#{arglist})"
+    end
+
+    def latex_format()
+      return "\\operatorname{#{name}}(%s)"
+    end
+    
+    def to_latex(args = nil)
+      if !args
+        args = @args
+      end
+      
+      if args.length > 0
+        arglist = args.map { |a| a.to_latex }.join(',')
+      else
+        arglist = "..."
+      end
+
+      return sprintf(latex_format, arglist)
+    end
+
+    def dump(indent = 0)
+      res = super(indent)
+      i = ' '*indent
+      if args
+        arglist = args.map { |a| a.to_s }.join(',')
+        res = "#{res}\n#{i}  args: #{arglist}"
+      end
+      if exp
+        res = "#{res}\n#{i}  exp: #{exp}"
+      end
+    end
+  end
+end
+
+def op(o, *args)
+  return SyMath::Operator.create(o, args.map { |a| a.nil? ? a : a.to_m })
+end
+
+def define_op(name, args, exp = nil)
+  if exp
+    return SyMath::Definition::Operator.new(name, args: args, exp: exp)
+  else
+    return SyMath::Definition::Operator.new(name, args: args)
+  end
+end
+
+require 'symath/definition/d'
+require 'symath/definition/xd'
+require 'symath/definition/int'
+require 'symath/definition/bounds'
+require 'symath/definition/sharp'
+require 'symath/definition/flat'
+require 'symath/definition/hodge'
+require 'symath/definition/grad'
+require 'symath/definition/curl'
+require 'symath/definition/div'
+require 'symath/definition/laplacian'
+require 'symath/definition/codiff'

data/lib/symath/definition/sec.rb

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

data/lib/symath/definition/sharp.rb

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

data/lib/symath/definition/sin.rb

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

data/lib/symath/definition/sqrt.rb

@@ -0,0 +1,62 @@
+require 'symath/definition/function'
+
+module SyMath
+  class Definition::Sqrt < Definition::Function
+    def initialize()
+      super(:sqrt)
+    end
+
+    def description()
+      return 'sqrt(x) - square root'
+    end
+
+    def reduce_call(call)
+      arg = call.args[0]
+      i = 1.to_m
+
+      # Real: sqrt(-n) = NaN
+      # Complex: sqrt(-n) = i*sqrt(n)
+      if arg.is_a?(SyMath::Minus)
+        if SyMath.setting(:complex_arithmetic)
+          i = :i.to_m
+          arg = -arg
+        else
+          return :nan.to_m
+        end
+      end
+
+      if arg.is_number?
+        # sqrt(n*n) = n
+        # sqrt(-n*n) = i*n
+        if (Math.sqrt(arg.value) % 1).zero?
+          return i*Math.sqrt(arg.value).to_i
+        end
+      elsif arg.is_a?(SyMath::Power)
+        # sqrt(n**(2*a)) = n^a
+        # sqrt(-n**(2*a)) = i*n**a
+
+        # Find coefficient of exponent
+        c = 1
+        arg.exponent.factors.each do |ef|
+          if ef.is_number?
+            c *= ef.value
+          end
+        end
+        
+        if c.even?
+          return i*arg.base**(arg.exponent/2)
+        end
+      end
+
+      if i != 1
+        return i*fn(:sqrt, arg)
+      else
+        return call
+      end
+    end
+
+    def to_latex(args = nil)
+      return '\sqrt{'.to_s + args[0].to_latex + '}'.to_s
+    end
+  end
+end

data/lib/symath/definition/tan.rb

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

data/lib/symath/definition/trig.rb

@@ -0,0 +1,95 @@
+require 'symath/definition/function'
+
+module SyMath
+  class Definition::Trig < Definition::Function
+    @@trig_reductions = {}
+  
+    def self.initialize()
+      sqrt3 = fn(:sqrt, 3)
+      sqrt2 = fn(:sqrt, 2)
+
+      @@trig_reductions = {
+        :sin_div6 => [ 0.to_m,   1.to_m/2,     sqrt3/2,
+                       1.to_m,   sqrt3/2,      1.to_m/2,
+                       0.to_m,  -(1.to_m/2),  -(sqrt3/2),
+                       -1.to_m,  -(sqrt3/2),   -(1.to_m/2)],
+      
+        :sin_div4 => [ 0.to_m,   sqrt2/2,
+                       1.to_m,   sqrt2/2,
+                       0.to_m,  -(sqrt2/2),
+                       -1.to_m,  -(sqrt2/2)],
+      
+        :sec_div6 => [ 1.to_m,    2.to_m*sqrt3/3,     2.to_m,
+                       nil,      -2.to_m,            -(2.to_m*sqrt3/2),
+                       -1.to_m,   -(2.to_m*sqrt3/3),  -2.to_m,
+                       nil,       2.to_m,             2.to_m*sqrt3/3],
+      
+        :sec_div4 => [ 1.to_m,   sqrt2/2,
+                       nil,     -(sqrt2/2),
+                       -1.to_m,  -(sqrt2/2),
+                       nil,      sqrt2/2],
+        
+        :tan_div6 => [0.to_m,   sqrt3/3,   sqrt3,
+                      nil,     -sqrt3,    -(sqrt3/3)],
+      
+        :tan_div4 => [0.to_m,   1.to_m,
+                      nil,     -1.to_m],
+      }
+    end
+
+    def reduce_sin_and_cos(f, off)
+      c, dc = check_pi_fraction(f.args[0], false)
+      return f if c.nil?
+
+      # Divisor is divisible by 6
+      if 6 % dc == 0
+        return @@trig_reductions[:sin_div6][(off*3 + c*6/dc) % 12]
+      end
+    
+      # Divisor is divisible by 4
+      if 4 % dc == 0
+        return @@trig_reductions[:sin_div4][(off*2 + c*4/dc) % 8]
+      end
+
+      return f
+    end
+
+    def reduce_tan_and_cot(f, off, sign)
+      c, dc = check_pi_fraction(f.args[0], false)
+      return f if c.nil?
+
+      # Divisor is divisible by 6
+      if 6 % dc == 0
+        ret = @@trig_reductions[:tan_div6][(off*3 + sign*c*6/dc) % 6]
+        return ret.nil? ? f : ret
+      end
+
+      # Divisor is divisible by 4
+      if 4 % dc == 0
+        ret = @@trig_reductions[:tan_div4][(off*2 + sign*c*4/dc) % 4]
+        return ret.nil? ? f : ret
+      end
+
+      return f
+    end
+
+    def reduce_sec_and_csc(f, off)
+      c, dc = check_pi_fraction(f.args[0], false)
+      return f if c.nil?
+    
+      # Divisor is divisible by 6
+      if 6 % dc == 0
+        ret = @@trig_reductions[:sec_div6][(off*3 + c*6/dc) % 12]
+        return ret.nil? ? f : ret
+      end
+    
+      # Divisor is divisible by 4
+      if 4 % dc == 0
+        ret = @@trig_reductions[:sec_div4][(off*2 + c*4/dc) % 8]
+        return ret.nil? ? f : ret
+      end
+    
+      return f
+    end
+  end
+end