algebra 0.2.1

data/lib/algebra/auto-require.rb

@@ -0,0 +1,84 @@
+## AUTO Require LIBRARY
+##  by Shin-ichiro HARA
+##
+##  version 1.21 (2002.04.22)
+##
+
+class Module
+  def _auto_req_init(sw)
+
+    if sw
+      code = "AUTO_LOAD = {} unless self.class.const_defined? 'AUTO_LOAD'\n"
+    else
+      code = "AUTO_LOAD = {} unless const_defined? 'AUTO_LOAD'\n"
+    end
+
+    code.concat <<-__CODE__
+    def method_missing(sym, *param, &block)
+      begin
+      	file, work = AUTO_LOAD[sym]
+      	unless file
+      	  raise NameError,
+      	    "undefined method `\#{sym.id2name}' for \#{inspect}"
+      	end
+      	require file
+      	work.call if work
+
+      	unless respond_to?(sym, true)
+      	  raise "(auto_req) `\#{sym.id2name}' is not defined for `\#{self}' in file:`\#{file}' \#{self.class.superclass.superclass}"
+      	end
+      	send(sym, *param, &block)
+      rescue Exception
+      	$@.delete_if do |trace|
+          trace =~ /^\\(eval\\):/
+        end
+      	raise
+      end
+    end
+    __CODE__
+
+    sw ? instance_eval(code) : module_eval(code)
+  end
+
+  private :_auto_req_init
+  def auto_req_init; _auto_req_init(false); end
+  def auto_req_s_init; _auto_req_init(true); end
+
+  def _auto_req(meths, file, sw = nil, &b)
+    meths = [meths] unless meths.is_a? Array
+    meths.each_index do |x, i|
+      meth[i] = x.intern if x.is_a? String
+    end
+
+    meths.each do |symb|
+      code = <<-__CODE__
+      AUTO_LOAD[symb.is_a?(String) ? symb.intern : symb] = [file, b]
+      __CODE__
+
+      sw ? instance_eval(code) : module_eval(code)
+    end
+  end
+
+  private :_auto_req
+  def auto_req(*a, &b); _auto_req(a[0...-1], a[-1], false, &b); end
+  def auto_req_s(*a, &b); _auto_req(a[0...-1], a[-1], true, &b); end
+end
+
+def auto_req_init
+  Object.auto_req_init
+end
+
+def auto_req(*a, &b)
+  Object.auto_req(*a, &b)
+end
+
+if $0 == __FILE__
+  class Foo
+    auto_req_init
+    auto_req(:hello, "hello.rb") {include Hello; extend Hello}
+  end
+  class Bar < Foo
+  end
+  Bar.new.hello
+  Bar.hello
+end

data/lib/algebra/chinese-rem-th.rb

@@ -0,0 +1,135 @@
+# require "algebra/euclidian-ring"
+require 'algebra/array-supplement'
+
+module Algebra
+  module ChineseRemainderTheorem
+    # return coeffs s.t. coeffs.inner_product(ary) == c
+    # entries of c and ary must be euclidian ring
+    def decompose_on_factors(c, ary)
+      f1, *fs = ary
+      k, *coeffs = f1.gcd_ext_all(*fs)
+      q, r = c.divmod(k)
+      unless r.zero?
+        print 'c = '
+        p c
+        print 'k = '
+        p k
+        print 'ary = '
+        p ary
+        raise "#{c} is not expressed by parameters"
+      end
+      d1, *ds = coeffs.collect { |x| x * q }
+      [d1] + ds # this is ok
+    end
+
+    def decompose_on_cofactors_modp(c, ary, cofacts)
+      # c: Polynomial/Zp
+      # ary: Array of Polynomial/Zp
+      # cofacts: cofacts of ary
+      # OutPut: coeff.inner_product(cofacts of ary) == c
+
+      pf = c.ground
+      prime = c.ground.char
+      coeffs = ary.collect(&:zero)
+      d1, *ds = decompose_on_factors(c, cofacts)
+      # normalize
+      ds_new = []
+      ds.each_with_index do |d, i|
+        fq, fr = d.divmod(ary[i + 1])
+        d1 += fq * ary[0]
+        ds_new << fr
+      end
+      coeffs = [d1] + ds_new
+
+      #    p c == coeffs.inner_product(cofacts)
+      coeffs
+    end
+
+    def decomp_on_cofactors_over_p_adic_int_first(c, ary, prime, cofacts)
+      pf = Polynomial.reduction(Integer, prime, 'x')
+      ary_Zp = ary.collect { |f| pf.reduce(f) }
+      cofacts_Zp = cofacts.collect { |f| pf.reduce(f) }
+      c_zp = pf.reduce(c)
+
+      d1, *ds = decompose_on_factors(c_zp, cofacts_Zp)
+
+      # normalize
+      ds_new = []
+      ds.each_with_index do |d, i|
+        fq, fr = d.divmod(ary_Zp[i + 1])
+        d1 += fq * ary_Zp[0]
+        ds_new << fr
+      end
+      coeffs = [d1] + ds_new
+      ring = c.class
+      coeffs.collect { |f| lifting(f, ring) }
+    end
+
+    def lifting(f, ring)
+      f.project(ring) { |c, _i| c.lift }
+    end
+
+    private :decomp_on_cofactors_over_p_adic_int_first, :lifting
+
+    def mk_cofacts(ary)
+      tot = ary.first.unity
+      ary.each { |f|; tot *= f; }
+      cofacts = []
+      ary.each { |f|; cofacts.push tot / f; }
+      cofacts
+    end
+
+    def decompose_on_cofactors_p_adic(c, ary, cofacts, prime, k)
+      # c: Polynomial/Intger
+      # ary: Array of Polynomial/Integer
+      # OutPut: coeff.inner_product(cofacts of ary) === c mod prime**k
+
+      raise if ary.find { |f| (f.lc % prime).zero? }
+      #    cofacts = mk_cofacts(ary)
+      coeffs = ary.collect(&:zero)
+      0.upto k - 1 do |j|
+        e = prime**j
+        c1 = (c - coeffs.inner_product(cofacts)) / e
+        coeffs1 = decomp_on_cofactors_over_p_adic_int_first(c1,
+                                                            ary, prime, cofacts)
+        coeffs.each_index do |i|
+          coeffs[i] += coeffs1[i] * e
+        end
+      end
+      #    p c - coeffs.inner_product(cofacts)
+      coeffs
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  CRT = ChineseRemainderTheorem
+  include CRT
+  require 'algebra/polynomial'
+  require 'algebra/residue-class-ring'
+  require 'algebra/polynomial-factor'
+  Zp = ResidueClassRing(Integer, 5)
+  P = Polynomial(Zp, 'x')
+  x = P.var
+  a = x + 1
+  b = x + 2
+  c = x + 3
+  #  ary = [b*c, c*a, a*b]
+  ary = [a, b, c]
+  f = a * b * c
+  #  coeffs =  decompose_on_factors(P.unity, ary)
+  coeffs =  decompose_on_cofactors_modp(P.unity, ary, mk_cofacts(ary))
+  p cofacts = mk_cofacts(ary)
+  p coeffs
+  p coeffs.inner_product(cofacts)
+
+  exit
+  PZ = Polynomial(Integer, 'x')
+  x = PZ.var
+  a = (x + 1)**2
+  b = (x + 2)**3
+  c = (x + 3)**1
+  ary = [a, b, c]
+  p decompose_on_cofactors_over_p_adic_int(PZ.unity, ary, mk_cofacts(ary),
+                                           11, 2)
+end

data/lib/algebra/combinatorial.rb

@@ -0,0 +1,145 @@
+# Combinatorial Calculation Library
+#
+#   by Shin-ichiro Hara
+#
+# Version 2.0 (2001.09.14)
+
+module Combinatorial
+  def power(n, m = n)
+    if m == 0
+      yield([])
+    else
+      power(n, m - 1) do |x|
+        (0...n).each do |i|
+          yield([i] + x)
+        end
+      end
+    end
+  end
+
+  def perm(n, m = n)
+    if m == 0
+      yield([])
+    else
+      perm(n - 1, m - 1) do |x|
+        (0...n).each do |i|
+          yield([i] + x.collect{|j| j < i ? j : j + 1})
+        end
+      end
+    end
+  end
+
+  def comb(n, m = n)
+    if m == 0
+      yield([])
+    else
+      comb(n, m - 1) do |x|
+        (((x[0] || -1) + 1)...n).each do |i|
+          yield([i] + x)
+        end
+      end
+    end
+  end
+
+  def rep_comb(n, m)
+     if m == 0
+       yield([])
+     else
+       rep_comb(n, m - 1) do |x|
+         ((x.empty? ? 0 : x.last)...n).each do |i|
+          yield(x+[i])
+         end
+       end
+     end
+  end
+
+  def power0(n, m = n)
+    0.upto n**m-1 do |i|
+      yield( (0...m).collect{ (i, = i.divmod n).last } )
+    end
+  end
+
+  def perm0(n, stack = [])
+    (0...n).each do |x|
+      unless stack.include? x
+	stack.push x
+	if stack.size < n
+	  perm0(n, stack) do |y|; yield y; end
+	else
+	  yield stack.self
+	end
+	stack.pop
+      end
+    end
+  end
+
+  module_function :power, :perm, :comb, :rep_comb, :power0, :perm0
+
+  module Diagonal
+    def diagonal_cone(n, m)
+      0.upto n do |i|
+	co_diagonal(i, m) do |a|
+	  yield a
+	end
+      end
+    end
+    
+    def co_diagonal(n, m)
+      rep_comb(n+1, m-1) do |a|
+	yield difference_seq(0, a, n)
+      end
+    end
+    
+    def difference_seq(n0, ary, n1)
+      x = n0
+      a = []
+      ary.each do |y|
+	a.push y - x
+	x = y
+      end
+      a.push n1 - x
+      a
+    end
+    private :difference_seq
+  end
+  include Diagonal
+  extend Diagonal
+
+  module Cubic
+    # power in order of (point, eadges, surfaces, bodies, ..)
+    def power_cubic(n, m)
+      if n < 1
+	raise "cubic(< 1, m) called"
+      elsif n == 1
+	yield( (0...m).collect{0} )# point of origin
+      else
+	0.upto m do |dim|
+	  Combinatorial.comb(m, dim) do |s|
+	    power_cubic(n-1, dim) do |a|
+	      yield inject(a, s.sort, m)
+	    end
+	  end
+	end
+      end
+    end
+
+    def inject(ary, inds, n = inds.size+1)
+      (0...n).collect{|i| (k = inds.index(i)) ? 1 + ary[k] : 0}
+    end
+    private :inject
+  end
+  include Cubic
+  extend Cubic
+end
+
+if __FILE__ == $0
+#  include Combinatorial
+  n, dim = ARGV.collect{|x|x.to_i}
+#  n, dim = 2, 3
+#  diagonal_cone(n, m) do |a|; p a; end
+  Combinatorial::power_cubic(n, dim) do |a|
+#  Combinatorial::power_cubic_nested(n, dim) do |a|
+    p a
+  end
+#  $stderr.puts( (2*n+1)**dim )
+end

data/lib/algebra/elementary-divisor.rb

@@ -0,0 +1,193 @@
+##########################################
+# Elementary Divisor
+#    by Shin-ichiro HARA
+#
+#    Ver. 1.0 (2001.11.03)
+#
+##########################################
+
+module Algebra
+  class MatrixAlgebra
+    def i2o
+      mground = self.class.ground.ground
+      r = if self.class <= Algebra::SquareMatrix
+            Algebra.SquareMatrix(mground, size)
+          else
+            Algebra.MatrixAlgebra(mground, rsize, csize)
+          end
+
+      rx = Algebra.Polynomial(r, 'x')
+      x = rx.var
+      s = 0
+      (0..e_deg).each do |n|
+        s += x**n * r.matrix { |i, j| self[i, j][n] }
+      end
+      s
+    end
+
+    def e_deg
+      max = -1
+      each_ij do |i, j|
+        if !self[i, j].zero? && (d = self[i, j].deg) > max
+          max = d
+        end
+      end
+      max
+    end
+  end
+
+  module ElementaryDivisor
+    def e_inverse
+      raise 'not square matrix' unless rsize == csize
+      size = rsize
+      edm = to_triplet.e_diagonalize
+      if edm.body[size - 1, size - 1].unity?
+        edm.right * edm.left
+      else
+        puts 'elementary divisor matrix:'; edm.body.display
+        raise 'not invertible'
+      end
+    end
+
+    def elementary_divisor
+      e_diagonalize.diag
+    end
+
+    def e_diagonalize
+      dup.e_diagonalize!
+    end
+
+    def e_diagonalize!
+      size = rsize < csize ? rsize : csize
+      0.upto size - 1 do |d|
+        el_sweep!(d)
+      end
+      self
+    end
+
+    def el_sweep!(d)
+      loop do
+        1 while horizontal_sweep!(d) || vertical_sweep!(d)
+        if idx = sq_find_nondiv(d + 1, self[d, d])
+          i, _j = idx
+          mix_r!(d, i)
+        else
+          break
+        end
+      end
+      unless self[d, d].zero?
+        #	row!(d)[d] = self[d, d].monic
+        divide_r!(d, _coeff(self[d, d]))
+      end
+      self
+    end
+
+    def el_sweep_old!(d)
+      loop do
+        sr = vertical_sweep!(d)
+        sc = horizontal_sweep!(d)
+        break unless sr || sc
+        next unless idx = sq_find_nondiv(d + 1, self[d, d])
+        i, _j = idx
+        mix_r!(d, i)
+        redo
+      end
+      unless self[d, d].zero?
+        #	row!(d)[d] = self[d, d].monic
+        divide_r!(d, _coeff(self[d, d]))
+      end
+      self
+    end
+
+    def _coeff(sdd)
+      if ground <= Algebra::Polynomial
+        sdd.lc
+      elsif ground.field?
+        sdd
+      elsif ground.euclidian?
+        if ground <= Integer && sdd < 0
+          - ground.unity
+        elsif sdd.unit?
+          sdd
+        else
+          ground.unity
+        end
+      else
+        ground.unity
+      end
+    end
+
+    def sq_find_nondiv(d, x)
+      (d...rsize).each do |i|
+        (d...csize).each do |j|
+          return [i, j] unless (self[i, j] % x).zero?
+        end
+      end
+      nil
+    end
+
+    def vertical_sweep!(d)
+      sw = false
+      if self[d, d].zero? && (i = ((d + 1)...rsize).find { |i1| !self[i1, d].zero? })
+        sswap_r!(d, i)
+        sw = true
+      end
+      unless self[d, d].zero?
+        (d + 1...rsize).each do |i0|
+          next if self[i0, d].zero?
+          q = self[i0, d] / self[d, d]
+          sw = true
+          mix_r!(i0, d, -q)
+          # high speed but lost genericity (wo'nt work on triplet)
+          #	    r = row!(i0)
+          #	    (d...csize).each do |j0|; r[j0] -=  q * self[d, j0]; end
+          unless self[i0, d].zero?
+            sswap_r!(d, i0)
+            redo
+          end
+        end
+      end
+      sw
+    end
+
+    def horizontal_sweep!(d)
+      m = transpose
+      if m.vertical_sweep!(d)
+        replace m.transpose
+        true
+      else
+        false
+      end
+    end
+
+    def self.factorize(eds)
+      prev = nil
+      qeds = []
+      eds.each do |f|
+        qeds << if prev
+                  f / prev
+                else
+                  f
+                end
+        prev = f
+      end
+
+      qeds_facts = qeds.collect(&:factorize)
+      result = []
+      prev = nil
+      qeds_facts.each do |fac|
+        prev = if prev
+                 prev * fac
+               else
+                 fac
+               end
+        result << prev
+      end
+      result
+    end
+  end
+
+  class MatrixAlgebra
+    include ElementaryDivisor
+  end
+end