rdx 0.9.0.pre

data/examples/ruby-2.0.0-p0/install/stdlib/diffs/lib/mathn.rb.diff

@@ -0,0 +1,58 @@
+--- stdlib/orig/lib/mathn.rb	2015-06-11 07:51:45 +0000
++++ stdlib/patched/lib/mathn.rb	2015-06-25 15:53:50 +0000
+@@ -10,16 +10,18 @@
+ # operations, then mathn is the right tool.
+ #
+ # Without mathn:
++# :rdx: before_require
+ #
+-#   3 / 2 => 1 # Integer
++#   3 / 2 # => 1 # Integer
+ #
+ # With mathn:
+ #
+-#   3 / 2 => 3/2 # Rational
++#   3 / 2 # => 3/2 # Rational
+ #
+ # mathn features late rounding and lacks truncation of intermediate results:
+ #
+ # Without mathn:
++# :rdx: before_require
+ #
+ #   20 / 9 * 3 * 14 / 7 * 3 / 2 # => 18
+ #
+@@ -55,8 +57,10 @@
+ ##
+ # When mathn is required, Fixnum's division and exponentiation are enhanced to
+ # return more precise values from mathematical expressions.
+-#
++# 
++# :rdx: before_require
+ #   2/3*3  # => 0
++# :rdx:
+ #   require 'mathn'
+ #   2/3*3  # => 2
+ 
+@@ -119,8 +123,9 @@
+ # operations.
+ #
+ # Normal behaviour:
++# :rdx: before_require
+ #
+-#   Rational.new!(1,3) ** 2 # => Rational(1, 9)
++#   Rational(1,3) ** 2 # => Rational(1, 9)
+ #   (1 / 3) ** 2            # => 0
+ #
+ # require 'mathn' behaviour:
+@@ -201,9 +206,10 @@
+ # When mathn is required, the Math module changes as follows:
+ #
+ # Standard Math module behaviour:
++# :rdx: before_require
+ #   Math.sqrt(4/9)     # => 0.0
+ #   Math.sqrt(4.0/9.0) # => 0.666666666666667
+-#   Math.sqrt(- 4/9)   # => Errno::EDOM: Numerical argument out of domain - sqrt
++#   Math.sqrt(- 4/9)   # raises Math::DomainError: Numerical argument is out of domain - "sqrt"
+ #
+ # After require 'mathn', this is changed to:
+ #

data/examples/ruby-2.0.0-p0/install/stdlib/diffs/lib/matrix.rb.diff

@@ -0,0 +1,657 @@
+--- stdlib/orig/lib/matrix.rb	2015-06-11 07:51:45 +0000
++++ stdlib/patched/lib/matrix.rb	2015-06-25 16:11:40 +0000
+@@ -119,6 +119,14 @@
+ # String representations:
+ # * #to_s
+ # * #inspect
++# 
++# We define for convenience a few matrixes that will be used in the following examples:
++# :rdx: setup
++#   m_int  = Matrix[[1,2,3], [4,5,6]]
++#   m_int2 = Matrix[[1,2,3], [4,5,6]] # same content as m_int, but different object
++#   m_int_clone = m_int.clone
++#   m_flt = Matrix[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]
++#   n_int = Matrix[[2,3,4], [5,6,7]]
+ #
+ class Matrix
+   include Enumerable
+@@ -134,8 +142,14 @@
+   #
+   # Creates a matrix where each argument is a row.
+   #   Matrix[ [25, 93], [-1, 66] ]
+-  #      =>  25 93
+-  #          -1 66
++	#   # => Matrix[
++  #   #      [25, 93],
++  #   #      [-1, 66]
++	#   # ]
++	#   Matrix[Object.new] # raises TypeError
++	#   o = Object.new
++	#   def o.to_ary; [1,2,3]; end
++	#   Matrix[o] #=> Matrix[[1,2,3]]
+   #
+   def Matrix.[](*rows)
+     rows(rows, false)
+@@ -146,8 +160,10 @@
+   # of the matrix.  If the optional argument +copy+ is false, use the given
+   # arrays as the internal structure of the matrix without copying.
+   #   Matrix.rows([[25, 93], [-1, 66]])
+-  #      =>  25 93
+-  #          -1 66
++	#   # => Matrix[
++  #   #      [25, 93],
++  #   #      [-1, 66]
++	#   # ]
+   #
+   def Matrix.rows(rows, copy = true)
+     rows = convert_to_array(rows)
+@@ -164,8 +180,10 @@
+   #
+   # Creates a matrix using +columns+ as an array of column vectors.
+   #   Matrix.columns([[25, 93], [-1, 66]])
+-  #      =>  25 -1
+-  #          93 66
++	#   # => Matrix[
++  #   #      [25, -1],
++  #   #      [93, 66]
++	#   # ]
+   #
+   def Matrix.columns(columns)
+     rows(columns, false).transpose
+@@ -178,9 +196,16 @@
+   # Returns an enumerator if no block is given.
+   #
+   #   m = Matrix.build(2, 4) {|row, col| col - row }
+-  #     => Matrix[[0, 1, 2, 3], [-1, 0, 1, 2]]
+-  #   m = Matrix.build(3) { rand }
+-  #     => a 3x3 matrix with random elements
++	#   # => Matrix[
++  #   #      [ 0, 1, 2, 3],
++  #   #      [-1, 0, 1, 2]
++	#   # ]
++  #   m = Matrix.build(3) { rand(10) }
++	#   # -> Matrix[
++  #   #      [7, 1, 3],
++	#   #      [2, 3, 6],
++  #   #      [8, 2, 1]
++	#   # ]
+   #
+   def Matrix.build(row_count, column_count = row_count)
+     row_count = CoercionHelper.coerce_to_int(row_count)
+@@ -198,9 +223,11 @@
+   #
+   # Creates a matrix where the diagonal elements are composed of +values+.
+   #   Matrix.diagonal(9, 5, -3)
+-  #     =>  9  0  0
+-  #         0  5  0
+-  #         0  0 -3
++	#   # => Matrix[
++  #   #      [9, 0, 0],
++	#   #      [0, 5, 0],
++  #   #      [0, 0,-3]
++	#   # ]
+   #
+   def Matrix.diagonal(*values)
+     size = values.size
+@@ -216,8 +243,10 @@
+   # Creates an +n+ by +n+ diagonal matrix where each diagonal element is
+   # +value+.
+   #   Matrix.scalar(2, 5)
+-  #     => 5 0
+-  #        0 5
++	#   # => Matrix[
++  #   #      [5, 0],
++	#   #      [0, 5]
++	#   # ]
+   #
+   def Matrix.scalar(n, value)
+     diagonal(*Array.new(n, value))
+@@ -226,8 +255,10 @@
+   #
+   # Creates an +n+ by +n+ identity matrix.
+   #   Matrix.identity(2)
+-  #     => 1 0
+-  #        0 1
++  #   # => Matrix[
++  #   #      [1, 0],
++	#   #      [0, 1]
++	#   # ]
+   #
+   def Matrix.identity(n)
+     scalar(n, 1)
+@@ -240,8 +271,10 @@
+   #
+   # Creates a zero matrix.
+   #   Matrix.zero(2)
+-  #     => 0 0
+-  #        0 0
++  #   # => Matrix[
++  #   #      [0, 0],
++	#   #      [0, 0]
++	#   # ]
+   #
+   def Matrix.zero(row_count, column_count = row_count)
+     rows = Array.new(row_count){Array.new(column_count, 0)}
+@@ -252,7 +285,9 @@
+   # Creates a single-row matrix where the values of that row are as given in
+   # +row+.
+   #   Matrix.row_vector([4,5,6])
+-  #     => 4 5 6
++	#   # => Matrix[
++  #   #      [4, 5, 6]
++	#   # ]
+   #
+   def Matrix.row_vector(row)
+     row = convert_to_array(row)
+@@ -263,9 +298,11 @@
+   # Creates a single-column matrix where the values of that column are as given
+   # in +column+.
+   #   Matrix.column_vector([4,5,6])
+-  #     => 4
+-  #        5
+-  #        6
++	#   # => Matrix[
++  #   #      [4],
++	#   #      [5],
++	#   #      [6]
++	#   # ]
+   #
+   def Matrix.column_vector(column)
+     column = convert_to_array(column)
+@@ -278,12 +315,12 @@
+   #
+   #   m = Matrix.empty(2, 0)
+   #   m == Matrix[ [], [] ]
+-  #     => true
++  #   # => true
+   #   n = Matrix.empty(0, 3)
+   #   n == Matrix.columns([ [], [], [] ])
+-  #     => true
++  #   # => true
+   #   m * n
+-  #     => Matrix[[0, 0, 0], [0, 0, 0]]
++  #   # => Matrix[[0, 0, 0], [0, 0, 0]]
+   #
+   def Matrix.empty(row_count = 0, column_count = 0)
+     raise ArgumentError, "One size must be 0" if column_count != 0 && row_count != 0
+@@ -310,6 +347,10 @@
+ 
+   #
+   # Returns element (+i+,+j+) of the matrix.  That is: row +i+, column +j+.
++	#   m = Matrix[ [1,2,3], [4,5,6] ]
++	#   m[0,0] #=> 1
++	#   m[1,0] #=> 4
++	#   m[1,2] #=> 6
+   #
+   def [](i, j)
+     @rows.fetch(i){return nil}[j]
+@@ -341,6 +382,10 @@
+   #
+   # Returns row vector number +i+ of the matrix as a Vector (starting at 0 like
+   # an array).  When a block is given, the elements of that vector are iterated.
++	#   m_int.row(0) #=> Vector[1, 2, 3]
++	#   a = []
++	#   m_int.row(0) {|x| a << x }
++	#   a #=> [1, 2, 3]
+   #
+   def row(i, &block) # :yield: e
+     if block_given?
+@@ -355,6 +400,10 @@
+   # Returns column vector number +j+ of the matrix as a Vector (starting at 0
+   # like an array).  When a block is given, the elements of that vector are
+   # iterated.
++	#   m_int.column(0) #=> Vector[1, 4]
++	#   a = []
++	#   m_int.column(0) {|x| a << x }
++	#   a #=> [1, 4]
+   #
+   def column(j) # :yield: e
+     if block_given?
+@@ -376,8 +425,10 @@
+   # Returns a matrix that is the result of iteration of the given block over all
+   # elements of the matrix.
+   #   Matrix[ [1,2], [3,4] ].collect { |e| e**2 }
+-  #     => 1  4
+-  #        9 16
++	#   # => Matrix[
++  #   #      [1, 4],
++	#   #      [9,16]
++	#   # ]
+   #
+   def collect(&block) # :yield: e
+     return to_enum(:collect) unless block_given?
+@@ -398,9 +449,10 @@
+   # * :strict_upper: yields only elements above the diagonal
+   # * :upper: yields only elements on or above the diagonal
+   #
+-  #   Matrix[ [1,2], [3,4] ].each { |e| puts e }
+-  #     # => prints the numbers 1 to 4
+-  #   Matrix[ [1,2], [3,4] ].each(:strict_lower).to_a # => [3]
++  #  Matrix[ [1,2], [3,4] ].each { |e| print e }
++  #    # prints: 1234
++  #  Matrix[ [1,2], [3,4] ].each(:strict_lower).to_a
++	#    # => [3]
+   #
+   def each(which = :all) # :yield: e
+     return to_enum :each, which unless block_given?
+@@ -457,11 +509,11 @@
+   #   Matrix[ [1,2], [3,4] ].each_with_index do |e, row, col|
+   #     puts "#{e} at #{row}, #{col}"
+   #   end
+-  #     # => Prints:
+-  #     #    1 at 0, 0
+-  #     #    2 at 0, 1
+-  #     #    3 at 1, 0
+-  #     #    4 at 1, 1
++  # produces:
++  #   1 at 0, 0
++  #   2 at 0, 1
++  #   3 at 1, 0
++  #   4 at 1, 1
+   #
+   def each_with_index(which = :all) # :yield: e, row, column
+     return to_enum :each_with_index, which unless block_given?
+@@ -549,8 +601,13 @@
+   # *  row_range, col_range
+   #
+   #   Matrix.diagonal(9, 5, -3).minor(0..1, 0..2)
+-  #     => 9 0 0
+-  #        0 5 0
++	#   # => Matrix[
++  #   #      [9, 0, 0],
++	#   #      [0, 5, 0]
++	#   # ]
++	#   m_int.minor(0, 2, 0, 2)
++	#   # => Matrix[[1, 2], [4, 5]]
++	#   m_int.minor(0) # raises ArgumentError
+   #
+   # Like Array#[], negative indices count backward from the end of the
+   # row or column (-1 is the last element). Returns nil if the starting
+@@ -695,6 +752,8 @@
+ 
+   #
+   # Returns +true+ if this is a regular (i.e. non-singular) matrix.
++	#   Matrix[[1, 0], [0, 1]].regular? #=> true
++	#   Matrix[[1, 0, 0], [0, 0, 1], [0, 0, 1]].regular? #=> false
+   #
+   def regular?
+     not singular?
+@@ -702,6 +761,8 @@
+ 
+   #
+   # Returns +true+ is this is a singular matrix.
++	#   Matrix[[1, 0], [0, 1]].singular? #=> false
++	#   Matrix[[1, 0, 0], [0, 0, 1], [0, 0, 1]].singular? #=> true
+   #
+   def singular?
+     determinant == 0
+@@ -709,6 +770,8 @@
+ 
+   #
+   # Returns +true+ is this is a square matrix.
++	#   Matrix[[1, 0], [0, 1]].square? #=> true
++	#   Matrix[[1, 0, 0], [0, 1, 0]].square? #=> false
+   #
+   def square?
+     column_count == row_count
+@@ -762,8 +825,19 @@
+   # OBJECT METHODS -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+   #++
+ 
++	#
++	# test identity
++	# :rdx: skip improve nested comments
++	#   m_int.equal? m_int2 #=> false
++	#   m_int.equal? m_int_clone #=> false
++	#   m_int.equal? m_flt #=> false
++	#   m_int.equal? n_int #=> false
++	#
++	
+   #
+   # Returns +true+ if and only if the two matrices contain equal elements.
++	#   m_int == m_int #=> true
++	#   m_int == m_flt #=> true
+   #
+   def ==(other)
+     return false unless Matrix === other &&
+@@ -771,6 +845,16 @@
+     rows == other.rows
+   end
+ 
++	#-- rdx
++	# test hash equality
++	#   m_int.eql? m_int #=> true
++	#   m_int.eql? m_flt #=> false
++	#   
++	#   hash = { m_int => :value }
++	#   hash.key?(m_int2) #=> true
++	#   hash.key?(m_int_clone) #=> true
++	#   hash.key?(n_int) #=> false
++	#
+   def eql?(other)
+     return false unless Matrix === other &&
+                         column_count == other.column_count # necessary for empty matrices
+@@ -781,13 +865,20 @@
+   # Returns a clone of the matrix, so that the contents of each do not reference
+   # identical objects.
+   # There should be no good reason to do this since Matrices are immutable.
+-  #
++	#   m_int == m_int_clone #=> true
++	#   m_int.equal? m_int_clone #=> false
++	#   m_int.equal? m_int #=> true
++	#
+   def clone
+     new_matrix @rows.map(&:dup), column_count
+   end
+ 
+   #
+   # Returns a hash-code for the matrix.
++	#-- rdx
++	#   m_int.hash #=> m_int.hash
++	#   m_int.hash #=> m_int2.hash
++	#   m_int.hash #=> m_int_clone.hash
+   #
+   def hash
+     @rows.hash
+@@ -800,8 +891,13 @@
+   #
+   # Matrix multiplication.
+   #   Matrix[[2,4], [6,8]] * Matrix.identity(2)
+-  #     => 2 4
+-  #        6 8
++	#   # => Matrix[
++  #   #      [2, 4],
++	#   #      [6, 8]
++	#   # ]
++	#   Matrix[[2,4],[6,8]] * 2 #=> Matrix[[4,8],[12,16]]
++	#   2 * Matrix[[2,4],[6,8]] #=> Matrix[[4,8],[12,16]]
++	#   m_int * Vector[1,2,3] #=> Vector[14,32]
+   #
+   def *(m) # m is matrix or vector or number
+     case(m)
+@@ -833,8 +929,13 @@
+   #
+   # Matrix addition.
+   #   Matrix.scalar(2,5) + Matrix[[1,0], [-4,7]]
+-  #     =>  6  0
+-  #        -4 12
++	#   # => Matrix[
++  #   #      [ 6,  0],
++	#   #      [-4, 12]
++	#   # ]
++	#   Matrix.scalar(2,5) + Matrix[[1,0],[-4,7]] #=> Matrix[[6,0],[-4,12]]
++	#   Matrix[[1],[2],[3]] + Vector[1,2,3] #=> Matrix[[2],[4],[6]]
++	#   m_int + 1 # raises Matrix::ErrOperationNotDefined
+   #
+   def +(m)
+     case m
+@@ -860,8 +961,13 @@
+   #
+   # Matrix subtraction.
+   #   Matrix[[1,5], [4,2]] - Matrix[[9,3], [-4,1]]
+-  #     => -8  2
+-  #         8  1
++	#   # => Matrix[
++  #   #      [-8, 2],
++	#   #      [ 8, 1]
++	#   # ]
++	#   Matrix.scalar(2,5) - Matrix[[1,0],[-4,7]] #=> Matrix[[4,0],[4,-2]]
++	#   Matrix[[1],[2],[3]] - Vector[1,2,3] #=> Matrix[[0],[0],[0]]
++	#   m_int - 1 # raises Matrix::ErrOperationNotDefined
+   #
+   def -(m)
+     case m
+@@ -887,8 +993,11 @@
+   #
+   # Matrix division (multiplication by the inverse).
+   #   Matrix[[7,6], [3,9]] / Matrix[[2,9], [3,1]]
+-  #     => -7  1
+-  #        -3 -6
++	#   # => Matrix[
++  #   #      [Rational(11,25), Rational(51,25)],
++	#   #      [Rational(24,25), Rational( 9,25)]
++	#   # ]
++	#   Matrix[[2,2],[2,2]] / Matrix.scalar(2,2) #=> Matrix[[1,1],[1,1]]
+   #
+   def /(other)
+     case other
+@@ -907,8 +1016,10 @@
+   #
+   # Returns the inverse of the matrix.
+   #   Matrix[[-1, -1], [0, -1]].inverse
+-  #     => -1  1
+-  #         0 -1
++	#   # => Matrix[
++  #   #      [-1,  1],
++	#   #      [ 0, -1]
++	#   # ]
+   #
+   def inverse
+     Matrix.Raise ErrDimensionMismatch unless square?
+@@ -967,8 +1078,12 @@
+   # Non integer exponents will be handled by diagonalizing the matrix.
+   #
+   #   Matrix[[7,6], [3,9]] ** 2
+-  #     => 67 96
+-  #        48 99
++	#   # => Matrix[
++  #   #      [67, 96],
++	#   #      [48, 99]
++	#   # ]
++	#   Matrix.I(5) ** -1 #=> Matrix.I(5)
++	#   Matrix.I(5) ** Object.new # raises Matrix::ErrOperationNotDefined
+   #
+   def ** (other)
+     case other
+@@ -1005,7 +1120,9 @@
+   # Consider using exact types like Rational or BigDecimal instead.
+   #
+   #   Matrix[[7,6], [3,9]].determinant
+-  #     => 45
++  #   # => 45
++	#   Matrix[[2,0,1],[0,-2,2],[1,2,3]].determinant
++	#   # => -18
+   #
+   def determinant
+     Matrix.Raise ErrDimensionMismatch unless square?
+@@ -1101,8 +1218,11 @@
+   # because of their lack of precision.
+   # Consider using exact types like Rational or BigDecimal instead.
+   #
+-  #   Matrix[[7,6], [3,9]].rank
+-  #     => 2
++	#   Matrix[[0]].rank #=> 0
++	#   Matrix[[0],[0]].rank #=> 0
++	#   Matrix[[7,6], [3,9]].rank
++  #   # => 2
++	#   Matrix[[0,0,1],[0,7,6],[1,3,9]].rank #=> 3
+   #
+   def rank
+     # We currently use Bareiss' multistep integer-preserving gaussian elimination
+@@ -1150,7 +1270,8 @@
+   #
+   # Returns the trace (sum of diagonal elements) of the matrix.
+   #   Matrix[[7,6], [3,9]].trace
+-  #     => 16
++  #   # => 16
++	#   Matrix[[1,2,3],[4,5,6],[7,8,9]].trace #=> 1+5+9
+   #
+   def trace
+     Matrix.Raise ErrDimensionMismatch unless square?
+@@ -1162,13 +1283,15 @@
+ 
+   #
+   # Returns the transpose of the matrix.
+-  #   Matrix[[1,2], [3,4], [5,6]]
+-  #     => 1 2
+-  #        3 4
+-  #        5 6
+-  #   Matrix[[1,2], [3,4], [5,6]].transpose
+-  #     => 1 3 5
+-  #        2 4 6
++  #   Matrix[
++	#     [1,2],
++	#     [3,4],
++	#     [5,6]
++	#   ].transpose
++	#   # => Matrix[
++  #   #      [ 1, 3, 5],
++	#   #      [ 2, 4, 6]
++	#   # ]
+   #
+   def transpose
+     return self.class.empty(column_count, 0) if row_count.zero?
+@@ -1201,7 +1324,7 @@
+   #   u.upper_triangular? # => true
+   #   p.permutation?      # => true
+   #   l * u == p * a      # => true
+-  #   a.lup.solve([2, 5]) # => Vector[(1/1), (1/2)]
++  #   a.lup.solve([2, 5]) # => Vector[1, Rational(1,2)]
+   #
+   def lup
+     LUPDecomposition.new(self)
+@@ -1214,12 +1337,14 @@
+ 
+   #
+   # Returns the conjugate of the matrix.
+-  #   Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]]
+-  #     => 1+2i   i  0
+-  #           1   2  3
+-  #   Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]].conjugate
+-  #     => 1-2i  -i  0
+-  #           1   2  3
++  #   Matrix[
++	#     [Complex(1,2), Complex(0,1), 0],
++	#     [1, 2, 3]
++	#   ].conjugate
++	#   # => Matrix[
++  #   #      [1-2.i, -1.i, 0],
++	#   #      [ 1   ,  2  , 3]
++	#   # ]
+   #
+   def conjugate
+     collect(&:conjugate)
+@@ -1228,12 +1353,14 @@
+ 
+   #
+   # Returns the imaginary part of the matrix.
+-  #   Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]]
+-  #     => 1+2i  i  0
+-  #           1  2  3
+-  #   Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]].imaginary
+-  #     =>   2i  i  0
+-  #           0  0  0
++	#   Matrix[
++	#     [Complex(1,2), Complex(0,1), 0],
++	#     [1, 2, 3]
++	#   ].imaginary
++	#   # => Matrix[
++  #   #      [ 2, 1, 0],
++	#   #      [ 0, 0, 0]
++	#   # ]
+   #
+   def imaginary
+     collect(&:imaginary)
+@@ -1242,12 +1369,14 @@
+ 
+   #
+   # Returns the real part of the matrix.
+-  #   Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]]
+-  #     => 1+2i  i  0
+-  #           1  2  3
+-  #   Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]].real
+-  #     =>    1  0  0
+-  #           1  2  3
++	#   Matrix[
++	#     [Complex(1,2), Complex(0,1), 0],
++	#     [1, 2, 3]
++	#   ].real
++	#   # => Matrix[
++  #   #      [ 1, 0, 0],
++	#   #      [ 1, 2, 3]
++	#   # ]
+   #
+   def real
+     collect(&:real)
+@@ -1256,8 +1385,12 @@
+   #
+   # Returns an array containing matrices corresponding to the real and imaginary
+   # parts of the matrix
+-  #
+-  # m.rect == [m.real, m.imag]  # ==> true for all matrices m
++	# 
++	# For all matrices +m+:
++	#-- rdx
++	#   m = Matrix.build(rand(10), rand(10)){ Complex( rand(10), rand(10)) }
++	#++
++  #   m.rect == [m.real, m.imag]  # => true
+   #
+   def rect
+     [real, imag]
+@@ -1286,6 +1419,7 @@
+ 
+   #
+   # Returns an array of the row vectors of the matrix.  See Vector.
++	#   m_int.row_vectors #=> [ Vector[1,2,3], Vector[4,5,6] ]
+   #
+   def row_vectors
+     Array.new(row_count) {|i|
+@@ -1295,6 +1429,7 @@
+ 
+   #
+   # Returns an array of the column vectors of the matrix.  See Vector.
++	#   m_int.column_vectors #=> [ Vector[1,4], Vector[2,5], Vector[3,6] ]
+   #
+   def column_vectors
+     Array.new(column_count) {|i|
+@@ -1330,6 +1465,9 @@
+ 
+   #
+   # Overrides Object#to_s
++	#   m_int.to_s #=> "Matrix[[1, 2, 3], [4, 5, 6]]"
++	#   Matrix[].to_s #=> "Matrix.empty(0, 0)"
++	#   Matrix[[]].to_s #=> "Matrix.empty(1, 0)"
+   #
+   def to_s
+     if empty?
+@@ -1550,7 +1688,7 @@
+ 
+   #
+   # Creates a Vector from a list of elements.
+-  #   Vector[7, 4, ...]
++  #   Vector[7, 4, 5]
+   #
+   def Vector.[](*array)
+     new convert_to_array(array, false)
+@@ -1745,7 +1883,7 @@
+ 
+   #
+   # Returns the inner product of this vector with the other.
+-  #   Vector[4,7].inner_product Vector[10,1]  => 47
++  #   Vector[4,7].inner_product Vector[10,1]  #=> 47
+   #
+   def inner_product(v)
+     Vector.Raise ErrDimensionMismatch if size != v.size
+@@ -1769,7 +1907,7 @@
+ 
+   #
+   # Returns the modulus (Pythagorean distance) of the vector.
+-  #   Vector[5,8,2].r => 9.643650761
++  #   Vector[5,8,2].r #=> 9.643650761
+   #
+   def magnitude
+     Math.sqrt(@elements.inject(0) {|v, e| v + e.abs2})
+@@ -1790,9 +1928,10 @@
+   end
+   #
+   # Returns a new vector with the same direction but with norm 1.
+-  #   v = Vector[5,8,2].normalize
+-  #   # => Vector[0.5184758473652127, 0.8295613557843402, 0.20739033894608505]
+-  #   v.norm => 1.0
++  #   v = Vector[5,8,2]
++	#   v_normalized = Vector[0.5184758473652127, 0.8295613557843402, 0.20739033894608505]
++	#   (v.normalize - v_normalized).map{ |e| e.round(5) } #=> Vector[0, 0, 0]
++  #   v_normalized.norm # => 1.0
+   #
+   def normalize
+     n = magnitude