commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From er...@apache.org
Subject svn commit: r1027952 [4/5] - in /commons/proper/math/trunk/src: main/java/org/apache/commons/math/exception/ main/java/org/apache/commons/math/exception/util/ main/java/org/apache/commons/math/linear/ main/resources/META-INF/localization/ test/java/org...
Date Wed, 27 Oct 2010 13:16:58 GMT
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/RealMatrix.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/RealMatrix.java?rev=1027952&r1=1027951&r2=1027952&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/RealMatrix.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/RealMatrix.java Wed Oct 27 13:16:57 2010
@@ -134,7 +134,8 @@ public interface RealMatrix extends AnyM
      * @param endColumn Final column index (inclusive)
      * @return The subMatrix containing the data of the
      *         specified rows and columns
-     * @exception MatrixIndexException  if the indices are not valid
+     * @throws org.apache.commons.math.exception.OutOfRangeException if
+     * the indices are not valid.
      */
     RealMatrix getSubMatrix(int startRow, int endRow, int startColumn, int endColumn);
 
@@ -146,7 +147,8 @@ public interface RealMatrix extends AnyM
     * @param selectedColumns Array of column indices.
     * @return The subMatrix containing the data in the
     *         specified rows and columns
-    * @exception MatrixIndexException if row or column selections are not valid
+    * @throws org.apache.commons.math.exception.OutOfRangeException if
+    * the indices are not valid.
     */
     RealMatrix getSubMatrix(int[] selectedRows, int[] selectedColumns);
 
@@ -160,22 +162,24 @@ public interface RealMatrix extends AnyM
     * @param endColumn Final column index (inclusive)
     * @param destination The arrays where the submatrix data should be copied
     * (if larger than rows/columns counts, only the upper-left part will be used)
-    * @exception MatrixIndexException if the indices are not valid
+    * @throws org.apache.commons.math.exception.OutOfRangeException if the
+    * indices are not valid.
     * @exception IllegalArgumentException if the destination array is too small
     */
-  void copySubMatrix(int startRow, int endRow, int startColumn, int endColumn,
-                     double[][] destination);
-  /**
-   * Copy a submatrix. Rows and columns are indicated
-   * counting from 0 to n-1.
-   *
-    * @param selectedRows Array of row indices.
-    * @param selectedColumns Array of column indices.
-   * @param destination The arrays where the submatrix data should be copied
-   * (if larger than rows/columns counts, only the upper-left part will be used)
-   * @exception MatrixIndexException if the indices are not valid
-   * @exception IllegalArgumentException if the destination array is too small
-   */
+    void copySubMatrix(int startRow, int endRow, int startColumn, int endColumn,
+                       double[][] destination);
+    /**
+     * Copy a submatrix. Rows and columns are indicated
+     * counting from 0 to n-1.
+     *
+     * @param selectedRows Array of row indices.
+     * @param selectedColumns Array of column indices.
+     * @param destination The arrays where the submatrix data should be copied
+     * (if larger than rows/columns counts, only the upper-left part will be used)
+     * @throws org.apache.commons.math.exception.OutOfRangeException if the
+     * indices are not valid.
+     * @exception IllegalArgumentException if the destination array is too small
+     */
     void copySubMatrix(int[] selectedRows, int[] selectedColumns, double[][] destination);
 
    /**
@@ -198,58 +202,67 @@ public interface RealMatrix extends AnyM
     * @param subMatrix  array containing the submatrix replacement data
     * @param row  row coordinate of the top, left element to be replaced
     * @param column  column coordinate of the top, left element to be replaced
-    * @throws MatrixIndexException  if subMatrix does not fit into this
-    *    matrix from element in (row, column)
-    * @throws IllegalArgumentException if <code>subMatrix</code> is not rectangular
-    *  (not all rows have the same length) or empty
-    * @throws NullPointerException if <code>subMatrix</code> is null
+    * @throws org.apache.commons.math.exception.ZeroException if
+    * {@code subMatrix} does not contain at least one column.
+    * @throws org.apache.commons.math.exception.OutOfRangeException if
+    * {@code subMatrix} does not fit into this matrix from element in
+    * {@code (row, column)}.
+    * @throws org.apache.commons.math.exception.DimensionMismatchException
+    * if {@code subMatrix} is not rectangular.
+    * (not all rows have the same length) or empty.
+    * @throws org.apache.commons.math.exception.NullArgumentException if
+    * {@code subMatrix} is {@code null}.
     * @since 2.0
     */
     void setSubMatrix(double[][] subMatrix, int row, int column);
 
    /**
-    * Returns the entries in row number <code>row</code>
+    * Geet the entries at the given row index
     * as a row matrix.  Row indices start at 0.
     *
-    * @param row the row to be fetched
-    * @return row matrix
-    * @throws MatrixIndexException if the specified row index is invalid
+    * @param row Row to be fetched.
+    * @return row Matrix.
+    * @throws org.apache.commons.math.exception.OutOfRangeException if
+    * the specified row index is invalid.
     */
    RealMatrix getRowMatrix(int row);
 
    /**
-    * Sets the entries in row number <code>row</code>
+    * Set the entries at the given row index
     * as a row matrix.  Row indices start at 0.
     *
-    * @param row the row to be set
-    * @param matrix row matrix (must have one row and the same number of columns
-    * as the instance)
-    * @throws MatrixIndexException if the specified row index is invalid
+    * @param row Row to be set.
+    * @param matrix Row matrix (must have one row and the same number of
+    * columns as the instance).
+    * @throws org.apache.commons.math.exception.OutOfRangeException if the
+    * specified row index is invalid.
     * @throws org.apache.commons.math.exception.MatrixDimensionMismatchException
     * if the matrix dimensions do not match one instance row.
     */
     void setRowMatrix(int row, RealMatrix matrix);
 
    /**
-    * Returns the entries in column number <code>column</code>
+    * Get the entries at the given column index
     * as a column matrix.  Column indices start at 0.
     *
-    * @param column the column to be fetched
-    * @return column matrix
-    * @throws MatrixIndexException if the specified column index is invalid
+    * @param column Column to be fetched.
+    * @return column Matrix.
+    * @throws org.apache.commons.math.exception.OutOfRangeException if
+    * the specified column index is invalid.
     */
    RealMatrix getColumnMatrix(int column);
 
    /**
-    * Sets the entries in column number <code>column</code>
+    * Set the entries at the given column index
     * as a column matrix.  Column indices start at 0.
     *
-    * @param column the column to be set
-    * @param matrix column matrix (must have one column and the same number of rows
-    * as the instance)
-    * @throws MatrixIndexException if the specified column index is invalid
+    * @param column Column to be set.
+    * @param matrix Column matrix (must have one column and the same number
+    * of rows as the instance).
+    * @throws org.apache.commons.math.exception.OutOfRangeException if
+    * the specified column index is invalid.
     * @throws org.apache.commons.math.exception.MatrixDimensionMismatchException
-    * if the matrix dimensions do not match one instance column.
+    * if the {@code matrix} dimensions do not match one instance column.
     */
     void setColumnMatrix(int column, RealMatrix matrix);
 
@@ -257,162 +270,149 @@ public interface RealMatrix extends AnyM
     * Returns the entries in row number <code>row</code>
     * as a vector.  Row indices start at 0.
     *
-    * @param row the row to be fetched
-    * @return row vector
-    * @throws MatrixIndexException if the specified row index is invalid
+    * @param row Row to be fetched.
+    * @return a row vector.
+    * @throws org.apache.commons.math.exception.OutOfRangeException if
+    * the specified row index is invalid.
     */
    RealVector getRowVector(int row);
 
    /**
-    * Sets the entries in row number <code>row</code>
+    * Set the entries at the given row index.
     * as a vector.  Row indices start at 0.
     *
-    * @param row the row to be set
+    * @param row Row to be set.
     * @param vector row vector (must have the same number of columns
-    * as the instance)
-    * @throws MatrixIndexException if the specified row index is invalid
+    * as the instance).
+    * @throws org.apache.commons.math.exception.OutOfRangeException if
+    * the specified row index is invalid.
     * @throws org.apache.commons.math.exception.MatrixDimensionMismatchException
     * if the vector dimension does not match one instance row.
     */
     void setRowVector(int row, RealVector vector);
 
    /**
-    * Returns the entries in column number <code>column</code>
+    * Get the entries at the given column index
     * as a vector.  Column indices start at 0.
     *
-    * @param column the column to be fetched
-    * @return column vector
-    * @throws MatrixIndexException if the specified column index is invalid
+    * @param column Column to be fetched.
+    * @return a column vector.
+    * @throws org.apache.commons.math.exception.OutOfRangeException if
+    * the specified column index is invalid
     */
    RealVector getColumnVector(int column);
 
    /**
-    * Sets the entries in column number <code>column</code>
+    * Set the entries at the given column index
     * as a vector.  Column indices start at 0.
     *
-    * @param column the column to be set
-    * @param vector column vector (must have the same number of rows as the instance)
-    * @throws MatrixIndexException if the specified column index is invalid
+    * @param column Column to be set.
+    * @param vector column vector (must have the same number of rows as
+    * the instance).
+    * @throws org.apache.commons.math.exception.OutOfRangeException if the
+    * specified column index is invalid.
     * @throws org.apache.commons.math.exception.MatrixDimensionMismatchException
     * if the vector dimension does not match one instance column.
     */
     void setColumnVector(int column, RealVector vector);
 
     /**
-     * Returns the entries in row number <code>row</code> as an array.
-     * <p>
-     * Row indices start at 0.  A <code>MatrixIndexException</code> is thrown
-     * unless {@code 0 <= row < rowDimension}.</p>
-     *
-     * @param row the row to be fetched
-     * @return array of entries in the row
-     * @throws MatrixIndexException if the specified row index is not valid
+     * Get the entries at the given row index.
+     * Row indices start at 0.
+     *
+     * @param row Row to be fetched.
+     * @return the array of entries in the row.
+     * @throws org.apache.commons.math.exception.OutOfRangeException if the
+     * specified row index is not valid.
      */
     double[] getRow(int row);
 
     /**
-     * Sets the entries in row number <code>row</code>
+     * Set the entries at the given row index
      * as a row matrix.  Row indices start at 0.
      *
-     * @param row the row to be set
-     * @param array row matrix (must have the same number of columns as the instance)
-     * @throws MatrixIndexException if the specified row index is invalid
+     * @param row Row to be set.
+     * @param array Row matrix (must have the same number of columns as
+     * the instance)
+     * @throws org.apache.commons.math.exception.OutOfRangeException if the
+     * specified row index is invalid.
      * @throws org.apache.commons.math.exception.MatrixDimensionMismatchException
      * if the array size does not match one instance row.
      */
     void setRow(int row, double[] array);
 
     /**
-     * Returns the entries in column number <code>col</code> as an array.
-     * <p>
-     * Column indices start at 0.  A <code>MatrixIndexException</code> is thrown
-     * unless {@code 0 <= column < columnDimension}.</p>
-     *
-     * @param column the column to be fetched
-     * @return array of entries in the column
-     * @throws MatrixIndexException if the specified column index is not valid
+     * Get the entries at the given column index as an array.
+     * Column indices start at 0.
+     *
+     * @param column Column to be fetched.
+     * @return the array of entries in the column.
+     * @throws org.apache.commons.math.exception.OutOfRangeException if the
+     * specified column index is not valid.
      */
     double[] getColumn(int column);
 
     /**
-     * Sets the entries in column number <code>column</code>
-     * as a column matrix.  Column indices start at 0.
+     * Set the entries at the given column index
+     * as a column matrix array.  Column indices start at 0.
      *
-     * @param column the column to be set
-     * @param array column array (must have the same number of rows as the instance)
-     * @throws MatrixIndexException if the specified column index is invalid
+     * @param column Column to be set.
+     * @param array Column array (must have the same number of rows as
+     * the instance).
+     * @throws org.apache.commons.math.exception.OutOfRangeException if the
+     * specified column index is invalid.
      * @throws org.apache.commons.math.exception.MatrixDimensionMismatchException
      * if the array size does not match one instance column.
      */
     void setColumn(int column, double[] array);
 
     /**
-     * Returns the entry in the specified row and column.
-     * <p>
-     * Row and column indices start at 0 and must satisfy
-     * <ul>
-     * <li>{@code 0 <= row < rowDimension}</li>
-     * <li>{@code 0 <= column < columnDimension}</li>
-     * </ul>
-     * otherwise a <code>MatrixIndexException</code> is thrown.</p>
-     *
-     * @param row  row location of entry to be fetched
-     * @param column  column location of entry to be fetched
-     * @return matrix entry in row,column
-     * @throws MatrixIndexException if the row or column index is not valid
+     * Get the entry in the specified row and column.
+     * Row and column indices start at 0.
+     *
+     * @param row Row location of entry to be fetched.
+     * @param column Column location of entry to be fetched.
+     * @return the matrix entry at {@code (row, column)}.
+     * @throws org.apache.commons.math.exception.OutOfRangeException if the
+     * row or column index is not valid.
      */
     double getEntry(int row, int column);
 
     /**
      * Set the entry in the specified row and column.
-     * <p>
-     * Row and column indices start at 0 and must satisfy
-     * <ul>
-     * <li>{@code 0 <= row < rowDimension}</li>
-     * <li>{@code 0 <= column < columnDimension}</li>
-     * </ul>
-     * otherwise a <code>MatrixIndexException</code> is thrown.</p>
-     *
-     * @param row  row location of entry to be set
-     * @param column  column location of entry to be set
-     * @param value matrix entry to be set in row,column
-     * @throws MatrixIndexException if the row or column index is not valid
+     * Row and column indices start at 0.
+     *
+     * @param row Row location of entry to be set.
+     * @param column Column location of entry to be set.
+     * @param value matrix entry to be set.
+     * @throws org.apache.commons.math.exception.OutOfRangeException if
+     * the row or column index is not valid
      * @since 2.0
      */
     void setEntry(int row, int column, double value);
 
     /**
      * Change an entry in the specified row and column.
-     * <p>
-     * Row and column indices start at 0 and must satisfy
-     * <ul>
-     * <li>{@code 0 <= row < rowDimension}</li>
-     * <li>{@code 0 <= column < columnDimension}</li>
-     * </ul>
-     * otherwise a <code>MatrixIndexException</code> is thrown.</p>
-     *
-     * @param row  row location of entry to be set
-     * @param column  column location of entry to be set
-     * @param increment value to add to the current matrix entry in row,column
-     * @throws MatrixIndexException if the row or column index is not valid
+     * Row and column indices start at 0.
+     *
+     * @param row Row location of entry to be set.
+     * @param column Column location of entry to be set.
+     * @param increment value to add to the matrix entry.
+     * @throws org.apache.commons.math.exception.OutOfRangeException if
+     * the row or column index is not valid.
      * @since 2.0
      */
     void addToEntry(int row, int column, double increment);
 
     /**
      * Change an entry in the specified row and column.
-     * <p>
-     * Row and column indices start at 0 and must satisfy
-     * <ul>
-     * <li>{@code 0 <= row < rowDimension}</li>
-     * <li>{@code 0 <= column < columnDimension}</li>
-     * </ul>
-     * otherwise a <code>MatrixIndexException</code> is thrown.</p>
-     *
-     * @param row  row location of entry to be set
-     * @param column  column location of entry to be set
-     * @param factor multiplication factor for the current matrix entry in row,column
-     * @throws MatrixIndexException if the row or column index is not valid
+     * Row and column indices start at 0.
+     *
+     * @param row Row location of entry to be set.
+     * @param column Column location of entry to be set.
+     * @param factor Multiplication factor for the matrix entry.
+     * @throws org.apache.commons.math.exception.OutOfRangeException if
+     * the row or column index is not valid.
      * @since 2.0
      */
     void multiplyEntry(int row, int column, double factor);
@@ -513,7 +513,7 @@ public interface RealMatrix extends AnyM
      * of a row from left to right before going to the leftmost element
      * of the next row.</p>
      * @param visitor visitor used to process all matrix entries
-     * @exception  MatrixVisitorException if the visitor cannot process an entry
+     * @throws MatrixVisitorException if the visitor cannot process an entry
      * @see #walkInRowOrder(RealMatrixPreservingVisitor)
      * @see #walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int)
      * @see #walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int)
@@ -536,7 +536,7 @@ public interface RealMatrix extends AnyM
      * of a row from left to right before going to the leftmost element
      * of the next row.</p>
      * @param visitor visitor used to process all matrix entries
-     * @exception  MatrixVisitorException if the visitor cannot process an entry
+     * @throws MatrixVisitorException if the visitor cannot process an entry
      * @see #walkInRowOrder(RealMatrixChangingVisitor)
      * @see #walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int)
      * @see #walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int)
@@ -563,8 +563,9 @@ public interface RealMatrix extends AnyM
      * @param endRow Final row index (inclusive)
      * @param startColumn Initial column index
      * @param endColumn Final column index
-     * @exception  MatrixVisitorException if the visitor cannot process an entry
-     * @exception MatrixIndexException  if the indices are not valid
+     * @throws MatrixVisitorException if the visitor cannot process an entry
+     * @throws org.apache.commons.math.exception.OutOfRangeException if
+     * the indices are not valid.
      * @see #walkInRowOrder(RealMatrixChangingVisitor)
      * @see #walkInRowOrder(RealMatrixPreservingVisitor)
      * @see #walkInRowOrder(RealMatrixPreservingVisitor, int, int, int, int)
@@ -592,8 +593,9 @@ public interface RealMatrix extends AnyM
      * @param endRow Final row index (inclusive)
      * @param startColumn Initial column index
      * @param endColumn Final column index
-     * @exception  MatrixVisitorException if the visitor cannot process an entry
-     * @exception MatrixIndexException  if the indices are not valid
+     * @throws MatrixVisitorException if the visitor cannot process an entry
+     * @throws org.apache.commons.math.exception.OutOfRangeException if
+     * the indices are not valid.
      * @see #walkInRowOrder(RealMatrixChangingVisitor)
      * @see #walkInRowOrder(RealMatrixPreservingVisitor)
      * @see #walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int)
@@ -617,7 +619,7 @@ public interface RealMatrix extends AnyM
      * of a column from top to bottom before going to the topmost element
      * of the next column.</p>
      * @param visitor visitor used to process all matrix entries
-     * @exception  MatrixVisitorException if the visitor cannot process an entry
+     * @throws MatrixVisitorException if the visitor cannot process an entry
      * @see #walkInRowOrder(RealMatrixChangingVisitor)
      * @see #walkInRowOrder(RealMatrixPreservingVisitor)
      * @see #walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int)
@@ -640,7 +642,7 @@ public interface RealMatrix extends AnyM
      * of a column from top to bottom before going to the topmost element
      * of the next column.</p>
      * @param visitor visitor used to process all matrix entries
-     * @exception  MatrixVisitorException if the visitor cannot process an entry
+     * @throws MatrixVisitorException if the visitor cannot process an entry
      * @see #walkInRowOrder(RealMatrixChangingVisitor)
      * @see #walkInRowOrder(RealMatrixPreservingVisitor)
      * @see #walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int)
@@ -667,8 +669,9 @@ public interface RealMatrix extends AnyM
      * @param endRow Final row index (inclusive)
      * @param startColumn Initial column index
      * @param endColumn Final column index
-     * @exception  MatrixVisitorException if the visitor cannot process an entry
-     * @exception MatrixIndexException  if the indices are not valid
+     * @throws MatrixVisitorException if the visitor cannot process an entry
+     * @throws org.apache.commons.math.exception.OutOfRangeException if
+     * the indices are not valid.
      * @see #walkInRowOrder(RealMatrixChangingVisitor)
      * @see #walkInRowOrder(RealMatrixPreservingVisitor)
      * @see #walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int)
@@ -696,8 +699,9 @@ public interface RealMatrix extends AnyM
      * @param endRow Final row index (inclusive)
      * @param startColumn Initial column index
      * @param endColumn Final column index
-     * @exception  MatrixVisitorException if the visitor cannot process an entry
-     * @exception MatrixIndexException  if the indices are not valid
+     * @throws MatrixVisitorException if the visitor cannot process an entry
+     * @throws org.apache.commons.math.exception.OutOfRangeException if
+     * the indices are not valid.
      * @see #walkInRowOrder(RealMatrixChangingVisitor)
      * @see #walkInRowOrder(RealMatrixPreservingVisitor)
      * @see #walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int)
@@ -720,7 +724,7 @@ public interface RealMatrix extends AnyM
      * <p>The fastest walking order depends on the exact matrix class. It may be
      * different from traditional row or column orders.</p>
      * @param visitor visitor used to process all matrix entries
-     * @exception  MatrixVisitorException if the visitor cannot process an entry
+     * @throws MatrixVisitorException if the visitor cannot process an entry
      * @see #walkInRowOrder(RealMatrixChangingVisitor)
      * @see #walkInRowOrder(RealMatrixPreservingVisitor)
      * @see #walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int)
@@ -742,7 +746,7 @@ public interface RealMatrix extends AnyM
      * <p>The fastest walking order depends on the exact matrix class. It may be
      * different from traditional row or column orders.</p>
      * @param visitor visitor used to process all matrix entries
-     * @exception  MatrixVisitorException if the visitor cannot process an entry
+     * @throws MatrixVisitorException if the visitor cannot process an entry
      * @see #walkInRowOrder(RealMatrixChangingVisitor)
      * @see #walkInRowOrder(RealMatrixPreservingVisitor)
      * @see #walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int)
@@ -768,8 +772,9 @@ public interface RealMatrix extends AnyM
      * @param endRow Final row index (inclusive)
      * @param startColumn Initial column index
      * @param endColumn Final column index (inclusive)
-     * @exception  MatrixVisitorException if the visitor cannot process an entry
-     * @exception MatrixIndexException  if the indices are not valid
+     * @throws MatrixVisitorException if the visitor cannot process an entry
+     * @throws org.apache.commons.math.exception.OutOfRangeException if
+     * the indices are not valid.
      * @see #walkInRowOrder(RealMatrixChangingVisitor)
      * @see #walkInRowOrder(RealMatrixPreservingVisitor)
      * @see #walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int)
@@ -796,8 +801,9 @@ public interface RealMatrix extends AnyM
      * @param endRow Final row index (inclusive)
      * @param startColumn Initial column index
      * @param endColumn Final column index (inclusive)
-     * @exception  MatrixVisitorException if the visitor cannot process an entry
-     * @exception MatrixIndexException  if the indices are not valid
+     * @throws MatrixVisitorException if the visitor cannot process an entry
+     * @throws org.apache.commons.math.exception.OutOfRangeException if the
+     * indices are not valid.
      * @see #walkInRowOrder(RealMatrixChangingVisitor)
      * @see #walkInRowOrder(RealMatrixPreservingVisitor)
      * @see #walkInRowOrder(RealMatrixChangingVisitor, int, int, int, int)

Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/RealVector.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/RealVector.java?rev=1027952&r1=1027951&r2=1027952&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/RealVector.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/RealVector.java Wed Oct 27 13:16:57 2010
@@ -46,202 +46,234 @@ import org.apache.commons.math.analysis.
  * @since 2.0
  */
 public interface RealVector {
-
     /**
      * Acts as if it is implemented as:
-     * Entry e = null;
-     * for(Iterator<Entry> it = iterator(); it.hasNext(); e = it.next()) {
-     *   e.setValue(function.value(e.getValue()));
-     * }
-     * @param function to apply to each successive entry
-     * @return this vector
-     * @throws FunctionEvaluationException if function throws it on application to any entry
+     * <pre>
+     *  Entry e = null;
+     *  for(Iterator<Entry> it = iterator(); it.hasNext(); e = it.next()) {
+     *      e.setValue(function.value(e.getValue()));
+     *  }
+     * </pre>
+     *
+     * @param function Function to apply to each entry.
+     * @return this vector.
+     * @throws FunctionEvaluationException if the function throws it.
      */
     RealVector mapToSelf(UnivariateRealFunction function) throws FunctionEvaluationException;
 
     /**
      * Acts as if implemented as:
-     * return copy().map(function);
-     * @param function to apply to each successive entry
-     * @return a new vector
-     * @throws FunctionEvaluationException if function throws it on application to any entry
+     * <pre>
+     *  return copy().map(function);
+     * </pre>
+     *
+     * @param function Functin to apply to each entry.
+     * @return a new vector.
+     * @throws FunctionEvaluationException if the function throws it.
      */
     RealVector map(UnivariateRealFunction function) throws FunctionEvaluationException;
 
     /** Class representing a modifiable entry in the vector. */
     public abstract class Entry {
-
         /** Index of the entry. */
         private int index;
 
-        /** Get the value of the entry.
-         * @return value of the entry
+        /**
+         * Get the value of the entry.
+         *
+         * @return the value of the entry.
          */
         public abstract double getValue();
-
-        /** Set the value of the entry.
-         * @param value new value for the entry
+        /**
+         * Set the value of the entry.
+         *
+         * @param value New value for the entry.
          */
         public abstract void setValue(double value);
-
-        /** Get the index of the entry.
-         * @return index of the entry
+        /**
+         * Get the index of the entry.
+         *
+         * @return the index of the entry.
          */
         public int getIndex() {
             return index;
         }
-
-        /** Set the index of the entry.
-         * @param index new index for the entry
+        /**
+         * Set the index of the entry.
+         *
+         * @param index New index for the entry.
          */
         public void setIndex(int index) {
             this.index = index;
         }
-
     }
 
     /**
-     * Generic dense iterator - starts with index == zero, and hasNext() == true until index == getDimension();
+     * Generic dense iterator.
+     * It iterates in increasing order of the vector index.
+     *
      * @return a dense iterator
      */
     Iterator<Entry> iterator();
 
     /**
-     * Specialized implementations may choose to not iterate over all dimensions, either because those values are
-     * unset, or are equal to defaultValue(), or are small enough to be ignored for the purposes of iteration.
+     * Specialized implementations may choose to not iterate over all
+     * dimensions, either because those values are unset, or are equal
+     * to defaultValue(), or are small enough to be ignored for the
+     * purposes of iteration.
      * No guarantees are made about order of iteration.
-     * In dense implementations, this method will often delegate to {@link #iterator()}
+     * In dense implementations, this method will often delegate to
+     * {@link #iterator()}.
+     *
      * @return a sparse iterator
      */
     Iterator<Entry> sparseIterator();
 
     /**
-     * Returns a (deep) copy of this.
-     * @return vector copy
+     * Returns a (deep) copy of this vector.
+     *
+     * @return a vector copy.
      */
     RealVector copy();
 
     /**
-     * Compute the sum of this and v.
-     * @param v vector to be added
-     * @return this + v
-     * @throws IllegalArgumentException if v is not the same size as this
+     * Compute the sum of this vector and {@code v}.
+     *
+     * @param v Vector to be added.
+     * @return {@code this} + {@code v}.
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      */
-    RealVector add(RealVector v)
-        throws IllegalArgumentException;
+    RealVector add(RealVector v);
 
     /**
-     * Compute the sum of this and v.
-     * @param v vector to be added
-     * @return this + v
-     * @throws IllegalArgumentException if v is not the same size as this
+     * Compute the sum of this vector and {@code v}.
+     *
+     * @param v Vector to be added.
+     * @return {@code this} + {@code v}.
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      */
-    RealVector add(double[] v)
-        throws IllegalArgumentException;
+    RealVector add(double[] v);
+
 
     /**
-     * Compute this minus v.
-     * @param v vector to be subtracted
-     * @return this + v
-     * @throws IllegalArgumentException if v is not the same size as this
+     * Subtract {@code v} from this vector.
+     *
+     * @param v Vector to be subtracted.
+     * @return {@code this} - {@code v}.
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      */
-    RealVector subtract(RealVector v)
-        throws IllegalArgumentException;
+    RealVector subtract(RealVector v);
 
     /**
-     * Compute this minus v.
-     * @param v vector to be subtracted
-     * @return this - v
-     * @throws IllegalArgumentException if v is not the same size as this
+     * Subtract {@code v} from this vector.
+     *
+     * @param v Vector to be subtracted.
+     * @return {@code this} - {@code v}.
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      */
-    RealVector subtract(double[] v)
-        throws IllegalArgumentException;
+    RealVector subtract(double[] v);
 
     /**
-     * Map an addition operation to each entry.
-     * @param d value to be added to each entry
-     * @return this + d
+     * Add a value to each entry.
+     *
+     * @param d Value to be added to each entry.
+     * @return {@code this} + {@code d}.
      */
     RealVector mapAdd(double d);
 
     /**
-     * Map an addition operation to each entry.
-     * <p>The instance <strong>is</strong> changed by this method.</p>
-     * @param d value to be added to each entry
-     * @return for convenience, return this
+     * Add a value to each entry.
+     * The instance is changed in-place.
+     *
+     * @param d Value to be added to each entry.
+     * @return {@code this}.
      */
     RealVector mapAddToSelf(double d);
 
     /**
-     * Map a subtraction operation to each entry.
-     * @param d value to be subtracted to each entry
-     * @return this - d
+     * Subtract a value from each entry.
+     *
+     * @param d Value to be subtracted.
+     * @return {@code this} - {@code d}.
      */
     RealVector mapSubtract(double d);
 
     /**
-     * Map a subtraction operation to each entry.
-     * <p>The instance <strong>is</strong> changed by this method.</p>
-     * @param d value to be subtracted to each entry
-     * @return for convenience, return this
+     * Subtract a value from each entry.
+     * The instance is changed in-place.
+     *
+     * @param d Value to be subtracted.
+     * @return {@code this}.
      */
     RealVector mapSubtractToSelf(double d);
 
     /**
-     * Map a multiplication operation to each entry.
-     * @param d value to multiply all entries by
-     * @return this * d
+     * Multiply each entry.
+     *
+     * @param d Multiplication factor.
+     * @return {@code this} * {@code d}.
      */
     RealVector mapMultiply(double d);
 
     /**
-     * Map a multiplication operation to each entry.
-     * <p>The instance <strong>is</strong> changed by this method.</p>
-     * @param d value to multiply all entries by
-     * @return for convenience, return this
+     * Multiply each entry.
+     * The instance is changed in-place.
+     *
+     * @param d Multiplication factor.
+     * @return {@code this}.
      */
     RealVector mapMultiplyToSelf(double d);
 
     /**
-     * Map a division operation to each entry.
-     * @param d value to divide all entries by
-     * @return this / d
+     * Divide each entry.
+     *
+     * @param d Value to divide by.
+     * @return {@code this} / {@code d}.
      */
     RealVector mapDivide(double d);
 
     /**
-     * Map a division operation to each entry.
-     * <p>The instance <strong>is</strong> changed by this method.</p>
-     * @param d value to divide all entries by
-     * @return for convenience, return this
+     * Divide each entry.
+     * The instance is changed in-place.
+     *
+     * @param d Value to divide by.
+     * @return {@code this}.
      */
     RealVector mapDivideToSelf(double d);
 
     /**
      * Map a power operation to each entry.
-     * @param d value to raise all entries to
-     * @return this ^ d
+     *
+     * @param d Operator value.
+     * @return a mapped copy of the vector.
      */
     RealVector mapPow(double d);
 
     /**
      * Map a power operation to each entry.
-     * <p>The instance <strong>is</strong> changed by this method.</p>
-     * @param d value to raise all entries to
-     * @return for convenience, return this
+     * The instance is changed in-place.
+     *
+     * @param d Operator value.
+     * @return the mapped vector.
      */
     RealVector mapPowToSelf(double d);
 
     /**
      * Map the {@link Math#exp(double)} function to each entry.
-     * @return a vector containing the result of applying the function to each entry
+     *
+     * @return a mapped copy of the vector.
      */
     RealVector mapExp();
 
     /**
-     * Map the {@link Math#exp(double)} function to each entry.
-     * <p>The instance <strong>is</strong> changed by this method.</p>
-     * @return for convenience, return this
+     * Map {@link Math#exp(double)} operation to each entry.
+     * The instance is changed in-place.
+     *
+     * @return the mapped vector.
      */
     RealVector mapExpToSelf();
 
@@ -535,33 +567,37 @@ public interface RealVector {
      * Element-by-element multiplication.
      * @param v vector by which instance elements must be multiplied
      * @return a vector containing this[i] * v[i] for all i
-     * @throws IllegalArgumentException if v is not the same size as this
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      */
-    RealVector ebeMultiply(RealVector v) throws IllegalArgumentException;
+    RealVector ebeMultiply(RealVector v);
 
     /**
      * Element-by-element multiplication.
      * @param v vector by which instance elements must be multiplied
      * @return a vector containing this[i] * v[i] for all i
-     * @throws IllegalArgumentException if v is not the same size as this
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      */
-    RealVector ebeMultiply(double[] v) throws IllegalArgumentException;
+    RealVector ebeMultiply(double[] v);
 
     /**
      * Element-by-element division.
      * @param v vector by which instance elements must be divided
      * @return a vector containing this[i] / v[i] for all i
-     * @throws IllegalArgumentException if v is not the same size as this
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      */
-    RealVector ebeDivide(RealVector v) throws IllegalArgumentException;
+    RealVector ebeDivide(RealVector v);
 
     /**
      * Element-by-element division.
      * @param v vector by which instance elements must be divided
      * @return a vector containing this[i] / v[i] for all i
-     * @throws IllegalArgumentException if v is not the same size as this
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      */
-    RealVector ebeDivide(double[] v) throws IllegalArgumentException;
+    RealVector ebeDivide(double[] v);
 
     /**
      * Returns vector entries as a double array.
@@ -573,19 +609,19 @@ public interface RealVector {
      * Compute the dot product.
      * @param v vector with which dot product should be computed
      * @return the scalar dot product between instance and v
-     * @exception IllegalArgumentException if v is not the same size as this
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      */
-    double dotProduct(RealVector v)
-        throws IllegalArgumentException;
+    double dotProduct(RealVector v);
 
     /**
      * Compute the dot product.
      * @param v vector with which dot product should be computed
      * @return the scalar dot product between instance and v
-     * @exception IllegalArgumentException if v is not the same size as this
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      */
-    double dotProduct(double[] v)
-        throws IllegalArgumentException;
+    double dotProduct(double[] v);
 
     /**
      * Returns the L<sub>2</sub> norm of the vector.
@@ -627,13 +663,13 @@ public interface RealVector {
      * elements differences, or euclidian distance.</p>
      * @param v vector to which distance is requested
      * @return distance between two vectors.
-     * @exception IllegalArgumentException if v is not the same size as this
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      * @see #getL1Distance(RealVector)
      * @see #getLInfDistance(RealVector)
      * @see #getNorm()
      */
-    double getDistance(RealVector v)
-        throws IllegalArgumentException;
+    double getDistance(RealVector v);
 
     /**
      * Distance between two vectors.
@@ -642,13 +678,13 @@ public interface RealVector {
      * elements differences, or euclidian distance.</p>
      * @param v vector to which distance is requested
      * @return distance between two vectors.
-     * @exception IllegalArgumentException if v is not the same size as this
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      * @see #getL1Distance(double[])
      * @see #getLInfDistance(double[])
      * @see #getNorm()
      */
-    double getDistance(double[] v)
-        throws IllegalArgumentException;
+    double getDistance(double[] v);
 
     /**
      * Distance between two vectors.
@@ -657,13 +693,13 @@ public interface RealVector {
      * elements differences.</p>
      * @param v vector to which distance is requested
      * @return distance between two vectors.
-     * @exception IllegalArgumentException if v is not the same size as this
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      * @see #getDistance(RealVector)
      * @see #getLInfDistance(RealVector)
      * @see #getL1Norm()
      */
-    double getL1Distance(RealVector v)
-        throws IllegalArgumentException;
+    double getL1Distance(RealVector v);
 
     /**
      * Distance between two vectors.
@@ -672,13 +708,13 @@ public interface RealVector {
      * elements differences.</p>
      * @param v vector to which distance is requested
      * @return distance between two vectors.
-     * @exception IllegalArgumentException if v is not the same size as this
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      * @see #getDistance(double[])
      * @see #getLInfDistance(double[])
      * @see #getL1Norm()
      */
-    double getL1Distance(double[] v)
-        throws IllegalArgumentException;
+    double getL1Distance(double[] v);
 
     /**
      * Distance between two vectors.
@@ -687,13 +723,13 @@ public interface RealVector {
      * elements differences.</p>
      * @param v vector to which distance is requested
      * @return distance between two vectors.
-     * @exception IllegalArgumentException if v is not the same size as this
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      * @see #getDistance(RealVector)
      * @see #getL1Distance(RealVector)
      * @see #getLInfNorm()
      */
-    double getLInfDistance(RealVector v)
-        throws IllegalArgumentException;
+    double getLInfDistance(RealVector v);
 
     /**
      * Distance between two vectors.
@@ -702,13 +738,13 @@ public interface RealVector {
      * elements differences.</p>
      * @param v vector to which distance is requested
      * @return distance between two vectors.
-     * @exception IllegalArgumentException if v is not the same size as this
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      * @see #getDistance(double[])
      * @see #getL1Distance(double[])
      * @see #getLInfNorm()
      */
-    double getLInfDistance(double[] v)
-        throws IllegalArgumentException;
+    double getLInfDistance(double[] v);
 
     /** Creates a unit vector pointing in the direction of this vector.
      * <p>The instance is not changed by this method.</p>
@@ -719,68 +755,65 @@ public interface RealVector {
 
     /** Converts this vector into a unit vector.
      * <p>The instance itself is changed by this method.</p>
-     * @exception ArithmeticException if the norm is null
+     * @throws  org.apache.commons.math.exception.MathArithmeticException
+     * if the norm is zero.
      */
     void unitize();
 
     /** Find the orthogonal projection of this vector onto another vector.
      * @param v vector onto which instance must be projected
      * @return projection of the instance onto v
-     * @throws IllegalArgumentException if v is not the same size as this
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      */
-    RealVector projection(RealVector v)
-        throws IllegalArgumentException;
+    RealVector projection(RealVector v);
 
     /** Find the orthogonal projection of this vector onto another vector.
      * @param v vector onto which instance must be projected
      * @return projection of the instance onto v
-     * @throws IllegalArgumentException if v is not the same size as this
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      */
-    RealVector projection(double[] v)
-        throws IllegalArgumentException;
+    RealVector projection(double[] v);
 
     /**
      * Compute the outer product.
      * @param v vector with which outer product should be computed
      * @return the square matrix outer product between instance and v
-     * @exception IllegalArgumentException if v is not the same size as this
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      */
-    RealMatrix outerProduct(RealVector v)
-        throws IllegalArgumentException;
+    RealMatrix outerProduct(RealVector v);
 
     /**
      * Compute the outer product.
      * @param v vector with which outer product should be computed
      * @return the square matrix outer product between instance and v
-     * @exception IllegalArgumentException if v is not the same size as this
+     * @throws org.apache.commons.math.exception.DimensionMismatchException
+     * if {@code v} is not the same size as this vector.
      */
-    RealMatrix outerProduct(double[] v)
-        throws IllegalArgumentException;
+    RealMatrix outerProduct(double[] v);
 
     /**
      * Returns the entry in the specified index.
-     * <p>
-     * The index start at 0 and must be lesser than the size,
-     * otherwise a {@link MatrixIndexException} is thrown.
-     * </p>
-     * @param index  index location of entry to be fetched
-     * @return vector entry at index
-     * @throws MatrixIndexException if the index is not valid
+     *
+     * @param index Index location of entry to be fetched.
+     * @return the vector entry at {@code index}.
+     * @throws org.apache.commons.math.exception.OutOfRangeException
+     * if the index is not valid.
      * @see #setEntry(int, double)
      */
-    double getEntry(int index)
-        throws MatrixIndexException;
+    double getEntry(int index);
 
     /**
      * Set a single element.
      * @param index element index.
      * @param value new value for the element.
-     * @exception MatrixIndexException if the index is
-     * inconsistent with vector size
+     * @throws org.apache.commons.math.exception.OutOfRangeException
+     * if the index is not valid.
      * @see #getEntry(int)
      */
-    void setEntry(int index, double value)
-        throws MatrixIndexException;
+    void setEntry(int index, double value);
 
     /**
      * Returns the size of the vector.
@@ -814,33 +847,30 @@ public interface RealVector {
      * @param index index of first element.
      * @param n number of elements to be retrieved.
      * @return a vector containing n elements.
-     * @exception MatrixIndexException if the index is
-     * inconsistent with vector size
+     * @throws org.apache.commons.math.exception.OutOfRangeException
+     * if the index is not valid.
      */
-    RealVector getSubVector(int index, int n)
-        throws MatrixIndexException;
+    RealVector getSubVector(int index, int n);
 
     /**
      * Set a set of consecutive elements.
      * @param index index of first element to be set.
      * @param v vector containing the values to set.
-     * @exception MatrixIndexException if the index is
-     * inconsistent with vector size
+     * @throws org.apache.commons.math.exception.OutOfRangeException
+     * if the index is not valid.
      * @see #setSubVector(int, double[])
      */
-    void setSubVector(int index, RealVector v)
-        throws MatrixIndexException;
+    void setSubVector(int index, RealVector v);
 
     /**
      * Set a set of consecutive elements.
      * @param index index of first element to be set.
      * @param v vector containing the values to set.
-     * @exception MatrixIndexException if the index is
-     * inconsistent with vector size
+     * @throws org.apache.commons.math.exception.OutOfRangeException
+     * if the index is not valid.
      * @see #setSubVector(int, RealVector)
      */
-    void setSubVector(int index, double[] v)
-        throws MatrixIndexException;
+    void setSubVector(int index, double[] v);
 
     /**
      * Set all elements to a single value.
@@ -857,17 +887,17 @@ public interface RealVector {
     double[] toArray();
 
     /**
-     * Returns true if any coordinate of this vector is NaN; false otherwise
-     * @return  true if any coordinate of this vector is NaN; false otherwise
+     * Check whether any coordinate of this vector is {@code NaN}.
+     * @return {@code true} if any coordinate of this vector is {@code NaN},
+     * {@code false} otherwise.
      */
     boolean isNaN();
 
     /**
-     * Returns true if any coordinate of this vector is infinite and none are NaN;
-     * false otherwise
-     * @return  true if any coordinate of this vector is infinite and none are NaN;
-     * false otherwise
+     * Check whether any coordinate of this vector is infinite and none are {@code NaN}.
+     *
+     * @return {@code true} if any coordinate of this vector is infinite and
+     * none are {@code NaN}, {@code false} otherwise.
      */
     boolean isInfinite();
-
 }

Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/SparseFieldMatrix.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/SparseFieldMatrix.java?rev=1027952&r1=1027951&r2=1027952&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/SparseFieldMatrix.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/SparseFieldMatrix.java Wed Oct 27 13:16:57 2010
@@ -28,25 +28,19 @@ import org.apache.commons.math.util.Open
  * @since 2.0
  */
 public class SparseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMatrix<T> {
-    /**
-     *  Serial id
-     */
+    /** Serialization identifier. */
     private static final long serialVersionUID = 9078068119297757342L;
     /** Storage for (sparse) matrix elements. */
     private final OpenIntToFieldHashMap<T> entries;
-    /**
-     * row dimension
-     */
+    /** Row dimension. */
     private final int rows;
-    /**
-     * column dimension
-     */
+    /** Column dimension. */
     private final int columns;
 
-
     /**
-     * Creates a matrix with no data.
-     * @param field field to which the elements belong
+     * Create a matrix with no data.
+     *
+     * @param field Field to which the elements belong.
      */
     public SparseFieldMatrix(final Field<T> field) {
         super(field);
@@ -56,16 +50,17 @@ public class SparseFieldMatrix<T extends
     }
 
     /**
-     * Create a new SparseFieldMatrix<T> with the supplied row and column dimensions.
+     * Create a new SparseFieldMatrix<T> with the supplied row and column
+     * dimensions.
      *
-     * @param field field to which the elements belong
-     * @param rowDimension  the number of rows in the new matrix
-     * @param columnDimension  the number of columns in the new matrix
-     * @throws IllegalArgumentException if row or column dimension is not positive
+     * @param field Field to which the elements belong.
+     * @param rowDimension Number of rows in the new matrix.
+     * @param columnDimension Number of columns in the new matrix.
+     * @throws org.apache.commons.math.exception.NotStrictlyPositiveException
+     * if row or column dimension is not positive.
      */
     public SparseFieldMatrix(final Field<T> field,
-                             final int rowDimension, final int columnDimension)
-        throws IllegalArgumentException {
+                             final int rowDimension, final int columnDimension) {
         super(field, rowDimension, columnDimension);
         this.rows = rowDimension;
         this.columns = columnDimension;
@@ -74,7 +69,8 @@ public class SparseFieldMatrix<T extends
 
     /**
      * Copy constructor.
-     * @param other The instance to copy
+     *
+     * @param other Instance to copy.
      */
     public SparseFieldMatrix(SparseFieldMatrix<T> other) {
         super(other.getField(), other.getRowDimension(), other.getColumnDimension());
@@ -85,7 +81,8 @@ public class SparseFieldMatrix<T extends
 
     /**
      * Generic copy constructor.
-     * @param other The instance to copy
+     *
+     * @param other Instance to copy.
      */
     public SparseFieldMatrix(FieldMatrix<T> other){
         super(other.getField(), other.getRowDimension(), other.getColumnDimension());
@@ -101,8 +98,7 @@ public class SparseFieldMatrix<T extends
 
     /** {@inheritDoc} */
     @Override
-    public void addToEntry(int row, int column, T increment)
-            throws MatrixIndexException {
+    public void addToEntry(int row, int column, T increment) {
         checkRowIndex(row);
         checkColumnIndex(column);
         final int key = computeKey(row, column);
@@ -112,7 +108,6 @@ public class SparseFieldMatrix<T extends
         } else {
             entries.put(key, value);
         }
-
     }
 
     /** {@inheritDoc} */
@@ -123,8 +118,7 @@ public class SparseFieldMatrix<T extends
 
     /** {@inheritDoc} */
     @Override
-    public FieldMatrix<T> createMatrix(int rowDimension, int columnDimension)
-            throws IllegalArgumentException {
+    public FieldMatrix<T> createMatrix(int rowDimension, int columnDimension) {
         return new SparseFieldMatrix<T>(getField(), rowDimension, columnDimension);
     }
 
@@ -136,7 +130,7 @@ public class SparseFieldMatrix<T extends
 
     /** {@inheritDoc} */
     @Override
-    public T getEntry(int row, int column) throws MatrixIndexException {
+    public T getEntry(int row, int column) {
         checkRowIndex(row);
         checkColumnIndex(column);
         return entries.get(computeKey(row, column));
@@ -150,8 +144,7 @@ public class SparseFieldMatrix<T extends
 
     /** {@inheritDoc} */
     @Override
-    public void multiplyEntry(int row, int column, T factor)
-            throws MatrixIndexException {
+    public void multiplyEntry(int row, int column, T factor) {
         checkRowIndex(row);
         checkColumnIndex(column);
         final int key = computeKey(row, column);
@@ -166,8 +159,7 @@ public class SparseFieldMatrix<T extends
 
     /** {@inheritDoc} */
     @Override
-    public void setEntry(int row, int column, T value)
-            throws MatrixIndexException {
+    public void setEntry(int row, int column, T value) {
         checkRowIndex(row);
         checkColumnIndex(column);
         if (getField().getZero().equals(value)) {
@@ -175,16 +167,16 @@ public class SparseFieldMatrix<T extends
         } else {
             entries.put(computeKey(row, column), value);
         }
-
     }
+
     /**
-     * Compute the key to access a matrix element
-     * @param row row index of the matrix element
-     * @param column column index of the matrix element
-     * @return key within the map to access the matrix element
+     * Compute the key to access a matrix element.
+     *
+     * @param row Row index of the matrix element.
+     * @param column Column index of the matrix element.
+     * @return the key within the map to access the matrix element.
      */
     private int computeKey(int row, int column) {
         return row * columns + column;
     }
-
 }

Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/SparseFieldVector.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/SparseFieldVector.java?rev=1027952&r1=1027951&r2=1027952&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/SparseFieldVector.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/SparseFieldVector.java Wed Oct 27 13:16:57 2010
@@ -21,8 +21,8 @@ import java.lang.reflect.Array;
 
 import org.apache.commons.math.Field;
 import org.apache.commons.math.FieldElement;
-import org.apache.commons.math.MathRuntimeException;
-import org.apache.commons.math.exception.util.LocalizedFormats;
+import org.apache.commons.math.exception.OutOfRangeException;
+import org.apache.commons.math.exception.DimensionMismatchException;
 import org.apache.commons.math.util.OpenIntToFieldHashMap;
 
 /**
@@ -32,10 +32,7 @@ import org.apache.commons.math.util.Open
  * @since 2.0
  */
 public class SparseFieldVector<T extends FieldElement<T>> implements FieldVector<T>, Serializable {
-
-    /**
-     *  Serial version id
-     */
+    /**  Serialization identifier. */
     private static final long serialVersionUID = 7841233292190413362L;
     /** Field to which the elements belong. */
     private final Field<T> field;
@@ -46,13 +43,14 @@ public class SparseFieldVector<T extends
 
     /**
      * Build a 0-length vector.
-     * <p>Zero-length vectors may be used to initialize construction of vectors
+     * Zero-length vectors may be used to initialize construction of vectors
      * by data gathering. We start with zero-length and use either the {@link
      * #SparseFieldVector(SparseFieldVector, int)} constructor
-     * or one of the <code>append</code> method ({@link #append(FieldElement)},
+     * or one of the {@code append} method ({@link #append(FieldElement)},
      * {@link #append(FieldElement[])}, {@link #append(FieldVector)},
-     * {@link #append(SparseFieldVector)}) to gather data into this vector.</p>
-     * @param field field to which the elements belong
+     * {@link #append(SparseFieldVector)}) to gather data into this vector.
+     *
+     * @param field Field to which the elements belong.
      */
     public SparseFieldVector(Field<T> field) {
         this(field, 0);
@@ -60,9 +58,10 @@ public class SparseFieldVector<T extends
 
 
     /**
-     * Construct a (dimension)-length vector of zeros.
-     * @param field field to which the elements belong
-     * @param dimension Size of the vector
+     * Construct a vector of zeroes.
+     *
+     * @param field Field to which the elements belong.
+     * @param dimension Size of the vector.
      */
     public SparseFieldVector(Field<T> field, int dimension) {
         this.field = field;
@@ -72,8 +71,9 @@ public class SparseFieldVector<T extends
 
     /**
      * Build a resized vector, for use with append.
-     * @param v The original vector
-     * @param resize The amount to resize it
+     *
+     * @param v Original vector
+     * @param resize Amount to add.
      */
     protected SparseFieldVector(SparseFieldVector<T> v, int resize) {
         field = v.field;
@@ -84,9 +84,10 @@ public class SparseFieldVector<T extends
 
     /**
      * Build a vector with known the sparseness (for advanced use only).
-     * @param field field to which the elements belong
-     * @param dimension The size of the vector
-     * @param expectedSize The expected number of non-zero entries
+     *
+     * @param field Field to which the elements belong.
+     * @param dimension Size of the vector.
+     * @param expectedSize Expected number of non-zero entries.
      */
     public SparseFieldVector(Field<T> field, int dimension, int expectedSize) {
         this.field = field;
@@ -96,9 +97,10 @@ public class SparseFieldVector<T extends
 
     /**
      * Create from a Field array.
-     * Only non-zero entries will be stored
-     * @param field field to which the elements belong
-     * @param values The set of values to create from
+     * Only non-zero entries will be stored.
+     *
+     * @param field Field to which the elements belong.
+     * @param values Set of values to create from.
      */
     public SparseFieldVector(Field<T> field, T[] values) {
         this.field = field;
@@ -110,11 +112,10 @@ public class SparseFieldVector<T extends
         }
     }
 
-
-
     /**
      * Copy constructor.
-     * @param v The instance to copy from
+     *
+     * @param v Instance to copy.
      */
     public SparseFieldVector(SparseFieldVector<T> v) {
         field = v.field;
@@ -124,7 +125,8 @@ public class SparseFieldVector<T extends
 
     /**
      * Get the entries of this instance.
-     * @return entries of this instance
+     *
+     * @return the entries of this instance
      */
     private OpenIntToFieldHashMap<T> getEntries() {
         return entries;
@@ -132,11 +134,13 @@ public class SparseFieldVector<T extends
 
     /**
      * Optimized method to add sparse vectors.
-     * @param v vector to add
-     * @return The sum of <code>this</code> and <code>v</code>
-     * @throws IllegalArgumentException If the dimensions don't match
+     *
+     * @param v Vector to add.
+     * @return the sum of {@code this} and {@code v}.
+     * @throws DimensionMismatchException
+     * if the dimensions do not match.
      */
-    public FieldVector<T> add(SparseFieldVector<T> v) throws IllegalArgumentException {
+    public FieldVector<T> add(SparseFieldVector<T> v) {
         checkVectorDimensions(v.getDimension());
         SparseFieldVector<T> res = (SparseFieldVector<T>)copy();
         OpenIntToFieldHashMap<T>.Iterator iter = v.getEntries().iterator();
@@ -156,7 +160,7 @@ public class SparseFieldVector<T extends
 
 
     /** {@inheritDoc} */
-    public FieldVector<T> add(T[] v) throws IllegalArgumentException {
+    public FieldVector<T> add(T[] v) {
         checkVectorDimensions(v.length);
         SparseFieldVector<T> res = new SparseFieldVector<T>(field,getDimension());
         for (int i = 0; i < v.length; i++) {
@@ -167,8 +171,9 @@ public class SparseFieldVector<T extends
 
     /**
      * Construct a vector by appending a vector to this vector.
-     * @param v vector to append to this one.
-     * @return a new vector
+     *
+     * @param v Vector to append to this one.
+     * @return a new vector.
      */
     public FieldVector<T> append(SparseFieldVector<T> v) {
         SparseFieldVector<T> res = new SparseFieldVector<T>(this, v.getDimension());
@@ -211,7 +216,7 @@ public class SparseFieldVector<T extends
    }
 
     /** {@inheritDoc} */
-    public T dotProduct(FieldVector<T> v) throws IllegalArgumentException {
+    public T dotProduct(FieldVector<T> v) {
         checkVectorDimensions(v.getDimension());
         T res = field.getZero();
         OpenIntToFieldHashMap<T>.Iterator iter = entries.iterator();
@@ -223,7 +228,7 @@ public class SparseFieldVector<T extends
     }
 
     /** {@inheritDoc} */
-    public T dotProduct(T[] v) throws IllegalArgumentException {
+    public T dotProduct(T[] v) {
         checkVectorDimensions(v.length);
         T res = field.getZero();
         OpenIntToFieldHashMap<T>.Iterator iter = entries.iterator();
@@ -239,8 +244,7 @@ public class SparseFieldVector<T extends
      }
 
     /** {@inheritDoc} */
-    public FieldVector<T> ebeDivide(FieldVector<T> v)
-        throws IllegalArgumentException {
+    public FieldVector<T> ebeDivide(FieldVector<T> v) {
         checkVectorDimensions(v.getDimension());
         SparseFieldVector<T> res = new SparseFieldVector<T>(this);
         OpenIntToFieldHashMap<T>.Iterator iter = res.entries.iterator();
@@ -252,7 +256,7 @@ public class SparseFieldVector<T extends
     }
 
     /** {@inheritDoc} */
-    public FieldVector<T> ebeDivide(T[] v) throws IllegalArgumentException {
+    public FieldVector<T> ebeDivide(T[] v) {
         checkVectorDimensions(v.length);
         SparseFieldVector<T> res = new SparseFieldVector<T>(this);
         OpenIntToFieldHashMap<T>.Iterator iter = res.entries.iterator();
@@ -264,7 +268,7 @@ public class SparseFieldVector<T extends
     }
 
     /** {@inheritDoc} */
-    public FieldVector<T> ebeMultiply(FieldVector<T> v)throws IllegalArgumentException {
+    public FieldVector<T> ebeMultiply(FieldVector<T> v) {
         checkVectorDimensions(v.getDimension());
         SparseFieldVector<T> res = new SparseFieldVector<T>(this);
         OpenIntToFieldHashMap<T>.Iterator iter = res.entries.iterator();
@@ -276,7 +280,7 @@ public class SparseFieldVector<T extends
     }
 
     /** {@inheritDoc} */
-     public FieldVector<T> ebeMultiply(T[] v) throws IllegalArgumentException {
+     public FieldVector<T> ebeMultiply(T[] v) {
         checkVectorDimensions(v.length);
         SparseFieldVector<T> res = new SparseFieldVector<T>(this);
         OpenIntToFieldHashMap<T>.Iterator iter = res.entries.iterator();
@@ -304,7 +308,7 @@ public class SparseFieldVector<T extends
     }
 
      /** {@inheritDoc} */
-     public T getEntry(int index) throws MatrixIndexException {
+     public T getEntry(int index) {
         checkIndex(index);
         return entries.get(index);
    }
@@ -315,8 +319,7 @@ public class SparseFieldVector<T extends
     }
 
      /** {@inheritDoc} */
-     public FieldVector<T> getSubVector(int index, int n)
-            throws MatrixIndexException {
+     public FieldVector<T> getSubVector(int index, int n) {
         checkIndex(index);
         checkIndex(index + n - 1);
         SparseFieldVector<T> res = new SparseFieldVector<T>(field,n);
@@ -398,14 +401,14 @@ public class SparseFieldVector<T extends
         return mapAddToSelf(field.getZero().subtract(d));
     }
 
-     /**
-      * Optimized method to compute outer product when both vectors are sparse.
-      * @param v vector with which outer product should be computed
-      * @return the square matrix outer product between instance and v
-      * @throws IllegalArgumentException if v is not the same size as {@code this}
-      */
-    public FieldMatrix<T> outerProduct(SparseFieldVector<T> v)
-            throws IllegalArgumentException {
+    /**
+     * Optimized method to compute outer product when both vectors are sparse.
+     * @param v vector with which outer product should be computed
+     * @return the square matrix outer product between instance and v
+     * @throws DimensionMismatchException
+     * if the dimensions do not match.
+     */
+    public FieldMatrix<T> outerProduct(SparseFieldVector<T> v) {
         checkVectorDimensions(v.getDimension());
         SparseFieldMatrix<T> res = new SparseFieldMatrix<T>(field, virtualSize, virtualSize);
         OpenIntToFieldHashMap<T>.Iterator iter = entries.iterator();
@@ -421,7 +424,7 @@ public class SparseFieldVector<T extends
     }
 
     /** {@inheritDoc} */
-    public FieldMatrix<T> outerProduct(T[] v) throws IllegalArgumentException {
+    public FieldMatrix<T> outerProduct(T[] v) {
         checkVectorDimensions(v.length);
         FieldMatrix<T> res = new SparseFieldMatrix<T>(field, virtualSize, virtualSize);
         OpenIntToFieldHashMap<T>.Iterator iter = entries.iterator();
@@ -437,8 +440,7 @@ public class SparseFieldVector<T extends
      }
 
     /** {@inheritDoc} */
-    public FieldMatrix<T> outerProduct(FieldVector<T> v)
-    throws IllegalArgumentException {
+    public FieldMatrix<T> outerProduct(FieldVector<T> v) {
         if(v instanceof SparseFieldVector<?>)
             return outerProduct((SparseFieldVector<T>)v);
         else
@@ -446,14 +448,13 @@ public class SparseFieldVector<T extends
     }
 
     /** {@inheritDoc} */
-    public FieldVector<T> projection(FieldVector<T> v)
-    throws IllegalArgumentException {
+    public FieldVector<T> projection(FieldVector<T> v) {
         checkVectorDimensions(v.getDimension());
         return v.mapMultiply(dotProduct(v).divide(v.dotProduct(v)));
     }
 
     /** {@inheritDoc} */
-    public FieldVector<T> projection(T[] v) throws IllegalArgumentException {
+    public FieldVector<T> projection(T[] v) {
         checkVectorDimensions(v.length);
         return projection(new SparseFieldVector<T>(field,v));
     }
@@ -466,21 +467,20 @@ public class SparseFieldVector<T extends
     }
 
     /** {@inheritDoc} */
-    public void setEntry(int index, T value) throws MatrixIndexException {
+    public void setEntry(int index, T value) {
         checkIndex(index);
         entries.put(index, value);
    }
 
     /** {@inheritDoc} */
-    public void setSubVector(int index, FieldVector<T> v)
-            throws MatrixIndexException {
+    public void setSubVector(int index, FieldVector<T> v) {
         checkIndex(index);
         checkIndex(index + v.getDimension() - 1);
         setSubVector(index, v.getData());
     }
 
     /** {@inheritDoc} */
-    public void setSubVector(int index, T[] v) throws MatrixIndexException {
+    public void setSubVector(int index, T[] v) {
         checkIndex(index);
         checkIndex(index + v.length - 1);
         for (int i = 0; i < v.length; i++) {
@@ -491,11 +491,13 @@ public class SparseFieldVector<T extends
 
     /**
      * Optimized method to subtract SparseRealVectors.
-     * @param v The vector to subtract from <code>this</code>
-     * @return The difference of <code>this</code> and <code>v</code>
-     * @throws IllegalArgumentException If the dimensions don't match
+     *
+     * @param v Vector to subtract.
+     * @return the difference between {@code this} and {@code v}.
+     * @throws DimensionMismatchException
+     * if the dimensions do not match.
      */
-    public SparseFieldVector<T> subtract(SparseFieldVector<T> v) throws IllegalArgumentException{
+    public SparseFieldVector<T> subtract(SparseFieldVector<T> v){
         checkVectorDimensions(v.getDimension());
         SparseFieldVector<T> res = (SparseFieldVector<T>)copy();
         OpenIntToFieldHashMap<T>.Iterator iter = v.getEntries().iterator();
@@ -512,8 +514,7 @@ public class SparseFieldVector<T extends
     }
 
     /** {@inheritDoc} */
-    public FieldVector<T> subtract(FieldVector<T> v)
-           throws IllegalArgumentException {
+    public FieldVector<T> subtract(FieldVector<T> v) {
         if(v instanceof SparseFieldVector<?>)
             return subtract((SparseFieldVector<T>)v);
         else
@@ -521,7 +522,7 @@ public class SparseFieldVector<T extends
     }
 
     /** {@inheritDoc} */
-    public FieldVector<T> subtract(T[] v) throws IllegalArgumentException {
+    public FieldVector<T> subtract(T[] v) {
         checkVectorDimensions(v.length);
         SparseFieldVector<T> res = new SparseFieldVector<T>(this);
         for (int i = 0; i < v.length; i++) {
@@ -540,39 +541,31 @@ public class SparseFieldVector<T extends
     }
 
     /**
-     * Check if an index is valid.
+     * Check whether an index is valid.
      *
-     * @param index
-     *            index to check
-     * @exception MatrixIndexException
-     *                if index is not valid
+     * @param index Index to check.
+     * @throws OutOfRangeException if the dimensions do not match.
      */
-    private void checkIndex(final int index) throws MatrixIndexException {
+    private void checkIndex(final int index) {
         if (index < 0 || index >= getDimension()) {
-            throw new MatrixIndexException(LocalizedFormats.INDEX_OUT_OF_RANGE,
-                                           index, 0, getDimension() - 1);
+            throw new OutOfRangeException(index, 0, getDimension() - 1);
         }
     }
 
     /**
      * Check if instance dimension is equal to some expected value.
      *
-     * @param n
-     *            expected dimension.
-     * @exception IllegalArgumentException
-     *                if the dimension is inconsistent with vector size
+     * @param n Expected dimension.
+     * @throws DimensionMismatchException if the dimensions do not match.
      */
-    protected void checkVectorDimensions(int n) throws IllegalArgumentException {
+    protected void checkVectorDimensions(int n) {
         if (getDimension() != n) {
-            throw MathRuntimeException.createIllegalArgumentException(
-                    LocalizedFormats.VECTOR_LENGTH_MISMATCH,
-                    getDimension(), n);
+            throw new DimensionMismatchException(getDimension(), n);
         }
     }
 
-
     /** {@inheritDoc} */
-    public FieldVector<T> add(FieldVector<T> v) throws IllegalArgumentException {
+    public FieldVector<T> add(FieldVector<T> v) {
         if (v instanceof SparseFieldVector<?>) {
             return add((SparseFieldVector<T>)v);
         } else {
@@ -580,9 +573,11 @@ public class SparseFieldVector<T extends
         }
     }
 
-    /** Build an array of elements.
-     * @param length size of the array to build
-     * @return a new array
+    /**
+     * Build an array of elements.
+     *
+     * @param length Size of the array to build.
+     * @return a new array.
      */
     @SuppressWarnings("unchecked") // field is type T
     private T[] buildArray(final int length) {
@@ -651,7 +646,4 @@ public class SparseFieldVector<T extends
         }
         return true;
     }
-
-
-
 }

Modified: commons/proper/math/trunk/src/main/resources/META-INF/localization/LocalizedFormats_fr.properties
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/resources/META-INF/localization/LocalizedFormats_fr.properties?rev=1027952&r1=1027951&r2=1027952&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/resources/META-INF/localization/LocalizedFormats_fr.properties (original)
+++ commons/proper/math/trunk/src/main/resources/META-INF/localization/LocalizedFormats_fr.properties Wed Oct 27 13:16:57 2010
@@ -84,11 +84,12 @@ IDENTICAL_ABSCISSAS_DIVISION_BY_ZERO = l
 INDEX_LARGER_THAN_MAX = l''index sp\u00e9cifi\u00e9 ({0}) d\u00e9passe l''index maximal courant ({1})
 INDEX_NOT_POSITIVE = l''indice ({0}) n''est pas positif
 INDEX_OUT_OF_RANGE = l''indice ({0}) est hors du domaine autoris\u00e9 [{1}, {2}]
+INDEX = indice ({0})
 INFINITE_ARRAY_ELEMENT = le tableau contient l''\u00e9l\u00e9ment infini {0} \u00e0 l''index {1}
 INFINITE_VALUE_CONVERSION = les valeurs infinies ne peuvent \u00eatre converties
 INITIAL_CAPACITY_NOT_POSITIVE = la capacit\u00e9 initiale ({0}) n''est pas positive
-INITIAL_COLUMN_AFTER_FINAL_COLUMN = colonne initiale {0} apr\u00e8s la colonne finale {1}
-INITIAL_ROW_AFTER_FINAL_ROW = ligne initiale {0} apr\u00e8s la ligne finale {1}
+INITIAL_COLUMN_AFTER_FINAL_COLUMN = colonne initiale {1} apr\u00e8s la colonne finale {0}
+INITIAL_ROW_AFTER_FINAL_ROW = ligne initiale {1} apr\u00e8s la ligne finale {0}
 INPUT_DATA_FROM_UNSUPPORTED_DATASOURCE = les donn\u00e9es d''entr\u00e9e proviennent 
 INSTANCES_NOT_COMPARABLE_TO_EXISTING_VALUES = l''instance de la classe {0} n''est pas comparable aux valeurs existantes
 INSUFFICIENT_DATA_FOR_T_STATISTIC = deux valeurs ou plus sont n\u00e9cessaires pour la statistique t, il y en a {0}

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/Array2DRowRealMatrixTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/Array2DRowRealMatrixTest.java?rev=1027952&r1=1027951&r2=1027952&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/Array2DRowRealMatrixTest.java (original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/Array2DRowRealMatrixTest.java Wed Oct 27 13:16:57 2010
@@ -21,6 +21,9 @@ import junit.framework.TestCase;
 import org.apache.commons.math.TestUtils;
 import org.apache.commons.math.util.FastMath;
 import org.apache.commons.math.exception.MatrixDimensionMismatchException;
+import org.apache.commons.math.exception.OutOfRangeException;
+import org.apache.commons.math.exception.ZeroException;
+import org.apache.commons.math.exception.NumberIsTooSmallException;
 
 /**
  * Test cases for the {@link Array2DRowRealMatrix} class.
@@ -316,14 +319,14 @@ public final class Array2DRowRealMatrixT
         TestUtils.assertEquals("get col",m.getColumn(2),testDataCol3,entryTolerance);
         try {
             m.getRow(10);
-            fail("expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // ignored
         }
         try {
             m.getColumn(-1);
-            fail("expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // ignored
         }
     }
@@ -333,8 +336,8 @@ public final class Array2DRowRealMatrixT
         assertEquals("get entry",m.getEntry(0,1),2d,entryTolerance);
         try {
             m.getEntry(10, 4);
-            fail ("Expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail ("Expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // expected
         }
     }
@@ -394,9 +397,17 @@ public final class Array2DRowRealMatrixT
             RealMatrix sub = m.getSubMatrix(startRow, endRow, startColumn, endColumn);
             assertEquals(new Array2DRowRealMatrix(reference), sub);
             if (mustFail) {
-                fail("Expecting MatrixIndexException");
+                fail("Expecting OutOfRangeException or NumberIsTooSmallException or ZeroException");
             }
-        } catch (MatrixIndexException e) {
+        } catch (OutOfRangeException e) {
+            if (!mustFail) {
+                throw e;
+            }
+        } catch (NumberIsTooSmallException e) {
+            if (!mustFail) {
+                throw e;
+            }
+        } catch (ZeroException e) {
             if (!mustFail) {
                 throw e;
             }
@@ -410,9 +421,17 @@ public final class Array2DRowRealMatrixT
             RealMatrix sub = m.getSubMatrix(selectedRows, selectedColumns);
             assertEquals(new Array2DRowRealMatrix(reference), sub);
             if (mustFail) {
-                fail("Expecting MatrixIndexException");
+                fail("Expecting OutOfRangeException or NumberIsTooSmallException or ZeroException");
+            }
+        } catch (OutOfRangeException e) {
+            if (!mustFail) {
+                throw e;
+            }
+        } catch (NumberIsTooSmallException e) {
+            if (!mustFail) {
+                throw e;
             }
-        } catch (MatrixIndexException e) {
+        } catch (ZeroException e) {
             if (!mustFail) {
                 throw e;
             }
@@ -449,9 +468,17 @@ public final class Array2DRowRealMatrixT
             m.copySubMatrix(startRow, endRow, startColumn, endColumn, sub);
             assertEquals(new Array2DRowRealMatrix(reference), new Array2DRowRealMatrix(sub));
             if (mustFail) {
-                fail("Expecting MatrixIndexException");
+                fail("Expecting OutOfRangeException or NumberIsTooSmallException or ZeroException");
             }
-        } catch (MatrixIndexException e) {
+        } catch (OutOfRangeException e) {
+            if (!mustFail) {
+                throw e;
+            }
+        } catch (NumberIsTooSmallException e) {
+            if (!mustFail) {
+                throw e;
+            }
+        } catch (ZeroException e) {
             if (!mustFail) {
                 throw e;
             }
@@ -468,9 +495,17 @@ public final class Array2DRowRealMatrixT
             m.copySubMatrix(selectedRows, selectedColumns, sub);
             assertEquals(new Array2DRowRealMatrix(reference), new Array2DRowRealMatrix(sub));
             if (mustFail) {
-                fail("Expecting MatrixIndexException");
+                fail("Expecting OutOfRangeException or NumberIsTooSmallException or ZeroException");
+            }
+        } catch (OutOfRangeException e) {
+            if (!mustFail) {
+                throw e;
+            }
+        } catch (NumberIsTooSmallException e) {
+            if (!mustFail) {
+                throw e;
             }
-        } catch (MatrixIndexException e) {
+        } catch (ZeroException e) {
             if (!mustFail) {
                 throw e;
             }
@@ -487,14 +522,14 @@ public final class Array2DRowRealMatrixT
                 m.getRowMatrix(3));
         try {
             m.getRowMatrix(-1);
-            fail("Expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("Expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // expected
         }
         try {
             m.getRowMatrix(4);
-            fail("Expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("Expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // expected
         }
     }
@@ -507,8 +542,8 @@ public final class Array2DRowRealMatrixT
         assertEquals(mRow3, m.getRowMatrix(0));
         try {
             m.setRowMatrix(-1, mRow3);
-            fail("Expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("Expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // expected
         }
         try {
@@ -529,14 +564,14 @@ public final class Array2DRowRealMatrixT
                 m.getColumnMatrix(3));
         try {
             m.getColumnMatrix(-1);
-            fail("Expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("Expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // expected
         }
         try {
             m.getColumnMatrix(4);
-            fail("Expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("Expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // expected
         }
     }
@@ -549,8 +584,8 @@ public final class Array2DRowRealMatrixT
         assertEquals(mColumn3, m.getColumnMatrix(1));
         try {
             m.setColumnMatrix(-1, mColumn3);
-            fail("Expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("Expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // expected
         }
         try {
@@ -569,14 +604,14 @@ public final class Array2DRowRealMatrixT
         assertEquals("Row3", mRow3, m.getRowVector(3));
         try {
             m.getRowVector(-1);
-            fail("Expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("Expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // expected
         }
         try {
             m.getRowVector(4);
-            fail("Expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("Expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // expected
         }
     }
@@ -589,8 +624,8 @@ public final class Array2DRowRealMatrixT
         assertEquals(mRow3, m.getRowVector(0));
         try {
             m.setRowVector(-1, mRow3);
-            fail("Expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("Expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // expected
         }
         try {
@@ -609,14 +644,14 @@ public final class Array2DRowRealMatrixT
         assertEquals("Column3", mColumn3, m.getColumnVector(3));
         try {
             m.getColumnVector(-1);
-            fail("Expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("Expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // expected
         }
         try {
             m.getColumnVector(4);
-            fail("Expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("Expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // expected
         }
     }
@@ -629,8 +664,8 @@ public final class Array2DRowRealMatrixT
         assertEquals(mColumn3, m.getColumnVector(1));
         try {
             m.setColumnVector(-1, mColumn3);
-            fail("Expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("Expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // expected
         }
         try {
@@ -655,14 +690,14 @@ public final class Array2DRowRealMatrixT
         checkArrays(subRow3[0], m.getRow(3));
         try {
             m.getRow(-1);
-            fail("Expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("Expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // expected
         }
         try {
             m.getRow(4);
-            fail("Expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("Expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // expected
         }
     }
@@ -674,8 +709,8 @@ public final class Array2DRowRealMatrixT
         checkArrays(subRow3[0], m.getRow(0));
         try {
             m.setRow(-1, subRow3[0]);
-            fail("Expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("Expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // expected
         }
         try {
@@ -694,14 +729,14 @@ public final class Array2DRowRealMatrixT
         checkArrays(mColumn3, m.getColumn(3));
         try {
             m.getColumn(-1);
-            fail("Expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("Expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // expected
         }
         try {
             m.getColumn(4);
-            fail("Expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("Expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // expected
         }
     }
@@ -714,8 +749,8 @@ public final class Array2DRowRealMatrixT
         checkArrays(mColumn3, m.getColumn(1));
         try {
             m.setColumn(-1, mColumn3);
-            fail("Expecting MatrixIndexException");
-        } catch (MatrixIndexException ex) {
+            fail("Expecting OutOfRangeException");
+        } catch (OutOfRangeException ex) {
             // expected
         }
         try {
@@ -783,21 +818,21 @@ public final class Array2DRowRealMatrixT
         // dimension overflow
         try {
             m.setSubMatrix(testData,1,1);
-            fail("expecting MatrixIndexException");
-        } catch (MatrixIndexException e) {
+            fail("expecting OutOfRangeException");
+        } catch (OutOfRangeException e) {
             // expected
         }
         // dimension underflow
         try {
             m.setSubMatrix(testData,-1,1);
-            fail("expecting MatrixIndexException");
-        } catch (MatrixIndexException e) {
+            fail("expecting OutOfRangeException");
+        } catch (OutOfRangeException e) {
             // expected
         }
         try {
             m.setSubMatrix(testData,1,-1);
-            fail("expecting MatrixIndexException");
-        } catch (MatrixIndexException e) {
+            fail("expecting OutOfRangeException");
+        } catch (OutOfRangeException e) {
             // expected
         }
 



Mime
View raw message