Apache
/
commons-math
mirror of https://github.com/apache/commons-math.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

renamed Dense{Real/Field}Matrix into Block{Real/Field}Matrix 

as suggested by Phil in http://markmail.org/message/iibgiz4bsv6hjjvh

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/math/trunk@783678 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Luc Maisonobe 2009-06-11 08:05:24 +00:00
parent 9d4fb6760b
commit 37ee8dbfe6
23 changed files with 391 additions and 385 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
findbugs-exclude-filter.xml
View File

@ -110,7 +110,7 @@
<Bug pattern="EI_EXPOSE_REP" /> <Bug pattern="EI_EXPOSE_REP" />
</Match> </Match>
<Match> <Match>
<Class name="org.apache.commons.math.linear.DenseFieldMatrix"/> <Class name="org.apache.commons.math.linear.BlockFieldMatrix"/>
<Method name="&lt;init>" params="int,int,org.apache.commons.math.FieldElement[][],boolean" returns="void" /> <Method name="&lt;init>" params="int,int,org.apache.commons.math.FieldElement[][],boolean" returns="void" />
<Bug pattern="EI_EXPOSE_REP2" /> <Bug pattern="EI_EXPOSE_REP2" />
</Match> </Match>
@ -125,7 +125,7 @@
<Bug pattern="EI_EXPOSE_REP" /> <Bug pattern="EI_EXPOSE_REP" />
</Match> </Match>
<Match> <Match>
<Class name="org.apache.commons.math.linear.DenseRealMatrix"/> <Class name="org.apache.commons.math.linear.BlockRealMatrix"/>
<Method name="&lt;init>" params="int,int,double[][],boolean" returns="void" /> <Method name="&lt;init>" params="int,int,double[][],boolean" returns="void" />
<Bug pattern="EI_EXPOSE_REP2" /> <Bug pattern="EI_EXPOSE_REP2" />
</Match> </Match>

2
src/java/org/apache/commons/math/MessagesResources_fr.java
View File

@ -421,7 +421,7 @@ public class MessagesResources_fr
{ "{0}x{1} and {2}x{3} matrices are not multiplication compatible", { "{0}x{1} and {2}x{3} matrices are not multiplication compatible",
"les dimensions {0}x{1} et {2}x{3} sont incompatibles pour la multiplication matricielle" }, "les dimensions {0}x{1} et {2}x{3} sont incompatibles pour la multiplication matricielle" },
// org.apache.commons.math.linear.DenseRealMatrix // org.apache.commons.math.linear.BlockRealMatrix
{ "wrong array shape (block length = {0}, expected {1})", { "wrong array shape (block length = {0}, expected {1})",
"forme de tableau erron\u00e9e (bloc de longueur {0} au lieu des {1} attendus)" }, "forme de tableau erron\u00e9e (bloc de longueur {0} au lieu des {1} attendus)" },

74
src/java/org/apache/commons/math/linear/DenseFieldMatrix.java → src/java/org/apache/commons/math/linear/BlockFieldMatrix.java
View File

@ -63,7 +63,7 @@ import org.apache.commons.math.MathRuntimeException;
* @version $Revision$ $Date$ * @version $Revision$ $Date$
* @since 2.0 * @since 2.0
*/ */
public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMatrix<T> implements Serializable { public class BlockFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMatrix<T> implements Serializable {
/** Serializable version identifier */ /** Serializable version identifier */
private static final long serialVersionUID = -4602336630143123183L; private static final long serialVersionUID = -4602336630143123183L;
@ -95,7 +95,7 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
* @throws IllegalArgumentException if row or column dimension is not * @throws IllegalArgumentException if row or column dimension is not
* positive * positive
*/ */
public DenseFieldMatrix(final Field<T> field, final int rows, final int columns) public BlockFieldMatrix(final Field<T> field, final int rows, final int columns)
throws IllegalArgumentException { throws IllegalArgumentException {
super(field, rows, columns); super(field, rows, columns);
@ -115,16 +115,16 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
* Create a new dense matrix copying entries from raw layout data. * Create a new dense matrix copying entries from raw layout data.
* <p>The input array <em>must</em> already be in raw layout.</p> * <p>The input array <em>must</em> already be in raw layout.</p>
* <p>Calling this constructor is equivalent to call: * <p>Calling this constructor is equivalent to call:
* <pre>matrix = new DenseFieldMatrix<T>(getField(), rawData.length, rawData[0].length, * <pre>matrix = new BlockFieldMatrix<T>(getField(), rawData.length, rawData[0].length,
* toBlocksLayout(rawData), false);</pre> * toBlocksLayout(rawData), false);</pre>
* </p> * </p>
* @param rawData data for new matrix, in raw layout * @param rawData data for new matrix, in raw layout
* *
* @exception IllegalArgumentException if <code>blockData</code> shape is * @exception IllegalArgumentException if <code>blockData</code> shape is
* inconsistent with block layout * inconsistent with block layout
* @see #DenseFieldMatrix(int, int, FieldElement[][], boolean) * @see #BlockFieldMatrix(int, int, FieldElement[][], boolean)
*/ */
public DenseFieldMatrix(final T[][] rawData) public BlockFieldMatrix(final T[][] rawData)
throws IllegalArgumentException { throws IllegalArgumentException {
this(rawData.length, rawData[0].length, toBlocksLayout(rawData), false); this(rawData.length, rawData[0].length, toBlocksLayout(rawData), false);
} }
@ -142,9 +142,9 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
* inconsistent with block layout * inconsistent with block layout
* @see #createBlocksLayout(Field, int, int) * @see #createBlocksLayout(Field, int, int)
* @see #toBlocksLayout(FieldElement[][]) * @see #toBlocksLayout(FieldElement[][])
* @see #DenseFieldMatrix(FieldElement[][]) * @see #BlockFieldMatrix(FieldElement[][])
*/ */
public DenseFieldMatrix(final int rows, final int columns, public BlockFieldMatrix(final int rows, final int columns,
final T[][] blockData, final boolean copyArray) final T[][] blockData, final boolean copyArray)
throws IllegalArgumentException { throws IllegalArgumentException {
@ -186,7 +186,7 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
* <p> * <p>
* Raw layout is the straightforward layout where element at row i and * Raw layout is the straightforward layout where element at row i and
* column j is in array element <code>rawData[i][j]</code>. Blocks layout * column j is in array element <code>rawData[i][j]</code>. Blocks layout
* is the layout used in {@link DenseFieldMatrix} instances, where the matrix * is the layout used in {@link BlockFieldMatrix} instances, where the matrix
* is split in square blocks (except at right and bottom side where blocks may * is split in square blocks (except at right and bottom side where blocks may
* be rectangular to fit matrix size) and each block is stored in a flattened * be rectangular to fit matrix size) and each block is stored in a flattened
* one-dimensional array. * one-dimensional array.
@ -194,7 +194,7 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
* <p> * <p>
* This method creates an array in blocks layout from an input array in raw layout. * This method creates an array in blocks layout from an input array in raw layout.
* It can be used to provide the array argument of the {@link * It can be used to provide the array argument of the {@link
* DenseFieldMatrix#DenseFieldMatrix(int, int, FieldElement[][], boolean)} * BlockFieldMatrix#DenseFieldMatrix(int, int, FieldElement[][], boolean)}
* constructor. * constructor.
* </p> * </p>
* @param <T> the type of the field elements * @param <T> the type of the field elements
@ -203,7 +203,7 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
* @exception IllegalArgumentException if <code>rawData</code> is not rectangular * @exception IllegalArgumentException if <code>rawData</code> is not rectangular
* (not all rows have the same length) * (not all rows have the same length)
* @see #createBlocksLayout(Field, int, int) * @see #createBlocksLayout(Field, int, int)
* @see #DenseFieldMatrix(int, int, FieldElement[][], boolean) * @see #BlockFieldMatrix(int, int, FieldElement[][], boolean)
*/ */
public static <T extends FieldElement<T>> T[][] toBlocksLayout(final T[][] rawData) public static <T extends FieldElement<T>> T[][] toBlocksLayout(final T[][] rawData)
throws IllegalArgumentException { throws IllegalArgumentException {
@ -255,7 +255,7 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
* Create a data array in blocks layout. * Create a data array in blocks layout.
* <p> * <p>
* This method can be used to create the array argument of the {@link * This method can be used to create the array argument of the {@link
* DenseFieldMatrix#DenseFieldMatrix(int, int, FieldElement[][], boolean)} * BlockFieldMatrix#DenseFieldMatrix(int, int, FieldElement[][], boolean)}
* constructor. * constructor.
* </p> * </p>
* @param <T> the type of the field elements * @param <T> the type of the field elements
@ -264,7 +264,7 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
* @param columns the number of columns in the new matrix * @param columns the number of columns in the new matrix
* @return a new data array in blocks layout * @return a new data array in blocks layout
* @see #toBlocksLayout(FieldElement[][]) * @see #toBlocksLayout(FieldElement[][])
* @see #DenseFieldMatrix(int, int, FieldElement[][], boolean) * @see #BlockFieldMatrix(int, int, FieldElement[][], boolean)
*/ */
public static <T extends FieldElement<T>> T[][] createBlocksLayout(final Field<T> field, public static <T extends FieldElement<T>> T[][] createBlocksLayout(final Field<T> field,
final int rows, final int columns) { final int rows, final int columns) {
@ -293,7 +293,7 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
@Override @Override
public FieldMatrix<T> createMatrix(final int rowDimension, final int columnDimension) public FieldMatrix<T> createMatrix(final int rowDimension, final int columnDimension)
throws IllegalArgumentException { throws IllegalArgumentException {
return new DenseFieldMatrix<T>(getField(), rowDimension, columnDimension); return new BlockFieldMatrix<T>(getField(), rowDimension, columnDimension);
} }
/** {@inheritDoc} */ /** {@inheritDoc} */
@ -301,7 +301,7 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
public FieldMatrix<T> copy() { public FieldMatrix<T> copy() {
// create an empty matrix // create an empty matrix
DenseFieldMatrix<T> copied = new DenseFieldMatrix<T>(getField(), rows, columns); BlockFieldMatrix<T> copied = new BlockFieldMatrix<T>(getField(), rows, columns);
// copy the blocks // copy the blocks
for (int i = 0; i < blocks.length; ++i) { for (int i = 0; i < blocks.length; ++i) {
@ -317,13 +317,13 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
public FieldMatrix<T> add(final FieldMatrix<T> m) public FieldMatrix<T> add(final FieldMatrix<T> m)
throws IllegalArgumentException { throws IllegalArgumentException {
try { try {
return add((DenseFieldMatrix<T>) m); return add((BlockFieldMatrix<T>) m);
} catch (ClassCastException cce) { } catch (ClassCastException cce) {
// safety check // safety check
checkAdditionCompatible(m); checkAdditionCompatible(m);
final DenseFieldMatrix<T> out = new DenseFieldMatrix<T>(getField(), rows, columns); final BlockFieldMatrix<T> out = new BlockFieldMatrix<T>(getField(), rows, columns);
// perform addition block-wise, to ensure good cache behavior // perform addition block-wise, to ensure good cache behavior
int blockIndex = 0; int blockIndex = 0;
@ -361,13 +361,13 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
* @return this + m * @return this + m
* @throws IllegalArgumentException if m is not the same size as this * @throws IllegalArgumentException if m is not the same size as this
*/ */
public DenseFieldMatrix<T> add(final DenseFieldMatrix<T> m) public BlockFieldMatrix<T> add(final BlockFieldMatrix<T> m)
throws IllegalArgumentException { throws IllegalArgumentException {
// safety check // safety check
checkAdditionCompatible(m); checkAdditionCompatible(m);
final DenseFieldMatrix<T> out = new DenseFieldMatrix<T>(getField(), rows, columns); final BlockFieldMatrix<T> out = new BlockFieldMatrix<T>(getField(), rows, columns);
// perform addition block-wise, to ensure good cache behavior // perform addition block-wise, to ensure good cache behavior
for (int blockIndex = 0; blockIndex < out.blocks.length; ++blockIndex) { for (int blockIndex = 0; blockIndex < out.blocks.length; ++blockIndex) {
@ -388,13 +388,13 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
public FieldMatrix<T> subtract(final FieldMatrix<T> m) public FieldMatrix<T> subtract(final FieldMatrix<T> m)
throws IllegalArgumentException { throws IllegalArgumentException {
try { try {
return subtract((DenseFieldMatrix<T>) m); return subtract((BlockFieldMatrix<T>) m);
} catch (ClassCastException cce) { } catch (ClassCastException cce) {
// safety check // safety check
checkSubtractionCompatible(m); checkSubtractionCompatible(m);
final DenseFieldMatrix<T> out = new DenseFieldMatrix<T>(getField(), rows, columns); final BlockFieldMatrix<T> out = new BlockFieldMatrix<T>(getField(), rows, columns);
// perform subtraction block-wise, to ensure good cache behavior // perform subtraction block-wise, to ensure good cache behavior
int blockIndex = 0; int blockIndex = 0;
@ -432,13 +432,13 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
* @return this - m * @return this - m
* @throws IllegalArgumentException if m is not the same size as this * @throws IllegalArgumentException if m is not the same size as this
*/ */
public DenseFieldMatrix<T> subtract(final DenseFieldMatrix<T> m) public BlockFieldMatrix<T> subtract(final BlockFieldMatrix<T> m)
throws IllegalArgumentException { throws IllegalArgumentException {
// safety check // safety check
checkSubtractionCompatible(m); checkSubtractionCompatible(m);
final DenseFieldMatrix<T> out = new DenseFieldMatrix<T>(getField(), rows, columns); final BlockFieldMatrix<T> out = new BlockFieldMatrix<T>(getField(), rows, columns);
// perform subtraction block-wise, to ensure good cache behavior // perform subtraction block-wise, to ensure good cache behavior
for (int blockIndex = 0; blockIndex < out.blocks.length; ++blockIndex) { for (int blockIndex = 0; blockIndex < out.blocks.length; ++blockIndex) {
@ -459,7 +459,7 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
public FieldMatrix<T> scalarAdd(final T d) public FieldMatrix<T> scalarAdd(final T d)
throws IllegalArgumentException { throws IllegalArgumentException {
final DenseFieldMatrix<T> out = new DenseFieldMatrix<T>(getField(), rows, columns); final BlockFieldMatrix<T> out = new BlockFieldMatrix<T>(getField(), rows, columns);
// perform subtraction block-wise, to ensure good cache behavior // perform subtraction block-wise, to ensure good cache behavior
for (int blockIndex = 0; blockIndex < out.blocks.length; ++blockIndex) { for (int blockIndex = 0; blockIndex < out.blocks.length; ++blockIndex) {
@ -479,7 +479,7 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
public FieldMatrix<T> scalarMultiply(final T d) public FieldMatrix<T> scalarMultiply(final T d)
throws IllegalArgumentException { throws IllegalArgumentException {
final DenseFieldMatrix<T> out = new DenseFieldMatrix<T>(getField(), rows, columns); final BlockFieldMatrix<T> out = new BlockFieldMatrix<T>(getField(), rows, columns);
// perform subtraction block-wise, to ensure good cache behavior // perform subtraction block-wise, to ensure good cache behavior
for (int blockIndex = 0; blockIndex < out.blocks.length; ++blockIndex) { for (int blockIndex = 0; blockIndex < out.blocks.length; ++blockIndex) {
@ -499,13 +499,13 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
public FieldMatrix<T> multiply(final FieldMatrix<T> m) public FieldMatrix<T> multiply(final FieldMatrix<T> m)
throws IllegalArgumentException { throws IllegalArgumentException {
try { try {
return multiply((DenseFieldMatrix<T>) m); return multiply((BlockFieldMatrix<T>) m);
} catch (ClassCastException cce) { } catch (ClassCastException cce) {
// safety check // safety check
checkMultiplicationCompatible(m); checkMultiplicationCompatible(m);
final DenseFieldMatrix<T> out = new DenseFieldMatrix<T>(getField(), rows, m.getColumnDimension()); final BlockFieldMatrix<T> out = new BlockFieldMatrix<T>(getField(), rows, m.getColumnDimension());
final T zero = getField().getZero(); final T zero = getField().getZero();
// perform multiplication block-wise, to ensure good cache behavior // perform multiplication block-wise, to ensure good cache behavior
@ -561,12 +561,12 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
* @throws IllegalArgumentException * @throws IllegalArgumentException
* if columnDimension(this) != rowDimension(m) * if columnDimension(this) != rowDimension(m)
*/ */
public DenseFieldMatrix<T> multiply(DenseFieldMatrix<T> m) throws IllegalArgumentException { public BlockFieldMatrix<T> multiply(BlockFieldMatrix<T> m) throws IllegalArgumentException {
// safety check // safety check
checkMultiplicationCompatible(m); checkMultiplicationCompatible(m);
final DenseFieldMatrix<T> out = new DenseFieldMatrix<T>(getField(), rows, m.columns); final BlockFieldMatrix<T> out = new BlockFieldMatrix<T>(getField(), rows, m.columns);
final T zero = getField().getZero(); final T zero = getField().getZero();
// perform multiplication block-wise, to ensure good cache behavior // perform multiplication block-wise, to ensure good cache behavior
@ -666,8 +666,8 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
checkSubMatrixIndex(startRow, endRow, startColumn, endColumn); checkSubMatrixIndex(startRow, endRow, startColumn, endColumn);
// create the output matrix // create the output matrix
final DenseFieldMatrix<T> out = final BlockFieldMatrix<T> out =
new DenseFieldMatrix<T>(getField(), endRow - startRow + 1, endColumn - startColumn + 1); new BlockFieldMatrix<T>(getField(), endRow - startRow + 1, endColumn - startColumn + 1);
// compute blocks shifts // compute blocks shifts
final int blockStartRow = startRow / BLOCK_SIZE; final int blockStartRow = startRow / BLOCK_SIZE;
@ -839,7 +839,7 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
throws MatrixIndexException { throws MatrixIndexException {
checkRowIndex(row); checkRowIndex(row);
final DenseFieldMatrix<T> out = new DenseFieldMatrix<T>(getField(), 1, columns); final BlockFieldMatrix<T> out = new BlockFieldMatrix<T>(getField(), 1, columns);
// perform copy block-wise, to ensure good cache behavior // perform copy block-wise, to ensure good cache behavior
final int iBlock = row / BLOCK_SIZE; final int iBlock = row / BLOCK_SIZE;
@ -871,7 +871,7 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
public void setRowMatrix(final int row, final FieldMatrix<T> matrix) public void setRowMatrix(final int row, final FieldMatrix<T> matrix)
throws MatrixIndexException, InvalidMatrixException { throws MatrixIndexException, InvalidMatrixException {
try { try {
setRowMatrix(row, (DenseFieldMatrix<T>) matrix); setRowMatrix(row, (BlockFieldMatrix<T>) matrix);
} catch (ClassCastException cce) { } catch (ClassCastException cce) {
super.setRowMatrix(row, matrix); super.setRowMatrix(row, matrix);
} }
@ -888,7 +888,7 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
* @throws InvalidMatrixException if the matrix dimensions do not match one * @throws InvalidMatrixException if the matrix dimensions do not match one
* instance row * instance row
*/ */
public void setRowMatrix(final int row, final DenseFieldMatrix<T> matrix) public void setRowMatrix(final int row, final BlockFieldMatrix<T> matrix)
throws MatrixIndexException, InvalidMatrixException { throws MatrixIndexException, InvalidMatrixException {
checkRowIndex(row); checkRowIndex(row);
@ -930,7 +930,7 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
throws MatrixIndexException { throws MatrixIndexException {
checkColumnIndex(column); checkColumnIndex(column);
final DenseFieldMatrix<T> out = new DenseFieldMatrix<T>(getField(), rows, 1); final BlockFieldMatrix<T> out = new BlockFieldMatrix<T>(getField(), rows, 1);
// perform copy block-wise, to ensure good cache behavior // perform copy block-wise, to ensure good cache behavior
final int jBlock = column / BLOCK_SIZE; final int jBlock = column / BLOCK_SIZE;
@ -960,7 +960,7 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
public void setColumnMatrix(final int column, final FieldMatrix<T> matrix) public void setColumnMatrix(final int column, final FieldMatrix<T> matrix)
throws MatrixIndexException, InvalidMatrixException { throws MatrixIndexException, InvalidMatrixException {
try { try {
setColumnMatrix(column, (DenseFieldMatrix<T>) matrix); setColumnMatrix(column, (BlockFieldMatrix<T>) matrix);
} catch (ClassCastException cce) { } catch (ClassCastException cce) {
super.setColumnMatrix(column, matrix); super.setColumnMatrix(column, matrix);
} }
@ -977,7 +977,7 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
* @throws InvalidMatrixException if the matrix dimensions do not match one * @throws InvalidMatrixException if the matrix dimensions do not match one
* instance column * instance column
*/ */
void setColumnMatrix(final int column, final DenseFieldMatrix<T> matrix) void setColumnMatrix(final int column, final BlockFieldMatrix<T> matrix)
throws MatrixIndexException, InvalidMatrixException { throws MatrixIndexException, InvalidMatrixException {
checkColumnIndex(column); checkColumnIndex(column);
@ -1259,7 +1259,7 @@ public class DenseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
final int nRows = getRowDimension(); final int nRows = getRowDimension();
final int nCols = getColumnDimension(); final int nCols = getColumnDimension();
final DenseFieldMatrix<T> out = new DenseFieldMatrix<T>(getField(), nCols, nRows); final BlockFieldMatrix<T> out = new BlockFieldMatrix<T>(getField(), nCols, nRows);
// perform transpose block-wise, to ensure good cache behavior // perform transpose block-wise, to ensure good cache behavior
int blockIndex = 0; int blockIndex = 0;

94
src/java/org/apache/commons/math/linear/DenseRealMatrix.java → src/java/org/apache/commons/math/linear/BlockRealMatrix.java
View File

@ -61,7 +61,7 @@ import org.apache.commons.math.MathRuntimeException;
* @version $Revision$ $Date$ * @version $Revision$ $Date$
* @since 2.0 * @since 2.0
*/ */
public class DenseRealMatrix extends AbstractRealMatrix implements Serializable { public class BlockRealMatrix extends AbstractRealMatrix implements Serializable {
/** Serializable version identifier */ /** Serializable version identifier */
private static final long serialVersionUID = 4991895511313664478L; private static final long serialVersionUID = 4991895511313664478L;
@ -92,7 +92,7 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
* @throws IllegalArgumentException if row or column dimension is not * @throws IllegalArgumentException if row or column dimension is not
* positive * positive
*/ */
public DenseRealMatrix(final int rows, final int columns) public BlockRealMatrix(final int rows, final int columns)
throws IllegalArgumentException { throws IllegalArgumentException {
super(rows, columns); super(rows, columns);
@ -112,16 +112,16 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
* Create a new dense matrix copying entries from raw layout data. * Create a new dense matrix copying entries from raw layout data.
* <p>The input array <em>must</em> already be in raw layout.</p> * <p>The input array <em>must</em> already be in raw layout.</p>
* <p>Calling this constructor is equivalent to call: * <p>Calling this constructor is equivalent to call:
* <pre>matrix = new DenseRealMatrix(rawData.length, rawData[0].length, * <pre>matrix = new BlockRealMatrix(rawData.length, rawData[0].length,
* toBlocksLayout(rawData), false);</pre> * toBlocksLayout(rawData), false);</pre>
* </p> * </p>
* @param rawData data for new matrix, in raw layout * @param rawData data for new matrix, in raw layout
* *
* @exception IllegalArgumentException if <code>blockData</code> shape is * @exception IllegalArgumentException if <code>blockData</code> shape is
* inconsistent with block layout * inconsistent with block layout
* @see #DenseRealMatrix(int, int, double[][], boolean) * @see #BlockRealMatrix(int, int, double[][], boolean)
*/ */
public DenseRealMatrix(final double[][] rawData) public BlockRealMatrix(final double[][] rawData)
throws IllegalArgumentException { throws IllegalArgumentException {
this(rawData.length, rawData[0].length, toBlocksLayout(rawData), false); this(rawData.length, rawData[0].length, toBlocksLayout(rawData), false);
} }
@ -139,9 +139,9 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
* inconsistent with block layout * inconsistent with block layout
* @see #createBlocksLayout(int, int) * @see #createBlocksLayout(int, int)
* @see #toBlocksLayout(double[][]) * @see #toBlocksLayout(double[][])
* @see #DenseRealMatrix(double[][]) * @see #BlockRealMatrix(double[][])
*/ */
public DenseRealMatrix(final int rows, final int columns, public BlockRealMatrix(final int rows, final int columns,
final double[][] blockData, final boolean copyArray) final double[][] blockData, final boolean copyArray)
throws IllegalArgumentException { throws IllegalArgumentException {
@ -183,7 +183,7 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
* <p> * <p>
* Raw layout is the straightforward layout where element at row i and * Raw layout is the straightforward layout where element at row i and
* column j is in array element <code>rawData[i][j]</code>. Blocks layout * column j is in array element <code>rawData[i][j]</code>. Blocks layout
* is the layout used in {@link DenseRealMatrix} instances, where the matrix * is the layout used in {@link BlockRealMatrix} instances, where the matrix
* is split in square blocks (except at right and bottom side where blocks may * is split in square blocks (except at right and bottom side where blocks may
* be rectangular to fit matrix size) and each block is stored in a flattened * be rectangular to fit matrix size) and each block is stored in a flattened
* one-dimensional array. * one-dimensional array.
@ -191,14 +191,14 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
* <p> * <p>
* This method creates an array in blocks layout from an input array in raw layout. * This method creates an array in blocks layout from an input array in raw layout.
* It can be used to provide the array argument of the {@link * It can be used to provide the array argument of the {@link
* DenseRealMatrix#DenseRealMatrix(int, int, double[][], boolean)} constructor. * BlockRealMatrix#DenseRealMatrix(int, int, double[][], boolean)} constructor.
* </p> * </p>
* @param rawData data array in raw layout * @param rawData data array in raw layout
* @return a new data array containing the same entries but in blocks layout * @return a new data array containing the same entries but in blocks layout
* @exception IllegalArgumentException if <code>rawData</code> is not rectangular * @exception IllegalArgumentException if <code>rawData</code> is not rectangular
* (not all rows have the same length) * (not all rows have the same length)
* @see #createBlocksLayout(int, int) * @see #createBlocksLayout(int, int)
* @see #DenseRealMatrix(int, int, double[][], boolean) * @see #BlockRealMatrix(int, int, double[][], boolean)
*/ */
public static double[][] toBlocksLayout(final double[][] rawData) public static double[][] toBlocksLayout(final double[][] rawData)
throws IllegalArgumentException { throws IllegalArgumentException {
@ -249,13 +249,13 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
* Create a data array in blocks layout. * Create a data array in blocks layout.
* <p> * <p>
* This method can be used to create the array argument of the {@link * This method can be used to create the array argument of the {@link
* DenseRealMatrix#DenseRealMatrix(int, int, double[][], boolean)} constructor. * BlockRealMatrix#DenseRealMatrix(int, int, double[][], boolean)} constructor.
* </p> * </p>
* @param rows the number of rows in the new matrix * @param rows the number of rows in the new matrix
* @param columns the number of columns in the new matrix * @param columns the number of columns in the new matrix
* @return a new data array in blocks layout * @return a new data array in blocks layout
* @see #toBlocksLayout(double[][]) * @see #toBlocksLayout(double[][])
* @see #DenseRealMatrix(int, int, double[][], boolean) * @see #BlockRealMatrix(int, int, double[][], boolean)
*/ */
public static double[][] createBlocksLayout(final int rows, final int columns) { public static double[][] createBlocksLayout(final int rows, final int columns) {
@ -281,17 +281,17 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
/** {@inheritDoc} */ /** {@inheritDoc} */
@Override @Override
public DenseRealMatrix createMatrix(final int rowDimension, final int columnDimension) public BlockRealMatrix createMatrix(final int rowDimension, final int columnDimension)
throws IllegalArgumentException { throws IllegalArgumentException {
return new DenseRealMatrix(rowDimension, columnDimension); return new BlockRealMatrix(rowDimension, columnDimension);
} }
/** {@inheritDoc} */ /** {@inheritDoc} */
@Override @Override
public DenseRealMatrix copy() { public BlockRealMatrix copy() {
// create an empty matrix // create an empty matrix
DenseRealMatrix copied = new DenseRealMatrix(rows, columns); BlockRealMatrix copied = new BlockRealMatrix(rows, columns);
// copy the blocks // copy the blocks
for (int i = 0; i < blocks.length; ++i) { for (int i = 0; i < blocks.length; ++i) {
@ -304,16 +304,16 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
/** {@inheritDoc} */ /** {@inheritDoc} */
@Override @Override
public DenseRealMatrix add(final RealMatrix m) public BlockRealMatrix add(final RealMatrix m)
throws IllegalArgumentException { throws IllegalArgumentException {
try { try {
return add((DenseRealMatrix) m); return add((BlockRealMatrix) m);
} catch (ClassCastException cce) { } catch (ClassCastException cce) {
// safety check // safety check
MatrixUtils.checkAdditionCompatible(this, m); MatrixUtils.checkAdditionCompatible(this, m);
final DenseRealMatrix out = new DenseRealMatrix(rows, columns); final BlockRealMatrix out = new BlockRealMatrix(rows, columns);
// perform addition block-wise, to ensure good cache behavior // perform addition block-wise, to ensure good cache behavior
int blockIndex = 0; int blockIndex = 0;
@ -351,13 +351,13 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
* @return this + m * @return this + m
* @throws IllegalArgumentException if m is not the same size as this * @throws IllegalArgumentException if m is not the same size as this
*/ */
public DenseRealMatrix add(final DenseRealMatrix m) public BlockRealMatrix add(final BlockRealMatrix m)
throws IllegalArgumentException { throws IllegalArgumentException {
// safety check // safety check
MatrixUtils.checkAdditionCompatible(this, m); MatrixUtils.checkAdditionCompatible(this, m);
final DenseRealMatrix out = new DenseRealMatrix(rows, columns); final BlockRealMatrix out = new BlockRealMatrix(rows, columns);
// perform addition block-wise, to ensure good cache behavior // perform addition block-wise, to ensure good cache behavior
for (int blockIndex = 0; blockIndex < out.blocks.length; ++blockIndex) { for (int blockIndex = 0; blockIndex < out.blocks.length; ++blockIndex) {
@ -375,16 +375,16 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
/** {@inheritDoc} */ /** {@inheritDoc} */
@Override @Override
public DenseRealMatrix subtract(final RealMatrix m) public BlockRealMatrix subtract(final RealMatrix m)
throws IllegalArgumentException { throws IllegalArgumentException {
try { try {
return subtract((DenseRealMatrix) m); return subtract((BlockRealMatrix) m);
} catch (ClassCastException cce) { } catch (ClassCastException cce) {
// safety check // safety check
MatrixUtils.checkSubtractionCompatible(this, m); MatrixUtils.checkSubtractionCompatible(this, m);
final DenseRealMatrix out = new DenseRealMatrix(rows, columns); final BlockRealMatrix out = new BlockRealMatrix(rows, columns);
// perform subtraction block-wise, to ensure good cache behavior // perform subtraction block-wise, to ensure good cache behavior
int blockIndex = 0; int blockIndex = 0;
@ -422,13 +422,13 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
* @return this - m * @return this - m
* @throws IllegalArgumentException if m is not the same size as this * @throws IllegalArgumentException if m is not the same size as this
*/ */
public DenseRealMatrix subtract(final DenseRealMatrix m) public BlockRealMatrix subtract(final BlockRealMatrix m)
throws IllegalArgumentException { throws IllegalArgumentException {
// safety check // safety check
MatrixUtils.checkSubtractionCompatible(this, m); MatrixUtils.checkSubtractionCompatible(this, m);
final DenseRealMatrix out = new DenseRealMatrix(rows, columns); final BlockRealMatrix out = new BlockRealMatrix(rows, columns);
// perform subtraction block-wise, to ensure good cache behavior // perform subtraction block-wise, to ensure good cache behavior
for (int blockIndex = 0; blockIndex < out.blocks.length; ++blockIndex) { for (int blockIndex = 0; blockIndex < out.blocks.length; ++blockIndex) {
@ -446,10 +446,10 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
/** {@inheritDoc} */ /** {@inheritDoc} */
@Override @Override
public DenseRealMatrix scalarAdd(final double d) public BlockRealMatrix scalarAdd(final double d)
throws IllegalArgumentException { throws IllegalArgumentException {
final DenseRealMatrix out = new DenseRealMatrix(rows, columns); final BlockRealMatrix out = new BlockRealMatrix(rows, columns);
// perform subtraction block-wise, to ensure good cache behavior // perform subtraction block-wise, to ensure good cache behavior
for (int blockIndex = 0; blockIndex < out.blocks.length; ++blockIndex) { for (int blockIndex = 0; blockIndex < out.blocks.length; ++blockIndex) {
@ -469,7 +469,7 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
public RealMatrix scalarMultiply(final double d) public RealMatrix scalarMultiply(final double d)
throws IllegalArgumentException { throws IllegalArgumentException {
final DenseRealMatrix out = new DenseRealMatrix(rows, columns); final BlockRealMatrix out = new BlockRealMatrix(rows, columns);
// perform subtraction block-wise, to ensure good cache behavior // perform subtraction block-wise, to ensure good cache behavior
for (int blockIndex = 0; blockIndex < out.blocks.length; ++blockIndex) { for (int blockIndex = 0; blockIndex < out.blocks.length; ++blockIndex) {
@ -486,16 +486,16 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
/** {@inheritDoc} */ /** {@inheritDoc} */
@Override @Override
public DenseRealMatrix multiply(final RealMatrix m) public BlockRealMatrix multiply(final RealMatrix m)
throws IllegalArgumentException { throws IllegalArgumentException {
try { try {
return multiply((DenseRealMatrix) m); return multiply((BlockRealMatrix) m);
} catch (ClassCastException cce) { } catch (ClassCastException cce) {
// safety check // safety check
MatrixUtils.checkMultiplicationCompatible(this, m); MatrixUtils.checkMultiplicationCompatible(this, m);
final DenseRealMatrix out = new DenseRealMatrix(rows, m.getColumnDimension()); final BlockRealMatrix out = new BlockRealMatrix(rows, m.getColumnDimension());
// perform multiplication block-wise, to ensure good cache behavior // perform multiplication block-wise, to ensure good cache behavior
int blockIndex = 0; int blockIndex = 0;
@ -549,12 +549,12 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
* @throws IllegalArgumentException * @throws IllegalArgumentException
* if columnDimension(this) != rowDimension(m) * if columnDimension(this) != rowDimension(m)
*/ */
public DenseRealMatrix multiply(DenseRealMatrix m) throws IllegalArgumentException { public BlockRealMatrix multiply(BlockRealMatrix m) throws IllegalArgumentException {
// safety check // safety check
MatrixUtils.checkMultiplicationCompatible(this, m); MatrixUtils.checkMultiplicationCompatible(this, m);
final DenseRealMatrix out = new DenseRealMatrix(rows, m.columns); final BlockRealMatrix out = new BlockRealMatrix(rows, m.columns);
// perform multiplication block-wise, to ensure good cache behavior // perform multiplication block-wise, to ensure good cache behavior
int blockIndex = 0; int blockIndex = 0;
@ -681,7 +681,7 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
/** {@inheritDoc} */ /** {@inheritDoc} */
@Override @Override
public DenseRealMatrix getSubMatrix(final int startRow, final int endRow, public BlockRealMatrix getSubMatrix(final int startRow, final int endRow,
final int startColumn, final int endColumn) final int startColumn, final int endColumn)
throws MatrixIndexException { throws MatrixIndexException {
@ -689,8 +689,8 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn); MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
// create the output matrix // create the output matrix
final DenseRealMatrix out = final BlockRealMatrix out =
new DenseRealMatrix(endRow - startRow + 1, endColumn - startColumn + 1); new BlockRealMatrix(endRow - startRow + 1, endColumn - startColumn + 1);
// compute blocks shifts // compute blocks shifts
final int blockStartRow = startRow / BLOCK_SIZE; final int blockStartRow = startRow / BLOCK_SIZE;
@ -858,11 +858,11 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
/** {@inheritDoc} */ /** {@inheritDoc} */
@Override @Override
public DenseRealMatrix getRowMatrix(final int row) public BlockRealMatrix getRowMatrix(final int row)
throws MatrixIndexException { throws MatrixIndexException {
MatrixUtils.checkRowIndex(this, row); MatrixUtils.checkRowIndex(this, row);
final DenseRealMatrix out = new DenseRealMatrix(1, columns); final BlockRealMatrix out = new BlockRealMatrix(1, columns);
// perform copy block-wise, to ensure good cache behavior // perform copy block-wise, to ensure good cache behavior
final int iBlock = row / BLOCK_SIZE; final int iBlock = row / BLOCK_SIZE;
@ -894,7 +894,7 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
public void setRowMatrix(final int row, final RealMatrix matrix) public void setRowMatrix(final int row, final RealMatrix matrix)
throws MatrixIndexException, InvalidMatrixException { throws MatrixIndexException, InvalidMatrixException {
try { try {
setRowMatrix(row, (DenseRealMatrix) matrix); setRowMatrix(row, (BlockRealMatrix) matrix);
} catch (ClassCastException cce) { } catch (ClassCastException cce) {
super.setRowMatrix(row, matrix); super.setRowMatrix(row, matrix);
} }
@ -911,7 +911,7 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
* @throws InvalidMatrixException if the matrix dimensions do not match one * @throws InvalidMatrixException if the matrix dimensions do not match one
* instance row * instance row
*/ */
public void setRowMatrix(final int row, final DenseRealMatrix matrix) public void setRowMatrix(final int row, final BlockRealMatrix matrix)
throws MatrixIndexException, InvalidMatrixException { throws MatrixIndexException, InvalidMatrixException {
MatrixUtils.checkRowIndex(this, row); MatrixUtils.checkRowIndex(this, row);
@ -949,11 +949,11 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
/** {@inheritDoc} */ /** {@inheritDoc} */
@Override @Override
public DenseRealMatrix getColumnMatrix(final int column) public BlockRealMatrix getColumnMatrix(final int column)
throws MatrixIndexException { throws MatrixIndexException {
MatrixUtils.checkColumnIndex(this, column); MatrixUtils.checkColumnIndex(this, column);
final DenseRealMatrix out = new DenseRealMatrix(rows, 1); final BlockRealMatrix out = new BlockRealMatrix(rows, 1);
// perform copy block-wise, to ensure good cache behavior // perform copy block-wise, to ensure good cache behavior
final int jBlock = column / BLOCK_SIZE; final int jBlock = column / BLOCK_SIZE;
@ -983,7 +983,7 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
public void setColumnMatrix(final int column, final RealMatrix matrix) public void setColumnMatrix(final int column, final RealMatrix matrix)
throws MatrixIndexException, InvalidMatrixException { throws MatrixIndexException, InvalidMatrixException {
try { try {
setColumnMatrix(column, (DenseRealMatrix) matrix); setColumnMatrix(column, (BlockRealMatrix) matrix);
} catch (ClassCastException cce) { } catch (ClassCastException cce) {
super.setColumnMatrix(column, matrix); super.setColumnMatrix(column, matrix);
} }
@ -1000,7 +1000,7 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
* @throws InvalidMatrixException if the matrix dimensions do not match one * @throws InvalidMatrixException if the matrix dimensions do not match one
* instance column * instance column
*/ */
void setColumnMatrix(final int column, final DenseRealMatrix matrix) void setColumnMatrix(final int column, final BlockRealMatrix matrix)
throws MatrixIndexException, InvalidMatrixException { throws MatrixIndexException, InvalidMatrixException {
MatrixUtils.checkColumnIndex(this, column); MatrixUtils.checkColumnIndex(this, column);
@ -1276,11 +1276,11 @@ public class DenseRealMatrix extends AbstractRealMatrix implements Serializable
/** {@inheritDoc} */ /** {@inheritDoc} */
@Override @Override
public DenseRealMatrix transpose() { public BlockRealMatrix transpose() {
final int nRows = getRowDimension(); final int nRows = getRowDimension();
final int nCols = getColumnDimension(); final int nCols = getColumnDimension();
final DenseRealMatrix out = new DenseRealMatrix(nCols, nRows); final BlockRealMatrix out = new BlockRealMatrix(nCols, nRows);
// perform transpose block-wise, to ensure good cache behavior // perform transpose block-wise, to ensure good cache behavior
int blockIndex = 0; int blockIndex = 0;

2
src/java/org/apache/commons/math/linear/OpenMapRealMatrix.java
View File

@ -164,7 +164,7 @@ public class OpenMapRealMatrix extends AbstractRealMatrix implements SparseRealM
MatrixUtils.checkMultiplicationCompatible(this, m); MatrixUtils.checkMultiplicationCompatible(this, m);
final int outCols = m.getColumnDimension(); final int outCols = m.getColumnDimension();
final DenseRealMatrix out = new DenseRealMatrix(rowDimension, outCols); final BlockRealMatrix out = new BlockRealMatrix(rowDimension, outCols);
for (OpenIntToDoubleHashMap.Iterator iterator = entries.iterator(); iterator.hasNext();) { for (OpenIntToDoubleHashMap.Iterator iterator = entries.iterator(); iterator.hasNext();) {
iterator.advance(); iterator.advance();
final double value = iterator.value(); final double value = iterator.value();

6
src/java/org/apache/commons/math/linear/QRDecompositionImpl.java
View File

@ -369,9 +369,9 @@ public class QRDecompositionImpl implements QRDecomposition {
} }
final int columns = b.getColumnDimension(); final int columns = b.getColumnDimension();
final int blockSize = DenseRealMatrix.BLOCK_SIZE; final int blockSize = BlockRealMatrix.BLOCK_SIZE;
final int cBlocks = (columns + blockSize - 1) / blockSize; final int cBlocks = (columns + blockSize - 1) / blockSize;
final double[][] xBlocks = DenseRealMatrix.createBlocksLayout(n, columns); final double[][] xBlocks = BlockRealMatrix.createBlocksLayout(n, columns);
final double[][] y = new double[b.getRowDimension()][blockSize]; final double[][] y = new double[b.getRowDimension()][blockSize];
final double[] alpha = new double[blockSize]; final double[] alpha = new double[blockSize];
@ -435,7 +435,7 @@ public class QRDecompositionImpl implements QRDecomposition {
} }
return new DenseRealMatrix(n, columns, xBlocks, false); return new BlockRealMatrix(n, columns, xBlocks, false);
} }

4
src/java/org/apache/commons/math/optimization/general/GaussNewtonOptimizer.java
View File

@ -21,7 +21,7 @@ import java.io.Serializable;
import org.apache.commons.math.FunctionEvaluationException; import org.apache.commons.math.FunctionEvaluationException;
import org.apache.commons.math.linear.DecompositionSolver; import org.apache.commons.math.linear.DecompositionSolver;
import org.apache.commons.math.linear.DenseRealMatrix; import org.apache.commons.math.linear.BlockRealMatrix;
import org.apache.commons.math.linear.InvalidMatrixException; import org.apache.commons.math.linear.InvalidMatrixException;
import org.apache.commons.math.linear.LUDecompositionImpl; import org.apache.commons.math.linear.LUDecompositionImpl;
import org.apache.commons.math.linear.QRDecompositionImpl; import org.apache.commons.math.linear.QRDecompositionImpl;
@ -109,7 +109,7 @@ public class GaussNewtonOptimizer extends AbstractLeastSquaresOptimizer implemen
try { try {
// solve the linearized least squares problem // solve the linearized least squares problem
RealMatrix mA = new DenseRealMatrix(a); RealMatrix mA = new BlockRealMatrix(a);
DecompositionSolver solver = useLU ? DecompositionSolver solver = useLU ?
new LUDecompositionImpl(mA).getSolver() : new LUDecompositionImpl(mA).getSolver() :
new QRDecompositionImpl(mA).getSolver(); new QRDecompositionImpl(mA).getSolver();

8
src/java/org/apache/commons/math/stat/correlation/Covariance.java
View File

@ -18,7 +18,7 @@ package org.apache.commons.math.stat.correlation;
import org.apache.commons.math.MathRuntimeException; import org.apache.commons.math.MathRuntimeException;
import org.apache.commons.math.linear.RealMatrix; import org.apache.commons.math.linear.RealMatrix;
import org.apache.commons.math.linear.DenseRealMatrix; import org.apache.commons.math.linear.BlockRealMatrix;
import org.apache.commons.math.stat.descriptive.moment.Mean; import org.apache.commons.math.stat.descriptive.moment.Mean;
import org.apache.commons.math.stat.descriptive.moment.Variance; import org.apache.commons.math.stat.descriptive.moment.Variance;
@ -78,7 +78,7 @@ public class Covariance {
* rectangular with at least two rows and two columns. * rectangular with at least two rows and two columns.
*/ */
public Covariance(double[][] data, boolean biasCorrected) { public Covariance(double[][] data, boolean biasCorrected) {
this(new DenseRealMatrix(data), biasCorrected); this(new BlockRealMatrix(data), biasCorrected);
} }
/** /**
@ -159,7 +159,7 @@ public class Covariance {
protected RealMatrix computeCovarianceMatrix(RealMatrix matrix, boolean biasCorrected) { protected RealMatrix computeCovarianceMatrix(RealMatrix matrix, boolean biasCorrected) {
int dimension = matrix.getColumnDimension(); int dimension = matrix.getColumnDimension();
Variance variance = new Variance(biasCorrected); Variance variance = new Variance(biasCorrected);
RealMatrix outMatrix = new DenseRealMatrix(dimension, dimension); RealMatrix outMatrix = new BlockRealMatrix(dimension, dimension);
for (int i = 0; i < dimension; i++) { for (int i = 0; i < dimension; i++) {
for (int j = 0; j < i; j++) { for (int j = 0; j < i; j++) {
double cov = covariance(matrix.getColumn(i), matrix.getColumn(j), biasCorrected); double cov = covariance(matrix.getColumn(i), matrix.getColumn(j), biasCorrected);
@ -190,7 +190,7 @@ public class Covariance {
* @return covariance matrix * @return covariance matrix
*/ */
protected RealMatrix computeCovarianceMatrix(double[][] data, boolean biasCorrected) { protected RealMatrix computeCovarianceMatrix(double[][] data, boolean biasCorrected) {
return computeCovarianceMatrix(new DenseRealMatrix(data), biasCorrected); return computeCovarianceMatrix(new BlockRealMatrix(data), biasCorrected);
} }
/** /**

14
src/java/org/apache/commons/math/stat/correlation/PearsonsCorrelation.java
View File

@ -21,7 +21,7 @@ import org.apache.commons.math.MathRuntimeException;
import org.apache.commons.math.distribution.TDistribution; import org.apache.commons.math.distribution.TDistribution;
import org.apache.commons.math.distribution.TDistributionImpl; import org.apache.commons.math.distribution.TDistributionImpl;
import org.apache.commons.math.linear.RealMatrix; import org.apache.commons.math.linear.RealMatrix;
import org.apache.commons.math.linear.DenseRealMatrix; import org.apache.commons.math.linear.BlockRealMatrix;
import org.apache.commons.math.stat.regression.SimpleRegression; import org.apache.commons.math.stat.regression.SimpleRegression;
/** /**
@ -65,7 +65,7 @@ public class PearsonsCorrelation {
* rectangular with at least two rows and two columns. * rectangular with at least two rows and two columns.
*/ */
public PearsonsCorrelation(double[][] data) { public PearsonsCorrelation(double[][] data) {
this(new DenseRealMatrix(data)); this(new BlockRealMatrix(data));
} }
/** /**
@ -141,7 +141,7 @@ public class PearsonsCorrelation {
out[i][j] = Math.sqrt((1 - r * r) /(nObs - 2)); out[i][j] = Math.sqrt((1 - r * r) /(nObs - 2));
} }
} }
return new DenseRealMatrix(out); return new BlockRealMatrix(out);
} }
/** /**
@ -172,7 +172,7 @@ public class PearsonsCorrelation {
} }
} }
} }
return new DenseRealMatrix(out); return new BlockRealMatrix(out);
} }
@ -185,7 +185,7 @@ public class PearsonsCorrelation {
*/ */
public RealMatrix computeCorrelationMatrix(RealMatrix matrix) { public RealMatrix computeCorrelationMatrix(RealMatrix matrix) {
int nVars = matrix.getColumnDimension(); int nVars = matrix.getColumnDimension();
RealMatrix outMatrix = new DenseRealMatrix(nVars, nVars); RealMatrix outMatrix = new BlockRealMatrix(nVars, nVars);
for (int i = 0; i < nVars; i++) { for (int i = 0; i < nVars; i++) {
for (int j = 0; j < i; j++) { for (int j = 0; j < i; j++) {
double corr = correlation(matrix.getColumn(i), matrix.getColumn(j)); double corr = correlation(matrix.getColumn(i), matrix.getColumn(j));
@ -206,7 +206,7 @@ public class PearsonsCorrelation {
* @return correlation matrix * @return correlation matrix
*/ */
public RealMatrix computeCorrelationMatrix(double[][] data) { public RealMatrix computeCorrelationMatrix(double[][] data) {
return computeCorrelationMatrix(new DenseRealMatrix(data)); return computeCorrelationMatrix(new BlockRealMatrix(data));
} }
/** /**
@ -249,7 +249,7 @@ public class PearsonsCorrelation {
*/ */
public RealMatrix covarianceToCorrelation(RealMatrix covarianceMatrix) { public RealMatrix covarianceToCorrelation(RealMatrix covarianceMatrix) {
int nVars = covarianceMatrix.getColumnDimension(); int nVars = covarianceMatrix.getColumnDimension();
RealMatrix outMatrix = new DenseRealMatrix(nVars, nVars); RealMatrix outMatrix = new BlockRealMatrix(nVars, nVars);
for (int i = 0; i < nVars; i++) { for (int i = 0; i < nVars; i++) {
double sigma = Math.sqrt(covarianceMatrix.getEntry(i, i)); double sigma = Math.sqrt(covarianceMatrix.getEntry(i, i));
outMatrix.setEntry(i, i, 1d); outMatrix.setEntry(i, i, 1d);

4
src/java/org/apache/commons/math/stat/correlation/SpearmansCorrelation.java
View File

@ -18,7 +18,7 @@
package org.apache.commons.math.stat.correlation; package org.apache.commons.math.stat.correlation;
import org.apache.commons.math.MathRuntimeException; import org.apache.commons.math.MathRuntimeException;
import org.apache.commons.math.linear.DenseRealMatrix; import org.apache.commons.math.linear.BlockRealMatrix;
import org.apache.commons.math.linear.RealMatrix; import org.apache.commons.math.linear.RealMatrix;
import org.apache.commons.math.stat.ranking.NaturalRanking; import org.apache.commons.math.stat.ranking.NaturalRanking;
import org.apache.commons.math.stat.ranking.RankingAlgorithm; import org.apache.commons.math.stat.ranking.RankingAlgorithm;
@ -128,7 +128,7 @@ public class SpearmansCorrelation {
* @return correlation matrix * @return correlation matrix
*/ */
public RealMatrix computeCorrelationMatrix(double[][] data) { public RealMatrix computeCorrelationMatrix(double[][] data) {
return computeCorrelationMatrix(new DenseRealMatrix(data)); return computeCorrelationMatrix(new BlockRealMatrix(data));
} }
/** /**

3
src/site/xdoc/changes.xml
View File

@ -83,6 +83,9 @@ The <action> type attribute can be add,update,fix,remove.
Added support for any type of field in linear algebra (FielxMatrix, FieldVector, Added support for any type of field in linear algebra (FielxMatrix, FieldVector,
FieldLUDecomposition) FieldLUDecomposition)
</action> </action>
<action dev="luc" type="add" >
Added a block-based storage type for dense matrices improving speed for large dimensions
</action>
<action dev="psteitz" type="add" due-to="John Bollinger"> <action dev="psteitz" type="add" due-to="John Bollinger">
Added AggregateSummaryStatistics class to support aggregation of SummaryStatistics. Added AggregateSummaryStatistics class to support aggregation of SummaryStatistics.
</action> </action>

7
src/site/xdoc/userguide/linear.xml
View File

@ -71,9 +71,12 @@ RealMatrix pInverse = new LUDecompositionImpl(p).getSolver().getInverse();
</source> </source>
</p> </p>
<p> <p>
The two main implementations of the interface are <a The three main implementations of the interface are <a
href="../apidocs/org/apache/commons/math/linear/RealMatrixImpl.html"> href="../apidocs/org/apache/commons/math/linear/RealMatrixImpl.html">
RealMatrixImpl</a> for dense matrices and <a RealMatrixImpl</a> and <a
href="../apidocs/org/apache/commons/math/linear/BlockRealMatrix.html">
BlockRealMatrix</a> for dense matrices (the second one being more suited to
dimensions above 50 or 100) and <a
href="../apidocs/org/apache/commons/math/linear/SparseRealMatrix.html"> href="../apidocs/org/apache/commons/math/linear/SparseRealMatrix.html">
SparseRealMatrix</a> for sparse matrices. SparseRealMatrix</a> for sparse matrices.
</p> </p>

242
src/test/org/apache/commons/math/linear/DenseFieldMatrixTest.java
View File

@ -28,7 +28,7 @@ import org.apache.commons.math.fraction.Fraction;
import org.apache.commons.math.fraction.FractionField; import org.apache.commons.math.fraction.FractionField;
/** /**
* Test cases for the {@link DenseFieldMatrix} class. * Test cases for the {@link BlockFieldMatrix} class.
* *
* @version $Revision$ $Date$ * @version $Revision$ $Date$
*/ */
@ -158,14 +158,14 @@ public final class DenseFieldMatrixTest extends TestCase {
public static Test suite() { public static Test suite() {
TestSuite suite = new TestSuite(DenseFieldMatrixTest.class); TestSuite suite = new TestSuite(DenseFieldMatrixTest.class);
suite.setName("DenseFieldMatrix<Fraction> Tests"); suite.setName("BlockFieldMatrix<Fraction> Tests");
return suite; return suite;
} }
/** test dimensions */ /** test dimensions */
public void testDimensions() { public void testDimensions() {
DenseFieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(testData); BlockFieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(testData);
DenseFieldMatrix<Fraction> m2 = new DenseFieldMatrix<Fraction>(testData2); BlockFieldMatrix<Fraction> m2 = new BlockFieldMatrix<Fraction>(testData2);
assertEquals("testData row dimension",3,m.getRowDimension()); assertEquals("testData row dimension",3,m.getRowDimension());
assertEquals("testData column dimension",3,m.getColumnDimension()); assertEquals("testData column dimension",3,m.getColumnDimension());
assertTrue("testData is square",m.isSquare()); assertTrue("testData is square",m.isSquare());
@ -177,18 +177,18 @@ public final class DenseFieldMatrixTest extends TestCase {
/** test copy functions */ /** test copy functions */
public void testCopyFunctions() { public void testCopyFunctions() {
Random r = new Random(66636328996002l); Random r = new Random(66636328996002l);
DenseFieldMatrix<Fraction> m1 = createRandomMatrix(r, 47, 83); BlockFieldMatrix<Fraction> m1 = createRandomMatrix(r, 47, 83);
DenseFieldMatrix<Fraction> m2 = new DenseFieldMatrix<Fraction>(m1.getData()); BlockFieldMatrix<Fraction> m2 = new BlockFieldMatrix<Fraction>(m1.getData());
assertEquals(m1, m2); assertEquals(m1, m2);
DenseFieldMatrix<Fraction> m3 = new DenseFieldMatrix<Fraction>(testData); BlockFieldMatrix<Fraction> m3 = new BlockFieldMatrix<Fraction>(testData);
DenseFieldMatrix<Fraction> m4 = new DenseFieldMatrix<Fraction>(m3.getData()); BlockFieldMatrix<Fraction> m4 = new BlockFieldMatrix<Fraction>(m3.getData());
assertEquals(m3, m4); assertEquals(m3, m4);
} }
/** test add */ /** test add */
public void testAdd() { public void testAdd() {
DenseFieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(testData); BlockFieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(testData);
DenseFieldMatrix<Fraction> mInv = new DenseFieldMatrix<Fraction>(testDataInv); BlockFieldMatrix<Fraction> mInv = new BlockFieldMatrix<Fraction>(testDataInv);
FieldMatrix<Fraction> mPlusMInv = m.add(mInv); FieldMatrix<Fraction> mPlusMInv = m.add(mInv);
Fraction[][] sumEntries = mPlusMInv.getData(); Fraction[][] sumEntries = mPlusMInv.getData();
for (int row = 0; row < m.getRowDimension(); row++) { for (int row = 0; row < m.getRowDimension(); row++) {
@ -200,8 +200,8 @@ public final class DenseFieldMatrixTest extends TestCase {
/** test add failure */ /** test add failure */
public void testAddFail() { public void testAddFail() {
DenseFieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(testData); BlockFieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(testData);
DenseFieldMatrix<Fraction> m2 = new DenseFieldMatrix<Fraction>(testData2); BlockFieldMatrix<Fraction> m2 = new BlockFieldMatrix<Fraction>(testData2);
try { try {
m.add(m2); m.add(m2);
fail("IllegalArgumentException expected"); fail("IllegalArgumentException expected");
@ -212,11 +212,11 @@ public final class DenseFieldMatrixTest extends TestCase {
/** test m-n = m + -n */ /** test m-n = m + -n */
public void testPlusMinus() { public void testPlusMinus() {
DenseFieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(testData); BlockFieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(testData);
DenseFieldMatrix<Fraction> m2 = new DenseFieldMatrix<Fraction>(testDataInv); BlockFieldMatrix<Fraction> m2 = new BlockFieldMatrix<Fraction>(testDataInv);
TestUtils.assertEquals(m.subtract(m2), m2.scalarMultiply(new Fraction(-1)).add(m)); TestUtils.assertEquals(m.subtract(m2), m2.scalarMultiply(new Fraction(-1)).add(m));
try { try {
m.subtract(new DenseFieldMatrix<Fraction>(testData2)); m.subtract(new BlockFieldMatrix<Fraction>(testData2));
fail("Expecting illegalArgumentException"); fail("Expecting illegalArgumentException");
} catch (IllegalArgumentException ex) { } catch (IllegalArgumentException ex) {
// ignored // ignored
@ -225,17 +225,17 @@ public final class DenseFieldMatrixTest extends TestCase {
/** test multiply */ /** test multiply */
public void testMultiply() { public void testMultiply() {
DenseFieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(testData); BlockFieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(testData);
DenseFieldMatrix<Fraction> mInv = new DenseFieldMatrix<Fraction>(testDataInv); BlockFieldMatrix<Fraction> mInv = new BlockFieldMatrix<Fraction>(testDataInv);
DenseFieldMatrix<Fraction> identity = new DenseFieldMatrix<Fraction>(id); BlockFieldMatrix<Fraction> identity = new BlockFieldMatrix<Fraction>(id);
DenseFieldMatrix<Fraction> m2 = new DenseFieldMatrix<Fraction>(testData2); BlockFieldMatrix<Fraction> m2 = new BlockFieldMatrix<Fraction>(testData2);
TestUtils.assertEquals(m.multiply(mInv), identity); TestUtils.assertEquals(m.multiply(mInv), identity);
TestUtils.assertEquals(mInv.multiply(m), identity); TestUtils.assertEquals(mInv.multiply(m), identity);
TestUtils.assertEquals(m.multiply(identity), m); TestUtils.assertEquals(m.multiply(identity), m);
TestUtils.assertEquals(identity.multiply(mInv), mInv); TestUtils.assertEquals(identity.multiply(mInv), mInv);
TestUtils.assertEquals(m2.multiply(identity), m2); TestUtils.assertEquals(m2.multiply(identity), m2);
try { try {
m.multiply(new DenseFieldMatrix<Fraction>(bigSingular)); m.multiply(new BlockFieldMatrix<Fraction>(bigSingular));
fail("Expecting illegalArgumentException"); fail("Expecting illegalArgumentException");
} catch (IllegalArgumentException ex) { } catch (IllegalArgumentException ex) {
// expected // expected
@ -245,7 +245,7 @@ public final class DenseFieldMatrixTest extends TestCase {
public void testSeveralBlocks() { public void testSeveralBlocks() {
FieldMatrix<Fraction> m = FieldMatrix<Fraction> m =
new DenseFieldMatrix<Fraction>(FractionField.getInstance(), 37, 41); new BlockFieldMatrix<Fraction>(FractionField.getInstance(), 37, 41);
for (int i = 0; i < m.getRowDimension(); ++i) { for (int i = 0; i < m.getRowDimension(); ++i) {
for (int j = 0; j < m.getColumnDimension(); ++j) { for (int j = 0; j < m.getColumnDimension(); ++j) {
m.setEntry(i, j, new Fraction(i * 11 + j, 11)); m.setEntry(i, j, new Fraction(i * 11 + j, 11));
@ -327,7 +327,7 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
//Additional Test for DenseFieldMatrix<Fraction>Test.testMultiply //Additional Test for BlockFieldMatrix<Fraction>Test.testMultiply
private Fraction[][] d3 = new Fraction[][] { private Fraction[][] d3 = new Fraction[][] {
{new Fraction(1),new Fraction(2),new Fraction(3),new Fraction(4)}, {new Fraction(1),new Fraction(2),new Fraction(3),new Fraction(4)},
@ -342,17 +342,17 @@ public final class DenseFieldMatrixTest extends TestCase {
private Fraction[][] d5 = new Fraction[][] {{new Fraction(30)},{new Fraction(70)}}; private Fraction[][] d5 = new Fraction[][] {{new Fraction(30)},{new Fraction(70)}};
public void testMultiply2() { public void testMultiply2() {
FieldMatrix<Fraction> m3 = new DenseFieldMatrix<Fraction>(d3); FieldMatrix<Fraction> m3 = new BlockFieldMatrix<Fraction>(d3);
FieldMatrix<Fraction> m4 = new DenseFieldMatrix<Fraction>(d4); FieldMatrix<Fraction> m4 = new BlockFieldMatrix<Fraction>(d4);
FieldMatrix<Fraction> m5 = new DenseFieldMatrix<Fraction>(d5); FieldMatrix<Fraction> m5 = new BlockFieldMatrix<Fraction>(d5);
TestUtils.assertEquals(m3.multiply(m4), m5); TestUtils.assertEquals(m3.multiply(m4), m5);
} }
/** test trace */ /** test trace */
public void testTrace() { public void testTrace() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(id); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(id);
assertEquals(new Fraction(3),m.getTrace()); assertEquals(new Fraction(3),m.getTrace());
m = new DenseFieldMatrix<Fraction>(testData2); m = new BlockFieldMatrix<Fraction>(testData2);
try { try {
m.getTrace(); m.getTrace();
fail("Expecting NonSquareMatrixException"); fail("Expecting NonSquareMatrixException");
@ -363,17 +363,17 @@ public final class DenseFieldMatrixTest extends TestCase {
/** test scalarAdd */ /** test scalarAdd */
public void testScalarAdd() { public void testScalarAdd() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(testData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(testData);
TestUtils.assertEquals(new DenseFieldMatrix<Fraction>(testDataPlus2), TestUtils.assertEquals(new BlockFieldMatrix<Fraction>(testDataPlus2),
m.scalarAdd(new Fraction(2))); m.scalarAdd(new Fraction(2)));
} }
/** test operate */ /** test operate */
public void testOperate() { public void testOperate() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(id); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(id);
TestUtils.assertEquals(testVector, m.operate(testVector)); TestUtils.assertEquals(testVector, m.operate(testVector));
TestUtils.assertEquals(testVector, m.operate(new FieldVectorImpl<Fraction>(testVector)).getData()); TestUtils.assertEquals(testVector, m.operate(new FieldVectorImpl<Fraction>(testVector)).getData());
m = new DenseFieldMatrix<Fraction>(bigSingular); m = new BlockFieldMatrix<Fraction>(bigSingular);
try { try {
m.operate(testVector); m.operate(testVector);
fail("Expecting illegalArgumentException"); fail("Expecting illegalArgumentException");
@ -383,9 +383,9 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testOperateLarge() { public void testOperateLarge() {
int p = (11 * DenseFieldMatrix.BLOCK_SIZE) / 10; int p = (11 * BlockFieldMatrix.BLOCK_SIZE) / 10;
int q = (11 * DenseFieldMatrix.BLOCK_SIZE) / 10; int q = (11 * BlockFieldMatrix.BLOCK_SIZE) / 10;
int r = DenseFieldMatrix.BLOCK_SIZE / 2; int r = BlockFieldMatrix.BLOCK_SIZE / 2;
Random random = new Random(111007463902334l); Random random = new Random(111007463902334l);
FieldMatrix<Fraction> m1 = createRandomMatrix(random, p, q); FieldMatrix<Fraction> m1 = createRandomMatrix(random, p, q);
FieldMatrix<Fraction> m2 = createRandomMatrix(random, q, r); FieldMatrix<Fraction> m2 = createRandomMatrix(random, q, r);
@ -396,9 +396,9 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testOperatePremultiplyLarge() { public void testOperatePremultiplyLarge() {
int p = (11 * DenseFieldMatrix.BLOCK_SIZE) / 10; int p = (11 * BlockFieldMatrix.BLOCK_SIZE) / 10;
int q = (11 * DenseFieldMatrix.BLOCK_SIZE) / 10; int q = (11 * BlockFieldMatrix.BLOCK_SIZE) / 10;
int r = DenseFieldMatrix.BLOCK_SIZE / 2; int r = BlockFieldMatrix.BLOCK_SIZE / 2;
Random random = new Random(111007463902334l); Random random = new Random(111007463902334l);
FieldMatrix<Fraction> m1 = createRandomMatrix(random, p, q); FieldMatrix<Fraction> m1 = createRandomMatrix(random, p, q);
FieldMatrix<Fraction> m2 = createRandomMatrix(random, q, r); FieldMatrix<Fraction> m2 = createRandomMatrix(random, q, r);
@ -410,7 +410,7 @@ public final class DenseFieldMatrixTest extends TestCase {
/** test issue MATH-209 */ /** test issue MATH-209 */
public void testMath209() { public void testMath209() {
FieldMatrix<Fraction> a = new DenseFieldMatrix<Fraction>(new Fraction[][] { FieldMatrix<Fraction> a = new BlockFieldMatrix<Fraction>(new Fraction[][] {
{ new Fraction(1), new Fraction(2) }, { new Fraction(1), new Fraction(2) },
{ new Fraction(3), new Fraction(4) }, { new Fraction(3), new Fraction(4) },
{ new Fraction(5), new Fraction(6) } { new Fraction(5), new Fraction(6) }
@ -424,22 +424,22 @@ public final class DenseFieldMatrixTest extends TestCase {
/** test transpose */ /** test transpose */
public void testTranspose() { public void testTranspose() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(testData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(testData);
FieldMatrix<Fraction> mIT = new FieldLUDecompositionImpl<Fraction>(m).getSolver().getInverse().transpose(); FieldMatrix<Fraction> mIT = new FieldLUDecompositionImpl<Fraction>(m).getSolver().getInverse().transpose();
FieldMatrix<Fraction> mTI = new FieldLUDecompositionImpl<Fraction>(m.transpose()).getSolver().getInverse(); FieldMatrix<Fraction> mTI = new FieldLUDecompositionImpl<Fraction>(m.transpose()).getSolver().getInverse();
TestUtils.assertEquals(mIT, mTI); TestUtils.assertEquals(mIT, mTI);
m = new DenseFieldMatrix<Fraction>(testData2); m = new BlockFieldMatrix<Fraction>(testData2);
FieldMatrix<Fraction> mt = new DenseFieldMatrix<Fraction>(testData2T); FieldMatrix<Fraction> mt = new BlockFieldMatrix<Fraction>(testData2T);
TestUtils.assertEquals(mt, m.transpose()); TestUtils.assertEquals(mt, m.transpose());
} }
/** test preMultiply by vector */ /** test preMultiply by vector */
public void testPremultiplyVector() { public void testPremultiplyVector() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(testData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(testData);
TestUtils.assertEquals(m.preMultiply(testVector), preMultTest); TestUtils.assertEquals(m.preMultiply(testVector), preMultTest);
TestUtils.assertEquals(m.preMultiply(new FieldVectorImpl<Fraction>(testVector).getData()), TestUtils.assertEquals(m.preMultiply(new FieldVectorImpl<Fraction>(testVector).getData()),
preMultTest); preMultTest);
m = new DenseFieldMatrix<Fraction>(bigSingular); m = new BlockFieldMatrix<Fraction>(bigSingular);
try { try {
m.preMultiply(testVector); m.preMultiply(testVector);
fail("expecting IllegalArgumentException"); fail("expecting IllegalArgumentException");
@ -449,20 +449,20 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testPremultiply() { public void testPremultiply() {
FieldMatrix<Fraction> m3 = new DenseFieldMatrix<Fraction>(d3); FieldMatrix<Fraction> m3 = new BlockFieldMatrix<Fraction>(d3);
FieldMatrix<Fraction> m4 = new DenseFieldMatrix<Fraction>(d4); FieldMatrix<Fraction> m4 = new BlockFieldMatrix<Fraction>(d4);
FieldMatrix<Fraction> m5 = new DenseFieldMatrix<Fraction>(d5); FieldMatrix<Fraction> m5 = new BlockFieldMatrix<Fraction>(d5);
TestUtils.assertEquals(m4.preMultiply(m3), m5); TestUtils.assertEquals(m4.preMultiply(m3), m5);
DenseFieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(testData); BlockFieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(testData);
DenseFieldMatrix<Fraction> mInv = new DenseFieldMatrix<Fraction>(testDataInv); BlockFieldMatrix<Fraction> mInv = new BlockFieldMatrix<Fraction>(testDataInv);
DenseFieldMatrix<Fraction> identity = new DenseFieldMatrix<Fraction>(id); BlockFieldMatrix<Fraction> identity = new BlockFieldMatrix<Fraction>(id);
TestUtils.assertEquals(m.preMultiply(mInv), identity); TestUtils.assertEquals(m.preMultiply(mInv), identity);
TestUtils.assertEquals(mInv.preMultiply(m), identity); TestUtils.assertEquals(mInv.preMultiply(m), identity);
TestUtils.assertEquals(m.preMultiply(identity), m); TestUtils.assertEquals(m.preMultiply(identity), m);
TestUtils.assertEquals(identity.preMultiply(mInv), mInv); TestUtils.assertEquals(identity.preMultiply(mInv), mInv);
try { try {
m.preMultiply(new DenseFieldMatrix<Fraction>(bigSingular)); m.preMultiply(new BlockFieldMatrix<Fraction>(bigSingular));
fail("Expecting illegalArgumentException"); fail("Expecting illegalArgumentException");
} catch (IllegalArgumentException ex) { } catch (IllegalArgumentException ex) {
// ignored // ignored
@ -470,7 +470,7 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testGetVectors() { public void testGetVectors() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(testData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(testData);
TestUtils.assertEquals(m.getRow(0), testDataRow1); TestUtils.assertEquals(m.getRow(0), testDataRow1);
TestUtils.assertEquals(m.getColumn(2), testDataCol3); TestUtils.assertEquals(m.getColumn(2), testDataCol3);
try { try {
@ -488,7 +488,7 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testGetEntry() { public void testGetEntry() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(testData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(testData);
assertEquals(m.getEntry(0,1),new Fraction(2)); assertEquals(m.getEntry(0,1),new Fraction(2));
try { try {
m.getEntry(10, 4); m.getEntry(10, 4);
@ -505,14 +505,14 @@ public final class DenseFieldMatrixTest extends TestCase {
{new Fraction(1),new Fraction(2),new Fraction(3)}, {new Fraction(1),new Fraction(2),new Fraction(3)},
{new Fraction(2),new Fraction(5),new Fraction(3)} {new Fraction(2),new Fraction(5),new Fraction(3)}
}; };
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(matrixData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(matrixData);
// One more with three rows, two columns // One more with three rows, two columns
Fraction[][] matrixData2 = { Fraction[][] matrixData2 = {
{new Fraction(1),new Fraction(2)}, {new Fraction(1),new Fraction(2)},
{new Fraction(2),new Fraction(5)}, {new Fraction(2),new Fraction(5)},
{new Fraction(1), new Fraction(7)} {new Fraction(1), new Fraction(7)}
}; };
FieldMatrix<Fraction> n = new DenseFieldMatrix<Fraction>(matrixData2); FieldMatrix<Fraction> n = new BlockFieldMatrix<Fraction>(matrixData2);
// Now multiply m by n // Now multiply m by n
FieldMatrix<Fraction> p = m.multiply(n); FieldMatrix<Fraction> p = m.multiply(n);
assertEquals(2, p.getRowDimension()); assertEquals(2, p.getRowDimension());
@ -528,7 +528,7 @@ public final class DenseFieldMatrixTest extends TestCase {
{new Fraction(-1), new Fraction(7), new Fraction(6)}, {new Fraction(-1), new Fraction(7), new Fraction(6)},
{new Fraction(4), new Fraction(-3), new Fraction(-5)} {new Fraction(4), new Fraction(-3), new Fraction(-5)}
}; };
FieldMatrix<Fraction> coefficients = new DenseFieldMatrix<Fraction>(coefficientsData); FieldMatrix<Fraction> coefficients = new BlockFieldMatrix<Fraction>(coefficientsData);
Fraction[] constants = {new Fraction(1), new Fraction(-2), new Fraction(1)}; Fraction[] constants = {new Fraction(1), new Fraction(-2), new Fraction(1)};
Fraction[] solution = new FieldLUDecompositionImpl<Fraction>(coefficients).getSolver().solve(constants); Fraction[] solution = new FieldLUDecompositionImpl<Fraction>(coefficients).getSolver().solve(constants);
assertEquals(new Fraction(2).multiply(solution[0]). assertEquals(new Fraction(2).multiply(solution[0]).
@ -548,7 +548,7 @@ public final class DenseFieldMatrixTest extends TestCase {
// test submatrix accessors // test submatrix accessors
public void testGetSubMatrix() { public void testGetSubMatrix() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(subTestData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(subTestData);
checkGetSubMatrix(m, subRows23Cols00, 2 , 3 , 0, 0, false); checkGetSubMatrix(m, subRows23Cols00, 2 , 3 , 0, 0, false);
checkGetSubMatrix(m, subRows00Cols33, 0 , 0 , 3, 3, false); checkGetSubMatrix(m, subRows00Cols33, 0 , 0 , 3, 3, false);
checkGetSubMatrix(m, subRows01Cols23, 0 , 1 , 2, 3, false); checkGetSubMatrix(m, subRows01Cols23, 0 , 1 , 2, 3, false);
@ -571,7 +571,7 @@ public final class DenseFieldMatrixTest extends TestCase {
boolean mustFail) { boolean mustFail) {
try { try {
FieldMatrix<Fraction> sub = m.getSubMatrix(startRow, endRow, startColumn, endColumn); FieldMatrix<Fraction> sub = m.getSubMatrix(startRow, endRow, startColumn, endColumn);
assertEquals(new DenseFieldMatrix<Fraction>(reference), sub); assertEquals(new BlockFieldMatrix<Fraction>(reference), sub);
if (mustFail) { if (mustFail) {
fail("Expecting MatrixIndexException"); fail("Expecting MatrixIndexException");
} }
@ -587,7 +587,7 @@ public final class DenseFieldMatrixTest extends TestCase {
boolean mustFail) { boolean mustFail) {
try { try {
FieldMatrix<Fraction> sub = m.getSubMatrix(selectedRows, selectedColumns); FieldMatrix<Fraction> sub = m.getSubMatrix(selectedRows, selectedColumns);
assertEquals(new DenseFieldMatrix<Fraction>(reference), sub); assertEquals(new BlockFieldMatrix<Fraction>(reference), sub);
if (mustFail) { if (mustFail) {
fail("Expecting MatrixIndexException"); fail("Expecting MatrixIndexException");
} }
@ -599,11 +599,11 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testGetSetMatrixLarge() { public void testGetSetMatrixLarge() {
int n = 3 * DenseFieldMatrix.BLOCK_SIZE; int n = 3 * BlockFieldMatrix.BLOCK_SIZE;
FieldMatrix<Fraction> m = FieldMatrix<Fraction> m =
new DenseFieldMatrix<Fraction>(FractionField.getInstance(), n, n); new BlockFieldMatrix<Fraction>(FractionField.getInstance(), n, n);
FieldMatrix<Fraction> sub = FieldMatrix<Fraction> sub =
new DenseFieldMatrix<Fraction>(FractionField.getInstance(), n - 4, n - 4).scalarAdd(new Fraction(1)); new BlockFieldMatrix<Fraction>(FractionField.getInstance(), n - 4, n - 4).scalarAdd(new Fraction(1));
m.setSubMatrix(sub.getData(), 2, 2); m.setSubMatrix(sub.getData(), 2, 2);
for (int i = 0; i < n; ++i) { for (int i = 0; i < n; ++i) {
@ -620,7 +620,7 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testCopySubMatrix() { public void testCopySubMatrix() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(subTestData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(subTestData);
checkCopy(m, subRows23Cols00, 2 , 3 , 0, 0, false); checkCopy(m, subRows23Cols00, 2 , 3 , 0, 0, false);
checkCopy(m, subRows00Cols33, 0 , 0 , 3, 3, false); checkCopy(m, subRows00Cols33, 0 , 0 , 3, 3, false);
checkCopy(m, subRows01Cols23, 0 , 1 , 2, 3, false); checkCopy(m, subRows01Cols23, 0 , 1 , 2, 3, false);
@ -647,7 +647,7 @@ public final class DenseFieldMatrixTest extends TestCase {
new Fraction[1][1] : new Fraction[1][1] :
new Fraction[reference.length][reference[0].length]; new Fraction[reference.length][reference[0].length];
m.copySubMatrix(startRow, endRow, startColumn, endColumn, sub); m.copySubMatrix(startRow, endRow, startColumn, endColumn, sub);
assertEquals(new DenseFieldMatrix<Fraction>(reference), new DenseFieldMatrix<Fraction>(sub)); assertEquals(new BlockFieldMatrix<Fraction>(reference), new BlockFieldMatrix<Fraction>(sub));
if (mustFail) { if (mustFail) {
fail("Expecting MatrixIndexException"); fail("Expecting MatrixIndexException");
} }
@ -666,7 +666,7 @@ public final class DenseFieldMatrixTest extends TestCase {
new Fraction[1][1] : new Fraction[1][1] :
new Fraction[reference.length][reference[0].length]; new Fraction[reference.length][reference[0].length];
m.copySubMatrix(selectedRows, selectedColumns, sub); m.copySubMatrix(selectedRows, selectedColumns, sub);
assertEquals(new DenseFieldMatrix<Fraction>(reference), new DenseFieldMatrix<Fraction>(sub)); assertEquals(new BlockFieldMatrix<Fraction>(reference), new BlockFieldMatrix<Fraction>(sub));
if (mustFail) { if (mustFail) {
fail("Expecting MatrixIndexException"); fail("Expecting MatrixIndexException");
} }
@ -678,9 +678,9 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testGetRowMatrix() { public void testGetRowMatrix() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(subTestData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(subTestData);
FieldMatrix<Fraction> mRow0 = new DenseFieldMatrix<Fraction>(subRow0); FieldMatrix<Fraction> mRow0 = new BlockFieldMatrix<Fraction>(subRow0);
FieldMatrix<Fraction> mRow3 = new DenseFieldMatrix<Fraction>(subRow3); FieldMatrix<Fraction> mRow3 = new BlockFieldMatrix<Fraction>(subRow3);
assertEquals("Row0", mRow0, m.getRowMatrix(0)); assertEquals("Row0", mRow0, m.getRowMatrix(0));
assertEquals("Row3", mRow3, m.getRowMatrix(3)); assertEquals("Row3", mRow3, m.getRowMatrix(3));
try { try {
@ -698,8 +698,8 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testSetRowMatrix() { public void testSetRowMatrix() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(subTestData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(subTestData);
FieldMatrix<Fraction> mRow3 = new DenseFieldMatrix<Fraction>(subRow3); FieldMatrix<Fraction> mRow3 = new BlockFieldMatrix<Fraction>(subRow3);
assertNotSame(mRow3, m.getRowMatrix(0)); assertNotSame(mRow3, m.getRowMatrix(0));
m.setRowMatrix(0, mRow3); m.setRowMatrix(0, mRow3);
assertEquals(mRow3, m.getRowMatrix(0)); assertEquals(mRow3, m.getRowMatrix(0));
@ -718,11 +718,11 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testGetSetRowMatrixLarge() { public void testGetSetRowMatrixLarge() {
int n = 3 * DenseFieldMatrix.BLOCK_SIZE; int n = 3 * BlockFieldMatrix.BLOCK_SIZE;
FieldMatrix<Fraction> m = FieldMatrix<Fraction> m =
new DenseFieldMatrix<Fraction>(FractionField.getInstance(), n, n); new BlockFieldMatrix<Fraction>(FractionField.getInstance(), n, n);
FieldMatrix<Fraction> sub = FieldMatrix<Fraction> sub =
new DenseFieldMatrix<Fraction>(FractionField.getInstance(), 1, n).scalarAdd(new Fraction(1)); new BlockFieldMatrix<Fraction>(FractionField.getInstance(), 1, n).scalarAdd(new Fraction(1));
m.setRowMatrix(2, sub); m.setRowMatrix(2, sub);
for (int i = 0; i < n; ++i) { for (int i = 0; i < n; ++i) {
@ -739,9 +739,9 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testGetColumnMatrix() { public void testGetColumnMatrix() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(subTestData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(subTestData);
FieldMatrix<Fraction> mColumn1 = new DenseFieldMatrix<Fraction>(subColumn1); FieldMatrix<Fraction> mColumn1 = new BlockFieldMatrix<Fraction>(subColumn1);
FieldMatrix<Fraction> mColumn3 = new DenseFieldMatrix<Fraction>(subColumn3); FieldMatrix<Fraction> mColumn3 = new BlockFieldMatrix<Fraction>(subColumn3);
assertEquals(mColumn1, m.getColumnMatrix(1)); assertEquals(mColumn1, m.getColumnMatrix(1));
assertEquals(mColumn3, m.getColumnMatrix(3)); assertEquals(mColumn3, m.getColumnMatrix(3));
try { try {
@ -759,8 +759,8 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testSetColumnMatrix() { public void testSetColumnMatrix() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(subTestData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(subTestData);
FieldMatrix<Fraction> mColumn3 = new DenseFieldMatrix<Fraction>(subColumn3); FieldMatrix<Fraction> mColumn3 = new BlockFieldMatrix<Fraction>(subColumn3);
assertNotSame(mColumn3, m.getColumnMatrix(1)); assertNotSame(mColumn3, m.getColumnMatrix(1));
m.setColumnMatrix(1, mColumn3); m.setColumnMatrix(1, mColumn3);
assertEquals(mColumn3, m.getColumnMatrix(1)); assertEquals(mColumn3, m.getColumnMatrix(1));
@ -779,11 +779,11 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testGetSetColumnMatrixLarge() { public void testGetSetColumnMatrixLarge() {
int n = 3 * DenseFieldMatrix.BLOCK_SIZE; int n = 3 * BlockFieldMatrix.BLOCK_SIZE;
FieldMatrix<Fraction> m = FieldMatrix<Fraction> m =
new DenseFieldMatrix<Fraction>(FractionField.getInstance(), n, n); new BlockFieldMatrix<Fraction>(FractionField.getInstance(), n, n);
FieldMatrix<Fraction> sub = FieldMatrix<Fraction> sub =
new DenseFieldMatrix<Fraction>(FractionField.getInstance(), n, 1).scalarAdd(new Fraction(1)); new BlockFieldMatrix<Fraction>(FractionField.getInstance(), n, 1).scalarAdd(new Fraction(1));
m.setColumnMatrix(2, sub); m.setColumnMatrix(2, sub);
for (int i = 0; i < n; ++i) { for (int i = 0; i < n; ++i) {
@ -800,7 +800,7 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testGetRowVector() { public void testGetRowVector() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(subTestData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(subTestData);
FieldVector<Fraction> mRow0 = new FieldVectorImpl<Fraction>(subRow0[0]); FieldVector<Fraction> mRow0 = new FieldVectorImpl<Fraction>(subRow0[0]);
FieldVector<Fraction> mRow3 = new FieldVectorImpl<Fraction>(subRow3[0]); FieldVector<Fraction> mRow3 = new FieldVectorImpl<Fraction>(subRow3[0]);
assertEquals(mRow0, m.getRowVector(0)); assertEquals(mRow0, m.getRowVector(0));
@ -820,7 +820,7 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testSetRowVector() { public void testSetRowVector() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(subTestData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(subTestData);
FieldVector<Fraction> mRow3 = new FieldVectorImpl<Fraction>(subRow3[0]); FieldVector<Fraction> mRow3 = new FieldVectorImpl<Fraction>(subRow3[0]);
assertNotSame(mRow3, m.getRowMatrix(0)); assertNotSame(mRow3, m.getRowMatrix(0));
m.setRowVector(0, mRow3); m.setRowVector(0, mRow3);
@ -840,8 +840,8 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testGetSetRowVectorLarge() { public void testGetSetRowVectorLarge() {
int n = 3 * DenseFieldMatrix.BLOCK_SIZE; int n = 3 * BlockFieldMatrix.BLOCK_SIZE;
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(FractionField.getInstance(), n, n); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(FractionField.getInstance(), n, n);
FieldVector<Fraction> sub = new FieldVectorImpl<Fraction>(n, new Fraction(1)); FieldVector<Fraction> sub = new FieldVectorImpl<Fraction>(n, new Fraction(1));
m.setRowVector(2, sub); m.setRowVector(2, sub);
@ -859,7 +859,7 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testGetColumnVector() { public void testGetColumnVector() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(subTestData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(subTestData);
FieldVector<Fraction> mColumn1 = columnToVector(subColumn1); FieldVector<Fraction> mColumn1 = columnToVector(subColumn1);
FieldVector<Fraction> mColumn3 = columnToVector(subColumn3); FieldVector<Fraction> mColumn3 = columnToVector(subColumn3);
assertEquals(mColumn1, m.getColumnVector(1)); assertEquals(mColumn1, m.getColumnVector(1));
@ -879,7 +879,7 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testSetColumnVector() { public void testSetColumnVector() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(subTestData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(subTestData);
FieldVector<Fraction> mColumn3 = columnToVector(subColumn3); FieldVector<Fraction> mColumn3 = columnToVector(subColumn3);
assertNotSame(mColumn3, m.getColumnVector(1)); assertNotSame(mColumn3, m.getColumnVector(1));
m.setColumnVector(1, mColumn3); m.setColumnVector(1, mColumn3);
@ -899,8 +899,8 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testGetSetColumnVectorLarge() { public void testGetSetColumnVectorLarge() {
int n = 3 * DenseFieldMatrix.BLOCK_SIZE; int n = 3 * BlockFieldMatrix.BLOCK_SIZE;
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(FractionField.getInstance(), n, n); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(FractionField.getInstance(), n, n);
FieldVector<Fraction> sub = new FieldVectorImpl<Fraction>(n, new Fraction(1)); FieldVector<Fraction> sub = new FieldVectorImpl<Fraction>(n, new Fraction(1));
m.setColumnVector(2, sub); m.setColumnVector(2, sub);
@ -926,7 +926,7 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testGetRow() { public void testGetRow() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(subTestData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(subTestData);
checkArrays(subRow0[0], m.getRow(0)); checkArrays(subRow0[0], m.getRow(0));
checkArrays(subRow3[0], m.getRow(3)); checkArrays(subRow3[0], m.getRow(3));
try { try {
@ -944,7 +944,7 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testSetRow() { public void testSetRow() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(subTestData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(subTestData);
assertTrue(subRow3[0][0] != m.getRow(0)[0]); assertTrue(subRow3[0][0] != m.getRow(0)[0]);
m.setRow(0, subRow3[0]); m.setRow(0, subRow3[0]);
checkArrays(subRow3[0], m.getRow(0)); checkArrays(subRow3[0], m.getRow(0));
@ -963,8 +963,8 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testGetSetRowLarge() { public void testGetSetRowLarge() {
int n = 3 * DenseFieldMatrix.BLOCK_SIZE; int n = 3 * BlockFieldMatrix.BLOCK_SIZE;
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(FractionField.getInstance(), n, n); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(FractionField.getInstance(), n, n);
Fraction[] sub = new Fraction[n]; Fraction[] sub = new Fraction[n];
Arrays.fill(sub, new Fraction(1)); Arrays.fill(sub, new Fraction(1));
@ -983,7 +983,7 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testGetColumn() { public void testGetColumn() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(subTestData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(subTestData);
Fraction[] mColumn1 = columnToArray(subColumn1); Fraction[] mColumn1 = columnToArray(subColumn1);
Fraction[] mColumn3 = columnToArray(subColumn3); Fraction[] mColumn3 = columnToArray(subColumn3);
checkArrays(mColumn1, m.getColumn(1)); checkArrays(mColumn1, m.getColumn(1));
@ -1003,7 +1003,7 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testSetColumn() { public void testSetColumn() {
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(subTestData); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(subTestData);
Fraction[] mColumn3 = columnToArray(subColumn3); Fraction[] mColumn3 = columnToArray(subColumn3);
assertTrue(mColumn3[0] != m.getColumn(1)[0]); assertTrue(mColumn3[0] != m.getColumn(1)[0]);
m.setColumn(1, mColumn3); m.setColumn(1, mColumn3);
@ -1023,8 +1023,8 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testGetSetColumnLarge() { public void testGetSetColumnLarge() {
int n = 3 * DenseFieldMatrix.BLOCK_SIZE; int n = 3 * BlockFieldMatrix.BLOCK_SIZE;
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(FractionField.getInstance(), n, n); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(FractionField.getInstance(), n, n);
Fraction[] sub = new Fraction[n]; Fraction[] sub = new Fraction[n];
Arrays.fill(sub, new Fraction(1)); Arrays.fill(sub, new Fraction(1));
@ -1058,43 +1058,43 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testEqualsAndHashCode() { public void testEqualsAndHashCode() {
DenseFieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(testData); BlockFieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(testData);
DenseFieldMatrix<Fraction> m1 = (DenseFieldMatrix<Fraction>) m.copy(); BlockFieldMatrix<Fraction> m1 = (BlockFieldMatrix<Fraction>) m.copy();
DenseFieldMatrix<Fraction> mt = (DenseFieldMatrix<Fraction>) m.transpose(); BlockFieldMatrix<Fraction> mt = (BlockFieldMatrix<Fraction>) m.transpose();
assertTrue(m.hashCode() != mt.hashCode()); assertTrue(m.hashCode() != mt.hashCode());
assertEquals(m.hashCode(), m1.hashCode()); assertEquals(m.hashCode(), m1.hashCode());
assertEquals(m, m); assertEquals(m, m);
assertEquals(m, m1); assertEquals(m, m1);
assertFalse(m.equals(null)); assertFalse(m.equals(null));
assertFalse(m.equals(mt)); assertFalse(m.equals(mt));
assertFalse(m.equals(new DenseFieldMatrix<Fraction>(bigSingular))); assertFalse(m.equals(new BlockFieldMatrix<Fraction>(bigSingular)));
} }
public void testToString() { public void testToString() {
DenseFieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(testData); BlockFieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(testData);
assertEquals("DenseFieldMatrix{{1,2,3},{2,5,3},{1,0,8}}", m.toString()); assertEquals("BlockFieldMatrix{{1,2,3},{2,5,3},{1,0,8}}", m.toString());
} }
public void testSetSubMatrix() throws Exception { public void testSetSubMatrix() throws Exception {
DenseFieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(testData); BlockFieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(testData);
m.setSubMatrix(detData2,1,1); m.setSubMatrix(detData2,1,1);
FieldMatrix<Fraction> expected = new DenseFieldMatrix<Fraction> FieldMatrix<Fraction> expected = new BlockFieldMatrix<Fraction>
(new Fraction[][] {{new Fraction(1),new Fraction(2),new Fraction(3)},{new Fraction(2),new Fraction(1),new Fraction(3)},{new Fraction(1),new Fraction(2),new Fraction(4)}}); (new Fraction[][] {{new Fraction(1),new Fraction(2),new Fraction(3)},{new Fraction(2),new Fraction(1),new Fraction(3)},{new Fraction(1),new Fraction(2),new Fraction(4)}});
assertEquals(expected, m); assertEquals(expected, m);
m.setSubMatrix(detData2,0,0); m.setSubMatrix(detData2,0,0);
expected = new DenseFieldMatrix<Fraction> expected = new BlockFieldMatrix<Fraction>
(new Fraction[][] {{new Fraction(1),new Fraction(3),new Fraction(3)},{new Fraction(2),new Fraction(4),new Fraction(3)},{new Fraction(1),new Fraction(2),new Fraction(4)}}); (new Fraction[][] {{new Fraction(1),new Fraction(3),new Fraction(3)},{new Fraction(2),new Fraction(4),new Fraction(3)},{new Fraction(1),new Fraction(2),new Fraction(4)}});
assertEquals(expected, m); assertEquals(expected, m);
m.setSubMatrix(testDataPlus2,0,0); m.setSubMatrix(testDataPlus2,0,0);
expected = new DenseFieldMatrix<Fraction> expected = new BlockFieldMatrix<Fraction>
(new Fraction[][] {{new Fraction(3),new Fraction(4),new Fraction(5)},{new Fraction(4),new Fraction(7),new Fraction(5)},{new Fraction(3),new Fraction(2),new Fraction(10)}}); (new Fraction[][] {{new Fraction(3),new Fraction(4),new Fraction(5)},{new Fraction(4),new Fraction(7),new Fraction(5)},{new Fraction(3),new Fraction(2),new Fraction(10)}});
assertEquals(expected, m); assertEquals(expected, m);
// javadoc example // javadoc example
DenseFieldMatrix<Fraction> matrix = BlockFieldMatrix<Fraction> matrix =
new DenseFieldMatrix<Fraction>(new Fraction[][] { new BlockFieldMatrix<Fraction>(new Fraction[][] {
{new Fraction(1), new Fraction(2), new Fraction(3), new Fraction(4)}, {new Fraction(1), new Fraction(2), new Fraction(3), new Fraction(4)},
{new Fraction(5), new Fraction(6), new Fraction(7), new Fraction(8)}, {new Fraction(5), new Fraction(6), new Fraction(7), new Fraction(8)},
{new Fraction(9), new Fraction(0), new Fraction(1) , new Fraction(2)} {new Fraction(9), new Fraction(0), new Fraction(1) , new Fraction(2)}
@ -1104,7 +1104,7 @@ public final class DenseFieldMatrixTest extends TestCase {
{new Fraction(5), new Fraction(6)} {new Fraction(5), new Fraction(6)}
}, 1, 1); }, 1, 1);
expected = expected =
new DenseFieldMatrix<Fraction>(new Fraction[][] { new BlockFieldMatrix<Fraction>(new Fraction[][] {
{new Fraction(1), new Fraction(2), new Fraction(3),new Fraction(4)}, {new Fraction(1), new Fraction(2), new Fraction(3),new Fraction(4)},
{new Fraction(5), new Fraction(3), new Fraction(4), new Fraction(8)}, {new Fraction(5), new Fraction(3), new Fraction(4), new Fraction(8)},
{new Fraction(9), new Fraction(5) ,new Fraction(6), new Fraction(2)} {new Fraction(9), new Fraction(5) ,new Fraction(6), new Fraction(2)}
@ -1162,13 +1162,13 @@ public final class DenseFieldMatrixTest extends TestCase {
int rows = 150; int rows = 150;
int columns = 75; int columns = 75;
FieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(FractionField.getInstance(), rows, columns); FieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(FractionField.getInstance(), rows, columns);
m.walkInRowOrder(new SetVisitor()); m.walkInRowOrder(new SetVisitor());
GetVisitor getVisitor = new GetVisitor(); GetVisitor getVisitor = new GetVisitor();
m.walkInOptimizedOrder(getVisitor); m.walkInOptimizedOrder(getVisitor);
assertEquals(rows * columns, getVisitor.getCount()); assertEquals(rows * columns, getVisitor.getCount());
m = new DenseFieldMatrix<Fraction>(FractionField.getInstance(), rows, columns); m = new BlockFieldMatrix<Fraction>(FractionField.getInstance(), rows, columns);
m.walkInRowOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2); m.walkInRowOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2);
getVisitor = new GetVisitor(); getVisitor = new GetVisitor();
m.walkInOptimizedOrder(getVisitor, 1, rows - 2, 1, columns - 2); m.walkInOptimizedOrder(getVisitor, 1, rows - 2, 1, columns - 2);
@ -1182,13 +1182,13 @@ public final class DenseFieldMatrixTest extends TestCase {
assertEquals(new Fraction(0), m.getEntry(rows - 1, j)); assertEquals(new Fraction(0), m.getEntry(rows - 1, j));
} }
m = new DenseFieldMatrix<Fraction>(FractionField.getInstance(), rows, columns); m = new BlockFieldMatrix<Fraction>(FractionField.getInstance(), rows, columns);
m.walkInColumnOrder(new SetVisitor()); m.walkInColumnOrder(new SetVisitor());
getVisitor = new GetVisitor(); getVisitor = new GetVisitor();
m.walkInOptimizedOrder(getVisitor); m.walkInOptimizedOrder(getVisitor);
assertEquals(rows * columns, getVisitor.getCount()); assertEquals(rows * columns, getVisitor.getCount());
m = new DenseFieldMatrix<Fraction>(FractionField.getInstance(), rows, columns); m = new BlockFieldMatrix<Fraction>(FractionField.getInstance(), rows, columns);
m.walkInColumnOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2); m.walkInColumnOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2);
getVisitor = new GetVisitor(); getVisitor = new GetVisitor();
m.walkInOptimizedOrder(getVisitor, 1, rows - 2, 1, columns - 2); m.walkInOptimizedOrder(getVisitor, 1, rows - 2, 1, columns - 2);
@ -1202,13 +1202,13 @@ public final class DenseFieldMatrixTest extends TestCase {
assertEquals(new Fraction(0), m.getEntry(rows - 1, j)); assertEquals(new Fraction(0), m.getEntry(rows - 1, j));
} }
m = new DenseFieldMatrix<Fraction>(FractionField.getInstance(), rows, columns); m = new BlockFieldMatrix<Fraction>(FractionField.getInstance(), rows, columns);
m.walkInOptimizedOrder(new SetVisitor()); m.walkInOptimizedOrder(new SetVisitor());
getVisitor = new GetVisitor(); getVisitor = new GetVisitor();
m.walkInRowOrder(getVisitor); m.walkInRowOrder(getVisitor);
assertEquals(rows * columns, getVisitor.getCount()); assertEquals(rows * columns, getVisitor.getCount());
m = new DenseFieldMatrix<Fraction>(FractionField.getInstance(), rows, columns); m = new BlockFieldMatrix<Fraction>(FractionField.getInstance(), rows, columns);
m.walkInOptimizedOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2); m.walkInOptimizedOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2);
getVisitor = new GetVisitor(); getVisitor = new GetVisitor();
m.walkInRowOrder(getVisitor, 1, rows - 2, 1, columns - 2); m.walkInRowOrder(getVisitor, 1, rows - 2, 1, columns - 2);
@ -1222,13 +1222,13 @@ public final class DenseFieldMatrixTest extends TestCase {
assertEquals(new Fraction(0), m.getEntry(rows - 1, j)); assertEquals(new Fraction(0), m.getEntry(rows - 1, j));
} }
m = new DenseFieldMatrix<Fraction>(FractionField.getInstance(), rows, columns); m = new BlockFieldMatrix<Fraction>(FractionField.getInstance(), rows, columns);
m.walkInOptimizedOrder(new SetVisitor()); m.walkInOptimizedOrder(new SetVisitor());
getVisitor = new GetVisitor(); getVisitor = new GetVisitor();
m.walkInColumnOrder(getVisitor); m.walkInColumnOrder(getVisitor);
assertEquals(rows * columns, getVisitor.getCount()); assertEquals(rows * columns, getVisitor.getCount());
m = new DenseFieldMatrix<Fraction>(FractionField.getInstance(), rows, columns); m = new BlockFieldMatrix<Fraction>(FractionField.getInstance(), rows, columns);
m.walkInOptimizedOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2); m.walkInOptimizedOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2);
getVisitor = new GetVisitor(); getVisitor = new GetVisitor();
m.walkInColumnOrder(getVisitor, 1, rows - 2, 1, columns - 2); m.walkInColumnOrder(getVisitor, 1, rows - 2, 1, columns - 2);
@ -1245,7 +1245,7 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
public void testSerial() { public void testSerial() {
DenseFieldMatrix<Fraction> m = new DenseFieldMatrix<Fraction>(testData); BlockFieldMatrix<Fraction> m = new BlockFieldMatrix<Fraction>(testData);
assertEquals(m,TestUtils.serializeAndRecover(m)); assertEquals(m,TestUtils.serializeAndRecover(m));
} }
@ -1275,9 +1275,9 @@ public final class DenseFieldMatrixTest extends TestCase {
} }
} }
private DenseFieldMatrix<Fraction> createRandomMatrix(Random r, int rows, int columns) { private BlockFieldMatrix<Fraction> createRandomMatrix(Random r, int rows, int columns) {
DenseFieldMatrix<Fraction> m = BlockFieldMatrix<Fraction> m =
new DenseFieldMatrix<Fraction>(FractionField.getInstance(), rows, columns); new BlockFieldMatrix<Fraction>(FractionField.getInstance(), rows, columns);
for (int i = 0; i < rows; ++i) { for (int i = 0; i < rows; ++i) {
for (int j = 0; j < columns; ++j) { for (int j = 0; j < columns; ++j) {
int p = r.nextInt(20) - 10; int p = r.nextInt(20) - 10;

244
src/test/org/apache/commons/math/linear/DenseRealMatrixTest.java
View File

@ -26,7 +26,7 @@ import junit.framework.TestSuite;
import org.apache.commons.math.TestUtils; import org.apache.commons.math.TestUtils;
/** /**
* Test cases for the {@link DenseRealMatrix} class. * Test cases for the {@link BlockRealMatrix} class.
* *
* @version $Revision$ $Date$ * @version $Revision$ $Date$
*/ */
@ -99,14 +99,14 @@ public final class DenseRealMatrixTest extends TestCase {
public static Test suite() { public static Test suite() {
TestSuite suite = new TestSuite(DenseRealMatrixTest.class); TestSuite suite = new TestSuite(DenseRealMatrixTest.class);
suite.setName("DenseRealMatrix Tests"); suite.setName("BlockRealMatrix Tests");
return suite; return suite;
} }
/** test dimensions */ /** test dimensions */
public void testDimensions() { public void testDimensions() {
DenseRealMatrix m = new DenseRealMatrix(testData); BlockRealMatrix m = new BlockRealMatrix(testData);
DenseRealMatrix m2 = new DenseRealMatrix(testData2); BlockRealMatrix m2 = new BlockRealMatrix(testData2);
assertEquals("testData row dimension",3,m.getRowDimension()); assertEquals("testData row dimension",3,m.getRowDimension());
assertEquals("testData column dimension",3,m.getColumnDimension()); assertEquals("testData column dimension",3,m.getColumnDimension());
assertTrue("testData is square",m.isSquare()); assertTrue("testData is square",m.isSquare());
@ -118,18 +118,18 @@ public final class DenseRealMatrixTest extends TestCase {
/** test copy functions */ /** test copy functions */
public void testCopyFunctions() { public void testCopyFunctions() {
Random r = new Random(66636328996002l); Random r = new Random(66636328996002l);
DenseRealMatrix m1 = createRandomMatrix(r, 47, 83); BlockRealMatrix m1 = createRandomMatrix(r, 47, 83);
DenseRealMatrix m2 = new DenseRealMatrix(m1.getData()); BlockRealMatrix m2 = new BlockRealMatrix(m1.getData());
assertEquals(m1, m2); assertEquals(m1, m2);
DenseRealMatrix m3 = new DenseRealMatrix(testData); BlockRealMatrix m3 = new BlockRealMatrix(testData);
DenseRealMatrix m4 = new DenseRealMatrix(m3.getData()); BlockRealMatrix m4 = new BlockRealMatrix(m3.getData());
assertEquals(m3, m4); assertEquals(m3, m4);
} }
/** test add */ /** test add */
public void testAdd() { public void testAdd() {
DenseRealMatrix m = new DenseRealMatrix(testData); BlockRealMatrix m = new BlockRealMatrix(testData);
DenseRealMatrix mInv = new DenseRealMatrix(testDataInv); BlockRealMatrix mInv = new BlockRealMatrix(testDataInv);
RealMatrix mPlusMInv = m.add(mInv); RealMatrix mPlusMInv = m.add(mInv);
double[][] sumEntries = mPlusMInv.getData(); double[][] sumEntries = mPlusMInv.getData();
for (int row = 0; row < m.getRowDimension(); row++) { for (int row = 0; row < m.getRowDimension(); row++) {
@ -143,8 +143,8 @@ public final class DenseRealMatrixTest extends TestCase {
/** test add failure */ /** test add failure */
public void testAddFail() { public void testAddFail() {
DenseRealMatrix m = new DenseRealMatrix(testData); BlockRealMatrix m = new BlockRealMatrix(testData);
DenseRealMatrix m2 = new DenseRealMatrix(testData2); BlockRealMatrix m2 = new BlockRealMatrix(testData2);
try { try {
m.add(m2); m.add(m2);
fail("IllegalArgumentException expected"); fail("IllegalArgumentException expected");
@ -155,27 +155,27 @@ public final class DenseRealMatrixTest extends TestCase {
/** test norm */ /** test norm */
public void testNorm() { public void testNorm() {
DenseRealMatrix m = new DenseRealMatrix(testData); BlockRealMatrix m = new BlockRealMatrix(testData);
DenseRealMatrix m2 = new DenseRealMatrix(testData2); BlockRealMatrix m2 = new BlockRealMatrix(testData2);
assertEquals("testData norm",14d,m.getNorm(),entryTolerance); assertEquals("testData norm",14d,m.getNorm(),entryTolerance);
assertEquals("testData2 norm",7d,m2.getNorm(),entryTolerance); assertEquals("testData2 norm",7d,m2.getNorm(),entryTolerance);
} }
/** test Frobenius norm */ /** test Frobenius norm */
public void testFrobeniusNorm() { public void testFrobeniusNorm() {
DenseRealMatrix m = new DenseRealMatrix(testData); BlockRealMatrix m = new BlockRealMatrix(testData);
DenseRealMatrix m2 = new DenseRealMatrix(testData2); BlockRealMatrix m2 = new BlockRealMatrix(testData2);
assertEquals("testData Frobenius norm", Math.sqrt(117.0), m.getFrobeniusNorm(), entryTolerance); assertEquals("testData Frobenius norm", Math.sqrt(117.0), m.getFrobeniusNorm(), entryTolerance);
assertEquals("testData2 Frobenius norm", Math.sqrt(52.0), m2.getFrobeniusNorm(), entryTolerance); assertEquals("testData2 Frobenius norm", Math.sqrt(52.0), m2.getFrobeniusNorm(), entryTolerance);
} }
/** test m-n = m + -n */ /** test m-n = m + -n */
public void testPlusMinus() { public void testPlusMinus() {
DenseRealMatrix m = new DenseRealMatrix(testData); BlockRealMatrix m = new BlockRealMatrix(testData);
DenseRealMatrix m2 = new DenseRealMatrix(testDataInv); BlockRealMatrix m2 = new BlockRealMatrix(testDataInv);
assertClose(m.subtract(m2), m2.scalarMultiply(-1d).add(m), entryTolerance); assertClose(m.subtract(m2), m2.scalarMultiply(-1d).add(m), entryTolerance);
try { try {
m.subtract(new DenseRealMatrix(testData2)); m.subtract(new BlockRealMatrix(testData2));
fail("Expecting illegalArgumentException"); fail("Expecting illegalArgumentException");
} catch (IllegalArgumentException ex) { } catch (IllegalArgumentException ex) {
// ignored // ignored
@ -184,17 +184,17 @@ public final class DenseRealMatrixTest extends TestCase {
/** test multiply */ /** test multiply */
public void testMultiply() { public void testMultiply() {
DenseRealMatrix m = new DenseRealMatrix(testData); BlockRealMatrix m = new BlockRealMatrix(testData);
DenseRealMatrix mInv = new DenseRealMatrix(testDataInv); BlockRealMatrix mInv = new BlockRealMatrix(testDataInv);
DenseRealMatrix identity = new DenseRealMatrix(id); BlockRealMatrix identity = new BlockRealMatrix(id);
DenseRealMatrix m2 = new DenseRealMatrix(testData2); BlockRealMatrix m2 = new BlockRealMatrix(testData2);
assertClose(m.multiply(mInv), identity, entryTolerance); assertClose(m.multiply(mInv), identity, entryTolerance);
assertClose(mInv.multiply(m), identity, entryTolerance); assertClose(mInv.multiply(m), identity, entryTolerance);
assertClose(m.multiply(identity), m, entryTolerance); assertClose(m.multiply(identity), m, entryTolerance);
assertClose(identity.multiply(mInv), mInv, entryTolerance); assertClose(identity.multiply(mInv), mInv, entryTolerance);
assertClose(m2.multiply(identity), m2, entryTolerance); assertClose(m2.multiply(identity), m2, entryTolerance);
try { try {
m.multiply(new DenseRealMatrix(bigSingular)); m.multiply(new BlockRealMatrix(bigSingular));
fail("Expecting illegalArgumentException"); fail("Expecting illegalArgumentException");
} catch (IllegalArgumentException ex) { } catch (IllegalArgumentException ex) {
// expected // expected
@ -203,7 +203,7 @@ public final class DenseRealMatrixTest extends TestCase {
public void testSeveralBlocks() { public void testSeveralBlocks() {
RealMatrix m = new DenseRealMatrix(35, 71); RealMatrix m = new BlockRealMatrix(35, 71);
for (int i = 0; i < m.getRowDimension(); ++i) { for (int i = 0; i < m.getRowDimension(); ++i) {
for (int j = 0; j < m.getColumnDimension(); ++j) { for (int j = 0; j < m.getColumnDimension(); ++j) {
m.setEntry(i, j, i + j / 1024.0); m.setEntry(i, j, i + j / 1024.0);
@ -292,17 +292,17 @@ public final class DenseRealMatrixTest extends TestCase {
private double[][] d5 = new double[][] {{30},{70}}; private double[][] d5 = new double[][] {{30},{70}};
public void testMultiply2() { public void testMultiply2() {
RealMatrix m3 = new DenseRealMatrix(d3); RealMatrix m3 = new BlockRealMatrix(d3);
RealMatrix m4 = new DenseRealMatrix(d4); RealMatrix m4 = new BlockRealMatrix(d4);
RealMatrix m5 = new DenseRealMatrix(d5); RealMatrix m5 = new BlockRealMatrix(d5);
assertClose(m3.multiply(m4), m5, entryTolerance); assertClose(m3.multiply(m4), m5, entryTolerance);
} }
/** test trace */ /** test trace */
public void testTrace() { public void testTrace() {
RealMatrix m = new DenseRealMatrix(id); RealMatrix m = new BlockRealMatrix(id);
assertEquals("identity trace",3d,m.getTrace(),entryTolerance); assertEquals("identity trace",3d,m.getTrace(),entryTolerance);
m = new DenseRealMatrix(testData2); m = new BlockRealMatrix(testData2);
try { try {
m.getTrace(); m.getTrace();
fail("Expecting NonSquareMatrixException"); fail("Expecting NonSquareMatrixException");
@ -313,16 +313,16 @@ public final class DenseRealMatrixTest extends TestCase {
/** test scalarAdd */ /** test scalarAdd */
public void testScalarAdd() { public void testScalarAdd() {
RealMatrix m = new DenseRealMatrix(testData); RealMatrix m = new BlockRealMatrix(testData);
assertClose(new DenseRealMatrix(testDataPlus2), m.scalarAdd(2d), entryTolerance); assertClose(new BlockRealMatrix(testDataPlus2), m.scalarAdd(2d), entryTolerance);
} }
/** test operate */ /** test operate */
public void testOperate() { public void testOperate() {
RealMatrix m = new DenseRealMatrix(id); RealMatrix m = new BlockRealMatrix(id);
assertClose(testVector, m.operate(testVector), entryTolerance); assertClose(testVector, m.operate(testVector), entryTolerance);
assertClose(testVector, m.operate(new RealVectorImpl(testVector)).getData(), entryTolerance); assertClose(testVector, m.operate(new RealVectorImpl(testVector)).getData(), entryTolerance);
m = new DenseRealMatrix(bigSingular); m = new BlockRealMatrix(bigSingular);
try { try {
m.operate(testVector); m.operate(testVector);
fail("Expecting illegalArgumentException"); fail("Expecting illegalArgumentException");
@ -332,9 +332,9 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testOperateLarge() { public void testOperateLarge() {
int p = (7 * DenseRealMatrix.BLOCK_SIZE) / 2; int p = (7 * BlockRealMatrix.BLOCK_SIZE) / 2;
int q = (5 * DenseRealMatrix.BLOCK_SIZE) / 2; int q = (5 * BlockRealMatrix.BLOCK_SIZE) / 2;
int r = 3 * DenseRealMatrix.BLOCK_SIZE; int r = 3 * BlockRealMatrix.BLOCK_SIZE;
Random random = new Random(111007463902334l); Random random = new Random(111007463902334l);
RealMatrix m1 = createRandomMatrix(random, p, q); RealMatrix m1 = createRandomMatrix(random, p, q);
RealMatrix m2 = createRandomMatrix(random, q, r); RealMatrix m2 = createRandomMatrix(random, q, r);
@ -345,9 +345,9 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testOperatePremultiplyLarge() { public void testOperatePremultiplyLarge() {
int p = (7 * DenseRealMatrix.BLOCK_SIZE) / 2; int p = (7 * BlockRealMatrix.BLOCK_SIZE) / 2;
int q = (5 * DenseRealMatrix.BLOCK_SIZE) / 2; int q = (5 * BlockRealMatrix.BLOCK_SIZE) / 2;
int r = 3 * DenseRealMatrix.BLOCK_SIZE; int r = 3 * BlockRealMatrix.BLOCK_SIZE;
Random random = new Random(111007463902334l); Random random = new Random(111007463902334l);
RealMatrix m1 = createRandomMatrix(random, p, q); RealMatrix m1 = createRandomMatrix(random, p, q);
RealMatrix m2 = createRandomMatrix(random, q, r); RealMatrix m2 = createRandomMatrix(random, q, r);
@ -359,7 +359,7 @@ public final class DenseRealMatrixTest extends TestCase {
/** test issue MATH-209 */ /** test issue MATH-209 */
public void testMath209() { public void testMath209() {
RealMatrix a = new DenseRealMatrix(new double[][] { RealMatrix a = new BlockRealMatrix(new double[][] {
{ 1, 2 }, { 3, 4 }, { 5, 6 } { 1, 2 }, { 3, 4 }, { 5, 6 }
}); });
double[] b = a.operate(new double[] { 1, 1 }); double[] b = a.operate(new double[] { 1, 1 });
@ -371,22 +371,22 @@ public final class DenseRealMatrixTest extends TestCase {
/** test transpose */ /** test transpose */
public void testTranspose() { public void testTranspose() {
RealMatrix m = new DenseRealMatrix(testData); RealMatrix m = new BlockRealMatrix(testData);
RealMatrix mIT = new LUDecompositionImpl(m).getSolver().getInverse().transpose(); RealMatrix mIT = new LUDecompositionImpl(m).getSolver().getInverse().transpose();
RealMatrix mTI = new LUDecompositionImpl(m.transpose()).getSolver().getInverse(); RealMatrix mTI = new LUDecompositionImpl(m.transpose()).getSolver().getInverse();
assertClose(mIT, mTI, normTolerance); assertClose(mIT, mTI, normTolerance);
m = new DenseRealMatrix(testData2); m = new BlockRealMatrix(testData2);
RealMatrix mt = new DenseRealMatrix(testData2T); RealMatrix mt = new BlockRealMatrix(testData2T);
assertClose(mt, m.transpose(), normTolerance); assertClose(mt, m.transpose(), normTolerance);
} }
/** test preMultiply by vector */ /** test preMultiply by vector */
public void testPremultiplyVector() { public void testPremultiplyVector() {
RealMatrix m = new DenseRealMatrix(testData); RealMatrix m = new BlockRealMatrix(testData);
assertClose(m.preMultiply(testVector), preMultTest, normTolerance); assertClose(m.preMultiply(testVector), preMultTest, normTolerance);
assertClose(m.preMultiply(new RealVectorImpl(testVector).getData()), assertClose(m.preMultiply(new RealVectorImpl(testVector).getData()),
preMultTest, normTolerance); preMultTest, normTolerance);
m = new DenseRealMatrix(bigSingular); m = new BlockRealMatrix(bigSingular);
try { try {
m.preMultiply(testVector); m.preMultiply(testVector);
fail("expecting IllegalArgumentException"); fail("expecting IllegalArgumentException");
@ -396,20 +396,20 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testPremultiply() { public void testPremultiply() {
RealMatrix m3 = new DenseRealMatrix(d3); RealMatrix m3 = new BlockRealMatrix(d3);
RealMatrix m4 = new DenseRealMatrix(d4); RealMatrix m4 = new BlockRealMatrix(d4);
RealMatrix m5 = new DenseRealMatrix(d5); RealMatrix m5 = new BlockRealMatrix(d5);
assertClose(m4.preMultiply(m3), m5, entryTolerance); assertClose(m4.preMultiply(m3), m5, entryTolerance);
DenseRealMatrix m = new DenseRealMatrix(testData); BlockRealMatrix m = new BlockRealMatrix(testData);
DenseRealMatrix mInv = new DenseRealMatrix(testDataInv); BlockRealMatrix mInv = new BlockRealMatrix(testDataInv);
DenseRealMatrix identity = new DenseRealMatrix(id); BlockRealMatrix identity = new BlockRealMatrix(id);
assertClose(m.preMultiply(mInv), identity, entryTolerance); assertClose(m.preMultiply(mInv), identity, entryTolerance);
assertClose(mInv.preMultiply(m), identity, entryTolerance); assertClose(mInv.preMultiply(m), identity, entryTolerance);
assertClose(m.preMultiply(identity), m, entryTolerance); assertClose(m.preMultiply(identity), m, entryTolerance);
assertClose(identity.preMultiply(mInv), mInv, entryTolerance); assertClose(identity.preMultiply(mInv), mInv, entryTolerance);
try { try {
m.preMultiply(new DenseRealMatrix(bigSingular)); m.preMultiply(new BlockRealMatrix(bigSingular));
fail("Expecting illegalArgumentException"); fail("Expecting illegalArgumentException");
} catch (IllegalArgumentException ex) { } catch (IllegalArgumentException ex) {
// ignored // ignored
@ -417,7 +417,7 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testGetVectors() { public void testGetVectors() {
RealMatrix m = new DenseRealMatrix(testData); RealMatrix m = new BlockRealMatrix(testData);
assertClose(m.getRow(0), testDataRow1, entryTolerance); assertClose(m.getRow(0), testDataRow1, entryTolerance);
assertClose(m.getColumn(2), testDataCol3, entryTolerance); assertClose(m.getColumn(2), testDataCol3, entryTolerance);
try { try {
@ -435,7 +435,7 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testGetEntry() { public void testGetEntry() {
RealMatrix m = new DenseRealMatrix(testData); RealMatrix m = new BlockRealMatrix(testData);
assertEquals("get entry",m.getEntry(0,1),2d,entryTolerance); assertEquals("get entry",m.getEntry(0,1),2d,entryTolerance);
try { try {
m.getEntry(10, 4); m.getEntry(10, 4);
@ -449,10 +449,10 @@ public final class DenseRealMatrixTest extends TestCase {
public void testExamples() { public void testExamples() {
// Create a real matrix with two rows and three columns // Create a real matrix with two rows and three columns
double[][] matrixData = { {1d,2d,3d}, {2d,5d,3d}}; double[][] matrixData = { {1d,2d,3d}, {2d,5d,3d}};
RealMatrix m = new DenseRealMatrix(matrixData); RealMatrix m = new BlockRealMatrix(matrixData);
// One more with three rows, two columns // One more with three rows, two columns
double[][] matrixData2 = { {1d,2d}, {2d,5d}, {1d, 7d}}; double[][] matrixData2 = { {1d,2d}, {2d,5d}, {1d, 7d}};
RealMatrix n = new DenseRealMatrix(matrixData2); RealMatrix n = new BlockRealMatrix(matrixData2);
// Now multiply m by n // Now multiply m by n
RealMatrix p = m.multiply(n); RealMatrix p = m.multiply(n);
assertEquals(2, p.getRowDimension()); assertEquals(2, p.getRowDimension());
@ -464,7 +464,7 @@ public final class DenseRealMatrixTest extends TestCase {
// Solve example // Solve example
double[][] coefficientsData = {{2, 3, -2}, {-1, 7, 6}, {4, -3, -5}}; double[][] coefficientsData = {{2, 3, -2}, {-1, 7, 6}, {4, -3, -5}};
RealMatrix coefficients = new DenseRealMatrix(coefficientsData); RealMatrix coefficients = new BlockRealMatrix(coefficientsData);
double[] constants = {1, -2, 1}; double[] constants = {1, -2, 1};
double[] solution = new LUDecompositionImpl(coefficients).getSolver().solve(constants); double[] solution = new LUDecompositionImpl(coefficients).getSolver().solve(constants);
assertEquals(2 * solution[0] + 3 * solution[1] -2 * solution[2], constants[0], 1E-12); assertEquals(2 * solution[0] + 3 * solution[1] -2 * solution[2], constants[0], 1E-12);
@ -475,7 +475,7 @@ public final class DenseRealMatrixTest extends TestCase {
// test submatrix accessors // test submatrix accessors
public void testGetSubMatrix() { public void testGetSubMatrix() {
RealMatrix m = new DenseRealMatrix(subTestData); RealMatrix m = new BlockRealMatrix(subTestData);
checkGetSubMatrix(m, subRows23Cols00, 2 , 3 , 0, 0, false); checkGetSubMatrix(m, subRows23Cols00, 2 , 3 , 0, 0, false);
checkGetSubMatrix(m, subRows00Cols33, 0 , 0 , 3, 3, false); checkGetSubMatrix(m, subRows00Cols33, 0 , 0 , 3, 3, false);
checkGetSubMatrix(m, subRows01Cols23, 0 , 1 , 2, 3, false); checkGetSubMatrix(m, subRows01Cols23, 0 , 1 , 2, 3, false);
@ -498,7 +498,7 @@ public final class DenseRealMatrixTest extends TestCase {
boolean mustFail) { boolean mustFail) {
try { try {
RealMatrix sub = m.getSubMatrix(startRow, endRow, startColumn, endColumn); RealMatrix sub = m.getSubMatrix(startRow, endRow, startColumn, endColumn);
assertEquals(new DenseRealMatrix(reference), sub); assertEquals(new BlockRealMatrix(reference), sub);
if (mustFail) { if (mustFail) {
fail("Expecting MatrixIndexException"); fail("Expecting MatrixIndexException");
} }
@ -514,7 +514,7 @@ public final class DenseRealMatrixTest extends TestCase {
boolean mustFail) { boolean mustFail) {
try { try {
RealMatrix sub = m.getSubMatrix(selectedRows, selectedColumns); RealMatrix sub = m.getSubMatrix(selectedRows, selectedColumns);
assertEquals(new DenseRealMatrix(reference), sub); assertEquals(new BlockRealMatrix(reference), sub);
if (mustFail) { if (mustFail) {
fail("Expecting MatrixIndexException"); fail("Expecting MatrixIndexException");
} }
@ -526,9 +526,9 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testGetSetMatrixLarge() { public void testGetSetMatrixLarge() {
int n = 3 * DenseRealMatrix.BLOCK_SIZE; int n = 3 * BlockRealMatrix.BLOCK_SIZE;
RealMatrix m = new DenseRealMatrix(n, n); RealMatrix m = new BlockRealMatrix(n, n);
RealMatrix sub = new DenseRealMatrix(n - 4, n - 4).scalarAdd(1); RealMatrix sub = new BlockRealMatrix(n - 4, n - 4).scalarAdd(1);
m.setSubMatrix(sub.getData(), 2, 2); m.setSubMatrix(sub.getData(), 2, 2);
for (int i = 0; i < n; ++i) { for (int i = 0; i < n; ++i) {
@ -545,7 +545,7 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testCopySubMatrix() { public void testCopySubMatrix() {
RealMatrix m = new DenseRealMatrix(subTestData); RealMatrix m = new BlockRealMatrix(subTestData);
checkCopy(m, subRows23Cols00, 2 , 3 , 0, 0, false); checkCopy(m, subRows23Cols00, 2 , 3 , 0, 0, false);
checkCopy(m, subRows00Cols33, 0 , 0 , 3, 3, false); checkCopy(m, subRows00Cols33, 0 , 0 , 3, 3, false);
checkCopy(m, subRows01Cols23, 0 , 1 , 2, 3, false); checkCopy(m, subRows01Cols23, 0 , 1 , 2, 3, false);
@ -572,7 +572,7 @@ public final class DenseRealMatrixTest extends TestCase {
new double[1][1] : new double[1][1] :
new double[reference.length][reference[0].length]; new double[reference.length][reference[0].length];
m.copySubMatrix(startRow, endRow, startColumn, endColumn, sub); m.copySubMatrix(startRow, endRow, startColumn, endColumn, sub);
assertEquals(new DenseRealMatrix(reference), new DenseRealMatrix(sub)); assertEquals(new BlockRealMatrix(reference), new BlockRealMatrix(sub));
if (mustFail) { if (mustFail) {
fail("Expecting MatrixIndexException"); fail("Expecting MatrixIndexException");
} }
@ -591,7 +591,7 @@ public final class DenseRealMatrixTest extends TestCase {
new double[1][1] : new double[1][1] :
new double[reference.length][reference[0].length]; new double[reference.length][reference[0].length];
m.copySubMatrix(selectedRows, selectedColumns, sub); m.copySubMatrix(selectedRows, selectedColumns, sub);
assertEquals(new DenseRealMatrix(reference), new DenseRealMatrix(sub)); assertEquals(new BlockRealMatrix(reference), new BlockRealMatrix(sub));
if (mustFail) { if (mustFail) {
fail("Expecting MatrixIndexException"); fail("Expecting MatrixIndexException");
} }
@ -603,9 +603,9 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testGetRowMatrix() { public void testGetRowMatrix() {
RealMatrix m = new DenseRealMatrix(subTestData); RealMatrix m = new BlockRealMatrix(subTestData);
RealMatrix mRow0 = new DenseRealMatrix(subRow0); RealMatrix mRow0 = new BlockRealMatrix(subRow0);
RealMatrix mRow3 = new DenseRealMatrix(subRow3); RealMatrix mRow3 = new BlockRealMatrix(subRow3);
assertEquals("Row0", mRow0, m.getRowMatrix(0)); assertEquals("Row0", mRow0, m.getRowMatrix(0));
assertEquals("Row3", mRow3, m.getRowMatrix(3)); assertEquals("Row3", mRow3, m.getRowMatrix(3));
try { try {
@ -623,8 +623,8 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testSetRowMatrix() { public void testSetRowMatrix() {
RealMatrix m = new DenseRealMatrix(subTestData); RealMatrix m = new BlockRealMatrix(subTestData);
RealMatrix mRow3 = new DenseRealMatrix(subRow3); RealMatrix mRow3 = new BlockRealMatrix(subRow3);
assertNotSame(mRow3, m.getRowMatrix(0)); assertNotSame(mRow3, m.getRowMatrix(0));
m.setRowMatrix(0, mRow3); m.setRowMatrix(0, mRow3);
assertEquals(mRow3, m.getRowMatrix(0)); assertEquals(mRow3, m.getRowMatrix(0));
@ -643,9 +643,9 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testGetSetRowMatrixLarge() { public void testGetSetRowMatrixLarge() {
int n = 3 * DenseRealMatrix.BLOCK_SIZE; int n = 3 * BlockRealMatrix.BLOCK_SIZE;
RealMatrix m = new DenseRealMatrix(n, n); RealMatrix m = new BlockRealMatrix(n, n);
RealMatrix sub = new DenseRealMatrix(1, n).scalarAdd(1); RealMatrix sub = new BlockRealMatrix(1, n).scalarAdd(1);
m.setRowMatrix(2, sub); m.setRowMatrix(2, sub);
for (int i = 0; i < n; ++i) { for (int i = 0; i < n; ++i) {
@ -662,9 +662,9 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testGetColumnMatrix() { public void testGetColumnMatrix() {
RealMatrix m = new DenseRealMatrix(subTestData); RealMatrix m = new BlockRealMatrix(subTestData);
RealMatrix mColumn1 = new DenseRealMatrix(subColumn1); RealMatrix mColumn1 = new BlockRealMatrix(subColumn1);
RealMatrix mColumn3 = new DenseRealMatrix(subColumn3); RealMatrix mColumn3 = new BlockRealMatrix(subColumn3);
assertEquals(mColumn1, m.getColumnMatrix(1)); assertEquals(mColumn1, m.getColumnMatrix(1));
assertEquals(mColumn3, m.getColumnMatrix(3)); assertEquals(mColumn3, m.getColumnMatrix(3));
try { try {
@ -682,8 +682,8 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testSetColumnMatrix() { public void testSetColumnMatrix() {
RealMatrix m = new DenseRealMatrix(subTestData); RealMatrix m = new BlockRealMatrix(subTestData);
RealMatrix mColumn3 = new DenseRealMatrix(subColumn3); RealMatrix mColumn3 = new BlockRealMatrix(subColumn3);
assertNotSame(mColumn3, m.getColumnMatrix(1)); assertNotSame(mColumn3, m.getColumnMatrix(1));
m.setColumnMatrix(1, mColumn3); m.setColumnMatrix(1, mColumn3);
assertEquals(mColumn3, m.getColumnMatrix(1)); assertEquals(mColumn3, m.getColumnMatrix(1));
@ -702,9 +702,9 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testGetSetColumnMatrixLarge() { public void testGetSetColumnMatrixLarge() {
int n = 3 * DenseRealMatrix.BLOCK_SIZE; int n = 3 * BlockRealMatrix.BLOCK_SIZE;
RealMatrix m = new DenseRealMatrix(n, n); RealMatrix m = new BlockRealMatrix(n, n);
RealMatrix sub = new DenseRealMatrix(n, 1).scalarAdd(1); RealMatrix sub = new BlockRealMatrix(n, 1).scalarAdd(1);
m.setColumnMatrix(2, sub); m.setColumnMatrix(2, sub);
for (int i = 0; i < n; ++i) { for (int i = 0; i < n; ++i) {
@ -721,7 +721,7 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testGetRowVector() { public void testGetRowVector() {
RealMatrix m = new DenseRealMatrix(subTestData); RealMatrix m = new BlockRealMatrix(subTestData);
RealVector mRow0 = new RealVectorImpl(subRow0[0]); RealVector mRow0 = new RealVectorImpl(subRow0[0]);
RealVector mRow3 = new RealVectorImpl(subRow3[0]); RealVector mRow3 = new RealVectorImpl(subRow3[0]);
assertEquals(mRow0, m.getRowVector(0)); assertEquals(mRow0, m.getRowVector(0));
@ -741,7 +741,7 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testSetRowVector() { public void testSetRowVector() {
RealMatrix m = new DenseRealMatrix(subTestData); RealMatrix m = new BlockRealMatrix(subTestData);
RealVector mRow3 = new RealVectorImpl(subRow3[0]); RealVector mRow3 = new RealVectorImpl(subRow3[0]);
assertNotSame(mRow3, m.getRowMatrix(0)); assertNotSame(mRow3, m.getRowMatrix(0));
m.setRowVector(0, mRow3); m.setRowVector(0, mRow3);
@ -761,8 +761,8 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testGetSetRowVectorLarge() { public void testGetSetRowVectorLarge() {
int n = 3 * DenseRealMatrix.BLOCK_SIZE; int n = 3 * BlockRealMatrix.BLOCK_SIZE;
RealMatrix m = new DenseRealMatrix(n, n); RealMatrix m = new BlockRealMatrix(n, n);
RealVector sub = new RealVectorImpl(n, 1.0); RealVector sub = new RealVectorImpl(n, 1.0);
m.setRowVector(2, sub); m.setRowVector(2, sub);
@ -780,7 +780,7 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testGetColumnVector() { public void testGetColumnVector() {
RealMatrix m = new DenseRealMatrix(subTestData); RealMatrix m = new BlockRealMatrix(subTestData);
RealVector mColumn1 = columnToVector(subColumn1); RealVector mColumn1 = columnToVector(subColumn1);
RealVector mColumn3 = columnToVector(subColumn3); RealVector mColumn3 = columnToVector(subColumn3);
assertEquals(mColumn1, m.getColumnVector(1)); assertEquals(mColumn1, m.getColumnVector(1));
@ -800,7 +800,7 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testSetColumnVector() { public void testSetColumnVector() {
RealMatrix m = new DenseRealMatrix(subTestData); RealMatrix m = new BlockRealMatrix(subTestData);
RealVector mColumn3 = columnToVector(subColumn3); RealVector mColumn3 = columnToVector(subColumn3);
assertNotSame(mColumn3, m.getColumnVector(1)); assertNotSame(mColumn3, m.getColumnVector(1));
m.setColumnVector(1, mColumn3); m.setColumnVector(1, mColumn3);
@ -820,8 +820,8 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testGetSetColumnVectorLarge() { public void testGetSetColumnVectorLarge() {
int n = 3 * DenseRealMatrix.BLOCK_SIZE; int n = 3 * BlockRealMatrix.BLOCK_SIZE;
RealMatrix m = new DenseRealMatrix(n, n); RealMatrix m = new BlockRealMatrix(n, n);
RealVector sub = new RealVectorImpl(n, 1.0); RealVector sub = new RealVectorImpl(n, 1.0);
m.setColumnVector(2, sub); m.setColumnVector(2, sub);
@ -847,7 +847,7 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testGetRow() { public void testGetRow() {
RealMatrix m = new DenseRealMatrix(subTestData); RealMatrix m = new BlockRealMatrix(subTestData);
checkArrays(subRow0[0], m.getRow(0)); checkArrays(subRow0[0], m.getRow(0));
checkArrays(subRow3[0], m.getRow(3)); checkArrays(subRow3[0], m.getRow(3));
try { try {
@ -865,7 +865,7 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testSetRow() { public void testSetRow() {
RealMatrix m = new DenseRealMatrix(subTestData); RealMatrix m = new BlockRealMatrix(subTestData);
assertTrue(subRow3[0][0] != m.getRow(0)[0]); assertTrue(subRow3[0][0] != m.getRow(0)[0]);
m.setRow(0, subRow3[0]); m.setRow(0, subRow3[0]);
checkArrays(subRow3[0], m.getRow(0)); checkArrays(subRow3[0], m.getRow(0));
@ -884,8 +884,8 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testGetSetRowLarge() { public void testGetSetRowLarge() {
int n = 3 * DenseRealMatrix.BLOCK_SIZE; int n = 3 * BlockRealMatrix.BLOCK_SIZE;
RealMatrix m = new DenseRealMatrix(n, n); RealMatrix m = new BlockRealMatrix(n, n);
double[] sub = new double[n]; double[] sub = new double[n];
Arrays.fill(sub, 1.0); Arrays.fill(sub, 1.0);
@ -904,7 +904,7 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testGetColumn() { public void testGetColumn() {
RealMatrix m = new DenseRealMatrix(subTestData); RealMatrix m = new BlockRealMatrix(subTestData);
double[] mColumn1 = columnToArray(subColumn1); double[] mColumn1 = columnToArray(subColumn1);
double[] mColumn3 = columnToArray(subColumn3); double[] mColumn3 = columnToArray(subColumn3);
checkArrays(mColumn1, m.getColumn(1)); checkArrays(mColumn1, m.getColumn(1));
@ -924,7 +924,7 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testSetColumn() { public void testSetColumn() {
RealMatrix m = new DenseRealMatrix(subTestData); RealMatrix m = new BlockRealMatrix(subTestData);
double[] mColumn3 = columnToArray(subColumn3); double[] mColumn3 = columnToArray(subColumn3);
assertTrue(mColumn3[0] != m.getColumn(1)[0]); assertTrue(mColumn3[0] != m.getColumn(1)[0]);
m.setColumn(1, mColumn3); m.setColumn(1, mColumn3);
@ -944,8 +944,8 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testGetSetColumnLarge() { public void testGetSetColumnLarge() {
int n = 3 * DenseRealMatrix.BLOCK_SIZE; int n = 3 * BlockRealMatrix.BLOCK_SIZE;
RealMatrix m = new DenseRealMatrix(n, n); RealMatrix m = new BlockRealMatrix(n, n);
double[] sub = new double[n]; double[] sub = new double[n];
Arrays.fill(sub, 1.0); Arrays.fill(sub, 1.0);
@ -979,46 +979,46 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testEqualsAndHashCode() { public void testEqualsAndHashCode() {
DenseRealMatrix m = new DenseRealMatrix(testData); BlockRealMatrix m = new BlockRealMatrix(testData);
DenseRealMatrix m1 = (DenseRealMatrix) m.copy(); BlockRealMatrix m1 = (BlockRealMatrix) m.copy();
DenseRealMatrix mt = (DenseRealMatrix) m.transpose(); BlockRealMatrix mt = (BlockRealMatrix) m.transpose();
assertTrue(m.hashCode() != mt.hashCode()); assertTrue(m.hashCode() != mt.hashCode());
assertEquals(m.hashCode(), m1.hashCode()); assertEquals(m.hashCode(), m1.hashCode());
assertEquals(m, m); assertEquals(m, m);
assertEquals(m, m1); assertEquals(m, m1);
assertFalse(m.equals(null)); assertFalse(m.equals(null));
assertFalse(m.equals(mt)); assertFalse(m.equals(mt));
assertFalse(m.equals(new DenseRealMatrix(bigSingular))); assertFalse(m.equals(new BlockRealMatrix(bigSingular)));
} }
public void testToString() { public void testToString() {
DenseRealMatrix m = new DenseRealMatrix(testData); BlockRealMatrix m = new BlockRealMatrix(testData);
assertEquals("DenseRealMatrix{{1.0,2.0,3.0},{2.0,5.0,3.0},{1.0,0.0,8.0}}", assertEquals("BlockRealMatrix{{1.0,2.0,3.0},{2.0,5.0,3.0},{1.0,0.0,8.0}}",
m.toString()); m.toString());
} }
public void testSetSubMatrix() throws Exception { public void testSetSubMatrix() throws Exception {
DenseRealMatrix m = new DenseRealMatrix(testData); BlockRealMatrix m = new BlockRealMatrix(testData);
m.setSubMatrix(detData2,1,1); m.setSubMatrix(detData2,1,1);
RealMatrix expected = new DenseRealMatrix RealMatrix expected = new BlockRealMatrix
(new double[][] {{1.0,2.0,3.0},{2.0,1.0,3.0},{1.0,2.0,4.0}}); (new double[][] {{1.0,2.0,3.0},{2.0,1.0,3.0},{1.0,2.0,4.0}});
assertEquals(expected, m); assertEquals(expected, m);
m.setSubMatrix(detData2,0,0); m.setSubMatrix(detData2,0,0);
expected = new DenseRealMatrix expected = new BlockRealMatrix
(new double[][] {{1.0,3.0,3.0},{2.0,4.0,3.0},{1.0,2.0,4.0}}); (new double[][] {{1.0,3.0,3.0},{2.0,4.0,3.0},{1.0,2.0,4.0}});
assertEquals(expected, m); assertEquals(expected, m);
m.setSubMatrix(testDataPlus2,0,0); m.setSubMatrix(testDataPlus2,0,0);
expected = new DenseRealMatrix expected = new BlockRealMatrix
(new double[][] {{3.0,4.0,5.0},{4.0,7.0,5.0},{3.0,2.0,10.0}}); (new double[][] {{3.0,4.0,5.0},{4.0,7.0,5.0},{3.0,2.0,10.0}});
assertEquals(expected, m); assertEquals(expected, m);
// javadoc example // javadoc example
DenseRealMatrix matrix = new DenseRealMatrix BlockRealMatrix matrix = new BlockRealMatrix
(new double[][] {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 0, 1 , 2}}); (new double[][] {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 0, 1 , 2}});
matrix.setSubMatrix(new double[][] {{3, 4}, {5, 6}}, 1, 1); matrix.setSubMatrix(new double[][] {{3, 4}, {5, 6}}, 1, 1);
expected = new DenseRealMatrix expected = new BlockRealMatrix
(new double[][] {{1, 2, 3, 4}, {5, 3, 4, 8}, {9, 5 ,6, 2}}); (new double[][] {{1, 2, 3, 4}, {5, 3, 4, 8}, {9, 5 ,6, 2}});
assertEquals(expected, matrix); assertEquals(expected, matrix);
@ -1073,13 +1073,13 @@ public final class DenseRealMatrixTest extends TestCase {
int rows = 150; int rows = 150;
int columns = 75; int columns = 75;
RealMatrix m = new DenseRealMatrix(rows, columns); RealMatrix m = new BlockRealMatrix(rows, columns);
m.walkInRowOrder(new SetVisitor()); m.walkInRowOrder(new SetVisitor());
GetVisitor getVisitor = new GetVisitor(); GetVisitor getVisitor = new GetVisitor();
m.walkInOptimizedOrder(getVisitor); m.walkInOptimizedOrder(getVisitor);
assertEquals(rows * columns, getVisitor.getCount()); assertEquals(rows * columns, getVisitor.getCount());
m = new DenseRealMatrix(rows, columns); m = new BlockRealMatrix(rows, columns);
m.walkInRowOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2); m.walkInRowOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2);
getVisitor = new GetVisitor(); getVisitor = new GetVisitor();
m.walkInOptimizedOrder(getVisitor, 1, rows - 2, 1, columns - 2); m.walkInOptimizedOrder(getVisitor, 1, rows - 2, 1, columns - 2);
@ -1093,13 +1093,13 @@ public final class DenseRealMatrixTest extends TestCase {
assertEquals(0.0, m.getEntry(rows - 1, j), 0); assertEquals(0.0, m.getEntry(rows - 1, j), 0);
} }
m = new DenseRealMatrix(rows, columns); m = new BlockRealMatrix(rows, columns);
m.walkInColumnOrder(new SetVisitor()); m.walkInColumnOrder(new SetVisitor());
getVisitor = new GetVisitor(); getVisitor = new GetVisitor();
m.walkInOptimizedOrder(getVisitor); m.walkInOptimizedOrder(getVisitor);
assertEquals(rows * columns, getVisitor.getCount()); assertEquals(rows * columns, getVisitor.getCount());
m = new DenseRealMatrix(rows, columns); m = new BlockRealMatrix(rows, columns);
m.walkInColumnOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2); m.walkInColumnOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2);
getVisitor = new GetVisitor(); getVisitor = new GetVisitor();
m.walkInOptimizedOrder(getVisitor, 1, rows - 2, 1, columns - 2); m.walkInOptimizedOrder(getVisitor, 1, rows - 2, 1, columns - 2);
@ -1113,13 +1113,13 @@ public final class DenseRealMatrixTest extends TestCase {
assertEquals(0.0, m.getEntry(rows - 1, j), 0); assertEquals(0.0, m.getEntry(rows - 1, j), 0);
} }
m = new DenseRealMatrix(rows, columns); m = new BlockRealMatrix(rows, columns);
m.walkInOptimizedOrder(new SetVisitor()); m.walkInOptimizedOrder(new SetVisitor());
getVisitor = new GetVisitor(); getVisitor = new GetVisitor();
m.walkInRowOrder(getVisitor); m.walkInRowOrder(getVisitor);
assertEquals(rows * columns, getVisitor.getCount()); assertEquals(rows * columns, getVisitor.getCount());
m = new DenseRealMatrix(rows, columns); m = new BlockRealMatrix(rows, columns);
m.walkInOptimizedOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2); m.walkInOptimizedOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2);
getVisitor = new GetVisitor(); getVisitor = new GetVisitor();
m.walkInRowOrder(getVisitor, 1, rows - 2, 1, columns - 2); m.walkInRowOrder(getVisitor, 1, rows - 2, 1, columns - 2);
@ -1133,13 +1133,13 @@ public final class DenseRealMatrixTest extends TestCase {
assertEquals(0.0, m.getEntry(rows - 1, j), 0); assertEquals(0.0, m.getEntry(rows - 1, j), 0);
} }
m = new DenseRealMatrix(rows, columns); m = new BlockRealMatrix(rows, columns);
m.walkInOptimizedOrder(new SetVisitor()); m.walkInOptimizedOrder(new SetVisitor());
getVisitor = new GetVisitor(); getVisitor = new GetVisitor();
m.walkInColumnOrder(getVisitor); m.walkInColumnOrder(getVisitor);
assertEquals(rows * columns, getVisitor.getCount()); assertEquals(rows * columns, getVisitor.getCount());
m = new DenseRealMatrix(rows, columns); m = new BlockRealMatrix(rows, columns);
m.walkInOptimizedOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2); m.walkInOptimizedOrder(new SetVisitor(), 1, rows - 2, 1, columns - 2);
getVisitor = new GetVisitor(); getVisitor = new GetVisitor();
m.walkInColumnOrder(getVisitor, 1, rows - 2, 1, columns - 2); m.walkInColumnOrder(getVisitor, 1, rows - 2, 1, columns - 2);
@ -1156,7 +1156,7 @@ public final class DenseRealMatrixTest extends TestCase {
} }
public void testSerial() { public void testSerial() {
DenseRealMatrix m = new DenseRealMatrix(testData); BlockRealMatrix m = new BlockRealMatrix(testData);
assertEquals(m,TestUtils.serializeAndRecover(m)); assertEquals(m,TestUtils.serializeAndRecover(m));
} }
@ -1196,8 +1196,8 @@ public final class DenseRealMatrixTest extends TestCase {
} }
} }
private DenseRealMatrix createRandomMatrix(Random r, int rows, int columns) { private BlockRealMatrix createRandomMatrix(Random r, int rows, int columns) {
DenseRealMatrix m = new DenseRealMatrix(rows, columns); BlockRealMatrix m = new BlockRealMatrix(rows, columns);
for (int i = 0; i < rows; ++i) { for (int i = 0; i < rows; ++i) {
for (int j = 0; j < columns; ++j) { for (int j = 0; j < columns; ++j) {
m.setEntry(i, j, 200 * r.nextDouble() - 100); m.setEntry(i, j, 200 * r.nextDouble() - 100);

6
src/test/org/apache/commons/math/linear/MatrixUtilsTest.java
View File

@ -74,7 +74,7 @@ public final class MatrixUtilsTest extends TestCase {
} }
public void testCreateRealMatrix() { public void testCreateRealMatrix() {
assertEquals(new DenseRealMatrix(testData), assertEquals(new BlockRealMatrix(testData),
MatrixUtils.createRealMatrix(testData)); MatrixUtils.createRealMatrix(testData));
try { try {
MatrixUtils.createRealMatrix(new double[][] {{1}, {1,2}}); // ragged MatrixUtils.createRealMatrix(new double[][] {{1}, {1,2}}); // ragged
@ -155,7 +155,7 @@ public final class MatrixUtilsTest extends TestCase {
public void testCreateRowRealMatrix() { public void testCreateRowRealMatrix() {
assertEquals(MatrixUtils.createRowRealMatrix(row), assertEquals(MatrixUtils.createRowRealMatrix(row),
new DenseRealMatrix(rowMatrix)); new BlockRealMatrix(rowMatrix));
try { try {
MatrixUtils.createRowRealMatrix(new double[] {}); // empty MatrixUtils.createRowRealMatrix(new double[] {}); // empty
fail("Expecting IllegalArgumentException"); fail("Expecting IllegalArgumentException");
@ -213,7 +213,7 @@ public final class MatrixUtilsTest extends TestCase {
public void testCreateColumnRealMatrix() { public void testCreateColumnRealMatrix() {
assertEquals(MatrixUtils.createColumnRealMatrix(col), assertEquals(MatrixUtils.createColumnRealMatrix(col),
new DenseRealMatrix(colMatrix)); new BlockRealMatrix(colMatrix));
try { try {
MatrixUtils.createColumnRealMatrix(new double[] {}); // empty MatrixUtils.createColumnRealMatrix(new double[] {}); // empty
fail("Expecting IllegalArgumentException"); fail("Expecting IllegalArgumentException");

22
src/test/org/apache/commons/math/linear/QRDecompositionImplTest.java
View File

@ -21,7 +21,7 @@ import java.util.Random;
import org.apache.commons.math.linear.DefaultRealMatrixChangingVisitor; import org.apache.commons.math.linear.DefaultRealMatrixChangingVisitor;
import org.apache.commons.math.linear.DefaultRealMatrixPreservingVisitor; import org.apache.commons.math.linear.DefaultRealMatrixPreservingVisitor;
import org.apache.commons.math.linear.DenseRealMatrix; import org.apache.commons.math.linear.BlockRealMatrix;
import org.apache.commons.math.linear.MatrixUtils; import org.apache.commons.math.linear.MatrixUtils;
import org.apache.commons.math.linear.MatrixVisitorException; import org.apache.commons.math.linear.MatrixVisitorException;
import org.apache.commons.math.linear.QRDecomposition; import org.apache.commons.math.linear.QRDecomposition;
@ -77,8 +77,8 @@ public class QRDecompositionImplTest extends TestCase {
checkDimension(MatrixUtils.createRealMatrix(testData3x4)); checkDimension(MatrixUtils.createRealMatrix(testData3x4));
Random r = new Random(643895747384642l); Random r = new Random(643895747384642l);
int p = (5 * DenseRealMatrix.BLOCK_SIZE) / 4; int p = (5 * BlockRealMatrix.BLOCK_SIZE) / 4;
int q = (7 * DenseRealMatrix.BLOCK_SIZE) / 4; int q = (7 * BlockRealMatrix.BLOCK_SIZE) / 4;
checkDimension(createTestMatrix(r, p, q)); checkDimension(createTestMatrix(r, p, q));
checkDimension(createTestMatrix(r, q, p)); checkDimension(createTestMatrix(r, q, p));
@ -105,8 +105,8 @@ public class QRDecompositionImplTest extends TestCase {
checkAEqualQR(MatrixUtils.createRealMatrix(testData4x3)); checkAEqualQR(MatrixUtils.createRealMatrix(testData4x3));
Random r = new Random(643895747384642l); Random r = new Random(643895747384642l);
int p = (5 * DenseRealMatrix.BLOCK_SIZE) / 4; int p = (5 * BlockRealMatrix.BLOCK_SIZE) / 4;
int q = (7 * DenseRealMatrix.BLOCK_SIZE) / 4; int q = (7 * BlockRealMatrix.BLOCK_SIZE) / 4;
checkAEqualQR(createTestMatrix(r, p, q)); checkAEqualQR(createTestMatrix(r, p, q));
checkAEqualQR(createTestMatrix(r, q, p)); checkAEqualQR(createTestMatrix(r, q, p));
@ -130,8 +130,8 @@ public class QRDecompositionImplTest extends TestCase {
checkQOrthogonal(MatrixUtils.createRealMatrix(testData4x3)); checkQOrthogonal(MatrixUtils.createRealMatrix(testData4x3));
Random r = new Random(643895747384642l); Random r = new Random(643895747384642l);
int p = (5 * DenseRealMatrix.BLOCK_SIZE) / 4; int p = (5 * BlockRealMatrix.BLOCK_SIZE) / 4;
int q = (7 * DenseRealMatrix.BLOCK_SIZE) / 4; int q = (7 * BlockRealMatrix.BLOCK_SIZE) / 4;
checkQOrthogonal(createTestMatrix(r, p, q)); checkQOrthogonal(createTestMatrix(r, p, q));
checkQOrthogonal(createTestMatrix(r, q, p)); checkQOrthogonal(createTestMatrix(r, q, p));
@ -160,8 +160,8 @@ public class QRDecompositionImplTest extends TestCase {
checkUpperTriangular(new QRDecompositionImpl(matrix).getR()); checkUpperTriangular(new QRDecompositionImpl(matrix).getR());
Random r = new Random(643895747384642l); Random r = new Random(643895747384642l);
int p = (5 * DenseRealMatrix.BLOCK_SIZE) / 4; int p = (5 * BlockRealMatrix.BLOCK_SIZE) / 4;
int q = (7 * DenseRealMatrix.BLOCK_SIZE) / 4; int q = (7 * BlockRealMatrix.BLOCK_SIZE) / 4;
matrix = createTestMatrix(r, p, q); matrix = createTestMatrix(r, p, q);
checkUpperTriangular(new QRDecompositionImpl(matrix).getR()); checkUpperTriangular(new QRDecompositionImpl(matrix).getR());
@ -196,8 +196,8 @@ public class QRDecompositionImplTest extends TestCase {
checkTrapezoidal(new QRDecompositionImpl(matrix).getH()); checkTrapezoidal(new QRDecompositionImpl(matrix).getH());
Random r = new Random(643895747384642l); Random r = new Random(643895747384642l);
int p = (5 * DenseRealMatrix.BLOCK_SIZE) / 4; int p = (5 * BlockRealMatrix.BLOCK_SIZE) / 4;
int q = (7 * DenseRealMatrix.BLOCK_SIZE) / 4; int q = (7 * BlockRealMatrix.BLOCK_SIZE) / 4;
matrix = createTestMatrix(r, p, q); matrix = createTestMatrix(r, p, q);
checkTrapezoidal(new QRDecompositionImpl(matrix).getH()); checkTrapezoidal(new QRDecompositionImpl(matrix).getH());

14
src/test/org/apache/commons/math/linear/QRSolverTest.java
View File

@ -25,7 +25,7 @@ import junit.framework.TestSuite;
import org.apache.commons.math.linear.DecompositionSolver; import org.apache.commons.math.linear.DecompositionSolver;
import org.apache.commons.math.linear.DefaultRealMatrixChangingVisitor; import org.apache.commons.math.linear.DefaultRealMatrixChangingVisitor;
import org.apache.commons.math.linear.DenseRealMatrix; import org.apache.commons.math.linear.BlockRealMatrix;
import org.apache.commons.math.linear.InvalidMatrixException; import org.apache.commons.math.linear.InvalidMatrixException;
import org.apache.commons.math.linear.MatrixUtils; import org.apache.commons.math.linear.MatrixUtils;
import org.apache.commons.math.linear.MatrixVisitorException; import org.apache.commons.math.linear.MatrixVisitorException;
@ -192,10 +192,10 @@ public class QRSolverTest extends TestCase {
public void testOverdetermined() { public void testOverdetermined() {
final Random r = new Random(5559252868205245l); final Random r = new Random(5559252868205245l);
int p = (7 * DenseRealMatrix.BLOCK_SIZE) / 4; int p = (7 * BlockRealMatrix.BLOCK_SIZE) / 4;
int q = (5 * DenseRealMatrix.BLOCK_SIZE) / 4; int q = (5 * BlockRealMatrix.BLOCK_SIZE) / 4;
RealMatrix a = createTestMatrix(r, p, q); RealMatrix a = createTestMatrix(r, p, q);
RealMatrix xRef = createTestMatrix(r, q, DenseRealMatrix.BLOCK_SIZE + 3); RealMatrix xRef = createTestMatrix(r, q, BlockRealMatrix.BLOCK_SIZE + 3);
// build a perturbed system: A.X + noise = B // build a perturbed system: A.X + noise = B
RealMatrix b = a.multiply(xRef); RealMatrix b = a.multiply(xRef);
@ -215,10 +215,10 @@ public class QRSolverTest extends TestCase {
public void testUnderdetermined() { public void testUnderdetermined() {
final Random r = new Random(42185006424567123l); final Random r = new Random(42185006424567123l);
int p = (5 * DenseRealMatrix.BLOCK_SIZE) / 4; int p = (5 * BlockRealMatrix.BLOCK_SIZE) / 4;
int q = (7 * DenseRealMatrix.BLOCK_SIZE) / 4; int q = (7 * BlockRealMatrix.BLOCK_SIZE) / 4;
RealMatrix a = createTestMatrix(r, p, q); RealMatrix a = createTestMatrix(r, p, q);
RealMatrix xRef = createTestMatrix(r, q, DenseRealMatrix.BLOCK_SIZE + 3); RealMatrix xRef = createTestMatrix(r, q, BlockRealMatrix.BLOCK_SIZE + 3);
RealMatrix b = a.multiply(xRef); RealMatrix b = a.multiply(xRef);
RealMatrix x = new QRDecompositionImpl(a).getSolver().solve(b); RealMatrix x = new QRDecompositionImpl(a).getSolver().solve(b);

2
src/test/org/apache/commons/math/linear/SparseRealMatrixTest.java
View File

@ -195,7 +195,7 @@ public final class SparseRealMatrixTest extends TestCase {
OpenMapRealMatrix m2 = createSparseMatrix(testData2); OpenMapRealMatrix m2 = createSparseMatrix(testData2);
assertClose("inverse multiply", m.multiply(mInv), identity, assertClose("inverse multiply", m.multiply(mInv), identity,
entryTolerance); entryTolerance);
assertClose("inverse multiply", m.multiply(new DenseRealMatrix(testDataInv)), identity, assertClose("inverse multiply", m.multiply(new BlockRealMatrix(testDataInv)), identity,
entryTolerance); entryTolerance);
assertClose("inverse multiply", mInv.multiply(m), identity, assertClose("inverse multiply", mInv.multiply(m), identity,
entryTolerance); entryTolerance);

4
src/test/org/apache/commons/math/optimization/general/GaussNewtonOptimizerTest.java
View File

@ -29,7 +29,7 @@ import junit.framework.TestSuite;
import org.apache.commons.math.FunctionEvaluationException; import org.apache.commons.math.FunctionEvaluationException;
import org.apache.commons.math.analysis.DifferentiableMultivariateVectorialFunction; import org.apache.commons.math.analysis.DifferentiableMultivariateVectorialFunction;
import org.apache.commons.math.analysis.MultivariateMatrixFunction; import org.apache.commons.math.analysis.MultivariateMatrixFunction;
import org.apache.commons.math.linear.DenseRealMatrix; import org.apache.commons.math.linear.BlockRealMatrix;
import org.apache.commons.math.linear.RealMatrix; import org.apache.commons.math.linear.RealMatrix;
import org.apache.commons.math.optimization.OptimizationException; import org.apache.commons.math.optimization.OptimizationException;
import org.apache.commons.math.optimization.SimpleVectorialValueChecker; import org.apache.commons.math.optimization.SimpleVectorialValueChecker;
@ -485,7 +485,7 @@ extends TestCase {
final RealMatrix factors; final RealMatrix factors;
final double[] target; final double[] target;
public LinearProblem(double[][] factors, double[] target) { public LinearProblem(double[][] factors, double[] target) {
this.factors = new DenseRealMatrix(factors); this.factors = new BlockRealMatrix(factors);
this.target = target; this.target = target;
} }

4
src/test/org/apache/commons/math/optimization/general/LevenbergMarquardtOptimizerTest.java
View File

@ -30,7 +30,7 @@ import junit.framework.TestSuite;
import org.apache.commons.math.FunctionEvaluationException; import org.apache.commons.math.FunctionEvaluationException;
import org.apache.commons.math.analysis.DifferentiableMultivariateVectorialFunction; import org.apache.commons.math.analysis.DifferentiableMultivariateVectorialFunction;
import org.apache.commons.math.analysis.MultivariateMatrixFunction; import org.apache.commons.math.analysis.MultivariateMatrixFunction;
import org.apache.commons.math.linear.DenseRealMatrix; import org.apache.commons.math.linear.BlockRealMatrix;
import org.apache.commons.math.linear.RealMatrix; import org.apache.commons.math.linear.RealMatrix;
import org.apache.commons.math.optimization.OptimizationException; import org.apache.commons.math.optimization.OptimizationException;
import org.apache.commons.math.optimization.SimpleVectorialValueChecker; import org.apache.commons.math.optimization.SimpleVectorialValueChecker;
@ -525,7 +525,7 @@ public class LevenbergMarquardtOptimizerTest
final RealMatrix factors; final RealMatrix factors;
final double[] target; final double[] target;
public LinearProblem(double[][] factors, double[] target) { public LinearProblem(double[][] factors, double[] target) {
this.factors = new DenseRealMatrix(factors); this.factors = new BlockRealMatrix(factors);
this.target = target; this.target = target;
} }

4
src/test/org/apache/commons/math/optimization/general/NonLinearConjugateGradientOptimizerTest.java
View File

@ -30,7 +30,7 @@ import org.apache.commons.math.analysis.DifferentiableMultivariateRealFunction;
import org.apache.commons.math.analysis.MultivariateRealFunction; import org.apache.commons.math.analysis.MultivariateRealFunction;
import org.apache.commons.math.analysis.MultivariateVectorialFunction; import org.apache.commons.math.analysis.MultivariateVectorialFunction;
import org.apache.commons.math.analysis.solvers.BrentSolver; import org.apache.commons.math.analysis.solvers.BrentSolver;
import org.apache.commons.math.linear.DenseRealMatrix; import org.apache.commons.math.linear.BlockRealMatrix;
import org.apache.commons.math.linear.RealMatrix; import org.apache.commons.math.linear.RealMatrix;
import org.apache.commons.math.optimization.GoalType; import org.apache.commons.math.optimization.GoalType;
import org.apache.commons.math.optimization.OptimizationException; import org.apache.commons.math.optimization.OptimizationException;
@ -369,7 +369,7 @@ extends TestCase {
final RealMatrix factors; final RealMatrix factors;
final double[] target; final double[] target;
public LinearProblem(double[][] factors, double[] target) { public LinearProblem(double[][] factors, double[] target) {
this.factors = new DenseRealMatrix(factors); this.factors = new BlockRealMatrix(factors);
this.target = target; this.target = target;
} }

8
src/test/org/apache/commons/math/stat/correlation/PearsonsCorrelationTest.java
View File

@ -20,7 +20,7 @@ import org.apache.commons.math.TestUtils;
import org.apache.commons.math.distribution.TDistribution; import org.apache.commons.math.distribution.TDistribution;
import org.apache.commons.math.distribution.TDistributionImpl; import org.apache.commons.math.distribution.TDistributionImpl;
import org.apache.commons.math.linear.RealMatrix; import org.apache.commons.math.linear.RealMatrix;
import org.apache.commons.math.linear.DenseRealMatrix; import org.apache.commons.math.linear.BlockRealMatrix;
import junit.framework.TestCase; import junit.framework.TestCase;
@ -184,7 +184,7 @@ public class PearsonsCorrelationTest extends TestCase {
} catch (IllegalArgumentException ex) { } catch (IllegalArgumentException ex) {
// Expected // Expected
} }
RealMatrix matrix = new DenseRealMatrix(new double[][] {{0},{1}}); RealMatrix matrix = new BlockRealMatrix(new double[][] {{0},{1}});
try { try {
new PearsonsCorrelation(matrix); new PearsonsCorrelation(matrix);
fail("Expecting IllegalArgumentException"); fail("Expecting IllegalArgumentException");
@ -259,12 +259,12 @@ public class PearsonsCorrelationTest extends TestCase {
System.arraycopy(data, ptr, matrixData[i], 0, nCols); System.arraycopy(data, ptr, matrixData[i], 0, nCols);
ptr += nCols; ptr += nCols;
} }
return new DenseRealMatrix(matrixData); return new BlockRealMatrix(matrixData);
} }
protected RealMatrix createLowerTriangularRealMatrix(double[] data, int dimension) { protected RealMatrix createLowerTriangularRealMatrix(double[] data, int dimension) {
int ptr = 0; int ptr = 0;
RealMatrix result = new DenseRealMatrix(dimension, dimension); RealMatrix result = new BlockRealMatrix(dimension, dimension);
for (int i = 1; i < dimension; i++) { for (int i = 1; i < dimension; i++) {
for (int j = 0; j < i; j++) { for (int j = 0; j < i; j++) {
result.setEntry(i, j, data[ptr]); result.setEntry(i, j, data[ptr]);

4
src/test/org/apache/commons/math/stat/correlation/SpearmansRankCorrelationTest.java
View File

@ -17,7 +17,7 @@
package org.apache.commons.math.stat.correlation; package org.apache.commons.math.stat.correlation;
import org.apache.commons.math.TestUtils; import org.apache.commons.math.TestUtils;
import org.apache.commons.math.linear.DenseRealMatrix; import org.apache.commons.math.linear.BlockRealMatrix;
import org.apache.commons.math.linear.RealMatrix; import org.apache.commons.math.linear.RealMatrix;
/** /**
@ -99,7 +99,7 @@ public class SpearmansRankCorrelationTest extends PearsonsCorrelationTest {
} catch (IllegalArgumentException ex) { } catch (IllegalArgumentException ex) {
// Expected // Expected
} }
RealMatrix matrix = new DenseRealMatrix(new double[][] {{0},{1}}); RealMatrix matrix = new BlockRealMatrix(new double[][] {{0},{1}});
try { try {
new SpearmansCorrelation(matrix); new SpearmansCorrelation(matrix);
fail("Expecting IllegalArgumentException"); fail("Expecting IllegalArgumentException");