Drukowanie czytelnej matrycy w Ruby

Question

Czy jest wbudowany sposób drukowania czytelnej matrycy w języku Ruby?

Na przykład

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

i go pokazać

=> 1 2 
    3 4 

w REPL zamiast:

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

The Ruby Docs dla matrix upozorować, że to, co powinno pokazać zdarzają się, ale to nie jest to, co widzę. Wiem, że napisanie funkcji do tego byłoby trywialne, ale jeśli istnieje "właściwy" sposób, wolę się uczyć!

Answer 1

Można przekonwertować go na tablicy:

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

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

EDIT:

Oto "punkt wolne" wersja:

puts m1.to_a.map(&:inspect) 

Answer 2

Można użyć metody each_slice połączeniu z Metoda column_size.

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

Answer 3

Nie mogłem sprawić, żeby wyglądała jak dokumentacja, więc napisałem dla ciebie funkcję, która wykonuje to samo zadanie.

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 

Answer 4

Nota prawna: Jestem głównym programistą dla NMatrix.

To trywialne w NMatrix. Po prostu zrób matrix.pretty_print.

Kolumny nie są uporządkowane w spójny sposób, ale można je łatwo naprawić i chcielibyśmy, aby wszelkie uwagi na ten temat zostały uwzględnione.

Nawiasem mówiąc, miło widzieć inną osobę z VT tutaj. =)

Answer 5

Ok, jestem totalną nowicjuszką w programowaniu ruby. Po prostu robię pierwsze inwazje, ale zdarza mi się, że mam ten sam problem i zastosowałem to szybkie podejście. Działa ze standardową biblioteką Matrix i wydrukuje kolumny sformatowane w tym samym rozmiarze.

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 

Wszelkie poprawki lub ulepszenia są mile widziane!

Answer 6

To działa na mnie

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 

Answer 7

Oto moja odpowiedź:

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 3\n3 4" 

Można użyć Matrix#to_pretty_s uzyskać ładny ciąg do pliku PDF.

Answer 8

Nie ma wbudowanego sposobu, aby to zrobić. Jednak utworzyłem moduł, który można dołączyć do macierzy, który zawiera metodę readable. Możesz znaleźć ten kod here, ale jest również w następującym bloku kodu.

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 

## example usage ## 
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