commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From l..@apache.org
Subject svn commit: r773189 - in /commons/proper/math/trunk/src: java/org/apache/commons/math/ java/org/apache/commons/math/stat/inference/ java/org/apache/commons/math/stat/regression/ site/xdoc/
Date Sat, 09 May 2009 09:57:05 GMT
Author: luc
Date: Sat May  9 09:57:04 2009
New Revision: 773189

URL: http://svn.apache.org/viewvc?rev=773189&view=rev
Log:
completed internationalization of all error messages

Modified:
    commons/proper/math/trunk/src/java/org/apache/commons/math/MessagesResources_fr.java
    commons/proper/math/trunk/src/java/org/apache/commons/math/stat/inference/ChiSquareTestImpl.java
    commons/proper/math/trunk/src/java/org/apache/commons/math/stat/inference/OneWayAnovaImpl.java
    commons/proper/math/trunk/src/java/org/apache/commons/math/stat/inference/TTestImpl.java
    commons/proper/math/trunk/src/java/org/apache/commons/math/stat/regression/AbstractMultipleLinearRegression.java
    commons/proper/math/trunk/src/java/org/apache/commons/math/stat/regression/OLSMultipleLinearRegression.java
    commons/proper/math/trunk/src/java/org/apache/commons/math/stat/regression/SimpleRegression.java
    commons/proper/math/trunk/src/site/xdoc/changes.xml

Modified: commons/proper/math/trunk/src/java/org/apache/commons/math/MessagesResources_fr.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/java/org/apache/commons/math/MessagesResources_fr.java?rev=773189&r1=773188&r2=773189&view=diff
==============================================================================
--- commons/proper/math/trunk/src/java/org/apache/commons/math/MessagesResources_fr.java (original)
+++ commons/proper/math/trunk/src/java/org/apache/commons/math/MessagesResources_fr.java Sat
May  9 09:57:04 2009
@@ -91,6 +91,8 @@
     // org.apache.commons.math.optimization.general.AbstractLeastSquaresOptimizer
     // org.apache.commons.math.ode.ContinuousOutputModel
     // org.apache.commons.math.random.UncorrelatedRandomVectorGenerator
+    // org.apache.commons.math.stat.regression.AbstractMultipleLinearRegression
+    // org.apache.commons.math.stat.inference.ChiSquareTestImpl
     { "dimension mismatch {0} != {1}",
       "dimensions incompatibles {0} != {1}" },
 
@@ -333,6 +335,7 @@
       "non sym\u00e9triques n''est pas encore disponible" },
 
     // org.apache.commons.math.linear.decomposition.NonSquareMatrixException
+    // org.apache.commons.math.stat.regression.AbstractMultipleLinearRegression
     { "a {0}x{1} matrix was provided instead of a square matrix",
       "une matrice {0}x{1} a \u00e9t\u00e9 fournie \u00e0 la place d''une matrice carr\u00e9e"
},
 
@@ -382,6 +385,10 @@
       "une matrice doit comporter au moins une ligne" },
     { "matrix must have at least one column",
       "une matrice doit comporter au moins une colonne" },
+
+    // org.apache.commons.math.linear.AbstractRealMatrix
+    // org.apache.commons.math.linear.AbstractFieldMatrix
+    // org.apache.commons.math.stat.inference.ChiSquareTestImpl      
     { "some rows have length {0} while others have length {1}",
       "certaines lignes ont une longueur de {0} alors que d''autres ont une longueur de {1}"
},
 
@@ -635,9 +642,48 @@
      "les statistiques bas\u00e9es sur des moments externes " +
      "ne peuvent pas \u00eatre remises \u00e0 z\u00e9ro" },
 
+   // org.apache.commons.math.stat.inference.ChiSquareTestImpl
+   { "expected array length = {0}, must be at least 2",
+     "le tableau des valeurs attendues a une longueur de {0}, elle devrait \u00eatre au moins
de 2" },
+   { "observed array length = {0}, must be at least 2",
+     "le tableau des valeurs observ\u00e9es a une longueur de {0}, elle devrait \u00eatre
au moins de 2" },
+   { "observed counts are all 0 in first observed array",
+     "aucune occurrence dans le premier tableau des observations" },
+   { "observed counts are all 0 in second observed array",
+     "aucune occurrence dans le second tableau des observations" },
+   { "observed counts are both zero for entry {0}",
+     "les occurrences observ\u00e9es sont toutes deux nulles pour l'entr\u00e9e {0}" },
+   { "invalid row dimension: {0} (must be at least 2)",
+     "nombre de lignes invalide : {0} (doit \u00eatre au moins de 2)" },
+   { "invalid column dimension: {0} (must be at least 2)",
+     "nombre de colonnes invalide : {0} (doit \u00eatre au moins de 2)" },
+   { "element {0} is not positive: {1}",
+     "l''\u00e9l\u00e9ment {0} n''est pas positif : {1}" },
+   { "element {0} is negative: {1}",
+     "l''\u00e9l\u00e9ment {0} est n\u00e9gatif : {1}" },
+   { "element ({0}, {1}) is negative: {2}",
+     "l''\u00e9l\u00e9ment ({0}, {1}) est n\u00e9gatif : {2}" },
+
+   // org.apache.commons.math.stat.inference.OneWayAnovaImpl
+   { "two or more categories required, got {0}",
+     "deux cat\u00e9gories ou plus sont n\u00e9cessaires, il y en a {0}" },
+   { "two or more values required in each category, one has {0}",
+     "deux valeurs ou plus sont n\u00e9cessaires pour chaque cat\u00e9gorie, une cat\u00e9gorie
en a {0}" },
+
+   // org.apache.commons.math.stat.inference.TTestImpl
+   { "insufficient data for t statistic, needs at least 2, got {0}",
+     "deux valeurs ou plus sont n\u00e9cessaires pour la statistique t, il y en a {0}" },
+
+   // org.apache.commons.math.stat.inference.ChiSquareTestImpl
+   // org.apache.commons.math.stat.inference.TTestImpl
+   // org.apache.commons.math.stat.inference.OneWayAnovaImpl
    // org.apache.commons.math.stat.Regression
-   { "out of bounds significance level {0}, must be in (0, 1)",
-     "niveau de signification {0} hors domaine, doit \u00eatre dans l''intervalle ]0, 1["
},
+   { "out of bounds significance level {0}, must be between {1} and {2}",
+     "niveau de signification {0} hors domaine, doit \u00eatre entre {1} et {2}" },
+
+   // org.apache.commons.math.stat.regression.OLSMultipleLinearRegression
+   { "matrix is not upper-triangular, entry ({0}, {1}) = {2} is too large",
+     "matrice non triangulaire sup\u00e9rieure, l''\u00e9l\u00e9ment ({0}, {1}) = {2} est
trop grand" },
 
    // org.apache.commons.math.distribution.AbstractContinuousDistribution
    // org.apache.commons.math.distribution.AbstractIntegerDistribution

Modified: commons/proper/math/trunk/src/java/org/apache/commons/math/stat/inference/ChiSquareTestImpl.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/java/org/apache/commons/math/stat/inference/ChiSquareTestImpl.java?rev=773189&r1=773188&r2=773189&view=diff
==============================================================================
--- commons/proper/math/trunk/src/java/org/apache/commons/math/stat/inference/ChiSquareTestImpl.java
(original)
+++ commons/proper/math/trunk/src/java/org/apache/commons/math/stat/inference/ChiSquareTestImpl.java
Sat May  9 09:57:04 2009
@@ -17,6 +17,7 @@
 package org.apache.commons.math.stat.inference;
 
 import org.apache.commons.math.MathException;
+import org.apache.commons.math.MathRuntimeException;
 import org.apache.commons.math.distribution.ChiSquaredDistribution;
 import org.apache.commons.math.distribution.ChiSquaredDistributionImpl;
 
@@ -62,14 +63,17 @@
      */
     public double chiSquare(double[] expected, long[] observed)
         throws IllegalArgumentException {
-        if ((expected.length < 2) || (expected.length != observed.length)) {
-            throw new IllegalArgumentException(
-                    "observed, expected array lengths incorrect");
-        }
-        if (!isPositive(expected) || !isNonNegative(observed)) {
-            throw new IllegalArgumentException(
-                "observed counts must be non-negative and expected counts must be postive");
+        if (expected.length < 2) {
+            throw MathRuntimeException.createIllegalArgumentException(
+                  "expected array length = {0}, must be at least 2",
+                  expected.length);
+        }
+        if (expected.length != observed.length) {
+            throw MathRuntimeException.createIllegalArgumentException(
+                  "dimension mismatch {0} != {1}", expected.length, observed.length);
         }
+        checkPositive(expected);
+        checkNonNegative(observed);
         double sumExpected = 0d;
         double sumObserved = 0d;
         for (int i = 0; i < observed.length; i++) {
@@ -132,8 +136,9 @@
     public boolean chiSquareTest(double[] expected, long[] observed, 
             double alpha) throws IllegalArgumentException, MathException {
         if ((alpha <= 0) || (alpha > 0.5)) {
-            throw new IllegalArgumentException(
-                    "bad significance level: " + alpha);
+            throw MathRuntimeException.createIllegalArgumentException(
+                  "out of bounds significance level {0}, must be between {1} and {2}",
+                  alpha, 0, 0.5);
         }
         return (chiSquareTest(expected, observed) < alpha);
     }
@@ -199,7 +204,9 @@
     public boolean chiSquareTest(long[][] counts, double alpha)
     throws IllegalArgumentException, MathException {
         if ((alpha <= 0) || (alpha > 0.5)) {
-            throw new IllegalArgumentException("bad significance level: " + alpha);
+            throw MathRuntimeException.createIllegalArgumentException(
+                  "out of bounds significance level {0}, must be between {1} and {2}",
+                  alpha, 0.0, 0.5);
         }
         return (chiSquareTest(counts) < alpha);
     }
@@ -215,15 +222,21 @@
         throws IllegalArgumentException {
         
         // Make sure lengths are same
-        if ((observed1.length < 2) || (observed1.length != observed2.length)) {
-            throw new IllegalArgumentException(
-                    "oberved1, observed2 array lengths incorrect");
+        if (observed1.length < 2) {
+            throw MathRuntimeException.createIllegalArgumentException(
+                  "observed array length = {0}, must be at least 2",
+                  observed1.length);
+        }
+        if (observed1.length != observed2.length) {
+            throw MathRuntimeException.createIllegalArgumentException(
+                  "dimension mismatch {0} != {1}",
+                  observed1.length, observed2.length);
         }
+
         // Ensure non-negative counts
-        if (!isNonNegative(observed1) || !isNonNegative(observed2)) {
-            throw new IllegalArgumentException(
-                "observed counts must be non-negative");
-        }
+        checkNonNegative(observed1);
+        checkNonNegative(observed2);
+
         // Compute and compare count sums
         long countSum1 = 0;
         long countSum2 = 0;
@@ -234,9 +247,13 @@
             countSum2 += observed2[i];   
         }
         // Ensure neither sample is uniformly 0
-        if (countSum1 * countSum2 == 0) {
-            throw new IllegalArgumentException(
-             "observed counts cannot all be 0"); 
+        if (countSum1 == 0) {
+            throw MathRuntimeException.createIllegalArgumentException(
+                  "observed counts are all 0 in first observed array"); 
+        }
+        if (countSum2 == 0) {
+            throw MathRuntimeException.createIllegalArgumentException(
+                  "observed counts are all 0 in second observed array"); 
         }
         // Compare and compute weight only if different
         unequalCounts = (countSum1 != countSum2);
@@ -250,8 +267,8 @@
         double obs2 = 0.0d;
         for (int i = 0; i < observed1.length; i++) {
             if (observed1[i] == 0 && observed2[i] == 0) {
-                throw new IllegalArgumentException(
-                        "observed counts must not both be zero");
+                throw MathRuntimeException.createIllegalArgumentException(
+                      "observed counts are both zero for entry {0}", i);
             } else {
                 obs1 = observed1[i];
                 obs2 = observed2[i];
@@ -294,8 +311,9 @@
     public boolean chiSquareTestDataSetsComparison(long[] observed1, long[] observed2,
             double alpha) throws IllegalArgumentException, MathException {
         if ((alpha <= 0) || (alpha > 0.5)) {
-            throw new IllegalArgumentException(
-                    "bad significance level: " + alpha);
+            throw MathRuntimeException.createIllegalArgumentException(
+                  "out of bounds significance level {0}, must be between {1} and {2}",
+                  alpha, 0.0, 0.5);
         }
         return (chiSquareTestDataSetsComparison(observed1, observed2) < alpha);
     }
@@ -311,20 +329,19 @@
     private void checkArray(long[][] in) throws IllegalArgumentException {
         
         if (in.length < 2) {
-            throw new IllegalArgumentException("Input table must have at least two rows");
+            throw MathRuntimeException.createIllegalArgumentException(
+                  "invalid row dimension: {0} (must be at least 2)",
+                  in.length);
         }
         
         if (in[0].length < 2) {
-            throw new IllegalArgumentException("Input table must have at least two columns");
+            throw MathRuntimeException.createIllegalArgumentException(
+                  "invalid column dimension: {0} (must be at least 2)",
+                  in[0].length);
         }    
         
-        if (!isRectangular(in)) {
-            throw new IllegalArgumentException("Input table must be rectangular");
-        }
-        
-        if (!isNonNegative(in)) {
-            throw new IllegalArgumentException("All entries in input 2-way table must be
non-negative");
-        }
+        checkRectangular(in);
+        checkNonNegative(in);
         
     }
     
@@ -338,66 +355,64 @@
      * @throws NullPointerException if input array is null
      * @throws ArrayIndexOutOfBoundsException if input array is empty
      */
-    private boolean isRectangular(long[][] in) {
+    private void checkRectangular(long[][] in) {
         for (int i = 1; i < in.length; i++) {
             if (in[i].length != in[0].length) {
-                return false;
+                throw MathRuntimeException.createIllegalArgumentException(
+                      "some rows have length {0} while others have length {1}",
+                      in[i].length, in[0].length);
             }
         }  
-        return true;
     }
     
     /**
-     * Returns true iff all entries of the input array are > 0.
-     * Returns true if the array is non-null, but empty
+     * Check all entries of the input array are > 0.
      * 
      * @param in array to be tested
-     * @return true if all entries of the array are positive
-     * @throws NullPointerException if input array is null
+     * @exception IllegalArgumentException if one entry is not positive
      */
-    private boolean isPositive(double[] in) {
-        for (int i = 0; i < in.length; i ++) {
+    private void checkPositive(double[] in) throws IllegalArgumentException {
+        for (int i = 0; i < in.length; i++) {
             if (in[i] <= 0) {
-                return false;
+                throw MathRuntimeException.createIllegalArgumentException(
+                      "element {0} is not positive: {1}",
+                      i, in[i]);
             }
         }
-        return true;
     }
     
     /**
-     * Returns true iff all entries of the input array are >= 0.
-     * Returns true if the array is non-null, but empty
+     * Check all entries of the input array are >= 0.
      * 
      * @param in array to be tested
-     * @return true if all entries of the array are non-negative
-     * @throws NullPointerException if input array is null
+     * @exception IllegalArgumentException if one entry is negative
      */
-    private boolean isNonNegative(long[] in) {
-        for (int i = 0; i < in.length; i ++) {
+    private void checkNonNegative(long[] in) throws IllegalArgumentException {
+        for (int i = 0; i < in.length; i++) {
             if (in[i] < 0) {
-                return false;
+                throw MathRuntimeException.createIllegalArgumentException(
+                      "element {0} is negative: {1}",
+                      i, in[i]);
             }
         }
-        return true;
     }
     
     /**
-     * Returns true iff all entries of (all subarrays of) the input array are >= 0.
-     * Returns true if the array is non-null, but empty
+     * Check all entries of the input array are >= 0.
      * 
      * @param in array to be tested
-     * @return true if all entries of the array are non-negative
-     * @throws NullPointerException if input array is null
+     * @exception IllegalArgumentException if one entry is negative
      */
-    private boolean isNonNegative(long[][] in) {
+    private void checkNonNegative(long[][] in) throws IllegalArgumentException {
         for (int i = 0; i < in.length; i ++) {
             for (int j = 0; j < in[i].length; j++) {
                 if (in[i][j] < 0) {
-                    return false;
+                    throw MathRuntimeException.createIllegalArgumentException(
+                          "element ({0}, {1}) is negative: {2}",
+                          i, j, in[i][j]);
                 }
             }
         }
-        return true;
     }
  
     /**

Modified: commons/proper/math/trunk/src/java/org/apache/commons/math/stat/inference/OneWayAnovaImpl.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/java/org/apache/commons/math/stat/inference/OneWayAnovaImpl.java?rev=773189&r1=773188&r2=773189&view=diff
==============================================================================
--- commons/proper/math/trunk/src/java/org/apache/commons/math/stat/inference/OneWayAnovaImpl.java
(original)
+++ commons/proper/math/trunk/src/java/org/apache/commons/math/stat/inference/OneWayAnovaImpl.java
Sat May  9 09:57:04 2009
@@ -19,6 +19,7 @@
 import java.util.Collection;
 
 import org.apache.commons.math.MathException;
+import org.apache.commons.math.MathRuntimeException;
 import org.apache.commons.math.distribution.FDistribution;
 import org.apache.commons.math.distribution.FDistributionImpl;
 import org.apache.commons.math.stat.descriptive.summary.Sum;
@@ -100,7 +101,9 @@
     public boolean anovaTest(Collection<double[]> categoryData, double alpha)
         throws IllegalArgumentException, MathException {
         if ((alpha <= 0) || (alpha > 0.5)) {
-            throw new IllegalArgumentException("bad significance level: " + alpha);
+            throw MathRuntimeException.createIllegalArgumentException(
+                  "out of bounds significance level {0}, must be between {1} and {2}",
+                  alpha, 0, 0.5);
         }
         return (anovaPValue(categoryData) < alpha);
     }
@@ -121,15 +124,17 @@
 
         // check if we have enough categories
         if (categoryData.size() < 2) {
-            throw new IllegalArgumentException(
-                    "ANOVA: two or more categories required");
+            throw MathRuntimeException.createIllegalArgumentException(
+                  "two or more categories required, got {0}",
+                  categoryData.size());
         }
         
         // check if each category has enough data and all is double[]
         for (double[] array : categoryData) {
             if (array.length <= 1) {
-                throw new IllegalArgumentException(
-                        "ANOVA: one element of categoryData has fewer than 2 values.");
+                throw MathRuntimeException.createIllegalArgumentException(
+                      "two or more values required in each category, one has {0}",
+                      array.length);
             }
         }
 

Modified: commons/proper/math/trunk/src/java/org/apache/commons/math/stat/inference/TTestImpl.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/java/org/apache/commons/math/stat/inference/TTestImpl.java?rev=773189&r1=773188&r2=773189&view=diff
==============================================================================
--- commons/proper/math/trunk/src/java/org/apache/commons/math/stat/inference/TTestImpl.java
(original)
+++ commons/proper/math/trunk/src/java/org/apache/commons/math/stat/inference/TTestImpl.java
Sat May  9 09:57:04 2009
@@ -17,6 +17,7 @@
 package org.apache.commons.math.stat.inference;
 
 import org.apache.commons.math.MathException;
+import org.apache.commons.math.MathRuntimeException;
 import org.apache.commons.math.distribution.TDistribution;
 import org.apache.commons.math.distribution.TDistributionImpl;
 import org.apache.commons.math.stat.StatUtils;
@@ -75,10 +76,8 @@
      */
     public double pairedT(double[] sample1, double[] sample2)
         throws IllegalArgumentException, MathException {
-        if ((sample1 == null) || (sample2 == null ||
-                Math.min(sample1.length, sample2.length) < 2)) {
-            throw new IllegalArgumentException("insufficient data for t statistic");
-        }
+        checkSampleData(sample1);
+        checkSampleData(sample2);
         double meanDifference = StatUtils.meanDifference(sample1, sample2);
         return t(meanDifference, 0,  
                 StatUtils.varianceDifference(sample1, sample2, meanDifference),
@@ -160,9 +159,7 @@
      */
     public boolean pairedTTest(double[] sample1, double[] sample2, double alpha)
         throws IllegalArgumentException, MathException {
-        if ((alpha <= 0) || (alpha > 0.5)) {
-            throw new IllegalArgumentException("bad significance level: " + alpha);
-        }
+        checkSignificanceLevel(alpha);
         return (pairedTTest(sample1, sample2) < alpha);
     }
 
@@ -183,9 +180,7 @@
      */
     public double t(double mu, double[] observed)
     throws IllegalArgumentException {
-        if ((observed == null) || (observed.length < 2)) {
-            throw new IllegalArgumentException("insufficient data for t statistic");
-        }
+        checkSampleData(observed);
         return t(StatUtils.mean(observed), mu, StatUtils.variance(observed),
                 observed.length);
     }
@@ -208,9 +203,7 @@
      */
     public double t(double mu, StatisticalSummary sampleStats)
     throws IllegalArgumentException {
-        if ((sampleStats == null) || (sampleStats.getN() < 2)) {
-            throw new IllegalArgumentException("insufficient data for t statistic");
-        }
+        checkSampleData(sampleStats);
         return t(sampleStats.getMean(), mu, sampleStats.getVariance(),
                 sampleStats.getN());
     }
@@ -250,10 +243,8 @@
      */
     public double homoscedasticT(double[] sample1, double[] sample2)
     throws IllegalArgumentException {
-        if ((sample1 == null) || (sample2 == null ||
-                Math.min(sample1.length, sample2.length) < 2)) {
-            throw new IllegalArgumentException("insufficient data for t statistic");
-        }
+        checkSampleData(sample1);
+        checkSampleData(sample2);
         return homoscedasticT(StatUtils.mean(sample1), StatUtils.mean(sample2),
                 StatUtils.variance(sample1), StatUtils.variance(sample2),
                 sample1.length, sample2.length);
@@ -289,10 +280,8 @@
      */
     public double t(double[] sample1, double[] sample2)
     throws IllegalArgumentException {
-        if ((sample1 == null) || (sample2 == null ||
-                Math.min(sample1.length, sample2.length) < 2)) {
-            throw new IllegalArgumentException("insufficient data for t statistic");
-        }
+        checkSampleData(sample1);
+        checkSampleData(sample2);
         return t(StatUtils.mean(sample1), StatUtils.mean(sample2),
                 StatUtils.variance(sample1), StatUtils.variance(sample2),
                 sample1.length, sample2.length);
@@ -330,13 +319,10 @@
      * @throws IllegalArgumentException if the precondition is not met
      */
     public double t(StatisticalSummary sampleStats1, 
-            StatisticalSummary sampleStats2)
+                    StatisticalSummary sampleStats2)
     throws IllegalArgumentException {
-        if ((sampleStats1 == null) ||
-                (sampleStats2 == null ||
-                        Math.min(sampleStats1.getN(), sampleStats2.getN()) < 2)) {
-            throw new IllegalArgumentException("insufficient data for t statistic");
-        }
+        checkSampleData(sampleStats1);
+        checkSampleData(sampleStats2);
         return t(sampleStats1.getMean(), sampleStats2.getMean(), 
                 sampleStats1.getVariance(), sampleStats2.getVariance(),
                 sampleStats1.getN(), sampleStats2.getN());
@@ -380,11 +366,8 @@
     public double homoscedasticT(StatisticalSummary sampleStats1, 
             StatisticalSummary sampleStats2)
     throws IllegalArgumentException {
-        if ((sampleStats1 == null) ||
-                (sampleStats2 == null ||
-                        Math.min(sampleStats1.getN(), sampleStats2.getN()) < 2)) {
-            throw new IllegalArgumentException("insufficient data for t statistic");
-        }
+        checkSampleData(sampleStats1);
+        checkSampleData(sampleStats2);
         return homoscedasticT(sampleStats1.getMean(), sampleStats2.getMean(), 
                 sampleStats1.getVariance(), sampleStats2.getVariance(), 
                 sampleStats1.getN(), sampleStats2.getN());
@@ -418,9 +401,7 @@
      */
     public double tTest(double mu, double[] sample)
     throws IllegalArgumentException, MathException {
-        if ((sample == null) || (sample.length < 2)) {
-            throw new IllegalArgumentException("insufficient data for t statistic");
-        }
+        checkSampleData(sample);
         return tTest( StatUtils.mean(sample), mu, StatUtils.variance(sample),
                 sample.length);
     }
@@ -462,9 +443,7 @@
      */
     public boolean tTest(double mu, double[] sample, double alpha)
     throws IllegalArgumentException, MathException {
-        if ((alpha <= 0) || (alpha > 0.5)) {
-            throw new IllegalArgumentException("bad significance level: " + alpha);
-        }
+        checkSignificanceLevel(alpha);
         return (tTest(mu, sample) < alpha);
     }
 
@@ -498,9 +477,7 @@
      */
     public double tTest(double mu, StatisticalSummary sampleStats)
     throws IllegalArgumentException, MathException {
-        if ((sampleStats == null) || (sampleStats.getN() < 2)) {
-            throw new IllegalArgumentException("insufficient data for t statistic");
-        }
+        checkSampleData(sampleStats);
         return tTest(sampleStats.getMean(), mu, sampleStats.getVariance(),
                 sampleStats.getN());
     }
@@ -544,9 +521,7 @@
     public boolean tTest( double mu, StatisticalSummary sampleStats,
             double alpha)
     throws IllegalArgumentException, MathException {
-        if ((alpha <= 0) || (alpha > 0.5)) {
-            throw new IllegalArgumentException("bad significance level: " + alpha);
-        }
+        checkSignificanceLevel(alpha);
         return (tTest(mu, sampleStats) < alpha);
     }
 
@@ -588,10 +563,8 @@
      */
     public double tTest(double[] sample1, double[] sample2)
     throws IllegalArgumentException, MathException {
-        if ((sample1 == null) || (sample2 == null ||
-                Math.min(sample1.length, sample2.length) < 2)) {
-            throw new IllegalArgumentException("insufficient data");
-        }
+        checkSampleData(sample1);
+        checkSampleData(sample2);
         return tTest(StatUtils.mean(sample1), StatUtils.mean(sample2),
                 StatUtils.variance(sample1), StatUtils.variance(sample2),
                 sample1.length, sample2.length);
@@ -632,10 +605,8 @@
      */
     public double homoscedasticTTest(double[] sample1, double[] sample2)
     throws IllegalArgumentException, MathException {
-        if ((sample1 == null) || (sample2 == null ||
-                Math.min(sample1.length, sample2.length) < 2)) {
-            throw new IllegalArgumentException("insufficient data");
-        }
+        checkSampleData(sample1);
+        checkSampleData(sample2);
         return homoscedasticTTest(StatUtils.mean(sample1), 
                 StatUtils.mean(sample2), StatUtils.variance(sample1),
                 StatUtils.variance(sample2), sample1.length, 
@@ -697,9 +668,7 @@
     public boolean tTest(double[] sample1, double[] sample2,
             double alpha)
     throws IllegalArgumentException, MathException {
-        if ((alpha <= 0) || (alpha > 0.5)) {
-            throw new IllegalArgumentException("bad significance level: " + alpha);
-        }
+        checkSignificanceLevel(alpha);
         return (tTest(sample1, sample2) < alpha);
     }
     
@@ -757,9 +726,7 @@
     public boolean homoscedasticTTest(double[] sample1, double[] sample2,
             double alpha)
     throws IllegalArgumentException, MathException {
-        if ((alpha <= 0) || (alpha > 0.5)) {
-            throw new IllegalArgumentException("bad significance level: " + alpha);
-        }
+        checkSignificanceLevel(alpha);
         return (homoscedasticTTest(sample1, sample2) < alpha);
     }
 
@@ -799,10 +766,8 @@
      */
     public double tTest(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2)
     throws IllegalArgumentException, MathException {
-        if ((sampleStats1 == null) || (sampleStats2 == null ||
-                Math.min(sampleStats1.getN(), sampleStats2.getN()) < 2)) {
-            throw new IllegalArgumentException("insufficient data for t statistic");
-        }
+        checkSampleData(sampleStats1);
+        checkSampleData(sampleStats2);
         return tTest(sampleStats1.getMean(), sampleStats2.getMean(), sampleStats1.getVariance(),
                 sampleStats2.getVariance(), sampleStats1.getN(), 
                 sampleStats2.getN());
@@ -842,12 +807,10 @@
      * @throws MathException if an error occurs computing the p-value
      */
     public double homoscedasticTTest(StatisticalSummary sampleStats1, 
-            StatisticalSummary sampleStats2)
+                                     StatisticalSummary sampleStats2)
     throws IllegalArgumentException, MathException {
-        if ((sampleStats1 == null) || (sampleStats2 == null ||
-                Math.min(sampleStats1.getN(), sampleStats2.getN()) < 2)) {
-            throw new IllegalArgumentException("insufficient data for t statistic");
-        }
+        checkSampleData(sampleStats1);
+        checkSampleData(sampleStats2);
         return homoscedasticTTest(sampleStats1.getMean(),
                 sampleStats2.getMean(), sampleStats1.getVariance(),
                 sampleStats2.getVariance(), sampleStats1.getN(), 
@@ -910,9 +873,7 @@
     public boolean tTest(StatisticalSummary sampleStats1,
             StatisticalSummary sampleStats2, double alpha)
     throws IllegalArgumentException, MathException {
-        if ((alpha <= 0) || (alpha > 0.5)) {
-            throw new IllegalArgumentException("bad significance level: " + alpha);
-        }
+        checkSignificanceLevel(alpha);
         return (tTest(sampleStats1, sampleStats2) < alpha);
     }
     
@@ -1056,4 +1017,44 @@
     public void setDistribution(TDistribution value) {
         distribution = value;
     }
+
+    /** Check significance level.
+     * @param alpha significance level
+     * @exception IllegalArgumentException if significance level is out of bounds
+     */
+    private void checkSignificanceLevel(final double alpha)
+        throws IllegalArgumentException {
+        if ((alpha <= 0) || (alpha > 0.5)) {
+            throw MathRuntimeException.createIllegalArgumentException(
+                  "out of bounds significance level {0}, must be between {1} and {2}",
+                  alpha, 0.0, 0.5);
+        }
+    }
+
+    /** Check sample data.
+     * @param data sample data
+     * @exception IllegalArgumentException if there is not enough sample data
+     */
+    private void checkSampleData(final double[] data)
+        throws IllegalArgumentException {
+        if ((data == null) || (data.length < 2)) {
+            throw MathRuntimeException.createIllegalArgumentException(
+                  "insufficient data for t statistic, needs at least 2, got {0}",
+                  (data == null) ? 0 : data.length);
+        }
+    }
+
+    /** Check sample data.
+     * @param stat statistical summary
+     * @exception IllegalArgumentException if there is not enough sample data
+     */
+    private void checkSampleData(final StatisticalSummary stat)
+        throws IllegalArgumentException {
+        if ((stat == null) || (stat.getN() < 2)) {
+            throw MathRuntimeException.createIllegalArgumentException(
+                  "insufficient data for t statistic, needs at least 2, got {0}",
+                  (stat == null) ? 0 : stat.getN());
+        }
+    }
+
 }

Modified: commons/proper/math/trunk/src/java/org/apache/commons/math/stat/regression/AbstractMultipleLinearRegression.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/java/org/apache/commons/math/stat/regression/AbstractMultipleLinearRegression.java?rev=773189&r1=773188&r2=773189&view=diff
==============================================================================
--- commons/proper/math/trunk/src/java/org/apache/commons/math/stat/regression/AbstractMultipleLinearRegression.java
(original)
+++ commons/proper/math/trunk/src/java/org/apache/commons/math/stat/regression/AbstractMultipleLinearRegression.java
Sat May  9 09:57:04 2009
@@ -16,6 +16,7 @@
  */
 package org.apache.commons.math.stat.regression;
 
+import org.apache.commons.math.MathRuntimeException;
 import org.apache.commons.math.linear.RealMatrix;
 import org.apache.commons.math.linear.RealMatrixImpl;
 import org.apache.commons.math.linear.RealVector;
@@ -85,15 +86,11 @@
      *             compatible for the regression
      */
     protected void validateSampleData(double[][] x, double[] y) {
-        if (x == null) {
-            throw new IllegalArgumentException("The regressors matrix x cannot be null.");
-        }
-        if (y == null) {
-            throw new IllegalArgumentException("The regressand vector y cannot be null.");
-        }
-        if (x.length != y.length) {
-            throw new IllegalArgumentException(
-                    "The regressors matrix x columns must have the same length of the regressand
vector y");
+        if ((x == null) || (y == null) || (x.length != y.length)) {
+            throw MathRuntimeException.createIllegalArgumentException(
+                  "dimension mismatch {0} != {1}",
+                  (x == null) ? 0 : x.length,
+                  (y == null) ? 0 : y.length);
         }
     }
 
@@ -106,15 +103,14 @@
      *             matrix are not compatible for the regression
      */
     protected void validateCovarianceData(double[][] x, double[][] covariance) {
-        if (covariance == null) {
-            throw new IllegalArgumentException("Covariance matrix cannot be null.");
-        }
         if (x.length != covariance.length) {
-            throw new IllegalArgumentException(
-                    "The regressors matrix x columns must have the same length of the covariance
matrix columns");
+            throw MathRuntimeException.createIllegalArgumentException(
+                 "dimension mismatch {0} != {1}", x.length, covariance.length);
         }
         if (covariance.length > 0 && covariance.length != covariance[0].length)
{
-            throw new IllegalArgumentException("The covariance matrix must be square");
+            throw MathRuntimeException.createIllegalArgumentException(
+                  "a {0}x{1} matrix was provided instead of a square matrix",
+                  covariance.length, covariance[0].length);
         }
     }
 

Modified: commons/proper/math/trunk/src/java/org/apache/commons/math/stat/regression/OLSMultipleLinearRegression.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/java/org/apache/commons/math/stat/regression/OLSMultipleLinearRegression.java?rev=773189&r1=773188&r2=773189&view=diff
==============================================================================
--- commons/proper/math/trunk/src/java/org/apache/commons/math/stat/regression/OLSMultipleLinearRegression.java
(original)
+++ commons/proper/math/trunk/src/java/org/apache/commons/math/stat/regression/OLSMultipleLinearRegression.java
Sat May  9 09:57:04 2009
@@ -16,6 +16,7 @@
  */
 package org.apache.commons.math.stat.regression;
 
+import org.apache.commons.math.MathRuntimeException;
 import org.apache.commons.math.linear.RealMatrix;
 import org.apache.commons.math.linear.RealMatrixImpl;
 import org.apache.commons.math.linear.RealVector;
@@ -199,10 +200,7 @@
      */
     private static RealVector solveUpperTriangular(RealMatrix coefficients,
                                                    RealVector constants) {
-        if (!isUpperTriangular(coefficients, 1E-12)) {
-            throw new IllegalArgumentException(
-                   "Coefficients is not upper-triangular");
-        }
+        checkUpperTriangular(coefficients, 1E-12);
         int length = coefficients.getColumnDimension();
         double x[] = new double[length];
         for (int i = 0; i < length; i++) {
@@ -217,7 +215,7 @@
     }
     
     /**
-     * <p>Returns true iff m is an upper-triangular matrix.</p>
+     * <p>Check if a matrix is upper-triangular.</p>
      * 
      * <p>Makes sure all below-diagonal elements are within epsilon of 0.</p>
      * 
@@ -225,20 +223,20 @@
      * @param epsilon maximum allowable absolute value for elements below
      * the main diagonal
      * 
-     * @return true if m is upper-triangular; false otherwise
-     * @throws NullPointerException if m is null
+     * @throws IllegalArgumentException if m is not upper-triangular
      */
-    private static boolean isUpperTriangular(RealMatrix m, double epsilon) {
+    private static void checkUpperTriangular(RealMatrix m, double epsilon) {
         int nCols = m.getColumnDimension();
         int nRows = m.getRowDimension();
         for (int r = 0; r < nRows; r++) {
             int bound = Math.min(r, nCols);
             for (int c = 0; c < bound; c++) {
                 if (Math.abs(m.getEntry(r, c)) > epsilon) {
-                    return false;
+                    throw MathRuntimeException.createIllegalArgumentException(
+                          "matrix is not upper-triangular, entry ({0}, {1}) = {2} is too
large",
+                          r, c, m.getEntry(r, c));
                 }
             }
         }
-        return true;
     }
 }

Modified: commons/proper/math/trunk/src/java/org/apache/commons/math/stat/regression/SimpleRegression.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/java/org/apache/commons/math/stat/regression/SimpleRegression.java?rev=773189&r1=773188&r2=773189&view=diff
==============================================================================
--- commons/proper/math/trunk/src/java/org/apache/commons/math/stat/regression/SimpleRegression.java
(original)
+++ commons/proper/math/trunk/src/java/org/apache/commons/math/stat/regression/SimpleRegression.java
Sat May  9 09:57:04 2009
@@ -548,8 +548,8 @@
         throws MathException {
         if (alpha >= 1 || alpha <= 0) {
             throw MathRuntimeException.createIllegalArgumentException(
-                  "out of bounds significance level {0}, must be in (0, 1)",
-                  alpha);
+                  "out of bounds significance level {0}, must be between {1} and {2}",
+                  alpha, 0.0, 1.0);
         }
         return getSlopeStdErr() *
             distribution.inverseCumulativeProbability(1d - alpha / 2d);

Modified: commons/proper/math/trunk/src/site/xdoc/changes.xml
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/site/xdoc/changes.xml?rev=773189&r1=773188&r2=773189&view=diff
==============================================================================
--- commons/proper/math/trunk/src/site/xdoc/changes.xml (original)
+++ commons/proper/math/trunk/src/site/xdoc/changes.xml Sat May  9 09:57:04 2009
@@ -39,6 +39,9 @@
   </properties>
   <body>
     <release version="2.0" date="TBD" description="TBD">
+      <action dev="luc" type="update" >
+        Completed internationalization of all error messages
+      </action>
       <action dev="luc" type="add" issue="MATH-266" due-to="Benjamin McCann">
         Added a clustering package with an implementation of the k-means++ algorithm
       </action>



Mime
View raw message