algebra 0.2.1

data/lib/algebra/algebraic-parser.rb

@@ -0,0 +1,160 @@
+# Algebraic Parser
+#
+#   by Shin-ichiro Hara
+#
+# Version 1.1 (2001.04.08)
+
+require 'algebra/numeric-supplement'
+
+module Algebra
+  class AlgebraicParser
+    def self.eval(str, klass) # , coeff = Numeric)
+      new(str, klass).compile
+    end
+
+    Var = '[a-zA-Z]\d*'.freeze
+    Num = '\d+(?:\.\d*)?'.freeze
+    Op = '(?:\*\*|[+\-*\/^])'.freeze
+    Gr = '[\(\)]'.freeze
+    Dlm = ';'.freeze
+
+    def initialize(str, klass)
+      @klass = klass
+      @coeff = klass.ground
+      @s = str.gsub(/\s+/, '').scan(/#{Dlm}|#{Num}|#{Op}|#{Gr}|#{Var}|.+/o)
+      @basis = [] # stack for the basis of the power
+    end
+
+    def compile
+      sentence
+    end
+
+    private
+
+    def head
+      @s[0]
+    end
+
+    def succ(x = nil)
+      raise "Error: receive #{x} expect #{head}" if x && x != head
+      @s.shift
+    end
+
+    def sentence
+      e = expr
+      while /^#{Dlm}$/ =~ head
+        succ(';')
+        e = expr
+      end
+      e
+    end
+
+    def expr
+      e = expr1
+      while /^[+-]$/ =~ head
+        case succ
+        when '+'
+          e += expr1
+        when '-'
+          e -= expr1
+        end
+      end
+      e
+    end
+
+    def expr1
+      case head
+      when '+' then succ; term
+      when '-' then succ; - term
+      else term
+      end
+    end
+
+    def term
+      e = sequence
+      while /^[*\/]$/ =~ head # /
+        case succ
+        when '*'
+          e *= sequence
+        when '/'
+          e /= sequence
+        end
+      end
+      e
+    end
+
+    def sequence
+      e = power
+      e *= power while head && head !~ /^#{Dlm}$|^#{Op}$|^#{Gr}$/o
+      e
+    end
+
+    def power
+      @basis.push(k = factor)
+      n = 0
+      while /^(?:\*\*)$|^\^$/ =~ head
+        succ
+        @basis.push(factor)
+        n += 1
+      end
+      f = @basis.pop
+      while n > 0
+        f = @basis.pop**f
+        n -= 1
+      end
+      f
+    end
+
+    def factor
+      case head
+      when '(' then succ; e = sentence; succ(')'); e
+      when /^#{Num}$/o
+        @basis.empty? ? @coeff.indeterminate(succ) : eval(succ)
+      when /^#{Var}$/o then @klass.indeterminate(succ)
+      else
+        raise "unknown token '#{head}'"
+      end
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  class A
+    def self.indeterminate(str)
+      case str
+      when 'x' then 7
+      when 'y' then 11
+      when /\d+/ then eval($&)
+      else
+        raise
+      end
+    end
+
+    def self.ground
+      Fixnum
+    end
+  end
+
+  p AlgebraicParser.eval('x * y - x^2 + x/8', A) #=> 7*11 - 7**2 + 7/8 = 28
+
+  require 'algebra/rational'
+
+  class B < A
+    def self.indeterminate(str)
+      case str
+      when /\d+/ then Rational(eval($&))
+      else
+        super
+      end
+    end
+  end
+  puts AlgebraicParser.eval('x * y - x^2 + x/8', B)
+  #=> 7*11 - 7**2 + 7/8 = 231/8
+  p AlgebraicParser.eval('2^(-8+4-2+(3-1)^3)^2', Integer) #=> 16
+
+  require 'algebra/m-polynomial'
+  F = MPolynomial(Rational)
+  p AlgebraicParser.eval('- (2*y)**3 + x', F) #=> -8y^3 + x
+  F.variables.clear
+  p AlgebraicParser.eval('x; y; - (2*y)**3 + x', F) #=> x - 8y^3
+end

data/lib/algebra/algebraic-system.rb

@@ -0,0 +1,224 @@
+# Algebraic System Library
+#
+#   by Shin-ichiro Hara
+#
+# Version 1.1 (2001.04.20)
+
+require 'algebra/numeric-supplement'
+require 'algebra/auto-require'
+
+module Algebra
+  module AlgebraCreator
+    def create(ground)
+      klass = Class.new(self)
+      klass.sysvar :ground, ground
+      def klass.inspect
+        to_s
+      end
+
+      def klass.to_s
+        s = super
+        s = "(#{superclass.inspect}/#{ground.inspect})" if s =~ /^#/ # /
+        s.gsub(/Algebra::/, '')
+      end
+      klass
+    end
+
+    # Needed in the type conversion of MatrixAlgebra
+    def wedge(otype) # =:= tensor
+      if superior?(otype)
+        self
+      elsif otype.respond_to?(:superior?) && otype.superior?(self)
+        otype
+      else
+        raise "wedge: unknown pair (#{self}) .wedge (#{otype})"
+      end
+    end
+
+    def superior?(otype)
+      if otype <= Numeric || self <= otype
+        true
+      elsif respond_to?(:ground) && ground.respond_to?(:superior?)
+        ground.superior?(otype)
+      else
+        false
+      end
+    end
+
+    def sysvar(var_name, value = nil, sw = false)
+      var_name = var_name.id2name if var_name.is_a?(Symbol)
+
+      class_eval <<__END_OF_CLASS_DEFINITION__
+      @@#{var_name} = nil
+      def self.#{var_name}; @@#{var_name}; end
+      def self.#{var_name}=(value); @@#{var_name} = value; end
+__END_OF_CLASS_DEFINITION__
+
+      send(var_name + '=', value) if value
+
+      if sw
+        class_eval <<__END_OF_CLASS_DEFINITION__
+        def #{var_name}; @@#{var_name}; end
+        def #{var_name}=(value); @@#{var_name} = value; end
+__END_OF_CLASS_DEFINITION__
+      end
+    end
+  end
+
+  module AlgebraBase
+    def zero
+      self.class.zero
+    end
+
+    def unity
+      self.class.unity
+    end
+
+    def zero?
+      zero == self
+    end
+
+    def unit?
+      unity == self || -unity == self
+    end
+
+    def unity?
+      unity == self
+    end
+
+    def ground
+      self.class.ground
+    end
+
+    def ground=(bf)
+      self.class.ground = bf
+    end
+
+    def devide?(other)
+      if self.class.field?
+        true
+      elsif self.class.euclidian?
+        _q, r = other.divmod(self)
+        r.zero?
+      else
+        raise "don't konw #{self} divides #{other}"
+      end
+    end
+
+    def regulate(x)
+      self.class.regulate(x)
+    end
+    #  private :regulate
+
+    def self.append_features(klass)
+      def klass.field?
+        !method_defined?(:divmod) # may be overwrited
+      end
+
+      def klass.euclidian?
+        method_defined?(:divmod) #  may be overwrited
+      end
+
+      def klass.ufd?
+        euclidian? #  may be overwrited
+      end
+
+      def klass.zero
+        new(ground.zero)
+      end
+
+      def klass.unity
+        new(ground.unity)
+      end
+
+      def klass.regulate(x)
+        if x.is_a? self
+          x
+        elsif y = ground.regulate(x)
+          new(y)
+                end
+      end
+      super
+    end
+
+    # Operations
+    def +@
+      self
+    end
+
+    def -@
+      zero - self
+    end
+
+    def ==(other)
+      if o = regulate(other)
+        yield o
+      else
+        x, y = other.coerce(self)
+        x == y
+      end
+    end
+
+    def +(other)
+      if o = regulate(other)
+        yield o
+      else
+        x, y = other.coerce(self)
+        x + y
+      end
+    end
+
+    def -(other)
+      if o = regulate(other)
+        yield o
+      else
+        x, y = other.coerce(self)
+        x - y
+      end
+    end
+
+    def *(other)
+      if o = regulate(other)
+        yield o
+      else
+        x, y = other.coerce(self)
+        x * y
+      end
+    end
+
+    def /(other)
+      if o = regulate(other)
+        yield o
+      else
+        x, y = other.coerce(self)
+        x / y
+      end
+    end
+
+    def **(n)
+      if !n.is_a?(Integer) || n < 0
+        raise 'index must be non negative integer'
+      elsif n == 0
+        return unity
+      elsif n == 1
+        self
+      else
+        q, r = n.divmod 2
+        x = self**q
+        x *= x
+        x *= self if r > 0
+        x
+      end
+    end
+
+    alias ^ **
+
+    def coerce(other)
+      if x = regulate(other)
+        [x, self]
+      else
+        raise "(ALG.SYS) can't coerce: (#{self.class}).coerce(#{other.class}) : (#{self}).coerce(#{other})"
+      end
+    end
+  end
+end

data/lib/algebra/annihilate.rb

@@ -0,0 +1,52 @@
+require 'algebra/m-polynomial'
+require 'algebra/groebner-basis'
+
+module Algebra
+  class MPolynomial
+    def lcm(other)
+      vars0 = vars
+      mp = MPolynomial.create(ground)
+      mp.vars('t', *vars)
+      t = mp.vars.first
+      mpvars = mp.vars
+      f = project0(mp) do |c, ind|
+        c * index_eval(mp, mpvars, [0] + ind.to_a)
+      end
+      g = other.project0(mp) do |c, ind|
+        c * index_eval(mp, mpvars, [0] + ind.to_a)
+      end
+      gb = Groebner.basis([t * f, (1 - t) * g])
+      lcm0 = gb.last
+      lcm0.project0(self.class) do |c, ind|
+        c * index_eval(self.class, vars0, ind.empty? ? [] : ind[1..-1])
+      end
+    end
+
+    def gcd(other)
+      (self * other).divmod(lcm(other)).first.first
+    end
+
+    def gcd_all(*a)
+      t = self
+      a.each do |x|
+        break if t.constant?
+        t = t.gcd(x)
+      end
+      t
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  require 'algebra/residue-class-ring'
+  include Algebra
+  Z7 = ResidueClassRing(Integer, 7)
+  P = MPolynomial(Z7)
+  x, y, z = P.vars('xyz')
+
+  f = (x + y) * (x + 2 * y)
+  g = (x + 2 * y) * (x + 3 * y)
+  #  f, g  = x**2*y, x*y**2
+  p f.lcm(g)
+  p f.gcd(g)
+end

data/lib/algebra/array-supplement.rb

@@ -0,0 +1,53 @@
+# Array Supplements
+#
+#   by Shin-ichiro Hara
+#
+# Version 1.2 (2001.07.23)
+
+class Array
+  def each_pair
+    each_with_index do |x, i|
+      (i + 1).upto(size - 1) do |j|
+        y = self[j]
+        yield(x, y)
+      end
+    end
+  end
+
+  def each_pair_with_index
+    each_with_index do |x, i|
+      (i + 1).upto(size - 1) do |j|
+        y = self[j]
+        yield(x, y, i, j)
+      end
+    end
+  end
+
+  def rsort!
+    sort!
+    reverse!
+    self
+  end
+
+  def rsort
+    s = sort
+    s.reverse!
+    s
+  end
+
+  def inner_product(other)
+    sum = 0
+    each_with_index do |x, i|
+      sum += x * other[i]
+    end
+    sum
+  end
+
+  def sumation
+    sum = 0
+    each do |x|
+      sum += x
+    end
+    sum
+  end
+end