algebra 0.2.1

data/lib/algebra/jordan-form.rb

@@ -0,0 +1,114 @@
+# Jordan Canonical Forms
+#
+#   by Shin-ichiro Hara
+#
+# Version 1.00 (2001.11.01)
+require 'algebra/matrix-algebra'
+
+module Algebra
+  class MatrixAlgebra
+    def jordan_form
+      Algebra::JordanForm.decompose(self).first
+    end
+
+    def jordan_form_info
+      Algebra::JordanForm.decompose(self)
+    end
+  end
+
+  class JordanForm
+    def initialize(body)
+      @body = body
+    end
+
+    def to_matrix(ring = Integer)
+      mat = nil
+      @body.each do |x, n|
+        mat = if mat
+                mat.dsum(jordan_block_u(ring, x, n))
+              else
+                jordan_block_u(ring, x, n)
+              end
+      end
+      mat
+    end
+
+    alias to_matrix_u to_matrix
+
+    def to_matrix_l
+      to_matrix_u.transpose
+    end
+
+    def jordan_block_u(ring, x, n)
+      a = Algebra.SquareMatrix(ring, n)
+      a.matrix do |i, j|
+        if i == j
+          x
+        elsif i == j - 1
+          ring.unity
+        else
+          ring.zero
+        end
+      end
+    end
+
+    def jordan_block_l(ring, x, n)
+      jordan_block_u(ring, x, n).transpose
+    end
+
+    def self.construct(elem_divs, facts, field, pfield)
+      a = []
+      elem_divs.each do |e|
+        facts.each do |f, n|
+          next if f.deg.zero? || n.zero?
+          f = f.convert_to(pfield)
+          g = e.convert_to(pfield)
+
+          raise 'insufficient decomposition' unless f.deg <= 1
+          k = 0
+          loop do
+            q, r = g.divmod f
+            break unless r.zero?
+            g = q
+            k += 1
+          end
+          a.push [-f[0], k] if k > 0
+        end
+      end
+      Algebra::JordanForm.new(a).to_matrix(field)
+    end
+
+    def self.decompose(m)
+      base_ring = m.ground
+      base_pring = Algebra.Polynomial(base_ring, 'x')
+      base_alg = Algebra.SquareMatrix(base_pring, m.size)
+
+      me = m._char_matrix(base_alg).to_quint.e_diagonalize
+      elem_divs = me.body.diag
+
+      facts = Algebra::ElementaryDivisor.factorize(elem_divs)
+      dl = facts.last
+      field, modulus, facts, roots, elms = dl.pi.decompose(dl)
+
+      pfield = Algebra.Polynomial(field, 'x')
+      pfm_alg = Algebra.SquareMatrix(pfield, m.size)
+
+      jm = Algebra::JordanForm.construct(elem_divs, facts, field, pfield)
+      jme = jm._char_matrix(pfm_alg).to_quint.e_diagonalize
+
+      mebody = pfm_alg.convert_from(me.body)
+      meright = pfm_alg.convert_from(me.right)
+      meleft = pfm_alg.convert_from(me.left)
+
+      sR = (meright * jme.righti).i2o.evaluateR(jm)
+      tL = (jme.lefti * meleft).i2o.evaluateL(jm)
+
+      [jm, tL, sR, field, modulus]
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  j = Algebra::JordanForm.new([[2, 3], [-1, 2]])
+  j.to_matrix.display
+end

data/lib/algebra/linear-algebra.rb

@@ -0,0 +1,143 @@
+# Linear Algebra
+#
+#   by Shin-ichiro Hara
+#
+# Version 1.00 (2001.11.01)
+
+require 'algebra/matrix-algebra'
+require 'algebra/gaussian-elimination'
+require 'algebra/polynomial'
+require 'algebra/polynomial-factor'
+require 'algebra/algebraic-equation'
+require 'algebra/jordan-form'
+
+module Algebra
+  module Orthogonalization
+    def orthogonalize
+      orth_basis = []
+      vectors.each_with_index do |b, i|
+        orth_basis.push b
+        next unless i > 0
+        orth_basis[0...i].each do |f|
+          orth_basis[i] -= b.inner_product(f) / f.norm2 * f
+          #	  orth_basis[i] = f.norm2*orth_basis[i] - b.inner_product(f)*f #also
+        end
+      end
+      self.class.collect_column { |j| orth_basis[j] }
+    end
+
+    def normalize
+      k = ground
+      orth_basis = []
+      vectors.each do |b|
+        k, n = Sqrt(k, b.norm2)
+        orth_basis.push Vector(k, size)**b / n
+      end
+      Algebra.SquareMatrix(k, size).collect_column { |j| orth_basis[j] }
+    end
+  end
+
+  class MatrixAlgebra
+    include Orthogonalization
+    # auto_req_init
+    # auto_req :e_diagonalize, "algebra/elementary-divisor"
+    # auto_req :elementary_divisor, "algebra/elementary-divisor"
+    require 'algebra/elementary-divisor'
+  end
+
+  class SquareMatrix < MatrixAlgebra
+    def self.symmetric(*a)
+      k = size * (size + 1) / 2
+      raise "the size of #{a.inspect} must be <= #{k}" if a.size > k
+      matrix do |i, j|
+        d = (i - j).abs
+        a[(i < j ? i : j) + (2 * size + 1 - d) * d / 2] || ground.zero
+      end
+    end
+
+    EigenSystem = Struct.new('EigenSystem',
+                             :extfield,
+                             :roots,
+                             :tmatrix,
+                             :evalues,
+                             :addelms,
+                             :evectors,
+                             :espaces,
+                             :chpoly,
+                             :facts)
+
+    def diagonalize
+      chp = char_polynomial(Algebra.Polynomial(ground, 't'))
+
+      facts = chp.factorize
+      mdf, mods, fas, roots, proots = chp.decompose(facts)
+      nu = Algebra.SquareMatrix(mdf, size)
+
+      espaces = {}
+      evalues = []
+      evectors = []
+      roots0 = []
+      k = 0
+      facts.each do |f, _n|
+        dim = f.deg
+        if dim <= 0 # 0 might be occurred
+          next
+        elsif dim == 1
+          evs = [-f[0] / f[1]]
+        else
+          evs = roots[k, dim] # .reverse
+          roots0.push [f, evs]
+        end
+        k += dim
+
+        evs.each do |evalue|
+          ks = nu.const(evalue) - self
+          kb = ks.kernel_basis
+          espaces[evalue] = kb
+
+          kb.each do |v|
+            evalues.push evalue
+            evectors.push v
+          end
+        end
+      end
+
+      raise "can't Diagonalize" if evalues.size < size
+      ttype = Algebra.SquareMatrix(mdf, size)
+      r = ttype.collect_column { |i| evectors[i] }
+      #    :extfield, :roots, :tmatrix, :evalues, :addelms, :evectors,
+      #                   :espaces, :chpoly, :facts
+      e = EigenSystem.new(mdf, roots0, r, evalues, proots, evectors,
+                          espaces, chp, facts)
+      def e.to_ary
+        to_a
+      end
+      e
+    end
+
+    def solve_eigen_value_problem
+      puts 'A = '; display; puts
+
+      e = diagonalize
+      puts "Charactoristic Poly.: #{e.chpoly} => #{e.facts}"; puts
+      puts 'Algebraic Numbers:'
+      e.roots.each do |po, rs|
+        puts "#{rs.join(', ')} : roots of #{po} == 0"
+      end; puts
+
+      puts 'EigenSpaces: '
+      e.evalues.uniq.each do |ev|
+        puts "W_{#{ev}} = <#{e.espaces[ev].join(', ')}>"
+      end; puts
+
+      puts 'Trans. Matrix:'
+      puts 'P ='
+      e.tmatrix.display; puts
+
+      puts 'P^-1 * A * P = '; (e.tmatrix.inverse * self * e.tmatrix).display; puts
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+end

data/lib/algebra/localized-ring.rb

@@ -0,0 +1,294 @@
+# Localization of Ring
+#
+#   by Shin-ichiro Hara
+#
+# Version 1.1 (2001.04.10)
+
+require 'algebra/euclidian-ring'
+require 'algebra/algebraic-system'
+
+module Algebra
+  def LocalizedRing(ring)
+    LocalizedRing.create(ring)
+  end
+
+  def RationalFunctionField(field, obj)
+    require 'algebra/polynomial'
+    k = LocalizedRing(Polynomial(field, obj))
+    def k.var
+      self[ground.var]
+    end
+
+    def k.to_ary
+      [self, var]
+    end
+    k
+  end
+
+  def MRationalFunctionField(field, *objs)
+    require 'algebra/m-polynomial'
+    k = LocalizedRing(MPolynomial(field, *objs))
+    def k.vars(*vs)
+      ground.vars(*vs).map { |v| self[v] }
+    end
+
+    def k.to_ary
+      [self, *vars]
+    end
+    k.reducible = false
+    k
+  end
+
+  module_function :LocalizedRing, :RationalFunctionField, :MRationalFunctionField
+
+  class LocalizedRing
+    extend AlgebraCreator
+    include AlgebraBase
+
+    def self.create(ground)
+      klass = super(ground)
+      klass.sysvar(:reducible, true)
+      klass
+    end
+
+    def self.reducible
+      @@reducible
+    end
+
+    def self.reducible=(sw)
+      @@reducible = sw
+    end
+
+    attr_reader :numerator
+    attr_reader :denominator
+
+    def monomial?
+      true
+    end
+
+    def self.[](num, den = nil)
+      den ? reduce(num, den) : unity * num
+    end
+
+    def self.reduce(num, den)
+      reducible ? simplify(num, den) : new(num, den)
+    end
+
+    def self.simplify(num, den)
+      raise ZeroDivisionError, 'denometor is 0' if den.zero?
+      return zero if num.zero?
+
+      if ground.field?
+        num /= den
+        den = ground.unit
+      elsif ground.ufd? # ground.euclidian?
+        gcd = num.gcd(den)
+        num /= gcd
+        den /= gcd
+        #      num = num.div(gcd)
+        #      den = den.div(gcd)
+      end
+
+      # regulate the leading coefficient of polynomil
+      if defined?(Polynomial) && ground <= Polynomial
+        if ground.ground.field?
+          m = den.lc
+          num /= m
+          den /= m
+        elsif ground.ground.euclidian? # high cost!
+          m = num.cont.gcd(den.cont)
+          num /= m
+          den /= m
+        end
+        #    elsif defined?(MPolynomial) && ground <= MPolynomial
+      end
+
+      #    if den.respond_to?(:<) and den < 0
+      #      num = -num
+      #      den = -den
+      #    end
+      new(num, den)
+    end
+
+    def initialize(num, den = ground.unity)
+      if den.respond_to?(:<=>) && den < ground.zero
+        num = -num
+        den = -den
+      end
+      @numerator = num
+      @denominator = den
+    end
+
+    def simplify
+      self.class.simplify(@numerator, @denominator)
+    end
+
+    def ==(o)
+      super do |o|
+        @numerator * o.denominator == o.numerator * @denominator
+      end
+    end
+
+    def +(o)
+      super do |o|
+        num = @numerator * o.denominator
+        num_o = o.numerator * @denominator
+        self.class.reduce(num + num_o, @denominator * o.denominator)
+      end
+    end
+
+    def -(o)
+      super do |o|
+        num = @numerator * o.denominator
+        num_o = o.numerator * @denominator
+        self.class.reduce(num - num_o, @denominator * o.denominator)
+      end
+    end
+
+    def *(o)
+      super do |o|
+        num = @numerator * o.numerator
+        den = @denominator * o.denominator
+        self.class.reduce(num, den)
+      end
+    end
+
+    def /(o)
+      raise ZeroDivisionError, 'devided by 0' if o.zero?
+      super do |o|
+        num = @numerator * o.denominator
+        den = @denominator * o.numerator
+        self.class.reduce(num, den)
+      end
+    end
+
+    def unit?
+      !zero? # some about
+    end
+
+    def pdivmod(other)
+      [self / other, zero]
+    end
+
+    #  def % (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 can not divide #@numerator mod #{o}" unless r.zero?
+    #    q
+    #  end
+
+    def **(other)
+      case other
+      when Integer
+        if other > 0
+          num = @numerator**other
+          den = @denominator**other
+          self.class.new(num, den)
+        elsif other < 0
+          num = @denominator**-other
+          den = @numerator**-other
+          self.class.new(num, den)
+        elsif other.zero?
+          unity
+        end
+      else
+        x, y = other.coerce(self)
+        x**y
+      end
+    end
+
+    def need_paren_in_coeff?
+      if @denominator.unity?
+        if @numerator.respond_to?(:need_paren_in_coeff?)
+          @numerator.need_paren_in_coeff?
+        elsif @numerator.is_a?(Numeric)
+          false
+        else
+          true
+        end
+      else
+        false
+      end
+    end
+
+    def to_s
+      n = if @numerator.respond_to?(:need_paren_in_coeff?) &&
+             @numerator.need_paren_in_coeff? &&
+             !@denominator.unity?
+            "(#{@numerator})"
+          else
+            @numerator.to_s
+          end
+      d = if @denominator.respond_to?(:need_paren_in_coeff?) &&
+             @denominator.need_paren_in_coeff? &&
+             !@denominator.is_a?(Integer)
+            "(#{@denominator})"
+          else
+            @denominator.to_s
+          end
+      if @denominator.unity?
+        n.to_s
+      else
+        n + '/' + d
+      end
+    end
+
+    def inspect
+      to_s
+      #    sprintf("%s(%s/%s)", self.class, @numerator.inspect, @denominator.inspect)
+    end
+
+    def hash
+      raise 'hash is undefined'
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  require 'algebra/polynomial'
+  require 'algebra/rational'
+  require 'algebra/residue-class-ring'
+  include Algebra
+
+  Q = LocalizedRing(Integer)
+  a = Q.new(3, 5)
+  b = Q.new(5, 3)
+  p [a + b, a - b, a * b, a / b, a + 3, 1 + a]
+
+  Z13 = ResidueClassRing(Integer, 13)
+
+  Z13x = Polynomial(Z13, 'x')
+  x = Z13x.var
+  QZ13x = LocalizedRing(Z13x)
+  a = QZ13x[x**2 + x + 1, x**2 - 1]
+  b = QZ13x[x + 1, x**2 + 3 * x + 2]
+  p a + b
+  p((a + b)**4)
+  puts
+
+  Rx = Polynomial(Rational, 'x')
+  #  Rx = Polynomial(Z13, "x")
+  x = Rx.var
+  QRx = LocalizedRing(Rx)
+  x = QRx[x]
+  a = (x**2 + 1) / (x**3 + x + 1)
+  QRxy = Polynomial(QRx, 'y')
+  y = QRxy.var
+  AFF = ResidueClassRing(QRxy, y**3 + a * y + 1)
+  y = AFF[y]
+  p((y + x)**3)
+
+  F = RationalFunctionField(Rational, 'x')
+  x = F.var
+  p ( 1 / (x**2 - 1) - 1 / (x**3 - 1))
+
+  require 'algebra/mathn'
+  require 'algebra/algebraic-extension-field'
+  S = AlgebraicExtensionField(Rational, 'a') { |a| a**2 - 2 }
+  QSx = RationalFunctionField(S, 'x')
+  x = QSx.var
+  a = S.var
+  p((a / 4 * x + 1 / 2) / (x**2 + a * x + 1) + (-a / 4 * x + 1 / 2) / (x**2 - a * x + 1))
+end