Javadoc only. Added @since tags.

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

src/java/org/apache/commons/math/ArgumentOutsideDomainException.java

@@ -20,6 +20,7 @@ package org.apache.commons.math;
 /**
  * Error thrown when a method is called with an out of bounds argument.
  *
+ * @since 1.2
  * @version $Revision$ $Date$
  */
 public class ArgumentOutsideDomainException extends FunctionEvaluationException {

src/java/org/apache/commons/math/ConvergenceException.java

@@ -39,6 +39,7 @@ public class ConvergenceException extends MathException {
      * Message formatting is delegated to {@link java.text.MessageFormat}.
      * @param pattern format specifier
      * @param arguments format arguments
+     * @since 1.2
      */
     public ConvergenceException(String pattern, Object[] arguments) {
         super(pattern, arguments);
@@ -58,6 +59,7 @@ public class ConvergenceException extends MathException {
      * @param pattern format specifier
      * @param arguments format arguments
      * @param cause  the exception or error that caused this exception to be thrown
+     * @since 1.2
      */
     public ConvergenceException(String pattern, Object[] arguments, Throwable cause) {
         super(pattern, arguments, cause);

src/java/org/apache/commons/math/DimensionMismatchException.java

@@ -18,6 +18,8 @@ package org.apache.commons.math;
 
 /**
  * Error thrown when two dimensions differ.
+ * 
+ * @since 1.2
  * @version $Revision$ $Date$
  */
 public class DimensionMismatchException extends MathException {

src/java/org/apache/commons/math/DuplicateSampleAbscissaException.java

@@ -18,6 +18,8 @@ package org.apache.commons.math;
 
 /**
  * Exeption thrown when a sample contains several entries at the same abscissa.
+ * 
+ * @since 1.2
  * @version $Revision$ $Date$
  */
 public class DuplicateSampleAbscissaException extends MathException  {

src/java/org/apache/commons/math/FunctionEvaluationException.java

@@ -63,6 +63,7 @@ public class FunctionEvaluationException extends MathException  {
      * @param argument  the failing function argument 
      * @param pattern format specifier
      * @param arguments format arguments
+     * @since 1.2
      */
     public FunctionEvaluationException(double argument,
                                        String pattern, Object[] arguments) {
@@ -89,6 +90,7 @@ public class FunctionEvaluationException extends MathException  {
      * Message formatting is delegated to {@link java.text.MessageFormat}.
      * @param argument  the failing function argument 
      * @param cause  the exception or error that caused this exception to be thrown
+     * @since 1.2
      */
     public FunctionEvaluationException(double argument, Throwable cause) {
         super(cause);
@@ -102,6 +104,7 @@ public class FunctionEvaluationException extends MathException  {
      * @param pattern format specifier
      * @param arguments format arguments
      * @param cause  the exception or error that caused this exception to be thrown
+     * @since 1.2
      */
     public FunctionEvaluationException(double argument,
                                        String pattern, Object[] arguments,

src/java/org/apache/commons/math/MathConfigurationException.java

@@ -47,6 +47,7 @@ public class MathConfigurationException extends MathException implements Seriali
      * Message formatting is delegated to {@link java.text.MessageFormat}.
      * @param pattern format specifier
      * @param arguments format arguments
+     * @since 1.2
      */
     public MathConfigurationException(String pattern, Object[] arguments) {
         super(pattern, arguments);
@@ -76,6 +77,7 @@ public class MathConfigurationException extends MathException implements Seriali
      * @param pattern format specifier
      * @param arguments format arguments
      * @param cause  the exception or error that caused this exception to be thrown
+     * @since 1.2
      */
     public MathConfigurationException(String pattern, Object[] arguments, Throwable cause) {
         super(pattern, arguments, cause);

src/java/org/apache/commons/math/MathException.java

@@ -191,8 +191,9 @@ public class MathException extends Exception {
      * Message formatting is delegated to {@link java.text.MessageFormat}.
      * @param pattern format specifier
      * @param arguments format arguments
-     * @param rootCause  the exception or error that caused this exception
-     *                   to be thrown.
+     * @param rootCause the exception or error that caused this exception
+     * to be thrown.
+     * @since 1.2
      */
     public MathException(String pattern, Object[] arguments, Throwable rootCause) {
       super(buildMessage(pattern, arguments, Locale.US));
@@ -204,6 +205,7 @@ public class MathException extends Exception {
     /** Gets the pattern used to build the message of this throwable.
      *
      * @return the pattern used to build the message of this throwable
+     * @since 1.2
      */
     public String getPattern() {
         return pattern;
@@ -212,6 +214,7 @@ public class MathException extends Exception {
     /** Gets the arguments used to build the message of this throwable.
      *
      * @return the arguments used to build the message of this throwable
+     * @since 1.2
      */
     public Object[] getArguments() {
         return (Object[]) arguments.clone();
@@ -222,6 +225,7 @@ public class MathException extends Exception {
      * @param locale Locale in which the message should be translated
      * 
      * @return localized message
+     * @since 1.2
      */
     public String getMessage(Locale locale) {
         return (pattern == null) ? null : buildMessage(pattern, arguments, locale);

src/java/org/apache/commons/math/MaxIterationsExceededException.java

@@ -24,6 +24,7 @@ import org.apache.commons.math.ConvergenceException;
  * number of iterations.
  *
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public class MaxIterationsExceededException extends ConvergenceException {
 

src/java/org/apache/commons/math/MessagesResources_fr.java

@@ -19,18 +19,22 @@ package org.apache.commons.math;
 
 import java.util.ListResourceBundle;
 
-/** French localization message resources for the commons-math library.
+/** 
+ * French localization message resources for the commons-math library.
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public class MessagesResources_fr
   extends ListResourceBundle {
 
-  /** Simple constructor.
+  /** 
+   * Simple constructor.
    */
   public MessagesResources_fr() {
   }
 
-  /** Get the non-translated/translated messages arrays from this resource bundle.
+  /** 
+   * Get the non-translated/translated messages arrays from this resource bundle.
    * @return non-translated/translated messages arrays
    */
   public Object[][] getContents() {

src/java/org/apache/commons/math/analysis/DividedDifferenceInterpolator.java

@@ -31,6 +31,7 @@ import org.apache.commons.math.DuplicateSampleAbscissaException;
  * this class provides an easy-to-use interface to it.</p>
  *
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public class DividedDifferenceInterpolator implements UnivariateRealInterpolator,
     Serializable {

src/java/org/apache/commons/math/analysis/LaguerreSolver.java

@@ -31,6 +31,7 @@ import org.apache.commons.math.complex.Complex;
  * approximation and be able to solve all roots from that point.</p>
  *
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public class LaguerreSolver extends UnivariateRealSolverImpl {
 

src/java/org/apache/commons/math/analysis/MullerSolver.java

@@ -31,6 +31,7 @@ import org.apache.commons.math.util.MathUtils;
  * real zeros, using different ways to bypass complex arithmetics.</p>
  *
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public class MullerSolver extends UnivariateRealSolverImpl {
 

src/java/org/apache/commons/math/analysis/NevilleInterpolator.java

@@ -29,6 +29,7 @@ import org.apache.commons.math.MathException;
  * this class provides an easy-to-use interface to it.</p>
  *
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public class NevilleInterpolator implements UnivariateRealInterpolator,
     Serializable {

src/java/org/apache/commons/math/analysis/PolynomialFunctionLagrangeForm.java

@@ -31,6 +31,7 @@ import org.apache.commons.math.FunctionEvaluationException;
  * to work well. Otherwise, consider using splines instead.</p>
  *
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public class PolynomialFunctionLagrangeForm implements UnivariateRealFunction,
     Serializable {

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

@@ -30,6 +30,7 @@ import org.apache.commons.math.FunctionEvaluationException;
  * Note that the length of a[] is one more than the length of c[]</p>
  *
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public class PolynomialFunctionNewtonForm implements UnivariateRealFunction,
     Serializable {

src/java/org/apache/commons/math/analysis/RiddersSolver.java

@@ -30,6 +30,7 @@ import org.apache.commons.math.util.MathUtils;
  * The function should be continuous but not necessarily smooth.</p>
  *  
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public class RiddersSolver extends UnivariateRealSolverImpl {
 

src/java/org/apache/commons/math/analysis/RombergIntegrator.java

@@ -30,6 +30,7 @@ import org.apache.commons.math.MaxIterationsExceededException;
  * is a special case of k = 2.</p>
  *  
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public class RombergIntegrator extends UnivariateRealIntegratorImpl {
 

src/java/org/apache/commons/math/analysis/SimpsonIntegrator.java

@@ -29,6 +29,7 @@ import org.apache.commons.math.MaxIterationsExceededException;
  * calculate the Simpson's rule of alternating 2/3 and 4/3.</p>
  *  
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public class SimpsonIntegrator extends UnivariateRealIntegratorImpl {
 

src/java/org/apache/commons/math/analysis/TrapezoidIntegrator.java

@@ -28,6 +28,7 @@ import org.apache.commons.math.MaxIterationsExceededException;
  * The function should be integrable.</p>
  *  
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public class TrapezoidIntegrator extends UnivariateRealIntegratorImpl {
 

src/java/org/apache/commons/math/analysis/UnivariateRealIntegrator.java

@@ -23,6 +23,7 @@ import org.apache.commons.math.FunctionEvaluationException;
  * Interface for univariate real integration algorithms.
  *  
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public interface UnivariateRealIntegrator {
 

src/java/org/apache/commons/math/analysis/UnivariateRealIntegratorImpl.java

@@ -22,6 +22,7 @@ import java.io.Serializable;
  * Provide a default implementation for several generic functions.
  *  
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public abstract class UnivariateRealIntegratorImpl implements
     UnivariateRealIntegrator, Serializable {

src/java/org/apache/commons/math/complex/Complex.java

@@ -34,7 +34,6 @@ import org.apache.commons.math.util.MathUtils;
  * or imaginary part - e.g., <pre>
  * <code>1 + NaNi  == NaN + i == NaN + NaNi.</code></pre></p>
  *
- * @author Apache Software Foundation
  * @version $Revision$ $Date$
  */
 public class Complex implements Serializable  {

src/java/org/apache/commons/math/estimation/AbstractEstimator.java

@@ -27,6 +27,7 @@ import org.apache.commons.math.linear.RealMatrixImpl;
  * <p>This base class handles the boilerplates methods associated to thresholds
  * settings, jacobian and error estimation.</p>
  * @version $Revision$ $Date$
+ * @since 1.2
  *
  */
 public abstract class AbstractEstimator implements Estimator {

src/java/org/apache/commons/math/estimation/EstimatedParameter.java

@@ -28,6 +28,7 @@ import java.io.Serializable;
  * satisfy convergence criterions specific to each solver.</p>
  *
  * @version $Revision$ $Date$
+ * @since 1.2
  *
  */
 

src/java/org/apache/commons/math/estimation/EstimationException.java

@@ -23,6 +23,7 @@ import org.apache.commons.math.MathException;
  * This class represents exceptions thrown by the estimation solvers.
  *
  * @version $Revision$ $Date$
+ * @since 1.2
  *
  */
 

src/java/org/apache/commons/math/estimation/EstimationProblem.java

@@ -39,6 +39,7 @@ package org.apache.commons.math.estimation;
  * @see WeightedMeasurement
  *
  * @version $Revision$ $Date$
+ * @since 1.2
  *
  */
 

src/java/org/apache/commons/math/estimation/Estimator.java

@@ -31,6 +31,7 @@ package org.apache.commons.math.estimation;
  * @see EstimationProblem
  *
  * @version $Revision$ $Date$
+ * @since 1.2
  *
  */
 

src/java/org/apache/commons/math/estimation/GaussNewtonEstimator.java

@@ -31,6 +31,7 @@ import org.apache.commons.math.linear.RealMatrixImpl;
  * Gauss-Newton algorithm.</p>
  *
  * @version $Revision$ $Date$
+ * @since 1.2
  *
  */
 

src/java/org/apache/commons/math/estimation/LevenbergMarquardtEstimator.java

@@ -94,7 +94,8 @@ import java.util.Arrays;
  * @author Jorge J. More (original fortran)
 
  * @version $Revision$ $Date$
-
+ * @since 1.2
+ *
  */
 public class LevenbergMarquardtEstimator extends AbstractEstimator implements Serializable {
 

src/java/org/apache/commons/math/estimation/SimpleEstimationProblem.java

@@ -36,6 +36,7 @@ import java.util.Iterator;
  * various parameters and their current estimate.</p>
 
  * @version $Revision$ $Date$
+ * @since 1.2
 
  */
 public class SimpleEstimationProblem implements EstimationProblem {

src/java/org/apache/commons/math/estimation/WeightedMeasurement.java

@@ -45,6 +45,7 @@ import java.io.Serializable;
  * @see EstimationProblem
  *
  * @version $Revision$ $Date$
+ * @since 1.2
  *
  */
 

src/java/org/apache/commons/math/fraction/FractionConversionException.java

@@ -24,6 +24,7 @@ import org.apache.commons.math.ConvergenceException;
  * in the allowed number of iterations.
  *
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public class FractionConversionException extends ConvergenceException {
 

src/java/org/apache/commons/math/geometry/CardanEulerSingularityException.java

@@ -23,12 +23,13 @@ import org.apache.commons.math.MathException;
  * or Euler angles from a rotation.
 
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 public class CardanEulerSingularityException
   extends MathException {
 
-  /** Simple constructor.
+  /** 
+   * Simple constructor.
    * build an exception with a default message.
    * @param isCardan if true, the rotation is related to Cardan angles,
    * if false it is related to EulerAngles

src/java/org/apache/commons/math/geometry/NotARotationMatrixException.java

@@ -19,17 +19,19 @@ package org.apache.commons.math.geometry;
 
 import org.apache.commons.math.MathException;
 
-/** This class represents exceptions thrown while building rotations
+/** 
+ * This class represents exceptions thrown while building rotations
  * from matrices.
-
+ *
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public class NotARotationMatrixException
   extends MathException {
 
-  /** Simple constructor.
+  /** 
+   * Simple constructor.
    * Build an exception by translating and formating a message
    * @param specifier format specifier (to be translated)
    * @param parts to insert in the format (no translation)

src/java/org/apache/commons/math/geometry/Rotation.java

@@ -21,7 +21,7 @@ import java.io.Serializable;
 
 /**
  * This class implements rotations in a three-dimensional space.
-
+ *
  * <p>Rotations can be represented by several different mathematical
  * entities (matrices, axe and angle, Cardan or Euler angles,
  * quaternions). This class presents an higher level abstraction, more
@@ -59,14 +59,14 @@ import java.io.Serializable;
  * need to transform the observing direction in the topocentric frame into the
  * observing direction in inertial frame taking into account the observatory
  * location and the Earth rotation.</p>
-
+ *
  * <p>These examples show that a rotation is what the user wants it to be, so this
  * class does not push the user towards one specific definition and hence does not
  * provide methods like <code>projectVectorIntoDestinationFrame</code> or
  * <code>computeTransformedDirection</code>. It provides simpler and more generic
  * methods: {@link #applyTo(Vector3D) applyTo(Vector3D)} and {@link
  * #applyInverseTo(Vector3D) applyInverseTo(Vector3D)}.</p>
-
+ *
  * <p>Since a rotation is basically a vectorial operator, several rotations can be
  * composed together and the composite operation <code>r = r<sub>1</sub> o
  * r<sub>2</sub></code> (which means that for each vector <code>u</code>,
@@ -77,13 +77,13 @@ import java.io.Serializable;
  * we get is <code>r = r<sub>1</sub> o r<sub>2</sub></code>. For this purpose, the
  * class provides the methods: {@link #applyTo(Rotation) applyTo(Rotation)} and
  * {@link #applyInverseTo(Rotation) applyInverseTo(Rotation)}.</p>
-
+ *
  * <p>Rotations are guaranteed to be immutable objects.</p>
-
+ *
  * @version $Revision$ $Date$
  * @see Vector3D
  * @see RotationOrder
-
+ * @since 1.2
  */
 
 public class Rotation implements Serializable {

src/java/org/apache/commons/math/geometry/RotationOrder.java

@@ -20,14 +20,14 @@ package org.apache.commons.math.geometry;
 /**
  * This class is a utility representing a rotation order specification
  * for Cardan or Euler angles specification.
-
+ *
  * This class cannot be instanciated by the user. He can only use one
  * of the twelve predefined supported orders as an argument to either
  * the {@link Rotation#Rotation(RotationOrder,double,double,double)}
  * constructor or the {@link Rotation#getAngles} method.
-
+ *
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 public final class RotationOrder {
 

src/java/org/apache/commons/math/geometry/Vector3D.java

@@ -19,9 +19,11 @@ package org.apache.commons.math.geometry;
 
 import java.io.Serializable;
 
-/** This class implements vectors in a three-dimensional space.
+/** 
+ * This class implements vectors in a three-dimensional space.
  * <p>Instance of this class are guaranteed to be immutable.</p>
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 
 public class Vector3D

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

@@ -23,8 +23,8 @@ package org.apache.commons.math.linear;
  *   
  * @see <a href="http://mathworld.wolfram.com/QRDecomposition.html">MathWorld</a>
  * @see <a href="http://en.wikipedia.org/wiki/QR_decomposition">Wikipedia</a>
- * 
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public interface QRDecomposition {
 

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

@@ -23,13 +23,13 @@ package org.apache.commons.math.linear;
  * orthogonal (Q<sup>T</sup>Q = I), and R is upper triangular. If A is
  * m&times;n, Q is m&times;m and R m&times;n. 
  * <p>
- * Implemented using Householder reflectors.
- *
+ * Implemented using Householder reflectors.</p>
  *
  * @see <a href="http://mathworld.wolfram.com/QRDecomposition.html">MathWorld</a>
  * @see <a href="http://en.wikipedia.org/wiki/QR_decomposition">Wikipedia</a>
  * 
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public class QRDecompositionImpl implements QRDecomposition {
 

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

@@ -34,6 +34,7 @@ import java.io.IOException;
  * @see StepHandler
  *
  * @version $Revision$ $Date$
+ * @since 1.2
  *
  */
 

src/java/org/apache/commons/math/ode/AdaptiveStepsizeIntegrator.java

@@ -20,7 +20,7 @@ package org.apache.commons.math.ode;
 /**
  * This abstract class holds the common part of all adaptive
  * stepsize integrators for Ordinary Differential Equations.
-
+ *
  * <p>These algorithms perform integration with stepsize control, which
  * means the user does not specify the integration step but rather a
  * tolerance on error. The error threshold is computed as
@@ -31,18 +31,19 @@ package org.apache.commons.math.ode;
  * state vector and relTol_i is the relative tolerance for the same
  * component. The user can also use only two scalar values absTol and
  * relTol which will be used for all components.</p>
-
+ *
  * <p>If the estimated error for ym+1 is such that
  * <pre>
  * sqrt((sum (errEst_i / threshold_i)^2 ) / n) < 1
  * </pre>
-
+ *
  * (where n is the state vector dimension) then the step is accepted,
  * otherwise the step is rejected and a new attempt is made with a new
  * stepsize.</p>
-
+ *
  * @version $Revision$ $Date$
-
+ * @since 1.2
+ *
  */
 
 public abstract class AdaptiveStepsizeIntegrator

src/java/org/apache/commons/math/ode/ClassicalRungeKuttaIntegrator.java

@@ -21,7 +21,7 @@ package org.apache.commons.math.ode;
  * This class implements the classical fourth order Runge-Kutta
  * integrator for Ordinary Differential Equations (it is the most
  * often used Runge-Kutta method).
-
+ *
  * <p>This method is an explicit Runge-Kutta method, its Butcher-array
  * is the following one :
  * <pre>
@@ -33,14 +33,13 @@ package org.apache.commons.math.ode;
  *       | 1/6  1/3  1/3  1/6
  * </pre>
  * </p>
-
+ *
  * @see EulerIntegrator
  * @see GillIntegrator
  * @see MidpointIntegrator
  * @see ThreeEighthesIntegrator
-
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public class ClassicalRungeKuttaIntegrator

src/java/org/apache/commons/math/ode/ClassicalRungeKuttaStepInterpolator.java

@@ -20,7 +20,7 @@ package org.apache.commons.math.ode;
 /**
  * This class implements a step interpolator for the classical fourth
  * order Runge-Kutta integrator.
-
+ *
  * <p>This interpolator allows to compute dense output inside the last
  * step computed. The interpolation equation is consistent with the
  * integration scheme :
@@ -32,15 +32,14 @@ package org.apache.commons.math.ode;
  *                                          -(4 theta^2 +   theta + 1) y'_4
  *                                        ]
  * </pre>
-
+ *
  * where theta belongs to [0 ; 1] and where y'_1 to y'_4 are the four
  * evaluations of the derivatives already computed during the
  * step.</p>
-
+ *
  * @see ClassicalRungeKuttaIntegrator
-
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 class ClassicalRungeKuttaStepInterpolator

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

@@ -25,7 +25,7 @@ import java.io.Serializable;
  * This class stores all information provided by an ODE integrator
  * during the integration process and build a continuous model of the
  * solution from this.
-
+ *
  * <p>This class act as a step handler from the integrator point of
  * view. It is called iteratively during the integration process and
  * stores a copy of all steps information in a sorted collection for
@@ -36,14 +36,14 @@ import java.io.Serializable;
  * integration to be over before attempting to call {@link
  * #setInterpolatedTime setInterpolatedTime} because some internal
  * variables are set only once the last step has been handled.</p>
-
+ *
  * <p>This is useful for example if the main loop of the user
  * application should remain independent from the integration process
  * or if one needs to mimic the behaviour of an analytical model
  * despite a numerical model is used (i.e. one needs the ability to
  * get the model value at any time or to navigate through the
  * data).</p>
-
+ *
  * <p>If problem modelization is done with several separate
  * integration phases for contiguous intervals, the same
  * ContinuousOutputModel can be used as step handler for all
@@ -57,7 +57,7 @@ import java.io.Serializable;
  * output model handles the steps of all integration phases, the user
  * do not need to bother when the maneuver begins or ends, he has all
  * the data available in a transparent manner.</p>
-
+ *
  * <p>An important feature of this class is that it implements the
  * <code>Serializable</code> interface. This means that the result of
  * an integration can be serialized and reused later (if stored into a
@@ -65,18 +65,17 @@ import java.io.Serializable;
  * sent to another application). Only the result of the integration is
  * stored, there is no reference to the integrated problem by
  * itself.</p>
-
+ *
  * <p>One should be aware that the amount of data stored in a
  * 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>
-
+ *
  * @see StepHandler
  * @see StepInterpolator
-
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public class ContinuousOutputModel

src/java/org/apache/commons/math/ode/DerivativeException.java

@@ -24,6 +24,7 @@ import org.apache.commons.math.MathException;
  * the error conditions that are trigegred while computing
  * the differential equations.
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public class DerivativeException
   extends MathException {

src/java/org/apache/commons/math/ode/DormandPrince54Integrator.java

@@ -29,7 +29,7 @@ package org.apache.commons.math.ode;
  * is an <i>fsal</i>, the last evaluation of one step is the same as
  * the first evaluation of the next step and hence can be avoided. So
  * the cost is really 6 functions evaluations per step.</p>
-
+ *
  * <p>This method has been published (whithout the continuous output
  * that was added by Shampine in 1986) in the following article :
  * <pre>
@@ -38,9 +38,9 @@ package org.apache.commons.math.ode;
  *  Journal of Computational and Applied Mathematics
  *  volume 6, no 1, 1980, pp. 19-26
  * </pre></p>
-
+ *
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public class DormandPrince54Integrator

src/java/org/apache/commons/math/ode/DormandPrince54StepInterpolator.java

@@ -24,7 +24,7 @@ package org.apache.commons.math.ode;
  * @see DormandPrince54Integrator
  *
  * @version $Revision$ $Date$
- *
+ * @since 1.2
  */
 
 class DormandPrince54StepInterpolator

src/java/org/apache/commons/math/ode/DormandPrince853Integrator.java

@@ -20,7 +20,7 @@ package org.apache.commons.math.ode;
 /**
  * This class implements the 8(5,3) Dormand-Prince integrator for Ordinary
  * Differential Equations.
-
+ *
  * <p>This integrator is an embedded Runge-Kutta integrator
  * of order 8(5,3) used in local extrapolation mode (i.e. the solution
  * is computed using the high order formula) with stepsize control
@@ -33,7 +33,7 @@ package org.apache.commons.math.ode;
  * <i>fsal</i>. Hence, despite we have 13 stages here, the cost is
  * really 12 evaluations per step even if no interpolation is done,
  * and the overcost of interpolation is only 3 evaluations.</p>
-
+ *
  * <p>This method is based on an 8(6) method by Dormand and Prince
  * (i.e. order 8 for the integration and order 6 for error estimation)
  * modified by Hairer and Wanner to use a 5th order error estimator
@@ -46,9 +46,9 @@ package org.apache.commons.math.ode;
  * Problems) of the reference book by Hairer, Norsett and Wanner:
  * <i>Solving Ordinary Differential Equations</i> (Springer-Verlag,
  * ISBN 3-540-56670-8).</p>
-
+ *
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public class DormandPrince853Integrator

src/java/org/apache/commons/math/ode/DormandPrince853StepInterpolator.java

@@ -28,7 +28,7 @@ import java.io.IOException;
  * @see DormandPrince853Integrator
  *
  * @version $Revision$ $Date$
- *
+ * @since 1.2
  */
 
 class DormandPrince853StepInterpolator

src/java/org/apache/commons/math/ode/DummyStepHandler.java

@@ -25,16 +25,15 @@ import java.io.Serializable;
  * <p>This class is provided as a convenience for users who are only
  * interested in the final state of an integration and not in the
  * intermediate steps. Its handleStep method does nothing.</p>
-
+ *
  * <p>Since this class has no internal state, it is implemented using
  * the Singleton design pattern. This means that only one instance is
  * ever created, which can be retrieved using the getInstance
  * method. This explains why there is no public constructor.</p>
-
+ *
  * @see StepHandler
-
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public class DummyStepHandler

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

@@ -32,7 +32,7 @@ import java.io.IOException;
  * @see StepHandler
  *
  * @version $Revision$ $Date$
- *
+ * @since 1.2
  */
 
 public class DummyStepInterpolator

src/java/org/apache/commons/math/ode/EmbeddedRungeKuttaIntegrator.java

@@ -20,7 +20,7 @@ package org.apache.commons.math.ode;
 /**
  * This class implements the common part of all embedded Runge-Kutta
  * integrators for Ordinary Differential Equations.
-
+ *
  * <p>These methods are embedded explicit Runge-Kutta methods with two
  * sets of coefficients allowing to estimate the error, their Butcher
  * arrays are as follows :
@@ -35,11 +35,11 @@ package org.apache.commons.math.ode;
  *       |  b'1  b'2 ...   b's-1 b's
  * </pre>
  * </p>
-
+ *
  * <p>In fact, we rather use the array defined by ej = bj - b'j to
  * compute directly the error rather than computing two estimates and
  * then comparing them.</p>
-
+ *
  * <p>Some methods are qualified as <i>fsal</i> (first same as last)
  * methods. This means the last evaluation of the derivatives in one
  * step is the same as the first in the next step. Then, this
@@ -49,9 +49,9 @@ package org.apache.commons.math.ode;
  * the step is rejected after the error estimation phase, no
  * evaluation is saved. For an <i>fsal</i> method, we have cs = 1 and
  * asi = bi for all i.</p>
-
+ *
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public abstract class EmbeddedRungeKuttaIntegrator

src/java/org/apache/commons/math/ode/EulerIntegrator.java

@@ -20,30 +20,29 @@ package org.apache.commons.math.ode;
 /**
  * This class implements a simple Euler integrator for Ordinary
  * Differential Equations.
-
+ *
  * <p>The Euler algorithm is the simplest one that can be used to
  * integrate ordinary differential equations. It is a simple inversion
  * of the forward difference expression :
  * <code>f'=(f(t+h)-f(t))/h</code> which leads to
  * <code>f(t+h)=f(t)+hf'</code>. The interpolation scheme used for
  * dense output is the linear scheme already used for integration.</p>
-
+ *
  * <p>This algorithm looks cheap because it needs only one function
  * evaluation per step. However, as it uses linear estimates, it needs
  * very small steps to achieve high accuracy, and small steps lead to
  * numerical errors and instabilities.</p>
-
+ *
  * <p>This algorithm is almost never used and has been included in
  * this package only as a comparison reference for more useful
  * integrators.</p>
-
+ *
  * @see MidpointIntegrator
  * @see ClassicalRungeKuttaIntegrator
  * @see GillIntegrator
  * @see ThreeEighthesIntegrator
-
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public class EulerIntegrator

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

@@ -19,22 +19,21 @@ package org.apache.commons.math.ode;
 
 /**
  * This class implements a linear interpolator for step.
-
+ *
  * <p>This interpolator allow to compute dense output inside the last
  * step computed. The interpolation equation is consistent with the
  * integration scheme :
-
+ *
  * <pre>
  *   y(t_n + theta h) = y (t_n + h) - (1-theta) h y'
  * </pre>
-
+ *
  * where theta belongs to [0 ; 1] and where y' is the evaluation of
  * the derivatives already computed during the step.</p>
-
+ *
  * @see EulerIntegrator
-
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 class EulerStepInterpolator

src/java/org/apache/commons/math/ode/FirstOrderConverter.java

@@ -19,11 +19,11 @@ package org.apache.commons.math.ode;
 
 /** This class converts second order differential equations to first
  * order ones.
-
+ *
  * <p>This class is a wrapper around a {@link
  * SecondOrderDifferentialEquations} which allow to use a {@link
  * FirstOrderIntegrator} to integrate it.</p>
-
+ *
  * <p>The transformation is done by changing the n dimension state
  * vector to a 2n dimension vector, where the first n components are
  * the initial state variables and the n last components are their
@@ -31,7 +31,7 @@ package org.apache.commons.math.ode;
  * vector then really contains both the first and second time
  * derivative of the initial state vector, which can be handled by the
  * underlying second order equations set.</p>
-
+ *
  * <p>One should be aware that the data is duplicated during the
  * transformation process and that for each call to {@link
  * #computeDerivatives computeDerivatives}, this wrapper does copy 4n
@@ -45,13 +45,12 @@ package org.apache.commons.math.ode;
  * avoid this duplication is to perform the transformation at the
  * problem level, i.e. to implement the problem as a first order one
  * and then avoid using this class.</p>
-
+ *
  * @see FirstOrderIntegrator
  * @see FirstOrderDifferentialEquations
  * @see SecondOrderDifferentialEquations
-
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public class FirstOrderConverter

src/java/org/apache/commons/math/ode/FirstOrderDifferentialEquations.java

@@ -41,7 +41,7 @@ package org.apache.commons.math.ode;
  * @see SecondOrderDifferentialEquations
  *
  * @version $Revision$ $Date$
- *
+ * @since 1.2
  */
 
 public interface FirstOrderDifferentialEquations {

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

@@ -24,13 +24,12 @@ package org.apache.commons.math.ode;
  * equations should implement this interface. The problems which can
  * be handled should implement the {@link
  * FirstOrderDifferentialEquations} interface.</p>
-
+ *
  * @see FirstOrderDifferentialEquations
  * @see StepHandler
  * @see SwitchingFunction
-
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public interface FirstOrderIntegrator {

src/java/org/apache/commons/math/ode/FixedStepHandler.java

@@ -29,12 +29,11 @@ package org.apache.commons.math.ode;
  * {@link StepNormalizer} object is called according to the integrator
  * internal algorithms and it calls objects implementing this
  * interface as necessary at fixed time steps.</p>
-
+ *
  * @see StepHandler
  * @see StepNormalizer
-
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public interface FixedStepHandler {

src/java/org/apache/commons/math/ode/GillIntegrator.java

@@ -32,14 +32,13 @@ package org.apache.commons.math.ode;
  *       |   1/6    (2-q)/6 (2+q)/6  1/6
  * </pre>
  * where q = sqrt(2)</p>
-
+ *
  * @see EulerIntegrator
  * @see ClassicalRungeKuttaIntegrator
  * @see MidpointIntegrator
  * @see ThreeEighthesIntegrator
-
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public class GillIntegrator

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

@@ -20,11 +20,11 @@ package org.apache.commons.math.ode;
 /**
  * This class implements a step interpolator for the Gill fourth
  * order Runge-Kutta integrator.
-
+ *
  * <p>This interpolator allows to compute dense output inside the last
  * step computed. The interpolation equation is consistent with the
  * integration scheme :
-
+ *
  * <pre>
  *   y(t_n + theta h) = y (t_n + h)
  *                    - (1 - theta) (h/6) [ (1 - theta) (1 - 4 theta) y'_1
@@ -35,11 +35,10 @@ package org.apache.commons.math.ode;
  * where theta belongs to [0 ; 1], q = sqrt(2) and where y'_1 to y'_4
  * are the four evaluations of the derivatives already computed during
  * the step.</p>
-
+ *
  * @see GillIntegrator
-
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 class GillStepInterpolator

src/java/org/apache/commons/math/ode/GraggBulirschStoerIntegrator.java

@@ -20,12 +20,12 @@ package org.apache.commons.math.ode;
 /**
  * This class implements a Gragg-Bulirsch-Stoer integrator for
  * Ordinary Differential Equations.
-
+ *
  * <p>The Gragg-Bulirsch-Stoer algorithm is one of the most efficient
  * ones currently available for smooth problems. It uses Richardson
  * extrapolation to estimate what would be the solution if the step
  * size could be decreased down to zero.</p>
-
+ *
  * <p>
  * This method changes both the step size and the order during
  * integration, in order to minimize computation cost. It is
@@ -41,7 +41,7 @@ package org.apache.commons.math.ode;
  * bodies (pleiades problem, involving quasi-collisions for which
  * <i>automatic step size control is essential</i>).
  * </p>
-
+ *
  * <p>
  * This implementation is basically a reimplementation in Java of the
  * <a
@@ -51,10 +51,10 @@ package org.apache.commons.math.ode;
  * href="http://www.unige.ch/~hairer/prog/licence.txt">here</a>, for
  * convenience, it is reproduced below.</p>
  * </p>
-
+ *
  * <table border="0" width="80%" cellpadding="10" align="center" bgcolor="#E0E0E0">
  * <tr><td>Copyright (c) 2004, Ernst Hairer</td></tr>
-
+ *
  * <tr><td>Redistribution and use in source and binary forms, with or
  * without modification, are permitted provided that the following
  * conditions are met:
@@ -65,7 +65,7 @@ package org.apache.commons.math.ode;
  *      notice, this list of conditions and the following disclaimer in the
  *      documentation and/or other materials provided with the distribution.</li>
  * </ul></td></tr>
-
+ *
  * <tr><td><strong>THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
@@ -78,10 +78,10 @@ package org.apache.commons.math.ode;
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.</strong></td></tr>
  * </table>
-
+ *
  * @author E. Hairer and G. Wanner (fortran version)
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public class GraggBulirschStoerIntegrator

src/java/org/apache/commons/math/ode/GraggBulirschStoerStepInterpolator.java

@@ -24,10 +24,10 @@ import java.io.IOException;
 /**
  * This class implements an interpolator for the Gragg-Bulirsch-Stoer
  * integrator.
-
+ *
  * <p>This interpolator compute dense output inside the last step
  * produced by a Gragg-Bulirsch-Stoer integrator.</p>
-
+ *
  * <p>
  * This implementation is basically a reimplementation in Java of the
  * <a
@@ -37,10 +37,10 @@ import java.io.IOException;
  * href="http://www.unige.ch/~hairer/prog/licence.txt">here</a>, for
  * convenience, it is reproduced below.</p>
  * </p>
-
+ *
  * <table border="0" width="80%" cellpadding="10" align="center" bgcolor="#E0E0E0">
  * <tr><td>Copyright (c) 2004, Ernst Hairer</td></tr>
-
+ *
  * <tr><td>Redistribution and use in source and binary forms, with or
  * without modification, are permitted provided that the following
  * conditions are met:
@@ -51,7 +51,7 @@ import java.io.IOException;
  *      notice, this list of conditions and the following disclaimer in the
  *      documentation and/or other materials provided with the distribution.</li>
  * </ul></td></tr>
-
+ *
  * <tr><td><strong>THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
@@ -64,12 +64,11 @@ import java.io.IOException;
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.</strong></td></tr>
  * </table>
-
+ *
  * @see GraggBulirschStoerIntegrator
-
  * @version $Revision$ $Date$
  * @author E. Hairer and G. Wanner (fortran version)
-
+ * @since 1.2
  */
 
 class GraggBulirschStoerStepInterpolator

src/java/org/apache/commons/math/ode/HighamHall54Integrator.java

@@ -20,15 +20,15 @@ package org.apache.commons.math.ode;
 /**
  * This class implements the 5(4) Higham and Hall integrator for
  * Ordinary Differential Equations.
-
+ *
  * <p>This integrator is an embedded Runge-Kutta integrator
  * of order 5(4) used in local extrapolation mode (i.e. the solution
  * is computed using the high order formula) with stepsize control
  * (and automatic step initialization) and continuous output. This
  * method uses 7 functions evaluations per step.</p>
-
+ *
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public class HighamHall54Integrator

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

@@ -24,7 +24,7 @@ package org.apache.commons.math.ode;
  * @see HighamHall54Integrator
  *
  * @version $Revision$ $Date$
- *
+ * @since 1.2
  */
 
 class HighamHall54StepInterpolator

src/java/org/apache/commons/math/ode/IntegratorException.java

@@ -23,6 +23,7 @@ import org.apache.commons.math.MathException;
  * This exception is made available to users to report
  * the error conditions that are triggered during integration
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public class IntegratorException
   extends MathException {

src/java/org/apache/commons/math/ode/MidpointIntegrator.java

@@ -20,7 +20,7 @@ package org.apache.commons.math.ode;
 /**
  * This class implements a second order Runge-Kutta integrator for
  * Ordinary Differential Equations.
-
+ *
  * <p>This method is an explicit Runge-Kutta method, its Butcher-array
  * is the following one :
  * <pre>
@@ -30,13 +30,13 @@ package org.apache.commons.math.ode;
  *       |  0    1
  * </pre>
  * </p>
-
+ *
  * @see EulerIntegrator
  * @see ClassicalRungeKuttaIntegrator
  * @see GillIntegrator
-
+ *
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public class MidpointIntegrator

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

@@ -20,23 +20,22 @@ package org.apache.commons.math.ode;
 /**
  * This class implements a step interpolator for second order
  * Runge-Kutta integrator.
-
+ *
  * <p>This interpolator allow to compute dense output inside the last
  * step computed. The interpolation equation is consistent with the
  * integration scheme :
-
+ *
  * <pre>
  *   y(t_n + theta h) = y (t_n + h) + (1-theta) h [theta y'_1 - (1+theta) y'_2]
  * </pre>
-
+ *
  * where theta belongs to [0 ; 1] and where y'_1 and y'_2 are the two
  * evaluations of the derivatives already computed during the
  * step.</p>
-
+ *
  * @see MidpointIntegrator
-
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 class MidpointStepInterpolator

src/java/org/apache/commons/math/ode/RungeKuttaIntegrator.java

@@ -20,7 +20,7 @@ package org.apache.commons.math.ode;
 /**
  * This class implements the common part of all fixed step Runge-Kutta
  * integrators for Ordinary Differential Equations.
-
+ *
  * <p>These methods are explicit Runge-Kutta methods, their Butcher
  * arrays are as follows :
  * <pre>
@@ -33,14 +33,13 @@ package org.apache.commons.math.ode;
  *       |  b1   b2  ...   bs-1  bs
  * </pre>
  * </p>
-
+ *
  * @see EulerIntegrator
  * @see ClassicalRungeKuttaIntegrator
  * @see GillIntegrator
  * @see MidpointIntegrator
-
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public abstract class RungeKuttaIntegrator

src/java/org/apache/commons/math/ode/RungeKuttaStepInterpolator.java

@@ -28,7 +28,7 @@ import java.io.IOException;
  * @see EmbeddedRungeKuttaIntegrator
  *
  * @version $Revision$ $Date$
- *
+ * @since 1.2
  */
 
 abstract class RungeKuttaStepInterpolator

src/java/org/apache/commons/math/ode/SecondOrderDifferentialEquations.java

@@ -22,7 +22,7 @@ package org.apache.commons.math.ode;
  * <p>This interface should be implemented by all real second order
  * differential equation problems before they can be handled by the
  * integrators {@link SecondOrderIntegrator#integrate} method.</p>
-
+ *
  * <p>A second order differential equations problem, as seen by an
  * integrator is the second time derivative <code>d2Y/dt^2</code> of a
  * state vector <code>Y</code>, both being one dimensional
@@ -30,19 +30,18 @@ package org.apache.commons.math.ode;
  * only on the current time <code>t</code>, on the state vector
  * <code>Y</code> and on the first time derivative of the state
  * vector.</p>
-
+ *
  * <p>For real problems, the derivative depends also on parameters
  * that do not belong to the state vector (dynamical model constants
  * for example). These constants are completely outside of the scope
  * of this interface, the classes that implement it are allowed to
  * handle them as they want.</p>
-
+ *
  * @see SecondOrderIntegrator
  * @see FirstOrderConverter
  * @see FirstOrderDifferentialEquations
-
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public interface SecondOrderDifferentialEquations {

src/java/org/apache/commons/math/ode/SecondOrderIntegrator.java

@@ -19,16 +19,15 @@ package org.apache.commons.math.ode;
 
 /** This interface represents a second order integrator for
  * differential equations.
-
+ *
  * <p>The classes which are devoted to solve second order differential
  * equations should implement this interface. The problems which can
  * be handled should implement the {@link
  * SecondOrderDifferentialEquations} interface.</p>
-
+ *
  * @see SecondOrderDifferentialEquations
-
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public interface SecondOrderIntegrator {

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

@@ -20,7 +20,7 @@ package org.apache.commons.math.ode;
 /**
  * This interface represents a handler that should be called after
  * each successful step.
-
+ *
  * <p>The ODE integrators compute the evolution of the state vector at
  * some grid points that depend on their own internal algorithm. Once
  * they have found a new grid point (possibly after having computed
@@ -29,13 +29,12 @@ package org.apache.commons.math.ode;
  * typically either ignore the intermediate steps and wait for the
  * last one, store the points in an ephemeris, or forward them to
  * specialized processing or output methods.</p>
-
+ *
  * @see FirstOrderIntegrator
  * @see SecondOrderIntegrator
  * @see StepInterpolator
-
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public interface StepHandler {

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

@@ -32,9 +32,8 @@ import java.io.Externalizable;
  * @see FirstOrderIntegrator
  * @see SecondOrderIntegrator
  * @see StepHandler
- *
  * @version $Revision$ $Date$
- *
+ * @since 1.2
  */
 
 public interface StepInterpolator

src/java/org/apache/commons/math/ode/StepNormalizer.java

@@ -25,7 +25,7 @@ package org.apache.commons.math.ode;
  * integrators which cannot guaranty their integration steps will
  * remain constant and therefore only accept general step
  * handlers.</p>
-
+ *
  * <p>The stepsize used is selected at construction time. The {@link
  * FixedStepHandler#handleStep handleStep} method of the underlying
  * {@link FixedStepHandler} object is called at the beginning time of
@@ -34,16 +34,15 @@ package org.apache.commons.math.ode;
  * last point handled will be the endpoint of the integration tend, if
  * not, the last point will belong to the interval [tend - h ;
  * tend].</p>
-
+ *
  * <p>There is no constraint on the integrator, it can use any
  * timestep it needs (time steps longer or shorter than the fixed time
  * step and non-integer ratios are all allowed).</p>
-
+ *
  * @see StepHandler
  * @see FixedStepHandler
-
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public class StepNormalizer

src/java/org/apache/commons/math/ode/SwitchState.java

@@ -37,7 +37,7 @@ import org.apache.commons.math.analysis.UnivariateRealSolver;
  * occurs at a bound rather than inside the step).</p>
  *
  * @version $Revision$ $Date$
- *
+ * @since 1.2
  */
 class SwitchState implements Serializable {
 

src/java/org/apache/commons/math/ode/SwitchingFunction.java

@@ -45,7 +45,7 @@ import org.apache.commons.math.FunctionEvaluationException;
  * fixed step ones).</p>
  *
  * @version $Revision$ $Date$
- *
+ * @since 1.2
  */
 
 public interface SwitchingFunction extends Serializable {

src/java/org/apache/commons/math/ode/SwitchingFunctionsHandler.java

@@ -27,9 +27,8 @@ import java.util.Iterator;
  * functions} during integration.
  *
  * @see SwitchingFunction
- *
  * @version $Revision$ $Date$
- *
+ * @since 1.2
  */
 
 public class SwitchingFunctionsHandler {

src/java/org/apache/commons/math/ode/ThreeEighthesIntegrator.java

@@ -20,7 +20,7 @@ package org.apache.commons.math.ode;
 /**
  * This class implements the 3/8 fourth order Runge-Kutta
  * integrator for Ordinary Differential Equations.
-
+ *
  * <p>This method is an explicit Runge-Kutta method, its Butcher-array
  * is the following one :
  * <pre>
@@ -32,14 +32,13 @@ package org.apache.commons.math.ode;
  *       | 1/8  3/8  3/8  1/8
  * </pre>
  * </p>
-
+ *
  * @see EulerIntegrator
  * @see ClassicalRungeKuttaIntegrator
  * @see GillIntegrator
  * @see MidpointIntegrator
-
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public class ThreeEighthesIntegrator

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

@@ -20,11 +20,11 @@ package org.apache.commons.math.ode;
 /**
  * This class implements a step interpolator for the 3/8 fourth
  * order Runge-Kutta integrator.
-
+ *
  * <p>This interpolator allows to compute dense output inside the last
  * step computed. The interpolation equation is consistent with the
  * integration scheme :
-
+ *
  * <pre>
  *   y(t_n + theta h) = y (t_n + h)
  *                    - (1 - theta) (h/8) [ (1 - 7 theta + 8 theta^2) y'_1
@@ -33,15 +33,14 @@ package org.apache.commons.math.ode;
  *                                      +   (1 +   theta + 4 theta^2) y'_4
  *                                        ]
  * </pre>
-
+ *
  * where theta belongs to [0 ; 1] and where y'_1 to y'_4 are the four
  * evaluations of the derivatives already computed during the
  * step.</p>
-
+ *
  * @see ThreeEighthesIntegrator
-
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 class ThreeEighthesStepInterpolator

src/java/org/apache/commons/math/optimization/ConvergenceChecker.java

@@ -19,14 +19,14 @@ package org.apache.commons.math.optimization;
 
 /** This interface specifies how to check if a {@link
  * DirectSearchOptimizer direct search method} has converged.
-
+ *
  * <p>Deciding if convergence has been reached is a problem-dependent
  * issue. The user should provide a class implementing this interface
  * to allow the optimization algorithm to stop its search according to
  * the problem at hand.</p>
-
+ *
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public interface ConvergenceChecker {

src/java/org/apache/commons/math/optimization/CostException.java

@@ -19,10 +19,11 @@ package org.apache.commons.math.optimization;
 
 import org.apache.commons.math.MathException;
 
-/** This class represents exceptions thrown by cost functions.
-
+/** 
+ * This class represents exceptions thrown by cost functions.
+ *
  * @version $Revision$ $Date$
-
+ * @since 1.2
  */
 
 public class CostException

src/java/org/apache/commons/math/optimization/CostFunction.java

@@ -17,13 +17,16 @@
 
 package org.apache.commons.math.optimization;
 
-/** This interface represents a cost function to be minimized.
+/** 
+ * This interface represents a cost function to be minimized.
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public interface CostFunction {
 
 
-  /** Compute the cost associated to the given parameters array.
+  /** 
+   * Compute the cost associated to the given parameters array.
    * @param x parameters array
    * @return cost associated to the parameters array
    * @exception CostException if no cost can be computed for the parameters

src/java/org/apache/commons/math/optimization/DirectSearchOptimizer.java

@@ -33,9 +33,10 @@ import org.apache.commons.math.random.UniformRandomGenerator;
 import org.apache.commons.math.stat.descriptive.moment.VectorialCovariance;
 import org.apache.commons.math.stat.descriptive.moment.VectorialMean;
 
-/** This class implements simplex-based direct search optimization
+/** 
+ * This class implements simplex-based direct search optimization
  * algorithms.
-
+ *
  * <p>Direct search methods only use cost function values, they don't
  * need derivatives and don't either try to compute approximation of
  * the derivatives. According to a 1996 paper by Margaret H. Wright
@@ -47,12 +48,12 @@ import org.apache.commons.math.stat.descriptive.moment.VectorialMean;
  * <em>not too bad</em> point is desired. In the latter cases, an
  * optimum is desired but cannot be reasonably found. In all cases
  * direct search methods can be useful.</p>
-
+ *
  * <p>Simplex-based direct search methods are based on comparison of
  * the cost function values at the vertices of a simplex (which is a
  * set of n+1 points in dimension n) that is updated by the algorithms
  * steps.</p>
-
+ *
  * <p>Minimization can be attempted either in single-start or in
  * multi-start mode. Multi-start is a traditional way to try to avoid
  * being trapped in a local minimum and miss the global minimum of a
@@ -63,16 +64,17 @@ import org.apache.commons.math.stat.descriptive.moment.VectorialMean;
  * minima from all starts (including the one already provided by the
  * {@link #minimizes(CostFunction, int, ConvergenceChecker, double[],
  * double[]) minimizes} method).</p>
-
+ *
  * <p>This class is the base class performing the boilerplate simplex
  * initialization and handling. The simplex update by itself is
  * performed by the derived classes according to the implemented
  * algorithms.</p>
-
- * @version $Revision$ $Date$
+ *
  * @see CostFunction
  * @see NelderMead
  * @see MultiDirectional
+ * @version $Revision$ $Date$
+ * @since 1.2
  */
 public abstract class DirectSearchOptimizer {
 

src/java/org/apache/commons/math/optimization/MultiDirectional.java

@@ -17,10 +17,12 @@
 
 package org.apache.commons.math.optimization;
 
-/** This class implements the multi-directional direct search method.
-
+/** 
+ * This class implements the multi-directional direct search method.
+ *
  * @version $Revision$ $Date$
  * @see NelderMead
+ * @since 1.2
  */
 public class MultiDirectional
   extends DirectSearchOptimizer {

src/java/org/apache/commons/math/optimization/NelderMead.java

@@ -17,10 +17,12 @@
 
 package org.apache.commons.math.optimization;
 
-/** This class implements the Nelder-Mead direct search method.
-
+/** 
+ * This class implements the Nelder-Mead direct search method.
+ *
  * @version $Revision$ $Date$
  * @see MultiDirectional
+ * @since 1.2
  */
 public class NelderMead
   extends DirectSearchOptimizer {

src/java/org/apache/commons/math/optimization/PointCostPair.java

@@ -17,10 +17,12 @@
 
 package org.apache.commons.math.optimization;
 
-/** This class holds a point and its associated cost.
+/** 
+ * This class holds a point and its associated cost.
  * <p>This is a simple immutable container.</p>
  * @version $Revision$ $Date$
  * @see CostFunction
+ * @since 1.2
  */
 public class PointCostPair {
 

src/java/org/apache/commons/math/random/CorrelatedRandomVectorGenerator.java

@@ -53,9 +53,9 @@ import org.apache.commons.math.linear.RealMatrixImpl;
  * uncorrelated random vector that is needed to compute the component
  * of the correlated vector. This class handles this situation
  * automatically.</p>
-
- * @version $Revision:$ $Date$
-
+ *
+ * @version $Revision$ $Date$
+ * @since 1.2
  */
 
 public class CorrelatedRandomVectorGenerator

src/java/org/apache/commons/math/random/GaussianRandomGenerator.java

@@ -17,10 +17,12 @@
 
 package org.apache.commons.math.random;
 
-/** This class is a gaussian normalized random generator for scalars.
+/** 
+ * This class is a gaussian normalized random generator for scalars.
  * <p>This class is a simple wrapper around the {@link
  * RandomGenerator#nextGaussian} method.</p>
- * @version $Revision:$ $Date$
+ * @version $Revision$ $Date$
+ * @since 1.2
  */
 
 public class GaussianRandomGenerator implements NormalizedRandomGenerator {

src/java/org/apache/commons/math/random/NormalizedRandomGenerator.java

@@ -17,10 +17,12 @@
 
 package org.apache.commons.math.random;
 
-/** This interface represent a normalized random generator for
+/** 
+ * This interface represent a normalized random generator for
  * scalars.
  * Normalized generator provide null mean and unit standard deviation scalars.
- * @version $Revision:$ $Date$
+ * @version $Revision$ $Date$
+ * @since 1.2
  */
 public interface NormalizedRandomGenerator {
 

src/java/org/apache/commons/math/random/UncorrelatedRandomVectorGenerator.java

@@ -25,6 +25,7 @@ import java.util.Arrays;
  * distributions, with parameters supplied in the constructor.
  * 
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 
 public class UncorrelatedRandomVectorGenerator

src/java/org/apache/commons/math/stat/descriptive/DescriptiveStatistics.java

@@ -443,6 +443,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
 
     /**
      * @param meanImpl the meanImpl to set
+     * @since 1.2
      */
     public synchronized void setMeanImpl(UnivariateStatistic meanImpl) {
         this.meanImpl = meanImpl;
@@ -450,6 +451,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
 
     /**
      * @return the geometricMeanImpl
+     * @since 1.2
      */
     public synchronized UnivariateStatistic getGeometricMeanImpl() {
         return geometricMeanImpl;
@@ -457,6 +459,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
 
     /**
      * @param geometricMeanImpl the geometricMeanImpl to set
+     * @since 1.2
      */
     public synchronized void setGeometricMeanImpl(
             UnivariateStatistic geometricMeanImpl) {
@@ -465,6 +468,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
 
     /**
      * @return the kurtosisImpl
+     * @since 1.2
      */
     public synchronized UnivariateStatistic getKurtosisImpl() {
         return kurtosisImpl;
@@ -472,6 +476,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
 
     /**
      * @param kurtosisImpl the kurtosisImpl to set
+     * @since 1.2
      */
     public synchronized void setKurtosisImpl(UnivariateStatistic kurtosisImpl) {
         this.kurtosisImpl = kurtosisImpl;
@@ -479,6 +484,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
 
     /**
      * @return the maxImpl
+     * @since 1.2
      */
     public synchronized UnivariateStatistic getMaxImpl() {
         return maxImpl;
@@ -486,6 +492,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
 
     /**
      * @param maxImpl the maxImpl to set
+     * @since 1.2
      */
     public synchronized void setMaxImpl(UnivariateStatistic maxImpl) {
         this.maxImpl = maxImpl;
@@ -493,6 +500,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
 
     /**
      * @return the minImpl
+     * @since 1.2
      */
     public synchronized UnivariateStatistic getMinImpl() {
         return minImpl;
@@ -500,6 +508,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
 
     /**
      * @param minImpl the minImpl to set
+     * @since 1.2
      */
     public synchronized void setMinImpl(UnivariateStatistic minImpl) {
         this.minImpl = minImpl;
@@ -507,6 +516,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
 
     /**
      * @return the percentileImpl
+     * @since 1.2
      */
     public synchronized UnivariateStatistic getPercentileImpl() {
         return percentileImpl;
@@ -521,6 +531,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
      * @param percentileImpl the percentileImpl to set
      * @throws IllegalArgumentException if the supplied implementation does not
      *  provide a <code>setQuantile</code> method
+     * @since 1.2
      */
     public synchronized void setPercentileImpl(
             UnivariateStatistic percentileImpl) {
@@ -543,6 +554,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
 
     /**
      * @return the skewnessImpl
+     * @since 1.2
      */
     public synchronized UnivariateStatistic getSkewnessImpl() {
         return skewnessImpl;
@@ -550,6 +562,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
 
     /**
      * @param skewnessImpl the skewnessImpl to set
+     * @since 1.2
      */
     public synchronized void setSkewnessImpl(
             UnivariateStatistic skewnessImpl) {
@@ -558,6 +571,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
 
     /**
      * @return the varianceImpl
+     * @since 1.2
      */
     public synchronized UnivariateStatistic getVarianceImpl() {
         return varianceImpl;
@@ -565,6 +579,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
 
     /**
      * @param varianceImpl the varianceImpl to set
+     * @since 1.2
      */
     public synchronized void setVarianceImpl(
             UnivariateStatistic varianceImpl) {
@@ -573,6 +588,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
 
     /**
      * @return the sumsqImpl
+     * @since 1.2
      */
     public synchronized UnivariateStatistic getSumsqImpl() {
         return sumsqImpl;
@@ -580,6 +596,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
 
     /**
      * @param sumsqImpl the sumsqImpl to set
+     * @since 1.2
      */
     public synchronized void setSumsqImpl(UnivariateStatistic sumsqImpl) {
         this.sumsqImpl = sumsqImpl;
@@ -587,6 +604,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
 
     /**
      * @return the sumImpl
+     * @since 1.2
      */
     public synchronized UnivariateStatistic getSumImpl() {
         return sumImpl;
@@ -594,6 +612,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
 
     /**
      * @param sumImpl the sumImpl to set
+     * @since 1.2
      */
     public synchronized void setSumImpl(UnivariateStatistic sumImpl) {
         this.sumImpl = sumImpl;

src/java/org/apache/commons/math/stat/descriptive/SummaryStatistics.java

@@ -303,7 +303,8 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
      * <p>
      *  Double.NaN is returned if no values have been added.</p>
      *
-     * @return the sum of logs  
+     * @return the sum of logs
+     * @since 1.2
      */
     public double getSumOfLogs() {
         return sumLogImpl.getResult();
@@ -314,6 +315,7 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
      * summary statistics from values that
      * have been added.
      * @return String with line feeds displaying statistics
+     * @since 1.2
      */
     public String toString() {
         StringBuffer outBuffer = new StringBuffer();
@@ -398,6 +400,7 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
      * Returns the currently configured Sum implementation
      * 
      * @return the StorelessUnivariateStatistic implementing the sum
+     * @since 1.2
      */
     public StorelessUnivariateStatistic getSumImpl() {
         return sumImpl;
@@ -413,6 +416,7 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
      * for computing the Sum
      * @throws IllegalStateException if data has already been added
      *  (i.e if n > 0)
+     * @since 1.2
      */
     public void setSumImpl(StorelessUnivariateStatistic sumImpl) {
         checkEmpty();
@@ -423,6 +427,7 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
      * Returns the currently configured sum of squares implementation
      * 
      * @return the StorelessUnivariateStatistic implementing the sum of squares
+     * @since 1.2
      */
     public StorelessUnivariateStatistic getSumsqImpl() {
         return sumsqImpl;
@@ -438,6 +443,7 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
      * for computing the sum of squares
      * @throws IllegalStateException if data has already been added
      *  (i.e if n > 0)
+     * @since 1.2
      */
     public void setSumsqImpl(
             StorelessUnivariateStatistic sumsqImpl) {
@@ -449,6 +455,7 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
      * Returns the currently configured minimum implementation
      * 
      * @return the StorelessUnivariateStatistic implementing the minimum
+     * @since 1.2
      */
     public StorelessUnivariateStatistic getMinImpl() {
         return minImpl;
@@ -464,6 +471,7 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
      * for computing the minimum
      * @throws IllegalStateException if data has already been added
      *  (i.e if n > 0)
+     * @since 1.2
      */
     public void setMinImpl(StorelessUnivariateStatistic minImpl) {
         checkEmpty();
@@ -474,6 +482,7 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
      * Returns the currently configured maximum implementation
      * 
      * @return the StorelessUnivariateStatistic implementing the maximum
+     * @since 1.2
      */
     public StorelessUnivariateStatistic getMaxImpl() {
         return maxImpl;
@@ -489,6 +498,7 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
      * for computing the maximum
      * @throws IllegalStateException if data has already been added
      *  (i.e if n > 0)
+     * @since 1.2
      */
     public void setMaxImpl(StorelessUnivariateStatistic maxImpl) {
         checkEmpty();
@@ -499,6 +509,7 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
      * Returns the currently configured sum of logs implementation
      * 
      * @return the StorelessUnivariateStatistic implementing the log sum
+     * @since 1.2
      */
     public StorelessUnivariateStatistic getSumLogImpl() {
         return sumLogImpl;
@@ -514,6 +525,7 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
      * for computing the log sum
      * @throws IllegalStateException if data has already been added 
      *  (i.e if n > 0)
+     * @since 1.2
      */
     public void setSumLogImpl(
             StorelessUnivariateStatistic sumLogImpl) {
@@ -526,6 +538,7 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
      * Returns the currently configured geometric mean implementation
      * 
      * @return the StorelessUnivariateStatistic implementing the geometric mean
+     * @since 1.2
      */
     public StorelessUnivariateStatistic getGeoMeanImpl() {
         return geoMeanImpl;
@@ -541,6 +554,7 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
      * for computing the geometric mean
      * @throws IllegalStateException if data has already been added
      *  (i.e if n > 0)
+     * @since 1.2
      */
     public void setGeoMeanImpl(
             StorelessUnivariateStatistic geoMeanImpl) {
@@ -552,6 +566,7 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
      * Returns the currently configured mean implementation
      * 
      * @return the StorelessUnivariateStatistic implementing the mean
+     * @since 1.2
      */
     public StorelessUnivariateStatistic getMeanImpl() {
         return meanImpl;
@@ -567,6 +582,7 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
      * for computing the mean
      * @throws IllegalStateException if data has already been added
      *  (i.e if n > 0)
+     * @since 1.2
      */
     public void setMeanImpl(
             StorelessUnivariateStatistic meanImpl) {
@@ -578,6 +594,7 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
      * Returns the currently configured variance implementation
      * 
      * @return the StorelessUnivariateStatistic implementing the variance
+     * @since 1.2
      */
     public StorelessUnivariateStatistic getVarianceImpl() {
         return varianceImpl;
@@ -593,6 +610,7 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
      * for computing the variance
      * @throws IllegalStateException if data has already been added
      *  (i.e if n > 0)
+     * @since 1.2
      */
     public void setVarianceImpl(
             StorelessUnivariateStatistic varianceImpl) {

src/java/org/apache/commons/math/stat/inference/ChiSquareTestImpl.java

@@ -210,6 +210,7 @@ public class ChiSquareTestImpl implements UnknownDistributionChiSquareTest {
      * @param observed2 array of observed frequency counts of the second data set
      * @return chi-square test statistic
      * @throws IllegalArgumentException if preconditions are not met
+     * @since 1.2
      */
     public double chiSquareDataSetsComparison(long[] observed1, long[] observed2)
         throws IllegalArgumentException {
@@ -272,6 +273,7 @@ public class ChiSquareTestImpl implements UnknownDistributionChiSquareTest {
      * @return p-value
      * @throws IllegalArgumentException if preconditions are not met
      * @throws MathException if an error occurs computing the p-value
+     * @since 1.2
      */
     public double chiSquareTestDataSetsComparison(long[] observed1, long[] observed2)
         throws IllegalArgumentException, MathException {
@@ -288,6 +290,7 @@ public class ChiSquareTestImpl implements UnknownDistributionChiSquareTest {
      * 1 - alpha
      * @throws IllegalArgumentException if preconditions are not met
      * @throws MathException if an error occurs performing the test
+     * @since 1.2
      */
     public boolean chiSquareTestDataSetsComparison(long[] observed1, long[] observed2,
             double alpha) throws IllegalArgumentException, MathException {

src/java/org/apache/commons/math/stat/inference/UnknownDistributionChiSquareTest.java

@@ -23,7 +23,8 @@ import org.apache.commons.math.MathException;
  * <p>Two samples tests are used when the distribution is unknown <i>a priori</i>
  * but provided by one sample. We compare the second sample against the first.</p>
  *
- * @version $Revision$ $Date$ 
+ * @version $Revision$ $Date$
+ * @since 1.2 
  */
 public interface UnknownDistributionChiSquareTest extends ChiSquareTest {
      

src/java/org/apache/commons/math/transform/FastCosineTransformer.java

@@ -35,6 +35,7 @@ import org.apache.commons.math.MathException;
  * function transformation on how this affects the sampling.</p>
  *
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public class FastCosineTransformer implements Serializable {
 

src/java/org/apache/commons/math/transform/FastFourierTransformer.java

@@ -38,6 +38,7 @@ import org.apache.commons.math.MathException;
  * 32 (1978), 175 - 199.</p>
  *
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public class FastFourierTransformer implements Serializable {
 

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

@@ -35,6 +35,7 @@ import org.apache.commons.math.MathException;
  * transformation after sampling.</p>
  *
  * @version $Revision$ $Date$
+ * @since 1.2
  */
 public class FastSineTransformer implements Serializable {
 

src/java/org/apache/commons/math/util/MathUtils.java

@@ -286,6 +286,7 @@ public final class MathUtils {
      * @param y second array
      * @return true if the values are both null or have same dimension
      * and equal elements
+     * @since 1.2
      */
     public static boolean equals(double[] x, double[] y) {
         if ((x == null) || (y == null)) {
@@ -464,6 +465,7 @@ public final class MathUtils {
      * 
      * @param value the value to be hashed (may be null)
      * @return the hash code
+     * @since 1.2
      */
     public static int hash(double[] value) {
         if (value == null) {
@@ -574,6 +576,7 @@ public final class MathUtils {
      * @param base the base of the logarithm, must be greater than 0
      * @param x argument, must be greater than 0
      * @return the value of the logarithm - the number y such that base^y = x.
+     * @since 1.2
      */ 
     public static double log(double base, double x) {
         return Math.log(x)/Math.log(base);
@@ -667,6 +670,7 @@ public final class MathUtils {
      * @param direction (the only important thing is whether
      * direction is greater or smaller than d)
      * @return the next machine representable number in the specified direction
+     * @since 1.2
      */
     public static double nextAfter(double d, double direction) {
 
@@ -725,6 +729,7 @@ public final class MathUtils {
      * @param a angle to normalize
      * @param center center of the desired 2π interval for the result
      * @return a-2kπ with integer k and center-π <= a-2kπ <= center+π
+     * @since 1.2
      */
      public static double normalizeAngle(double a, double center) {
          return a - TWO_PI * Math.floor((a + Math.PI - center) / TWO_PI);

src/site/xdoc/changes.xml

@@ -43,10 +43,10 @@ Commons Math Release Notes</title>
     description="This release combines bug fixes and new features. Most notable
     among the new features are the estimation, optimization, geometry and ode
     packages added from the Mantissa library. Implementations of fast Fourier
-    transform and QR decomposition have also been added, along with
-    enhancements and extensions to packages included in Commons Math 1.1. This
-    release is source and binary compatible with earlier versions of
-    Commons Math.">
+    transform, QR decomposition and several numerical integration algorithms
+    have also been added, along with enhancements and extensions to packages
+    included in Commons Math 1.1. This release is source and binary compatible
+    with earlier versions of Commons Math.">
       <action dev="luc" type="fix">
         Fixed numerous warnings in test code.
       </action>