require 'matrix'
m1 = Matrix[[1,2], [3,4]]
print m1

=> 1 2
   3 4

=> Matrix[[1,2][3,4]]

m1.to_a.each {|r| puts r.inspect}

=> [1, 2]
   [3, 4]

puts m1.to_a.map(&:inspect)

require 'matrix'

m1 = Matrix[[1,2],[3,4],[5,6]]

class Matrix
  def to_readable
    i = 0
    self.each do |number|
      print number.to_s + " "
      i+= 1
      if i == self.column_size
        print "n"
        i = 0
      end
    end
  end
end

m1.to_readable

=> 1 2
   3 4
   5 6

m1.each_slice(m1.column_size) {|r| p r }
=> [1,2]
   [3,4]

class Matrix
  def to_readable
   column_counter = 0
   columns_arrays = []
   while column_counter < self.column_size
     maximum_length = 0
     self.column(column_counter).each do |column_element|# Get maximal size
       length = column_element.to_s.size
       if length > maximal_length
         maximum_length = length
       end
     end # now we've got the maximum size
     column_array = []
     self.column(column_counter).each do |column_element| # Add needed spaces to equalize each column
      element_string = column_element.to_s
      element_size = element_string.size
      space_needed = maximal_length - element_size +1
      if space_needed > 0
        space_needed.times {element_string.prepend " "}
        if column_counter == 0
          element_string.prepend "["
        else
          element_string.prepend ","
        end
      end
      column_array << element_string
    end
    columns_arrays << column_array # Now columns contains equal size strings
    column_counter += 1
  end
  row_counter = 0
  while row_counter < self.row_size
    columns_arrays.each do |column|
      element = column[row_counter]
      print element #Each column yield the correspondant row in order
    end
    print "]n"
    row_counter += 1
  end
 end
end

require 'matrix'

class Matrix

  def print
    matrix = self.to_a
    field_size = matrix.flatten.collect{|i|i.to_s.size}.max
    matrix.each do |row|
      puts (row.collect{|i| ' ' * (field_size - i.to_s.size) + i.to_s}).join('  ')
    end
  end

end

m = Matrix[[1,23,3],[123,64.5, 2],[0,0,0]]
m.print

require 'matrix'

class Matrix
    def to_pretty_s
        s = ""
        i = 0
        while i < self.column_size
            s += "n" if i != 0
            j = 0
            while j < self.row_size
                s += ' ' if j != 0
                s += self.element(i, j).to_s
                j += 1
            end
            i += 1
        end
        s
    end
end

m = Matrix[[0, 3], [3, 4]]

puts m # same as 'puts m.to_s'
# Matrix[[0, 3], [3, 4]]

puts m.to_pretty_s
# 0 3
# 3 4

p m.to_pretty_s
# "0 3n3 4"

require 'matrix'

module ReadableArrays
    def readable(factor: 1, method: :rjust)
        repr = to_a.map { |row|
            row.map(&:inspect)
        }

        column_widths = repr.transpose.map { |col|
            col.map(&:size).max + factor
        }

        res = ""
        repr.each { |row|
            row.each_with_index { |el, j|
                res += el.send method, column_widths[j]
            }
            res += "n"
        }
        res.chomp
    end
end

class Matrix
    include ReadableArrays
end
class Array
    include ReadableArrays
end

arr = [[1, 20, 3], [20, 3, 19], [-32, 3, 5]]
mat = Matrix[*arr]

p arr
#=> [[1, 20, 3], [20, 3, 19], [-2, 3, 5]]
p mat
#=> Matrix[[1, 20, 3], [20, 3, 19], [-2, 3, 5]]

puts arr.readable
#=>
#    1 20  3
#   20  3 19
#  -32  3  5
puts mat.readable
#=>
#    1 20  3
#   20  3 19
#  -32  3  5
puts mat.readable(method: :ljust)
#=>
# 1   20 3
# 20  3  19
# -32 3  5
puts mat.readable(method: :center)
#=>
#  1  20  3
#  20  3 19
# -32  3  5