commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From er...@apache.org
Subject svn commit: r1027952 [1/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
Author: erans
Date: Wed Oct 27 13:16:57 2010
New Revision: 1027952

URL: http://svn.apache.org/viewvc?rev=1027952&view=rev
Log:
MATH-425
Deleted deprecated classes in package "linear".
Removed redundant methods in "Array2DRowRealMatrix".
Removed usage of "MatrixIndexException" (class is now deprecated).
Javadoc clean up.

Added:
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/exception/MathArithmeticException.java   (with props)
Removed:
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/BigMatrix.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/BigMatrixImpl.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/RealMatrixImpl.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/BigMatrixImplTest.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/RealMatrixImplTest.java
Modified:
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/exception/util/LocalizedFormats.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/AbstractRealMatrix.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/AbstractRealVector.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/Array2DRowRealMatrix.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/ArrayFieldVector.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/ArrayRealVector.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/BlockRealMatrix.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/FieldMatrix.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/FieldVector.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/MatrixIndexException.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/MatrixUtils.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/OpenMapRealMatrix.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/OpenMapRealVector.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/RealMatrix.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/RealVector.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/SparseFieldMatrix.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/SparseFieldVector.java
    commons/proper/math/trunk/src/main/resources/META-INF/localization/LocalizedFormats_fr.properties
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/Array2DRowRealMatrixTest.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/ArrayFieldVectorTest.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/ArrayRealVectorTest.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/BlockRealMatrixTest.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/MatrixUtilsTest.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/SparseRealMatrixTest.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/linear/SparseRealVectorTest.java

Added: commons/proper/math/trunk/src/main/java/org/apache/commons/math/exception/MathArithmeticException.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/exception/MathArithmeticException.java?rev=1027952&view=auto
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/exception/MathArithmeticException.java (added)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/exception/MathArithmeticException.java Wed Oct 27 13:16:57 2010
@@ -0,0 +1,91 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math.exception;
+
+import java.util.Locale;
+
+import org.apache.commons.math.exception.util.ArgUtils;
+import org.apache.commons.math.exception.util.MessageFactory;
+import org.apache.commons.math.exception.util.Localizable;
+import org.apache.commons.math.exception.util.LocalizedFormats;
+
+/**
+ * Base class for arithmetic exceptions.
+ * It is used for all the exceptions that share the semantics of the standard
+ * {@link ArithmeticException}, but must also provide a localized
+ * message.
+ *
+ * @since 3.0
+ * @version $Revision$ $Date$
+ */
+public class MathArithmeticException extends ArithmeticException {
+
+    /** Serializable version Id. */
+    private static final long serialVersionUID = -6024911025449780478L;
+
+    /**
+     * Pattern used to build the message (specific context).
+     */
+    private final Localizable specific;
+    /**
+     * Arguments used to build the message.
+     */
+    private final Object[] arguments;
+
+    /**
+     * @param args Arguments.
+     */
+    public MathArithmeticException(Object ... args) {
+        this(null, args);
+    }
+    /**
+     * @param specific Message pattern providing the specific context of
+     * the error.
+     * @param args Arguments.
+     */
+    public MathArithmeticException(Localizable specific,
+                                   Object ... args) {
+        this.specific = specific;
+        arguments = ArgUtils.flatten(args);
+    }
+
+    /**
+     * Get the message in a specified locale.
+     *
+     * @param locale Locale in which the message should be translated.
+     *
+     * @return the localized message.
+     */
+    public String getMessage(final Locale locale) {
+        return MessageFactory.buildMessage(locale,
+                                           specific,
+                                           LocalizedFormats.UNSUPPORTED_OPERATION,
+                                           arguments);
+    }
+
+   /** {@inheritDoc} */
+    @Override
+    public String getMessage() {
+        return getMessage(Locale.US);
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public String getLocalizedMessage() {
+        return getMessage(Locale.getDefault());
+    }
+}

Propchange: commons/proper/math/trunk/src/main/java/org/apache/commons/math/exception/MathArithmeticException.java
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/exception/util/LocalizedFormats.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/exception/util/LocalizedFormats.java?rev=1027952&r1=1027951&r2=1027952&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/exception/util/LocalizedFormats.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/exception/util/LocalizedFormats.java Wed Oct 27 13:16:57 2010
@@ -112,11 +112,12 @@ public enum LocalizedFormats implements 
     INDEX_LARGER_THAN_MAX("the index specified: {0} is larger than the current maximal index {1}"),
     INDEX_NOT_POSITIVE("index ({0}) is not positive"),
     INDEX_OUT_OF_RANGE("index {0} out of allowed range [{1}, {2}]"),
+    INDEX("index ({0})"), /* keep */
     INFINITE_ARRAY_ELEMENT("Array contains an infinite element, {0} at index {1}"),
     INFINITE_VALUE_CONVERSION("cannot convert infinite value"),
     INITIAL_CAPACITY_NOT_POSITIVE("initial capacity ({0}) is not positive"),
-    INITIAL_COLUMN_AFTER_FINAL_COLUMN("initial column {0} after final column {1}"),
-    INITIAL_ROW_AFTER_FINAL_ROW("initial row {0} after final row {1}"),
+    INITIAL_COLUMN_AFTER_FINAL_COLUMN("initial column {1} after final column {0}"),
+    INITIAL_ROW_AFTER_FINAL_ROW("initial row {1} after final row {0}"),
     INPUT_DATA_FROM_UNSUPPORTED_DATASOURCE("input data comes from unsupported datasource: {0}, supported sources: {1}, {2}"),
     INSTANCES_NOT_COMPARABLE_TO_EXISTING_VALUES("instance of class {0} not comparable to existing values"),
     INSUFFICIENT_DATA_FOR_T_STATISTIC("insufficient data for t statistic, needs at least 2, got {0}"),

Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/AbstractRealMatrix.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/AbstractRealMatrix.java?rev=1027952&r1=1027951&r2=1027952&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/AbstractRealMatrix.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/AbstractRealMatrix.java Wed Oct 27 13:16:57 2010
@@ -74,9 +74,8 @@ public abstract class AbstractRealMatrix
     public abstract RealMatrix copy();
 
     /** {@inheritDoc} */
-    public RealMatrix add(RealMatrix m) throws IllegalArgumentException {
-
-        // safety check
+    public RealMatrix add(RealMatrix m) {
+        // Safety check.
         MatrixUtils.checkAdditionCompatible(this, m);
 
         final int rowCount    = getRowDimension();
@@ -92,9 +91,8 @@ public abstract class AbstractRealMatrix
     }
 
     /** {@inheritDoc} */
-    public RealMatrix subtract(final RealMatrix m) throws IllegalArgumentException {
-
-        // safety check
+    public RealMatrix subtract(final RealMatrix m) {
+        // Safety check.
         MatrixUtils.checkSubtractionCompatible(this, m);
 
         final int rowCount    = getRowDimension();
@@ -111,7 +109,6 @@ public abstract class AbstractRealMatrix
 
     /** {@inheritDoc} */
     public RealMatrix scalarAdd(final double d) {
-
         final int rowCount    = getRowDimension();
         final int columnCount = getColumnDimension();
         final RealMatrix out = createMatrix(rowCount, columnCount);
@@ -126,7 +123,6 @@ public abstract class AbstractRealMatrix
 
     /** {@inheritDoc} */
     public RealMatrix scalarMultiply(final double d) {
-
         final int rowCount    = getRowDimension();
         final int columnCount = getColumnDimension();
         final RealMatrix out = createMatrix(rowCount, columnCount);
@@ -140,10 +136,8 @@ public abstract class AbstractRealMatrix
     }
 
     /** {@inheritDoc} */
-    public RealMatrix multiply(final RealMatrix m)
-        throws IllegalArgumentException {
-
-        // safety check
+    public RealMatrix multiply(final RealMatrix m) {
+        // Safety check.
         MatrixUtils.checkMultiplicationCompatible(this, m);
 
         final int nRows = getRowDimension();
@@ -164,14 +158,12 @@ public abstract class AbstractRealMatrix
     }
 
     /** {@inheritDoc} */
-    public RealMatrix preMultiply(final RealMatrix m)
-        throws IllegalArgumentException {
+    public RealMatrix preMultiply(final RealMatrix m) {
         return m.multiply(this);
     }
 
     /** {@inheritDoc} */
     public double[][] getData() {
-
         final double[][] data = new double[getRowDimension()][getColumnDimension()];
 
         for (int i = 0; i < data.length; ++i) {
@@ -250,9 +242,7 @@ public abstract class AbstractRealMatrix
 
     /** {@inheritDoc} */
     public RealMatrix getSubMatrix(final int startRow, final int endRow,
-                                   final int startColumn, final int endColumn)
-        throws MatrixIndexException {
-
+                                   final int startColumn, final int endColumn) {
         MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
 
         final RealMatrix subMatrix =
@@ -267,9 +257,7 @@ public abstract class AbstractRealMatrix
     }
 
     /** {@inheritDoc} */
-    public RealMatrix getSubMatrix(final int[] selectedRows, final int[] selectedColumns)
-        throws MatrixIndexException {
-
+    public RealMatrix getSubMatrix(final int[] selectedRows, final int[] selectedColumns) {
         // safety checks
         MatrixUtils.checkSubMatrixIndex(this, selectedRows, selectedColumns);
 
@@ -292,8 +280,7 @@ public abstract class AbstractRealMatrix
     /** {@inheritDoc} */
     public void copySubMatrix(final int startRow, final int endRow,
                               final int startColumn, final int endColumn,
-                              final double[][] destination)
-        throws MatrixIndexException, IllegalArgumentException {
+                              final double[][] destination) {
 
         // safety checks
         MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
@@ -352,9 +339,7 @@ public abstract class AbstractRealMatrix
     }
 
     /** {@inheritDoc} */
-    public void setSubMatrix(final double[][] subMatrix, final int row, final int column)
-        throws MatrixIndexException {
-
+    public void setSubMatrix(final double[][] subMatrix, final int row, final int column) {
         final int nRows = subMatrix.length;
         if (nRows == 0) {
             throw new NoDataException(LocalizedFormats.AT_LEAST_ONE_ROW);
@@ -386,9 +371,7 @@ public abstract class AbstractRealMatrix
     }
 
     /** {@inheritDoc} */
-    public RealMatrix getRowMatrix(final int row)
-        throws MatrixIndexException {
-
+    public RealMatrix getRowMatrix(final int row) {
         MatrixUtils.checkRowIndex(this, row);
         final int nCols = getColumnDimension();
         final RealMatrix out = createMatrix(1, nCols);
@@ -415,9 +398,7 @@ public abstract class AbstractRealMatrix
     }
 
     /** {@inheritDoc} */
-    public RealMatrix getColumnMatrix(final int column)
-        throws MatrixIndexException {
-
+    public RealMatrix getColumnMatrix(final int column) {
         MatrixUtils.checkColumnIndex(this, column);
         final int nRows = getRowDimension();
         final RealMatrix out = createMatrix(nRows, 1);
@@ -444,8 +425,7 @@ public abstract class AbstractRealMatrix
     }
 
     /** {@inheritDoc} */
-    public RealVector getRowVector(final int row)
-        throws MatrixIndexException {
+    public RealVector getRowVector(final int row) {
         return new ArrayRealVector(getRow(row), false);
     }
 
@@ -463,8 +443,7 @@ public abstract class AbstractRealMatrix
     }
 
     /** {@inheritDoc} */
-    public RealVector getColumnVector(final int column)
-        throws MatrixIndexException {
+    public RealVector getColumnVector(final int column) {
         return new ArrayRealVector(getColumn(column), false);
     }
 
@@ -482,9 +461,7 @@ public abstract class AbstractRealMatrix
     }
 
     /** {@inheritDoc} */
-    public double[] getRow(final int row)
-        throws MatrixIndexException {
-
+    public double[] getRow(final int row) {
         MatrixUtils.checkRowIndex(this, row);
         final int nCols = getColumnDimension();
         final double[] out = new double[nCols];
@@ -508,9 +485,7 @@ public abstract class AbstractRealMatrix
     }
 
     /** {@inheritDoc} */
-    public double[] getColumn(final int column)
-        throws MatrixIndexException {
-
+    public double[] getColumn(final int column) {
         MatrixUtils.checkColumnIndex(this, column);
         final int nRows = getRowDimension();
         final double[] out = new double[nRows];
@@ -534,24 +509,19 @@ public abstract class AbstractRealMatrix
     }
 
     /** {@inheritDoc} */
-    public abstract double getEntry(int row, int column)
-        throws MatrixIndexException;
+    public abstract double getEntry(int row, int column);
 
     /** {@inheritDoc} */
-    public abstract void setEntry(int row, int column, double value)
-        throws MatrixIndexException;
+    public abstract void setEntry(int row, int column, double value);
 
     /** {@inheritDoc} */
-    public abstract void addToEntry(int row, int column, double increment)
-        throws MatrixIndexException;
+    public abstract void addToEntry(int row, int column, double increment);
 
     /** {@inheritDoc} */
-    public abstract void multiplyEntry(int row, int column, double factor)
-        throws MatrixIndexException;
+    public abstract void multiplyEntry(int row, int column, double factor);
 
     /** {@inheritDoc} */
     public RealMatrix transpose() {
-
         final int nRows = getRowDimension();
         final int nCols = getColumnDimension();
         final RealMatrix out = createMatrix(nCols, nRows);
@@ -750,7 +720,7 @@ public abstract class AbstractRealMatrix
     public double walkInRowOrder(final RealMatrixChangingVisitor visitor,
                                  final int startRow, final int endRow,
                                  final int startColumn, final int endColumn)
-        throws MatrixIndexException, MatrixVisitorException {
+        throws MatrixVisitorException {
         MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
         visitor.start(getRowDimension(), getColumnDimension(),
                       startRow, endRow, startColumn, endColumn);
@@ -769,7 +739,7 @@ public abstract class AbstractRealMatrix
     public double walkInRowOrder(final RealMatrixPreservingVisitor visitor,
                                  final int startRow, final int endRow,
                                  final int startColumn, final int endColumn)
-        throws MatrixIndexException, MatrixVisitorException {
+        throws MatrixVisitorException {
         MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
         visitor.start(getRowDimension(), getColumnDimension(),
                       startRow, endRow, startColumn, endColumn);
@@ -816,7 +786,7 @@ public abstract class AbstractRealMatrix
     public double walkInColumnOrder(final RealMatrixChangingVisitor visitor,
                                     final int startRow, final int endRow,
                                     final int startColumn, final int endColumn)
-    throws MatrixIndexException, MatrixVisitorException {
+    throws MatrixVisitorException {
         MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
         visitor.start(getRowDimension(), getColumnDimension(),
                       startRow, endRow, startColumn, endColumn);
@@ -835,7 +805,7 @@ public abstract class AbstractRealMatrix
     public double walkInColumnOrder(final RealMatrixPreservingVisitor visitor,
                                     final int startRow, final int endRow,
                                     final int startColumn, final int endColumn)
-    throws MatrixIndexException, MatrixVisitorException {
+    throws MatrixVisitorException {
         MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
         visitor.start(getRowDimension(), getColumnDimension(),
                       startRow, endRow, startColumn, endColumn);
@@ -863,7 +833,7 @@ public abstract class AbstractRealMatrix
     public double walkInOptimizedOrder(final RealMatrixChangingVisitor visitor,
                                        final int startRow, final int endRow,
                                        final int startColumn, final int endColumn)
-        throws MatrixIndexException, MatrixVisitorException {
+        throws MatrixVisitorException {
         return walkInRowOrder(visitor, startRow, endRow, startColumn, endColumn);
     }
 
@@ -871,7 +841,7 @@ public abstract class AbstractRealMatrix
     public double walkInOptimizedOrder(final RealMatrixPreservingVisitor visitor,
                                        final int startRow, final int endRow,
                                        final int startColumn, final int endColumn)
-        throws MatrixIndexException, MatrixVisitorException {
+        throws MatrixVisitorException {
         return walkInRowOrder(visitor, startRow, endRow, startColumn, endColumn);
     }
 

Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/AbstractRealVector.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/AbstractRealVector.java?rev=1027952&r1=1027951&r2=1027952&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/AbstractRealVector.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/AbstractRealVector.java Wed Oct 27 13:16:57 2010
@@ -23,6 +23,7 @@ import java.util.NoSuchElementException;
 import org.apache.commons.math.FunctionEvaluationException;
 import org.apache.commons.math.exception.MathUnsupportedOperationException;
 import org.apache.commons.math.exception.DimensionMismatchException;
+import org.apache.commons.math.exception.OutOfRangeException;
 import org.apache.commons.math.analysis.BinaryFunction;
 import org.apache.commons.math.analysis.ComposableFunction;
 import org.apache.commons.math.analysis.UnivariateRealFunction;
@@ -64,26 +65,27 @@ public abstract class AbstractRealVector
 
     /**
      * Check if an index is valid.
-     * @param index index to check
-     * @exception MatrixIndexException if index is not valid
+     *
+     * @param index Index to check.
+     * @exception OutOfRangeException if {@code index} is not valid.
      */
-    protected void checkIndex(final int index)
-        throws MatrixIndexException {
-        if (index < 0 || index >= getDimension()) {
-            throw new MatrixIndexException(LocalizedFormats.INDEX_OUT_OF_RANGE,
-                                           index, 0, getDimension() - 1);
+    protected void checkIndex(final int index) {
+        if (index < 0 ||
+            index >= getDimension()) {
+            throw new OutOfRangeException(LocalizedFormats.INDEX,
+                                          index, 0, getDimension() - 1);
         }
     }
 
     /** {@inheritDoc} */
-    public void setSubVector(int index, RealVector v) throws MatrixIndexException {
+    public void setSubVector(int index, RealVector v) {
         checkIndex(index);
         checkIndex(index + v.getDimension() - 1);
         setSubVector(index, v.getData());
     }
 
     /** {@inheritDoc} */
-    public void setSubVector(int index, double[] v) throws MatrixIndexException {
+    public void setSubVector(int index, double[] v) {
         checkIndex(index);
         checkIndex(index + v.length - 1);
         for (int i = 0; i < v.length; i++) {
@@ -92,7 +94,7 @@ public abstract class AbstractRealVector
     }
 
     /** {@inheritDoc} */
-    public RealVector add(double[] v) throws IllegalArgumentException {
+    public RealVector add(double[] v) {
         double[] result = v.clone();
         Iterator<Entry> it = sparseIterator();
         Entry e;
@@ -103,7 +105,7 @@ public abstract class AbstractRealVector
     }
 
     /** {@inheritDoc} */
-    public RealVector add(RealVector v) throws IllegalArgumentException {
+    public RealVector add(RealVector v) {
         if (v instanceof ArrayRealVector) {
             double[] values = ((ArrayRealVector)v).getDataRef();
             return add(values);
@@ -119,7 +121,7 @@ public abstract class AbstractRealVector
     }
 
     /** {@inheritDoc} */
-    public RealVector subtract(double[] v) throws IllegalArgumentException {
+    public RealVector subtract(double[] v) {
         double[] result = v.clone();
         Iterator<Entry> it = sparseIterator();
         Entry e;
@@ -131,7 +133,7 @@ public abstract class AbstractRealVector
     }
 
     /** {@inheritDoc} */
-    public RealVector subtract(RealVector v) throws IllegalArgumentException {
+    public RealVector subtract(RealVector v) {
         if (v instanceof ArrayRealVector) {
             double[] values = ((ArrayRealVector)v).getDataRef();
             return add(values);
@@ -167,12 +169,12 @@ public abstract class AbstractRealVector
     public abstract AbstractRealVector copy();
 
     /** {@inheritDoc} */
-    public double dotProduct(double[] v) throws IllegalArgumentException {
+    public double dotProduct(double[] v) {
         return dotProduct(new ArrayRealVector(v, false));
     }
 
     /** {@inheritDoc} */
-    public double dotProduct(RealVector v) throws IllegalArgumentException {
+    public double dotProduct(RealVector v) {
         checkVectorDimensions(v);
         double d = 0;
         Iterator<Entry> it = sparseIterator();
@@ -184,17 +186,17 @@ public abstract class AbstractRealVector
     }
 
     /** {@inheritDoc} */
-    public RealVector ebeDivide(double[] v) throws IllegalArgumentException {
+    public RealVector ebeDivide(double[] v) {
         return ebeDivide(new ArrayRealVector(v, false));
     }
 
     /** {@inheritDoc} */
-    public RealVector ebeMultiply(double[] v) throws IllegalArgumentException {
+    public RealVector ebeMultiply(double[] v) {
         return ebeMultiply(new ArrayRealVector(v, false));
     }
 
     /** {@inheritDoc} */
-    public double getDistance(RealVector v) throws IllegalArgumentException {
+    public double getDistance(RealVector v) {
         checkVectorDimensions(v);
         double d = 0;
         Iterator<Entry> it = iterator();
@@ -241,12 +243,12 @@ public abstract class AbstractRealVector
     }
 
     /** {@inheritDoc} */
-    public double getDistance(double[] v) throws IllegalArgumentException {
+    public double getDistance(double[] v) {
         return getDistance(new ArrayRealVector(v,false));
     }
 
     /** {@inheritDoc} */
-    public double getL1Distance(RealVector v) throws IllegalArgumentException {
+    public double getL1Distance(RealVector v) {
         checkVectorDimensions(v);
         double d = 0;
         Iterator<Entry> it = iterator();
@@ -258,7 +260,7 @@ public abstract class AbstractRealVector
     }
 
     /** {@inheritDoc} */
-    public double getL1Distance(double[] v) throws IllegalArgumentException {
+    public double getL1Distance(double[] v) {
         checkVectorDimensions(v.length);
         double d = 0;
         Iterator<Entry> it = iterator();
@@ -270,7 +272,7 @@ public abstract class AbstractRealVector
     }
 
     /** {@inheritDoc} */
-    public double getLInfDistance(RealVector v) throws IllegalArgumentException {
+    public double getLInfDistance(RealVector v) {
         checkVectorDimensions(v);
         double d = 0;
         Iterator<Entry> it = iterator();
@@ -282,7 +284,7 @@ public abstract class AbstractRealVector
     }
 
     /** {@inheritDoc} */
-    public double getLInfDistance(double[] v) throws IllegalArgumentException {
+    public double getLInfDistance(double[] v) {
         checkVectorDimensions(v.length);
         double d = 0;
         Iterator<Entry> it = iterator();
@@ -720,12 +722,14 @@ public abstract class AbstractRealVector
     }
 
     /** {@inheritDoc} */
-    public RealMatrix outerProduct(RealVector v) throws IllegalArgumentException {
+    public RealMatrix outerProduct(RealVector v) {
         RealMatrix product;
         if (v instanceof SparseRealVector || this instanceof SparseRealVector) {
-            product = new OpenMapRealMatrix(this.getDimension(), v.getDimension());
+            product = new OpenMapRealMatrix(this.getDimension(),
+                                            v.getDimension());
         } else {
-            product = new Array2DRowRealMatrix(this.getDimension(), v.getDimension());
+            product = new Array2DRowRealMatrix(this.getDimension(),
+                                               v.getDimension());
         }
         Iterator<Entry> thisIt = sparseIterator();
         Entry thisE = null;
@@ -743,12 +747,12 @@ public abstract class AbstractRealVector
     }
 
     /** {@inheritDoc} */
-    public RealMatrix outerProduct(double[] v) throws IllegalArgumentException {
+    public RealMatrix outerProduct(double[] v) {
         return outerProduct(new ArrayRealVector(v, false));
     }
 
     /** {@inheritDoc} */
-    public RealVector projection(double[] v) throws IllegalArgumentException {
+    public RealVector projection(double[] v) {
         return projection(new ArrayRealVector(v, false));
     }
 

Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/Array2DRowRealMatrix.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/Array2DRowRealMatrix.java?rev=1027952&r1=1027951&r2=1027952&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/Array2DRowRealMatrix.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/Array2DRowRealMatrix.java Wed Oct 27 13:16:57 2010
@@ -19,7 +19,10 @@ package org.apache.commons.math.linear;
 
 import java.io.Serializable;
 
-import org.apache.commons.math.MathRuntimeException;
+import org.apache.commons.math.exception.DimensionMismatchException;
+import org.apache.commons.math.exception.NullArgumentException;
+import org.apache.commons.math.exception.ZeroException;
+import org.apache.commons.math.exception.MathIllegalStateException;
 import org.apache.commons.math.exception.util.LocalizedFormats;
 
 /**
@@ -51,18 +54,15 @@ import org.apache.commons.math.exception
  * @version $Revision$ $Date$
  */
 public class Array2DRowRealMatrix extends AbstractRealMatrix implements Serializable {
-
-    /** Serializable version identifier */
+    /** Serializable version identifier. */
     private static final long serialVersionUID = -1067294169172445528L;
-
-    /** Entries of the matrix */
+    /** Entries of the matrix. */
     protected double data[][];
 
     /**
      * Creates a matrix with no data
      */
-    public Array2DRowRealMatrix() {
-    }
+    public Array2DRowRealMatrix() {}
 
     /**
      * Create a new RealMatrix with the supplied row and column dimensions.
@@ -99,40 +99,38 @@ public class Array2DRowRealMatrix extend
     /**
      * Create a new RealMatrix using the input array as the underlying
      * data array.
-     * <p>If an array is built specially in order to be embedded in a
-     * RealMatrix and not used directly, the <code>copyArray</code> may be
-     * set to <code>false</code. This will prevent the copying and improve
-     * performance as no new array will be built and no data will be copied.</p>
-     * @param d data for new matrix
-     * @param copyArray if true, the input array will be copied, otherwise
-     * it will be referenced
-     * @throws IllegalArgumentException if <code>d</code> is not rectangular
-     *  (not all rows have the same length) or empty
-     * @throws NullPointerException if <code>d</code> is null
+     * If an array is built specially in order to be embedded in a
+     * RealMatrix and not used directly, the {@code copyArray} may be
+     * set to {@code false}. This will prevent the copying and improve
+     * performance as no new array will be built and no data will be copied.
+     *
+     * @param d Data for new matrix.
+     * @param copyArray if {@code true}, the input array will be copied,
+     * otherwise it will be referenced.
+     * @throws DimensionMismatchException if {@code d} is not rectangular
+     * (not all rows have the same length) or empty.
+     * @throws NullArgumentException if {@code d} is {@code null}.
+     * @throws ZeroException if there are not at least one row and one column.
      * @see #Array2DRowRealMatrix(double[][])
      */
-    public Array2DRowRealMatrix(final double[][] d, final boolean copyArray)
-        throws IllegalArgumentException, NullPointerException {
+    public Array2DRowRealMatrix(final double[][] d, final boolean copyArray) {
         if (copyArray) {
             copyIn(d);
         } else {
             if (d == null) {
-                throw new NullPointerException();
+                throw new NullArgumentException();
             }
             final int nRows = d.length;
             if (nRows == 0) {
-                throw MathRuntimeException.createIllegalArgumentException(
-                      LocalizedFormats.AT_LEAST_ONE_ROW);
+                throw new ZeroException(LocalizedFormats.AT_LEAST_ONE_ROW);
             }
             final int nCols = d[0].length;
             if (nCols == 0) {
-                throw MathRuntimeException.createIllegalArgumentException(
-                      LocalizedFormats.AT_LEAST_ONE_COLUMN);
+                throw new ZeroException(LocalizedFormats.AT_LEAST_ONE_COLUMN);
             }
             for (int r = 1; r < nRows; r++) {
                 if (d[r].length != nCols) {
-                    throw MathRuntimeException.createIllegalArgumentException(
-                          LocalizedFormats.DIFFERENT_ROWS_LENGTHS, nCols, d[r].length);
+                    throw new DimensionMismatchException(d[r].length, nCols);
                 }
             }
             data = d;
@@ -140,12 +138,12 @@ public class Array2DRowRealMatrix extend
     }
 
     /**
-     * Create a new (column) RealMatrix using <code>v</code> as the
-     * data for the unique column of the <code>v.length x 1</code> matrix
+     * Create a new (column) RealMatrix using {@code v} as the
+     * data for the unique column of the {@code v.length x 1} matrix
      * created.
-     * <p>The input array is copied, not referenced.</p>
+     * The input array is copied, not referenced.
      *
-     * @param v column vector holding data for new matrix
+     * @param v Column vector holding data for new matrix.
      */
     public Array2DRowRealMatrix(final double[] v) {
         final int nRows = v.length;
@@ -157,8 +155,8 @@ public class Array2DRowRealMatrix extend
 
     /** {@inheritDoc} */
     @Override
-    public RealMatrix createMatrix(final int rowDimension, final int columnDimension)
-        throws IllegalArgumentException {
+    public RealMatrix createMatrix(final int rowDimension,
+                                   final int columnDimension) {
         return new Array2DRowRealMatrix(rowDimension, columnDimension);
     }
 
@@ -168,28 +166,16 @@ public class Array2DRowRealMatrix extend
         return new Array2DRowRealMatrix(copyOut(), false);
     }
 
-    /** {@inheritDoc} */
-    @Override
-    public RealMatrix add(final RealMatrix m)
-        throws IllegalArgumentException {
-        try {
-            return add((Array2DRowRealMatrix) m);
-        } catch (ClassCastException cce) {
-            return super.add(m);
-        }
-    }
-
     /**
-     * Compute the sum of this and <code>m</code>.
+     * Compute the sum of this matrix with {@code m}.
      *
-     * @param m    matrix to be added
-     * @return     this + m
-     * @throws  IllegalArgumentException if m is not the same size as this
+     * @param m Matrix to be added.
+     * @return {@code this} + m.
+     * @throws org.apache.commons.math.exception.MatrixDimensionMismatchException
+     * if {@code m} is not the same size as this matrix.
      */
-    public Array2DRowRealMatrix add(final Array2DRowRealMatrix m)
-        throws IllegalArgumentException {
-
-        // safety check
+    public Array2DRowRealMatrix add(final Array2DRowRealMatrix m) {
+        // Safety check.
         MatrixUtils.checkAdditionCompatible(this, m);
 
         final int rowCount    = getRowDimension();
@@ -205,31 +191,18 @@ public class Array2DRowRealMatrix extend
         }
 
         return new Array2DRowRealMatrix(outData, false);
-
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public RealMatrix subtract(final RealMatrix m)
-        throws IllegalArgumentException {
-        try {
-            return subtract((Array2DRowRealMatrix) m);
-        } catch (ClassCastException cce) {
-            return super.subtract(m);
-        }
     }
 
     /**
-     * Compute  this minus <code>m</code>.
+     * Subtract {@code m} from this matrix.
      *
-     * @param m    matrix to be subtracted
-     * @return     this + m
-     * @throws  IllegalArgumentException if m is not the same size as this
+     * @param m Matrix to be subtracted.
+     * @return {@code this} - m.
+     * @throws org.apache.commons.math.exception.MatrixDimensionMismatchException
+     * if {@code m} is not the same size as this matrix.
      */
-    public Array2DRowRealMatrix subtract(final Array2DRowRealMatrix m)
-        throws IllegalArgumentException {
-
-        // safety check
+    public Array2DRowRealMatrix subtract(final Array2DRowRealMatrix m) {
+        // Safety check.
         MatrixUtils.checkSubtractionCompatible(this, m);
 
         final int rowCount    = getRowDimension();
@@ -245,31 +218,19 @@ public class Array2DRowRealMatrix extend
         }
 
         return new Array2DRowRealMatrix(outData, false);
-
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public RealMatrix multiply(final RealMatrix m)
-        throws IllegalArgumentException {
-        try {
-            return multiply((Array2DRowRealMatrix) m);
-        } catch (ClassCastException cce) {
-            return super.multiply(m);
-        }
     }
 
     /**
-     * Returns the result of postmultiplying this by <code>m</code>.
-     * @param m    matrix to postmultiply by
-     * @return     this*m
-     * @throws     IllegalArgumentException
-     *             if columnDimension(this) != rowDimension(m)
+     * Returns the result of postmultiplying this matrix with {@code m}.
+     *
+     * @param m Matrix to postmultiply by.
+     * @return {@code this} * m.
+     * @throws org.apache.commons.math.exception.MatrixDimensionMismatchException
+     * if the column dimension of this matrix is different from the row
+     * dimension of {@code m}.
      */
-    public Array2DRowRealMatrix multiply(final Array2DRowRealMatrix m)
-        throws IllegalArgumentException {
-
-        // safety check
+    public Array2DRowRealMatrix multiply(final Array2DRowRealMatrix m) {
+        // Safety check.
         MatrixUtils.checkMultiplicationCompatible(this, m);
 
         final int nRows = this.getRowDimension();
@@ -299,11 +260,9 @@ public class Array2DRowRealMatrix extend
     }
 
     /**
-     * Returns a reference to the underlying data array.
-     * <p>
-     * Does <strong>not</strong> make a fresh copy of the underlying data.</p>
+     * Return a reference to the underlying data array.
      *
-     * @return 2-dimensional array of entries
+     * @return 2-dimensional array of entries.
      */
     public double[][] getDataRef() {
         return data;
@@ -311,33 +270,28 @@ public class Array2DRowRealMatrix extend
 
     /** {@inheritDoc} */
     @Override
-    public void setSubMatrix(final double[][] subMatrix, final int row, final int column)
-    throws MatrixIndexException {
+    public void setSubMatrix(final double[][] subMatrix,
+                             final int row, final int column) {
         if (data == null) {
             if (row > 0) {
-                throw MathRuntimeException.createIllegalStateException(
-                      LocalizedFormats.FIRST_ROWS_NOT_INITIALIZED_YET, row);
+                throw new MathIllegalStateException(LocalizedFormats.FIRST_ROWS_NOT_INITIALIZED_YET, row);
             }
             if (column > 0) {
-                throw MathRuntimeException.createIllegalStateException(
-                      LocalizedFormats.FIRST_COLUMNS_NOT_INITIALIZED_YET, column);
+                throw new MathIllegalStateException(LocalizedFormats.FIRST_COLUMNS_NOT_INITIALIZED_YET, column);
             }
             final int nRows = subMatrix.length;
             if (nRows == 0) {
-                throw MathRuntimeException.createIllegalArgumentException(
-                      LocalizedFormats.AT_LEAST_ONE_ROW);
+                throw new ZeroException(LocalizedFormats.AT_LEAST_ONE_ROW);
             }
 
             final int nCols = subMatrix[0].length;
             if (nCols == 0) {
-                throw MathRuntimeException.createIllegalArgumentException(
-                      LocalizedFormats.AT_LEAST_ONE_COLUMN);
+                throw new ZeroException(LocalizedFormats.AT_LEAST_ONE_COLUMN);
             }
             data = new double[subMatrix.length][nCols];
             for (int i = 0; i < data.length; ++i) {
                 if (subMatrix[i].length != nCols) {
-                    throw MathRuntimeException.createIllegalArgumentException(
-                          LocalizedFormats.DIFFERENT_ROWS_LENGTHS, nCols, subMatrix[i].length);
+                    throw new DimensionMismatchException(subMatrix[i].length, nCols);
                 }
                 System.arraycopy(subMatrix[i], 0, data[i + row], column, nCols);
             }
@@ -349,55 +303,35 @@ public class Array2DRowRealMatrix extend
 
     /** {@inheritDoc} */
     @Override
-    public double getEntry(final int row, final int column)
-        throws MatrixIndexException {
-        try {
-            return data[row][column];
-        } catch (ArrayIndexOutOfBoundsException e) {
-            throw new MatrixIndexException(
-                      LocalizedFormats.NO_SUCH_MATRIX_ENTRY, row, column, getRowDimension(), getColumnDimension());
-        }
+    public double getEntry(final int row, final int column) {
+        MatrixUtils.checkMatrixIndex(this, row, column);
+        return data[row][column];
     }
 
     /** {@inheritDoc} */
     @Override
-    public void setEntry(final int row, final int column, final double value)
-        throws MatrixIndexException {
-        try {
-            data[row][column] = value;
-        } catch (ArrayIndexOutOfBoundsException e) {
-            throw new MatrixIndexException(
-                      LocalizedFormats.NO_SUCH_MATRIX_ENTRY, row, column, getRowDimension(), getColumnDimension());
-        }
+    public void setEntry(final int row, final int column, final double value) {
+        MatrixUtils.checkMatrixIndex(this, row, column);
+        data[row][column] = value;
     }
 
     /** {@inheritDoc} */
     @Override
-    public void addToEntry(final int row, final int column, final double increment)
-        throws MatrixIndexException {
-        try {
-            data[row][column] += increment;
-        } catch (ArrayIndexOutOfBoundsException e) {
-            throw new MatrixIndexException(
-                      LocalizedFormats.NO_SUCH_MATRIX_ENTRY, row, column, getRowDimension(), getColumnDimension());
-        }
+    public void addToEntry(final int row, final int column, final double increment) {
+        MatrixUtils.checkMatrixIndex(this, row, column);
+        data[row][column] += increment;
     }
 
     /** {@inheritDoc} */
     @Override
-    public void multiplyEntry(final int row, final int column, final double factor)
-        throws MatrixIndexException {
-        try {
-            data[row][column] *= factor;
-        } catch (ArrayIndexOutOfBoundsException e) {
-            throw new MatrixIndexException(
-                      LocalizedFormats.NO_SUCH_MATRIX_ENTRY, row, column, getRowDimension(), getColumnDimension());
-        }
+    public void multiplyEntry(final int row, final int column, final double factor) {
+        MatrixUtils.checkMatrixIndex(this, row, column);
+        data[row][column] *= factor;
     }
 
     /** {@inheritDoc} */
     @Override
-    public int getRowDimension() {
+        public int getRowDimension() {
         return (data == null) ? 0 : data.length;
     }
 
@@ -409,13 +343,11 @@ public class Array2DRowRealMatrix extend
 
     /** {@inheritDoc} */
     @Override
-    public double[] operate(final double[] v)
-        throws IllegalArgumentException {
+    public double[] operate(final double[] v) {
         final int nRows = this.getRowDimension();
         final int nCols = this.getColumnDimension();
         if (v.length != nCols) {
-            throw MathRuntimeException.createIllegalArgumentException(
-                  LocalizedFormats.VECTOR_LENGTH_MISMATCH, v.length, nCols);
+            throw new DimensionMismatchException(v.length, nCols);
         }
         final double[] out = new double[nRows];
         for (int row = 0; row < nRows; row++) {
@@ -431,14 +363,11 @@ public class Array2DRowRealMatrix extend
 
     /** {@inheritDoc} */
     @Override
-    public double[] preMultiply(final double[] v)
-        throws IllegalArgumentException {
-
+    public double[] preMultiply(final double[] v) {
         final int nRows = getRowDimension();
         final int nCols = getColumnDimension();
         if (v.length != nRows) {
-            throw MathRuntimeException.createIllegalArgumentException(
-                  LocalizedFormats.VECTOR_LENGTH_MISMATCH, v.length, nRows);
+            throw new DimensionMismatchException(v.length, nRows);
         }
 
         final double[] out = new double[nCols];
@@ -491,7 +420,7 @@ public class Array2DRowRealMatrix extend
     public double walkInRowOrder(final RealMatrixChangingVisitor visitor,
                                  final int startRow, final int endRow,
                                  final int startColumn, final int endColumn)
-        throws MatrixIndexException, MatrixVisitorException {
+        throws MatrixVisitorException {
         MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
         visitor.start(getRowDimension(), getColumnDimension(),
                       startRow, endRow, startColumn, endColumn);
@@ -509,7 +438,7 @@ public class Array2DRowRealMatrix extend
     public double walkInRowOrder(final RealMatrixPreservingVisitor visitor,
                                  final int startRow, final int endRow,
                                  final int startColumn, final int endColumn)
-        throws MatrixIndexException, MatrixVisitorException {
+        throws MatrixVisitorException {
         MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
         visitor.start(getRowDimension(), getColumnDimension(),
                       startRow, endRow, startColumn, endColumn);
@@ -558,7 +487,7 @@ public class Array2DRowRealMatrix extend
     public double walkInColumnOrder(final RealMatrixChangingVisitor visitor,
                                     final int startRow, final int endRow,
                                     final int startColumn, final int endColumn)
-        throws MatrixIndexException, MatrixVisitorException {
+        throws MatrixVisitorException {
         MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
         visitor.start(getRowDimension(), getColumnDimension(),
                       startRow, endRow, startColumn, endColumn);
@@ -576,7 +505,7 @@ public class Array2DRowRealMatrix extend
     public double walkInColumnOrder(final RealMatrixPreservingVisitor visitor,
                                     final int startRow, final int endRow,
                                     final int startColumn, final int endColumn)
-        throws MatrixIndexException, MatrixVisitorException {
+        throws MatrixVisitorException {
         MatrixUtils.checkSubMatrixIndex(this, startRow, endRow, startColumn, endColumn);
         visitor.start(getRowDimension(), getColumnDimension(),
                       startRow, endRow, startColumn, endColumn);

Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/ArrayFieldVector.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/ArrayFieldVector.java?rev=1027952&r1=1027951&r2=1027952&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/ArrayFieldVector.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/linear/ArrayFieldVector.java Wed Oct 27 13:16:57 2010
@@ -22,7 +22,11 @@ import java.util.Arrays;
 
 import org.apache.commons.math.Field;
 import org.apache.commons.math.FieldElement;
-import org.apache.commons.math.MathRuntimeException;
+import org.apache.commons.math.exception.ZeroException;
+import org.apache.commons.math.exception.NullArgumentException;
+import org.apache.commons.math.exception.OutOfRangeException;
+import org.apache.commons.math.exception.DimensionMismatchException;
+import org.apache.commons.math.exception.NumberIsTooLargeException;
 import org.apache.commons.math.exception.util.LocalizedFormats;
 
 /**
@@ -32,24 +36,22 @@ import org.apache.commons.math.exception
  * @since 2.0
  */
 public class ArrayFieldVector<T extends FieldElement<T>> implements FieldVector<T>, Serializable {
-
     /** Serializable version identifier. */
     private static final long serialVersionUID = 7648186910365927050L;
-
     /** Entries of the vector. */
     protected T[] data;
-
     /** Field to which the elements belong. */
     private final Field<T> field;
 
     /**
      * Build a 0-length vector.
-     * <p>Zero-length vectors may be used to initialized construction of vectors
+     * Zero-length vectors may be used to initialized construction of vectors
      * by data gathering. We start with zero-length and use either the {@link
      * #ArrayFieldVector(ArrayFieldVector, ArrayFieldVector)} constructor
-     * or one of the <code>append</code> methods ({@link #append(FieldElement[])},
+     * or one of the {@code append} methods ({@link #append(FieldElement[])},
      * {@link #add(FieldVector)}, {@link #append(ArrayFieldVector)}) to gather data
-     * into this vector.</p>
+     * into this vector.
+     *
      * @param field field to which the elements belong
      */
     public ArrayFieldVector(final Field<T> field) {
@@ -57,9 +59,10 @@ public class ArrayFieldVector<T extends 
     }
 
     /**
-     * Construct a (size)-length vector of zeros.
-     * @param field field to which the elements belong
-     * @param size size of the vector
+     * Construct a vector of zeroes.
+     *
+     * @param field Field to which the elements belong.
+     * @param size Size of the vector.
      */
     public ArrayFieldVector(Field<T> field, int size) {
         this.field = field;
@@ -68,9 +71,10 @@ public class ArrayFieldVector<T extends 
     }
 
     /**
-     * Construct an (size)-length vector with preset values.
-     * @param size size of the vector
-     * @param preset fill the vector with this scalar value
+     * Construct a vector with preset values.
+     *
+     * @param size Size of the vector.
+     * @param preset All entries will be set with this value.
      */
     public ArrayFieldVector(int size, T preset) {
         this(preset.getField(), size);
@@ -79,34 +83,40 @@ public class ArrayFieldVector<T extends 
 
     /**
      * Construct a vector from an array, copying the input array.
-     * <p>
      * This constructor needs a non-empty {@code d} array to retrieve
      * the field from its first element. This implies it cannot build
      * 0 length vectors. To build vectors from any size, one should
      * use the {@link #ArrayFieldVector(Field, FieldElement[])} constructor.
-     * </p>
-     * @param d array of Ts.
-     * @throws IllegalArgumentException if <code>d</code> is empty
+     *
+     * @param d Array.
+     * @throws NullArgumentException if {@code d} is {@code null}.
+     * @throws ZeroException if {@code d} is empty.
      * @see #ArrayFieldVector(Field, FieldElement[])
      */
-    public ArrayFieldVector(T[] d)
-        throws IllegalArgumentException {
+    public ArrayFieldVector(T[] d) {
+        if (d == null) {
+            throw new NullArgumentException();
+        }
         try {
             field = d[0].getField();
             data = d.clone();
         } catch (ArrayIndexOutOfBoundsException e) {
-            throw MathRuntimeException.createIllegalArgumentException(
-                      LocalizedFormats.VECTOR_MUST_HAVE_AT_LEAST_ONE_ELEMENT);
+            throw new ZeroException(LocalizedFormats.VECTOR_MUST_HAVE_AT_LEAST_ONE_ELEMENT);
         }
     }
 
     /**
      * Construct a vector from an array, copying the input array.
-     * @param field field to which the elements belong
-     * @param d array of Ts.
+     *
+     * @param field Field to which the elements belong.
+     * @param d Array.
+     * @throws NullArgumentException if {@code d} is {@code null}.
      * @see #ArrayFieldVector(FieldElement[])
      */
     public ArrayFieldVector(Field<T> field, T[] d) {
+        if (d == null) {
+            throw new NullArgumentException();
+        }
         this.field = field;
         data = d.clone();
     }
@@ -114,29 +124,30 @@ public class ArrayFieldVector<T extends 
     /**
      * Create a new ArrayFieldVector using the input array as the underlying
      * data array.
-     * <p>If an array is built specially in order to be embedded in a
-     * ArrayFieldVector and not used directly, the <code>copyArray</code> may be
-     * set to <code>false</code. This will prevent the copying and improve
-     * performance as no new array will be built and no data will be copied.</p>
-     * <p>
+     * If an array is built specially in order to be embedded in a
+     * ArrayFieldVector and not used directly, the {@code copyArray} may be
+     * set to {@code false}. This will prevent the copying and improve
+     * performance as no new array will be built and no data will be copied.
      * This constructor needs a non-empty {@code d} array to retrieve
      * the field from its first element. This implies it cannot build
      * 0 length vectors. To build vectors from any size, one should
-     * use the {@link #ArrayFieldVector(Field, FieldElement[], boolean)} constructor.
-     * </p>
-     * @param d data for new vector
-     * @param copyArray if true, the input array will be copied, otherwise
-     * it will be referenced
-     * @throws IllegalArgumentException if <code>d</code> is empty
-     * @throws NullPointerException if <code>d</code> is null
+     * use the {@link #ArrayFieldVector(Field, FieldElement[], boolean)}
+     * constructor.
+     *
+     * @param d Data for the new vector.
+     * @param copyArray If {@code true}, the input array will be copied,
+     * otherwise it will be referenced.
+     * @throws NullArgumentException if {@code d} is {@code null}.
+     * @throws ZeroException if {@code d} is empty.
      * @see #ArrayFieldVector(FieldElement[])
      * @see #ArrayFieldVector(Field, FieldElement[], boolean)
      */
-    public ArrayFieldVector(T[] d, boolean copyArray)
-        throws NullPointerException, IllegalArgumentException {
+    public ArrayFieldVector(T[] d, boolean copyArray) {
+        if (d == null) {
+            throw new NullArgumentException();
+        }
         if (d.length == 0) {
-            throw MathRuntimeException.createIllegalArgumentException(
-                  LocalizedFormats.VECTOR_MUST_HAVE_AT_LEAST_ONE_ELEMENT);
+            throw new ZeroException(LocalizedFormats.VECTOR_MUST_HAVE_AT_LEAST_ONE_ELEMENT);
         }
         field = d[0].getField();
         data = copyArray ? d.clone() :  d;
@@ -145,32 +156,42 @@ public class ArrayFieldVector<T extends 
     /**
      * Create a new ArrayFieldVector using the input array as the underlying
      * data array.
-     * <p>If an array is built specially in order to be embedded in a
-     * ArrayFieldVector and not used directly, the <code>copyArray</code> may be
-     * set to <code>false</code. This will prevent the copying and improve
-     * performance as no new array will be built and no data will be copied.</p>
-     * @param field field to which the elements belong
-     * @param d data for new vector
-     * @param copyArray if true, the input array will be copied, otherwise
-     * it will be referenced
+     * If an array is built specially in order to be embedded in a
+     * ArrayFieldVector and not used directly, the {@code copyArray} may be
+     * set to {@code false}. This will prevent the copying and improve
+     * performance as no new array will be built and no data will be copied.
+     *
+     * @param field Field to which the elements belong.
+     * @param d Data for the new vector.
+     * @param copyArray If {@code true}, the input array will be copied,
+     * otherwise it will be referenced.
+     * @throws NullArgumentException if {@code d} is {@code null}.
      * @see #ArrayFieldVector(FieldElement[], boolean)
      */
     public ArrayFieldVector(Field<T> field, T[] d, boolean copyArray) {
+        if (d == null) {
+            throw new NullArgumentException();
+        }
         this.field = field;
         data = copyArray ? d.clone() :  d;
     }
 
     /**
      * Construct a vector from part of a array.
-     * @param d array of Ts.
-     * @param pos position of first entry
-     * @param size number of entries to copy
+     *
+     * @param d Array.
+     * @param pos Position of the first entry.
+     * @param size Number of entries to copy.
+     * @throws NullArgumentException if {@code d} is {@code null}.
+     * @throws NumberIsTooLargeException if the size of {@code d} is less
+     * than {@code pos + size}.
      */
     public ArrayFieldVector(T[] d, int pos, int size) {
+        if (d == null) {
+            throw new NullArgumentException();
+        }
         if (d.length < pos + size) {
-            throw MathRuntimeException.createIllegalArgumentException(
-                    LocalizedFormats.POSITION_SIZE_MISMATCH_INPUT_ARRAY,
-                    pos, size, d.length);
+            throw new NumberIsTooLargeException(pos + size, d.length, true);
         }
         field = d[0].getField();
         data = buildArray(size);
@@ -179,9 +200,14 @@ public class ArrayFieldVector<T extends 
 
     /**
      * Construct a vector from another vector, using a deep copy.
-     * @param v vector to copy
+     *
+     * @param v Vector to copy.
+     * @throws NullArgumentException if {@code v} is {@code null}.
      */
     public ArrayFieldVector(FieldVector<T> v) {
+        if (v == null) {
+            throw new NullArgumentException();
+        }
         field = v.getField();
         data = buildArray(v.getDimension());
         for (int i = 0; i < data.length; ++i) {
@@ -191,29 +217,47 @@ public class ArrayFieldVector<T extends 
 
     /**
      * Construct a vector from another vector, using a deep copy.
-     * @param v vector to copy
+     *
+     * @param v Vector to copy.
+     * @throws NullArgumentException if {@code v} is {@code null}.
      */
     public ArrayFieldVector(ArrayFieldVector<T> v) {
+        if (v == null) {
+            throw new NullArgumentException();
+        }
         field = v.getField();
         data = v.data.clone();
     }
 
     /**
      * Construct a vector from another vector.
-     * @param v vector to copy
-     * @param deep if true perform a deep copy otherwise perform a shallow copy
+     *
+     * @param v Vector to copy.
+     * @param deep If {@code true} perform a deep copy, otherwise perform
+     * a shallow copy
+     * @throws NullArgumentException if {@code v} is {@code null}.
      */
     public ArrayFieldVector(ArrayFieldVector<T> v, boolean deep) {
+        if (v == null) {
+            throw new NullArgumentException();
+        }
         field = v.getField();
         data = deep ? v.data.clone() : v.data;
     }
 
     /**
      * Construct a vector by appending one vector to another vector.
-     * @param v1 first vector (will be put in front of the new vector)
-     * @param v2 second vector (will be put at back of the new vector)
+     *
+     * @param v1 First vector (will be put in front of the new vector).
+     * @param v2 Second vector (will be put at back of the new vector).
+     * @throws NullArgumentException if {@code v1} or {@code v2} is
+     * {@code null}.
      */
     public ArrayFieldVector(ArrayFieldVector<T> v1, ArrayFieldVector<T> v2) {
+        if (v1 == null ||
+            v2 == null) {
+            throw new NullArgumentException();
+        }
         field = v1.getField();
         data = buildArray(v1.data.length + v2.data.length);
         System.arraycopy(v1.data, 0, data, 0, v1.data.length);
@@ -222,10 +266,17 @@ public class ArrayFieldVector<T extends 
 
     /**
      * Construct a vector by appending one vector to another vector.
-     * @param v1 first vector (will be put in front of the new vector)
-     * @param v2 second vector (will be put at back of the new vector)
+     *
+     * @param v1 First vector (will be put in front of the new vector).
+     * @param v2 Second vector (will be put at back of the new vector).
+     * @throws NullArgumentException if {@code v1} or {@code v2} is
+     * {@code null}.
      */
     public ArrayFieldVector(ArrayFieldVector<T> v1, T[] v2) {
+        if (v1 == null ||
+            v2 == null) {
+            throw new NullArgumentException();
+        }
         field = v1.getField();
         data = buildArray(v1.data.length + v2.length);
         System.arraycopy(v1.data, 0, data, 0, v1.data.length);
@@ -234,10 +285,17 @@ public class ArrayFieldVector<T extends 
 
     /**
      * Construct a vector by appending one vector to another vector.
-     * @param v1 first vector (will be put in front of the new vector)
-     * @param v2 second vector (will be put at back of the new vector)
+     *
+     * @param v1 First vector (will be put in front of the new vector).
+     * @param v2 Second vector (will be put at back of the new vector).
+     * @throws NullArgumentException if {@code v1} or {@code v2} is
+     * {@code null}.
      */
     public ArrayFieldVector(T[] v1, ArrayFieldVector<T> v2) {
+        if (v1 == null ||
+            v2 == null) {
+            throw new NullArgumentException();
+        }
         field = v2.getField();
         data = buildArray(v1.length + v2.data.length);
         System.arraycopy(v1, 0, data, 0, v1.length);
@@ -246,40 +304,47 @@ public class ArrayFieldVector<T extends 
 
     /**
      * Construct a vector by appending one vector to another vector.
-     * <p>
      * This constructor needs at least one non-empty array to retrieve
      * the field from its first element. This implies it cannot build
      * 0 length vectors. To build vectors from any size, one should
-     * use the {@link #ArrayFieldVector(Field, FieldElement[], FieldElement[])} constructor.
-     * </p>
-     * @param v1 first vector (will be put in front of the new vector)
-     * @param v2 second vector (will be put at back of the new vector)
-     * @exception IllegalArgumentException if both vectors are empty
+     * use the {@link #ArrayFieldVector(Field, FieldElement[], FieldElement[])}
+     * constructor.
+     *
+     * @param v1 First vector (will be put in front of the new vector).
+     * @param v2 Second vector (will be put at back of the new vector).
+     * @throws NullArgumentException if {@code v1} or {@code v2} is
+     * {@code null}.
+     * @throws ZeroException if both arrays are empty.
      * @see #ArrayFieldVector(Field, FieldElement[], FieldElement[])
      */
     public ArrayFieldVector(T[] v1, T[] v2) {
-        try {
-            data = buildArray(v1.length + v2.length);
-            System.arraycopy(v1, 0, data, 0, v1.length);
-            System.arraycopy(v2, 0, data, v1.length, v2.length);
-            field = data[0].getField();
-        } catch (ArrayIndexOutOfBoundsException e) {
-            throw MathRuntimeException.createIllegalArgumentException(
-                      LocalizedFormats.VECTOR_MUST_HAVE_AT_LEAST_ONE_ELEMENT);
+        if (v1 == null ||
+            v2 == null) {
+            throw new NullArgumentException();
         }
+        if (v1.length + v2.length == 0) {
+            throw new ZeroException(LocalizedFormats.VECTOR_MUST_HAVE_AT_LEAST_ONE_ELEMENT);
+        }
+        data = buildArray(v1.length + v2.length);
+        System.arraycopy(v1, 0, data, 0, v1.length);
+        System.arraycopy(v2, 0, data, v1.length, v2.length);
+        field = data[0].getField();
     }
 
     /**
      * Construct a vector by appending one vector to another vector.
-     * @param field field to which the elements belong
-     * @param v1 first vector (will be put in front of the new vector)
-     * @param v2 second vector (will be put at back of the new vector)
+     *
+     * @param field Field to which the elements belong.
+     * @param v1 First vector (will be put in front of the new vector).
+     * @param v2 Second vector (will be put at back of the new vector).
+     * @throws NullArgumentException if {@code v1} or {@code v2} is
+     * {@code null}.
+     * @throws ZeroException if both arrays are empty.
      * @see #ArrayFieldVector(FieldElement[], FieldElement[])
      */
     public ArrayFieldVector(Field<T> field, T[] v1, T[] v2) {
         if (v1.length + v2.length == 0) {
-            throw MathRuntimeException.createIllegalArgumentException(
-                  LocalizedFormats.VECTOR_MUST_HAVE_AT_LEAST_ONE_ELEMENT);
+            throw new ZeroException(LocalizedFormats.VECTOR_MUST_HAVE_AT_LEAST_ONE_ELEMENT);
         }
         data = buildArray(v1.length + v2.length);
         System.arraycopy(v1, 0, data, 0, v1.length);
@@ -287,9 +352,11 @@ public class ArrayFieldVector<T extends 
         this.field = data[0].getField();
     }
 
-    /** 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 of type T
     private T[] buildArray(final int length) {
@@ -307,7 +374,7 @@ public class ArrayFieldVector<T extends 
     }
 
     /** {@inheritDoc} */
-    public FieldVector<T> add(FieldVector<T> v) throws IllegalArgumentException {
+    public FieldVector<T> add(FieldVector<T> v) {
         try {
             return add((ArrayFieldVector<T>) v);
         } catch (ClassCastException cce) {
@@ -321,7 +388,7 @@ public class ArrayFieldVector<T extends 
     }
 
     /** {@inheritDoc} */
-    public FieldVector<T> add(T[] v) throws IllegalArgumentException {
+    public FieldVector<T> add(T[] v) {
         checkVectorDimensions(v.length);
         T[] out = buildArray(data.length);
         for (int i = 0; i < data.length; i++) {
@@ -336,13 +403,12 @@ public class ArrayFieldVector<T extends 
      * @return this + v
      * @throws IllegalArgumentException if v is not the same size as this
      */
-    public ArrayFieldVector<T> add(ArrayFieldVector<T> v)
-        throws IllegalArgumentException {
+    public ArrayFieldVector<T> add(ArrayFieldVector<T> v) {
         return (ArrayFieldVector<T>) add(v.data);
     }
 
     /** {@inheritDoc} */
-    public FieldVector<T> subtract(FieldVector<T> v) throws IllegalArgumentException {
+    public FieldVector<T> subtract(FieldVector<T> v) {
         try {
             return subtract((ArrayFieldVector<T>) v);
         } catch (ClassCastException cce) {
@@ -356,7 +422,7 @@ public class ArrayFieldVector<T extends 
     }
 
     /** {@inheritDoc} */
-    public FieldVector<T> subtract(T[] v) throws IllegalArgumentException {
+    public FieldVector<T> subtract(T[] v) {
         checkVectorDimensions(v.length);
         T[] out = buildArray(data.length);
         for (int i = 0; i < data.length; i++) {
@@ -371,8 +437,7 @@ public class ArrayFieldVector<T extends 
      * @return this + v
      * @throws IllegalArgumentException if v is not the same size as this
      */
-    public ArrayFieldVector<T> subtract(ArrayFieldVector<T> v)
-        throws IllegalArgumentException {
+    public ArrayFieldVector<T> subtract(ArrayFieldVector<T> v) {
         return (ArrayFieldVector<T>) subtract(v.data);
     }
 
@@ -464,8 +529,7 @@ public class ArrayFieldVector<T extends 
     }
 
     /** {@inheritDoc} */
-    public FieldVector<T> ebeMultiply(FieldVector<T> v)
-        throws IllegalArgumentException {
+    public FieldVector<T> ebeMultiply(FieldVector<T> v) {
         try {
             return ebeMultiply((ArrayFieldVector<T>) v);
         } catch (ClassCastException cce) {
@@ -479,8 +543,7 @@ public class ArrayFieldVector<T extends 
     }
 
     /** {@inheritDoc} */
-    public FieldVector<T> ebeMultiply(T[] v)
-        throws IllegalArgumentException {
+    public FieldVector<T> ebeMultiply(T[] v) {
         checkVectorDimensions(v.length);
         T[] out = buildArray(data.length);
         for (int i = 0; i < data.length; i++) {
@@ -495,14 +558,12 @@ public class ArrayFieldVector<T extends 
      * @return a vector containing this[i] * v[i] for all i
      * @exception IllegalArgumentException if v is not the same size as this
      */
-    public ArrayFieldVector<T> ebeMultiply(ArrayFieldVector<T> v)
-        throws IllegalArgumentException {
+    public ArrayFieldVector<T> ebeMultiply(ArrayFieldVector<T> v) {
         return (ArrayFieldVector<T>) ebeMultiply(v.data);
     }
 
     /** {@inheritDoc} */
-    public FieldVector<T> ebeDivide(FieldVector<T> v)
-        throws IllegalArgumentException {
+    public FieldVector<T> ebeDivide(FieldVector<T> v) {
         try {
             return ebeDivide((ArrayFieldVector<T>) v);
         } catch (ClassCastException cce) {
@@ -516,8 +577,7 @@ public class ArrayFieldVector<T extends 
     }
 
     /** {@inheritDoc} */
-    public FieldVector<T> ebeDivide(T[] v)
-        throws IllegalArgumentException {
+    public FieldVector<T> ebeDivide(T[] v) {
         checkVectorDimensions(v.length);
         T[] out = buildArray(data.length);
         for (int i = 0; i < data.length; i++) {
@@ -532,8 +592,7 @@ public class ArrayFieldVector<T extends 
      * @return a vector containing this[i] / v[i] for all i
      * @throws IllegalArgumentException if v is not the same size as this
      */
-    public ArrayFieldVector<T> ebeDivide(ArrayFieldVector<T> v)
-        throws IllegalArgumentException {
+    public ArrayFieldVector<T> ebeDivide(ArrayFieldVector<T> v) {
         return (ArrayFieldVector<T>) ebeDivide(v.data);
     }
 
@@ -552,8 +611,7 @@ public class ArrayFieldVector<T extends 
     }
 
     /** {@inheritDoc} */
-    public T dotProduct(FieldVector<T> v)
-        throws IllegalArgumentException {
+    public T dotProduct(FieldVector<T> v) {
         try {
             return dotProduct((ArrayFieldVector<T>) v);
         } catch (ClassCastException cce) {
@@ -567,8 +625,7 @@ public class ArrayFieldVector<T extends 
     }
 
     /** {@inheritDoc} */
-    public T dotProduct(T[] v)
-        throws IllegalArgumentException {
+    public T dotProduct(T[] v) {
         checkVectorDimensions(v.length);
         T dot = field.getZero();
         for (int i = 0; i < data.length; i++) {
@@ -583,8 +640,7 @@ public class ArrayFieldVector<T extends 
      * @return the scalar dot product between instance and v
      * @exception IllegalArgumentException if v is not the same size as this
      */
-    public T dotProduct(ArrayFieldVector<T> v)
-        throws IllegalArgumentException {
+    public T dotProduct(ArrayFieldVector<T> v) {
         return dotProduct(v.data);
     }
 
@@ -608,8 +664,7 @@ public class ArrayFieldVector<T extends 
     }
 
     /** {@inheritDoc} */
-    public FieldMatrix<T> outerProduct(FieldVector<T> v)
-        throws IllegalArgumentException {
+    public FieldMatrix<T> outerProduct(FieldVector<T> v) {
         try {
             return outerProduct((ArrayFieldVector<T>) v);
         } catch (ClassCastException cce) {
@@ -631,14 +686,12 @@ public class ArrayFieldVector<T extends 
      * @return the square matrix outer product between instance and v
      * @exception IllegalArgumentException if v is not the same size as this
      */
-    public FieldMatrix<T> outerProduct(ArrayFieldVector<T> v)
-        throws IllegalArgumentException {
+    public FieldMatrix<T> outerProduct(ArrayFieldVector<T> v) {
         return outerProduct(v.data);
     }
 
     /** {@inheritDoc} */
-    public FieldMatrix<T> outerProduct(T[] v)
-        throws IllegalArgumentException {
+    public FieldMatrix<T> outerProduct(T[] v) {
         checkVectorDimensions(v.length);
         final int m = data.length;
         final FieldMatrix<T> out = new Array2DRowFieldMatrix<T>(field, m, m);
@@ -651,7 +704,7 @@ public class ArrayFieldVector<T extends 
     }
 
     /** {@inheritDoc} */
-    public T getEntry(int index) throws MatrixIndexException {
+    public T getEntry(int index) {
         return data[index];
     }
 
@@ -743,11 +796,10 @@ public class ArrayFieldVector<T extends 
      *
      * @param index index of first element to be set.
      * @param v vector containing the values to set.
-     * @exception MatrixIndexException if the index is
+     * @throws OutOfRangeException if the index is
      * inconsistent with vector size
      */
-    public void set(int index, ArrayFieldVector<T> v)
-        throws MatrixIndexException {
+    public void set(int index, ArrayFieldVector<T> v) {
         setSubVector(index, v.data);
     }
 
@@ -767,76 +819,56 @@ public class ArrayFieldVector<T extends 
      * @exception IllegalArgumentException if the vectors do not
      * have the same dimension
      */
-    protected void checkVectorDimensions(FieldVector<T> v)
-        throws IllegalArgumentException {
+    protected void checkVectorDimensions(FieldVector<T> v) {
         checkVectorDimensions(v.getDimension());
     }
 
     /**
      * 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 OutOfRangeException if the dimension is
+     * inconsistent with this vector size.
      */
-    protected void checkVectorDimensions(int n)
-        throws IllegalArgumentException {
+    protected void checkVectorDimensions(int n) {
         if (data.length != n) {
-            throw MathRuntimeException.createIllegalArgumentException(
-                    LocalizedFormats.VECTOR_LENGTH_MISMATCH,
-                    data.length, n);
+            throw new DimensionMismatchException(data.length, n);
         }
     }
 
     /**
-     * Test for the equality of two real vectors.
-     * <p>
-     * If all coordinates of two real vectors are exactly the same, and none are
-     * <code>Double.NaN</code>, the two real vectors are considered to be equal.
-     * </p>
-     * <p>
-     * <code>NaN</code> coordinates are considered to affect globally the vector
-     * and be equals to each other - i.e, if either (or all) coordinates of the
-     * real vector are equal to <code>Double.NaN</code>, the real vector is equal to
-     * a vector with all <code>Double.NaN</code> coordinates.
-     * </p>
-     *
-     * @param other Object to test for equality to this
-     * @return true if two 3D vector objects are equal, false if
-     *         object is null, not an instance of Vector3D, or
-     *         not equal to this Vector3D instance
+     * Test for the equality of two vectors.
      *
+     * @param other Object to test for equality.
+     * @return {@code true} if two vector objects are equal, {@code false}
+     * otherwise.
      */
     @Override
     public boolean equals(Object other) {
+        if (this == other) {
+            return true;
+        }
+        if (other == null) {
+            return false;
+        }
 
-      if (this == other) {
-        return true;
-      }
-
-      if (other == null) {
-        return false;
-      }
-
-      try {
-          @SuppressWarnings("unchecked") // May fail, but we ignore ClassCastException
-          FieldVector<T> rhs = (FieldVector<T>) other;
-          if (data.length != rhs.getDimension()) {
-              return false;
-          }
-
-          for (int i = 0; i < data.length; ++i) {
-              if (!data[i].equals(rhs.getEntry(i))) {
-                  return false;
-              }
-          }
-          return true;
-
-      } catch (ClassCastException ex) {
-          // ignore exception
-          return false;
-      }
+        try {
+            @SuppressWarnings("unchecked") // May fail, but we ignore ClassCastException
+                FieldVector<T> rhs = (FieldVector<T>) other;
+            if (data.length != rhs.getDimension()) {
+                return false;
+            }
 
+            for (int i = 0; i < data.length; ++i) {
+                if (!data[i].equals(rhs.getEntry(i))) {
+                    return false;
+                }
+            }
+            return true;
+        } catch (ClassCastException ex) {
+            // ignore exception
+            return false;
+        }
     }
 
     /**
@@ -855,15 +887,14 @@ public class ArrayFieldVector<T extends 
 
     /**
      * Check if an index is valid.
-     * @param index index to check
-     * @exception MatrixIndexException if index is not valid
+     *
+     * @param index Index to check.
+     * @exception OutOfRangeException if the index is not valid.
      */
-    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(LocalizedFormats.INDEX,
+                                          index, 0, getDimension() - 1);
         }
     }
-
 }



Mime
View raw message