From f8254ebbd3ce543854e93539eb0a3375e8e406b6 Mon Sep 17 00:00:00 2001
From: Luc Maisonobe <luc@apache.org>
Date: Sun, 6 Sep 2009 15:32:50 +0000
Subject: [PATCH] use standard declaration order rules

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/math/trunk@811827 13f79535-47bb-0310-9956-ffa450edef68
---
 checkstyle.xml                                |   9 +-
 .../math/DimensionMismatchException.java      |  14 +-
 .../apache/commons/math/MathException.java    |  74 ++--
 .../commons/math/MathRuntimeException.java    |  76 ++--
 .../commons/math/MessagesResources_fr.java    |  30 +-
 .../interpolation/LoessInterpolator.java      |  15 +-
 .../solvers/UnivariateRealSolverUtils.java    |  11 +-
 .../apache/commons/math/complex/Complex.java  |  22 +-
 .../commons/math/complex/ComplexField.java    |   8 +-
 .../math/estimation/AbstractEstimator.java    |  82 ++--
 .../math/estimation/EstimatedParameter.java   | 148 +++----
 .../LevenbergMarquardtEstimator.java          |  80 ++--
 .../estimation/SimpleEstimationProblem.java   |  12 +-
 .../math/estimation/WeightedMeasurement.java  |  20 +-
 .../commons/math/fraction/BigFraction.java    |  56 +--
 .../math/fraction/BigFractionField.java       |   8 +-
 .../commons/math/fraction/FractionField.java  |   8 +-
 .../math/genetics/GeneticAlgorithm.java       |  36 +-
 .../CardanEulerSingularityException.java      |  22 +-
 .../geometry/NotARotationMatrixException.java |  22 +-
 .../commons/math/geometry/RotationOrder.java  | 240 ++++++------
 .../math/linear/AbstractFieldMatrix.java      |  78 ++--
 .../commons/math/linear/ArrayFieldVector.java |  22 +-
 .../commons/math/linear/BigMatrixImpl.java    |  17 +-
 .../commons/math/linear/BlockFieldMatrix.java |   6 +-
 .../commons/math/linear/BlockRealMatrix.java  |   6 +-
 .../math/linear/LUDecompositionImpl.java      |   6 +-
 .../math/linear/OpenMapRealVector.java        |   6 +-
 .../commons/math/ode/AbstractIntegrator.java  |  23 +-
 .../math/ode/ContinuousOutputModel.java       |  36 +-
 .../commons/math/ode/FirstOrderConverter.java |  30 +-
 .../commons/math/ode/MultistepIntegrator.java |  12 +-
 .../nonstiff/AdaptiveStepsizeIntegrator.java  |  41 +-
 .../DormandPrince54StepInterpolator.java      | 110 +++---
 .../DormandPrince853StepInterpolator.java     | 360 +++++++++---------
 .../EmbeddedRungeKuttaIntegrator.java         |  54 +--
 .../ode/nonstiff/GillStepInterpolator.java    |  18 +-
 .../GraggBulirschStoerIntegrator.java         | 120 +++---
 .../GraggBulirschStoerStepInterpolator.java   | 130 +++----
 .../HighamHall54StepInterpolator.java         |   6 +-
 .../nonstiff/MidpointStepInterpolator.java    |   6 +-
 .../ode/nonstiff/RungeKuttaIntegrator.java    |  30 +-
 .../nonstiff/RungeKuttaStepInterpolator.java  |  12 +-
 .../ThreeEighthesStepInterpolator.java        |   6 +-
 .../math/ode/sampling/DummyStepHandler.java   |  98 +++--
 .../ode/sampling/DummyStepInterpolator.java   |   6 +-
 .../sampling/NordsieckStepInterpolator.java   |   6 +-
 .../AbstractLeastSquaresOptimizer.java        |  42 +-
 ...AbstractScalarDifferentiableOptimizer.java |  18 +-
 .../linear/AbstractLinearOptimizer.java       |  12 +-
 .../optimization/linear/SimplexTableau.java   |  10 +-
 .../CorrelatedRandomVectorGenerator.java      |  30 +-
 .../math/random/GaussianRandomGenerator.java  |   8 +-
 .../UncorrelatedRandomVectorGenerator.java    |  18 +-
 .../math/random/UniformRandomGenerator.java   |  12 +-
 .../commons/math/random/ValueServer.java      |  77 ++--
 .../apache/commons/math/special/Gamma.java    |  12 +-
 .../descriptive/DescriptiveStatistics.java    |  14 +-
 .../MultivariateSummaryStatistics.java        |  60 +--
 .../stat/descriptive/SummaryStatistics.java   |  30 +-
 .../descriptive/moment/GeometricMean.java     |  16 +-
 .../math/stat/inference/TestUtils.java        |  13 +-
 .../math/stat/ranking/NaturalRanking.java     |  12 +-
 .../org/apache/commons/math/util/BigReal.java |   6 +-
 .../commons/math/util/BigRealField.java       |   8 +-
 .../apache/commons/math/util/MathUtils.java   |  17 +-
 .../math/util/OpenIntToDoubleHashMap.java     |  18 +-
 .../math/util/OpenIntToFieldHashMap.java      |  18 +-
 .../math/util/ResizableDoubleArray.java       |   6 +-
 69 files changed, 1343 insertions(+), 1352 deletions(-)

diff --git a/checkstyle.xml b/checkstyle.xml
index 14c6565bf..61d22636a 100644
--- a/checkstyle.xml
+++ b/checkstyle.xml
@@ -116,8 +116,10 @@
     <module name="RedundantModifier" />
     <module name="ModifierOrder" />
 
-    <!--
+    <!-- Use a consistent way to put declarations -->
     <module name="DeclarationOrder" />
+
+    <!--
     <module name="IllegalCatch" />
     <module name="StringLiteralEquality" />
     <module name="MultipleStringLiterals" />
@@ -144,6 +146,11 @@
     <property name="onCommentFormat"  value="CHECKSTYLE\: resume ConstantName"/>
     <property name="checkFormat"      value="ConstantName"/>
   </module>
+  <module name="SuppressionCommentFilter">
+    <property name="offCommentFormat" value="CHECKSTYLE\: stop HideUtilityClassConstructor"/>
+    <property name="onCommentFormat"  value="CHECKSTYLE\: resume HideUtilityClassConstructor"/>
+    <property name="checkFormat"      value="HideUtilityClassConstructor"/>
+  </module>
 
 </module>
 
diff --git a/src/main/java/org/apache/commons/math/DimensionMismatchException.java b/src/main/java/org/apache/commons/math/DimensionMismatchException.java
index 81590b635..6cc51d165 100644
--- a/src/main/java/org/apache/commons/math/DimensionMismatchException.java
+++ b/src/main/java/org/apache/commons/math/DimensionMismatchException.java
@@ -27,12 +27,18 @@ public class DimensionMismatchException extends MathException {
     /** Serializable version identifier */
     private static final long serialVersionUID = -1316089546353786411L;
 
+    /** First dimension. */
+    private final int dimension1;
+
+    /** Second dimension. */
+    private final int dimension2;
+
     /**
      * Construct an exception from the mismatched dimensions
      * @param dimension1 first dimension
      * @param dimension2 second dimension
      */
-    public DimensionMismatchException(int dimension1, int dimension2) {
+    public DimensionMismatchException(final int dimension1, final int dimension2) {
         super("dimension mismatch {0} != {1}", dimension1, dimension2);
         this.dimension1 = dimension1;
         this.dimension2 = dimension2;
@@ -54,10 +60,4 @@ public class DimensionMismatchException extends MathException {
         return dimension2;
     }
 
-    /** First dimension. */
-    private int dimension1;
-
-    /** Second dimension. */
-    private int dimension2;
-
 }
diff --git a/src/main/java/org/apache/commons/math/MathException.java b/src/main/java/org/apache/commons/math/MathException.java
index 8305cd6ac..d955964a7 100644
--- a/src/main/java/org/apache/commons/math/MathException.java
+++ b/src/main/java/org/apache/commons/math/MathException.java
@@ -48,43 +48,6 @@ public class MathException extends Exception {
      */
     private final Object[] arguments;
 
-    /**
-     * Translate a string to a given locale.
-     * @param s string to translate
-     * @param locale locale into which to translate the string
-     * @return translated string or original string
-     * for unsupported locales or unknown strings
-     */
-    private static String translate(String s, Locale locale) {
-        try {
-            ResourceBundle bundle =
-                    ResourceBundle.getBundle("org.apache.commons.math.MessagesResources", locale);
-            if (bundle.getLocale().getLanguage().equals(locale.getLanguage())) {
-                // the value of the resource is the translated string
-                return bundle.getString(s);
-            }
-
-        } catch (MissingResourceException mre) {
-            // do nothing here
-        }
-
-        // the locale is not supported or the resource is unknown
-        // don't translate and fall back to using the string as is
-        return s;
-
-    }
-
-    /**
-     * Builds a message string by from a pattern and its arguments.
-     * @param locale Locale in which the message should be translated
-     * @param pattern format specifier
-     * @param arguments format arguments
-     * @return a message string
-     */
-    private static String buildMessage(Locale locale, String pattern, Object ... arguments) {
-        return (pattern == null) ? "" : new MessageFormat(translate(pattern, locale), locale).format(arguments);
-    }
-
     /**
      * Constructs a new <code>MathException</code> with no
      * detail message.
@@ -137,6 +100,43 @@ public class MathException extends Exception {
       this.arguments = (arguments == null) ? new Object[0] : arguments.clone();
     }
 
+    /**
+     * Translate a string to a given locale.
+     * @param s string to translate
+     * @param locale locale into which to translate the string
+     * @return translated string or original string
+     * for unsupported locales or unknown strings
+     */
+    private static String translate(String s, Locale locale) {
+        try {
+            ResourceBundle bundle =
+                    ResourceBundle.getBundle("org.apache.commons.math.MessagesResources", locale);
+            if (bundle.getLocale().getLanguage().equals(locale.getLanguage())) {
+                // the value of the resource is the translated string
+                return bundle.getString(s);
+            }
+
+        } catch (MissingResourceException mre) {
+            // do nothing here
+        }
+
+        // the locale is not supported or the resource is unknown
+        // don't translate and fall back to using the string as is
+        return s;
+
+    }
+
+    /**
+     * Builds a message string by from a pattern and its arguments.
+     * @param locale Locale in which the message should be translated
+     * @param pattern format specifier
+     * @param arguments format arguments
+     * @return a message string
+     */
+    private static String buildMessage(Locale locale, String pattern, Object ... arguments) {
+        return (pattern == null) ? "" : new MessageFormat(translate(pattern, locale), locale).format(arguments);
+    }
+
     /** Gets the pattern used to build the message of this throwable.
      *
      * @return the pattern used to build the message of this throwable
diff --git a/src/main/java/org/apache/commons/math/MathRuntimeException.java b/src/main/java/org/apache/commons/math/MathRuntimeException.java
index e883995b0..301e76fae 100644
--- a/src/main/java/org/apache/commons/math/MathRuntimeException.java
+++ b/src/main/java/org/apache/commons/math/MathRuntimeException.java
@@ -49,44 +49,6 @@ public class MathRuntimeException extends RuntimeException {
      */
     private final Object[] arguments;
 
-    /**
-     * Translate a string to a given locale.
-     * @param s string to translate
-     * @param locale locale into which to translate the string
-     * @return translated string or original string
-     * for unsupported locales or unknown strings
-     */
-    private static String translate(final String s, final Locale locale) {
-        try {
-            ResourceBundle bundle =
-                    ResourceBundle.getBundle("org.apache.commons.math.MessagesResources", locale);
-            if (bundle.getLocale().getLanguage().equals(locale.getLanguage())) {
-                // the value of the resource is the translated string
-                return bundle.getString(s);
-            }
-
-        } catch (MissingResourceException mre) {
-            // do nothing here
-        }
-
-        // the locale is not supported or the resource is unknown
-        // don't translate and fall back to using the string as is
-        return s;
-
-    }
-
-    /**
-     * Builds a message string by from a pattern and its arguments.
-     * @param locale Locale in which the message should be translated
-     * @param pattern format specifier
-     * @param arguments format arguments
-     * @return a message string
-     */
-    private static String buildMessage(final Locale locale, final String pattern,
-                                       final Object ... arguments) {
-        return (pattern == null) ? "" : new MessageFormat(translate(pattern, locale), locale).format(arguments);
-    }
-
     /**
      * Constructs a new <code>MathRuntimeException</code> with specified
      * formatted detail message.
@@ -129,6 +91,44 @@ public class MathRuntimeException extends RuntimeException {
       this.arguments = (arguments == null) ? new Object[0] : arguments.clone();
     }
 
+    /**
+     * Translate a string to a given locale.
+     * @param s string to translate
+     * @param locale locale into which to translate the string
+     * @return translated string or original string
+     * for unsupported locales or unknown strings
+     */
+    private static String translate(final String s, final Locale locale) {
+        try {
+            ResourceBundle bundle =
+                    ResourceBundle.getBundle("org.apache.commons.math.MessagesResources", locale);
+            if (bundle.getLocale().getLanguage().equals(locale.getLanguage())) {
+                // the value of the resource is the translated string
+                return bundle.getString(s);
+            }
+
+        } catch (MissingResourceException mre) {
+            // do nothing here
+        }
+
+        // the locale is not supported or the resource is unknown
+        // don't translate and fall back to using the string as is
+        return s;
+
+    }
+
+    /**
+     * Builds a message string by from a pattern and its arguments.
+     * @param locale Locale in which the message should be translated
+     * @param pattern format specifier
+     * @param arguments format arguments
+     * @return a message string
+     */
+    private static String buildMessage(final Locale locale, final String pattern,
+                                       final Object ... arguments) {
+        return (pattern == null) ? "" : new MessageFormat(translate(pattern, locale), locale).format(arguments);
+    }
+
     /** Gets the pattern used to build the message of this throwable.
      *
      * @return the pattern used to build the message of this throwable
diff --git a/src/main/java/org/apache/commons/math/MessagesResources_fr.java b/src/main/java/org/apache/commons/math/MessagesResources_fr.java
index fda4a2df4..a3824468b 100644
--- a/src/main/java/org/apache/commons/math/MessagesResources_fr.java
+++ b/src/main/java/org/apache/commons/math/MessagesResources_fr.java
@@ -27,21 +27,6 @@ import java.util.ListResourceBundle;
 public class MessagesResources_fr
   extends ListResourceBundle {
 
-  /**
-   * Simple constructor.
-   */
-  public MessagesResources_fr() {
-  }
-
-  /**
-   * Get the non-translated/translated messages arrays from this resource bundle.
-   * @return non-translated/translated messages arrays
-   */
-  @Override
-  public Object[][] getContents() {
-    return CONTENTS.clone();
-  }
-
   /** Non-translated/translated messages arrays. */
   private static final Object[][] CONTENTS = {
 
@@ -854,4 +839,19 @@ public class MessagesResources_fr
 
   };
 
+  /**
+   * Simple constructor.
+   */
+  public MessagesResources_fr() {
+  }
+
+  /**
+   * Get the non-translated/translated messages arrays from this resource bundle.
+   * @return non-translated/translated messages arrays
+   */
+  @Override
+  public Object[][] getContents() {
+    return CONTENTS.clone();
+  }
+
 }
diff --git a/src/main/java/org/apache/commons/math/analysis/interpolation/LoessInterpolator.java b/src/main/java/org/apache/commons/math/analysis/interpolation/LoessInterpolator.java
index e58216865..ce1b34b44 100644
--- a/src/main/java/org/apache/commons/math/analysis/interpolation/LoessInterpolator.java
+++ b/src/main/java/org/apache/commons/math/analysis/interpolation/LoessInterpolator.java
@@ -41,18 +41,15 @@ import org.apache.commons.math.analysis.polynomials.PolynomialSplineFunction;
 public class LoessInterpolator
         implements UnivariateRealInterpolator, Serializable {
 
+    /** Default value of the bandwidth parameter. */
+    public static final double DEFAULT_BANDWIDTH = 0.3;
+
+    /** Default value of the number of robustness iterations. */
+    public static final int DEFAULT_ROBUSTNESS_ITERS = 2;
+
     /** serializable version identifier. */
     private static final long serialVersionUID = 5204927143605193821L;
 
-    /**
-     * Default value of the bandwidth parameter.
-     */
-    public static final double DEFAULT_BANDWIDTH = 0.3;
-    /**
-     * Default value of the number of robustness iterations.
-     */
-    public static final int DEFAULT_ROBUSTNESS_ITERS = 2;
-
     /**
      * The bandwidth parameter: when computing the loess fit at
      * a particular point, this fraction of source points closest
diff --git a/src/main/java/org/apache/commons/math/analysis/solvers/UnivariateRealSolverUtils.java b/src/main/java/org/apache/commons/math/analysis/solvers/UnivariateRealSolverUtils.java
index 7482747b2..d4c386fee 100644
--- a/src/main/java/org/apache/commons/math/analysis/solvers/UnivariateRealSolverUtils.java
+++ b/src/main/java/org/apache/commons/math/analysis/solvers/UnivariateRealSolverUtils.java
@@ -229,19 +229,14 @@ public class UnivariateRealSolverUtils {
         }
     }
 
+    // CHECKSTYLE: stop HideUtilityClassConstructor
     /** Holder for the factory.
      * <p>We use here the Initialization On Demand Holder Idiom.</p>
      */
     private static class LazyHolder {
-
-        /** Private constructor. */
-        private LazyHolder() {
-        }
-
         /** Cached solver factory */
-        private static final UnivariateRealSolverFactory FACTORY =
-            UnivariateRealSolverFactory.newInstance();
-
+        private static final UnivariateRealSolverFactory FACTORY = UnivariateRealSolverFactory.newInstance();
     }
+    // CHECKSTYLE: resume HideUtilityClassConstructor
 
 }
diff --git a/src/main/java/org/apache/commons/math/complex/Complex.java b/src/main/java/org/apache/commons/math/complex/Complex.java
index 86845e5fc..aa92b8679 100644
--- a/src/main/java/org/apache/commons/math/complex/Complex.java
+++ b/src/main/java/org/apache/commons/math/complex/Complex.java
@@ -45,9 +45,6 @@ import org.apache.commons.math.util.MathUtils;
  */
 public class Complex implements FieldElement<Complex>, Serializable  {
 
-    /** Serializable version identifier */
-    private static final long serialVersionUID = -6195664516687396620L;
-
     /** The square root of -1. A number representing "0.0 + 1.0i" */
     public static final Complex I = new Complex(0.0, 1.0);
 
@@ -65,24 +62,19 @@ public class Complex implements FieldElement<Complex>, Serializable  {
     /** A complex number representing "0.0 + 0.0i" */
     public static final Complex ZERO = new Complex(0.0, 0.0);
 
-    /**
-     * The imaginary part
-     */
+    /** Serializable version identifier */
+    private static final long serialVersionUID = -6195664516687396620L;
+
+    /** The imaginary part. */
     private final double imaginary;
 
-    /**
-     * The real part
-     */
+    /** The real part. */
     private final double real;
 
-    /**
-     * Record whether this complex number is equal to NaN
-     */
+    /** Record whether this complex number is equal to NaN. */
     private final transient boolean isNaN;
 
-    /**
-     * Record whether this complex number is infinite
-     */
+    /** Record whether this complex number is infinite. */
     private final transient boolean isInfinite;
 
     /**
diff --git a/src/main/java/org/apache/commons/math/complex/ComplexField.java b/src/main/java/org/apache/commons/math/complex/ComplexField.java
index 99705806a..3e91a94f8 100644
--- a/src/main/java/org/apache/commons/math/complex/ComplexField.java
+++ b/src/main/java/org/apache/commons/math/complex/ComplexField.java
@@ -57,19 +57,15 @@ public class ComplexField implements Field<Complex>, Serializable  {
         return Complex.ZERO;
     }
 
+    // CHECKSTYLE: stop HideUtilityClassConstructor
     /** Holder for the instance.
      * <p>We use here the Initialization On Demand Holder Idiom.</p>
      */
     private static class LazyHolder {
-
-        /** Private constructor. */
-        private LazyHolder() {
-        }
-
         /** Cached field instance. */
         private static final ComplexField INSTANCE = new ComplexField();
-
     }
+    // CHECKSTYLE: resume HideUtilityClassConstructor
 
     /** Handle deserialization of the singleton.
      * @return the singleton instance
diff --git a/src/main/java/org/apache/commons/math/estimation/AbstractEstimator.java b/src/main/java/org/apache/commons/math/estimation/AbstractEstimator.java
index 85c38de43..8b149c4b3 100644
--- a/src/main/java/org/apache/commons/math/estimation/AbstractEstimator.java
+++ b/src/main/java/org/apache/commons/math/estimation/AbstractEstimator.java
@@ -40,6 +40,47 @@ public abstract class AbstractEstimator implements Estimator {
     /** Default maximal number of cost evaluations allowed. */
     public static final int DEFAULT_MAX_COST_EVALUATIONS = 100;
 
+    /** Array of measurements. */
+    protected WeightedMeasurement[] measurements;
+
+    /** Array of parameters. */
+    protected EstimatedParameter[] parameters;
+
+    /**
+     * Jacobian matrix.
+     * <p>This matrix is in canonical form just after the calls to
+     * {@link #updateJacobian()}, but may be modified by the solver
+     * in the derived class (the {@link LevenbergMarquardtEstimator
+     * Levenberg-Marquardt estimator} does this).</p>
+     */
+    protected double[] jacobian;
+
+    /** Number of columns of the jacobian matrix. */
+    protected int cols;
+
+    /** Number of rows of the jacobian matrix. */
+    protected int rows;
+
+    /** Residuals array.
+     * <p>This array is in canonical form just after the calls to
+     * {@link #updateJacobian()}, but may be modified by the solver
+     * in the derived class (the {@link LevenbergMarquardtEstimator
+     * Levenberg-Marquardt estimator} does this).</p>
+     */
+    protected double[] residuals;
+
+    /** Cost value (square root of the sum of the residuals). */
+    protected double cost;
+
+    /** Maximal allowed number of cost evaluations. */
+    private int maxCostEval;
+
+    /** Number of cost evaluations. */
+    private int costEvaluations;
+
+    /** Number of jacobian evaluations. */
+    private int jacobianEvaluations;
+
     /**
      * Build an abstract estimator for least squares problems.
      * <p>The maximal number of cost evaluations allowed is set
@@ -270,45 +311,4 @@ public abstract class AbstractEstimator implements Estimator {
     public abstract void estimate(EstimationProblem problem)
     throws EstimationException;
 
-    /** Array of measurements. */
-    protected WeightedMeasurement[] measurements;
-
-    /** Array of parameters. */
-    protected EstimatedParameter[] parameters;
-
-    /**
-     * Jacobian matrix.
-     * <p>This matrix is in canonical form just after the calls to
-     * {@link #updateJacobian()}, but may be modified by the solver
-     * in the derived class (the {@link LevenbergMarquardtEstimator
-     * Levenberg-Marquardt estimator} does this).</p>
-     */
-    protected double[] jacobian;
-
-    /** Number of columns of the jacobian matrix. */
-    protected int cols;
-
-    /** Number of rows of the jacobian matrix. */
-    protected int rows;
-
-    /** Residuals array.
-     * <p>This array is in canonical form just after the calls to
-     * {@link #updateJacobian()}, but may be modified by the solver
-     * in the derived class (the {@link LevenbergMarquardtEstimator
-     * Levenberg-Marquardt estimator} does this).</p>
-     */
-    protected double[] residuals;
-
-    /** Cost value (square root of the sum of the residuals). */
-    protected double cost;
-
-    /** Maximal allowed number of cost evaluations. */
-    private int maxCostEval;
-
-    /** Number of cost evaluations. */
-    private int costEvaluations;
-
-    /** Number of jacobian evaluations. */
-    private int jacobianEvaluations;
-
 }
diff --git a/src/main/java/org/apache/commons/math/estimation/EstimatedParameter.java b/src/main/java/org/apache/commons/math/estimation/EstimatedParameter.java
index b193d6701..9c8bea883 100644
--- a/src/main/java/org/apache/commons/math/estimation/EstimatedParameter.java
+++ b/src/main/java/org/apache/commons/math/estimation/EstimatedParameter.java
@@ -37,90 +37,90 @@ import java.io.Serializable;
 public class EstimatedParameter
   implements Serializable {
 
-  /** Simple constructor.
-   * Build an instance from a first estimate of the parameter,
-   * initially considered unbound.
-   * @param name name of the parameter
-   * @param firstEstimate first estimate of the parameter
-   */
-  public EstimatedParameter(String name, double firstEstimate) {
-    this.name = name;
-    estimate  = firstEstimate;
-    bound     = false;
-  }
+    /** Serializable version identifier */
+    private static final long serialVersionUID = -555440800213416949L;
 
-  /** Simple constructor.
-   * Build an instance from a first estimate of the parameter and a
-   * bound flag
-   * @param name name of the parameter
-   * @param firstEstimate first estimate of the parameter
-   * @param bound flag, should be true if the parameter is bound
-   */
-  public EstimatedParameter(String name,
-                            double firstEstimate,
-                            boolean bound) {
-    this.name  = name;
-    estimate   = firstEstimate;
-    this.bound = bound;
-  }
+    /** Current value of the parameter */
+    protected double  estimate;
 
-  /** Copy constructor.
-   * Build a copy of a parameter
-   * @param parameter instance to copy
-   */
-  public EstimatedParameter(EstimatedParameter parameter) {
-    name     = parameter.name;
-    estimate = parameter.estimate;
-    bound    = parameter.bound;
-  }
+    /** Name of the parameter */
+    private   String  name;
 
-  /** Set a new estimated value for the parameter.
-   * @param estimate new estimate for the parameter
-   */
-  public void setEstimate(double estimate) {
-    this.estimate = estimate;
-  }
+    /** Indicator for bound parameters
+     * (ie parameters that should not be estimated)
+     */
+    private   boolean bound;
 
-  /** Get the current estimate of the parameter
-   * @return current estimate
-   */
-  public double getEstimate() {
-    return estimate;
-  }
+    /** Simple constructor.
+     * Build an instance from a first estimate of the parameter,
+     * initially considered unbound.
+     * @param name name of the parameter
+     * @param firstEstimate first estimate of the parameter
+     */
+    public EstimatedParameter(String name, double firstEstimate) {
+        this.name = name;
+        estimate  = firstEstimate;
+        bound     = false;
+    }
 
-  /** get the name of the parameter
-   * @return parameter name
-   */
-  public String getName() {
-    return name;
-  }
+    /** Simple constructor.
+     * Build an instance from a first estimate of the parameter and a
+     * bound flag
+     * @param name name of the parameter
+     * @param firstEstimate first estimate of the parameter
+     * @param bound flag, should be true if the parameter is bound
+     */
+    public EstimatedParameter(String name,
+                              double firstEstimate,
+                              boolean bound) {
+        this.name  = name;
+        estimate   = firstEstimate;
+        this.bound = bound;
+    }
 
-  /** Set the bound flag of the parameter
-   * @param bound this flag should be set to true if the parameter is
-   * bound (i.e. if it should not be adjusted by the solver).
-   */
-  public void setBound(boolean bound) {
-    this.bound = bound;
-  }
+    /** Copy constructor.
+     * Build a copy of a parameter
+     * @param parameter instance to copy
+     */
+    public EstimatedParameter(EstimatedParameter parameter) {
+        name     = parameter.name;
+        estimate = parameter.estimate;
+        bound    = parameter.bound;
+    }
 
-  /** Check if the parameter is bound
-   * @return true if the parameter is bound */
-  public boolean isBound() {
-    return bound;
-  }
+    /** Set a new estimated value for the parameter.
+     * @param estimate new estimate for the parameter
+     */
+    public void setEstimate(double estimate) {
+        this.estimate = estimate;
+    }
 
-  /** Name of the parameter */
-  private   String  name;
+    /** Get the current estimate of the parameter
+     * @return current estimate
+     */
+    public double getEstimate() {
+        return estimate;
+    }
 
-  /** Current value of the parameter */
-  protected double  estimate;
+    /** get the name of the parameter
+     * @return parameter name
+     */
+    public String getName() {
+        return name;
+    }
 
-  /** Indicator for bound parameters
-   * (ie parameters that should not be estimated)
-   */
-  private   boolean bound;
+    /** Set the bound flag of the parameter
+     * @param bound this flag should be set to true if the parameter is
+     * bound (i.e. if it should not be adjusted by the solver).
+     */
+    public void setBound(boolean bound) {
+        this.bound = bound;
+    }
 
-  /** Serializable version identifier */
-  private static final long serialVersionUID = -555440800213416949L;
+    /** Check if the parameter is bound
+     * @return true if the parameter is bound */
+    public boolean isBound() {
+        return bound;
+    }
 
 }
diff --git a/src/main/java/org/apache/commons/math/estimation/LevenbergMarquardtEstimator.java b/src/main/java/org/apache/commons/math/estimation/LevenbergMarquardtEstimator.java
index 7fbca8d07..2fc1f0e1c 100644
--- a/src/main/java/org/apache/commons/math/estimation/LevenbergMarquardtEstimator.java
+++ b/src/main/java/org/apache/commons/math/estimation/LevenbergMarquardtEstimator.java
@@ -103,6 +103,46 @@ import java.util.Arrays;
 @Deprecated
 public class LevenbergMarquardtEstimator extends AbstractEstimator implements Serializable {
 
+    /** Serializable version identifier */
+    private static final long serialVersionUID = -5705952631533171019L;
+
+    /** Number of solved variables. */
+    private int solvedCols;
+
+    /** Diagonal elements of the R matrix in the Q.R. decomposition. */
+    private double[] diagR;
+
+    /** Norms of the columns of the jacobian matrix. */
+    private double[] jacNorm;
+
+    /** Coefficients of the Householder transforms vectors. */
+    private double[] beta;
+
+    /** Columns permutation array. */
+    private int[] permutation;
+
+    /** Rank of the jacobian matrix. */
+    private int rank;
+
+    /** Levenberg-Marquardt parameter. */
+    private double lmPar;
+
+    /** Parameters evolution direction associated with lmPar. */
+    private double[] lmDir;
+
+    /** Positive input variable used in determining the initial step bound. */
+    private double initialStepBoundFactor;
+
+    /** Desired relative error in the sum of squares. */
+    private double costRelativeTolerance;
+
+    /**  Desired relative error in the approximate solution parameters. */
+    private double parRelativeTolerance;
+
+    /** Desired max cosine on the orthogonality between the function vector
+     * and the columns of the jacobian. */
+    private double orthoTolerance;
+
   /**
    * Build an estimator for least squares problems.
    * <p>The default values for the algorithm settings are:
@@ -834,44 +874,4 @@ public class LevenbergMarquardtEstimator extends AbstractEstimator implements Se
     }
   }
 
-  /** Number of solved variables. */
-  private int solvedCols;
-
-  /** Diagonal elements of the R matrix in the Q.R. decomposition. */
-  private double[] diagR;
-
-  /** Norms of the columns of the jacobian matrix. */
-  private double[] jacNorm;
-
-  /** Coefficients of the Householder transforms vectors. */
-  private double[] beta;
-
-  /** Columns permutation array. */
-  private int[] permutation;
-
-  /** Rank of the jacobian matrix. */
-  private int rank;
-
-  /** Levenberg-Marquardt parameter. */
-  private double lmPar;
-
-  /** Parameters evolution direction associated with lmPar. */
-  private double[] lmDir;
-
-  /** Positive input variable used in determining the initial step bound. */
-  private double initialStepBoundFactor;
-
-  /** Desired relative error in the sum of squares. */
-  private double costRelativeTolerance;
-
-  /**  Desired relative error in the approximate solution parameters. */
-  private double parRelativeTolerance;
-
-  /** Desired max cosine on the orthogonality between the function vector
-   * and the columns of the jacobian. */
-  private double orthoTolerance;
-
-  /** Serializable version identifier */
-  private static final long serialVersionUID = -5705952631533171019L;
-
 }
diff --git a/src/main/java/org/apache/commons/math/estimation/SimpleEstimationProblem.java b/src/main/java/org/apache/commons/math/estimation/SimpleEstimationProblem.java
index eacf7be99..b0794b950 100644
--- a/src/main/java/org/apache/commons/math/estimation/SimpleEstimationProblem.java
+++ b/src/main/java/org/apache/commons/math/estimation/SimpleEstimationProblem.java
@@ -44,6 +44,12 @@ import java.util.List;
 @Deprecated
 public class SimpleEstimationProblem implements EstimationProblem {
 
+    /** Estimated parameters. */
+    private final List<EstimatedParameter> parameters;
+
+    /** Measurements. */
+    private final List<WeightedMeasurement> measurements;
+
     /**
      * Build an empty instance without parameters nor measurements.
      */
@@ -102,10 +108,4 @@ public class SimpleEstimationProblem implements EstimationProblem {
         measurements.add(m);
     }
 
-    /** Estimated parameters. */
-    private final List<EstimatedParameter> parameters;
-
-    /** Measurements. */
-    private final List<WeightedMeasurement> measurements;
-
 }
diff --git a/src/main/java/org/apache/commons/math/estimation/WeightedMeasurement.java b/src/main/java/org/apache/commons/math/estimation/WeightedMeasurement.java
index 2ba679fd5..a34678f12 100644
--- a/src/main/java/org/apache/commons/math/estimation/WeightedMeasurement.java
+++ b/src/main/java/org/apache/commons/math/estimation/WeightedMeasurement.java
@@ -56,7 +56,16 @@ public abstract class WeightedMeasurement implements Serializable {
     /** Serializable version identifier. */
     private static final long serialVersionUID = 4360046376796901941L;
 
-    /**
+    /** Measurement weight. */
+    private final double  weight;
+
+    /** Value of the measurements. */
+    private final double  measuredValue;
+
+    /** Ignore measurement indicator. */
+    private boolean ignored;
+
+  /**
    * Simple constructor.
    * Build a measurement with the given parameters, and set its ignore
    * flag to false.
@@ -160,13 +169,4 @@ public abstract class WeightedMeasurement implements Serializable {
     return ignored;
   }
 
-  /** Measurement weight. */
-  private final double  weight;
-
-  /** Value of the measurements. */
-  private final double  measuredValue;
-
-  /** Ignore measurement indicator. */
-  private       boolean ignored;
-
 }
diff --git a/src/main/java/org/apache/commons/math/fraction/BigFraction.java b/src/main/java/org/apache/commons/math/fraction/BigFraction.java
index 6412f9f68..bd2849444 100644
--- a/src/main/java/org/apache/commons/math/fraction/BigFraction.java
+++ b/src/main/java/org/apache/commons/math/fraction/BigFraction.java
@@ -89,34 +89,6 @@ public class BigFraction
     /** The denominator. */
     private final BigInteger denominator;
 
-    /**
-     * <p>
-     * Creates a <code>BigFraction</code> instance with the 2 parts of a fraction
-     * Y/Z.
-     * </p>
-     *
-     * <p>
-     * Any negative signs are resolved to be on the numerator.
-     * </p>
-     *
-     * @param numerator
-     *            the numerator, for example the three in 'three sevenths'.
-     * @param denominator
-     *            the denominator, for example the seven in 'three sevenths'.
-     * @return a new fraction instance, with the numerator and denominator
-     *         reduced.
-     * @throws ArithmeticException
-     *             if the denominator is <code>zero</code>.
-     */
-    public static BigFraction getReducedFraction(final int numerator,
-                                                 final int denominator) {
-        if (numerator == 0) {
-            return ZERO; // normalize zero.
-        }
-
-        return new BigFraction(numerator, denominator);
-    }
-
     /**
      * <p>
      * Create a {@link BigFraction} equivalent to the passed <tt>BigInteger</tt>, ie
@@ -441,6 +413,34 @@ public class BigFraction
         this(BigInteger.valueOf(num), BigInteger.valueOf(den));
     }
 
+    /**
+     * <p>
+     * Creates a <code>BigFraction</code> instance with the 2 parts of a fraction
+     * Y/Z.
+     * </p>
+     *
+     * <p>
+     * Any negative signs are resolved to be on the numerator.
+     * </p>
+     *
+     * @param numerator
+     *            the numerator, for example the three in 'three sevenths'.
+     * @param denominator
+     *            the denominator, for example the seven in 'three sevenths'.
+     * @return a new fraction instance, with the numerator and denominator
+     *         reduced.
+     * @throws ArithmeticException
+     *             if the denominator is <code>zero</code>.
+     */
+    public static BigFraction getReducedFraction(final int numerator,
+                                                 final int denominator) {
+        if (numerator == 0) {
+            return ZERO; // normalize zero.
+        }
+
+        return new BigFraction(numerator, denominator);
+    }
+
     /**
      * <p>
      * Returns the absolute value of this {@link BigFraction}.
diff --git a/src/main/java/org/apache/commons/math/fraction/BigFractionField.java b/src/main/java/org/apache/commons/math/fraction/BigFractionField.java
index 44dce3567..8df4e0703 100644
--- a/src/main/java/org/apache/commons/math/fraction/BigFractionField.java
+++ b/src/main/java/org/apache/commons/math/fraction/BigFractionField.java
@@ -57,19 +57,15 @@ public class BigFractionField implements Field<BigFraction>, Serializable  {
         return BigFraction.ZERO;
     }
 
+    // CHECKSTYLE: stop HideUtilityClassConstructor
     /** Holder for the instance.
      * <p>We use here the Initialization On Demand Holder Idiom.</p>
      */
     private static class LazyHolder {
-
-        /** Private constructor. */
-        private LazyHolder() {
-        }
-
         /** Cached field instance. */
         private static final BigFractionField INSTANCE = new BigFractionField();
-
     }
+    // CHECKSTYLE: resume HideUtilityClassConstructor
 
     /** Handle deserialization of the singleton.
      * @return the singleton instance
diff --git a/src/main/java/org/apache/commons/math/fraction/FractionField.java b/src/main/java/org/apache/commons/math/fraction/FractionField.java
index dbf0c40df..c802fdd5b 100644
--- a/src/main/java/org/apache/commons/math/fraction/FractionField.java
+++ b/src/main/java/org/apache/commons/math/fraction/FractionField.java
@@ -57,19 +57,15 @@ public class FractionField implements Field<Fraction>, Serializable  {
         return Fraction.ZERO;
     }
 
+    // CHECKSTYLE: stop HideUtilityClassConstructor
     /** Holder for the instance.
      * <p>We use here the Initialization On Demand Holder Idiom.</p>
      */
     private static class LazyHolder {
-
-        /** Private constructor. */
-        private LazyHolder() {
-        }
-
         /** Cached field instance. */
         private static final FractionField INSTANCE = new FractionField();
-
     }
+    // CHECKSTYLE: resume HideUtilityClassConstructor
 
     /** Handle deserialization of the singleton.
      * @return the singleton instance
diff --git a/src/main/java/org/apache/commons/math/genetics/GeneticAlgorithm.java b/src/main/java/org/apache/commons/math/genetics/GeneticAlgorithm.java
index 9d3a9756b..04ae10f53 100644
--- a/src/main/java/org/apache/commons/math/genetics/GeneticAlgorithm.java
+++ b/src/main/java/org/apache/commons/math/genetics/GeneticAlgorithm.java
@@ -37,24 +37,6 @@ public class GeneticAlgorithm {
     //@GuardedBy("this")
     private static RandomGenerator randomGenerator = new JDKRandomGenerator();
 
-    /**
-     * Set the (static) random generator.
-     *
-     * @param random random generator
-     */
-    public static synchronized void setRandomGenerator(RandomGenerator random) {
-        randomGenerator = random;
-    }
-
-    /**
-     * Returns the (static) random generator.
-     *
-     * @return the static random generator shared by GA implementation classes
-     */
-    public static synchronized RandomGenerator getRandomGenerator() {
-        return randomGenerator;
-    }
-
     /** the crossover policy used by the algorithm. */
     private final CrossoverPolicy crossoverPolicy;
 
@@ -94,6 +76,24 @@ public class GeneticAlgorithm {
         this.selectionPolicy = selectionPolicy;
     }
 
+    /**
+     * Set the (static) random generator.
+     *
+     * @param random random generator
+     */
+    public static synchronized void setRandomGenerator(RandomGenerator random) {
+        randomGenerator = random;
+    }
+
+    /**
+     * Returns the (static) random generator.
+     *
+     * @return the static random generator shared by GA implementation classes
+     */
+    public static synchronized RandomGenerator getRandomGenerator() {
+        return randomGenerator;
+    }
+
     /**
      * Evolve the given population. Evolution stops when the stopping condition
      * is satisfied.
diff --git a/src/main/java/org/apache/commons/math/geometry/CardanEulerSingularityException.java b/src/main/java/org/apache/commons/math/geometry/CardanEulerSingularityException.java
index 1272f7d0e..65271a228 100644
--- a/src/main/java/org/apache/commons/math/geometry/CardanEulerSingularityException.java
+++ b/src/main/java/org/apache/commons/math/geometry/CardanEulerSingularityException.java
@@ -28,17 +28,17 @@ import org.apache.commons.math.MathException;
 public class CardanEulerSingularityException
   extends MathException {
 
-  /**
-   * 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
-   */
-  public CardanEulerSingularityException(boolean isCardan) {
-    super(isCardan ? "Cardan angles singularity" : "Euler angles singularity");
-  }
+    /** Serializable version identifier */
+    private static final long serialVersionUID = -1360952845582206770L;
 
-  /** Serializable version identifier */
-  private static final long serialVersionUID = -1360952845582206770L;
+    /**
+     * 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
+     */
+    public CardanEulerSingularityException(boolean isCardan) {
+        super(isCardan ? "Cardan angles singularity" : "Euler angles singularity");
+    }
 
 }
diff --git a/src/main/java/org/apache/commons/math/geometry/NotARotationMatrixException.java b/src/main/java/org/apache/commons/math/geometry/NotARotationMatrixException.java
index cd74d5946..6622b0a07 100644
--- a/src/main/java/org/apache/commons/math/geometry/NotARotationMatrixException.java
+++ b/src/main/java/org/apache/commons/math/geometry/NotARotationMatrixException.java
@@ -30,17 +30,17 @@ import org.apache.commons.math.MathException;
 public class NotARotationMatrixException
   extends MathException {
 
-  /**
-   * 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)
-   */
-  public NotARotationMatrixException(String specifier, Object ... parts) {
-    super(specifier, parts);
-  }
+    /** Serializable version identifier */
+    private static final long serialVersionUID = 5647178478658937642L;
 
-  /** Serializable version identifier */
-  private static final long serialVersionUID = 5647178478658937642L;
+    /**
+     * 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)
+     */
+    public NotARotationMatrixException(String specifier, Object ... parts) {
+        super(specifier, parts);
+    }
 
 }
diff --git a/src/main/java/org/apache/commons/math/geometry/RotationOrder.java b/src/main/java/org/apache/commons/math/geometry/RotationOrder.java
index dae50127e..f6aae1972 100644
--- a/src/main/java/org/apache/commons/math/geometry/RotationOrder.java
+++ b/src/main/java/org/apache/commons/math/geometry/RotationOrder.java
@@ -31,145 +31,145 @@ package org.apache.commons.math.geometry;
  */
 public final class RotationOrder {
 
-  /** Private constructor.
-   * This is a utility class that cannot be instantiated by the user,
-   * so its only constructor is private.
-   * @param name name of the rotation order
-   * @param a1 axis of the first rotation
-   * @param a2 axis of the second rotation
-   * @param a3 axis of the third rotation
-   */
-  private RotationOrder(String name,
-                        Vector3D a1, Vector3D a2, Vector3D a3) {
-    this.name = name;
-    this.a1   = a1;
-    this.a2   = a2;
-    this.a3   = a3;
-  }
+    /** Set of Cardan angles.
+     * this ordered set of rotations is around X, then around Y, then
+     * around Z
+     */
+    public static final RotationOrder XYZ =
+      new RotationOrder("XYZ", Vector3D.PLUS_I, Vector3D.PLUS_J, Vector3D.PLUS_K);
 
-  /** Get a string representation of the instance.
-   * @return a string representation of the instance (in fact, its name)
-   */
-  @Override
-  public String toString() {
-    return name;
-  }
+    /** Set of Cardan angles.
+     * this ordered set of rotations is around X, then around Z, then
+     * around Y
+     */
+    public static final RotationOrder XZY =
+      new RotationOrder("XZY", Vector3D.PLUS_I, Vector3D.PLUS_K, Vector3D.PLUS_J);
 
-  /** Get the axis of the first rotation.
-   * @return axis of the first rotation
-   */
-  public Vector3D getA1() {
-    return a1;
-  }
+    /** Set of Cardan angles.
+     * this ordered set of rotations is around Y, then around X, then
+     * around Z
+     */
+    public static final RotationOrder YXZ =
+      new RotationOrder("YXZ", Vector3D.PLUS_J, Vector3D.PLUS_I, Vector3D.PLUS_K);
 
-  /** Get the axis of the second rotation.
-   * @return axis of the second rotation
-   */
-  public Vector3D getA2() {
-    return a2;
-  }
+    /** Set of Cardan angles.
+     * this ordered set of rotations is around Y, then around Z, then
+     * around X
+     */
+    public static final RotationOrder YZX =
+      new RotationOrder("YZX", Vector3D.PLUS_J, Vector3D.PLUS_K, Vector3D.PLUS_I);
 
-  /** Get the axis of the second rotation.
-   * @return axis of the second rotation
-   */
-  public Vector3D getA3() {
-    return a3;
-  }
+    /** Set of Cardan angles.
+     * this ordered set of rotations is around Z, then around X, then
+     * around Y
+     */
+    public static final RotationOrder ZXY =
+      new RotationOrder("ZXY", Vector3D.PLUS_K, Vector3D.PLUS_I, Vector3D.PLUS_J);
 
-  /** Set of Cardan angles.
-   * this ordered set of rotations is around X, then around Y, then
-   * around Z
-   */
-  public static final RotationOrder XYZ =
-    new RotationOrder("XYZ", Vector3D.PLUS_I, Vector3D.PLUS_J, Vector3D.PLUS_K);
+    /** Set of Cardan angles.
+     * this ordered set of rotations is around Z, then around Y, then
+     * around X
+     */
+    public static final RotationOrder ZYX =
+      new RotationOrder("ZYX", Vector3D.PLUS_K, Vector3D.PLUS_J, Vector3D.PLUS_I);
 
-  /** Set of Cardan angles.
-   * this ordered set of rotations is around X, then around Z, then
-   * around Y
-   */
-  public static final RotationOrder XZY =
-    new RotationOrder("XZY", Vector3D.PLUS_I, Vector3D.PLUS_K, Vector3D.PLUS_J);
+    /** Set of Euler angles.
+     * this ordered set of rotations is around X, then around Y, then
+     * around X
+     */
+    public static final RotationOrder XYX =
+      new RotationOrder("XYX", Vector3D.PLUS_I, Vector3D.PLUS_J, Vector3D.PLUS_I);
 
-  /** Set of Cardan angles.
-   * this ordered set of rotations is around Y, then around X, then
-   * around Z
-   */
-  public static final RotationOrder YXZ =
-    new RotationOrder("YXZ", Vector3D.PLUS_J, Vector3D.PLUS_I, Vector3D.PLUS_K);
+    /** Set of Euler angles.
+     * this ordered set of rotations is around X, then around Z, then
+     * around X
+     */
+    public static final RotationOrder XZX =
+      new RotationOrder("XZX", Vector3D.PLUS_I, Vector3D.PLUS_K, Vector3D.PLUS_I);
 
-  /** Set of Cardan angles.
-   * this ordered set of rotations is around Y, then around Z, then
-   * around X
-   */
-  public static final RotationOrder YZX =
-    new RotationOrder("YZX", Vector3D.PLUS_J, Vector3D.PLUS_K, Vector3D.PLUS_I);
+    /** Set of Euler angles.
+     * this ordered set of rotations is around Y, then around X, then
+     * around Y
+     */
+    public static final RotationOrder YXY =
+      new RotationOrder("YXY", Vector3D.PLUS_J, Vector3D.PLUS_I, Vector3D.PLUS_J);
 
-  /** Set of Cardan angles.
-   * this ordered set of rotations is around Z, then around X, then
-   * around Y
-   */
-  public static final RotationOrder ZXY =
-    new RotationOrder("ZXY", Vector3D.PLUS_K, Vector3D.PLUS_I, Vector3D.PLUS_J);
+    /** Set of Euler angles.
+     * this ordered set of rotations is around Y, then around Z, then
+     * around Y
+     */
+    public static final RotationOrder YZY =
+      new RotationOrder("YZY", Vector3D.PLUS_J, Vector3D.PLUS_K, Vector3D.PLUS_J);
 
-  /** Set of Cardan angles.
-   * this ordered set of rotations is around Z, then around Y, then
-   * around X
-   */
-  public static final RotationOrder ZYX =
-    new RotationOrder("ZYX", Vector3D.PLUS_K, Vector3D.PLUS_J, Vector3D.PLUS_I);
+    /** Set of Euler angles.
+     * this ordered set of rotations is around Z, then around X, then
+     * around Z
+     */
+    public static final RotationOrder ZXZ =
+      new RotationOrder("ZXZ", Vector3D.PLUS_K, Vector3D.PLUS_I, Vector3D.PLUS_K);
 
-  /** Set of Euler angles.
-   * this ordered set of rotations is around X, then around Y, then
-   * around X
-   */
-  public static final RotationOrder XYX =
-    new RotationOrder("XYX", Vector3D.PLUS_I, Vector3D.PLUS_J, Vector3D.PLUS_I);
+    /** Set of Euler angles.
+     * this ordered set of rotations is around Z, then around Y, then
+     * around Z
+     */
+    public static final RotationOrder ZYZ =
+      new RotationOrder("ZYZ", Vector3D.PLUS_K, Vector3D.PLUS_J, Vector3D.PLUS_K);
 
-  /** Set of Euler angles.
-   * this ordered set of rotations is around X, then around Z, then
-   * around X
-   */
-  public static final RotationOrder XZX =
-    new RotationOrder("XZX", Vector3D.PLUS_I, Vector3D.PLUS_K, Vector3D.PLUS_I);
+    /** Name of the rotations order. */
+    private final String name;
 
-  /** Set of Euler angles.
-   * this ordered set of rotations is around Y, then around X, then
-   * around Y
-   */
-  public static final RotationOrder YXY =
-    new RotationOrder("YXY", Vector3D.PLUS_J, Vector3D.PLUS_I, Vector3D.PLUS_J);
+    /** Axis of the first rotation. */
+    private final Vector3D a1;
 
-  /** Set of Euler angles.
-   * this ordered set of rotations is around Y, then around Z, then
-   * around Y
-   */
-  public static final RotationOrder YZY =
-    new RotationOrder("YZY", Vector3D.PLUS_J, Vector3D.PLUS_K, Vector3D.PLUS_J);
+    /** Axis of the second rotation. */
+    private final Vector3D a2;
 
-  /** Set of Euler angles.
-   * this ordered set of rotations is around Z, then around X, then
-   * around Z
-   */
-  public static final RotationOrder ZXZ =
-    new RotationOrder("ZXZ", Vector3D.PLUS_K, Vector3D.PLUS_I, Vector3D.PLUS_K);
+    /** Axis of the third rotation. */
+    private final Vector3D a3;
 
-  /** Set of Euler angles.
-   * this ordered set of rotations is around Z, then around Y, then
-   * around Z
-   */
-  public static final RotationOrder ZYZ =
-    new RotationOrder("ZYZ", Vector3D.PLUS_K, Vector3D.PLUS_J, Vector3D.PLUS_K);
+    /** Private constructor.
+     * This is a utility class that cannot be instantiated by the user,
+     * so its only constructor is private.
+     * @param name name of the rotation order
+     * @param a1 axis of the first rotation
+     * @param a2 axis of the second rotation
+     * @param a3 axis of the third rotation
+     */
+    private RotationOrder(final String name,
+                          final Vector3D a1, final Vector3D a2, final Vector3D a3) {
+        this.name = name;
+        this.a1   = a1;
+        this.a2   = a2;
+        this.a3   = a3;
+    }
 
-  /** Name of the rotations order. */
-  private final String name;
+    /** Get a string representation of the instance.
+     * @return a string representation of the instance (in fact, its name)
+     */
+    @Override
+    public String toString() {
+        return name;
+    }
 
-  /** Axis of the first rotation. */
-  private final Vector3D a1;
+    /** Get the axis of the first rotation.
+     * @return axis of the first rotation
+     */
+    public Vector3D getA1() {
+        return a1;
+    }
 
-  /** Axis of the second rotation. */
-  private final Vector3D a2;
+    /** Get the axis of the second rotation.
+     * @return axis of the second rotation
+     */
+    public Vector3D getA2() {
+        return a2;
+    }
 
-  /** Axis of the third rotation. */
-  private final Vector3D a3;
+    /** Get the axis of the second rotation.
+     * @return axis of the second rotation
+     */
+    public Vector3D getA3() {
+        return a3;
+    }
 
 }
diff --git a/src/main/java/org/apache/commons/math/linear/AbstractFieldMatrix.java b/src/main/java/org/apache/commons/math/linear/AbstractFieldMatrix.java
index bc996b42e..d719621e2 100644
--- a/src/main/java/org/apache/commons/math/linear/AbstractFieldMatrix.java
+++ b/src/main/java/org/apache/commons/math/linear/AbstractFieldMatrix.java
@@ -38,6 +38,45 @@ public abstract class AbstractFieldMatrix<T extends FieldElement<T>> implements
     /** Field to which the elements belong. */
     private final Field<T> field;
 
+    /**
+     * Constructor for use with Serializable
+     */
+    protected AbstractFieldMatrix() {
+        field = null;
+    }
+
+    /**
+     * Creates a matrix with no data
+     * @param field field to which the elements belong
+     */
+    protected AbstractFieldMatrix(final Field<T> field) {
+        this.field = field;
+    }
+
+    /**
+     * Create a new FieldMatrix<T> with the supplied row and column dimensions.
+     *
+     * @param field field to which the elements belong
+     * @param rowDimension  the number of rows in the new matrix
+     * @param columnDimension  the number of columns in the new matrix
+     * @throws IllegalArgumentException if row or column dimension is not positive
+     */
+    protected AbstractFieldMatrix(final Field<T> field,
+                                  final int rowDimension, final int columnDimension)
+        throws IllegalArgumentException {
+        if (rowDimension <= 0 ) {
+            throw MathRuntimeException.createIllegalArgumentException(
+                    "invalid row dimension {0} (must be positive)",
+                    rowDimension);
+        }
+        if (columnDimension <= 0) {
+            throw MathRuntimeException.createIllegalArgumentException(
+                    "invalid column dimension {0} (must be positive)",
+                    columnDimension);
+        }
+        this.field = field;
+    }
+
     /**
      * Get the elements type from an array.
      * @param <T> the type of the field elements
@@ -115,45 +154,6 @@ public abstract class AbstractFieldMatrix<T extends FieldElement<T>> implements
         return array;
     }
 
-    /**
-     * Constructor for use with Serializable
-     */
-    protected AbstractFieldMatrix() {
-        field = null;
-    }
-
-    /**
-     * Creates a matrix with no data
-     * @param field field to which the elements belong
-     */
-    protected AbstractFieldMatrix(final Field<T> field) {
-        this.field = field;
-    }
-
-    /**
-     * Create a new FieldMatrix<T> with the supplied row and column dimensions.
-     *
-     * @param field field to which the elements belong
-     * @param rowDimension  the number of rows in the new matrix
-     * @param columnDimension  the number of columns in the new matrix
-     * @throws IllegalArgumentException if row or column dimension is not positive
-     */
-    protected AbstractFieldMatrix(final Field<T> field,
-                                  final int rowDimension, final int columnDimension)
-        throws IllegalArgumentException {
-        if (rowDimension <= 0 ) {
-            throw MathRuntimeException.createIllegalArgumentException(
-                    "invalid row dimension {0} (must be positive)",
-                    rowDimension);
-        }
-        if (columnDimension <= 0) {
-            throw MathRuntimeException.createIllegalArgumentException(
-                    "invalid column dimension {0} (must be positive)",
-                    columnDimension);
-        }
-        this.field = field;
-    }
-
     /** {@inheritDoc} */
     public Field<T> getField() {
         return field;
diff --git a/src/main/java/org/apache/commons/math/linear/ArrayFieldVector.java b/src/main/java/org/apache/commons/math/linear/ArrayFieldVector.java
index 2ec1ed6dc..5b17dccd6 100644
--- a/src/main/java/org/apache/commons/math/linear/ArrayFieldVector.java
+++ b/src/main/java/org/apache/commons/math/linear/ArrayFieldVector.java
@@ -35,20 +35,11 @@ public class ArrayFieldVector<T extends FieldElement<T>> implements FieldVector<
     /** Serializable version identifier. */
     private static final long serialVersionUID = 7648186910365927050L;
 
-    /** Field to which the elements belong. */
-    private final Field<T> field;
-
     /** Entries of the vector. */
     protected T[] data;
 
-    /** Build an array of elements.
-     * @param length size of the array to build
-     * @return a new array
-     */
-    @SuppressWarnings("unchecked")
-    private T[] buildArray(final int length) {
-        return (T[]) Array.newInstance(field.getZero().getClass(), length);
-    }
+    /** Field to which the elements belong. */
+    private final Field<T> field;
 
     /**
      * Build a 0-length vector.
@@ -228,6 +219,15 @@ public class ArrayFieldVector<T extends FieldElement<T>> implements FieldVector<
         }
     }
 
+    /** Build an array of elements.
+     * @param length size of the array to build
+     * @return a new array
+     */
+    @SuppressWarnings("unchecked")
+    private T[] buildArray(final int length) {
+        return (T[]) Array.newInstance(field.getZero().getClass(), length);
+    }
+
     /** {@inheritDoc} */
     public Field<T> getField() {
         return field;
diff --git a/src/main/java/org/apache/commons/math/linear/BigMatrixImpl.java b/src/main/java/org/apache/commons/math/linear/BigMatrixImpl.java
index e4cff9691..373356497 100644
--- a/src/main/java/org/apache/commons/math/linear/BigMatrixImpl.java
+++ b/src/main/java/org/apache/commons/math/linear/BigMatrixImpl.java
@@ -54,6 +54,15 @@ import org.apache.commons.math.MathRuntimeException;
 @Deprecated
 public class BigMatrixImpl implements BigMatrix, Serializable {
 
+    /** BigDecimal 0 */
+    static final BigDecimal ZERO = new BigDecimal(0);
+
+    /** BigDecimal 1 */
+    static final BigDecimal ONE = new BigDecimal(1);
+
+    /** Bound to determine effective singularity in LU decomposition */
+    private static final BigDecimal TOO_SMALL = new BigDecimal(10E-12);
+
     /** Serialization id */
     private static final long serialVersionUID = -1011428905656140431L;
 
@@ -77,14 +86,6 @@ public class BigMatrixImpl implements BigMatrix, Serializable {
     /*** BigDecimal scale ***/
     private int scale = 64;
 
-    /** Bound to determine effective singularity in LU decomposition */
-    private static final BigDecimal TOO_SMALL = new BigDecimal(10E-12);
-
-    /** BigDecimal 0 */
-    static final BigDecimal ZERO = new BigDecimal(0);
-    /** BigDecimal 1 */
-    static final BigDecimal ONE = new BigDecimal(1);
-
     /**
      * Creates a matrix with no data
      */
diff --git a/src/main/java/org/apache/commons/math/linear/BlockFieldMatrix.java b/src/main/java/org/apache/commons/math/linear/BlockFieldMatrix.java
index a7f00b19b..cd87d2363 100644
--- a/src/main/java/org/apache/commons/math/linear/BlockFieldMatrix.java
+++ b/src/main/java/org/apache/commons/math/linear/BlockFieldMatrix.java
@@ -65,12 +65,12 @@ import org.apache.commons.math.MathRuntimeException;
  */
 public class BlockFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMatrix<T> implements Serializable {
 
-    /** Serializable version identifier */
-    private static final long serialVersionUID = -4602336630143123183L;
-
     /** Block size. */
     public static final int BLOCK_SIZE = 36;
 
+    /** Serializable version identifier */
+    private static final long serialVersionUID = -4602336630143123183L;
+
     /** Blocks of matrix entries. */
     private final T blocks[][];
 
diff --git a/src/main/java/org/apache/commons/math/linear/BlockRealMatrix.java b/src/main/java/org/apache/commons/math/linear/BlockRealMatrix.java
index 0d4706ba8..cfb0a0f4d 100644
--- a/src/main/java/org/apache/commons/math/linear/BlockRealMatrix.java
+++ b/src/main/java/org/apache/commons/math/linear/BlockRealMatrix.java
@@ -63,12 +63,12 @@ import org.apache.commons.math.MathRuntimeException;
  */
 public class BlockRealMatrix extends AbstractRealMatrix implements Serializable {
 
-    /** Serializable version identifier */
-    private static final long serialVersionUID = 4991895511313664478L;
-
     /** Block size. */
     public static final int BLOCK_SIZE = 52;
 
+    /** Serializable version identifier */
+    private static final long serialVersionUID = 4991895511313664478L;
+
     /** Blocks of matrix entries. */
     private final double blocks[][];
 
diff --git a/src/main/java/org/apache/commons/math/linear/LUDecompositionImpl.java b/src/main/java/org/apache/commons/math/linear/LUDecompositionImpl.java
index 357b44fdd..2f403c037 100644
--- a/src/main/java/org/apache/commons/math/linear/LUDecompositionImpl.java
+++ b/src/main/java/org/apache/commons/math/linear/LUDecompositionImpl.java
@@ -33,6 +33,9 @@ import org.apache.commons.math.MathRuntimeException;
  */
 public class LUDecompositionImpl implements LUDecomposition {
 
+    /** Default bound to determine effective singularity in LU decomposition */
+    private static final double DEFAULT_TOO_SMALL = 10E-12;
+
     /** Entries of LU decomposition. */
     private double lu[][];
 
@@ -54,9 +57,6 @@ public class LUDecompositionImpl implements LUDecomposition {
     /** Cached value of P. */
     private RealMatrix cachedP;
 
-    /** Default bound to determine effective singularity in LU decomposition */
-    private static final double DEFAULT_TOO_SMALL = 10E-12;
-
     /**
      * Calculates the LU-decomposition of the given matrix.
      * @param matrix The matrix to decompose.
diff --git a/src/main/java/org/apache/commons/math/linear/OpenMapRealVector.java b/src/main/java/org/apache/commons/math/linear/OpenMapRealVector.java
index 2ea35fe9a..c404aafda 100644
--- a/src/main/java/org/apache/commons/math/linear/OpenMapRealVector.java
+++ b/src/main/java/org/apache/commons/math/linear/OpenMapRealVector.java
@@ -29,12 +29,12 @@ import org.apache.commons.math.util.OpenIntToDoubleHashMap.Iterator;
 */
 public class OpenMapRealVector implements SparseRealVector, Serializable {
 
-    /** Serializable version identifier. */
-    private static final long serialVersionUID = 8772222695580707260L;
-
     /** Default Tolerance for having a value considered zero. */
     public static final double DEFAULT_ZERO_TOLERANCE = 1.0e-12;
 
+    /** Serializable version identifier. */
+    private static final long serialVersionUID = 8772222695580707260L;
+
     /** Entries of the vector. */
     private final OpenIntToDoubleHashMap entries;
 
diff --git a/src/main/java/org/apache/commons/math/ode/AbstractIntegrator.java b/src/main/java/org/apache/commons/math/ode/AbstractIntegrator.java
index ea1546da7..4b4d0b928 100644
--- a/src/main/java/org/apache/commons/math/ode/AbstractIntegrator.java
+++ b/src/main/java/org/apache/commons/math/ode/AbstractIntegrator.java
@@ -34,6 +34,17 @@ import org.apache.commons.math.ode.sampling.StepHandler;
  */
 public abstract class AbstractIntegrator implements FirstOrderIntegrator {
 
+    /** Step handler. */
+    protected Collection<StepHandler> stepHandlers;
+
+    /** Current step start time. */
+    protected double stepStart;
+
+    /** Current stepsize. */
+    protected double stepSize;
+
+    /** Events handlers manager. */
+    protected CombinedEventsManager eventsHandlersManager;
 
     /** Name of the method. */
     private final String name;
@@ -47,18 +58,6 @@ public abstract class AbstractIntegrator implements FirstOrderIntegrator {
     /** Differential equations to integrate. */
     private transient FirstOrderDifferentialEquations equations;
 
-    /** Step handler. */
-    protected Collection<StepHandler> stepHandlers;
-
-    /** Current step start time. */
-    protected double stepStart;
-
-    /** Current stepsize. */
-    protected double stepSize;
-
-    /** Events handlers manager. */
-    protected CombinedEventsManager eventsHandlersManager;
-
     /** Build an instance.
      * @param name name of the method
      */
diff --git a/src/main/java/org/apache/commons/math/ode/ContinuousOutputModel.java b/src/main/java/org/apache/commons/math/ode/ContinuousOutputModel.java
index 8a61ed2ae..02b64b3d9 100644
--- a/src/main/java/org/apache/commons/math/ode/ContinuousOutputModel.java
+++ b/src/main/java/org/apache/commons/math/ode/ContinuousOutputModel.java
@@ -86,6 +86,24 @@ import org.apache.commons.math.ode.sampling.StepInterpolator;
 public class ContinuousOutputModel
   implements StepHandler, Serializable {
 
+    /** Serializable version identifier */
+    private static final long serialVersionUID = -1417964919405031606L;
+
+    /** Initial integration time. */
+    private double initialTime;
+
+    /** Final integration time. */
+    private double finalTime;
+
+    /** Integration direction indicator. */
+    private boolean forward;
+
+    /** Current interpolator index. */
+    private int index;
+
+    /** Steps table. */
+    private List<StepInterpolator> steps;
+
   /** Simple constructor.
    * Build an empty continuous output model.
    */
@@ -355,22 +373,4 @@ public class ContinuousOutputModel
     }
   }
 
-  /** Initial integration time. */
-  private double initialTime;
-
-  /** Final integration time. */
-  private double finalTime;
-
-  /** Integration direction indicator. */
-  private boolean forward;
-
-  /** Current interpolator index. */
-  private int index;
-
-  /** Steps table. */
-  private List<StepInterpolator> steps;
-
-  /** Serializable version identifier */
-  private static final long serialVersionUID = -1417964919405031606L;
-
 }
diff --git a/src/main/java/org/apache/commons/math/ode/FirstOrderConverter.java b/src/main/java/org/apache/commons/math/ode/FirstOrderConverter.java
index 830f781b9..4313c391a 100644
--- a/src/main/java/org/apache/commons/math/ode/FirstOrderConverter.java
+++ b/src/main/java/org/apache/commons/math/ode/FirstOrderConverter.java
@@ -55,6 +55,21 @@ package org.apache.commons.math.ode;
 
 public class FirstOrderConverter implements FirstOrderDifferentialEquations {
 
+    /** Underlying second order equations set. */
+    private final SecondOrderDifferentialEquations equations;
+
+    /** second order problem dimension. */
+    private final int dimension;
+
+    /** state vector. */
+    private final double[] z;
+
+    /** first time derivative of the state vector. */
+    private final double[] zDot;
+
+    /** second time derivative of the state vector. */
+    private final double[] zDDot;
+
   /** Simple constructor.
    * Build a converter around a second order equations set.
    * @param equations second order equations set to convert
@@ -99,19 +114,4 @@ public class FirstOrderConverter implements FirstOrderDifferentialEquations {
 
   }
 
-  /** Underlying second order equations set. */
-  private SecondOrderDifferentialEquations equations;
-
-  /** second order problem dimension. */
-  private int dimension;
-
-  /** state vector. */
-  private double[] z;
-
-  /** first time derivative of the state vector. */
-  private double[] zDot;
-
-  /** second time derivative of the state vector. */
-  private double[] zDDot;
-
 }
diff --git a/src/main/java/org/apache/commons/math/ode/MultistepIntegrator.java b/src/main/java/org/apache/commons/math/ode/MultistepIntegrator.java
index 1c14d546c..d33bdfed1 100644
--- a/src/main/java/org/apache/commons/math/ode/MultistepIntegrator.java
+++ b/src/main/java/org/apache/commons/math/ode/MultistepIntegrator.java
@@ -58,12 +58,6 @@ import org.apache.commons.math.ode.sampling.StepInterpolator;
  */
 public abstract class MultistepIntegrator extends AdaptiveStepsizeIntegrator {
 
-    /** Starter integrator. */
-    private FirstOrderIntegrator starter;
-
-    /** Number of steps of the multistep method (excluding the one being computed). */
-    private final int nSteps;
-
     /** First scaled derivative (h y'). */
     protected double[] scaled;
 
@@ -72,6 +66,12 @@ public abstract class MultistepIntegrator extends AdaptiveStepsizeIntegrator {
      */
     protected Array2DRowRealMatrix nordsieck;
 
+    /** Starter integrator. */
+    private FirstOrderIntegrator starter;
+
+    /** Number of steps of the multistep method (excluding the one being computed). */
+    private final int nSteps;
+
     /** Stepsize control exponent. */
     private double exp;
 
diff --git a/src/main/java/org/apache/commons/math/ode/nonstiff/AdaptiveStepsizeIntegrator.java b/src/main/java/org/apache/commons/math/ode/nonstiff/AdaptiveStepsizeIntegrator.java
index 097329d5b..549f1091f 100644
--- a/src/main/java/org/apache/commons/math/ode/nonstiff/AdaptiveStepsizeIntegrator.java
+++ b/src/main/java/org/apache/commons/math/ode/nonstiff/AdaptiveStepsizeIntegrator.java
@@ -54,6 +54,26 @@ import org.apache.commons.math.ode.IntegratorException;
 public abstract class AdaptiveStepsizeIntegrator
   extends AbstractIntegrator {
 
+    /** Allowed absolute scalar error. */
+    protected final double scalAbsoluteTolerance;
+
+    /** Allowed relative scalar error. */
+    protected final double scalRelativeTolerance;
+
+    /** Allowed absolute vectorial error. */
+    protected final double[] vecAbsoluteTolerance;
+
+    /** Allowed relative vectorial error. */
+    protected final double[] vecRelativeTolerance;
+
+    /** User supplied initial step. */
+    private double initialStep;
+
+    /** Minimal step. */
+    private final double minStep;
+
+    /** Maximal step. */
+    private final double maxStep;
 
   /** Build an integrator with the given stepsize bounds.
    * The default step handler does nothing.
@@ -310,25 +330,4 @@ public abstract class AdaptiveStepsizeIntegrator
     return maxStep;
   }
 
-  /** Minimal step. */
-  private double minStep;
-
-  /** Maximal step. */
-  private double maxStep;
-
-  /** User supplied initial step. */
-  private double initialStep;
-
-  /** Allowed absolute scalar error. */
-  protected double scalAbsoluteTolerance;
-
-  /** Allowed relative scalar error. */
-  protected double scalRelativeTolerance;
-
-  /** Allowed absolute vectorial error. */
-  protected double[] vecAbsoluteTolerance;
-
-  /** Allowed relative vectorial error. */
-  protected double[] vecRelativeTolerance;
-
 }
diff --git a/src/main/java/org/apache/commons/math/ode/nonstiff/DormandPrince54StepInterpolator.java b/src/main/java/org/apache/commons/math/ode/nonstiff/DormandPrince54StepInterpolator.java
index d1d917777..5358af9ae 100644
--- a/src/main/java/org/apache/commons/math/ode/nonstiff/DormandPrince54StepInterpolator.java
+++ b/src/main/java/org/apache/commons/math/ode/nonstiff/DormandPrince54StepInterpolator.java
@@ -34,6 +34,61 @@ import org.apache.commons.math.ode.sampling.StepInterpolator;
 class DormandPrince54StepInterpolator
   extends RungeKuttaStepInterpolator {
 
+    /** Last row of the Butcher-array internal weights, element 0. */
+    private static final double A70 =    35.0 /  384.0;
+
+    // element 1 is zero, so it is neither stored nor used
+
+    /** Last row of the Butcher-array internal weights, element 2. */
+    private static final double A72 =   500.0 / 1113.0;
+
+    /** Last row of the Butcher-array internal weights, element 3. */
+    private static final double A73 =   125.0 /  192.0;
+
+    /** Last row of the Butcher-array internal weights, element 4. */
+    private static final double A74 = -2187.0 / 6784.0;
+
+    /** Last row of the Butcher-array internal weights, element 5. */
+    private static final double A75 =    11.0 /   84.0;
+
+    /** Shampine (1986) Dense output, element 0. */
+    private static final double D0 =  -12715105075.0 /  11282082432.0;
+
+    // element 1 is zero, so it is neither stored nor used
+
+    /** Shampine (1986) Dense output, element 2. */
+    private static final double D2 =   87487479700.0 /  32700410799.0;
+
+    /** Shampine (1986) Dense output, element 3. */
+    private static final double D3 =  -10690763975.0 /   1880347072.0;
+
+    /** Shampine (1986) Dense output, element 4. */
+    private static final double D4 =  701980252875.0 / 199316789632.0;
+
+    /** Shampine (1986) Dense output, element 5. */
+    private static final double D5 =   -1453857185.0 /    822651844.0;
+
+    /** Shampine (1986) Dense output, element 6. */
+    private static final double D6 =      69997945.0 /     29380423.0;
+
+    /** Serializable version identifier */
+    private static final long serialVersionUID = 4104157279605906956L;
+
+    /** First vector for interpolation. */
+    private double[] v1;
+
+    /** Second vector for interpolation. */
+    private double[] v2;
+
+    /** Third vector for interpolation. */
+    private double[] v3;
+
+    /** Fourth vector for interpolation. */
+    private double[] v4;
+
+    /** Initialization indicator for the interpolation vectors. */
+    private boolean vectorsInitialized;
+
   /** Simple constructor.
    * This constructor builds an instance that is not usable yet, the
    * {@link #reinitialize} method should be called before using the
@@ -156,59 +211,4 @@ class DormandPrince54StepInterpolator
 
   }
 
-  /** First vector for interpolation. */
-  private double[] v1;
-
-  /** Second vector for interpolation. */
-  private double[] v2;
-
-  /** Third vector for interpolation. */
-  private double[] v3;
-
-  /** Fourth vector for interpolation. */
-  private double[] v4;
-
-  /** Initialization indicator for the interpolation vectors. */
-  private boolean vectorsInitialized;
-
-  /** Last row of the Butcher-array internal weights, element 0. */
-  private static final double A70 =    35.0 /  384.0;
-
-  // element 1 is zero, so it is neither stored nor used
-
-  /** Last row of the Butcher-array internal weights, element 2. */
-  private static final double A72 =   500.0 / 1113.0;
-
-  /** Last row of the Butcher-array internal weights, element 3. */
-  private static final double A73 =   125.0 /  192.0;
-
-  /** Last row of the Butcher-array internal weights, element 4. */
-  private static final double A74 = -2187.0 / 6784.0;
-
-  /** Last row of the Butcher-array internal weights, element 5. */
-  private static final double A75 =    11.0 /   84.0;
-
-  /** Shampine (1986) Dense output, element 0. */
-  private static final double D0 =  -12715105075.0 /  11282082432.0;
-
-  // element 1 is zero, so it is neither stored nor used
-
-  /** Shampine (1986) Dense output, element 2. */
-  private static final double D2 =   87487479700.0 /  32700410799.0;
-
-  /** Shampine (1986) Dense output, element 3. */
-  private static final double D3 =  -10690763975.0 /   1880347072.0;
-
-  /** Shampine (1986) Dense output, element 4. */
-  private static final double D4 =  701980252875.0 / 199316789632.0;
-
-  /** Shampine (1986) Dense output, element 5. */
-  private static final double D5 =   -1453857185.0 /    822651844.0;
-
-  /** Shampine (1986) Dense output, element 6. */
-  private static final double D6 =      69997945.0 /     29380423.0;
-
-  /** Serializable version identifier */
-  private static final long serialVersionUID = 4104157279605906956L;
-
 }
diff --git a/src/main/java/org/apache/commons/math/ode/nonstiff/DormandPrince853StepInterpolator.java b/src/main/java/org/apache/commons/math/ode/nonstiff/DormandPrince853StepInterpolator.java
index b2b61d217..a5ff994c9 100644
--- a/src/main/java/org/apache/commons/math/ode/nonstiff/DormandPrince853StepInterpolator.java
+++ b/src/main/java/org/apache/commons/math/ode/nonstiff/DormandPrince853StepInterpolator.java
@@ -39,6 +39,186 @@ import org.apache.commons.math.ode.sampling.StepInterpolator;
 class DormandPrince853StepInterpolator
   extends RungeKuttaStepInterpolator {
 
+    /** Serializable version identifier */
+    private static final long serialVersionUID = 7152276390558450974L;
+
+    /** Propagation weights, element 1. */
+    private static final double B_01 =         104257.0 / 1920240.0;
+
+    // elements 2 to 5 are zero, so they are neither stored nor used
+
+    /** Propagation weights, element 6. */
+    private static final double B_06 =        3399327.0 / 763840.0;
+
+    /** Propagation weights, element 7. */
+    private static final double B_07 =       66578432.0 / 35198415.0;
+
+    /** Propagation weights, element 8. */
+    private static final double B_08 =    -1674902723.0 / 288716400.0;
+
+    /** Propagation weights, element 9. */
+    private static final double B_09 = 54980371265625.0 / 176692375811392.0;
+
+    /** Propagation weights, element 10. */
+    private static final double B_10 =        -734375.0 / 4826304.0;
+
+    /** Propagation weights, element 11. */
+    private static final double B_11 =      171414593.0 / 851261400.0;
+
+    /** Propagation weights, element 12. */
+    private static final double B_12 =         137909.0 / 3084480.0;
+
+    /** Time step for stage 14 (interpolation only). */
+    private static final double C14    = 1.0 / 10.0;
+
+    /** Internal weights for stage 14, element 1. */
+    private static final double K14_01 =       13481885573.0 / 240030000000.0      - B_01;
+
+    // elements 2 to 5 are zero, so they are neither stored nor used
+
+    /** Internal weights for stage 14, element 6. */
+    private static final double K14_06 =                 0.0                       - B_06;
+
+    /** Internal weights for stage 14, element 7. */
+    private static final double K14_07 =      139418837528.0 / 549975234375.0      - B_07;
+
+    /** Internal weights for stage 14, element 8. */
+    private static final double K14_08 =   -11108320068443.0 / 45111937500000.0    - B_08;
+
+    /** Internal weights for stage 14, element 9. */
+    private static final double K14_09 = -1769651421925959.0 / 14249385146080000.0 - B_09;
+
+    /** Internal weights for stage 14, element 10. */
+    private static final double K14_10 =          57799439.0 / 377055000.0         - B_10;
+
+    /** Internal weights for stage 14, element 11. */
+    private static final double K14_11 =      793322643029.0 / 96734250000000.0    - B_11;
+
+    /** Internal weights for stage 14, element 12. */
+    private static final double K14_12 =        1458939311.0 / 192780000000.0      - B_12;
+
+    /** Internal weights for stage 14, element 13. */
+    private static final double K14_13 =             -4149.0 / 500000.0;
+
+    /** Time step for stage 15 (interpolation only). */
+    private static final double C15    = 1.0 / 5.0;
+
+
+    /** Internal weights for stage 15, element 1. */
+    private static final double K15_01 =     1595561272731.0 / 50120273500000.0    - B_01;
+
+    // elements 2 to 5 are zero, so they are neither stored nor used
+
+    /** Internal weights for stage 15, element 6. */
+    private static final double K15_06 =      975183916491.0 / 34457688031250.0    - B_06;
+
+    /** Internal weights for stage 15, element 7. */
+    private static final double K15_07 =    38492013932672.0 / 718912673015625.0   - B_07;
+
+    /** Internal weights for stage 15, element 8. */
+    private static final double K15_08 = -1114881286517557.0 / 20298710767500000.0 - B_08;
+
+    /** Internal weights for stage 15, element 9. */
+    private static final double K15_09 =                 0.0                       - B_09;
+
+    /** Internal weights for stage 15, element 10. */
+    private static final double K15_10 =                 0.0                       - B_10;
+
+    /** Internal weights for stage 15, element 11. */
+    private static final double K15_11 =    -2538710946863.0 / 23431227861250000.0 - B_11;
+
+    /** Internal weights for stage 15, element 12. */
+    private static final double K15_12 =        8824659001.0 / 23066716781250.0    - B_12;
+
+    /** Internal weights for stage 15, element 13. */
+    private static final double K15_13 =      -11518334563.0 / 33831184612500.0;
+
+    /** Internal weights for stage 15, element 14. */
+    private static final double K15_14 =        1912306948.0 / 13532473845.0;
+
+    /** Time step for stage 16 (interpolation only). */
+    private static final double C16    = 7.0 / 9.0;
+
+
+    /** Internal weights for stage 16, element 1. */
+    private static final double K16_01 =      -13613986967.0 / 31741908048.0       - B_01;
+
+    // elements 2 to 5 are zero, so they are neither stored nor used
+
+    /** Internal weights for stage 16, element 6. */
+    private static final double K16_06 =       -4755612631.0 / 1012344804.0        - B_06;
+
+    /** Internal weights for stage 16, element 7. */
+    private static final double K16_07 =    42939257944576.0 / 5588559685701.0     - B_07;
+
+    /** Internal weights for stage 16, element 8. */
+    private static final double K16_08 =    77881972900277.0 / 19140370552944.0    - B_08;
+
+    /** Internal weights for stage 16, element 9. */
+    private static final double K16_09 =    22719829234375.0 / 63689648654052.0    - B_09;
+
+    /** Internal weights for stage 16, element 10. */
+    private static final double K16_10 =                 0.0                       - B_10;
+
+    /** Internal weights for stage 16, element 11. */
+    private static final double K16_11 =                 0.0                       - B_11;
+
+    /** Internal weights for stage 16, element 12. */
+    private static final double K16_12 =                 0.0                       - B_12;
+
+    /** Internal weights for stage 16, element 13. */
+    private static final double K16_13 =       -1199007803.0 / 857031517296.0;
+
+    /** Internal weights for stage 16, element 14. */
+    private static final double K16_14 =      157882067000.0 / 53564469831.0;
+
+    /** Internal weights for stage 16, element 15. */
+    private static final double K16_15 =     -290468882375.0 / 31741908048.0;
+
+    /** Interpolation weights.
+     * (beware that only the non-null values are in the table)
+     */
+    private static final double[][] D = {
+
+      {        -17751989329.0 / 2106076560.0,               4272954039.0 / 7539864640.0,
+              -118476319744.0 / 38604839385.0,            755123450731.0 / 316657731600.0,
+        3692384461234828125.0 / 1744130441634250432.0,     -4612609375.0 / 5293382976.0,
+              2091772278379.0 / 933644586600.0,             2136624137.0 / 3382989120.0,
+                    -126493.0 / 1421424.0,                    98350000.0 / 5419179.0,
+                  -18878125.0 / 2053168.0,                 -1944542619.0 / 438351368.0},
+
+      {         32941697297.0 / 3159114840.0,             456696183123.0 / 1884966160.0,
+             19132610714624.0 / 115814518155.0,       -177904688592943.0 / 474986597400.0,
+       -4821139941836765625.0 / 218016305204281304.0,      30702015625.0 / 3970037232.0,
+            -85916079474274.0 / 2800933759800.0,           -5919468007.0 / 634310460.0,
+                    2479159.0 / 157936.0,                    -18750000.0 / 602131.0,
+                  -19203125.0 / 2053168.0,                 15700361463.0 / 438351368.0},
+
+      {         12627015655.0 / 631822968.0,              -72955222965.0 / 188496616.0,
+            -13145744952320.0 / 69488710893.0,          30084216194513.0 / 56998391688.0,
+        -296858761006640625.0 / 25648977082856624.0,         569140625.0 / 82709109.0,
+               -18684190637.0 / 18672891732.0,                69644045.0 / 89549712.0,
+                  -11847025.0 / 4264272.0,                  -978650000.0 / 16257537.0,
+                  519371875.0 / 6159504.0,                  5256837225.0 / 438351368.0},
+
+      {          -450944925.0 / 17550638.0,               -14532122925.0 / 94248308.0,
+              -595876966400.0 / 2573655959.0,             188748653015.0 / 527762886.0,
+        2545485458115234375.0 / 27252038150535163.0,       -1376953125.0 / 36759604.0,
+                53995596795.0 / 518691437.0,                 210311225.0 / 7047894.0,
+                   -1718875.0 / 39484.0,                      58000000.0 / 602131.0,
+                   -1546875.0 / 39484.0,                   -1262172375.0 / 8429834.0}
+
+    };
+
+    /** Last evaluations. */
+    private double[][] yDotKLast;
+
+    /** Vectors for interpolation. */
+    private double[][] v;
+
+    /** Initialization indicator for the interpolation vectors. */
+    private boolean vectorsInitialized;
+
   /** Simple constructor.
    * This constructor builds an instance that is not usable yet, the
    * {@link #reinitialize} method should be called before using the
@@ -295,184 +475,4 @@ class DormandPrince853StepInterpolator
 
   }
 
-  /** Last evaluations. */
-  private double[][] yDotKLast;
-
-  /** Vectors for interpolation. */
-  private double[][] v;
-
-  /** Initialization indicator for the interpolation vectors. */
-  private boolean vectorsInitialized;
-
-  /** Propagation weights, element 1. */
-  private static final double B_01 =         104257.0 / 1920240.0;
-
-  // elements 2 to 5 are zero, so they are neither stored nor used
-
-  /** Propagation weights, element 6. */
-  private static final double B_06 =        3399327.0 / 763840.0;
-
-  /** Propagation weights, element 7. */
-  private static final double B_07 =       66578432.0 / 35198415.0;
-
-  /** Propagation weights, element 8. */
-  private static final double B_08 =    -1674902723.0 / 288716400.0;
-
-  /** Propagation weights, element 9. */
-  private static final double B_09 = 54980371265625.0 / 176692375811392.0;
-
-  /** Propagation weights, element 10. */
-  private static final double B_10 =        -734375.0 / 4826304.0;
-
-  /** Propagation weights, element 11. */
-  private static final double B_11 =      171414593.0 / 851261400.0;
-
-  /** Propagation weights, element 12. */
-  private static final double B_12 =         137909.0 / 3084480.0;
-
-  /** Time step for stage 14 (interpolation only). */
-  private static final double C14    = 1.0 / 10.0;
-
-  /** Internal weights for stage 14, element 1. */
-  private static final double K14_01 =       13481885573.0 / 240030000000.0      - B_01;
-
-  // elements 2 to 5 are zero, so they are neither stored nor used
-
-  /** Internal weights for stage 14, element 6. */
-  private static final double K14_06 =                 0.0                       - B_06;
-
-  /** Internal weights for stage 14, element 7. */
-  private static final double K14_07 =      139418837528.0 / 549975234375.0      - B_07;
-
-  /** Internal weights for stage 14, element 8. */
-  private static final double K14_08 =   -11108320068443.0 / 45111937500000.0    - B_08;
-
-  /** Internal weights for stage 14, element 9. */
-  private static final double K14_09 = -1769651421925959.0 / 14249385146080000.0 - B_09;
-
-  /** Internal weights for stage 14, element 10. */
-  private static final double K14_10 =          57799439.0 / 377055000.0         - B_10;
-
-  /** Internal weights for stage 14, element 11. */
-  private static final double K14_11 =      793322643029.0 / 96734250000000.0    - B_11;
-
-  /** Internal weights for stage 14, element 12. */
-  private static final double K14_12 =        1458939311.0 / 192780000000.0      - B_12;
-
-  /** Internal weights for stage 14, element 13. */
-  private static final double K14_13 =             -4149.0 / 500000.0;
-
-  /** Time step for stage 15 (interpolation only). */
-  private static final double C15    = 1.0 / 5.0;
-
-
-  /** Internal weights for stage 15, element 1. */
-  private static final double K15_01 =     1595561272731.0 / 50120273500000.0    - B_01;
-
-  // elements 2 to 5 are zero, so they are neither stored nor used
-
-  /** Internal weights for stage 15, element 6. */
-  private static final double K15_06 =      975183916491.0 / 34457688031250.0    - B_06;
-
-  /** Internal weights for stage 15, element 7. */
-  private static final double K15_07 =    38492013932672.0 / 718912673015625.0   - B_07;
-
-  /** Internal weights for stage 15, element 8. */
-  private static final double K15_08 = -1114881286517557.0 / 20298710767500000.0 - B_08;
-
-  /** Internal weights for stage 15, element 9. */
-  private static final double K15_09 =                 0.0                       - B_09;
-
-  /** Internal weights for stage 15, element 10. */
-  private static final double K15_10 =                 0.0                       - B_10;
-
-  /** Internal weights for stage 15, element 11. */
-  private static final double K15_11 =    -2538710946863.0 / 23431227861250000.0 - B_11;
-
-  /** Internal weights for stage 15, element 12. */
-  private static final double K15_12 =        8824659001.0 / 23066716781250.0    - B_12;
-
-  /** Internal weights for stage 15, element 13. */
-  private static final double K15_13 =      -11518334563.0 / 33831184612500.0;
-
-  /** Internal weights for stage 15, element 14. */
-  private static final double K15_14 =        1912306948.0 / 13532473845.0;
-
-  /** Time step for stage 16 (interpolation only). */
-  private static final double C16    = 7.0 / 9.0;
-
-
-  /** Internal weights for stage 16, element 1. */
-  private static final double K16_01 =      -13613986967.0 / 31741908048.0       - B_01;
-
-  // elements 2 to 5 are zero, so they are neither stored nor used
-
-  /** Internal weights for stage 16, element 6. */
-  private static final double K16_06 =       -4755612631.0 / 1012344804.0        - B_06;
-
-  /** Internal weights for stage 16, element 7. */
-  private static final double K16_07 =    42939257944576.0 / 5588559685701.0     - B_07;
-
-  /** Internal weights for stage 16, element 8. */
-  private static final double K16_08 =    77881972900277.0 / 19140370552944.0    - B_08;
-
-  /** Internal weights for stage 16, element 9. */
-  private static final double K16_09 =    22719829234375.0 / 63689648654052.0    - B_09;
-
-  /** Internal weights for stage 16, element 10. */
-  private static final double K16_10 =                 0.0                       - B_10;
-
-  /** Internal weights for stage 16, element 11. */
-  private static final double K16_11 =                 0.0                       - B_11;
-
-  /** Internal weights for stage 16, element 12. */
-  private static final double K16_12 =                 0.0                       - B_12;
-
-  /** Internal weights for stage 16, element 13. */
-  private static final double K16_13 =       -1199007803.0 / 857031517296.0;
-
-  /** Internal weights for stage 16, element 14. */
-  private static final double K16_14 =      157882067000.0 / 53564469831.0;
-
-  /** Internal weights for stage 16, element 15. */
-  private static final double K16_15 =     -290468882375.0 / 31741908048.0;
-
-  /** Interpolation weights.
-   * (beware that only the non-null values are in the table)
-   */
-  private static final double[][] D = {
-
-    {        -17751989329.0 / 2106076560.0,               4272954039.0 / 7539864640.0,
-            -118476319744.0 / 38604839385.0,            755123450731.0 / 316657731600.0,
-      3692384461234828125.0 / 1744130441634250432.0,     -4612609375.0 / 5293382976.0,
-            2091772278379.0 / 933644586600.0,             2136624137.0 / 3382989120.0,
-                  -126493.0 / 1421424.0,                    98350000.0 / 5419179.0,
-                -18878125.0 / 2053168.0,                 -1944542619.0 / 438351368.0},
-
-    {         32941697297.0 / 3159114840.0,             456696183123.0 / 1884966160.0,
-           19132610714624.0 / 115814518155.0,       -177904688592943.0 / 474986597400.0,
-     -4821139941836765625.0 / 218016305204281304.0,      30702015625.0 / 3970037232.0,
-          -85916079474274.0 / 2800933759800.0,           -5919468007.0 / 634310460.0,
-                  2479159.0 / 157936.0,                    -18750000.0 / 602131.0,
-                -19203125.0 / 2053168.0,                 15700361463.0 / 438351368.0},
-
-    {         12627015655.0 / 631822968.0,              -72955222965.0 / 188496616.0,
-          -13145744952320.0 / 69488710893.0,          30084216194513.0 / 56998391688.0,
-      -296858761006640625.0 / 25648977082856624.0,         569140625.0 / 82709109.0,
-             -18684190637.0 / 18672891732.0,                69644045.0 / 89549712.0,
-                -11847025.0 / 4264272.0,                  -978650000.0 / 16257537.0,
-                519371875.0 / 6159504.0,                  5256837225.0 / 438351368.0},
-
-    {          -450944925.0 / 17550638.0,               -14532122925.0 / 94248308.0,
-            -595876966400.0 / 2573655959.0,             188748653015.0 / 527762886.0,
-      2545485458115234375.0 / 27252038150535163.0,       -1376953125.0 / 36759604.0,
-              53995596795.0 / 518691437.0,                 210311225.0 / 7047894.0,
-                 -1718875.0 / 39484.0,                      58000000.0 / 602131.0,
-                 -1546875.0 / 39484.0,                   -1262172375.0 / 8429834.0}
-
-  };
-
-  /** Serializable version identifier */
-  private static final long serialVersionUID = 7152276390558450974L;
-
 }
diff --git a/src/main/java/org/apache/commons/math/ode/nonstiff/EmbeddedRungeKuttaIntegrator.java b/src/main/java/org/apache/commons/math/ode/nonstiff/EmbeddedRungeKuttaIntegrator.java
index b58cc71e2..5a96d6911 100644
--- a/src/main/java/org/apache/commons/math/ode/nonstiff/EmbeddedRungeKuttaIntegrator.java
+++ b/src/main/java/org/apache/commons/math/ode/nonstiff/EmbeddedRungeKuttaIntegrator.java
@@ -67,6 +67,33 @@ import org.apache.commons.math.ode.sampling.StepHandler;
 public abstract class EmbeddedRungeKuttaIntegrator
   extends AdaptiveStepsizeIntegrator {
 
+    /** Indicator for <i>fsal</i> methods. */
+    private final boolean fsal;
+
+    /** Time steps from Butcher array (without the first zero). */
+    private final double[] c;
+
+    /** Internal weights from Butcher array (without the first empty row). */
+    private final double[][] a;
+
+    /** External weights for the high order method from Butcher array. */
+    private final double[] b;
+
+    /** Prototype of the step interpolator. */
+    private final RungeKuttaStepInterpolator prototype;
+
+    /** Stepsize control exponent. */
+    private final double exp;
+
+    /** Safety factor for stepsize control. */
+    private double safety;
+
+    /** Minimal reduction factor for stepsize control. */
+    private double minReduction;
+
+    /** Maximal growth factor for stepsize control. */
+    private double maxGrowth;
+
   /** Build a Runge-Kutta integrator with the given Butcher array.
    * @param name name of the method
    * @param fsal indicate that the method is an <i>fsal</i>
@@ -372,31 +399,4 @@ public abstract class EmbeddedRungeKuttaIntegrator
                                           double[] y0, double[] y1,
                                           double h);
 
-  /** Indicator for <i>fsal</i> methods. */
-  private boolean fsal;
-
-  /** Time steps from Butcher array (without the first zero). */
-  private double[] c;
-
-  /** Internal weights from Butcher array (without the first empty row). */
-  private double[][] a;
-
-  /** External weights for the high order method from Butcher array. */
-  private double[] b;
-
-  /** Prototype of the step interpolator. */
-  private RungeKuttaStepInterpolator prototype;
-
-  /** Stepsize control exponent. */
-  private double exp;
-
-  /** Safety factor for stepsize control. */
-  private double safety;
-
-  /** Minimal reduction factor for stepsize control. */
-  private double minReduction;
-
-  /** Maximal growth factor for stepsize control. */
-  private double maxGrowth;
-
 }
diff --git a/src/main/java/org/apache/commons/math/ode/nonstiff/GillStepInterpolator.java b/src/main/java/org/apache/commons/math/ode/nonstiff/GillStepInterpolator.java
index 4f19d7272..c2fc18edc 100644
--- a/src/main/java/org/apache/commons/math/ode/nonstiff/GillStepInterpolator.java
+++ b/src/main/java/org/apache/commons/math/ode/nonstiff/GillStepInterpolator.java
@@ -47,6 +47,15 @@ import org.apache.commons.math.ode.sampling.StepInterpolator;
 class GillStepInterpolator
   extends RungeKuttaStepInterpolator {
 
+    /** First Gill coefficient. */
+    private static final double TWO_MINUS_SQRT_2 = 2 - Math.sqrt(2.0);
+
+    /** Second Gill coefficient. */
+    private static final double TWO_PLUS_SQRT_2 = 2 + Math.sqrt(2.0);
+
+    /** Serializable version identifier */
+    private static final long serialVersionUID = -107804074496313322L;
+
   /** Simple constructor.
    * This constructor builds an instance that is not usable yet, the
    * {@link
@@ -112,13 +121,4 @@ class GillStepInterpolator
 
   }
 
-  /** First Gill coefficient. */
-  private static final double TWO_MINUS_SQRT_2 = 2 - Math.sqrt(2.0);
-
-  /** Second Gill coefficient. */
-  private static final double TWO_PLUS_SQRT_2 = 2 + Math.sqrt(2.0);
-
-  /** Serializable version identifier */
-  private static final long serialVersionUID = -107804074496313322L;
-
 }
diff --git a/src/main/java/org/apache/commons/math/ode/nonstiff/GraggBulirschStoerIntegrator.java b/src/main/java/org/apache/commons/math/ode/nonstiff/GraggBulirschStoerIntegrator.java
index 3936cc1c3..6a4444a4e 100644
--- a/src/main/java/org/apache/commons/math/ode/nonstiff/GraggBulirschStoerIntegrator.java
+++ b/src/main/java/org/apache/commons/math/ode/nonstiff/GraggBulirschStoerIntegrator.java
@@ -93,8 +93,65 @@ import org.apache.commons.math.ode.sampling.StepHandler;
 
 public class GraggBulirschStoerIntegrator extends AdaptiveStepsizeIntegrator {
 
-  /** Integrator method name. */
-  private static final String METHOD_NAME = "Gragg-Bulirsch-Stoer";
+    /** Integrator method name. */
+    private static final String METHOD_NAME = "Gragg-Bulirsch-Stoer";
+
+    /** maximal order. */
+    private int maxOrder;
+
+    /** step size sequence. */
+    private int[] sequence;
+
+    /** overall cost of applying step reduction up to iteration k+1, in number of calls. */
+    private int[] costPerStep;
+
+    /** cost per unit step. */
+    private double[] costPerTimeUnit;
+
+    /** optimal steps for each order. */
+    private double[] optimalStep;
+
+    /** extrapolation coefficients. */
+    private double[][] coeff;
+
+    /** stability check enabling parameter. */
+    private boolean performTest;
+
+    /** maximal number of checks for each iteration. */
+    private int maxChecks;
+
+    /** maximal number of iterations for which checks are performed. */
+    private int maxIter;
+
+    /** stepsize reduction factor in case of stability check failure. */
+    private double stabilityReduction;
+
+    /** first stepsize control factor. */
+    private double stepControl1;
+
+    /** second stepsize control factor. */
+    private double stepControl2;
+
+    /** third stepsize control factor. */
+    private double stepControl3;
+
+    /** fourth stepsize control factor. */
+    private double stepControl4;
+
+    /** first order control factor. */
+    private double orderControl1;
+
+    /** second order control factor. */
+    private double orderControl2;
+
+    /** dense outpute required. */
+    private boolean denseOutput;
+
+    /** use interpolation error in stepsize control. */
+    private boolean useInterpolationError;
+
+    /** interpolation order control parameter. */
+    private int mudif;
 
   /** Simple constructor.
    * Build a Gragg-Bulirsch-Stoer integrator with the given step
@@ -941,63 +998,4 @@ public class GraggBulirschStoerIntegrator extends AdaptiveStepsizeIntegrator {
 
   }
 
-  /** maximal order. */
-  private int maxOrder;
-
-  /** step size sequence. */
-  private int[] sequence;
-
-  /** overall cost of applying step reduction up to iteration k+1,
-   *  in number of calls.
-   */
-  private int[] costPerStep;
-
-  /** cost per unit step. */
-  private double[] costPerTimeUnit;
-
-  /** optimal steps for each order. */
-  private double[] optimalStep;
-
-  /** extrapolation coefficients. */
-  private double[][] coeff;
-
-  /** stability check enabling parameter. */
-  private boolean performTest;
-
-  /** maximal number of checks for each iteration. */
-  private int maxChecks;
-
-  /** maximal number of iterations for which checks are performed. */
-  private int maxIter;
-
-  /** stepsize reduction factor in case of stability check failure. */
-  private double stabilityReduction;
-
-  /** first stepsize control factor. */
-  private double stepControl1;
-
-  /** second stepsize control factor. */
-  private double stepControl2;
-
-  /** third stepsize control factor. */
-  private double stepControl3;
-
-  /** fourth stepsize control factor. */
-  private double stepControl4;
-
-  /** first order control factor. */
-  private double orderControl1;
-
-  /** second order control factor. */
-  private double orderControl2;
-
-  /** dense outpute required. */
-  private boolean denseOutput;
-
-  /** use interpolation error in stepsize control. */
-  private boolean useInterpolationError;
-
-  /** interpolation order control parameter. */
-  private int mudif;
-
 }
diff --git a/src/main/java/org/apache/commons/math/ode/nonstiff/GraggBulirschStoerStepInterpolator.java b/src/main/java/org/apache/commons/math/ode/nonstiff/GraggBulirschStoerStepInterpolator.java
index ce3739f15..5e3ea8b10 100644
--- a/src/main/java/org/apache/commons/math/ode/nonstiff/GraggBulirschStoerStepInterpolator.java
+++ b/src/main/java/org/apache/commons/math/ode/nonstiff/GraggBulirschStoerStepInterpolator.java
@@ -77,75 +77,31 @@ import org.apache.commons.math.ode.sampling.StepInterpolator;
 class GraggBulirschStoerStepInterpolator
   extends AbstractStepInterpolator {
 
-  /** Slope at the beginning of the step. */
-  private double[] y0Dot;
+    /** Serializable version identifier. */
+    private static final long serialVersionUID = 7320613236731409847L;
 
-  /** State at the end of the step. */
-  private double[] y1;
+    /** Slope at the beginning of the step. */
+    private double[] y0Dot;
 
-  /** Slope at the end of the step. */
-  private double[] y1Dot;
+    /** State at the end of the step. */
+    private double[] y1;
 
-  /** Derivatives at the middle of the step.
-   * element 0 is state at midpoint, element 1 is first derivative ...
-   */
-  private double[][] yMidDots;
+    /** Slope at the end of the step. */
+    private double[] y1Dot;
 
-  /** Interpolation polynoms. */
-  private double[][] polynoms;
+    /** Derivatives at the middle of the step.
+     * element 0 is state at midpoint, element 1 is first derivative ...
+     */
+    private double[][] yMidDots;
 
-  /** Error coefficients for the interpolation. */
-  private double[] errfac;
+    /** Interpolation polynoms. */
+    private double[][] polynoms;
 
-  /** Degree of the interpolation polynoms. */
-  private int currentDegree;
+    /** Error coefficients for the interpolation. */
+    private double[] errfac;
 
-  /** Reallocate the internal tables.
-   * Reallocate the internal tables in order to be able to handle
-   * interpolation polynoms up to the given degree
-   * @param maxDegree maximal degree to handle
-   */
-  private void resetTables(final int maxDegree) {
-
-    if (maxDegree < 0) {
-      polynoms      = null;
-      errfac        = null;
-      currentDegree = -1;
-    } else {
-
-      final double[][] newPols = new double[maxDegree + 1][];
-      if (polynoms != null) {
-        System.arraycopy(polynoms, 0, newPols, 0, polynoms.length);
-        for (int i = polynoms.length; i < newPols.length; ++i) {
-          newPols[i] = new double[currentState.length];
-        }
-      } else {
-        for (int i = 0; i < newPols.length; ++i) {
-          newPols[i] = new double[currentState.length];
-        }
-      }
-      polynoms = newPols;
-
-      // initialize the error factors array for interpolation
-      if (maxDegree <= 4) {
-        errfac = null;
-      } else {
-        errfac = new double[maxDegree - 4];
-        for (int i = 0; i < errfac.length; ++i) {
-          final int ip5 = i + 5;
-          errfac[i] = 1.0 / (ip5 * ip5);
-          final double e = 0.5 * Math.sqrt (((double) (i + 1)) / ip5);
-          for (int j = 0; j <= i; ++j) {
-            errfac[i] *= e / (j + 1);
-          }
-        }
-      }
-
-      currentDegree = 0;
-
-    }
-
-  }
+    /** Degree of the interpolation polynoms. */
+    private int currentDegree;
 
   /** Simple constructor.
    * This constructor should not be used directly, it is only intended
@@ -221,6 +177,53 @@ class GraggBulirschStoerStepInterpolator
 
   }
 
+  /** Reallocate the internal tables.
+   * Reallocate the internal tables in order to be able to handle
+   * interpolation polynoms up to the given degree
+   * @param maxDegree maximal degree to handle
+   */
+  private void resetTables(final int maxDegree) {
+
+    if (maxDegree < 0) {
+      polynoms      = null;
+      errfac        = null;
+      currentDegree = -1;
+    } else {
+
+      final double[][] newPols = new double[maxDegree + 1][];
+      if (polynoms != null) {
+        System.arraycopy(polynoms, 0, newPols, 0, polynoms.length);
+        for (int i = polynoms.length; i < newPols.length; ++i) {
+          newPols[i] = new double[currentState.length];
+        }
+      } else {
+        for (int i = 0; i < newPols.length; ++i) {
+          newPols[i] = new double[currentState.length];
+        }
+      }
+      polynoms = newPols;
+
+      // initialize the error factors array for interpolation
+      if (maxDegree <= 4) {
+        errfac = null;
+      } else {
+        errfac = new double[maxDegree - 4];
+        for (int i = 0; i < errfac.length; ++i) {
+          final int ip5 = i + 5;
+          errfac[i] = 1.0 / (ip5 * ip5);
+          final double e = 0.5 * Math.sqrt (((double) (i + 1)) / ip5);
+          for (int j = 0; j <= i; ++j) {
+            errfac[i] *= e / (j + 1);
+          }
+        }
+      }
+
+      currentDegree = 0;
+
+    }
+
+  }
+
   /** {@inheritDoc} */
   @Override
   protected StepInterpolator doCopy() {
@@ -396,7 +399,4 @@ class GraggBulirschStoerStepInterpolator
 
   }
 
-  /** Serializable version identifier */
-  private static final long serialVersionUID = 7320613236731409847L;
-
 }
diff --git a/src/main/java/org/apache/commons/math/ode/nonstiff/HighamHall54StepInterpolator.java b/src/main/java/org/apache/commons/math/ode/nonstiff/HighamHall54StepInterpolator.java
index 135fc560e..ddcb12d5e 100644
--- a/src/main/java/org/apache/commons/math/ode/nonstiff/HighamHall54StepInterpolator.java
+++ b/src/main/java/org/apache/commons/math/ode/nonstiff/HighamHall54StepInterpolator.java
@@ -33,6 +33,9 @@ import org.apache.commons.math.ode.sampling.StepInterpolator;
 class HighamHall54StepInterpolator
   extends RungeKuttaStepInterpolator {
 
+  /** Serializable version identifier */
+  private static final long serialVersionUID = -3583240427587318654L;
+
   /** Simple constructor.
    * This constructor builds an instance that is not usable yet, the
    * {@link
@@ -97,7 +100,4 @@ class HighamHall54StepInterpolator
 
   }
 
-  /** Serializable version identifier */
-  private static final long serialVersionUID = -3583240427587318654L;
-
 }
diff --git a/src/main/java/org/apache/commons/math/ode/nonstiff/MidpointStepInterpolator.java b/src/main/java/org/apache/commons/math/ode/nonstiff/MidpointStepInterpolator.java
index 6f4dec7cd..988057c89 100644
--- a/src/main/java/org/apache/commons/math/ode/nonstiff/MidpointStepInterpolator.java
+++ b/src/main/java/org/apache/commons/math/ode/nonstiff/MidpointStepInterpolator.java
@@ -44,6 +44,9 @@ import org.apache.commons.math.ode.sampling.StepInterpolator;
 class MidpointStepInterpolator
   extends RungeKuttaStepInterpolator {
 
+    /** Serializable version identifier */
+    private static final long serialVersionUID = -865524111506042509L;
+
   /** Simple constructor.
    * This constructor builds an instance that is not usable yet, the
    * {@link
@@ -94,7 +97,4 @@ class MidpointStepInterpolator
 
   }
 
-  /** Serializable version identifier */
-  private static final long serialVersionUID = -865524111506042509L;
-
 }
diff --git a/src/main/java/org/apache/commons/math/ode/nonstiff/RungeKuttaIntegrator.java b/src/main/java/org/apache/commons/math/ode/nonstiff/RungeKuttaIntegrator.java
index b58424f20..ca2acbd4d 100644
--- a/src/main/java/org/apache/commons/math/ode/nonstiff/RungeKuttaIntegrator.java
+++ b/src/main/java/org/apache/commons/math/ode/nonstiff/RungeKuttaIntegrator.java
@@ -54,6 +54,21 @@ import org.apache.commons.math.ode.sampling.StepHandler;
 
 public abstract class RungeKuttaIntegrator extends AbstractIntegrator {
 
+    /** Time steps from Butcher array (without the first zero). */
+    private final double[] c;
+
+    /** Internal weights from Butcher array (without the first empty row). */
+    private final double[][] a;
+
+    /** External weights for the high order method from Butcher array. */
+    private final double[] b;
+
+    /** Prototype of the step interpolator. */
+    private final RungeKuttaStepInterpolator prototype;
+
+    /** Integration step. */
+    private final double step;
+
   /** Simple constructor.
    * Build a Runge-Kutta integrator with the given
    * step. The default step handler does nothing.
@@ -200,19 +215,4 @@ public abstract class RungeKuttaIntegrator extends AbstractIntegrator {
 
   }
 
-  /** Time steps from Butcher array (without the first zero). */
-  private double[] c;
-
-  /** Internal weights from Butcher array (without the first empty row). */
-  private double[][] a;
-
-  /** External weights for the high order method from Butcher array. */
-  private double[] b;
-
-  /** Prototype of the step interpolator. */
-  private RungeKuttaStepInterpolator prototype;
-
-  /** Integration step. */
-  private double step;
-
 }
diff --git a/src/main/java/org/apache/commons/math/ode/nonstiff/RungeKuttaStepInterpolator.java b/src/main/java/org/apache/commons/math/ode/nonstiff/RungeKuttaStepInterpolator.java
index fb95af9bb..5375df437 100644
--- a/src/main/java/org/apache/commons/math/ode/nonstiff/RungeKuttaStepInterpolator.java
+++ b/src/main/java/org/apache/commons/math/ode/nonstiff/RungeKuttaStepInterpolator.java
@@ -37,6 +37,12 @@ import org.apache.commons.math.ode.sampling.AbstractStepInterpolator;
 abstract class RungeKuttaStepInterpolator
   extends AbstractStepInterpolator {
 
+    /** Slopes at the intermediate points */
+    protected double[][] yDotK;
+
+    /** Reference to the integrator. */
+    protected AbstractIntegrator integrator;
+
   /** Simple constructor.
    * This constructor builds an instance that is not usable yet, the
    * {@link #reinitialize} method should be called before using the
@@ -174,10 +180,4 @@ abstract class RungeKuttaStepInterpolator
 
   }
 
-  /** Slopes at the intermediate points */
-  protected double[][] yDotK;
-
-  /** Reference to the integrator. */
-  protected AbstractIntegrator integrator;
-
 }
diff --git a/src/main/java/org/apache/commons/math/ode/nonstiff/ThreeEighthesStepInterpolator.java b/src/main/java/org/apache/commons/math/ode/nonstiff/ThreeEighthesStepInterpolator.java
index 85bab41bf..31d864176 100644
--- a/src/main/java/org/apache/commons/math/ode/nonstiff/ThreeEighthesStepInterpolator.java
+++ b/src/main/java/org/apache/commons/math/ode/nonstiff/ThreeEighthesStepInterpolator.java
@@ -49,6 +49,9 @@ import org.apache.commons.math.ode.sampling.StepInterpolator;
 class ThreeEighthesStepInterpolator
   extends RungeKuttaStepInterpolator {
 
+    /** Serializable version identifier */
+    private static final long serialVersionUID = -3345024435978721931L;
+
   /** Simple constructor.
    * This constructor builds an instance that is not usable yet, the
    * {@link
@@ -110,7 +113,4 @@ class ThreeEighthesStepInterpolator
 
   }
 
-  /** Serializable version identifier */
-  private static final long serialVersionUID = -3345024435978721931L;
-
 }
diff --git a/src/main/java/org/apache/commons/math/ode/sampling/DummyStepHandler.java b/src/main/java/org/apache/commons/math/ode/sampling/DummyStepHandler.java
index 4b63efc5d..e17b2f2c5 100644
--- a/src/main/java/org/apache/commons/math/ode/sampling/DummyStepHandler.java
+++ b/src/main/java/org/apache/commons/math/ode/sampling/DummyStepHandler.java
@@ -17,7 +17,6 @@
 
 package org.apache.commons.math.ode.sampling;
 
-
 /**
  * This class is a step handler that does nothing.
 
@@ -37,51 +36,66 @@ package org.apache.commons.math.ode.sampling;
 
 public class DummyStepHandler implements StepHandler {
 
-  /** Private constructor.
-   * The constructor is private to prevent users from creating
-   * instances (Singleton design-pattern).
-   */
-  private DummyStepHandler() {
-  }
+    /** Private constructor.
+     * The constructor is private to prevent users from creating
+     * instances (Singleton design-pattern).
+     */
+    private DummyStepHandler() {
+    }
 
-  /** Get the only instance.
-   * @return the only instance
-   */
-  public static DummyStepHandler getInstance() {
-    return INSTANCE;
-  }
+    /** Get the only instance.
+     * @return the only instance
+     */
+    public static DummyStepHandler getInstance() {
+        return LazyHolder.INSTANCE;
+    }
 
-  /** Determines whether this handler needs dense output.
-   * Since this handler does nothing, it does not require dense output.
-   * @return always false
-   */
-  public boolean requiresDenseOutput() {
-    return false;
-  }
+    /** Determines whether this handler needs dense output.
+     * Since this handler does nothing, it does not require dense output.
+     * @return always false
+     */
+    public boolean requiresDenseOutput() {
+        return false;
+    }
 
-  /** Reset the step handler.
-   * Initialize the internal data as required before the first step is
-   * handled.
-   */
-  public void reset() {
-  }
+    /** Reset the step handler.
+     * Initialize the internal data as required before the first step is
+     * handled.
+     */
+    public void reset() {
+    }
 
-  /**
-   * Handle the last accepted step.
-   * This method does nothing in this class.
-   * @param interpolator interpolator for the last accepted step. For
-   * efficiency purposes, the various integrators reuse the same
-   * 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), it
-   * should build a local copy using the clone method and store this
-   * copy.
-   * @param isLast true if the step is the last one
-   */
-  public void handleStep(final StepInterpolator interpolator, final boolean isLast) {
-  }
+    /**
+     * Handle the last accepted step.
+     * This method does nothing in this class.
+     * @param interpolator interpolator for the last accepted step. For
+     * efficiency purposes, the various integrators reuse the same
+     * 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), it
+     * should build a local copy using the clone method and store this
+     * copy.
+     * @param isLast true if the step is the last one
+     */
+    public void handleStep(final StepInterpolator interpolator, final boolean isLast) {
+    }
 
-  /** The only instance. */
-  private static final DummyStepHandler INSTANCE = new DummyStepHandler();
+    // CHECKSTYLE: stop HideUtilityClassConstructor
+    /** Holder for the instance.
+     * <p>We use here the Initialization On Demand Holder Idiom.</p>
+     */
+    private static class LazyHolder {
+        /** Cached field instance. */
+        private static final DummyStepHandler INSTANCE = new DummyStepHandler();
+    }
+    // CHECKSTYLE: resume HideUtilityClassConstructor
+
+    /** Handle deserialization of the singleton.
+     * @return the singleton instance
+     */
+    private Object readResolve() {
+        // return the singleton instance
+        return LazyHolder.INSTANCE;
+    }
 
 }
diff --git a/src/main/java/org/apache/commons/math/ode/sampling/DummyStepInterpolator.java b/src/main/java/org/apache/commons/math/ode/sampling/DummyStepInterpolator.java
index d344bdcbd..d94f5e55a 100644
--- a/src/main/java/org/apache/commons/math/ode/sampling/DummyStepInterpolator.java
+++ b/src/main/java/org/apache/commons/math/ode/sampling/DummyStepInterpolator.java
@@ -40,6 +40,9 @@ import org.apache.commons.math.ode.DerivativeException;
 public class DummyStepInterpolator
   extends AbstractStepInterpolator {
 
+    /** Serializable version identifier */
+    private static final long serialVersionUID = 1708010296707839488L;
+
   /** Simple constructor.
    * This constructor builds an instance that is not usable yet, the
    * <code>AbstractStepInterpolator.reinitialize</code> protected method
@@ -123,7 +126,4 @@ public class DummyStepInterpolator
 
   }
 
-  /** Serializable version identifier */
-  private static final long serialVersionUID = 1708010296707839488L;
-
 }
diff --git a/src/main/java/org/apache/commons/math/ode/sampling/NordsieckStepInterpolator.java b/src/main/java/org/apache/commons/math/ode/sampling/NordsieckStepInterpolator.java
index 33cd09d76..d1a606dc5 100644
--- a/src/main/java/org/apache/commons/math/ode/sampling/NordsieckStepInterpolator.java
+++ b/src/main/java/org/apache/commons/math/ode/sampling/NordsieckStepInterpolator.java
@@ -42,6 +42,9 @@ public class NordsieckStepInterpolator extends AbstractStepInterpolator {
     /** Serializable version identifier */
     private static final long serialVersionUID = -7179861704951334960L;
 
+    /** State variation. */
+    protected double[] stateVariation;
+
     /** Step size used in the first scaled derivative and Nordsieck vector. */
     private double scalingH;
 
@@ -59,9 +62,6 @@ public class NordsieckStepInterpolator extends AbstractStepInterpolator {
     /** Nordsieck vector. */
     private Array2DRowRealMatrix nordsieck;
 
-    /** State variation. */
-    protected double[] stateVariation;
-
     /** Simple constructor.
      * This constructor builds an instance that is not usable yet, the
      * {@link AbstractStepInterpolator#reinitialize} method should be called
diff --git a/src/main/java/org/apache/commons/math/optimization/general/AbstractLeastSquaresOptimizer.java b/src/main/java/org/apache/commons/math/optimization/general/AbstractLeastSquaresOptimizer.java
index 26632f9ea..9060323a2 100644
--- a/src/main/java/org/apache/commons/math/optimization/general/AbstractLeastSquaresOptimizer.java
+++ b/src/main/java/org/apache/commons/math/optimization/general/AbstractLeastSquaresOptimizer.java
@@ -45,21 +45,6 @@ public abstract class AbstractLeastSquaresOptimizer implements DifferentiableMul
     /** Default maximal number of iterations allowed. */
     public static final int DEFAULT_MAX_ITERATIONS = 100;
 
-    /** Maximal number of iterations allowed. */
-    private int maxIterations;
-
-    /** Number of iterations already performed. */
-    private int iterations;
-
-    /** Maximal number of evaluations allowed. */
-    private int maxEvaluations;
-
-    /** Number of evaluations already performed. */
-    private int objectiveEvaluations;
-
-    /** Number of jacobian evaluations. */
-    private int jacobianEvaluations;
-
     /** Convergence checker. */
     protected VectorialConvergenceChecker checker;
 
@@ -78,12 +63,6 @@ public abstract class AbstractLeastSquaresOptimizer implements DifferentiableMul
     /** Number of rows of the jacobian matrix. */
     protected int rows;
 
-    /** Objective function. */
-    private DifferentiableMultivariateVectorialFunction function;
-
-    /** Objective function derivatives. */
-    private MultivariateMatrixFunction jF;
-
     /** Target value for the objective functions at optimum. */
     protected double[] targetValues;
 
@@ -102,6 +81,27 @@ public abstract class AbstractLeastSquaresOptimizer implements DifferentiableMul
     /** Cost value (square root of the sum of the residuals). */
     protected double cost;
 
+    /** Maximal number of iterations allowed. */
+    private int maxIterations;
+
+    /** Number of iterations already performed. */
+    private int iterations;
+
+    /** Maximal number of evaluations allowed. */
+    private int maxEvaluations;
+
+    /** Number of evaluations already performed. */
+    private int objectiveEvaluations;
+
+    /** Number of jacobian evaluations. */
+    private int jacobianEvaluations;
+
+    /** Objective function. */
+    private DifferentiableMultivariateVectorialFunction function;
+
+    /** Objective function derivatives. */
+    private MultivariateMatrixFunction jF;
+
     /** Simple constructor with default settings.
      * <p>The convergence check is set to a {@link SimpleVectorialValueChecker}
      * and the maximal number of evaluation is set to its default value.</p>
diff --git a/src/main/java/org/apache/commons/math/optimization/general/AbstractScalarDifferentiableOptimizer.java b/src/main/java/org/apache/commons/math/optimization/general/AbstractScalarDifferentiableOptimizer.java
index ea4bb006b..3daec7132 100644
--- a/src/main/java/org/apache/commons/math/optimization/general/AbstractScalarDifferentiableOptimizer.java
+++ b/src/main/java/org/apache/commons/math/optimization/general/AbstractScalarDifferentiableOptimizer.java
@@ -42,6 +42,15 @@ public abstract class AbstractScalarDifferentiableOptimizer
     /** Default maximal number of iterations allowed. */
     public static final int DEFAULT_MAX_ITERATIONS = 100;
 
+    /** Convergence checker. */
+    protected RealConvergenceChecker checker;
+
+    /** Type of optimization. */
+    protected GoalType goal;
+
+    /** Current point set. */
+    protected double[] point;
+
     /** Maximal number of iterations allowed. */
     private int maxIterations;
 
@@ -57,21 +66,12 @@ public abstract class AbstractScalarDifferentiableOptimizer
     /** Number of gradient evaluations. */
     private int gradientEvaluations;
 
-    /** Convergence checker. */
-    protected RealConvergenceChecker checker;
-
     /** Objective function. */
     private DifferentiableMultivariateRealFunction function;
 
     /** Objective function gradient. */
     private MultivariateVectorialFunction gradient;
 
-    /** Type of optimization. */
-    protected GoalType goal;
-
-    /** Current point set. */
-    protected double[] point;
-
     /** Simple constructor with default settings.
      * <p>The convergence check is set to a {@link SimpleScalarValueChecker}
      * and the maximal number of evaluation is set to its default value.</p>
diff --git a/src/main/java/org/apache/commons/math/optimization/linear/AbstractLinearOptimizer.java b/src/main/java/org/apache/commons/math/optimization/linear/AbstractLinearOptimizer.java
index cb21abb85..06704bdc3 100644
--- a/src/main/java/org/apache/commons/math/optimization/linear/AbstractLinearOptimizer.java
+++ b/src/main/java/org/apache/commons/math/optimization/linear/AbstractLinearOptimizer.java
@@ -37,12 +37,6 @@ public abstract class AbstractLinearOptimizer implements LinearOptimizer {
     /** Default maximal number of iterations allowed. */
     public static final int DEFAULT_MAX_ITERATIONS = 100;
 
-    /** Maximal number of iterations allowed. */
-    private int maxIterations;
-
-    /** Number of iterations already performed. */
-    private int iterations;
-
     /** Linear objective function. */
     protected LinearObjectiveFunction function;
 
@@ -55,6 +49,12 @@ public abstract class AbstractLinearOptimizer implements LinearOptimizer {
     /** Whether to restrict the variables to non-negative values. */
     protected boolean nonNegative;
 
+    /** Maximal number of iterations allowed. */
+    private int maxIterations;
+
+    /** Number of iterations already performed. */
+    private int iterations;
+
     /** Simple constructor with default settings.
      * <p>The maximal number of evaluation is set to its default value.</p>
      */
diff --git a/src/main/java/org/apache/commons/math/optimization/linear/SimplexTableau.java b/src/main/java/org/apache/commons/math/optimization/linear/SimplexTableau.java
index 60b3db947..3a5edfdaa 100644
--- a/src/main/java/org/apache/commons/math/optimization/linear/SimplexTableau.java
+++ b/src/main/java/org/apache/commons/math/optimization/linear/SimplexTableau.java
@@ -75,19 +75,19 @@ class SimplexTableau implements Serializable {
     private final boolean restrictToNonNegative;
 
     /** Simple tableau. */
-    protected transient RealMatrix tableau;
+    private transient RealMatrix tableau;
 
     /** Number of decision variables. */
-    protected final int numDecisionVariables;
+    private final int numDecisionVariables;
 
     /** Number of slack variables. */
-    protected final int numSlackVariables;
+    private final int numSlackVariables;
 
     /** Number of artificial variables. */
-    protected int numArtificialVariables;
+    private int numArtificialVariables;
 
     /** Amount of error to accept in floating point comparisons. */
-    protected final double epsilon;
+    private final double epsilon;
 
     /**
      * Build a tableau for a linear problem.
diff --git a/src/main/java/org/apache/commons/math/random/CorrelatedRandomVectorGenerator.java b/src/main/java/org/apache/commons/math/random/CorrelatedRandomVectorGenerator.java
index edb8b6135..063e1e267 100644
--- a/src/main/java/org/apache/commons/math/random/CorrelatedRandomVectorGenerator.java
+++ b/src/main/java/org/apache/commons/math/random/CorrelatedRandomVectorGenerator.java
@@ -62,6 +62,21 @@ import org.apache.commons.math.linear.RealMatrix;
 public class CorrelatedRandomVectorGenerator
     implements RandomVectorGenerator {
 
+    /** Mean vector. */
+    private final double[] mean;
+
+    /** Underlying generator. */
+    private final NormalizedRandomGenerator generator;
+
+    /** Storage for the normalized vector. */
+    private final double[] normalized;
+
+    /** Permutated Cholesky root of the covariance matrix. */
+    private RealMatrix root;
+
+    /** Rank of the covariance matrix. */
+    private int rank;
+
     /** Simple constructor.
      * <p>Build a correlated random vector generator from its mean
      * vector and covariance matrix.</p>
@@ -285,19 +300,4 @@ public class CorrelatedRandomVectorGenerator
 
     }
 
-    /** Mean vector. */
-    private double[] mean;
-
-    /** Permutated Cholesky root of the covariance matrix. */
-    private RealMatrix root;
-
-    /** Rank of the covariance matrix. */
-    private int rank;
-
-    /** Underlying generator. */
-    private NormalizedRandomGenerator generator;
-
-    /** Storage for the normalized vector. */
-    private double[] normalized;
-
 }
diff --git a/src/main/java/org/apache/commons/math/random/GaussianRandomGenerator.java b/src/main/java/org/apache/commons/math/random/GaussianRandomGenerator.java
index b23c017a8..6be8e7128 100644
--- a/src/main/java/org/apache/commons/math/random/GaussianRandomGenerator.java
+++ b/src/main/java/org/apache/commons/math/random/GaussianRandomGenerator.java
@@ -27,10 +27,13 @@ package org.apache.commons.math.random;
 
 public class GaussianRandomGenerator implements NormalizedRandomGenerator {
 
+    /** Underlying generator. */
+    private final RandomGenerator generator;
+
     /** Create a new generator.
      * @param generator underlying random generator to use
      */
-    public GaussianRandomGenerator(RandomGenerator generator) {
+    public GaussianRandomGenerator(final RandomGenerator generator) {
         this.generator = generator;
     }
 
@@ -41,7 +44,4 @@ public class GaussianRandomGenerator implements NormalizedRandomGenerator {
         return generator.nextGaussian();
     }
 
-    /** Underlying generator. */
-    private RandomGenerator generator;
-
 }
diff --git a/src/main/java/org/apache/commons/math/random/UncorrelatedRandomVectorGenerator.java b/src/main/java/org/apache/commons/math/random/UncorrelatedRandomVectorGenerator.java
index b85e4e603..f4e71fb05 100644
--- a/src/main/java/org/apache/commons/math/random/UncorrelatedRandomVectorGenerator.java
+++ b/src/main/java/org/apache/commons/math/random/UncorrelatedRandomVectorGenerator.java
@@ -33,6 +33,15 @@ import org.apache.commons.math.MathRuntimeException;
 public class UncorrelatedRandomVectorGenerator
   implements RandomVectorGenerator {
 
+    /** Underlying scalar generator. */
+    private final NormalizedRandomGenerator generator;
+
+    /** Mean vector. */
+    private final double[] mean;
+
+    /** Standard deviation vector. */
+    private final double[] standardDeviation;
+
   /** Simple constructor.
    * <p>Build an uncorrelated random vector generator from
    * its mean and standard deviation vectors.</p>
@@ -83,13 +92,4 @@ public class UncorrelatedRandomVectorGenerator
 
   }
 
-  /** Mean vector. */
-  private double[] mean;
-
-  /** Standard deviation vector. */
-  private double[] standardDeviation;
-
-  /** Underlying scalar generator. */
-  private NormalizedRandomGenerator generator;
-
 }
diff --git a/src/main/java/org/apache/commons/math/random/UniformRandomGenerator.java b/src/main/java/org/apache/commons/math/random/UniformRandomGenerator.java
index 2289f39af..f93b0906e 100644
--- a/src/main/java/org/apache/commons/math/random/UniformRandomGenerator.java
+++ b/src/main/java/org/apache/commons/math/random/UniformRandomGenerator.java
@@ -34,6 +34,12 @@ public class UniformRandomGenerator implements NormalizedRandomGenerator {
     /** Serializable version identifier. */
     private static final long serialVersionUID = 1569292426375546027L;
 
+    /** Square root of three. */
+    private static final double SQRT3 = Math.sqrt(3.0);
+
+    /** Underlying generator. */
+    private final RandomGenerator generator;
+
     /** Create a new generator.
      * @param generator underlying random generator to use
      */
@@ -50,10 +56,4 @@ public class UniformRandomGenerator implements NormalizedRandomGenerator {
         return SQRT3 * (2 * generator.nextDouble() - 1.0);
     }
 
-    /** Underlying generator. */
-    private RandomGenerator generator;
-
-    /** Square root of three. */
-    private static final double SQRT3 = Math.sqrt(3.0);
-
 }
diff --git a/src/main/java/org/apache/commons/math/random/ValueServer.java b/src/main/java/org/apache/commons/math/random/ValueServer.java
index 6f66bd34f..2f198dcc2 100644
--- a/src/main/java/org/apache/commons/math/random/ValueServer.java
+++ b/src/main/java/org/apache/commons/math/random/ValueServer.java
@@ -46,51 +46,63 @@ import org.apache.commons.math.MathRuntimeException;
  *
  */
 public class ValueServer {
-    /** mode determines how values are generated */
-    private int mode = 5;
 
-    /** URI to raw data values  */
-    private URL valuesFileURL = null;
-
-    /** Mean for use with non-data-driven modes */
-    private double mu = 0.0;
-
-    /** Standard deviation for use with GAUSSIAN_MODE */
-    private double sigma = 0.0;
-
-    /** Empirical probability distribution for use with DIGEST_MODE */
-    private EmpiricalDistribution empiricalDistribution = null;
-
-    /** file pointer for REPLAY_MODE */
-    private BufferedReader filePointer = null;
-
-    /** RandomDataImpl to use for random data generation */
-    private RandomData randomData = new RandomDataImpl();
-
-    // Data generation modes ======================================
-
-    /** Use empirical distribution  */
+    /** Use empirical distribution.  */
     public static final int DIGEST_MODE = 0;
 
-    /** Replay data from valuesFilePath */
+    /** Replay data from valuesFilePath. */
     public static final int REPLAY_MODE = 1;
 
-    /** Uniform random deviates with mean = mu */
+    /** Uniform random deviates with mean = &mu;. */
     public static final int UNIFORM_MODE = 2;
 
-    /** Exponential random deviates with mean = mu */
+    /** Exponential random deviates with mean = &mu;. */
     public static final int EXPONENTIAL_MODE = 3;
 
-    /** Gaussian random deviates with mean = mu, std dev = sigma */
+    /** Gaussian random deviates with mean = &mu;, std dev = &sigma;. */
     public static final int GAUSSIAN_MODE = 4;
 
     /** Always return mu */
     public static final int CONSTANT_MODE = 5;
 
+    /** mode determines how values are generated. */
+    private int mode = 5;
+
+    /** URI to raw data values. */
+    private URL valuesFileURL = null;
+
+    /** Mean for use with non-data-driven modes. */
+    private double mu = 0.0;
+
+    /** Standard deviation for use with GAUSSIAN_MODE. */
+    private double sigma = 0.0;
+
+    /** Empirical probability distribution for use with DIGEST_MODE. */
+    private EmpiricalDistribution empiricalDistribution = null;
+
+    /** File pointer for REPLAY_MODE. */
+    private BufferedReader filePointer = null;
+
+    /** RandomDataImpl to use for random data generation. */
+    private RandomData randomData = new RandomDataImpl();
+
+    // Data generation modes ======================================
+
     /** Creates new ValueServer */
     public ValueServer() {
     }
 
+    /**
+     * Construct a ValueServer instance using a RandomData as its source
+     * of random data.
+     *
+     * @param randomData the RandomData instance used to source random data
+     * @since 1.1
+     */
+    public ValueServer(RandomData randomData) {
+        this.randomData = randomData;
+    }
+
     /**
      * Returns the next generated value, generated according
      * to the mode value (see MODE constants).
@@ -369,15 +381,4 @@ public class ValueServer {
         return randomData.nextGaussian(mu, sigma);
     }
 
-    /**
-     * Construct a ValueServer instance using a RandomData as its source
-     * of random data.
-     *
-     * @param randomData the RandomData instance used to source random data
-     * @since 1.1
-     */
-    public ValueServer(RandomData randomData) {
-        super();
-        this.randomData = randomData;
-    }
 }
diff --git a/src/main/java/org/apache/commons/math/special/Gamma.java b/src/main/java/org/apache/commons/math/special/Gamma.java
index 0ea2b7d92..a80c01948 100644
--- a/src/main/java/org/apache/commons/math/special/Gamma.java
+++ b/src/main/java/org/apache/commons/math/special/Gamma.java
@@ -60,6 +60,12 @@ public class Gamma {
     /** Avoid repeated computation of log of 2 PI in logGamma */
     private static final double HALF_LOG_2_PI = 0.5 * Math.log(2.0 * Math.PI);
 
+    // limits for switching algorithm in digamma
+    /** C limit. */
+    private static final double C_LIMIT = 49;
+
+    /** S limit. */
+    private static final double S_LIMIT = 1e-5;
 
     /**
      * Default constructor.  Prohibit instantiation.
@@ -262,12 +268,6 @@ public class Gamma {
     }
 
 
-    // limits for switching algorithm in digamma
-    /** C limit */
-     private static final double C_LIMIT = 49;
-     /** S limit */
-     private static final double S_LIMIT = 1e-5;
-
     /**
      * <p>Computes the digamma function of x.</p>
      *
diff --git a/src/main/java/org/apache/commons/math/stat/descriptive/DescriptiveStatistics.java b/src/main/java/org/apache/commons/math/stat/descriptive/DescriptiveStatistics.java
index eec151526..0a5abf1f7 100644
--- a/src/main/java/org/apache/commons/math/stat/descriptive/DescriptiveStatistics.java
+++ b/src/main/java/org/apache/commons/math/stat/descriptive/DescriptiveStatistics.java
@@ -55,6 +55,13 @@ import org.apache.commons.math.util.ResizableDoubleArray;
  */
 public class DescriptiveStatistics implements StatisticalSummary, Serializable {
 
+    /**
+     * Represents an infinite window size.  When the {@link #getWindowSize()}
+     * returns this value, there is no limit to the number of data values
+     * that can be stored in the dataset.
+     */
+    public static final int INFINITE_WINDOW = -1;
+
     /** Serialization UID */
     private static final long serialVersionUID = 4133067267405273064L;
 
@@ -121,13 +128,6 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
         copy(original, this);
     }
 
-    /**
-     * Represents an infinite window size.  When the {@link #getWindowSize()}
-     * returns this value, there is no limit to the number of data values
-     * that can be stored in the dataset.
-     */
-    public static final int INFINITE_WINDOW = -1;
-
     /**
      * Adds the value to the dataset. If the dataset is at the maximum size
      * (i.e., the number of stored elements equals the currently configured
diff --git a/src/main/java/org/apache/commons/math/stat/descriptive/MultivariateSummaryStatistics.java b/src/main/java/org/apache/commons/math/stat/descriptive/MultivariateSummaryStatistics.java
index c28c39954..20e7684c2 100644
--- a/src/main/java/org/apache/commons/math/stat/descriptive/MultivariateSummaryStatistics.java
+++ b/src/main/java/org/apache/commons/math/stat/descriptive/MultivariateSummaryStatistics.java
@@ -71,6 +71,36 @@ public class MultivariateSummaryStatistics
     /** Serialization UID */
     private static final long serialVersionUID = 2271900808994826718L;
 
+    /** Dimension of the data. */
+    private int k;
+
+    /** Count of values that have been added */
+    private long n = 0;
+
+    /** Sum statistic implementation - can be reset by setter. */
+    private StorelessUnivariateStatistic[] sumImpl;
+
+    /** Sum of squares statistic implementation - can be reset by setter. */
+    private StorelessUnivariateStatistic[] sumSqImpl;
+
+    /** Minimum statistic implementation - can be reset by setter. */
+    private StorelessUnivariateStatistic[] minImpl;
+
+    /** Maximum statistic implementation - can be reset by setter. */
+    private StorelessUnivariateStatistic[] maxImpl;
+
+    /** Sum of log statistic implementation - can be reset by setter. */
+    private StorelessUnivariateStatistic[] sumLogImpl;
+
+    /** Geometric mean statistic implementation - can be reset by setter. */
+    private StorelessUnivariateStatistic[] geoMeanImpl;
+
+    /** Mean statistic implementation - can be reset by setter. */
+    private StorelessUnivariateStatistic[] meanImpl;
+
+    /** Covariance statistic implementation - cannot be reset. */
+    private VectorialCovariance covarianceImpl;
+
     /**
      * Construct a MultivariateSummaryStatistics instance
      * @param k dimension of the data
@@ -104,36 +134,6 @@ public class MultivariateSummaryStatistics
 
     }
 
-    /** Dimension of the data. */
-    private int k;
-
-    /** Count of values that have been added */
-    private long n = 0;
-
-    /** Sum statistic implementation - can be reset by setter. */
-    private StorelessUnivariateStatistic[] sumImpl;
-
-    /** Sum of squares statistic implementation - can be reset by setter. */
-    private StorelessUnivariateStatistic[] sumSqImpl;
-
-    /** Minimum statistic implementation - can be reset by setter. */
-    private StorelessUnivariateStatistic[] minImpl;
-
-    /** Maximum statistic implementation - can be reset by setter. */
-    private StorelessUnivariateStatistic[] maxImpl;
-
-    /** Sum of log statistic implementation - can be reset by setter. */
-    private StorelessUnivariateStatistic[] sumLogImpl;
-
-    /** Geometric mean statistic implementation - can be reset by setter. */
-    private StorelessUnivariateStatistic[] geoMeanImpl;
-
-    /** Mean statistic implementation - can be reset by setter. */
-    private StorelessUnivariateStatistic[] meanImpl;
-
-    /** Covariance statistic implementation - cannot be reset. */
-    private VectorialCovariance covarianceImpl;
-
     /**
      * Add an n-tuple to the data
      *
diff --git a/src/main/java/org/apache/commons/math/stat/descriptive/SummaryStatistics.java b/src/main/java/org/apache/commons/math/stat/descriptive/SummaryStatistics.java
index 6f165a188..6c972f67a 100644
--- a/src/main/java/org/apache/commons/math/stat/descriptive/SummaryStatistics.java
+++ b/src/main/java/org/apache/commons/math/stat/descriptive/SummaryStatistics.java
@@ -59,21 +59,6 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
     /** Serialization UID */
     private static final long serialVersionUID = -2021321786743555871L;
 
-    /**
-     * Construct a SummaryStatistics instance
-     */
-    public SummaryStatistics() {
-    }
-
-    /**
-     * A copy constructor. Creates a deep-copy of the {@code original}.
-     *
-     * @param original the {@code SummaryStatistics} instance to copy
-     */
-    public SummaryStatistics(SummaryStatistics original) {
-        copy(original, this);
-    }
-
     /** count of values that have been added */
     protected long n = 0;
 
@@ -128,6 +113,21 @@ public class SummaryStatistics implements StatisticalSummary, Serializable {
     /** Variance statistic implementation - can be reset by setter. */
     private StorelessUnivariateStatistic varianceImpl = variance;
 
+    /**
+     * Construct a SummaryStatistics instance
+     */
+    public SummaryStatistics() {
+    }
+
+    /**
+     * A copy constructor. Creates a deep-copy of the {@code original}.
+     *
+     * @param original the {@code SummaryStatistics} instance to copy
+     */
+    public SummaryStatistics(SummaryStatistics original) {
+        copy(original, this);
+    }
+
     /**
      * Return a {@link StatisticalSummaryValues} instance reporting current
      * statistics.
diff --git a/src/main/java/org/apache/commons/math/stat/descriptive/moment/GeometricMean.java b/src/main/java/org/apache/commons/math/stat/descriptive/moment/GeometricMean.java
index d7d560799..8883a1c40 100644
--- a/src/main/java/org/apache/commons/math/stat/descriptive/moment/GeometricMean.java
+++ b/src/main/java/org/apache/commons/math/stat/descriptive/moment/GeometricMean.java
@@ -73,6 +73,14 @@ public class GeometricMean extends AbstractStorelessUnivariateStatistic implemen
         copy(original, this);
     }
 
+    /**
+     * Create a GeometricMean instance using the given SumOfLogs instance
+     * @param sumOfLogs sum of logs instance to use for computation
+     */
+    public GeometricMean(SumOfLogs sumOfLogs) {
+        this.sumOfLogs = sumOfLogs;
+    }
+
     /**
      * {@inheritDoc}
      */
@@ -83,14 +91,6 @@ public class GeometricMean extends AbstractStorelessUnivariateStatistic implemen
         return result;
     }
 
-    /**
-     * Create a GeometricMean instance using the given SumOfLogs instance
-     * @param sumOfLogs sum of logs instance to use for computation
-     */
-    public GeometricMean(SumOfLogs sumOfLogs) {
-        this.sumOfLogs = sumOfLogs;
-    }
-
     /**
      * {@inheritDoc}
      */
diff --git a/src/main/java/org/apache/commons/math/stat/inference/TestUtils.java b/src/main/java/org/apache/commons/math/stat/inference/TestUtils.java
index 1921a459a..c5075fce5 100644
--- a/src/main/java/org/apache/commons/math/stat/inference/TestUtils.java
+++ b/src/main/java/org/apache/commons/math/stat/inference/TestUtils.java
@@ -28,12 +28,6 @@ import org.apache.commons.math.stat.descriptive.StatisticalSummary;
  * @version $Revision$ $Date$
  */
 public class TestUtils  {
-    /**
-     * Prevent instantiation.
-     */
-    protected TestUtils() {
-        super();
-    }
 
     /** Singleton TTest instance using default implementation. */
     private static TTest tTest = new TTestImpl();
@@ -50,6 +44,13 @@ public class TestUtils  {
     private static OneWayAnova oneWayAnova =
         new OneWayAnovaImpl();
 
+    /**
+     * Prevent instantiation.
+     */
+    protected TestUtils() {
+        super();
+    }
+
     /**
      * Set the (singleton) TTest instance.
      *
diff --git a/src/main/java/org/apache/commons/math/stat/ranking/NaturalRanking.java b/src/main/java/org/apache/commons/math/stat/ranking/NaturalRanking.java
index f03864db0..5e43290dc 100644
--- a/src/main/java/org/apache/commons/math/stat/ranking/NaturalRanking.java
+++ b/src/main/java/org/apache/commons/math/stat/ranking/NaturalRanking.java
@@ -69,6 +69,12 @@ import org.apache.commons.math.random.RandomGenerator;
  */
 public class NaturalRanking implements RankingAlgorithm {
 
+    /** default NaN strategy */
+    public static final NaNStrategy DEFAULT_NAN_STRATEGY = NaNStrategy.MAXIMAL;
+
+    /** default ties strategy */
+    public static final TiesStrategy DEFAULT_TIES_STRATEGY = TiesStrategy.AVERAGE;
+
     /** NaN strategy - defaults to NaNs maximal */
     private final NaNStrategy nanStrategy;
 
@@ -78,12 +84,6 @@ public class NaturalRanking implements RankingAlgorithm {
     /** Source of random data - used only when ties strategy is RANDOM */
     private final RandomData randomData;
 
-    /** default NaN strategy */
-    public static final NaNStrategy DEFAULT_NAN_STRATEGY = NaNStrategy.MAXIMAL;
-
-    /** default ties strategy */
-    public static final TiesStrategy DEFAULT_TIES_STRATEGY = TiesStrategy.AVERAGE;
-
     /**
      * Create a NaturalRanking with default strategies for handling ties and NaNs.
      */
diff --git a/src/main/java/org/apache/commons/math/util/BigReal.java b/src/main/java/org/apache/commons/math/util/BigReal.java
index f66816239..0b9b47514 100644
--- a/src/main/java/org/apache/commons/math/util/BigReal.java
+++ b/src/main/java/org/apache/commons/math/util/BigReal.java
@@ -36,15 +36,15 @@ import org.apache.commons.math.FieldElement;
  */
 public class BigReal implements FieldElement<BigReal>, Comparable<BigReal>, Serializable {
 
-    /** Serializable version identifier. */
-    private static final long serialVersionUID = 7887631840434052850L;
-
     /** A big real representing 0. */
     public static final BigReal ZERO = new BigReal(BigDecimal.ZERO);
 
     /** A big real representing 1. */
     public static final BigReal ONE = new BigReal(BigDecimal.ONE);
 
+    /** Serializable version identifier. */
+    private static final long serialVersionUID = 7887631840434052850L;
+
     /** Underlying BigDecimal. */
     private final BigDecimal d;
 
diff --git a/src/main/java/org/apache/commons/math/util/BigRealField.java b/src/main/java/org/apache/commons/math/util/BigRealField.java
index 0f21c6895..7eca9598d 100644
--- a/src/main/java/org/apache/commons/math/util/BigRealField.java
+++ b/src/main/java/org/apache/commons/math/util/BigRealField.java
@@ -57,19 +57,15 @@ public class BigRealField implements Field<BigReal>, Serializable  {
         return BigReal.ZERO;
     }
 
+    // CHECKSTYLE: stop HideUtilityClassConstructor
     /** Holder for the instance.
      * <p>We use here the Initialization On Demand Holder Idiom.</p>
      */
     private static class LazyHolder {
-
-        /** Private constructor. */
-        private LazyHolder() {
-        }
-
         /** Cached field instance. */
         private static final BigRealField INSTANCE = new BigRealField();
-
     }
+    // CHECKSTYLE: resume HideUtilityClassConstructor
 
     /** Handle deserialization of the singleton.
      * @return the singleton instance
diff --git a/src/main/java/org/apache/commons/math/util/MathUtils.java b/src/main/java/org/apache/commons/math/util/MathUtils.java
index 394841246..979c7f77a 100644
--- a/src/main/java/org/apache/commons/math/util/MathUtils.java
+++ b/src/main/java/org/apache/commons/math/util/MathUtils.java
@@ -65,6 +65,16 @@ public final class MathUtils {
     /** Offset to order signed double numbers lexicographically. */
     private static final long SGN_MASK = 0x8000000000000000L;
 
+    /** All long-representable factorials */
+    private static final long[] FACTORIALS = new long[] {
+                       1l,                  1l,                   2l,
+                       6l,                 24l,                 120l,
+                     720l,               5040l,               40320l,
+                  362880l,            3628800l,            39916800l,
+               479001600l,         6227020800l,         87178291200l,
+           1307674368000l,     20922789888000l,     355687428096000l,
+        6402373705728000l, 121645100408832000l, 2432902008176640000l };
+
     /**
      * Private Constructor
      */
@@ -469,13 +479,6 @@ public final class MathUtils {
         return true;
     }
 
-    /** All long-representable factorials */
-    private static final long[] FACTORIALS = new long[]
-       {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800,
-        479001600, 6227020800l, 87178291200l, 1307674368000l, 20922789888000l,
-        355687428096000l, 6402373705728000l, 121645100408832000l,
-        2432902008176640000l};
-
     /**
      * Returns n!. Shorthand for <code>n</code> <a
      * href="http://mathworld.wolfram.com/Factorial.html"> Factorial</a>, the
diff --git a/src/main/java/org/apache/commons/math/util/OpenIntToDoubleHashMap.java b/src/main/java/org/apache/commons/math/util/OpenIntToDoubleHashMap.java
index f288d30d1..1cfa90580 100644
--- a/src/main/java/org/apache/commons/math/util/OpenIntToDoubleHashMap.java
+++ b/src/main/java/org/apache/commons/math/util/OpenIntToDoubleHashMap.java
@@ -38,6 +38,15 @@ import org.apache.commons.math.MathRuntimeException;
  */
 public class OpenIntToDoubleHashMap implements Serializable {
 
+    /** Status indicator for free table entries. */
+    protected static final byte FREE    = 0;
+
+    /** Status indicator for full table entries. */
+    protected static final byte FULL    = 1;
+
+    /** Status indicator for removed table entries. */
+    protected static final byte REMOVED = 2;
+
     /** Serializable version identifier */
     private static final long serialVersionUID = -3646337053166149105L;
 
@@ -57,15 +66,6 @@ public class OpenIntToDoubleHashMap implements Serializable {
     /** Number of bits to perturb the index when probing for collision resolution. */
     private static final int PERTURB_SHIFT = 5;
 
-    /** Status indicator for free table entries. */
-    protected static final byte FREE    = 0;
-
-    /** Status indicator for full table entries. */
-    protected static final byte FULL    = 1;
-
-    /** Status indicator for removed table entries. */
-    protected static final byte REMOVED = 2;
-
     /** Keys table. */
     private int[] keys;
 
diff --git a/src/main/java/org/apache/commons/math/util/OpenIntToFieldHashMap.java b/src/main/java/org/apache/commons/math/util/OpenIntToFieldHashMap.java
index 3de831b41..bbd94870a 100644
--- a/src/main/java/org/apache/commons/math/util/OpenIntToFieldHashMap.java
+++ b/src/main/java/org/apache/commons/math/util/OpenIntToFieldHashMap.java
@@ -41,6 +41,15 @@ import org.apache.commons.math.MathRuntimeException;
  */
 public class OpenIntToFieldHashMap<T extends FieldElement<T>> implements Serializable {
 
+    /** Status indicator for free table entries. */
+    protected static final byte FREE    = 0;
+
+    /** Status indicator for full table entries. */
+    protected static final byte FULL    = 1;
+
+    /** Status indicator for removed table entries. */
+    protected static final byte REMOVED = 2;
+
     /** Serializable version identifier. */
     private static final long serialVersionUID = -9179080286849120720L;
 
@@ -60,15 +69,6 @@ public class OpenIntToFieldHashMap<T extends FieldElement<T>> implements Seriali
     /** Number of bits to perturb the index when probing for collision resolution. */
     private static final int PERTURB_SHIFT = 5;
 
-    /** Status indicator for free table entries. */
-    protected static final byte FREE    = 0;
-
-    /** Status indicator for full table entries. */
-    protected static final byte FULL    = 1;
-
-    /** Status indicator for removed table entries. */
-    protected static final byte REMOVED = 2;
-
     /** Field to which the elements belong. */
     private final Field<T> field;
 
diff --git a/src/main/java/org/apache/commons/math/util/ResizableDoubleArray.java b/src/main/java/org/apache/commons/math/util/ResizableDoubleArray.java
index b29615702..90087bede 100644
--- a/src/main/java/org/apache/commons/math/util/ResizableDoubleArray.java
+++ b/src/main/java/org/apache/commons/math/util/ResizableDoubleArray.java
@@ -73,15 +73,15 @@ import org.apache.commons.math.MathRuntimeException;
  */
 public class ResizableDoubleArray implements DoubleArray, Serializable {
 
-    /** Serializable version identifier */
-    private static final long serialVersionUID = -3485529955529426875L;
-
     /** additive expansion mode */
     public static final int ADDITIVE_MODE = 1;
 
     /** multiplicative expansion mode */
     public static final int MULTIPLICATIVE_MODE = 0;
 
+    /** Serializable version identifier */
+    private static final long serialVersionUID = -3485529955529426875L;
+
     /**
      * The contraction criteria determines when the internal array will be
      * contracted to fit the number of elements contained in the element