algebra 0.2.1

data/lib/algebra/m-index.rb

@@ -0,0 +1,282 @@
+# Multi-index class for MPolymial
+#
+#   by Shin-ichiro Hara
+#
+# Version 2.00 (2002.02.04)
+
+module Algebra
+  class MIndex
+    include Enumerable
+
+    module Lex
+      def <=>(other)
+        @body <=> other.to_a
+      end
+    end
+
+    module Grlex
+      def <=>(other)
+        s = (totdeg <=> other.totdeg)
+        return s unless s.zero?
+        @body <=> other.to_a
+      end
+    end
+
+    module Grevlex
+      def <=>(other)
+        s = (totdeg <=> other.totdeg)
+        return s unless s.zero?
+        n = [size, other.size].max
+        (n - 1).downto 0 do |i|
+          x = other[i] - self[i]
+          return x unless x.zero?
+        end
+        0
+      end
+    end
+
+    module V_lex
+      def <=>(other)
+        #	n = [size, other.size].max
+        #	0.upto (n-1) do |i|
+        V_ORDER.each do |i|
+          #	  x = self[V_ORDER[i]] - other[V_ORDER[i]]
+          x = self[i] - other[i]
+          return x unless x.zero?
+        end
+        #	p [111111111, self, other]
+        0
+      end
+    end
+
+    module V_grlex
+      def <=>(other)
+        s = (totdeg <=> other.totdeg)
+        return s unless s.zero?
+        #	n = [size, other.size].max
+        #	0.upto (n-1) do |i|
+        V_ORDER.each do |i|
+          #	  x = self[V_ORDER[i]] - other[V_ORDER[i]]
+          x = self[i] - other[i]
+          return x unless x.zero?
+        end
+        0
+      end
+    end
+
+    module V_grevlex
+      def <=>(other)
+        s = (totdeg <=> other.totdeg)
+        return s unless s.zero?
+        #	n = [size, other.size].max
+        #	(n-1).downto 0 do |i|
+        V_ORDER.reverse_each do |i|
+          #	  x = other[V_ORDER[i]] - self[V_ORDER[i]]
+          x = other[i] - self[i]
+          return x unless x.zero?
+        end
+        0
+      end
+    end
+
+    def initialize(array = [])
+      @body = array
+    end
+
+    def to_a
+      @body
+    end
+
+    def empty?
+      @body.empty?
+    end
+
+    def size
+      @body.size
+    end
+
+    def each
+      @body.each do |x|
+        yield x
+      end
+    end
+
+    # def ==(other)
+    #   @body == other.to_a
+    # end
+
+    def eql?(other)
+      @body.eql? other.to_a
+    end
+
+    def hash
+      @body.hash
+    end
+
+    Unity = new
+
+    def self.[](*ind)
+      new(ind)
+    end
+
+    def unity
+      Unity.dup
+    end
+
+    def unity?
+      self == Unity
+    end
+
+    def [](i)
+      @body[i] || 0
+    end
+
+    def []=(i, x)
+      k = (self[i] = x)
+      raise 'illegal operation' if totdeg == 0
+      k
+    end
+
+    def self.monomial(idx, height = 1)
+      ind0 = []
+      (0..idx).each do |i|
+        ind0.push(i == idx ? height : 0)
+      end
+      new(ind0)
+    end
+
+    def multideg
+      @body
+    end
+
+    def devide?(other)
+      each_with_index do |x, i|
+        return false if x > other[i]
+      end
+      true
+    end
+
+    def devide_or?(other0, other1)
+      each_with_index do |x, i|
+        return false if x > other0[i] || x > other1[i]
+      end
+      true
+    end
+
+    def prime_to?(other)
+      each_with_index do |x, i|
+        return false if x > 0 && other[i] > 0
+      end
+      true
+    end
+
+    def totdeg
+      s = 0
+      each { |n| s += n; }
+      s
+    end
+
+    def ==(other)
+      0.upto [size, other.size].max - 1 do |i|
+        return false if self[i] != other[i]
+      end
+      true
+    end
+
+    def +(other)
+      self.class.new((0...[size, other.size].max).collect do |i|
+                       self[i] + other[i]
+                     end)
+    end
+
+    def -(other)
+      self.class.new((0...[size, other.size].max).collect do |i|
+                       x = self[i] - other[i]
+                       raise "#{self} is not devided by #{other}" if x < 0
+                       x
+                     end).compact!
+    end
+
+    def annihilate(at)
+      self - self.class.monomial(at, self[at])
+    end
+
+    def lcm(other)
+      self.class.new((0...[size, other.size].max).collect do |i|
+                       [self[i], other[i]].max
+                     end)
+    end
+
+    def gcm(other)
+      self.class.new((0...[size, other.size].max).collect do |i|
+                       [self[i], other[i]].min
+                     end).compact!
+    end
+
+    def compact! # be careful, when this index is used plural places!!
+      i = size - 1
+      i -= 1 while i >= 0 && self[i].zero?
+      @body.slice!((i + 1)..-1) if i < size - 1
+      self
+    end
+
+    def compact # more safe
+      dup.compact!
+    end
+
+    def dup
+      self.class.new(@body)
+    end
+
+    def to_s!(vars = nil, pr = nil, po = nil)
+      return @body.inspect unless vars
+      a = ''
+      each_with_index do |n, i|
+        case n
+        when 0
+        else
+          #          u = n == 1 ? vars[i].to_s : vars[i].to_s + "#{po}#{n}"
+          u = if n == 1
+                vars[i].to_s
+              elsif /^\}/ =~ po
+                "{#{vars[i]}#{po}#{n}"
+              else
+                "#{vars[i]}#{po}#{n}"
+              end
+          a.concat(a.empty? ? u : "#{pr}#{u}")
+        end
+      end
+      a
+    end
+
+    def to_s(var = nil, pr = nil, po = nil)
+      $DEBUG ? @body.inspect.gsub(/\s+/, '') : to_s!(var, pr, po)
+    end
+
+    def inspect(var = nil, po = nil)
+      to_s(var, po)
+    end
+
+    def self.set_ord(ord)
+      mod = get_module(ord)
+      adopt_module(mod)
+    end
+
+    def self.set_V_ORDER(v_ord)
+      remove_const 'V_ORDER' if const_defined? 'V_ORDER'
+      const_set('V_ORDER', v_ord)
+    end
+
+    def self.set_v_ord(ord, v_ord)
+      set_V_ORDER(v_ord)
+      vord = get_module(ord, v_ord)
+      adopt_module(vord)
+    end
+
+    def self.get_module(ord, v_ord = nil)
+      ord = ord.id2name
+      ord = 'V_' + ord if v_ord
+      eval(ord.capitalize)
+    end
+  end
+end

data/lib/algebra/m-polynomial-factor-int.rb

@@ -0,0 +1,186 @@
+# Factorization of Multivariate polynomial / Integer, Rational
+#
+#   by Shin-ichiro Hara
+#
+# Version 1.0 (2001.09.14)
+
+require 'algebra/m-polynomial'
+require 'algebra/polynomial'
+require 'algebra/polynomial-factor'
+require 'algebra/residue-class-ring'
+require 'algebra/rational'
+require 'algebra/chinese-rem-th'
+require 'algebra/m-polynomial-gcd'
+# require "algebra/combinatorial"
+
+module Algebra
+  module MPolynomialFactorization
+    include PolynomialFactorization::Z
+    #  include PolynomialFactorization::Q
+
+    def factorize_int(an = 0)
+      return Factors.new([[self, 1]]) if constant?
+      f = self
+      f = f.sqfree if an == 0
+      an += 1 while f.deg_at(an) <= 0
+      f = f.pp(an)
+      lc_of_f = f.lc_at(an)
+      f = f.monic_int(an)
+      facts = f._factorize(an)
+      facts = facts.map! do |f2|
+        f3 = f2.project(self.class) { |c, j| c * lc_of_f**j[an] }
+        f3.pp(an)
+      end
+      facts = facts.fact_all_u(self)
+      facts.mcorrect_lc!(self, an) do |fac|
+        fac.factorize_int(an + 1)
+      end
+      facts
+    end
+
+    def sqfree
+      _sqfree
+    end
+
+    def gelfond_bound(char)
+      n = vars.size
+      ds = (0...n).collect { 0 }
+      c0 = 0
+      each do |ind, c|
+        next if c.zero?
+        ind.each_with_index do |d0, i|
+          ds[i] = d0 if d0 > ds[i]
+        end
+        c0 = c.abs if c.abs > c0
+      end
+      tot = 0
+      ds.each do |x|
+        tot += x
+      end
+      b = Math::E**tot * c0
+      l = 0
+      s = 1
+      while s <= 2 * b
+        s *= char
+        l += 1
+      end
+      l
+    end
+
+    #  def hensel_lift_int(g0, f0, char, height)
+    def hensel_lift_int(g0, f0, char, height, where)
+      # self in MPolynomial/int
+      # g0 in Polyomial/Z, candidate of factor of f0
+      # f0 in Polyomial/Z, one variable reduction of self
+
+      pheight = gelfond_bound(char)
+
+      fk = _hensel_lift(g0, f0, char, height, where) do |ha, ary, cofacts|
+        #    fk =  _hensel_lift(g0, f0, char, height) {|ha, ary, cofacts|
+        decompose_on_cofactors_p_adic(ha, ary, cofacts, char, pheight)
+      end
+      mod = char**pheight
+      g = centorize(fk[0], mod)
+      h = centorize(fk[1], mod)
+
+      r = self - g * h
+      return [g, h] if r.zero?
+
+      nil
+    end
+
+    def centorize(f, n)
+      half = n / 2
+      #    f.class.new(*f.collect{|c| c > half ? c - n : c })
+      f.project(f.class) do |c, _ind|
+        c = c % n
+        c > half ? c - n : c
+      end
+    end
+
+    module Q
+      def contQ
+        ns = collect { |_ind, q| q.numerator }
+        ds = collect { |_ind, q| q.denominator }
+        n = ns.first.gcd_all(* ns[1..-1])
+        d = ds.first.lcm_all(* ds[1..-1])
+        # if ground == Rational #in 1.8.0, Rational.new is private.
+        # ground.new!(n, d)
+        # else
+        # raise "unknown gound type #{ground}" #20030606
+        # ground.new(n, d)
+        # end
+        if ground == Rational
+          Rational(n, d)
+        else
+          ground.new(n, d)
+        end
+      end
+
+      def ppQ(ring)
+        (self / contQ).project(ring) { |c, _j| c.to_i }
+      end
+
+      def factorize_rational
+        pz = Algebra.MPolynomial(Integer)
+        pz.vars(*self.class.variables)
+        fz = ppQ(pz)
+        a = fz.factorize_int
+
+        # ground == Rational, ground.ground == Integer
+        u = ground.ground.unity
+        b = a.collect do |f, i|
+          [f.project(self.class) do |c, _j|
+             if ground == Rational
+               Rational(c, u)
+             else
+               ground.new(c, u)
+             end
+           end, i]
+        end
+        contQ == ground.unity ? b : b.unshift([self.class.const(contQ), 1])
+      end
+    end
+    include Q
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  require 'algebra/m-polynomial-factor'
+  include Algebra
+
+  def test(f)
+    print "#{f}\n  => \n"
+    a = f.factorize_int
+    sw = (f == a.pi)
+    puts "#{a.inspect}, #{sw}"
+    raise unless sw
+  end
+
+  #  P = MPolynomial(Rational)
+  P = MPolynomial(Integer)
+  PS = Polynomial(Integer, 't')
+  x, y, z = P.vars('xyz')
+  #  x, y, z, t = P.vars("xyzt")
+
+  #  f = (x + y + z)**3*(2*z + x)**2*(4*z + y)
+  #  g = (x + y + z)*(2*z + x)*(4*z + y)
+  #  p f
+  #  fs = f.sqfree
+  #  p fs
+  #  p g == fs
+
+  fs = [
+    x**3 + y**3 + z**3 - 3 * x * y * z,
+    x**2 + (-z**2 - y * z + y + z + 2) * x + (y * z**3 - z**3 - y**2 * z - y * z + 2 * z),
+    (x + y) * (x + z**2 + 1) * (x**2 + y * z + 1),
+    (x + y) * (x + y**2 + z**2 + 1 + y * z) * (x**2 + z + y * 3),
+    (x + y) * (x + z + y * 3) * (x + 1),
+    (x + y)**2 * (x + z)
+    #    (t + x)*(t + y)*(t + z),
+  ]
+
+  fs.each do |f|
+    test(f)
+  end
+end