Apache
/
commons-math
mirror of https://github.com/apache/commons-math.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

completed internationalization of all error messages 

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/math/trunk@773189 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Luc Maisonobe 2009-05-09 09:57:04 +00:00
parent f4dbd2ecf5
commit 2ba5fd1cbc
8 changed files with 226 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
src/java/org/apache/commons/math/MessagesResources_fr.java
View File

@ -91,6 +91,8 @@ public class MessagesResources_fr
// 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 @@ public class MessagesResources_fr
"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 @@ public class MessagesResources_fr
"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 @@ public class MessagesResources_fr
"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

131
src/java/org/apache/commons/math/stat/inference/ChiSquareTestImpl.java
View File

@ -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 class ChiSquareTestImpl implements UnknownDistributionChiSquareTest {
*/
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 (expected.length < 2) {
throw MathRuntimeException.createIllegalArgumentException(
"expected array length = {0}, must be at least 2",
expected.length);
}
if (!isPositive(expected) || !isNonNegative(observed)) {
throw new IllegalArgumentException(
"observed counts must be non-negative and expected counts must be postive");
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 class ChiSquareTestImpl implements UnknownDistributionChiSquareTest {
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 class ChiSquareTestImpl implements UnknownDistributionChiSquareTest {
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 @@ public class ChiSquareTestImpl implements UnknownDistributionChiSquareTest {
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 @@ public class ChiSquareTestImpl implements UnknownDistributionChiSquareTest {
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 @@ public class ChiSquareTestImpl implements UnknownDistributionChiSquareTest {
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 class ChiSquareTestImpl implements UnknownDistributionChiSquareTest {
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 @@ public class ChiSquareTestImpl implements UnknownDistributionChiSquareTest {
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 @@ public class ChiSquareTestImpl implements UnknownDistributionChiSquareTest {
* @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;
}
/**

15
src/java/org/apache/commons/math/stat/inference/OneWayAnovaImpl.java
View File

@ -19,6 +19,7 @@ package org.apache.commons.math.stat.inference;
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 class OneWayAnovaImpl implements OneWayAnova {
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 @@ public class OneWayAnovaImpl implements OneWayAnova {
// 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);
}
}

141
src/java/org/apache/commons/math/stat/inference/TTestImpl.java
View File

@ -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 class TTestImpl implements TTest {
*/
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 class TTestImpl implements TTest {
*/
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 class TTestImpl implements TTest {
*/
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 class TTestImpl implements TTest {
*/
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 class TTestImpl implements TTest {
*/
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 class TTestImpl implements TTest {
*/
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 @@ public class TTestImpl implements TTest {
* @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 class TTestImpl implements TTest {
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 class TTestImpl implements TTest {
*/
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 class TTestImpl implements TTest {
*/
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 class TTestImpl implements TTest {
*/
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 class TTestImpl implements TTest {
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 class TTestImpl implements TTest {
*/
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 class TTestImpl implements TTest {
*/
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 class TTestImpl implements TTest {
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 class TTestImpl implements TTest {
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 class TTestImpl implements TTest {
*/
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 @@ public class TTestImpl implements TTest {
* @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 class TTestImpl implements TTest {
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 class TTestImpl implements TTest {
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());
}
}
}

26
src/java/org/apache/commons/math/stat/regression/AbstractMultipleLinearRegression.java
View File

@ -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 @@ public abstract class AbstractMultipleLinearRegression implements
* 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 @@ public abstract class AbstractMultipleLinearRegression implements
* 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);
}
}

18
src/java/org/apache/commons/math/stat/regression/OLSMultipleLinearRegression.java
View File

@ -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 @@ public class OLSMultipleLinearRegression extends AbstractMultipleLinearRegressio
*/
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 @@ public class OLSMultipleLinearRegression extends AbstractMultipleLinearRegressio
}
/**
* <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 @@ public class OLSMultipleLinearRegression extends AbstractMultipleLinearRegressio
* @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;
}
}

4
src/java/org/apache/commons/math/stat/regression/SimpleRegression.java
View File

@ -548,8 +548,8 @@ public class SimpleRegression implements Serializable {
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);

3
src/site/xdoc/changes.xml
View File

@ -39,6 +39,9 @@ The <action> type attribute can be add,update,fix,remove.
</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>