symath 0.1.0

data/lib/symath/type.rb

@@ -0,0 +1,282 @@
+module SyMath
+  class Type
+    # Type name
+    attr_reader :name
+    # Matrix dimensions
+    attr_reader :dimn, :dimm
+    # Tensor indexes (array of 'h' amd 'l')
+    attr_reader :indexes
+
+    # Type hierarchy with generic types at the top level and more specific
+    # types further down.
+    @@hierarchy = {
+      # Non numbers
+      :nonfinite => 1,
+      # Operators
+      :operator => {
+        # Linear operators
+        :linop => {
+          # Matrices
+          :matrix => {
+            :column => 1,
+            :row => 1,
+          },
+          # Vector types (one dimension param)
+          :tensor => {
+            :nvector => {
+              :vector => 1,
+            },
+            :nform => {
+              :covector => {
+                :dform => 1,
+              },
+            },
+          },
+          # Scalar types
+          :quaternion => {
+            :scalar => {
+              :complex => {
+                :real => {
+                  :rational => {
+                    :integer => {
+                      :natural => 1
+                    }
+                  }
+                },
+                :imaginary => 1,
+              }
+            }
+          }
+        }
+      }
+    }
+
+    # Create a transitively closed subtype hash for quicker subtype lookup
+    @@subtype = {}
+
+    def self.fill_subtype_hash(hiera, bases = [])
+      hiera.keys.each do |k|
+        bases.each do |b|
+          if !@@subtype.key?(k)
+            @@subtype[k] = {}
+          end
+          @@subtype[k][b] = 1
+        end
+        
+        next unless hiera[k].is_a?(Hash)
+
+        fill_subtype_hash(hiera[k], bases + [k])
+      end
+    end
+
+    fill_subtype_hash(@@hierarchy)
+
+    @@types = {}
+
+    def self.types
+      return @@types
+    end
+
+    def initialize(name, dimn: nil, dimm: nil, indexes: nil)
+      @name = name.to_sym
+      @dimn = dimn
+      @dimm = dimm
+      @indexes = indexes
+    end
+
+    # Hash of simple types, for faster instansiations.
+    @@types = {
+      :natural    => SyMath::Type.new(:natural),
+      :integer    => SyMath::Type.new(:integer),
+      :rational   => SyMath::Type.new(:rational),
+      :real       => SyMath::Type.new(:real),
+      :complex    => SyMath::Type.new(:complex),
+      :imaginary  => SyMath::Type.new(:imaginary),
+      :quaternion => SyMath::Type.new(:quaternion),
+      :vector     => SyMath::Type.new(:vector, indexes: ['u']),
+      :covector   => SyMath::Type.new(:covector, indexes: ['l']),
+      :dform      => SyMath::Type.new(:dform, indexes: ['l']),
+    }
+
+    # Check if a type is a subtype of another
+    def is_subtype?(other)
+      # Allow input as type or as string
+      other = other.to_t
+
+      # Types are not compatible if they have different attributes.
+      # FIXME: What is the correct way to define subtypes of matrices
+      # with respect to dimensions?
+      return false if @dim1 != other.dimn
+      return false if @dim2 != other.dimm
+
+      # Same types, 
+      return true if @name == other.name
+
+      # This is a subtype of other
+      return true if @@subtype.key?(@name) and @@subtype[@name].key?(other.name)
+
+      # Fallback to false
+      return false
+    end
+
+    def common_parent(other)
+      if other.is_subtype?(self)
+        return self
+      elsif is_subtype?(other)
+        return other
+      elsif is_subtype?(@@types[:complex]) and
+           other.is_subtype?(@@types[:complex])
+        return  @@types[:complex]
+      else
+        raise "No common type for #{self} and #{other}"
+      end
+    end
+
+    # Determine the type of a sum
+    def sum(other)
+      if is_subtype?('quaternion') and
+        other.is_subtype?('quaternion')
+        return common_parent(other)
+      elsif self == other
+        return self
+      elsif self.is_subtype?('tensor') or other.is_subtype?('tensor')
+        # FIXME: Hack. This is probably not true. 
+        return self
+      else
+        raise "Types #{self} and #{other} cannot be summed."
+      end
+    end
+
+    # Determine the type of a product
+    def product(other)
+      scalar = is_scalar?
+      oscalar = other.is_scalar?
+      
+      if scalar and oscalar
+        return common_parent(other)
+      elsif scalar
+        return other
+      elsif oscalar
+        return self
+      elsif is_subtype?('matrix') and
+           other.is_subtype?('matrix') and
+           dimn == other.dimm
+        return 'matrix'.to_t(dimm: dimm, dimn: other.dimn)
+      else
+        raise "Types #{self} and #{other} cannot be multiplied"
+      end
+    end
+    
+    # Return tensor degree (rank)
+    def degree()
+      return @indexes.length
+    end
+
+    # True if type is a scalar value 
+    def is_scalar?()
+      return is_subtype?('scalar')
+    end
+
+    def is_vector?()
+      return is_subtype?('vector')
+    end
+
+    # True if type is a linear combination of blades
+    def is_nvector?()
+      return is_subtype?('nvector')
+    end
+
+    def is_matrix?()
+      return ([:matrix, :colum, :row].include?(@name))
+    end
+
+    # True if type is a pseudovector. We use the notion of a pseudovector
+    # both for N-1 dimensional nvectors and nforms (N being the dimensionality
+    # of the default vector space)
+    def is_pseudovector?()
+      if !is_subtype?('nvector') and !is_subtype?('nform')
+        return false
+      end
+
+      return degree == SyMath.get_variable(:basis).ncols - 1
+    end
+
+    # True if type is a pseudoscalar. We use the notion of a pseudoscalar
+    # both for N dimensional nvectors and nforms (N being the dimensionality
+    # of the default vector space)
+    def is_pseudoscalar?()
+      if !is_subtype?('nvector') and !is_subtype?('nform')
+        return false
+      end
+
+      return degree == SyMath.get_variable(:basis).ncols
+    end
+    
+    # True if type is the dual of an nvector
+    def is_nform?()
+      return is_subtype?('nform')
+    end
+
+    # FIXME: What is the difference between a covector and a dform?
+    def is_covector?()
+      return is_subtype?('covector')
+    end
+
+    def is_dform?()
+      return is_subtype?('dform')
+    end
+    
+    # Return index list as a string coded with upper indices as ' and lower
+    # indices as .
+    def index_str()
+      return @indexes.map do |i|
+        if i == 'u'
+          '\''
+        elsif i == 'l'
+          '.'
+        end
+      end.join('')
+    end
+    
+    def ==(other)
+      return false if @dim1 != other.dimn
+      return false if @dim2 != other.dimm
+      return false if @indexes != other.indexes
+      return @name == other.name
+    end
+
+    def to_s()
+      if !@dimn.nil?
+        return @name.to_s + '[' + @dimm.to_s + 'x' + @dimn.to_s + ']'
+      elsif !@indexes.nil?
+        return @name.to_s + '[' + @indexes.join('') + ']'
+      else
+        return @name.to_s
+      end
+    end
+
+    def to_t(*args)
+      return self
+    end
+  end
+end
+
+class String
+  def to_t(**args)
+    if args.empty? and SyMath::Type.types.key?(self.to_sym)
+      return SyMath::Type.types[self.to_sym]
+    end
+
+    return SyMath::Type.new(self, **args)
+  end
+end
+
+class Symbol
+  def to_t(**args)
+    if args.empty? and SyMath::Type.types.key?(self)
+      return SyMath::Type.types[self]
+    end
+
+    return SyMath::Type.new(self, **args)
+  end
+end

data/lib/symath/value.rb

@@ -0,0 +1,372 @@
+require 'symath/operation'
+require 'symath/operation/match'
+require 'symath/operation/normalization'
+require 'symath/operation/distributivelaw'
+require 'symath/operation/differential'
+require 'symath/operation/integration'
+require 'symath/operation/exterior'
+
+module SyMath
+  class Value
+    include Operation::Match
+    include Operation::Normalization
+    include Operation::DistributiveLaw
+    include Operation::Differential
+    include Operation::Integration
+    include Operation::Exterior
+    
+    @@class_order = [
+      'SyMath::Definition::Number',
+      'SyMath::Definition::Constant',
+      'SyMath::Definition::Variable',
+      'SyMath::Definition::Function',
+      'SyMath::Definition::Operator',
+      'SyMath::Definition',
+      'SyMath::Minus',
+      'SyMath::Power',
+      'SyMath::Wedge',
+      'SyMath::Fraction',
+      'SyMath::Product',
+      'SyMath::Sum',
+      'SyMath::Operator',
+    ]
+
+    @@class_order_hash = {}
+
+    @@class_order.each_with_index do |e, i|
+      @@class_order_hash[e] = i
+    end
+
+    def self.create(definition, *args)
+      if !definition.is_a?(SyMath::Value)
+        definition = SyMath::Definition.get(definition)
+      end
+      
+      if SyMath.setting(:compose_with_simplify)
+        return self.compose_with_simplify(definition, *args)
+      else
+        return self.new(definition, *args)
+      end
+    end
+
+    # Compose with simplify. Defaults to composition with no reductions
+    def self.compose_with_simplify(*args)
+      return self.new(*args)
+    end
+    
+    def deep_clone()
+      return Marshal.load(Marshal.dump(self))
+    end
+
+    # Sorting/ordering operator. The ordering is used by the normalization to
+    # order the parts of a sum, product etc.
+    def <=>(other)
+      return @@class_order_hash[self.class.name] <=>
+        @@class_order_hash[other.class.name]
+    end
+
+    def <(other)
+      return (self <=> other) < 0
+    end
+
+    def >(other)
+      return (self <=> other) > 0
+    end
+
+    def <=(other)
+      return (self <=> other) <= 0
+    end
+
+    def >=(other)
+      return (self <=> other) >= 0
+    end
+
+    # Default properties for operators
+    # Note: Returning nil here means neither true or false, but unknown.
+    def is_nan?()
+      return
+    end
+
+    def is_finite?()
+      return
+    end
+
+    def is_positive?()
+      return
+    end
+
+    def is_negative?()
+      if is_nan?
+        return false
+      end
+
+      return (is_positive? == false and is_zero? == false)
+    end
+
+    def is_number?()
+      return false
+    end
+
+    def is_negative_number?()
+      return false
+    end
+    
+    def is_zero?()
+      return
+    end
+
+    def is_divisor_factor?()
+      return false
+    end
+
+    def is_unit_quaternion?()
+      return false
+    end
+
+    # Reduce expression if possible. Defaults to no reduction
+    def reduce()
+      return self
+    end
+
+    # Evaluate expression. Defaults to no evaluation
+    def evaluate()
+      return self
+    end
+
+    ##
+    # Compositional math operator methods. No reductions are performed.
+    ##
+    def add(other)
+      return SyMath::Sum.new(self, other.to_m)
+    end
+
+    def sub(other)
+      return SyMath::Sum.new(self, SyMath::Minus.new(other.to_m))
+    end
+
+    def neg()
+      return SyMath::Minus.new(self)
+    end
+
+    def mul(other)
+      return SyMath::Product.new(self, other.to_m)
+    end
+
+    def div(other)
+      return SyMath::Fraction.new(self, other.to_m)
+    end
+    
+    def power(other)
+      return SyMath::Power.new(self, other.to_m)
+    end
+
+    def wedge(other)
+      return SyMath::Wedge.new(self, other.to_m)
+    end
+
+    ##
+    # Overridden object operators.
+    # These operations do some simple reductions.
+    ##
+    def +(other)
+      return SyMath::Sum.create(self, other)
+    end
+
+    def -(other)
+      return self + (- other)
+    end
+
+    def -@()
+      return SyMath::Minus.create(self)
+    end
+
+    def *(other)
+      return SyMath::Product.create(self, other)
+    end
+
+    def /(other)
+      return SyMath::Fraction.create(self, other)
+    end
+
+    def inv()
+      return 1/self
+    end
+    
+    def **(other)
+      return SyMath::Power.create(self, other)
+    end
+
+    def ^(other)
+      # Identical with *. We apply * or ^ depending on what
+      # the arguments are.
+      return self*other
+    end
+
+    ##
+    # Helper methods for the normalization operation. These are overridden by
+    # the subclasses. Default behaviour is defined here.
+    ##
+
+    # Value is a sum or unitary minus
+    def is_sum_exp?()
+      return false
+    end
+
+    # Value is a product, fraction or unitary minus
+    def is_prod_exp?()
+      return false
+    end
+
+    # Returns the terms of a sum in an array.
+    # Defaults to self for non-sums.
+    def terms()
+      return [self]
+    end
+
+    # Returns the base of a power expression.
+    # Defaults to self for non-powers.
+    def base()
+      return self
+    end
+
+    # Returns the exponent of a power expression.
+    # Defaults to self for non-powers.
+    def exponent()
+      return 1.to_m
+    end
+    
+    # Return factors in enumerator
+    def factors()
+      return [self].to_enum
+    end
+
+    # Returns the accumulated sign of a product.
+    # Defaults to 1 for positive non-sum expressions.
+    def sign()
+      return 1
+    end
+
+    # Simple reduction rules, allows sign to change. Returns
+    # (reduced exp, sign, changed). Defaults to no change
+    def reduce_modulo_sign
+      return self, 1, false
+    end
+
+    # By default, assume an unknown expression to be scalar
+    def type()
+      return 'scalar'.to_t
+    end
+
+    alias eql? ==
+
+    def to_m()
+      return self
+    end
+
+    def inspect()
+      if SyMath.setting(:inspect_to_s)
+        return self.to_s
+      else
+        return super.inspect
+      end
+    end
+
+    def dump(indent = 0)
+      i = ' '*indent
+      return "#{i}#{self.class}: #{self}"
+    end
+  end
+end
+
+class Integer
+  alias_method :super_add, :+
+  alias_method :super_sub, :-
+  alias_method :super_mul, :*
+  alias_method :super_div, :/
+  alias_method :super_pow, :**
+  alias_method :super_wedge, :^
+  
+  def +(other)
+    if other.class.method_defined?(:to_m) and !other.is_a?(Integer)
+      return self.to_m + other.to_m
+    else
+      return self.super_add(other)
+    end
+  end
+
+  def -(other)
+    if other.class.method_defined?(:to_m) and !other.is_a?(Integer)
+      return self.to_m - other.to_m
+    else
+      return self.super_sub(other)
+    end
+  end
+
+  def *(other)
+    if other.class.method_defined?(:to_m) and !other.is_a?(Integer)
+      return self.to_m*other.to_m
+    else
+      return self.super_mul(other)
+    end
+  end
+
+  def /(other)
+    if other.class.method_defined?(:to_m) and !other.is_a?(Integer)
+      return self.to_m/other.to_m
+    else
+      return self.super_div(other)
+    end
+  end
+
+  def **(other)
+    if other.class.method_defined?(:to_m)  and !other.is_a?(Integer)
+      return self.to_m**other.to_m
+    else
+      return self.super_pow(other)
+    end
+  end
+
+  def ^(other)
+    if other.class.method_defined?(:to_m)  and !other.is_a?(Integer)
+      return self.to_m^other.to_m
+    else
+      return self.super_wedge(other)
+    end
+  end
+end
+
+class Symbol
+  def +(other)
+    return self.to_m + other.to_m
+  end
+
+  def -(other)
+    return self.to_m - other.to_m
+  end
+
+  def -@()
+    return - self.to_m
+  end
+
+  def *(other)
+    return self.to_m*other.to_m
+  end
+
+  def /(other)
+    return self.to_m/other.to_m
+  end
+
+  def **(other)
+    return self.to_m**other.to_m
+  end
+
+  def ^(other)
+    return self.to_m^other.to_m
+  end
+end
+
+class String
+  def to_m()
+    return SyMath.parse(self)
+  end
+end

data/lib/symath/version.rb

@@ -0,0 +1,3 @@
+module SyMath
+  VERSION = "0.1.0"
+end

data/lib/symath/wedge.rb

@@ -0,0 +1,48 @@
+require 'symath/product'
+
+module SyMath
+  class Wedge < Product
+    def initialize(arg1, arg2)
+      super(arg1, arg2)
+      @name = '^'
+    end
+
+    def type()
+      if factor1.type.is_subtype?('tensor') and
+         factor2.type.is_subtype?('tensor')
+        # Wedge product of two tensor-like object. Determine index signature
+        # and subtype.
+        indexes = factor1.type.indexes + factor2.type.indexes
+        if (indexes - ['u']).empty?
+          type = 'nvector'
+        elsif (indexes - ['l']).empty?
+          type = 'nform'
+        else
+          type = 'tensor'
+        end
+        
+        return type.to_t(indexes: indexes)
+      else
+        return factor1.type.sum(factor2.type)
+      end
+    end
+
+    def to_s()
+      if SyMath.setting(:expl_parentheses)
+        return '('.to_s + factor1.to_s + '^' + factor2.to_s + ')'.to_s
+      else
+        return @args.map do |a|
+          if a.is_sum_exp?
+            '(' + a.to_s + ')'
+          else
+            a.to_s
+          end
+        end.join('^')
+      end
+    end
+
+    def to_latex()
+      return @args.map { |a| a.to_latex }.join('\wedge')
+    end
+  end
+end