tighten checkstyle rules for import statements

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

checkstyle.xml

@@ -62,7 +62,7 @@
     <!-- Require hash code override when equals is -->
     <module name="EqualsHashCode"/>
     
-    <!-- Disallow unecessary instantiantion of Boolean, String -->
+    <!-- Disallow unnecessary instantiation of Boolean, String -->
     <module name="IllegalInstantiation">
       <property name="classes" value="java.lang.Boolean, java.lang.String"/>
     </module>
@@ -70,6 +70,11 @@
     <!-- Required for SuppressionCommentFilter below -->
     <module name="FileContentsHolder"/>
  
+    <!--  Import should be explicit, really needed and only from pure java packages -->
+    <module name="AvoidStarImport" />
+    <module name="UnusedImports" />
+    <module name="IllegalImport" />
+
   </module>
   
   <!-- Require package javadoc -->

src/main/java/org/apache/commons/math/analysis/polynomials/PolynomialFunctionNewtonForm.java

@@ -19,7 +19,6 @@ package org.apache.commons.math.analysis.polynomials;
 import org.apache.commons.math.FunctionEvaluationException;
 import org.apache.commons.math.MathRuntimeException;
 import org.apache.commons.math.analysis.UnivariateRealFunction;
-import org.apache.commons.math.analysis.interpolation.DividedDifferenceInterpolator;
 
 /**
  * Implements the representation of a real polynomial function in
@@ -198,7 +197,7 @@ public class PolynomialFunctionNewtonForm implements UnivariateRealFunction {
      * @param a the coefficients in Newton form formula
      * @param c the centers
      * @throws IllegalArgumentException if not valid
-     * @see DividedDifferenceInterpolator#computeDividedDifference(double[],
+     * @see org.apache.commons.math.analysis.interpolation.DividedDifferenceInterpolator#computeDividedDifference(double[],
      * double[])
      */
     protected static void verifyInputArray(double a[], double c[]) throws

src/main/java/org/apache/commons/math/linear/EigenDecompositionImpl.java

@@ -21,7 +21,6 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
-import org.apache.commons.math.ConvergenceException;
 import org.apache.commons.math.MathRuntimeException;
 import org.apache.commons.math.MaxIterationsExceededException;
 import org.apache.commons.math.util.MathUtils;
@@ -156,8 +155,8 @@ public class EigenDecompositionImpl implements EigenDecomposition {
      * @param splitTolerance tolerance on the off-diagonal elements relative to the
      * geometric mean to split the tridiagonal matrix (a suggested value is
      * {@link MathUtils#SAFE_MIN})
-     * @exception InvalidMatrixException (wrapping a {@link ConvergenceException}
+     * @exception InvalidMatrixException (wrapping a {@link
-     * if algorithm fails to converge
+     * org.apache.commons.math.ConvergenceException} if algorithm fails to converge
      */
     public EigenDecompositionImpl(final RealMatrix matrix,
                                   final double splitTolerance)
@@ -180,8 +179,8 @@ public class EigenDecompositionImpl implements EigenDecomposition {
      * @param splitTolerance tolerance on the off-diagonal elements relative to the
      * geometric mean to split the tridiagonal matrix (a suggested value is
      * {@link MathUtils#SAFE_MIN})
-     * @exception InvalidMatrixException (wrapping a {@link ConvergenceException}
+     * @exception InvalidMatrixException (wrapping a {@link
-     * if algorithm fails to converge
+     * org.apache.commons.math.ConvergenceException} if algorithm fails to converge
      */
     public EigenDecompositionImpl(final double[] main, double[] secondary,
             final double splitTolerance)
@@ -226,8 +225,8 @@ public class EigenDecompositionImpl implements EigenDecomposition {
 
     /**
      * Decompose a tridiagonal symmetric matrix. 
-     * @exception InvalidMatrixException (wrapping a {@link ConvergenceException}
+     * @exception InvalidMatrixException (wrapping a {@link
-     * if algorithm fails to converge
+     * org.apache.commons.math.ConvergenceException} if algorithm fails to converge
      */
     private void decompose() {
 

src/main/java/org/apache/commons/math/linear/SingularValueDecompositionImpl.java

@@ -17,7 +17,6 @@
 
 package org.apache.commons.math.linear;
 
-import org.apache.commons.math.ConvergenceException;
 import org.apache.commons.math.MathRuntimeException;
 import org.apache.commons.math.util.MathUtils;
 
@@ -79,8 +78,8 @@ public class SingularValueDecompositionImpl implements SingularValueDecompositio
     /**
      * Calculates the Singular Value Decomposition of the given matrix. 
      * @param matrix The matrix to decompose.
-     * @exception InvalidMatrixException (wrapping a {@link ConvergenceException}
+     * @exception InvalidMatrixException (wrapping a {@link
-     * if algorithm fails to converge
+     * org.apache.commons.math.ConvergenceException} if algorithm fails to converge
      */
     public SingularValueDecompositionImpl(RealMatrix matrix)
         throws InvalidMatrixException {

src/main/java/org/apache/commons/math/ode/ContinuousOutputModel.java

@@ -22,7 +22,6 @@ import java.util.List;
 import java.io.Serializable;
 
 import org.apache.commons.math.MathRuntimeException;
-import org.apache.commons.math.ode.nonstiff.AdaptiveStepsizeIntegrator;
 import org.apache.commons.math.ode.sampling.StepHandler;
 import org.apache.commons.math.ode.sampling.StepInterpolator;
 
@@ -75,7 +74,8 @@ import org.apache.commons.math.ode.sampling.StepInterpolator;
  * ContinuousOutputModel instance can be important if the state vector
  * is large, if the integration interval is long or if the steps are
  * small (which can result from small tolerance settings in {@link
- * AdaptiveStepsizeIntegrator adaptive step size integrators}).</p>
+ * org.apache.commons.math.ode.nonstiff.AdaptiveStepsizeIntegrator adaptive
+ * step size integrators}).</p>
  *
  * @see StepHandler
  * @see StepInterpolator

src/main/java/org/apache/commons/math/ode/FirstOrderIntegrator.java

@@ -17,9 +17,6 @@
 
 package org.apache.commons.math.ode;
 
-import org.apache.commons.math.ode.events.EventHandler;
-import org.apache.commons.math.ode.sampling.StepHandler;
-
 /** This interface represents a first order integrator for
  * differential equations.
 
@@ -29,8 +26,8 @@ import org.apache.commons.math.ode.sampling.StepHandler;
  * FirstOrderDifferentialEquations} interface.</p>
  *
  * @see FirstOrderDifferentialEquations
- * @see StepHandler
+ * @see org.apache.commons.math.ode.sampling.StepHandler
- * @see EventHandler
+ * @see org.apache.commons.math.ode.events.EventHandler
  * @version $Revision$ $Date$
  * @since 1.2
  */
@@ -50,7 +47,8 @@ public interface FirstOrderIntegrator extends ODEIntegrator {
    * @param y placeholder where to put the state vector at each successful
    *  step (and hence at the end of integration), can be the same object as y0
    * @return stop time, will be the same as target time if integration reached its
-   * target, but may be different if some {@link EventHandler} stops it at some point.
+   * target, but may be different if some {@link
+   * org.apache.commons.math.ode.events.EventHandler} stops it at some point.
    * @throws IntegratorException if the integrator cannot perform integration
    * @throws DerivativeException this exception is propagated to the caller if
    * the underlying user function triggers one

src/main/java/org/apache/commons/math/ode/events/EventHandler.java

@@ -17,9 +17,6 @@
 
 package org.apache.commons.math.ode.events;
 
-import org.apache.commons.math.ode.FirstOrderDifferentialEquations;
-import org.apache.commons.math.ode.sampling.StepHandler;
-
 /** This interface represents a handler for discrete events triggered
  * during ODE integration.
  *
@@ -73,7 +70,8 @@ public interface EventHandler  {
    * #eventOccurred eventOccurred} method when the integration should
    * go on after the event ending the current step, with a new derivatives
    * vector (which will be retrieved thanks to the {@link
-   * FirstOrderDifferentialEquations#computeDerivatives} method).</p>
+   * org.apache.commons.math.ode.FirstOrderDifferentialEquations#computeDerivatives}
+   * method).</p>
    */
   public static final int RESET_DERIVATIVES = 2;
 
@@ -107,16 +105,16 @@ public interface EventHandler  {
    * step handler itself is called. It allows the user to update his
    * internal data to acknowledge the fact the event has been handled
    * (for example setting a flag in the {@link
-   * FirstOrderDifferentialEquations differential equations} to switch
+   * org.apache.commons.math.ode.FirstOrderDifferentialEquations
-   * the derivatives computation in case of discontinuity), or to
+   * differential equations} to switch the derivatives computation in
-   * direct the integrator to either stop or continue integration,
+   * case of discontinuity), or to direct the integrator to either stop
-   * possibly with a reset state or derivatives.</p>
+   * or continue integration, possibly with a reset state or derivatives.</p>
 
    * <ul>
    *   <li>if {@link #STOP} is returned, the step handler will be called
    *   with the <code>isLast</code> flag of the {@link
-   *   StepHandler#handleStep handleStep} method set to true and the
+   *   org.apache.commons.math.ode.sampling.StepHandler#handleStep handleStep}
-   *   integration will be stopped,</li>
+   *   method set to true and the integration will be stopped,</li>
    *   <li>if {@link #RESET_STATE} is returned, the {@link #resetState
    *   resetState} method will be called once the step handler has
    *   finished its task, and the integrator will also recompute the

src/main/java/org/apache/commons/math/ode/nonstiff/EulerStepInterpolator.java

@@ -18,7 +18,6 @@
 package org.apache.commons.math.ode.nonstiff;
 
 import org.apache.commons.math.ode.DerivativeException;
-import org.apache.commons.math.ode.sampling.AbstractStepInterpolator;
 import org.apache.commons.math.ode.sampling.StepInterpolator;
 
 /**
@@ -48,12 +47,14 @@ class EulerStepInterpolator
 
   /** Simple constructor.
    * This constructor builds an instance that is not usable yet, the
-   * {@link AbstractStepInterpolator#reinitialize} method should be called
+   * {@link
-   * before using the instance in order to initialize the internal arrays. This
+   * org.apache.commons.math.ode.sampling.AbstractStepInterpolator#reinitialize}
-   * constructor is used only in order to delay the initialization in
+   * method should be called before using the instance in order to
-   * some cases. The {@link RungeKuttaIntegrator} class uses the
+   * initialize the internal arrays. This constructor is used only
-   * prototyping design pattern to create the step interpolators by
+   * in order to delay the initialization in some cases. The {@link
-   * cloning an uninitialized model and latter initializing the copy.
+   * RungeKuttaIntegrator} class uses the prototyping design pattern
+   * to create the step interpolators by cloning an uninitialized model
+   * and later initializing the copy.
    */
   public EulerStepInterpolator() {
   }

src/main/java/org/apache/commons/math/ode/nonstiff/GillStepInterpolator.java

@@ -18,7 +18,6 @@
 package org.apache.commons.math.ode.nonstiff;
 
 import org.apache.commons.math.ode.DerivativeException;
-import org.apache.commons.math.ode.sampling.AbstractStepInterpolator;
 import org.apache.commons.math.ode.sampling.StepInterpolator;
 
 /**
@@ -50,12 +49,14 @@ class GillStepInterpolator
     
   /** Simple constructor.
    * This constructor builds an instance that is not usable yet, the
-   * {@link AbstractStepInterpolator#reinitialize} method should be called
+   * {@link
-   * before using the instance in order to initialize the internal arrays. This
+   * org.apache.commons.math.ode.sampling.AbstractStepInterpolator#reinitialize}
-   * constructor is used only in order to delay the initialization in
+   * method should be called before using the instance in order to
-   * some cases. The {@link RungeKuttaIntegrator} class uses the
+   * initialize the internal arrays. This constructor is used only
-   * prototyping design pattern to create the step interpolators by
+   * in order to delay the initialization in some cases. The {@link
-   * cloning an uninitialized model and latter initializing the copy.
+   * RungeKuttaIntegrator} class uses the prototyping design pattern
+   * to create the step interpolators by cloning an uninitialized model
+   * and later initializing the copy.
    */
   public GillStepInterpolator() {
   }

src/main/java/org/apache/commons/math/ode/nonstiff/HighamHall54StepInterpolator.java

@@ -18,7 +18,6 @@
 package org.apache.commons.math.ode.nonstiff;
 
 import org.apache.commons.math.ode.DerivativeException;
-import org.apache.commons.math.ode.sampling.AbstractStepInterpolator;
 import org.apache.commons.math.ode.sampling.StepInterpolator;
 
 /**
@@ -36,12 +35,14 @@ class HighamHall54StepInterpolator
 
   /** Simple constructor.
    * This constructor builds an instance that is not usable yet, the
-   * {@link AbstractStepInterpolator#reinitialize} method should be called
+   * {@link
-   * before using the instance in order to initialize the internal arrays. This
+   * org.apache.commons.math.ode.sampling.AbstractStepInterpolator#reinitialize}
-   * constructor is used only in order to delay the initialization in
+   * method should be called before using the instance in order to
-   * some cases. The {@link EmbeddedRungeKuttaIntegrator} uses the
+   * initialize the internal arrays. This constructor is used only
-   * prototyping design pattern to create the step interpolators by
+   * in order to delay the initialization in some cases. The {@link
-   * cloning an uninitialized model and latter initializing the copy.
+   * EmbeddedRungeKuttaIntegrator} uses the prototyping design pattern
+   * to create the step interpolators by cloning an uninitialized model
+   * and later initializing the copy.
    */
   public HighamHall54StepInterpolator() {
     super();

src/main/java/org/apache/commons/math/ode/nonstiff/MidpointStepInterpolator.java

@@ -18,7 +18,6 @@
 package org.apache.commons.math.ode.nonstiff;
 
 import org.apache.commons.math.ode.DerivativeException;
-import org.apache.commons.math.ode.sampling.AbstractStepInterpolator;
 import org.apache.commons.math.ode.sampling.StepInterpolator;
 
 /**
@@ -47,12 +46,14 @@ class MidpointStepInterpolator
     
   /** Simple constructor.
    * This constructor builds an instance that is not usable yet, the
-   * {@link AbstractStepInterpolator#reinitialize} method should be called
+   * {@link
-   * before using the instance in order to initialize the internal arrays. This
+   * org.apache.commons.math.ode.sampling.AbstractStepInterpolator#reinitialize}
-   * constructor is used only in order to delay the initialization in
+   * method should be called before using the instance in order to
-   * some cases. The {@link RungeKuttaIntegrator} class uses the
+   * initialize the internal arrays. This constructor is used only
-   * prototyping design pattern to create the step interpolators by
+   * in order to delay the initialization in some cases. The {@link
-   * cloning an uninitialized model and latter initializing the copy.
+   * RungeKuttaIntegrator} class uses the prototyping design pattern
+   * to create the step interpolators by cloning an uninitialized model
+   * and later initializing the copy.
    */
   public MidpointStepInterpolator() {
   }

src/main/java/org/apache/commons/math/ode/nonstiff/ThreeEighthesStepInterpolator.java

@@ -18,7 +18,6 @@
 package org.apache.commons.math.ode.nonstiff;
 
 import org.apache.commons.math.ode.DerivativeException;
-import org.apache.commons.math.ode.sampling.AbstractStepInterpolator;
 import org.apache.commons.math.ode.sampling.StepInterpolator;
 
 /**
@@ -52,12 +51,14 @@ class ThreeEighthesStepInterpolator
     
   /** Simple constructor.
    * This constructor builds an instance that is not usable yet, the
-   * {@link AbstractStepInterpolator#reinitialize} method should be called
+   * {@link
-   * before using the instance in order to initialize the internal arrays. This
+   * org.apache.commons.math.ode.sampling.AbstractStepInterpolator#reinitialize}
-   * constructor is used only in order to delay the initialization in
+   * method should be called before using the instance in order to
-   * some cases. The {@link RungeKuttaIntegrator} class uses the
+   * initialize the internal arrays. This constructor is used only
-   * prototyping design pattern to create the step interpolators by
+   * in order to delay the initialization in some cases. The {@link
-   * cloning an uninitialized model and latter initializing the copy.
+   * RungeKuttaIntegrator} class uses the prototyping design pattern
+   * to create the step interpolators by cloning an uninitialized model
+   * and later initializing the copy.
    */
   public ThreeEighthesStepInterpolator() {
   }

src/main/java/org/apache/commons/math/ode/sampling/AbstractStepInterpolator.java

@@ -23,9 +23,6 @@ import java.io.ObjectOutput;
 
 import org.apache.commons.math.MathRuntimeException;
 import org.apache.commons.math.ode.DerivativeException;
-import org.apache.commons.math.ode.FirstOrderIntegrator;
-import org.apache.commons.math.ode.SecondOrderIntegrator;
-import org.apache.commons.math.ode.nonstiff.EmbeddedRungeKuttaIntegrator;
 
 /** This abstract class represents an interpolator over the last step
  * during an ODE integration.
@@ -35,8 +32,8 @@ import org.apache.commons.math.ode.nonstiff.EmbeddedRungeKuttaIntegrator;
  * retrieve the state vector at intermediate times between the
  * previous and the current grid points (dense output).</p>
  *
- * @see FirstOrderIntegrator
+ * @see org.apache.commons.math.ode.FirstOrderIntegrator
- * @see SecondOrderIntegrator
+ * @see org.apache.commons.math.ode.SecondOrderIntegrator
  * @see StepHandler
  *
  * @version $Revision$ $Date$
@@ -84,9 +81,10 @@ public abstract class AbstractStepInterpolator
    * instance in order to initialize the internal arrays. This
    * constructor is used only in order to delay the initialization in
    * some cases. As an example, the {@link
-   * EmbeddedRungeKuttaIntegrator} uses the prototyping design pattern
+   * org.apache.commons.math.ode.nonstiff.EmbeddedRungeKuttaIntegrator}
-   * to create the step interpolators by cloning an uninitialized
+   * class uses the prototyping design pattern to create the step
-   * model and latter initializing the copy.
+   * interpolators by cloning an uninitialized model and latter
+   * initializing the copy.
    */
   protected AbstractStepInterpolator() {
     previousTime            = Double.NaN;

src/main/java/org/apache/commons/math/ode/sampling/DummyStepInterpolator.java

@@ -22,7 +22,6 @@ import java.io.ObjectInput;
 import java.io.ObjectOutput;
 
 import org.apache.commons.math.ode.DerivativeException;
-import org.apache.commons.math.ode.nonstiff.EmbeddedRungeKuttaIntegrator;
 
 /** This class is a step interpolator that does nothing.
  *
@@ -47,9 +46,9 @@ public class DummyStepInterpolator
    * should be called before using the instance in order to initialize
    * the internal arrays. This constructor is used only in order to delay
    * the initialization in some cases. As an example, the {@link
-   * EmbeddedRungeKuttaIntegrator} uses the prototyping design pattern
+   * org.apache.commons.math.ode.nonstiff.EmbeddedRungeKuttaIntegrator} uses
-   * to create the step interpolators by cloning an uninitialized
+   * the prototyping design pattern to create the step interpolators by
-   * model and latter initializing the copy.
+   * cloning an uninitialized model and latter initializing the copy.
    */
   public DummyStepInterpolator() {
     super();

src/main/java/org/apache/commons/math/ode/sampling/StepHandler.java

@@ -17,10 +17,7 @@
 
 package org.apache.commons.math.ode.sampling;
 
-import org.apache.commons.math.ode.ContinuousOutputModel;
 import org.apache.commons.math.ode.DerivativeException;
-import org.apache.commons.math.ode.FirstOrderIntegrator;
-import org.apache.commons.math.ode.SecondOrderIntegrator;
 
 /**
  * This interface represents a handler that should be called after
@@ -35,8 +32,8 @@ import org.apache.commons.math.ode.SecondOrderIntegrator;
  * last one, store the points in an ephemeris, or forward them to
  * specialized processing or output methods.</p>
  *
- * @see FirstOrderIntegrator
+ * @see org.apache.commons.math.ode.FirstOrderIntegrator
- * @see SecondOrderIntegrator
+ * @see org.apache.commons.math.ode.SecondOrderIntegrator
  * @see StepInterpolator
  * @version $Revision$ $Date$
  * @since 1.2
@@ -67,11 +64,11 @@ public interface StepHandler {
    * object on each call, so if the instance wants to keep it across
    * all calls (for example to provide at the end of the integration a
    * continuous model valid throughout the integration range, as the
-   * {@link ContinuousOutputModel ContinuousOutputModel} class does),
+   * {@link org.apache.commons.math.ode.ContinuousOutputModel
-   * it should build a local copy using the clone method of the
+   * ContinuousOutputModel} class does), it should build a local copy
-   * interpolator and store this copy. Keeping only a reference to the
+   * using the clone method of the interpolator and store this copy.
-   * interpolator and reusing it will result in unpredictable
+   * Keeping only a reference to the interpolator and reusing it will
-   * behaviour (potentially crashing the application).
+   * result in unpredictable behavior (potentially crashing the application).
    * @param isLast true if the step is the last one
    * @throws DerivativeException this exception is propagated to the
    * caller if the underlying user function triggers one

src/main/java/org/apache/commons/math/ode/sampling/StepInterpolator.java

@@ -20,8 +20,6 @@ package org.apache.commons.math.ode.sampling;
 import java.io.Externalizable;
 
 import org.apache.commons.math.ode.DerivativeException;
-import org.apache.commons.math.ode.FirstOrderIntegrator;
-import org.apache.commons.math.ode.SecondOrderIntegrator;
 
 /** This interface represents an interpolator over the last step
  * during an ODE integration.
@@ -41,8 +39,8 @@ import org.apache.commons.math.ode.SecondOrderIntegrator;
  * {@link #copy()} method.
  * </p>
  *
- * @see FirstOrderIntegrator
+ * @see org.apache.commons.math.ode.FirstOrderIntegrator
- * @see SecondOrderIntegrator
+ * @see org.apache.commons.math.ode.SecondOrderIntegrator
  * @see StepHandler
  * @version $Revision$ $Date$
  * @since 1.2

src/main/java/org/apache/commons/math/optimization/MultiStartDifferentiableMultivariateRealOptimizer.java

@@ -20,7 +20,6 @@ package org.apache.commons.math.optimization;
 import java.util.Arrays;
 import java.util.Comparator;
 
-import org.apache.commons.math.ConvergenceException;
 import org.apache.commons.math.FunctionEvaluationException;
 import org.apache.commons.math.MathRuntimeException;
 import org.apache.commons.math.analysis.DifferentiableMultivariateRealFunction;
@@ -109,9 +108,9 @@ public class MultiStartDifferentiableMultivariateRealOptimizer
      * corresponding to the runs that did not converge. This means all
      * elements will be null if the {@link #optimize(DifferentiableMultivariateRealFunction,
      * GoalType, double[]) optimize} method did throw a {@link
-     * ConvergenceException ConvergenceException}). This also means that
+     * org.apache.commons.math.ConvergenceException ConvergenceException}).
-     * if the first element is non null, it is the best point found across
+     * This also means that if the first element is non null, it is the best
-     * all starts.</p>
+     * point found across all starts.</p>
      * @return array containing the optima
      * @exception IllegalStateException if {@link #optimize(DifferentiableMultivariateRealFunction,
      * GoalType, double[]) optimize} has not been called

src/main/java/org/apache/commons/math/optimization/MultiStartDifferentiableMultivariateVectorialOptimizer.java

@@ -20,7 +20,6 @@ package org.apache.commons.math.optimization;
 import java.util.Arrays;
 import java.util.Comparator;
 
-import org.apache.commons.math.ConvergenceException;
 import org.apache.commons.math.FunctionEvaluationException;
 import org.apache.commons.math.MathRuntimeException;
 import org.apache.commons.math.analysis.DifferentiableMultivariateVectorialFunction;
@@ -113,9 +112,9 @@ public class MultiStartDifferentiableMultivariateVectorialOptimizer
      * corresponding to the runs that did not converge. This means all
      * elements will be null if the {@link #optimize(DifferentiableMultivariateVectorialFunction,
      * double[], double[], double[]) optimize} method did throw a {@link
-     * ConvergenceException ConvergenceException}). This also means that
+     * org.apache.commons.math.ConvergenceException ConvergenceException}).
-     * if the first element is non null, it is the best point found across
+     * This also means that if the first element is non null, it is the best
-     * all starts.</p>
+     * point found across all starts.</p>
      * @return array containing the optima
      * @exception IllegalStateException if {@link #optimize(DifferentiableMultivariateVectorialFunction,
      * double[], double[], double[]) optimize} has not been called

src/main/java/org/apache/commons/math/optimization/MultiStartMultivariateRealOptimizer.java

@@ -20,7 +20,6 @@ package org.apache.commons.math.optimization;
 import java.util.Arrays;
 import java.util.Comparator;
 
-import org.apache.commons.math.ConvergenceException;
 import org.apache.commons.math.FunctionEvaluationException;
 import org.apache.commons.math.MathRuntimeException;
 import org.apache.commons.math.analysis.MultivariateRealFunction;
@@ -104,9 +103,9 @@ public class MultiStartMultivariateRealOptimizer
      * corresponding to the runs that did not converge. This means all
      * elements will be null if the {@link #optimize(MultivariateRealFunction,
      * GoalType, double[]) optimize} method did throw a {@link
-     * ConvergenceException ConvergenceException}). This also means that
+     * org.apache.commons.math.ConvergenceException ConvergenceException}).
-     * if the first element is non null, it is the best point found across
+     * This also means that if the first element is non null, it is the best
-     * all starts.</p>
+     * point found across all starts.</p>
      * @return array containing the optima
      * @exception IllegalStateException if {@link #optimize(MultivariateRealFunction,
      * GoalType, double[]) optimize} has not been called

src/main/java/org/apache/commons/math/optimization/RealPointValuePair.java

@@ -19,13 +19,12 @@ package org.apache.commons.math.optimization;
 
 import java.io.Serializable;
 
-import org.apache.commons.math.analysis.MultivariateRealFunction;
 
 /** 
  * This class holds a point and the value of an objective function at this point.
  * <p>This is a simple immutable container.</p>
  * @see VectorialPointValuePair
- * @see MultivariateRealFunction
+ * @see org.apache.commons.math.analysis.MultivariateRealFunction
  * @version $Revision$ $Date$
  * @since 2.0
  */

src/main/java/org/apache/commons/math/optimization/VectorialPointValuePair.java

@@ -19,13 +19,11 @@ package org.apache.commons.math.optimization;
 
 import java.io.Serializable;
 
-import org.apache.commons.math.analysis.MultivariateVectorialFunction;
-
 /** 
  * This class holds a point and the vectorial value of an objective function at this point.
  * <p>This is a simple immutable container.</p>
  * @see RealPointValuePair
- * @see MultivariateVectorialFunction
+ * @see org.apache.commons.math.analysis.MultivariateVectorialFunction
  * @version $Revision$ $Date$
  * @since 2.0
  */

src/main/java/org/apache/commons/math/optimization/general/GaussNewtonOptimizer.java

@@ -25,7 +25,6 @@ import org.apache.commons.math.linear.LUDecompositionImpl;
 import org.apache.commons.math.linear.QRDecompositionImpl;
 import org.apache.commons.math.linear.RealMatrix;
 import org.apache.commons.math.optimization.OptimizationException;
-import org.apache.commons.math.optimization.SimpleVectorialValueChecker;
 import org.apache.commons.math.optimization.VectorialPointValuePair;
 
 /** 
@@ -48,7 +47,8 @@ public class GaussNewtonOptimizer extends AbstractLeastSquaresOptimizer {
     private final boolean useLU;
 
     /** Simple constructor with default settings.
-     * <p>The convergence check is set to a {@link SimpleVectorialValueChecker}
+     * <p>The convergence check is set to a {@link
+     * org.apache.commons.math.optimization.SimpleVectorialValueChecker}
      * and the maximal number of evaluation is set to
      * {@link AbstractLeastSquaresOptimizer#DEFAULT_MAX_ITERATIONS}.
      * @param useLU if true, the normal equations will be solved using LU

src/main/java/org/apache/commons/math/optimization/general/NonLinearConjugateGradientOptimizer.java

@@ -26,7 +26,6 @@ import org.apache.commons.math.optimization.GoalType;
 import org.apache.commons.math.optimization.OptimizationException;
 import org.apache.commons.math.optimization.DifferentiableMultivariateRealOptimizer;
 import org.apache.commons.math.optimization.RealPointValuePair;
-import org.apache.commons.math.optimization.SimpleVectorialValueChecker;
 
 /** 
  * Non-linear conjugate gradient optimizer.
@@ -58,7 +57,8 @@ public class NonLinearConjugateGradientOptimizer
     private double initialStep;
 
     /** Simple constructor with default settings.
-     * <p>The convergence check is set to a {@link SimpleVectorialValueChecker}
+     * <p>The convergence check is set to a {@link
+     * org.apache.commons.math.optimization.SimpleVectorialValueChecker}
      * and the maximal number of iterations is set to
      * {@link AbstractScalarDifferentiableOptimizer#DEFAULT_MAX_ITERATIONS}.
      * @param updateFormula formula to use for updating the &beta; parameter,

src/main/java/org/apache/commons/math/transform/FastSineTransformer.java

@@ -16,10 +16,10 @@
  */
 package org.apache.commons.math.transform;
 
-import org.apache.commons.math.analysis.*;
-import org.apache.commons.math.complex.*;
 import org.apache.commons.math.FunctionEvaluationException;
 import org.apache.commons.math.MathRuntimeException;
+import org.apache.commons.math.analysis.UnivariateRealFunction;
+import org.apache.commons.math.complex.Complex;
 
 /**
  * Implements the <a href="http://documents.wolfram.com/v5/Add-onsLinks/

src/main/java/org/apache/commons/math/transform/RealTransformer.java

@@ -18,7 +18,6 @@ package org.apache.commons.math.transform;
 
 import org.apache.commons.math.FunctionEvaluationException;
 import org.apache.commons.math.analysis.UnivariateRealFunction;
-import org.apache.commons.math.complex.Complex;
 
 /**
  * Interface for one-dimensional data sets transformations producing real results.
@@ -26,8 +25,8 @@ import org.apache.commons.math.complex.Complex;
  * {@link FastCosineTransformer cosine transform} or {@link
  * FastHadamardTransformer Hadamard transform}. {@link FastFourierTransformer
  * Fourier transform} is of a different kind and does not implement this
- * interface since it produces {@link Complex complex} results instead of real
+ * interface since it produces {@link org.apache.commons.math.complex.Complex complex}
- * ones.
+ * results instead of real ones.
  * </p>
  * @version $Revision$ $Date$
  * @since 2.0