The copy constructor should normally be avoided. More
details are available under the documentation for Array.
Matrix objects are two-dimensional specializations (e.g., more convenient and efficient indexing) of the general Array class. You might also want to look at the Array documentation to see inherited functionality. A tutorial on using the array classes in general is available in the "AIPS++ Programming Manual".
Generally the member functions of Array are also available in Matrix versions which take a pair of integers where the array needs an IPosition. Since the Matrix is two-dimensional, the IPositions are overkill, although you may use those versions if you want to.
Matrix<Int> mi(100,100); // Shape is 100x100
mi.resize(50,50); // Shape now 50x50
Slices may be taken with the Slice class. To take a slice, one "indexes" with one Slice(start, length, inc) for each axis, where end and inc are optional. Additionally, there are row(), column() and diagonal() member functions which return Vector's which refer to the storage back in the Matrix:
Matrix<Float> mf(100, 100);
mf.diagonal() = 1;
Correct indexing order of a matrix is:
Matrix<Int> mi(n1,n2) // [nrow, ncolumn]
for (uInt j=0; j<mi.ncolumn(); j++) {
for (uInt i=0; i<mi.nrow(); i++) {
mi(i,j) = i*j;
}
}
Element-by-element arithmetic and logical operations are available (in aips/ArrayMath.h and aips/ArrayLogical.h). Other Matrix operations (e.g. LU decomposition) are available, and more appear periodically.
As with the Arrays, if the preprocessor symbol AIPS_DEBUG is defined at compile time invariants will be checked on entry to most member functions. Additionally, if AIPS_ARRAY_INDEX_CHECK is defined index operations will be bounds-checked. Neither of these should be defined for production code.
A Matrix with "l1" rows and "l2" columns.
A Matrix with "l1" rows and "l2" columns. Fill it with the initial value.
A matrix of shape with shape "len".
A matrix of shape with shape "len". Fill it with the initial value.
The copy constructor uses reference semantics.
Construct a Matrix by reference from "other". "other must have ndim() of 2 or less. The warning which applies to the copy constructor is also valid here.
Create an Matrix of a given shape from a pointer.
Define a destructor, otherwise the (SUN) compiler makes a static one.
Assign the other array (which must be dimension 2) to this matrix. If the shapes mismatch, this array is resized.
Make this matrix a reference to other. Other must be of dimensionality 2 or less.
Resize to the given shape (must be 2-dimensional). Resize without argument is equal to resize(0,0).
Copy the values from other to this Matrix. If this matrix has zero elements then it will resize to be the same shape as other; otherwise other must conform to this. Note that the assign function can be used to assign a non-conforming matrix.
Copy val into every element of this Matrix; i.e. behaves as if val were a constant conformant matrix.
Copy to this those values in marray whose corresponding elements in marray's mask are True.
Single-pixel addressing. If AIPS_ARRAY_INDEX_CHECK is defined, bounds checking is performed.
The array is masked by the input LogicalArray. This mask must conform to the array.
Return a MaskedArray.
The array is masked by the input LogicalArray. This mask must conform to the array.
The array is masked by the input MaskedLogicalArray. The mask is effectively the AND of the internal LogicalArray and the internal mask of the MaskedLogicalArray. The MaskedLogicalArray must conform to the array.
Return a MaskedArray.
The array is masked by the input MaskedLogicalArray. The mask is effectively the AND of the internal LogicalArray and the internal mask of the MaskedLogicalArray. The MaskedLogicalArray must conform to the array.
Returns a reference to the i'th row.
Returns a reference to the j'th column
Returns a diagonal from the Matrix. The Matrix must be square.
n==0 is the main diagonal. n>0 is above the main diagonal, n<0 is below it.
Returns a diagonal from the Matrix. The Matrix must be square.
Take a slice of this matrix. Slices are always indexed starting at zero. This uses reference semantics, i.e. changing a value in the slice changes the original.
Matrix<Double> vd(100,100);
//...
vd(Slice(0,10),Slice(10,10)) = -1.0; // 10x10 sub-matrix set to -1.0
Slice using IPositions. Required to be defined, otherwise the base class versions are hidden.
The length of each axis of the Matrix.
The number of rows in the Matrix, i.e. the length of the first axis.
The number of columns in the Matrix, i.e. the length of the 2nd axis.
Replace the data values with those in the pointer storage. The results are undefined is storage does not point at nelements() or more data elements. After takeStorage() is called, unique() is True.
Since the pointer is const, a copy is always taken.
Replace the data values with those in the pointer storage. The results are undefined is storage does not point at nelements() or more data elements. After takeStorage() is called, unique() is True.
Checks that the Matrix is consistent (invariants check out).
Helper fn to calculate the indexing constants.