algebra 0.2.1

data/lib/algebra/matrix-algebra-triplet.rb

@@ -0,0 +1,292 @@
+# Matrix Algebra Triplet
+#
+#   by Shin-ichiro Hara
+#
+# Version 1.0 (2001.11.01)
+
+require 'algebra/gaussian-elimination'
+require 'algebra/elementary-divisor'
+
+module Algebra
+  class MatrixAlgebra
+    def to_triplet
+      Algebra::MatrixAlgebraTriplet.new(self)
+    end
+
+    def to_quint
+      Algebra::MatrixAlgebraQuint.new(self)
+    end
+  end
+
+  class MatrixAlgebraTriplet
+    include GaussianElimination
+    include ElementaryDivisor
+
+    attr_reader :left, :body, :right, :ground
+    def initialize(matrix, left = nil, right = nil)
+      @body = matrix
+      @type = @body.class
+      @ground = @type.ground
+      @left_type = Algebra.SquareMatrix(@type.ground, @type.rsize)
+      @right_type = Algebra.SquareMatrix(@type.ground, @type.csize)
+      @left = left ? left : @left_type.unity
+      @right = right ? right : @right_type.unity
+    end
+
+    def to_ary
+      [body, left, right]
+    end
+
+    alias to_a to_ary
+
+    def dup
+      self.class.new(body.dup, left.dup, right.dup)
+    end
+
+    def transpose
+      self.class.new(body.transpose, right.transpose, left.transpose)
+    end
+
+    def replace(other)
+      initialize(other.body, other.left, other.right)
+      self
+    end
+
+    def display
+      puts '============= begin'
+      @left.display
+      puts
+      @body.display
+      puts
+      @right.display
+      puts '============= end'
+    end
+
+    def [](i, j)
+      @body[i, j]
+    end
+
+    def rsize
+      @body.rsize
+    end
+
+    def csize
+      @body.csize
+    end
+
+    def each_i(&block)
+      @body.each_i(&block)
+    end
+
+    def each_j(&block)
+      @body.each_j(&block)
+    end
+
+    def row!(i)
+      @body.row!(i)
+    end
+
+    # ElementaryOpeartion
+    def sswap_r!(i, j)
+      @left.sswap_r!(i, j)
+      @body.sswap_r!(i, j)
+      self
+    end
+
+    def swap_r!(i, j)
+      @left.swap_r!(i, j)
+      @body.swap_r!(i, j)
+      self
+    end
+
+    #  def swap_r(i, j)
+    #    dup.swap_r!(i, j)
+    #  end
+
+    def swap_c!(i, j)
+      @body.swap_c!(i, j)
+      @right.swap_c!(i, j)
+      self
+    end
+
+    #  def swap_c(i, j)
+    #    dup.swap_c!(i, j)
+    #  end
+
+    def multiply_r!(i, c)
+      @left.multiply_r!(i, c)
+      @body.multiply_r!(i, c)
+      self
+    end
+
+    #  def multiply_r(i, c)
+    #    dup.multiply_r!(i, c)
+    #  end
+
+    def multiply_c!(j, c)
+      @body.multiply_c!(j, c)
+      @right.multiply_c!(j, c)
+      self
+    end
+
+    #  def multiply_c(j, c)
+    #    dup.multiply_c!(j, c)
+    #  end
+
+    def divide_r!(i, c)
+      @left.divide_r!(i, c)
+      @body.divide_r!(i, c)
+    end
+
+    #  def divide_r(i, c)
+    #    dup.divide_r!(i, c)
+    #  end
+
+    def divide_c!(j, c)
+      @body.divide_c!(j, c)
+      @right.divide_c!(j, c)
+    end
+
+    #  def divide_c(j, c)
+    #    dup.divide_c!(j, c)
+    #  end
+
+    def mix_r!(i, j, c = nil)
+      @left.mix_r!(i, j, c)
+      @body.mix_r!(i, j, c)
+      self
+    end
+
+    #  def mix_r(i, j, c = nil)
+    #    dup.mix_r!(i, j, c)
+    #  end
+
+    def mix_c!(i, j, c = nil)
+      @body.mix_c!(i, j, c)
+      @right.mix_c!(i, j, c)
+      self
+    end
+
+    #  def mix_c(i, j, c = nil)
+    #    dup.mix_c!(i, j, c)
+    #  end
+
+    def left_eliminate!
+      #    inv = Algebra.SquareMatrix(ground, rsize).unity
+      k = ground.unity
+      pi = 0
+      each_j do |j|
+        next unless i = (pi...rsize).find { |i1| !self[i1, j].zero? }
+        if i != pi
+          swap_r!(pi, i) # ; inv.swap_r!(pi, i)
+          k = -k
+        end
+        c = ground.unity / self[pi, j] # this lets the entries be in ground
+        multiply_r!(pi, c) # ; inv.multiply_r!(pi, c)
+        k *= c
+        each_i do |i0|
+          next if i0 == pi
+          d = self[i0, j] # / self[pi, j]
+          mix_r!(i0, pi, -d) # ; inv.mix_r!(i0, pi, -d)
+        end
+        pi += 1
+      end
+      [left, k]
+    end
+  end
+
+  class MatrixAlgebraQuint < MatrixAlgebraTriplet
+    attr_reader :lefti, :righti
+    def initialize(matrix, left = nil, right = nil, lefti = nil, righti = nil)
+      super(matrix, left, right)
+      @lefti = lefti ? lefti : @left_type.unity
+      @righti = righti ? righti : @right_type.unity
+    end
+
+    def to_ary
+      [body, left, right, lefti, righti]
+    end
+
+    alias to_a to_ary
+
+    def dup
+      self.class.new(body.dup, left.dup, right.dup, lefti.dup, righti.dup)
+    end
+
+    def transpose
+      self.class.new(body.transpose, right.transpose, left.transpose,
+                     righti.transpose, lefti.transpose)
+    end
+
+    def replace(other)
+      initialize(other.body, other.left, other.right, other.lefti, other.righti)
+      self
+    end
+
+    # ElementaryOpeartion
+    def sswap_r!(i, j)
+      @lefti.swap_c!(i, j) # sswap_c doesn't exist
+      super
+    end
+
+    def swap_r!(i, j)
+      @lefti.swap_c!(i, j)
+      super
+    end
+
+    def swap_c!(i, j)
+      @righti.swap_r!(i, j)
+      super
+    end
+
+    def multiply_r!(i, c)
+      @lefti.divide_c!(i, c)
+      super
+    end
+
+    def multiply_c!(j, c)
+      @righti.divide_r!(j, c)
+      super
+    end
+
+    def divide_r!(i, c)
+      @lefti.multiply_c!(i, c)
+      super
+    end
+
+    def divide_c!(j, c)
+      @righti.multiply_r!(j, c)
+      super
+    end
+
+    def mix_r!(i, j, c = nil)
+      @lefti.mix_c!(j, i, c ? -c : -1)
+      super
+    end
+
+    def mix_c!(i, j, c = nil)
+      @righti.mix_r!(j, i, c ? -c : -1)
+      super
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  require 'algebra/m-polynomial'
+  require 'algebra/polynomial'
+  require 'algebra/rational'
+  require 'algebra/matrix-algebra'
+  #  class Rational# < Numeric
+  #    def inspect; to_s; end
+  #  end
+  #  include Algebra
+
+  G = Algebra.MatrixAlgebra(Rational, 2, 2)
+  a = G[[1, 1], [1, -1]]
+  a0 = Algebra::MatrixAlgebraTriplet.new(a)
+  a0.display
+  a0.left_eliminate!
+  puts '-------'
+  a0.display
+  #  p a.kernel_basis
+end

data/lib/algebra/matrix-algebra.rb

@@ -0,0 +1,929 @@
+# MatrixAlgebra over Ring
+#
+#   by Shin-ichiro Hara
+#
+# Version 1.05 (2003.06.24)
+
+require "algebra/algebraic-system"
+require "algebra/gaussian-elimination"
+
+module Enumerable
+  def collecti
+    a = []
+    each_with_index do |x, i|
+      a.push yield(x, i)
+    end
+    a
+  end
+
+  def sum(z)
+    sum = z
+    each do |i|
+      sum += yield(i)
+    end
+    sum
+  end
+end
+
+module Algebra
+def MatrixAlgebra(ground, rsize, csize)
+  MatrixAlgebra.create(ground, rsize, csize)
+end
+
+def SquareMatrix(ground, size)
+  SquareMatrix.create(ground, size)
+end
+
+def Vector(ground, size)
+  Vector.create(ground, size)
+end
+
+def Covector(ground, size)
+  Covector.create(ground, size)
+end
+module_function :MatrixAlgebra, :SquareMatrix, :Vector, :Covector
+
+class MatrixAlgebra
+  extend AlgebraCreator
+  include AlgebraBase
+  include Enumerable
+  auto_req_init
+  auto_req :solve_eigen_value_problem, "algebra/linear-algebra"
+  auto_req :diagonalize, "algebra/linear-algebra"
+  auto_req :to_triplet, "algebra/matrix-algebra-triplet"
+  auto_req :to_quint, "algebra/matrix-algebra-triplet"
+  auto_req :e_inverse, "algebra/elementary-divisor"
+  auto_req :elementary_divisor, "algebra/elementary-divisor"
+  auto_req :e_diagonalize, "algebra/elementary-divisor"
+  auto_req :e_diagonalize!, "algebra/elementary-divisor"
+  autoload :JordanForm, "algebra/jordan-form"
+  auto_req :jordan_form, "algebra/jordan-form"
+  auto_req :jordan_form_info, "algebra/jordan-form"
+  # require 'algebra/linear-algebra'
+  # require 'algebra/matrix-algebra-triplet'
+  # require 'algebra/elementary-divisor'
+  # require 'algebra/jordan-form'
+
+  Matrices = {}
+
+  def initialize(array, conv = false)
+    raise "rsize error (#{array.size} for #{rsize})" if array.size != rsize
+    array.each do |v|
+      raise "csize error (#{v.size} for #{csize})" if v.size != csize
+    end
+    if conv
+      @bone = array.collect{|cv| cv.collect{|x|
+          ground.regulate(x) or
+            raise "initialize: unknown type #{x.class} (#{x})"
+        }}
+    else
+      @bone = array
+    end
+  end
+
+  def dup
+#    matrix{|x| self[* x.collect{|y| y.dup}]}
+#    matrix{|x| self[* x.collect{|y| y}]} #in 1.8.0, Integer can't be dup..
+    matrix{|i, j| self[i, j]} #in 1.8.0, Integer can't be dup..
+  end
+
+  def replace(m)
+    if m.is_a?(self.class) and sizes == m.sizes
+      each_index do |i, j|
+	@bone[i][j] = m[i, j]
+      end
+    else
+      raise "Type Error #{m.class}"
+    end
+  end
+
+  def simplify; matrix{|i, j| self[i, j].simplify}; end
+
+  def self.matrices; Matrices; end
+
+  def self.[](*a)
+     new(a, true)
+  end
+
+  ############################################
+  #
+  # matrix type conversion
+  #
+  #############################################
+
+  def self.*(otype)
+    if csize != otype.rsize
+      raise "type error (#{self} * #{otype}, #{csize}:#{otype.rsize})"
+    end
+
+    if ground.respond_to?(:wedge)
+      g = ground.wedge otype.ground
+    elsif ground <= Numeric
+      g = otype.ground
+    else
+      raise "*: unkown type conversion (#{ground}) * (#{oground})"
+    end
+
+    if otype <= Vector
+      Algebra::Vector.create(g, rsize)
+    elsif self <= Covector
+      Algebra::Covector.create(g, csize)
+    elsif rsize == otype.csize
+      SquareMatrix.create(g, rsize)
+    else
+      MatrixAlgebra.create(g, rsize, otype.csize)
+    end
+  end
+
+#  def self.vector_type
+#    Algebra::Vector.create(ground, rsize)
+#  end
+
+#  def self.covector_type
+#    Algebra::Covector.create(ground, csize)
+#  end
+
+  def self.minor
+    if self <= SquareMatrix
+      superclass.create(ground, size-1)
+    elsif self <= MatrixAlgebra
+      superclass.create(ground, rsize-1, csize-1)
+    else
+      raise "minor: unknown type #{self.class}"
+    end
+  end
+
+  def self.dsum(otype)
+    #unless ground == otype.ground
+    #  raise "type error #{ground}.dsum #{otype.ground}"
+    #end
+    if self <= SquareMatrix and otype <= SquareMatrix
+      superclass.create(ground, size + otype.size)
+    else
+      superclass.create(ground, rsize + otype.rsize, csize + otype.csize)
+    end
+  end
+
+  def self.dsum_r(otype); raise "not implemented"; end
+
+  def self.dsum_c(otype); raise "not implemented"; end
+
+  ################################
+
+
+#  def [](i, j = nil)
+#    j ? @bone[i][j] : @bone[i]
+#  end
+
+  def [](i, j)
+    @bone[i][j]
+  end
+
+  def []=(i, j, x)
+    @bone[i][j] = x
+  end
+
+  def rows
+    (0...rsize).collect{|i| row(i)}
+  end
+
+  def row(i)
+    raise "size error" unless 0 <= i && i < rsize
+    @bone[i].clone
+  end
+
+  def row!(i) # column!(j) is not defined!
+    raise "size error" unless 0 <= i && i < rsize
+    @bone[i]
+  end
+
+  def set_row(i, array)
+    raise "size error" unless 0 <= i && i < rsize
+    raise "size error" unless csize == array.size
+    @bone[i] = array
+    self
+  end
+
+  def columns
+    (0...csize).collect{|j| column(j)}
+  end
+
+  def vectors
+#    vc = self.class.vector_type
+    vc = Algebra::Vector.create(ground, rsize)
+    columns.collect{|v| vc[*v]}
+  end
+
+  def column(j)
+    raise "size error" unless 0 <= j && j < csize
+    (0...rsize).collect{|i| @bone[i][j]}
+  end
+
+  def set_column(j, array)
+    raise "size error" unless 0 <= j && j < csize
+    raise "size error" unless rsize == array.size
+    (0...rsize).each{|i| @bone[i][j] = array[i]}
+    self
+  end
+
+
+  def sizes; self.class.sizes; end
+  def rsize; self.class.rsize; end
+  def csize; self.class.csize; end
+
+  def self.create(ground, rsize, csize)
+    if klass = matrices[[ground, rsize, csize]] #flyweight
+      klass
+    else
+      klass = super(ground)
+      klass.sysvar(:sizes, [rsize, csize])
+      klass.sysvar(:rsize, rsize)
+      klass.sysvar(:csize, csize)
+      matrices[[ground, rsize, csize]] = klass
+      klass
+    end
+  end
+
+  def self.transpose
+    if sizes == [csize, rsize]
+      self
+    else
+      superclass.create(ground, csize, rsize)
+    end
+  end
+
+  def to_s
+    @bone.inspect
+  end
+
+  def display(out = $stdout)
+    @bone.each do |col|
+#      out << col.inspect << "\n"
+      first = true
+      col.each do |x|
+	if first
+	  first = false
+	else
+	  out << ", "
+	end
+	out << sprintf("%3s", x)
+      end
+      out << "\n"
+    end
+    out
+  end
+
+  def display_by_latex(out = $stdout)
+#    out << "\\left(\n"
+#    out "\\begin{array}{" + "c" * @bone[0].size + "}\n"
+    @bone.each do |col|
+#      out << col.inspect << "\n"
+      first = true
+      col.each do |x|
+	if first
+	  first = false
+	else
+	  out << " & "
+	end
+	out << sprintf("%3s", x)
+      end
+      out << "\\\\\n"
+    end
+#    out << "\\end{array}"
+#    out << "\\right)"
+    out
+  end
+
+  def latex(env = "pmatrix")
+    s = ""
+    s << "\\begin{#{env}}\n" if env
+    s << display_by_latex("")
+    s << "\\end{#{env}}\n" if env
+    s
+  end
+
+  def inspect
+    "#{self.class}#{to_s}"
+  end
+
+  #check entries
+  def types
+    matrix{|i, j| self[i, j].class}
+  end
+
+  def self.zero
+#    new((0...rsize).collect{(0...csize).collect{ground.zero}})
+    matrix{ground.zero}
+  end
+
+  def self.regulate(x)
+    case x
+    when Vector, Covector, MatrixAlgebra #,SquareMatrix
+      x
+    else
+      nil
+    end
+  end
+
+  def coerce(other)#MatrixAlgebra
+    if x = ground.regulate(other)
+      [Algebra::Scalar.new(x), self]
+    else
+      super
+    end
+  end
+
+  def each(&b)
+    @bone.each(&b)
+  end
+
+  def self.each_index
+    (0...rsize).each do |i|
+      (0...csize).each do |j|
+	yield i, j
+      end
+    end
+  end
+
+  class << self
+    alias each_ij each_index
+  end
+
+  def each_index(&b)
+    self.class.each_index(&b)
+  end
+
+  alias each_ij each_index
+
+  def each_i
+    (0...rsize).each do |i|
+      yield i
+    end
+  end
+
+  def each_j
+    (0...csize).each do |j|
+      yield j
+    end
+  end
+
+  def each_row
+    (0...rsize).each do |i|
+      yield row(i)
+    end
+  end
+
+  def each_column
+    (0...rsize).each do |i|
+      yield column(i)
+    end
+  end
+
+  def ==(other)
+    super{ |o|
+      rais "type error" unless sizes == o.sizes
+      each_index do |i, j|
+	return false unless self[i, j] == o[i, j]
+      end
+      true
+    }
+  end
+
+  def self.collect_ij(m = rsize, n = csize)
+    (0...m).collect do |i|
+      (0...n).collect do |j|
+	yield(i, j)
+      end
+    end
+  end
+
+  def collect_ij(*x, &b); self.class.collect_ij(*x, &b); end
+
+  def self.matrix(m = rsize, n = csize)
+    new(collect_ij(m, n) {|i, j| yield i, j})
+  end
+
+  def matrix(m = rsize, n = csize)
+    self.class.matrix(m, n){|i, j| yield i, j}
+  end
+
+  def minor(i, j)
+    self.class.minor.matrix{|a, b|
+      self[a < i ? a : a+1, b < j ? b : b+1]
+    }
+  end
+
+  def cofactor(i, j)
+    minor(i, j).determinant * (-1)**(i+j)
+  end
+
+  def cofactor_matrix
+    self.transpose.matrix{|i, j| cofactor(j, i)}
+  end
+
+  alias adjoint cofactor_matrix
+
+  def self.collect_row(m = rsize)
+    new((0...m).collect{|i| yield i})
+  end
+
+  def collect_row(m = rsize)
+    self.class.collect_row(m){|i| yield i}
+  end
+
+  def self.collect_column(n = csize)
+    columns = (0...n).collect{|j| yield j}
+    matrix{|i, j| columns[j][i]}
+  end
+
+  def collect_column(n = csize)
+    self.class.collect_columns(n){|j| yield j}
+  end
+
+  def +(other)
+    super{ |o|
+      raise "type error" unless sizes == o.sizes
+      matrix{|i, j| self[i, j] + o[i, j]}
+    }
+  end
+
+  def -(other)
+    super{ |o|
+      raise "type error" unless sizes == o.sizes
+      matrix{|i, j| self[i, j] - o[i, j]}
+    }
+  end
+
+  def old_mul(other)
+    #without regulation
+    case other
+    when ground, Numeric # 1.is_a?(Rational) is false
+      matrix{|i, j| self[i, j]*other}
+    else
+      super{|o|
+        msize = csize
+        raise "type error" unless msize == o.rsize
+        (self.class * o.class).matrix(rsize, o.csize){|i, j|
+          (0...msize).sum(ground.zero){|k| self[i, k] * o[k, j]}
+        }
+      }
+    end
+  end
+
+  def *(other)
+    #without regulation!
+    if other.is_a?(ground) || other.is_a?(Numeric)#1.is_a?(Rational) is false
+      matrix{|i, j| self[i, j]*other}
+    elsif self.is_a?(other.ground)
+      other.matrix{|i, j| self*other[i, j]}
+    else
+      super{|o|
+        msize = csize
+        raise "type error" unless msize == o.rsize
+        (self.class * o.class).matrix(rsize, o.csize){|i, j|
+          (0...msize).sum(ground.zero){|k| self[i, k] * o[k, j]}
+        }
+      }
+    end
+  end
+
+  def /(other)
+    case other
+    when ground, Numeric
+      matrix{|i, j| self[i, j] / other}
+    else
+      raise "(/): unknown type #{other.class}"
+    end
+  end
+
+  def map
+    matrix{|i, j| yield(self[i, j])}
+  end
+
+  def transpose
+    self.class.transpose.matrix(csize, rsize){|i, j| self[j, i]}
+  end
+
+  alias t transpose
+
+  def dsum(other)
+    mytype = self.class.dsum(other.class)
+    mytype.matrix{|i, j|
+      if i < rsize
+	if j < csize
+	  self[i, j]
+	else
+	  other.ground.zero
+	end
+      else
+	if j < csize
+	  ground.zero
+	else
+	  other[i - rsize, j - csize]
+	end
+      end
+    }
+  end
+
+  def to_ary
+    to_a
+  end
+
+  def flatten
+    #'to_a' is defined in Enumerable
+    to_a.flatten
+  end
+
+  def diag
+    ed = []
+    size = rsize < csize ? rsize : csize
+    (0...size).each do |i|
+      break if self[i, i].zero?
+      ed.push self[i, i]
+      end
+    ed
+  end
+
+  def convert_to(mat_alg)
+    mat_alg.matrix{|i, j| mat_alg.ground.regulate(self[i, j])}
+  end
+
+  def self.convert_from(m)
+    matrix{|i, j| m[i, j].convert_to(ground)}
+  end
+
+  def self.**(m)
+    m.convert_to(self)
+  end
+end
+
+module InnerProductSpace
+  def inner_product(other)
+    ip = defined?(ground) ? ground.zero : first.zero
+    each_with_index do |x, i|
+      ip += x * other[i]
+    end
+    ip
+  end
+
+  def inner_product_complex(other)
+    inner_product(other.conjugate)
+  end
+
+  def norm2
+    inner_product(self)
+  end
+
+  def norm2_complex
+    inner_product_complex(self)
+  end
+end
+
+class Vector < MatrixAlgebra
+  include InnerProductSpace
+
+  Matrices = {}
+
+  def initialize(array, conv = false)
+    @bone0 = array
+    super(array.collect{|x| [x]}, conv)
+  end
+
+  def each
+    @bone0.each do |x|
+      yield x
+    end
+  end
+
+  def size; self.class.size; end
+
+  #def to_a
+  #  column(0)
+  #end
+
+  def [](*x)
+    case x.size
+    when 1
+      super(x[0], 0)
+    when 2
+      super(*x)
+    else
+      raise "size of index be 1 or 2"
+    end
+  end
+
+  def self.create(ground, n)
+    klass = super(ground, n, 1)
+    klass.sysvar(:size, n)
+    klass
+  end
+
+  def transpose
+    Algebra::Covector.create(ground, size).new(to_a)
+  end
+
+  def self.vector(conv = false, &b)
+    new((0...size).collect(&b), conv)
+  end
+
+  def self.[](*a)
+    vector(true){|i| a[i]}
+  end
+
+  def self.matrix(r = size, s = 1)
+    vector{|i| yield(i, 0)}
+  end
+
+  def inspect
+    @bone0.inspect
+  end
+
+  def to_s
+    @bone0.inspect
+  end
+end
+
+class Covector < MatrixAlgebra
+  include InnerProductSpace
+
+  Matrices = {}
+
+  def initialize(array, conv = false)
+    @bone0 = array
+    super([array], conv)
+  end
+
+  def each
+    @bone0.each do |x|
+      yield x
+    end
+  end
+
+  def size; self.class.size; end
+
+  #    def to_a
+  #      row(0)
+  #    end
+
+  def [](*x)
+    case x.size
+    when 1; super(0, x[0])
+    when 2; super(*x)
+    else
+      raise "size of index be 1 or 2"
+    end
+  end
+
+  def self.create(ground, n)
+    klass = super(ground, 1, n)
+    klass.sysvar(:size, n)
+    klass
+  end
+
+  def transpose
+    Algebra::Vector.create(ground, size).new(to_a)
+  end
+
+  def self.[](*a)
+    covector(true){|i| a[i]}
+  end
+
+  def self.covector(conv = false, &b)
+    new((0...size).collect(&b), true)
+  end
+
+  def self.matrix(r = 1, s = size)
+    covector{|j| yield(0, j)}
+  end
+
+  def inspect
+    @bone0.inspect
+  end
+
+  def to_s
+    super
+  end
+end
+
+class SquareMatrix < MatrixAlgebra
+  Matrices = {}
+
+  def self.unity
+    matrix{|i, j| i == j ? ground.unity : ground.zero }
+  end
+
+  def self.const(x)
+    matrix{|i, j| i == j ? ground.regulate(x) : ground.zero }
+  end
+
+  def const(x)
+    self.class.const(x)
+  end
+
+  def self.matrices
+    Matrices
+  end
+
+  def initialzie(array, conv = false)
+    super
+  end
+
+  def self.create(ground, n, m = nil)
+    if m && n != m
+      raise "type error to create SquareMatrix"
+    end
+    klass = super(ground, n, n)
+    klass.sysvar(:size, n)
+    klass
+  end
+
+  def size; self.class.size; end
+
+  def self.regulate(x)
+    if x.is_a? superclass #SquareMatrix
+      x
+    elsif y = ground.regulate(x)
+      const(y)
+    else
+      super
+    end
+  end
+
+  def self.determinant(aa)
+    r = create(Integer, aa.size)
+    m = r.new(aa)
+    m.determinant
+  end
+
+  class << self
+    alias det determinant
+  end
+
+  def /(other)
+    #It might be better to use regulate ...
+    case other
+#    when ground, Numeric
+#      matrix{|i, j| self[i, j] / other}
+    when self.class.superclass #SquareMatrix
+      self * other.inverse
+    else
+      super
+    end
+  end
+
+  def determinant
+    sum = ground.zero
+    perm do |idx|
+      product = ground.unity
+      idx.each_with_index do |i, j|
+	product *= self[i, j]
+      end
+      sum += product * sign(idx)
+    end
+    sum
+  end
+
+  alias determinant! determinant
+  alias det determinant
+
+  def inverse
+    #gaussian-elimination.rb
+    if ground.field? &&
+        (!ground.respond_to?(:reducible) || ground.reducible)
+      inverse_field
+    else
+      a = adjoint
+      d = determinant
+      unless d.unit?
+        warn("#{a}/#{d} may not be done.")
+      end
+      a / d
+    end
+  end
+
+  def sign(a)
+    n = a.size
+    a = a.dup
+    b = (0...n).collect{|i| a.index(i)}
+    s = 1
+    (0...(n-1)).each do |i|
+      if (j = a[i]) != i
+	a[b[i]], b[j], s = j, b[i], -s
+      end
+    end
+    s
+  end
+
+  def perm(n = size, stack = [])
+    (0...n).each do |x|
+      unless stack.include? x
+	stack.push x
+	if stack.size < n
+	  perm(n, stack) do |y|; yield y; end
+	else
+	  yield stack
+	end
+	stack.pop
+      end
+    end
+  end
+
+  def char_polynomial0(obj = "x")
+    require "algebra/polynomial"
+    a = Algebra.Polynomial(ground, obj)
+    k = Algebra.SquareMatrix(a, size)
+    (k.unity * a.var - self).determinant
+    #    (k.unity * a.var - k.matrix{|i, j| self[i,j]}).determinant
+  end
+
+  def _char_matrix(mop)
+    # assume mop.ground.ground == self.ground
+    mop.unity * mop.ground.var - self
+  end
+
+  def char_matrix(polyring)
+    matrix_over_poly = Algebra.SquareMatrix(polyring, size)
+    _char_matrix(matrix_over_poly)
+  end
+
+  def char_polynomial(polyring)
+    matrix_over_poly = Algebra.SquareMatrix(polyring, size)
+    _char_matrix(matrix_over_poly).determinant
+  end
+end
+
+class Scalar # fake class for SCALAR * MATRIX
+  def initialize(x)
+    @value = x
+  end
+
+  def +(other)
+    case other
+    when Algebra::SquareMatrix
+      other.const(@value) + other
+    else
+      raise "Fail: Scalar(#{@value}) + #{other}"
+    end
+  end
+
+  def -(other)
+    case other
+    when Algebra::SquareMatrix
+      other.const(@value) - other
+    else
+      raise "Fail: Scalar(#{@value}) - #{other}"
+    end
+  end
+
+  def *(other)
+    case other
+    when Algebra::MatrixAlgebra
+      other.matrix{|i, j| @value * other[i, j]}
+    else
+      raise "Fail: Scalar(#{@value}) * #{other}"
+    end
+  end
+end
+end
+
+if $0 == __FILE__
+#  include Algebra
+  M33 = Algebra.MatrixAlgebra(Integer, 3, 3)
+  M34 = Algebra.MatrixAlgebra(Integer, 3, 4)
+  a33 = [
+    [1, 1, 2],
+    [3, 4, 5],
+    [6, 7, 8]
+  ]
+  m0 = M33.new(a33)
+  m0[0, 0] = 0
+  m1 = M33[
+    [10, 11, 12],
+    [13, 14, 15],
+    [16, 17, 18]]
+  m2 = M34[[20, 21, 22, 23], [24, 25, 26, 27], [28, 29, 30, 31]]
+  p m0 + m1
+  p m0 * m0
+  p( (m0 * m0).t )
+  # m = m0 * m2
+  M43 = M34.transpose
+  p M34.sizes
+  p M43.sizes
+  M44 = M43 * M34
+  p m2.t * m2
+  p m0.dsum(m1).display
+
+
+  require "algebra/rational"
+
+  M3 = Algebra.SquareMatrix(Rational, 3)
+  # m3 = M3[
+  #   [0, 1, 2],
+  #   [3, 4, 5],
+  #   [6, 7, 8]]
+
+#  require "algebra/polynomial"
+#  Px =  Algebra.Polynomial(Rational, "x")
+#  require "algebra/polynomial"
+#  p f = m3.char_polynomial(Px)
+end