/// <inheritdoc/>
public FieldMatrix <T> multiply(FieldMatrix <T> m)
{
// safety check
checkMultiplicationCompatible(m);
int nRows = getRowDimension();
int nCols = m.getColumnDimension();
int nSum = getColumnDimension();
FieldMatrix <T> outp = createMatrix(nRows, nCols);
for (int row = 0; row < nRows; ++row)
{
for (int col = 0; col < nCols; ++col)
{
T sum = field.getZero();
for (int i = 0; i < nSum; ++i)
{
sum = sum.add(getEntry(row, i).multiply(m.getEntry(i, col)));
}
outp.setEntry(row, col, sum);
}
}
return(outp);
}
/// <summary>
/// Returns the matrix L of the decomposition.
/// <para>L is a lower-triangular matrix</para>
/// </summary>
/// <returns>the L matrix (or null if decomposed matrix is singular)</returns>
public FieldMatrix <T> getL()
{
if ((cachedL == null) && !singular)
{
int m = pivot.Length;
cachedL = new Array2DRowFieldMatrix <T>(field, m, m);
for (int i = 0; i < m; ++i)
{
T[] luI = lu[i];
for (int j = 0; j < i; ++j)
{
cachedL.setEntry(i, j, luI[j]);
}
cachedL.setEntry(i, i, field.getOne());
}
}
return(cachedL);
}
/// <summary>
/// Returns a diagonal matrix with specified elements.
/// </summary>
/// <typeparam name="T">the type of the field elements</typeparam>
/// <param name="diagonal">diagonal elements of the matrix (the array elements
/// will be copied)</param>
/// <returns>diagonal matrix</returns>
public static FieldMatrix <T> createFieldDiagonalMatrix <T>(T[] diagonal) where T : FieldElement <T>
{
FieldMatrix <T> m =
createFieldMatrix(diagonal[0].getField(), diagonal.Length, diagonal.Length);
for (int i = 0; i < diagonal.Length; ++i)
{
m.setEntry(i, i, diagonal[i]);
}
return(m);
}
/// <inheritdoc/>
public FieldMatrix <T> getColumnMatrix(int column)
{
checkColumnIndex(column);
int nRows = getRowDimension();
FieldMatrix <T> outp = createMatrix(nRows, 1);
for (int i = 0; i < nRows; ++i)
{
outp.setEntry(i, 0, getEntry(i, column));
}
return(outp);
}
/// <inheritdoc/>
public FieldMatrix <T> getRowMatrix(int row)
{
checkRowIndex(row);
int nCols = getColumnDimension();
FieldMatrix <T> outp = createMatrix(1, nCols);
for (int i = 0; i < nCols; ++i)
{
outp.setEntry(0, i, getEntry(row, i));
}
return(outp);
}
/// <summary>
/// Returns the P rows permutation matrix.
/// <para>P is a sparse matrix with exactly one element set to 1.0 in
/// each row and each column, all other elements being set to 0.0.</para>
/// <para>The positions of the 1 elements are given by the <see cref="getPivot()">
/// pivot permutation vector</see>.</para>
/// </summary>
/// <returns>the P rows permutation matrix (or null if decomposed matrix is singular)
/// </returns>
/// <remarks>
/// See <see cref="getPivot()"/>
/// </remarks>
public FieldMatrix <T> getP()
{
if ((cachedP == null) && !singular)
{
int m = pivot.Length;
cachedP = new Array2DRowFieldMatrix <T>(field, m, m);
for (int i = 0; i < m; ++i)
{
cachedP.setEntry(i, pivot[i], field.getOne());
}
}
return(cachedP);
}
/// <inheritdoc/>
public FieldMatrix <T> scalarAdd(T d)
{
int rowCount = getRowDimension();
int columnCount = getColumnDimension();
FieldMatrix <T> outp = createMatrix(rowCount, columnCount);
for (int row = 0; row < rowCount; ++row)
{
for (int col = 0; col < columnCount; ++col)
{
outp.setEntry(row, col, getEntry(row, col).add(d));
}
}
return(outp);
}
/// <inheritdoc/>
public FieldMatrix <T> getSubMatrix(int startRow, int endRow, int startColumn, int endColumn)
{
checkSubMatrixIndex(startRow, endRow, startColumn, endColumn);
FieldMatrix <T> subMatrix = createMatrix(endRow - startRow + 1, endColumn - startColumn + 1);
for (int i = startRow; i <= endRow; ++i)
{
for (int j = startColumn; j <= endColumn; ++j)
{
subMatrix.setEntry(i - startRow, j - startColumn, getEntry(i, j));
}
}
return(subMatrix);
}
/// <summary>
/// Returns the matrix U of the decomposition.
/// <para>U is an upper-triangular matrix</para>
/// </summary>
/// <returns>the U matrix (or null if decomposed matrix is singular)</returns>
public FieldMatrix <T> getU()
{
if ((cachedU == null) && !singular)
{
int m = pivot.Length;
cachedU = new Array2DRowFieldMatrix <T>(field, m, m);
for (int i = 0; i < m; ++i)
{
T[] luI = lu[i];
for (int j = i; j < m; ++j)
{
cachedU.setEntry(i, j, luI[j]);
}
}
}
return(cachedU);
}
/// <inheritdoc/>
public FieldMatrix <T> subtract(FieldMatrix <T> m)
{
// safety check
checkSubtractionCompatible(m);
int rowCount = getRowDimension();
int columnCount = getColumnDimension();
FieldMatrix <T> outp = createMatrix(rowCount, columnCount);
for (int row = 0; row < rowCount; ++row)
{
for (int col = 0; col < columnCount; ++col)
{
outp.setEntry(row, col, getEntry(row, col).subtract(m.getEntry(row, col)));
}
}
return(outp);
}
/// <summary>
/// Creates a column <see cref="FieldMatrix"/> using the data from the input
/// array.
/// </summary>
/// <typeparam name="T">the type of the field elements</typeparam>
/// <param name="columnData">the input column data</param>
/// <returns>a columnData x 1 FieldMatrix</returns>
/// <exception cref="NoDataException"> if <c>data</c> is empty.</exception>
/// <exception cref="NullArgumentException"> if <c>columnData</c> is <c>null</c>.
/// </exception>
public static FieldMatrix <T> createColumnFieldMatrix <T>(T[] columnData) where T : FieldElement <T>
{
if (columnData == null)
{
throw new NullArgumentException();
}
int nRows = columnData.Length;
if (nRows == 0)
{
throw new NoDataException(new LocalizedFormats("AT_LEAST_ONE_ROW"));
}
FieldMatrix <T> m = createFieldMatrix(columnData[0].getField(), nRows, 1);
for (int i = 0; i < nRows; ++i)
{
m.setEntry(i, 0, columnData[i]);
}
return(m);
}
/// <summary>
/// Create a row <see cref="FieldMatrix"/> using the data from the input
/// array.
/// </summary>
/// <typeparam name="T">the type of the field elements</typeparam>
/// <param name="rowData">the input row data</param>
/// <returns>a 1 x rowData.length FieldMatrix</returns>
/// <exception cref="NoDataException"> if <c>rowData</c> is empty.</exception>
/// <exception cref="NullArgumentException"> if <c>rowData</c> is <c>null</c>.</exception>
public static FieldMatrix <T> createRowFieldMatrix <T>(T[] rowData) where T : FieldElement <T>
{
if (rowData == null)
{
throw new NullArgumentException();
}
int nCols = rowData.Length;
if (nCols == 0)
{
throw new NoDataException(new LocalizedFormats("AT_LEAST_ONE_COLUMN"));
}
FieldMatrix <T> m = createFieldMatrix(rowData[0].getField(), 1, nCols);
for (int i = 0; i < nCols; ++i)
{
m.setEntry(0, i, rowData[i]);
}
return(m);
}
/// <inheritdoc/>
public new void visit(int row, int column, U value)
{
outp.setEntry(column, row, value);
}
