Matrix Ruby Wrappers

[rajithv]

No description provided.

[abinashmeher999]

What does klass stand for here?

[rajithv]

I was writing it by taking the example of cbasic_alloc. So assumed, the klass is something which is called when allocating the space bound defined in rb_define_alloc_func(c_dense_matrix, cmatrix_dense_alloc);

Shoud I remove it?

[isuruf]

klass is the class object. https://github.com/symengine/symengine.rb/blob/master/ext/symengine/ruby_basic.h#L13

[rajithv]

@abinashmeher999 @isuruf

Please check the following:

irb(main):003:0> A = SymEngine::DenseMatrix.new(arr)
=> #<SymEngine::DenseMatrix([1, 2]
[3, 4]
[5, 6]
)>
irb(main):004:0> A.to_s
=> "[1, 2]\n[3, 4]\n[5, 6]\n"

Also, does it need row count and column count?

The to_s output is not nice.. right? What are our options?

[zverok]

There are two main things to consider:

1. inspect: it should be as informative, as possible, but with reasonable limitation; for example, what we did in daru:

v = Daru::DataFrame.new(a: [1,2,3], b: [4,5,6])
# => #<Daru::DataFrame(3x2)>
#       a   b
#   0   1   4
#   1   2   5
#   2   3   6 

v = Daru::DataFrame.new(a: (1..100), b: (201..300))
# => #<Daru::DataFrame(100x2)>
#       a   b
#   0   1 201
#   1   2 202
#   2   3 203
#   3   4 204
#   4   5 205
#   5   6 206
#   6   7 207
#   7   8 208
#   8   9 209
#   9  10 210
#  10  11 211
#  11  12 212
#  12  13 213
#  13  14 214
#  14  15 215
# ... ... ... 

# ^ above is full output of #inspect of large DataFrame, including those "..."

2. to_s: for "non-stringy" types it should be as short as possible (while saving some informativeness), consider it used in contexts like raise ArgumentError, "Expected blah, yet received #{wtf}" ← this uses #to_s to render some error message... And somebody would output it.

[rajithv]

@zverok Thanks. I'll come up with a scheme considering the points you mentioned. I have a better idea now.

@isuruf mentioned that to_s is going to change in C++ layer soon, so I'll wait for that to happen. Until then, I'll show the number of rows and number of columns in inspect.

[isuruf]

This is needed in C++ layer, but not needed in Ruby right?

[rajithv]

@isuruf should I remove it?

I suppose this can be used to generate an empty Matrix of size RxC, where individual elements can be assigned with set. But again, there's no point in doing that.

[isuruf]

Yes, for that use case, it's better to use zeros

[rajithv]

@isuruf @abinashmeher999 @zverok ready for review.

@zverok I'm not too sure about the specs. Please advice if I'm not doing it right :)

[zverok]

Looking at it!

[zverok]

Shouldn't it say class DenseMatrix here?

[zverok]

I've left some comments.
Also, I am a bit concerned about the fact that only "happy path" is tested. What if I'll try to multiply DenseMatrix by string or nil? Would there be an informative exception? Would there be at least some exception (and not some nasty crash in the middle of C code). Testing behavior on failures and corner cases (for ex., behavior of empty matrices) could be tiresome, but without it we can't be sure code is actually working.

[isuruf]

Can you remove these changes from this PR?

[isuruf]

You can move this if else function to a new function, sympify_matrix

[isuruf]

You can use a C API call to check that operand is a DenseMatrix instead of string comparisons

[zverok]

I think, you can completely omit those describes including only one example each, its texts are pretty informative and well-written 👍
Just less cognitive load would be to read it this way:

describe SymEngine::DenseMatrix do
  describe 'convert' do
    subject { SymEngine([[1, 2],[3, 4]]) }

    it { is_expected.to be_a SymEngine::DenseMatrix }
    its(:to_s) { is_expected.to eq "[1, 2]\n[3, 4]\n" }
  end

  describe 'methods without arguments' do # that descibes accurately why you group it
    subject { SymEngine([[4, 3],[3, 2]]) }

    # moving those two here as they are pretty basic & have no arguments
    its(:rows) { is_expected.to eq (2) }
    its(:cols) { is_expected.to eq (2) }

    its(:inv) { is_expected.to be_a SymEngine::DenseMatrix }
    its(:inv) { is_expected.to eq SymEngine([[-2, 3],[3, -4]]) }

    its(:FFLU) { is_expected.to be_a SymEngine::DenseMatrix }
    its(:FFLU) { is_expected.to eq SymEngine([[4, 3],[3, -1]]) }

    its(:LU) { is_expected.to eq [SymEngine([[1, 0],[SymEngine(3)/SymEngine(4), 1]]), 
                                  SymEngine([[4, 3],[0, SymEngine(-1)/SymEngine(4)]])] }

    its(:LDL) { is_expected.to eq [SymEngine([[1, 0],[SymEngine(3)/SymEngine(4), 1]]), 
                                  SymEngine([[4, 0],[0, SymEngine(-1)/SymEngine(4)]])] }

    its(:FFLDU) { is_expected.to eq [SymEngine([[4, 0],[3, 1]]), SymEngine([[4, 0],[0, 4]]), 
                                     SymEngine([[4, 3],[0, -1]])] }

    its(:det) { is_expected.to eq (-1)}  

  end

  describe 'methods with arguments' do

    let(:mat1) { SymEngine([[1, 2],[3, 4]]) }
    let(:mat2) { SymEngine([[4, 3],[2, 1]]) }
    let(:a) { SymEngine(4) }
    let(:matA) { SymEngine([[3, 1, 2],[5, 7, 5], [1, 2, 3]]) }
    let(:b) { SymEngine([[4],[4],[4]]) }

    it 'adds and multiplies' do
      expect(mat1 + mat2).to eq(SymEngine([[5, 5],[5, 5]]))
      expect(mat1 + a).to eq(SymEngine([[5, 6],[7, 8]]))
      expect(mat1 * mat2).to eq(SymEngine([[8, 5],[20, 13]]))
      expect(mat1 * a).to eq(SymEngine([[4, 8],[12, 16]]))
    end  

    it 'performs transpose and submatrix' do
      expect(mat1.transpose).to eq(SymEngine([[1, 3],[2, 4]]))
      expect(mat1.submatrix(0, 0, 1, 0, 1, 1)).to eq(SymEngine([[1],[3]]))
    end

    it 'solves Ax = b' do
      expect(matA.LU_solve(b)).to eq(SymEngine([[SymEngine(12)/SymEngine(29)],
                                             [SymEngine(-32)/SymEngine(29)],
                                             [SymEngine(56)/SymEngine(29)]
                                             ]))  
    end

    it 'gets and sets elements' do
      expect(mat1.set(0, 0, a)).to eq(SymEngine([[4, 2],[3, 4]]))
      expect(mat1.get(1, 0)).to eq(SymEngine(3))
    end
  end
end

WDYT?