Feature #10077: [PATCH] Implement Matrix#row_merge and Matrix#column_merge

• Status: Closed
• Assignee: marcandre (Marc-Andre Lafortune)
• Target version: -

[gogotanaka (Kazuki Tanaka)]

Merge matrices horizontally and vertically.

It is useful and important when we handle linear equations, statistics and so on.

Matrix[[1, 2], [3, 4]].row_merge(Matrix[[5], [6]])

  => 1 2 5
     3 4 6

Matrix[[1, 2], [3, 4]].column_merge(Matrix[[5, 6]])

  => 1 2
     3 4
     5 6

# accept more than two matrices as an argument.

Matrix[[1, 2], [3, 4]].column_merge(Matrix[[5, 6]], Matrix[[7, 8]])

  => 1 2
     3 4
     5 6
     7 8

• Matrix#row_merge needs Matrix#column

[gogotanaka (Kazuki Tanaka)]

Is there anything I should do with?

[hsbt (Hiroshi SHIBATA)]

• Status changed from Open to Assigned
• Assignee set to marcandre (Marc-Andre Lafortune)

[gogotanaka (Kazuki Tanaka)]

@hiroshi (Hiroshi MORIYAMA) SHIBATA san

Thank you so much!

いつもありがとうございます. 助かっています.

[david_macmahon (David MacMahon)]

FWIW, Matlab calls these operations "horzcat" (for "horizontal concatenation") and "vertcat" (for "vertical concatenation"). I personally find these names less ambiguous than "row_merge" and "column_merge". IMHO, the name "row_merge" seems to have an ambiguity as to whether it will merge along the rows of the Matrix (creating more columns) or whether it will merge additional rows onto the Matrix, but maybe that's just my lack of familiarity with these new names.

On Sep 12, 2014, at 10:11 AM, [e-mail] wrote:

Issue #10077 has been updated by gogo tanaka.

@hiroshi (Hiroshi MORIYAMA) SHIBATA san

Thank you so much!

いつもありがとうございます. 助かっています.

---

Feature #10077: [PATCH] Implement Matrix#row_merge and Matrix#column_merge
https://bugs.ruby-lang.org/issues/10077#change-48878

• Author: gogo tanaka
• Status: Assigned
• Priority: Normal
• Assignee: Marc-Andre Lafortune
• Category:
• Target version:

---

Merge matrices horizontally and vertically.

It is useful and important when we handle linear equations, statistics and so on.

Matrix[[1, 2], [3, 4]].row_merge(Matrix[[5], [6]])

 => 1 2 5
    3 4 6

Matrix[[1, 2], [3, 4]].column_merge(Matrix[[5, 6]])

 => 1 2
    3 4
    5 6

# accept more than two matrices as an argument.

Matrix[[1, 2], [3, 4]].column_merge(Matrix[[5, 6]], Matrix[[7, 8]])

 => 1 2
    3 4
    5 6
    7 8

• Matrix#row_merge needs Matrix#column

---Files--------------------------------
Implement_Matrix#column_merge.patch (863 Bytes)
Add_test_for_Matrix#column_merge.patch (1.36 KB)
Add_Matrix#column_merge_to_NEWS.patch (452 Bytes)
Implement_Matrix#row_merge.patch (899 Bytes)
Add_test_for_Matrix#row_merge.patch (1.4 KB)
Add_Matrix#row_merge_to_NEWS.patch (523 Bytes)

--
https://bugs.ruby-lang.org/

[gogotanaka (Kazuki Tanaka)]

@david (david he) MacMahon

Thank you!

It make sense for me.

As you said,

the name "row_merge" seems to have an ambiguity as to whether it will merge along the rows of the Matrix (creating more columns) or whether it will merge additional rows onto the Matrix

I agree with this, but horzcat or vertcat are hard to understand for people who isn't familiar with Matlab.

So I'm gonna propose horz_merge and vert_merge. Dose it make sense?

[david_macmahon (David MacMahon)]

On Sep 16, 2014, at 4:21 PM, [e-mail] wrote:

So I propose horz_merge and vert_merge. Dose it make sense?

I definitely like it better than row_merge and col_merge, but to me the verb "merge" has connotations of intertwining or melding. IMHO, "merge" makes sense for Hash or Set, but not so much for Matrix. Since we already have Array#concat, how about Matrix#horz_concat and Matrix#vert_concat? Just an idea...

[marcandre (Marc-Andre Lafortune)]

• Category set to lib
• Status changed from Assigned to Closed

I've used hstack and vstack, as suggested in https://github.com/ruby/ruby/pull/344

I hope this satisfied everyone :-)

Committed as r47769

[gogotanaka (Kazuki Tanaka)]

Sure, no problem.

[gogotanaka (Kazuki Tanaka)]

@Marc-Andre Lafortune san

It’s hard for me to say this, but I have confidence in my implementation more than merged one.

My implementation

def row_merge(*matrices)
  if matrices.any?{ |m| m.row_size != row_size }
    raise ErrDimensionMismatch, "all matrices should have same row size"
  end
  transpose.column_merge(*matrices.map(&:transpose)).transpose
end
alias_method :merge, :row_merge

def column_merge(*matrices)
  if matrices.any?{ |m| m.column_size != column_size }
    raise ErrDimensionMismatch, "all matrices should have same column size"
  end
  new_matrix [self, *matrices].map(&:to_a).flatten(1)
end

Merged implementation

def Matrix.hstack(x, *matrices)
  raise TypeError, "Expected a Matrix, got a #{x.class}" unless x.is_a?(Matrix)
  result = x.send(:rows).map(&:dup)
  total_column_count = x.column_count
  matrices.each do |m|
    raise TypeError, "Expected a Matrix, got a #{m.class}" unless m.is_a?(Matrix)
    if m.row_count != x.row_count
      raise ErrDimensionMismatch, "The given matrices must have #{x.row_count} rows, but one has #{m.row_count}"
    end
    result.each_with_index do |row, i|
      row.concat m.send(:rows)[i]
    end
    total_column_count += m.column_count
  end
  new result, total_column_count
end



def Matrix.vstack(x, *matrices)
  raise TypeError, "Expected a Matrix, got a #{x.class}" unless x.is_a?(Matrix)
  result = x.send(:rows).map(&:dup)
  matrices.each do |m|
    raise TypeError, "Expected a Matrix, got a #{m.class}" unless m.is_a?(Matrix)
    if m.column_count != x.column_count
      raise ErrDimensionMismatch, "The given matrices must have #{x.column_count} columns, but one has #{m.column_count}"
    end
    result.concat(m.send(:rows))
  end
  new result, x.column_count
end

I believe the interface x.row_merge(y) is preferred to Matrix.vstack(x, y),

And I think my implementation is more clear and maintainability.

Of course, merged one has some better point my patch doesn't have.

But we should use symmetry between row and column at least.

How is merged implementation preferred to my implementation?

I'm so sorry, I said something trouble.

Take you time.

[marcandre (Marc-Andre Lafortune)]

Thank you for your comments.

I want to point out that I've added both x.hstack(y) and Matrix.hstack(x, y), so both interfaces are available now, the same way I would love for Array#product to have a corresponding Array.product (see https://bugs.ruby-lang.org/issues/8970)

Your proposed implementation using transpose is shorter, clever and expressive. It's very nice. I've chosen mine for efficiency:

require 'fruity'
m = Matrix.identity(3)
compare do
  row_merge { m.row_merge(m) }
  hstack     { m.hstack(m) }
end
# => hstack is faster than row_merge by 2x ± 0.1

For bigger matrices, the performance gap gets bigger (8x for 100x100 and 23x for 1000x1000).

[gogotanaka (Kazuki Tanaka)]

@Marc-Andre Lafortune

Thank you for the thorough explanation.

OK, I understand what you said, this satisfied me now.

I realize we'd better think about efficiency more than maintainability or brevity of codes.
(There might be some exceptions)

Thanks.