algebra 0.2.1

data/lib/algebra/powers.rb

@@ -0,0 +1,31 @@
+module Algebra
+  module Powers
+    def **(n)
+      return unity if n == 0
+
+      if n > 0
+        m = self
+      else
+        n = -n
+        m = inverse
+      end
+
+      z = x = m
+      n -= 1
+      while n & 1 != 0 && (z *= x); (n >>= 1) != 0
+                                    x *= x
+      end
+      z
+
+      #    if n == 1
+      #      m
+      #    else
+      #      q , r = n.divmod 2
+      #      x = m ** q
+      #      x = x * x
+      #      x = x * m if r > 0
+      #      x
+      #    end
+    end
+  end
+end

data/lib/algebra/prime-gen.rb

@@ -0,0 +1,32 @@
+# Prime Generator
+#
+#   by Shin-ichiro Hara
+#
+# Version 1.0 (2001.09.07)
+
+class Primes
+  List = [2, 3]
+  def [](n); List[n]; end
+  def succ
+    n = List[-1] + 2
+    n += 2 while List.find{|k| n % k == 0}
+    List << n
+    n
+  end
+
+  def each
+    List.each do |x|
+      yield x
+    end
+    loop do
+      yield succ
+    end
+  end
+
+  def self.include?(x)
+    new.each do |prm|
+      return false if prm > x
+      return true if prm == x
+    end
+  end
+end

data/lib/algebra/rational.rb

@@ -0,0 +1,81 @@
+# if ENV["RUBY_RAT"]
+#   $LOAD_PATH.unshift ENV["RUBY_RAT"]
+#   require "rational.rb"
+# elsif ENV["RUBY_USE_FRACTION"]
+#   require "frac"
+#   class Fraction < Numeric
+#     instance_eval do
+#       alias new! new
+#     end
+#
+#     def initialize(n, d = 1)
+#       @numerator, @denominator = n, d
+#     end
+#   end
+#
+#   Rational = Fraction
+#   alias Rational frac
+#
+#   class Rational < Numeric
+#     def self.unity; new(1,1); end
+#     def self.zero; new(0,1); end
+#     def inverse; 1 / self; end
+#   end
+# else
+#   require "rational"
+# end
+
+class Rational
+  # public_class_method :new
+
+#  def pdivmod(other); [self / other, zero]; end
+  alias pdivmod divmod
+
+  def self.ground; Integer; end
+
+  def self.regulate(o)
+    case o
+    when self
+      o
+    when Numeric
+      Rational(o)
+    else
+      nil
+    end
+  end
+
+  def self.wedge(otype)
+    if otype <= Integer || otype <= self
+      self
+    else
+      otype
+    end
+  end
+
+  def devide?(other); true; end
+
+  def gcd_coeff(b)
+    if b.zero?
+      [self, self.class.unity, self.class.zero]
+    else
+      q, r = divmod b
+      d, x, y = b.gcd_coeff(r)
+      [d, y, x - y * q]
+    end
+  end
+
+  # def self.unity; new(1, 1); end
+  # def self.zero; new(0, 1); end
+  def self.unity; Rational(1); end
+  def self.zero; Rational(0); end
+
+
+  def mod(o)
+    raise ZeroDivisionError, "devided by 0" if o.zero?
+    den, a, = denominator.gcd_coeff(o)
+    num = (numerator * a) % o
+    q, r = num.divmod den
+    raise "denominator(#{denominator}) can not divide numerator(#{numerator}) mod #{o}" unless r.zero?
+    q
+  end
+end

data/lib/algebra/residue-class-ring.rb

@@ -0,0 +1,219 @@
+# Residue Class Ring
+#
+#   by Shin-ichiro Hara
+#
+# Version 1.2 (2001.04.08)
+
+require "algebra/euclidian-ring"
+require "algebra/algebraic-system"
+#require "algebra/algebraic-extension-field.rb"
+
+module Algebra
+  def ResidueClassRing(klass, mod)
+    ResidueClassRing.create(klass, mod)
+  end
+
+=begin
+  def AlgebraicExtensionField(field, var)
+    ring = Polynomial(field, var)
+    k = ResidueClassRing(ring, yield(ring.var))
+    def k.var; self[ground.var]; end
+    k
+  end
+  module_function :ResidueClassRing, :AlgebraicExtensionField
+=end
+  module_function :ResidueClassRing
+
+  class ResidueClassRing
+    extend AlgebraCreator
+    include AlgebraBase
+
+    attr_reader :x
+
+    def lift; @x; end
+
+    def self.[](m); new(m); end
+
+    def self.indeterminate(obj)
+      new(ground.indeterminate(obj))
+    end
+
+    def self.**(elem)
+      #elem: Polynomial, ResidueClassRing
+      elem.convert_to(self)
+    end
+
+    def initialize(x)
+      @x = x % modulus
+    end
+
+    def monomial?
+      !@x.respond_to?(:monomial?) || @x.monomial?
+     #^^^^^^^^^ numeric ^^^^^^^^^
+    end
+
+    def need_paren_in_coeff?
+      if @x.respond_to?(:need_paren_in_coeff?)
+        @x.need_paren_in_coeff?
+      elsif @x.is_a?(Numeric)
+        false
+      else
+        true
+      end
+    end
+
+    def evaluate(*a)
+      #p [333, @x, @x.class, a[0], a[0].class]
+      #b = a[0].lift
+      #c = b.evaluate(@x)
+      #p [c, c.class]
+      #d = self.class[c]
+      #p [d, d.class]
+      #k = @x.evaluate(*a)
+      #p [444, k, k.class, k.lift, k.lift.class]
+      self.class[@x.evaluate(*a)]
+      #d
+    end
+
+    def convert_to(k)
+      b = lift
+      c = b.evaluate(k.ground.var)
+      k[c]
+    end
+
+    def ==(other)
+      super{ |o|
+	((@x - o.x) % modulus).zero?
+      }
+    end
+
+    def +(other)
+      super{ |o|
+	self.class[@x + o.x]
+      }
+    end
+
+    def -(other)
+      super{ |o|
+	self.class[@x - o.x]
+      }
+    end
+
+    def *(other)
+      super{ |o|
+	self.class[@x * o.x]
+      }
+    end
+
+    def inverse
+      return self.class.inverse(@x) if self.class.respond_to? :inverse
+      return self.class[@x.inverse] if @x.respond_to? :inverse
+      d, a, = @x.gcd_coeff(modulus)
+      self.class.new(a / d)
+    end
+
+    def /(other)
+      if other.is_a?(self.class)
+	self * other.inverse
+      else
+	super{ |o|
+	  self.class[@x / o.x]
+	}
+      end
+    end
+
+    def pdivmod(other); [self / other, zero]; end
+
+    #  def unit?
+    #    inverse
+    #  end
+
+    def to_s
+      (@x % modulus).to_s
+    end
+
+    alias inspect to_s unless $DEBUG
+
+    def modulus; self.class.modulus; end
+    def modulus=(var); self.class.modulus = var; end
+
+    def self.create(ground, mod)
+      klass = super(ground)
+      klass.sysvar(:modulus, mod)
+
+      if mod.is_a?(Integer) && (ground <= Integer || defined?(Rational) &&
+				ground <= Rational)
+	klass.class_eval <<__END_OF_CLASS_DEFINITION__
+
+	#      @@modulus = #{mod}
+	@@inverse = [nil] + (1...@@modulus).collect{|x|
+	  d, a, = x.gcd_coeff(@@modulus)
+	  (y = a % @@modulus / d).zero? ? nil : y
+	}
+	require "algebra/prime-gen"
+	def self.field?; Primes.include?(@@modulus); end
+	def self.char; @@modulus; end
+	def self.inverse(k); @@inverse[k]; end
+	def self.to_ary; (0...@@modulus).collect{|x| self[x]}; end
+
+__END_OF_CLASS_DEFINITION__
+      end
+      klass
+    end
+  end
+end
+
+if __FILE__ == $0
+  include Algebra
+  Z13 = ResidueClassRing.create(Integer, 13)
+
+  _a, b, c, d, e, _f, _g = Z13
+  p [e + c, e - c, e * c, e * 2001, 3 + c, 1/c, 1/c * c,
+    d / d, b * 1 / b] #=> [6, 2, 8, 9, 5, 7, 1, 1, 1]
+  p( (1...13).collect{|i|  Z13[i]**12} )
+          #=> [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+
+  require "algebra/polynomial"
+  require "algebra/rational"
+
+  Px = Polynomial(Rational, "x")
+#  Px = Polynomial(Z13, "x")
+
+  x = Px.var
+  F = ResidueClassRing(Px, x**2 + x + 1)
+  x = F[x]
+  p( (x + 1)**100 )    #=> -x - 1
+
+  G = Polynomial(F, "y")
+  y = G.var
+
+  p( (x + y + 1)** 7 )
+    #=> y^7 + (7x + 7)y^6 + 8xy^5 + 4y^4 + (4x + 4)y^3 + 5xy^2 + 7y + x + 1
+
+  H = ResidueClassRing(G, y**5 + x*y + 1)
+  y = H[y]
+
+  p( (x + y + 1)**7 )
+    #=> 4y^4 + (3x + 4)y^3 + (5x + 6)y^2 + (x + 8)y + 6x + 1
+  p( 1/(x + y + 1)**7 )
+    #=> (1798/3x + 1825/9)y^4 + (-74x + 5176/9)y^3 +
+    #     (-6886/9x - 5917/9)y^2 + (1826/3x - 3101/9)y + 2146/9x + 4702/9
+
+  require "algebra/polynomial"
+#  A = Polynomial(Rational, "x")
+  Z7 = ResidueClassRing.create(Integer, 7)
+  A = Polynomial(Z7, "x")
+  x = A.var
+  B = Polynomial(A, "y")
+  y = B.var
+  C = Polynomial(B, "z")
+  z = C.var
+  D = Polynomial(C, "w")
+  w = D.var
+  p( (x+y+z+w)**7 ) #=> w^7 + z^7 + y^7 + x^7
+
+  require "algebra/algebraic-extension-field.rb"
+  AEF = AlgebraicExtensionField(Rational, "x") {|x1| x1**2 + x1 + 1}
+  x = AEF.var
+  p( (x-1)** 3 / (x**2 - 1) )
+end

data/lib/algebra/sets-system.rb

@@ -0,0 +1,43 @@
+class Class
+  def use_setname
+    const = 'C__names__'
+    evalstr = <<-__END_OF_EVAL__
+    class #{name}
+      raise '#{const} is already defined.' if defined? #{const}
+      
+      #{const} = {}
+      
+      raise 'setname is already defined.' if defined? setname
+
+      def setname(s)
+	#{const}[self] = s
+      end
+      
+      alias inspect! inspect
+      
+      def inspect
+	#{const}[self] || super
+      end
+      
+    end
+    __END_OF_EVAL__
+    eval(evalstr, TOPLEVEL_BINDING)
+  end
+end
+
+module Marshal
+  def self.put(obj, filename)
+    open(filename, "wb") do |f|
+      Marshal.dump(obj, f)
+    end
+  end
+  def self.get(filename)
+    open(filename, "rb") do |f|
+      Marshal.load(f)
+    end
+  end
+end
+
+def p!(x); puts x.inspect!; end
+
+

data/lib/algebra/splitting-field.rb

@@ -0,0 +1,103 @@
+# Splitting Field of Polynomial over Rational
+#
+#   by Shin-ichiro Hara
+#
+# Version 1.11 (2002.02.23)
+
+require 'algebra/polynomial'
+require 'algebra/polynomial-factor'
+require 'algebra/algebraic-extension-field'
+
+module Algebra
+  module SplittingField
+    def decompose(pre_facts = nil, var_obj = 'a', no_sq = false)
+      poly = self
+      # poly may have duplicate roots
+      ext_field = poly.ground
+
+      polys = pre_facts ? pre_facts.dup : poly.factorize
+      roots = []
+      # roots == addelems + cmpelems, as set.
+      # the difference is ordering.
+      addelems = []
+      cmpelems = []
+      fac = Factors.new
+
+      while fn = polys.shift
+        f, n = fn # f: irreducible, n: duplication
+        if f.deg <= 1
+          fac.push [f, n]
+          roots.concat([-f[0] / f[1]] * n) unless f[1].zero?
+          cmpelems.concat([-f[0] / f[1]] * n) unless f[1].zero?
+        else
+          if !no_sq && f.deg == 2
+            newF, r, r0 = Algebra.QuadraticExtensionField(ext_field, &f)
+            roots.concat([r, r0] * n)
+
+            addelems.push r
+            cmpelems.concat([r] * (n - 1))
+            cmpelems.concat([r0] * n)
+
+            px, x = Algebra.Polynomial(newF, 'x')
+            fac.push [x - r, n]
+            fac.push [x - r0, n]
+            q = f.convert_to(px) / (x - r) / (x - r0) # scalar
+          else
+            newF = Algebra.AlgebraicExtensionField(ext_field, var_obj) do |v|
+              f.evaluate(v)
+            end
+            r = newF.var
+
+            roots.concat([r] * n)
+            addelems.push r
+            cmpelems.concat([r] * (n - 1))
+
+            px, x = Algebra.Polynomial(newF, 'x')
+            fac.push [x - r, n]
+            q = f.convert_to(px) / (x - r)
+          end
+
+          polys_new = q.factorize**n
+          polys.each do |g, m|
+            g0 = g.convert_to(px)
+            fc = g0.factorize
+            polys_new.concat fc**m
+          end
+
+          ext_field = newF
+          polys = polys_new
+          var_obj = /^[a-qs-z]\d*$/ =~ var_obj ? var_obj.succ : var_obj + '_'
+        end
+      end
+
+      mods = if ext_field <= Algebra::AlgebraicExtensionField
+               ext_field.def_polys
+             else
+               []
+       end
+
+      proots = addelems + cmpelems
+
+      [ext_field, mods, fac, roots, proots]
+    end
+
+    def splitting_field(pre_facts = nil, var_obj = 'a', no_sq = false)
+      var_obj ||= 'a'
+      poly = self
+      field, def_polys, fac, roots, proots =
+        poly.decompose(pre_facts, var_obj, no_sq)
+      roots = roots.collect { |r| field.regulate(r) }
+      proots = proots.collect { |r| field.regulate(r) }
+
+      Struct.new(:poly, :field, :roots, :def_polys, :proots)[
+  poly, field, roots, def_polys, proots
+      ]
+    end
+  end
+
+  # for backward compatibility
+  def MinimalDecompositionField(f, *a)
+    f.decompose(*a)
+  end
+  module_function :MinimalDecompositionField
+end