CoCoA » CoCoALib

another proposal

RowMat(M, i);
ColMat(M, j);

• RowMatView
• ColMatView

The intention is that the result should be a matrix 1xC or Rx1, right?

What should these functions do if the matrix is 0-by-C or R-by-0?
Return a 0-by-1 or 1-by-0 matrix?

I have just checked the code: it is in MatrixView (as one would expect).

I am not so happy about the names RowMat and ColMat because these names exist also for some completely different functions: ones which allow a C++ vector of RingElem to be viewed as a row-matrix or a col-matrix.

How about the names RowOfMat and ColOfMat?
Or even submat1row and submat1col? (uglier but maybe clearer?)

We could even use the names row and col, so sample uses would be

  MatrixView FirstRow = row(M,0);
  MatrixView LastRow = row(M, NumRows(M)-1);

One odd aspect of this implementation is that if we want to get an element from the resulting row/column, we must supply two indices (because the result is really just a sub-matrix. For instance:

  MatrixView FirstCol = col(M,0);
  if (FirstCol(0,0) == 1) cout << "Top left entry is 1" << endl;

This is rather weird! Usually we try to avoid too much weirdness.

Personally I would expect the result of a "get-row" or "get-col" function to produce an object which requires just a single index.

An advantage of the current impl (as a submatrix) is that we can directly use the chosen row/col in matrix multiplication.

Perhaps the correct result type(s) should be new objects which require just a single index to access the values, but if used in a context where a matrix is required are automatically converted to (or viewed as) a matrix.

Should the "get-row" or "get-col" function make a copy or just refer to the original matrix?

Making a copy could be expensive, and possibly unwanted in many contexts.
If a copy is required, it can be made explicitly by calling DenseMat (or some similar fn).

Refering to the original matrix might leave a "dangling pointer":

  M = 3x3 matrix;
  auto LastRow = row(M,2);
  M = 2x2 matrix;
  cout << LastRow(2) << endl;  /// What happens here?

If the matrix impl is ref counted then the object produced by row (or col) could maintain a counted pointer to the impl. This would then appear to the user as though a copy had been made.

Also, can elements in a row/col object be assigned to? [probably yes]
Should this then change the entry in the original matrix? [probably yes]
Assigning an element in a row object may cause an element in a col object to change value:

  M = 3x3 matrix;
  auto FirstRow = row(M,0);
  auto FirstCol = col(M,0);
  FirstRow[0] = -99;
  cout << FirstCol[0] << endl;  // should print -99!

What is the status of this issue? With luck we can soon close it!