algebra 0.2.1

data/lib/algebra/groebner-basis-coeff.rb

@@ -0,0 +1,228 @@
+# Groebner basis module (with coeffitients)
+#
+#   by Shin-ichiro Hara
+#
+# Version 1.2 (2001.04.03)
+
+module Algebra
+  module Groebner
+    def S_pair_coeff(other)
+      x = lm.lcm(other.lm)
+      a = x / lt
+      b = x / other.lt
+      y = a * rt - b * other.rt
+      [y, a, -b]
+    end
+
+    def self.basis_coeff_132D(g)
+      gbasis = g.dup
+      n0 = g.size
+      #    coeff = (0...n0).collect{|k| [0]*k+[1]+[0]*(n0-k-1)}
+      zero = f.first.zero
+      unity = f.first.unity
+      coeff = (0...n0).collect { |k| [zero] * k + [unity] + [zero] * (n0 - k - 1) }
+      pairs = []
+      g.each_pair_with_index do |x, y, i, j|
+        pairs.push [x, y, i, j]
+      end
+      while pair = pairs.shift
+        x, y, i, j = pair
+        t, a, b = x.S_pair_coeff(y)
+        q, s = t.divmod(*gbasis)
+        next if s.zero?
+        n1 = gbasis.size
+        gbasis.each_with_index { |z, k| pairs.push([z, s, k, n1]) }
+        u = (0...n0).collect do |k|
+          sum = 0
+          (0...gbasis.size).each do |m|
+            sum += (m == i ? a - q[m] : (m == j ? b - q[m] : -q[m])) * coeff[m][k]
+          end
+          sum
+        end
+        coeff.push u
+        gbasis.push s
+      end
+      [coeff, gbasis]
+    end
+
+    def self.basis_coeff_159A(f)
+      n0 = f.size
+      glm = f.collect(&:lm)
+      #    fc = (0...n0).collect{|k| [0]*k+[1]+[0]*(n0-k-1)}
+      zero = f.first.zero
+      unity = f.first.unity
+      fc = (0...n0).collect { |k| [zero] * k + [unity] + [zero] * (n0 - k - 1) }
+
+      indexes = (0...n0).sort { |i, j| glm[i] <=> glm[j] }
+      glm = glm.values_at(*indexes)
+      gbasis = f.values_at(*indexes)
+      coeff = fc.values_at(*indexes)
+
+      pairs = []
+      (0...n0).to_a.each_pair do |i, j|
+        pairs.push [i, j]
+      end
+
+      until pairs.empty?
+        i, j = pairs.first
+        if !glm[i].prime_to?(glm[j]) && !_ct(glm, pairs, i, j)
+          t, a, b = gbasis[i].S_pair_coeff(gbasis[j])
+          q, s = t.divmod(*gbasis)
+          unless s.zero?
+            0.upto glm.size - 1 do |k|
+              pairs.push [k, glm.size]
+            end
+            u = (0...n0).collect do |k|
+              sum = 0
+              (0...gbasis.size).each do |m|
+                sum += (m == i ? a - q[m] : (m == j ? b - q[m] : -q[m])) * coeff[m][k]
+              end
+              sum
+            end
+            coeff.push u
+            gbasis.push s
+            glm.push s.lm
+          end
+        end
+        pairs.shift
+      end
+
+      [coeff, gbasis]
+    end
+
+    def self.minimal_basis_coeff(coeff, gbasis)
+      glm = gbasis.collect(&:lm)
+      indexes = (0...gbasis.size).sort { |i, j| glm[j] <=> glm[i] }
+      indexes.each_with_index do |i, s|
+        (s + 1).upto indexes.size - 1 do |k|
+          j = indexes[k]
+          if glm[j].divide? glm[i]
+            indexes[s] = nil
+            break
+          end
+        end
+      end
+      indexes.compact!
+      b = gbasis.values_at(*indexes)
+      c = coeff.values_at(*indexes)
+      [c, b]
+    end
+
+    def self.reduced_basis_coeff(coeff, gbasis)
+      gbasis.each_with_index do |x, i|
+        (g = gbasis.dup).delete_at(i)
+        q, gbasis[i] = x.divmod(*g)
+        coeff[i] = (0...coeff[i].size).collect do |k|
+          sum = 0
+          (0...gbasis.size).each do |m|
+            d = (m < i ? -q[m] : m == i ? 1 : -q[m - 1])
+            sum += d * coeff[m][k]
+          end
+          sum
+        end
+      end
+      gbasis.each_with_index do |x, i|
+        c = x.lc
+        coeff[i].collect! { |v| v / c }
+        gbasis[i] = x / c
+      end
+      [coeff, gbasis]
+    end
+
+    def self.basis_coeff(g)
+      #    coeff, gbasis = basis_coeff_132D(g)
+      coeff, gbasis = basis_coeff_159A(g)
+      coeff, gbasis = minimal_basis_coeff(coeff, gbasis)
+      coeff, gbasis = reduced_basis_coeff(coeff, gbasis)
+      ind = (0...gbasis.size).to_a
+      ind.sort! { |i, j| gbasis[j] <=> gbasis[i] }
+      [coeff.values_at(*ind), gbasis.values_at(*ind)]
+    end
+
+    def divmod_s0(*f)
+      coeff, gbasis = Groebner.basis_coeff(f)
+      q, r = divmod(*gbasis)
+      q0 = (0...f.size).collect do |i|
+        sum = 0
+        (0...q.size).each do |j|
+          sum += q[j] * coeff[j][i]
+        end
+        sum
+      end
+      [q0, r]
+    end
+
+    def divmod_s(*f)
+      cg = Groebner.basis_coeff(f)
+      div_cg(f, cg)
+    end
+
+    def div_cg(f, cg = nil)
+      cg = Groebner.basis_coeff(f) unless cg
+      coeff, gbasis = cg
+      q, r = divmod(*gbasis)
+      q0 = (0...f.size).collect do |i|
+        sum = 0
+        (0...q.size).each do |j|
+          sum += q[j] * coeff[j][i]
+        end
+        sum
+      end
+      [q0, r]
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  require 'algebra/m-polynomial'
+  require 'algebra/groebner-basis'
+  require 'algebra/algebraic-parser'
+  #  include Algebra
+
+  def gbc(f)
+    f0 = f.first
+    print 'Basis of: '
+    puts(f.join(', '))
+    c, g = Algebra::Groebner.basis_coeff(f)
+    print 'is: '
+    puts(g.join(', '))
+    puts 'Coeefitients are: '
+    c.each do |x|
+      puts x.join(', ')
+    end
+    p 3333
+    p g
+    p c.collect { |x| f.inner_product x }
+
+    if g == c.collect { |x| f.inner_product x }
+      puts 'Success!'
+    else
+      puts 'Fail.'
+    end
+    puts
+  end
+
+  #  require "algebra/residue-class-ring"
+  #  Z5 = ResidueClassRing(Integer, 5)
+  #  P = MPolynomial(Z5)
+  require 'algebra/rational'
+  P = Algebra.MPolynomial(Rational)
+
+  x, y, z = P.vars('xyz')
+
+  f1 = x**2 + y**2 + z**2 - 1
+  f2 = x**2 + z**2 - y
+  f3 = x - z
+
+  gbc([f1, f2, f3])
+
+  g = x**3 + y**3 + z**3
+  q, r = g.divmod_s(f1, f2, f3)
+  p q
+  p r
+  if g == q.inner_product([f1, f2, f3]) + r
+    puts 'Success!'
+  else
+    puts 'Fail.'
+  end
+end

data/lib/algebra/groebner-basis.rb

@@ -0,0 +1,197 @@
+# Groebner basis module
+#
+#   by Shin-ichiro Hara
+#
+# Version 1.3 (2001.04.03)
+#
+# Example:
+#   x, y, z = MPolynomial.vars "xyz"
+#   require "algebra/mathn"
+#   p Groebner.basis([x**2 + y**2 + z**2 -1, x**2 + z**2 - y, x - z])
+
+# require "algebra/ruby-version"
+require "algebra/array-supplement"
+require "algebra/groebner-basis-coeff"
+#require "algebra/work/old-basis"
+
+module Algebra
+module Groebner
+  def S_pair(other)
+    x = lm.lcm(other.lm)
+    x / lt * rt - x / other.lt * other.rt
+  end
+
+  alias | S_pair
+
+  def self.basis?(f)
+    f.each_pair do |x, y|
+      unless ((x|y) % f).zero?
+	return false
+      end
+    end
+    true
+  end
+
+  def self.minimal_basis?(f)
+    return false unless basis?(f)
+    indexes = (0...f.size).to_a
+    indexes.each do |i|
+      others = f.values_at(*(indexes-[i])).collect{|x| x.lt}
+      if (f[i].lt % others).zero?
+	return false
+      end
+    end
+    true
+  end
+
+  def self.reduced_basis?(f)
+    return false unless basis?(f)
+    indexes = (0...f.size).to_a
+    indexes.each do |i|
+      others = f.values_at(*(indexes-[i])).collect{|x| x.lt}
+      f[i].each_term do |t|
+	if (t % others).zero?
+	  return false
+	end
+      end
+    end
+    true
+  end
+
+  def self.basis_132D(f)
+    gbasis = f.dup
+    pairs = []
+    gbasis.each_pair do |x, y|
+      pairs.push [x, y]
+    end
+    while pair = pairs.shift
+      x, y = pair
+      s = (x|y) % gbasis
+      unless s.zero?
+	gbasis.each do |z| pairs.push([z, s]) end
+	gbasis.push s
+      end
+    end
+    gbasis
+  end
+
+  def self.basis_159A(f)
+    gbasis = f.sort # little effort
+    glm = gbasis.collect{|x| x.lm}
+    pairs = []
+    (0...glm.size).to_a.each_pair do |i, j|
+      pairs.push [i, j]
+    end
+
+    until pairs.empty?
+      i, j = pairs.first
+      if !glm[i].prime_to?(glm[j]) && !_ct(glm, pairs, i, j)
+	s = (gbasis[i]|gbasis[j]) % gbasis
+	unless s.zero?
+	  0.upto glm.size-1 do |k|
+	    pairs.push [k, glm.size]
+	  end
+	  gbasis.push s
+	  glm.push s.lm
+	end
+      end
+      pairs.shift
+    end
+    gbasis
+  end
+
+  def self._ct(fm, b, i, j)
+    0.upto fm.size-1 do |k|
+      next if k == i or
+	k == j or
+	i < k ? b.include?([i, k]) : b.include?([k, i]) or
+	j < k ? b.include?([j, k]) : b.include?([k, j])
+      return true if fm[k].divide_or?(fm[i], fm[j])
+    end
+    false
+  end
+
+  def self.minimal_basis(gbasis)
+#    p [200, gbasis]
+    glm = gbasis.collect{|x| x.lm}
+    indexes = (0...gbasis.size).sort{|i, j| glm[j] <=> glm[i]}
+    indexes.each_with_index do |i, s|
+      (s+1).upto indexes.size-1 do |k| j = indexes[k]
+#	p [glm[j], glm[i],  glm[j].divide? glm[i]]
+	if glm[j].divide? glm[i]
+	  indexes[s] = nil
+	  break
+	end
+      end
+    end
+    indexes.compact!
+    gbasis.values_at(*indexes)
+  end
+
+  def self.reduced_basis(gbasis)
+    gbasis.each_with_index do |x, i|
+      (g = gbasis.dup).delete_at(i)
+      gbasis[i] = x % g
+    end
+    gbasis.collect{|t| t / t.lc}
+  end
+
+  def self.basis(g)
+    gbasis = nil
+
+#    gbasis = basis_132D(g)
+    gbasis = basis_159A(g)
+
+    gbasis = minimal_basis(gbasis)
+    gbasis = reduced_basis(gbasis)
+    gbasis.sort!{|x, y| y <=> x}
+    gbasis
+  end
+end
+
+class MPolynomial
+  include Algebra::Groebner
+end
+
+end
+
+if $0 == __FILE__
+  require "algebra/m-polynomial"
+#  include Algebra
+
+  def gb(f, sw = false)
+    f0 = f.first
+    print "Basis of: "
+    sw ? puts('', *f) : puts(f.join(", "))
+    gbase = Algebra::Groebner.reduced_basis(f)
+    print "Is: "
+    sw ? puts('', *gbase) : puts(gbase.join(", "))
+    puts
+  end
+
+  puts "rational"
+  require "algebra/rational"
+  x, y, z = Algebra.MPolynomial(Rational).vars "xyz"
+  f1 = x**2 + y**2 + z**2 -1
+  f2 = x**2 + z**2 - y
+  f3 = x - z
+  gb([f1, f2, f3])
+
+
+  puts "mod 5"
+  require "algebra/residue-class-ring"
+  F5 = Algebra.ResidueClassRing(Integer, 5)
+  x, y, z = Algebra.MPolynomial(F5).vars "xyz"
+  f1 = x**2 + y**2 + z**2 -1
+  f2 = x**2 + z**2 - y
+  f3 = x - z
+  gb([f1, f2, f3])
+
+  puts "require 'algebra/mathn'"
+  require "algebra/mathn"
+  x, y, z = Algebra.MPolynomial(Integer).vars "xyz"
+  f1 = x**2 + y**2 + z**2 -1
+  f2 = x**2 + z**2 - y
+  f3 = x - z
+  gb([f1, f2, f3])
+end

data/lib/algebra/import-module-single-thread.rb

@@ -0,0 +1,86 @@
+# $IMPORT_MODULE_debug = true
+require 'algebra/import-module'
+module Import_Module
+  class Scope
+    def set_methods
+      meths = @target.get_orig_methods(@source)
+      @target.def_orig_methods meths
+      # def_methods
+      mod = @mod
+      @klass.class_eval { include mod }
+    end
+
+    def push
+      def_methods
+      c = @target.stack.current
+      @target.stack.push(update(c))
+    end
+
+    def pop
+      c = @target.stack.pop
+      recov_methods(c)
+    end
+
+    private
+
+    def update(c)
+      d = c.dup
+      @source.methods.__each__ do |meth|
+        d[meth] = @mod
+      end
+      d
+    end
+
+    def def_methods
+      mod = @mod
+      target = @target
+      @source.methods.__each__ do |meth|
+        @klass.module_eval do
+          alias_method meth, Import_Module.name(meth, mod)
+          protected(meth) if target.protecteds.include?(meth)
+          private(meth) if target.privates.include?(meth)
+        end
+      end
+    end
+
+    def recov_methods(c)
+      orig_methods = @target.orig_methods
+      d = @target.stack.current
+      c.__each__ do |meth, _mod|
+        @klass.module_eval do
+          if m = d[meth] || orig_methods[meth] && :orig
+            alias_method meth, Import_Module.name(meth, m)
+          else
+            undef_method meth
+          end
+        end
+      end
+    end
+  end
+
+  class Target
+    def initialize(klass)
+      @scopes = {}
+      @klass = klass
+      @publics = @klass.public_instance_methods(true) # .find_all{|m| @klass.public_method_defined? m}
+      @privates = @klass.private_instance_methods(true) # .find_all{|m| @klass.private_method_defined? m}
+      @protecteds = @klass.protected_instance_methods(true) # .find_all{|m| @klass.protected_method_defined? m}
+      @orig_methods = {}
+      @saved_methods = {}
+      resist_orig_methods
+      @stack = Stack.new([{}]) # diff
+    end
+  end
+
+  class Stack
+    private
+
+    def export_current; end
+  end
+end
+
+class << Thread
+  alias new new_org
+  alias start new_org
+  alias fork new_org
+end