fixed checkstyle warnings

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/math/branches/MATH_2_0@705239 13f79535-47bb-0310-9956-ffa450edef68

src/java/org/apache/commons/math/distribution/BetaDistribution.java

@@ -21,7 +21,9 @@ import org.apache.commons.math.MathException;
 /**
  * Computes the cumulative, inverse cumulative and density functions for the beta distribuiton.
  *
- * See http://en.wikipedia.org/wiki/Beta_distribution
+ * @see <a href="http://en.wikipedia.org/wiki/Beta_distribution">Beta_distribution</a>
+ * @version $Revision$ $Date$
+ * @since 2.0
  */
 public interface BetaDistribution extends ContinuousDistribution, HasDensity<Double> {
     /**
@@ -52,6 +54,7 @@ public interface BetaDistribution extends ContinuousDistribution, HasDensity<Dou
       * Return the probability density for a particular point.
       * @param x  The point at which the density should be computed.
       * @return  The pdf at point x.
+      * @exception MathException if probability density cannot be computed
       */
      double density(Double x) throws MathException;
 

src/java/org/apache/commons/math/distribution/BetaDistributionImpl.java

@@ -29,6 +29,8 @@ import org.apache.commons.math.special.Beta;
  * Beta distribution</a></li>
  * </ul>
  * </p>
+ * @version $Revision$ $Date$
+ * @since 2.0
  */
 public class BetaDistributionImpl
     extends AbstractContinuousDistribution implements BetaDistribution {
@@ -58,40 +60,24 @@ public class BetaDistributionImpl
         z = Double.NaN;
     }
 
-    /**
+    /** {@inheritDoc} */
-     * Modify the shape parameter, alpha.
-     *
-     * @param alpha the new shape parameter.
-     */
     public void setAlpha(double alpha) {
         this.alpha = alpha;
         z = Double.NaN;
     }
 
-    /**
+    /** {@inheritDoc} */
-     * Access the shape parameter, alpha
-     *
-     * @return alpha.
-     */
     public double getAlpha() {
         return alpha;
     }
 
-    /**
+    /** {@inheritDoc} */
-     * Modify the shape parameter, beta.
-     *
-     * @param beta the new scale parameter.
-     */
     public void setBeta(double beta) {
         this.beta = beta;
         z = Double.NaN;
     }
 
-    /**
+    /** {@inheritDoc} */
-     * Access the shape parameter, beta
-     *
-     * @return beta.
-     */
     public double getBeta() {
         return beta;
     }
@@ -105,12 +91,7 @@ public class BetaDistributionImpl
         }
     }
 
-    /**
+    /** {@inheritDoc} */
-     * Return the probability density for a particular point.
-     *
-     * @param x The point at which the density should be computed.
-     * @return The pdf at point x.
-     */
     public double density(Double x) throws MathException {
         recomputeZ();
         if (x < 0 || x > 1) {
@@ -132,15 +113,7 @@ public class BetaDistributionImpl
         }
     }
 
-    /**
+    /** {@inheritDoc} */
-     * For this distribution, X, this method returns x such that P(X &lt; x) = p.
-     *
-     * @param p the cumulative probability.
-     * @return x.
-     * @throws org.apache.commons.math.MathException
-     *          if the inverse cumulative probability can not be
-     *          computed due to convergence or other numerical errors.
-     */
     public double inverseCumulativeProbability(double p) throws MathException {
         if (p == 0) {
             return 0;
@@ -151,57 +124,22 @@ public class BetaDistributionImpl
         }
     }
 
-    /**
+    /** {@inheritDoc} */
-     * Access the initial domain value, based on <code>p</code>, used to
-     * bracket a CDF root.  This method is used by
-     * {@link #inverseCumulativeProbability(double)} to find critical values.
-     *
-     * @param p the desired probability for the critical value
-     * @return initial domain value
-     */
     protected double getInitialDomain(double p) {
         return p;
     }
 
-    /**
+    /** {@inheritDoc} */
-     * Access the domain value lower bound, based on <code>p</code>, used to
-     * bracket a CDF root.  This method is used by
-     * {@link #inverseCumulativeProbability(double)} to find critical values.
-     *
-     * @param p the desired probability for the critical value
-     * @return domain value lower bound, i.e.
-     *         P(X &lt; <i>lower bound</i>) &lt; <code>p</code>
-     */
     protected double getDomainLowerBound(double p) {
         return 0;
     }
 
-    /**
+    /** {@inheritDoc} */
-     * Access the domain value upper bound, based on <code>p</code>, used to
-     * bracket a CDF root.  This method is used by
-     * {@link #inverseCumulativeProbability(double)} to find critical values.
-     *
-     * @param p the desired probability for the critical value
-     * @return domain value upper bound, i.e.
-     *         P(X &lt; <i>upper bound</i>) &gt; <code>p</code>
-     */
     protected double getDomainUpperBound(double p) {
         return 1;
     }
 
-    /**
+    /** {@inheritDoc} */
-     * For a random variable X whose values are distributed according
-     * to this distribution, this method returns P(X &le; x).  In other words,
-     * this method represents the  (cumulative) distribution function, or
-     * CDF, for this distribution.
-     *
-     * @param x the value at which the distribution function is evaluated.
-     * @return the probability that a random variable with this
-     *         distribution takes a value less than or equal to <code>x</code>
-     * @throws org.apache.commons.math.MathException
-     *          if the cumulative probability can not be
-     *          computed due to convergence or other numerical errors.
-     */
     public double cumulativeProbability(double x) throws MathException {
         if (x <= 0) {
             return 0;
@@ -212,20 +150,7 @@ public class BetaDistributionImpl
         }
     }
 
-    /**
+    /** {@inheritDoc} */
-     * For a random variable X whose values are distributed according
-     * to this distribution, this method returns P(x0 &le; X &le; x1).
-     *
-     * @param x0 the (inclusive) lower bound
-     * @param x1 the (inclusive) upper bound
-     * @return the probability that a random variable with this distribution
-     *         will take a value between <code>x0</code> and <code>x1</code>,
-     *         including the endpoints
-     * @throws org.apache.commons.math.MathException
-     *                                  if the cumulative probability can not be
-     *                                  computed due to convergence or other numerical errors.
-     * @throws IllegalArgumentException if <code>x0 > x1</code>
-     */
     public double cumulativeProbability(double x0, double x1) throws MathException {
         return cumulativeProbability(x1) - cumulativeProbability(x0);
     }

src/java/org/apache/commons/math/distribution/HasDensity.java

@@ -22,6 +22,8 @@ import org.apache.commons.math.MathException;
 /**
  * Interface that signals that a distribution can compute the probability density function
  * for a particular point.
+ * @param <P> the type of the point at which density is to be computed, this
+ * may be for example <code>Double</code>
  * @version $Revision$ $Date$
  */
 public interface HasDensity<P> {

src/java/org/apache/commons/math/distribution/NormalDistributionImpl.java

@@ -35,12 +35,14 @@ public class NormalDistributionImpl extends AbstractContinuousDistribution
     /** Serializable version identifier */
     private static final long serialVersionUID = 8589540077390120676L;
 
+    /** &sqrt;(2 π) */
+    private static final double SQRT2PI = Math.sqrt(2 * Math.PI);
+
     /** The mean of this distribution. */
     private double mean = 0;
     
     /** The standard deviation of this distribution. */
     private double standardDeviation = 1;
-    private static final double SQRT2PI = Math.sqrt(2 * Math.PI);
 
     /**
      * Create a normal distribution using the given mean and standard deviation.

src/java/org/apache/commons/math/linear/DecompositionSolver.java

@@ -40,7 +40,7 @@ public interface DecompositionSolver extends Serializable {
 
     /**
      * Decompose a matrix.
-     * @param matrix
+     * @param matrix matrix to decompose
      * @exception InvalidMatrixException if matrix does not fulfill
      * the decomposition requirements (for example non-square matrix
      * for {@link LUDecomposition})

src/java/org/apache/commons/math/linear/EigenDecomposition.java

@@ -93,6 +93,7 @@ public interface EigenDecomposition extends DecompositionSolver {
 
     /**
      * Returns the i<sup>th</sup> eigenvalue of the original matrix.
+     * @param i index of the eigenvalue (counting from 0)
      * @return i<sup>th</sup> eigenvalue of the original matrix
      * @exception IllegalStateException if {@link
      * DecompositionSolver#decompose(RealMatrix) decompose} has not been called
@@ -103,6 +104,7 @@ public interface EigenDecomposition extends DecompositionSolver {
 
     /**
      * Returns a copy of the i<sup>th</sup> eigenvector of the original matrix.
+     * @param i index of the eigenvector (counting from 0)
      * @return copy of the i<sup>th</sup> eigenvector of the original matrix
      * @exception IllegalStateException if {@link
      * DecompositionSolver#decompose(RealMatrix) decompose} has not been called

src/java/org/apache/commons/math/linear/GershgorinCirclesUnion.java

@@ -75,13 +75,18 @@ class GershgorinCirclesUnion implements Comparable<GershgorinCirclesUnion> {
      * either circles union. It is mainly intended for circles unions
      * that {@link #intersects(GershgorinCirclesUnion) intersect}
      * each other beforehand.</p>
+     * @param other Gershgorin circles union to swallow
      */
     public void swallow(final GershgorinCirclesUnion other) {
         low  = Math.min(low,  other.low);
         high = Math.max(high, other.high);
     }
 
-    /** Comparator class for sorting intervals. */
+    /** Compare another Gershgorin circles union in interval start order.
+     * @param other Gershgorin circles union to compare to instance
+     * @return a negative, zero or positive value depending on the other
+     * union starting before, at same location or after instance
+     */
     public int compareTo(GershgorinCirclesUnion other) {
         return Double.compare(low, other.low);
     }

src/java/org/apache/commons/math/linear/LUDecompositionImpl.java

@@ -348,8 +348,10 @@ public class LUDecompositionImpl implements LUDecomposition {
      * <p>The A matrix is implicit here. It is </p>
      * @param b right-hand side of the equation A &times; X = B
      * @return a vector X such that A &times; X = B
-     * @throws IllegalArgumentException if matrices dimensions don't match
+     * @exception IllegalStateException if {@link #decompose(RealMatrix) decompose}
-     * @throws InvalidMatrixException if decomposed matrix is singular
+     * has not been called
+     * @exception IllegalArgumentException if matrices dimensions don't match
+     * @exception InvalidMatrixException if decomposed matrix is singular
      */
     public RealVectorImpl solve(RealVectorImpl b)
         throws IllegalStateException, IllegalArgumentException, InvalidMatrixException {

src/java/org/apache/commons/math/linear/SingularValueDecomposition.java

@@ -56,7 +56,7 @@ public interface SingularValueDecomposition extends DecompositionSolver {
 
     /**
      * Decompose a matrix to find its largest singular values.
-     * @param matrix
+     * @param matrix matrix to decompose
      * @param maxSingularValues maximal number of singular values to compute
      * @exception InvalidMatrixException (wrapping a {@link ConvergenceException}
      * if algorithm fails to converge

src/java/org/apache/commons/math/stat/regression/GLSMultipleLinearRegression.java

@@ -48,6 +48,11 @@ public class GLSMultipleLinearRegression extends AbstractMultipleLinearRegressio
     /** Inverse of covariance matrix. */
     private RealMatrix OmegaInverse;
 
+    /** Replace sample data, overriding any previous sample.
+     * @param y y values of the sample
+     * @param x x values of the sample
+     * @param covariance array representing the covariance matrix
+     */
     public void newSampleData(double[] y, double[][] x, double[][] covariance) {
         validateSampleData(x, y);
         newYSampleData(y);

src/java/org/apache/commons/math/stat/regression/OLSMultipleLinearRegression.java

@@ -58,7 +58,7 @@ public class OLSMultipleLinearRegression extends AbstractMultipleLinearRegressio
     /** Cached QR decomposition of X matrix */
     private QRDecomposition qr = null;
 
-    /*
+    /**
      * {@inheritDoc}
      * 
      * Computes and caches QR decomposition of the X matrix.