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

Eliminated tabs and trailing spaces. Formatting only. 

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/math/branches/MATH_2_X@1054186 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Phil Steitz 2011-01-01 02:28:46 +00:00
parent 593ae5e9e5
commit c1af4d2094
29 changed files with 259 additions and 259 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/main/java/org/apache/commons/math/analysis/solvers/UnivariateRealSolver.java
View File

@ -98,7 +98,7 @@ public interface UnivariateRealSolver extends ConvergingAlgorithm {
*/
double solve(int maxEval, UnivariateRealFunction f, double min, double max)
throws ConvergenceException, MathUserException;
/**
* Solve for a zero root in the given interval.
* <p>A solver may require that the interval brackets a single zero root.

2
src/main/java/org/apache/commons/math/distribution/AbstractContinuousDistribution.java
View File

@ -234,7 +234,7 @@ public abstract class AbstractContinuousDistribution
* @return lower bound of the support (might be Double.NEGATIVE_INFINITY)
*/
public abstract double getSupportLowerBound();
/**
* Access the upper bound of the support.
*

64
src/main/java/org/apache/commons/math/distribution/AbstractDistribution.java
View File

@ -35,10 +35,10 @@ public abstract class AbstractDistribution
private double numericalMean = Double.NaN;
private boolean numericalMeanIsCalculated = false;
private double numericalVariance = Double.NaN;
private boolean numericalVarianceIsCalculated = false;
/**
* Default constructor.
*/
@ -72,12 +72,12 @@ public abstract class AbstractDistribution
}
return cumulativeProbability(x1) - cumulativeProbability(x0);
}
/**
* This method invalidates cached moments when parameters change.
* Usually it is called from a sub-class when the distribution
* gets its parameters updated.
*
*
* @deprecated as of 2.2 (sub-classes will become immutable in 3.0)
*/
@Deprecated
@ -85,18 +85,18 @@ public abstract class AbstractDistribution
numericalMeanIsCalculated = false;
numericalVarianceIsCalculated = false;
}
/**
* Use this method to actually calculate the mean for the
* specific distribution. Use {@link #getNumericalMean()}
* Use this method to actually calculate the mean for the
* specific distribution. Use {@link #getNumericalMean()}
* (which implements caching) to actually get the mean.
*
*
* @return the mean or Double.NaN if it's not defined
*/
protected abstract double calculateNumericalMean();
/**
* Use this method to get the numerical value of the mean of this
* Use this method to get the numerical value of the mean of this
* distribution.
*
* @return the mean or Double.NaN if it's not defined
@ -109,22 +109,22 @@ public abstract class AbstractDistribution
return numericalMean;
}
/**
* Use this method to actually calculate the variance for the
* specific distribution. Use {@link #getNumericalVariance()}
* (which implements caching) to actually get the variance.
* Use this method to actually calculate the variance for the
* specific distribution. Use {@link #getNumericalVariance()}
* (which implements caching) to actually get the variance.
*
* @return the variance or Double.NaN if it's not defined
*/
protected abstract double calculateNumericalVariance();
/**
* Use this method to get the numerical value of the variance of this
* Use this method to get the numerical value of the variance of this
* distribution.
*
* @return the variance (possibly Double.POSITIVE_INFINITY as
* for certain cases in {@link TDistributionImpl}) or
* @return the variance (possibly Double.POSITIVE_INFINITY as
* for certain cases in {@link TDistributionImpl}) or
* Double.NaN if it's not defined
*/
public double getNumericalVariance() {
@ -132,40 +132,40 @@ public abstract class AbstractDistribution
numericalVariance = calculateNumericalVariance();
numericalVarianceIsCalculated = true;
}
return numericalVariance;
}
}
/**
* Use this method to get information about whether the lower bound
* Use this method to get information about whether the lower bound
* of the support is inclusive or not.
*
* @return whether the lower bound of the support is inclusive or not
*/
public abstract boolean isSupportLowerBoundInclusive();
/**
* Use this method to get information about whether the upper bound
* Use this method to get information about whether the upper bound
* of the support is inclusive or not.
*
* @return whether the upper bound of the support is inclusive or not
*/
public abstract boolean isSupportUpperBoundInclusive();
public abstract boolean isSupportUpperBoundInclusive();
/**
* Use this method to get information about whether the support is connected,
* Use this method to get information about whether the support is connected,
* i.e. whether all values between the lower and upper bound of the support
* is included in the support.
*
*
* For {@link AbstractIntegerDistribution} the support is discrete, so
* if this is true, then the support is
* if this is true, then the support is
* {lower bound, lower bound + 1, ..., upper bound}.
*
*
* For {@link AbstractContinuousDistribution} the support is continuous, so
* if this is true, then the support is the interval
* [lower bound, upper bound]
* where the limits are inclusive or not according to
* {@link #isSupportLowerBoundInclusive()} and {@link #isSupportUpperBoundInclusive()}
* where the limits are inclusive or not according to
* {@link #isSupportLowerBoundInclusive()} and {@link #isSupportUpperBoundInclusive()}
* (in the example both are true). If both are false, then the support is the interval
* (lower bound, upper bound)
*

18
src/main/java/org/apache/commons/math/distribution/AbstractIntegerDistribution.java
View File

@ -291,42 +291,42 @@ public abstract class AbstractIntegerDistribution extends AbstractDistribution
* P(X &lt; <i>upper bound</i>) &gt; <code>p</code>
*/
protected abstract int getDomainUpperBound(double p);
/**
* Access the lower bound of the support.
*
* @return lower bound of the support (Integer.MIN_VALUE for negative infinity)
*/
public abstract int getSupportLowerBound();
/**
* Access the upper bound of the support.
*
* @return upper bound of the support (Integer.MAX_VALUE for positive infinity)
*/
public abstract int getSupportUpperBound();
/**
* Use this method to get information about whether the lower bound
* Use this method to get information about whether the lower bound
* of the support is inclusive or not. For discrete support,
* only true here is meaningful.
*
* @return true (always but at Integer.MIN_VALUE because of the nature of discrete support)
* @return true (always but at Integer.MIN_VALUE because of the nature of discrete support)
*/
@Override
public boolean isSupportLowerBoundInclusive() {
return true;
}
/**
* Use this method to get information about whether the upper bound
* Use this method to get information about whether the upper bound
* of the support is inclusive or not. For discrete support,
* only true here is meaningful.
*
* @return true (always but at Integer.MAX_VALUE because of the nature of discrete support)
* @return true (always but at Integer.MAX_VALUE because of the nature of discrete support)
*/
@Override
public boolean isSupportUpperBoundInclusive() {
return true;
}
}
}

16
src/main/java/org/apache/commons/math/distribution/BetaDistributionImpl.java
View File

@ -228,7 +228,7 @@ public class BetaDistributionImpl
/**
* {@inheritDoc}
*
*
* The lower bound of the support is always 0 no matter the parameters.
*
* @return lower bound of the support (always 0)
@ -240,7 +240,7 @@ public class BetaDistributionImpl
/**
* {@inheritDoc}
*
*
* The upper bound of the support is always 1 no matter the parameters.
*
* @return upper bound of the support (always 1)
@ -252,8 +252,8 @@ public class BetaDistributionImpl
/**
* {@inheritDoc}
*
* For first shape parameter <code>s1</code> and
*
* For first shape parameter <code>s1</code> and
* second shape parameter <code>s2</code>, the mean is
* <code>s1 / (s1 + s2)</code>
*
@ -267,9 +267,9 @@ public class BetaDistributionImpl
/**
* {@inheritDoc}
*
* For first shape parameter <code>s1</code> and
* second shape parameter <code>s2</code>,
*
* For first shape parameter <code>s1</code> and
* second shape parameter <code>s2</code>,
* the variance is
* <code>[ s1 * s2 ] / [ (s1 + s2)^2 * (s1 + s2 + 1) ]</code>
*
@ -278,7 +278,7 @@ public class BetaDistributionImpl
@Override
protected double calculateNumericalVariance() {
final double alpha = getAlpha();
final double beta = getBeta();
final double beta = getBeta();
final double alphabetasum = alpha + beta;
return (alpha * beta) / ((alphabetasum * alphabetasum) * (alphabetasum + 1));
}

20
src/main/java/org/apache/commons/math/distribution/BinomialDistributionImpl.java
View File

@ -85,7 +85,7 @@ public class BinomialDistributionImpl extends AbstractIntegerDistribution
setNumberOfTrialsInternal(trials);
invalidateParameterDependentMoments();
}
/**
* Change the number of trials for this distribution.
*
@ -114,7 +114,7 @@ public class BinomialDistributionImpl extends AbstractIntegerDistribution
setProbabilityOfSuccessInternal(p);
invalidateParameterDependentMoments();
}
/**
* Change the probability of success for this distribution.
*
@ -227,8 +227,8 @@ public class BinomialDistributionImpl extends AbstractIntegerDistribution
/**
* {@inheritDoc}
*
* The lower bound of the support is always 0 no matter the number of trials
*
* The lower bound of the support is always 0 no matter the number of trials
* and probability parameter.
*
* @return lower bound of the support (always 0)
@ -237,10 +237,10 @@ public class BinomialDistributionImpl extends AbstractIntegerDistribution
public int getSupportLowerBound() {
return 0;
}
/**
* {@inheritDoc}
*
*
* The upper bound of the support is the number of trials.
*
* @return upper bound of the support (equal to number of trials)
@ -252,8 +252,8 @@ public class BinomialDistributionImpl extends AbstractIntegerDistribution
/**
* {@inheritDoc}
*
* For <code>n</code> number of trials and
*
* For <code>n</code> number of trials and
* probability parameter <code>p</code>, the mean is
* <code>n * p</code>
*
@ -266,8 +266,8 @@ public class BinomialDistributionImpl extends AbstractIntegerDistribution
/**
* {@inheritDoc}
*
* For <code>n</code> number of trials and
*
* For <code>n</code> number of trials and
* probability parameter <code>p</code>, the variance is
* <code>n * p * (1 - p)</code>
*

16
src/main/java/org/apache/commons/math/distribution/CauchyDistributionImpl.java
View File

@ -159,7 +159,7 @@ public class CauchyDistributionImpl extends AbstractContinuousDistribution
setMedianInternal(median);
invalidateParameterDependentMoments();
}
/**
* Modify the median.
* @param newMedian for this distribution
@ -179,7 +179,7 @@ public class CauchyDistributionImpl extends AbstractContinuousDistribution
setScaleInternal(s);
invalidateParameterDependentMoments();
}
/**
* Modify the scale parameter.
* @param s scale parameter for this distribution
@ -274,8 +274,8 @@ public class CauchyDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
* The lower bound of the support is always negative infinity no matter
*
* The lower bound of the support is always negative infinity no matter
* the parameters.
*
* @return lower bound of the support (always Double.NEGATIVE_INFINITY)
@ -287,8 +287,8 @@ public class CauchyDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
* The upper bound of the support is always positive infinity no matter
*
* The upper bound of the support is always positive infinity no matter
* the parameters.
*
* @return upper bound of the support (always Double.POSITIVE_INFINITY)
@ -300,7 +300,7 @@ public class CauchyDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
*
* The mean is always undefined no matter the parameters.
*
* @return mean (always Double.NaN)
@ -312,7 +312,7 @@ public class CauchyDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
*
* The variance is always undefined no matter the parameters.
*
* @return variance (always Double.NaN)

12
src/main/java/org/apache/commons/math/distribution/ChiSquaredDistributionImpl.java
View File

@ -273,8 +273,8 @@ public class ChiSquaredDistributionImpl
/**
* {@inheritDoc}
*
* The lower bound of the support is always 0 no matter the
*
* The lower bound of the support is always 0 no matter the
* degrees of freedom.
*
* @return lower bound of the support (always 0)
@ -286,8 +286,8 @@ public class ChiSquaredDistributionImpl
/**
* {@inheritDoc}
*
* The upper bound of the support is always positive infinity no matter the
*
* The upper bound of the support is always positive infinity no matter the
* degrees of freedom.
*
* @return upper bound of the support (always Double.POSITIVE_INFINITY)
@ -299,7 +299,7 @@ public class ChiSquaredDistributionImpl
/**
* {@inheritDoc}
*
*
* For <code>k</code> degrees of freedom, the mean is
* <code>k</code>
*
@ -312,7 +312,7 @@ public class ChiSquaredDistributionImpl
/**
* {@inheritDoc}
*
*
* For <code>k</code> degrees of freedom, the variance is
* <code>2 * k</code>
*

38
src/main/java/org/apache/commons/math/distribution/Distribution.java
View File

@ -52,55 +52,55 @@ public interface Distribution {
* @throws IllegalArgumentException if <code>x0 > x1</code>
*/
double cumulativeProbability(double x0, double x1) throws MathException;
/**
* Use this method to get the numerical value of the mean of this
* Use this method to get the numerical value of the mean of this
* distribution.
*
* @return the mean or Double.NaN if it's not defined
*/
double getNumericalMean();
/**
* Use this method to get the numerical value of the variance of this
* Use this method to get the numerical value of the variance of this
* distribution.
*
* @return the variance (possibly Double.POSITIVE_INFINITY as
* for certain cases in {@link TDistributionImpl}) or
* @return the variance (possibly Double.POSITIVE_INFINITY as
* for certain cases in {@link TDistributionImpl}) or
* Double.NaN if it's not defined
*/
double getNumericalVariance();
double getNumericalVariance();
/**
* Use this method to get information about whether the lower bound
* Use this method to get information about whether the lower bound
* of the support is inclusive or not.
*
* @return whether the lower bound of the support is inclusive or not
*/
boolean isSupportLowerBoundInclusive();
/**
* Use this method to get information about whether the upper bound
* Use this method to get information about whether the upper bound
* of the support is inclusive or not.
*
* @return whether the upper bound of the support is inclusive or not
*/
boolean isSupportUpperBoundInclusive();
boolean isSupportUpperBoundInclusive();
/**
* Use this method to get information about whether the support is connected,
* Use this method to get information about whether the support is connected,
* i.e. whether all values between the lower and upper bound of the support
* is included in the support.
*
*
* For {@link AbstractIntegerDistribution} the support is discrete, so
* if this is true, then the support is
* if this is true, then the support is
* {lower bound, lower bound + 1, ..., upper bound}.
*
*
* For {@link AbstractContinuousDistribution} the support is continuous, so
* if this is true, then the support is the interval
* [lower bound, upper bound]
* where the limits are inclusive or not according to
* {@link #isSupportLowerBoundInclusive()} and {@link #isSupportUpperBoundInclusive()}
* where the limits are inclusive or not according to
* {@link #isSupportLowerBoundInclusive()} and {@link #isSupportUpperBoundInclusive()}
* (in the example both are true). If both are false, then the support is the interval
* (lower bound, upper bound)
*

10
src/main/java/org/apache/commons/math/distribution/ExponentialDistributionImpl.java
View File

@ -267,7 +267,7 @@ public class ExponentialDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
*
* The lower bound of the support is always 0 no matter the mean parameter.
*
* @return lower bound of the support (always 0)
@ -279,8 +279,8 @@ public class ExponentialDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
* The upper bound of the support is always positive infinity
*
* The upper bound of the support is always positive infinity
* no matter the mean parameter.
*
* @return upper bound of the support (always Double.POSITIVE_INFINITY)
@ -292,7 +292,7 @@ public class ExponentialDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
*
* For mean parameter <code>k</code>, the mean is
* <code>k</code>
*
@ -305,7 +305,7 @@ public class ExponentialDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
*
* For mean parameter <code>k</code>, the variance is
* <code>k^2</code>
*

34
src/main/java/org/apache/commons/math/distribution/FDistributionImpl.java
View File

@ -280,10 +280,10 @@ public class FDistributionImpl
protected double getSolverAbsoluteAccuracy() {
return solverAbsoluteAccuracy;
}
/**
* {@inheritDoc}
*
*
* The lower bound of the support is always 0 no matter the parameters.
*
* @return lower bound of the support (always 0)
@ -295,8 +295,8 @@ public class FDistributionImpl
/**
* {@inheritDoc}
*
* The upper bound of the support is always positive infinity
*
* The upper bound of the support is always positive infinity
* no matter the parameters.
*
* @return upper bound of the support (always Double.POSITIVE_INFINITY)
@ -308,8 +308,8 @@ public class FDistributionImpl
/**
* {@inheritDoc}
*
* For denominator degrees of freedom parameter <code>b</code>,
*
* For denominator degrees of freedom parameter <code>b</code>,
* the mean is
* <ul>
* <li>if <code>b &gt; 2</code> then <code>b / (b - 2)</code></li>
@ -317,27 +317,27 @@ public class FDistributionImpl
* </ul>
*
* @return {@inheritDoc}
*/
*/
@Override
protected double calculateNumericalMean() {
protected double calculateNumericalMean() {
final double denominatorDF = getDenominatorDegreesOfFreedom();
if (denominatorDF > 2) {
return denominatorDF / (denominatorDF - 2);
return denominatorDF / (denominatorDF - 2);
}
return Double.NaN;
}
/**
* {@inheritDoc}
*
* For numerator degrees of freedom parameter <code>a</code>
* and denominator degrees of freedom parameter <code>b</code>,
*
* For numerator degrees of freedom parameter <code>a</code>
* and denominator degrees of freedom parameter <code>b</code>,
* the variance is
* <ul>
* <li>
* if <code>b &gt; 4</code> then
* if <code>b &gt; 4</code> then
* <code>[ 2 * b^2 * (a + b - 2) ] / [ a * (b - 2)^2 * (b - 4) ]</code>
* </li>
* <li>else <code>undefined</code>
@ -352,12 +352,12 @@ public class FDistributionImpl
if (denominatorDF > 4) {
final double numeratorDF = getNumeratorDegreesOfFreedom();
final double denomDFMinusTwo = denominatorDF - 2;
return ( 2 * (denominatorDF * denominatorDF) * (numeratorDF + denominatorDF - 2) )
/ ( (numeratorDF * (denomDFMinusTwo * denomDFMinusTwo) * (denominatorDF - 4)) );
}
return Double.NaN;
return Double.NaN;
}
@Override

16
src/main/java/org/apache/commons/math/distribution/GammaDistributionImpl.java
View File

@ -303,7 +303,7 @@ public class GammaDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
*
* The lower bound of the support is always 0 no matter the parameters.
*
* @return lower bound of the support (always 0)
@ -315,8 +315,8 @@ public class GammaDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
* The upper bound of the support is always positive infinity
*
* The upper bound of the support is always positive infinity
* no matter the parameters.
*
* @return upper bound of the support (always Double.POSITIVE_INFINITY)
@ -328,8 +328,8 @@ public class GammaDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
* For shape parameter <code>alpha</code> and scale
*
* For shape parameter <code>alpha</code> and scale
* parameter <code>beta</code>, the mean is
* <code>alpha * beta</code>
*
@ -342,8 +342,8 @@ public class GammaDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
* For shape parameter <code>alpha</code> and scale
*
* For shape parameter <code>alpha</code> and scale
* parameter <code>beta</code>, the variance is
* <code>alpha * beta^2</code>
*
@ -351,7 +351,7 @@ public class GammaDistributionImpl extends AbstractContinuousDistribution
*/
@Override
protected double calculateNumericalVariance() {
final double beta = getBeta();
final double beta = getBeta();
return getAlpha() * beta * beta;
}

32
src/main/java/org/apache/commons/math/distribution/HypergeometricDistributionImpl.java
View File

@ -243,7 +243,7 @@ public class HypergeometricDistributionImpl extends AbstractIntegerDistribution
setNumberOfSuccessesInternal(num);
invalidateParameterDependentMoments();
}
/**
* Modify the number of successes.
*
@ -270,7 +270,7 @@ public class HypergeometricDistributionImpl extends AbstractIntegerDistribution
setPopulationSizeInternal(size);
invalidateParameterDependentMoments();
}
/**
* Modify the population size.
*
@ -359,10 +359,10 @@ public class HypergeometricDistributionImpl extends AbstractIntegerDistribution
/**
* {@inheritDoc}
*
* For population size <code>N</code>,
* number of successes <code>m</code>, and
* sample size <code>n</code>,
*
* For population size <code>N</code>,
* number of successes <code>m</code>, and
* sample size <code>n</code>,
* the lower bound of the support is
* <code>max(0, n + m - N)</code>
*
@ -370,15 +370,15 @@ public class HypergeometricDistributionImpl extends AbstractIntegerDistribution
*/
@Override
public int getSupportLowerBound() {
return FastMath.max(0,
return FastMath.max(0,
getSampleSize() + getNumberOfSuccesses() - getPopulationSize());
}
/**
* {@inheritDoc}
*
* For number of successes <code>m</code> and
* sample size <code>n</code>,
*
* For number of successes <code>m</code> and
* sample size <code>n</code>,
* the upper bound of the support is
* <code>min(m, n)</code>
*
@ -391,9 +391,9 @@ public class HypergeometricDistributionImpl extends AbstractIntegerDistribution
/**
* {@inheritDoc}
*
* For population size <code>N</code>,
* number of successes <code>m</code>, and
*
* For population size <code>N</code>,
* number of successes <code>m</code>, and
* sample size <code>n</code>, the mean is
* <code>n * m / N</code>
*
@ -406,9 +406,9 @@ public class HypergeometricDistributionImpl extends AbstractIntegerDistribution
/**
* {@inheritDoc}
*
* For population size <code>N</code>,
* number of successes <code>m</code>, and
*
* For population size <code>N</code>,
* number of successes <code>m</code>, and
* sample size <code>n</code>, the variance is
* <code>[ n * m * (N - n) * (N - m) ] / [ N^2 * (N - 1) ]</code>
*

22
src/main/java/org/apache/commons/math/distribution/NormalDistributionImpl.java
View File

@ -106,7 +106,7 @@ public class NormalDistributionImpl extends AbstractContinuousDistribution
setMeanInternal(mean);
invalidateParameterDependentMoments();
}
/**
* Modify the mean.
* @param newMean for this distribution
@ -134,7 +134,7 @@ public class NormalDistributionImpl extends AbstractContinuousDistribution
setStandardDeviationInternal(sd);
invalidateParameterDependentMoments();
}
/**
* Modify the standard deviation.
* @param sd standard deviation for this distribution
@ -178,14 +178,14 @@ public class NormalDistributionImpl extends AbstractContinuousDistribution
* For this distribution, X, this method returns P(X &lt; <code>x</code>).
* If <code>x</code>is more than 40 standard deviations from the mean, 0 or 1 is returned,
* as in these cases the actual value is within <code>Double.MIN_VALUE</code> of 0 or 1.
*
*
* @param x the value at which the CDF is evaluated.
* @return CDF evaluated at <code>x</code>.
* @throws MathException if the algorithm fails to converge
*/
public double cumulativeProbability(double x) throws MathException {
final double dev = x - mean;
if (FastMath.abs(dev) > 40 * standardDeviation) {
if (FastMath.abs(dev) > 40 * standardDeviation) {
return dev < 0 ? 0.0d : 1.0d;
}
return 0.5 * (1.0 + Erf.erf((dev) /
@ -311,8 +311,8 @@ public class NormalDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
* The lower bound of the support is always negative infinity
*
* The lower bound of the support is always negative infinity
* no matter the parameters.
*
* @return lower bound of the support (always Double.NEGATIVE_INFINITY)
@ -324,8 +324,8 @@ public class NormalDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
* The upper bound of the support is always positive infinity
*
* The upper bound of the support is always positive infinity
* no matter the parameters.
*
* @return upper bound of the support (always Double.POSITIVE_INFINITY)
@ -337,7 +337,7 @@ public class NormalDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
*
* For mean parameter <code>mu</code>, the mean is <code>mu</code>
*
* @return {@inheritDoc}
@ -349,8 +349,8 @@ public class NormalDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
* For standard deviation parameter <code>s</code>,
*
* For standard deviation parameter <code>s</code>,
* the variance is <code>s^2</code>
*
* @return {@inheritDoc}

24
src/main/java/org/apache/commons/math/distribution/PascalDistributionImpl.java
View File

@ -82,7 +82,7 @@ public class PascalDistributionImpl extends AbstractIntegerDistribution
setNumberOfSuccessesInternal(successes);
invalidateParameterDependentMoments();
}
/**
* Change the number of successes for this distribution.
* @param successes the new number of successes
@ -110,7 +110,7 @@ public class PascalDistributionImpl extends AbstractIntegerDistribution
setProbabilityOfSuccessInternal(p);
invalidateParameterDependentMoments();
}
/**
* Change the probability of success for this distribution.
* @param p the new probability of success
@ -218,7 +218,7 @@ public class PascalDistributionImpl extends AbstractIntegerDistribution
/**
* {@inheritDoc}
*
*
* The lower bound of the support is always 0 no matter the parameters.
*
* @return lower bound of the support (always 0)
@ -230,10 +230,10 @@ public class PascalDistributionImpl extends AbstractIntegerDistribution
/**
* {@inheritDoc}
*
* The upper bound of the support is always positive infinity
* no matter the parameters. Positive infinity is symbolised
* by <code>Integer.MAX_VALUE</code> together with
*
* The upper bound of the support is always positive infinity
* no matter the parameters. Positive infinity is symbolised
* by <code>Integer.MAX_VALUE</code> together with
* {@link #isSupportUpperBoundInclusive()} being <code>false</code>
*
* @return upper bound of the support (always <code>Integer.MAX_VALUE</code> for positive infinity)
@ -245,8 +245,8 @@ public class PascalDistributionImpl extends AbstractIntegerDistribution
/**
* {@inheritDoc}
*
* For number of successes <code>r</code> and
*
* For number of successes <code>r</code> and
* probability of success <code>p</code>, the mean is
* <code>( r * p ) / ( 1 - p )</code>
*
@ -261,8 +261,8 @@ public class PascalDistributionImpl extends AbstractIntegerDistribution
/**
* {@inheritDoc}
*
* For number of successes <code>r</code> and
*
* For number of successes <code>r</code> and
* probability of success <code>p</code>, the mean is
* <code>( r * p ) / ( 1 - p )^2</code>
*
@ -275,7 +275,7 @@ public class PascalDistributionImpl extends AbstractIntegerDistribution
final double pInv = 1 - p;
return ( r * p ) / (pInv * pInv);
}
@Override
public boolean isSupportUpperBoundInclusive() {
return false;

14
src/main/java/org/apache/commons/math/distribution/PoissonDistributionImpl.java
View File

@ -304,7 +304,7 @@ public class PoissonDistributionImpl extends AbstractIntegerDistribution
/**
* {@inheritDoc}
*
*
* The lower bound of the support is always 0 no matter the mean parameter.
*
* @return lower bound of the support (always 0)
@ -316,9 +316,9 @@ public class PoissonDistributionImpl extends AbstractIntegerDistribution
/**
* {@inheritDoc}
*
* The upper bound of the support is positive infinity,
* regardless of the parameter values. There is no integer infinity,
*
* The upper bound of the support is positive infinity,
* regardless of the parameter values. There is no integer infinity,
* so this method returns <code>Integer.MAX_VALUE</code> and
* {@link #isSupportUpperBoundInclusive()} returns <code>true</code>.
*
@ -331,7 +331,7 @@ public class PoissonDistributionImpl extends AbstractIntegerDistribution
/**
* {@inheritDoc}
*
*
* For mean parameter <code>p</code>, the mean is <code>p</code>
*
* @return {@inheritDoc}
@ -343,7 +343,7 @@ public class PoissonDistributionImpl extends AbstractIntegerDistribution
/**
* {@inheritDoc}
*
*
* For mean parameter <code>p</code>, the variance is <code>p</code>
*
* @return {@inheritDoc}
@ -352,7 +352,7 @@ public class PoissonDistributionImpl extends AbstractIntegerDistribution
protected double calculateNumericalVariance() {
return getMean();
}
@Override
public boolean isSupportUpperBoundInclusive() {
return true;

24
src/main/java/org/apache/commons/math/distribution/TDistributionImpl.java
View File

@ -83,7 +83,7 @@ public class TDistributionImpl
setDegreesOfFreedomInternal(degreesOfFreedom);
invalidateParameterDependentMoments();
}
/**
* Modify the degrees of freedom.
* @param newDegreesOfFreedom the new degrees of freedom.
@ -228,8 +228,8 @@ public class TDistributionImpl
/**
* {@inheritDoc}
*
* The lower bound of the support is always negative infinity
*
* The lower bound of the support is always negative infinity
* no matter the parameters.
*
* @return lower bound of the support (always Double.NEGATIVE_INFINITY)
@ -241,8 +241,8 @@ public class TDistributionImpl
/**
* {@inheritDoc}
*
* The upper bound of the support is always positive infinity
*
* The upper bound of the support is always positive infinity
* no matter the parameters.
*
* @return upper bound of the support (always Double.POSITIVE_INFINITY)
@ -254,7 +254,7 @@ public class TDistributionImpl
/**
* {@inheritDoc}
*
*
* For degrees of freedom parameter df, the mean is
* <ul>
* <li>if <code>df &gt; 1</code> then <code>0</code></li>
@ -266,17 +266,17 @@ public class TDistributionImpl
@Override
protected double calculateNumericalMean() {
final double df = getDegreesOfFreedom();
if (df > 1) {
return 0;
}
return Double.NaN;
return Double.NaN;
}
/**
* {@inheritDoc}
*
*
* For degrees of freedom parameter df, the variance is
* <ul>
* <li>if <code>df &gt; 2</code> then <code>df / (df - 2)</code> </li>
@ -288,7 +288,7 @@ public class TDistributionImpl
*/
@Override
protected double calculateNumericalVariance() {
final double df = getDegreesOfFreedom();
final double df = getDegreesOfFreedom();
if (df > 2) {
return df / (df - 2);
@ -297,7 +297,7 @@ public class TDistributionImpl
if (df > 1 && df <= 2) {
return Double.POSITIVE_INFINITY;
}
return Double.NaN;
}

16
src/main/java/org/apache/commons/math/distribution/WeibullDistributionImpl.java
View File

@ -265,7 +265,7 @@ public class WeibullDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
*
* The lower bound of the support is always 0 no matter the parameters.
*
* @return lower bound of the support (always 0)
@ -277,8 +277,8 @@ public class WeibullDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
* The upper bound of the support is always positive infinity
*
* The upper bound of the support is always positive infinity
* no matter the parameters.
*
* @return upper bound of the support (always Double.POSITIVE_INFINITY)
@ -290,7 +290,7 @@ public class WeibullDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
*
* The mean is <code>scale * Gamma(1 + (1 / shape))</code>
* where <code>Gamma(...)</code> is the Gamma-function
*
@ -306,9 +306,9 @@ public class WeibullDistributionImpl extends AbstractContinuousDistribution
/**
* {@inheritDoc}
*
* The variance is
* <code>scale^2 * Gamma(1 + (2 / shape)) - mean^2</code>
*
* The variance is
* <code>scale^2 * Gamma(1 + (2 / shape)) - mean^2</code>
* where <code>Gamma(...)</code> is the Gamma-function
*
* @return {@inheritDoc}
@ -319,7 +319,7 @@ public class WeibullDistributionImpl extends AbstractContinuousDistribution
final double scale = getScale();
final double mean = getNumericalMean();
return (scale * scale) *
return (scale * scale) *
FastMath.exp(Gamma.logGamma(1 + (2 / shape))) -
(mean * mean);
}

26
src/main/java/org/apache/commons/math/distribution/ZipfDistributionImpl.java
View File

@ -118,7 +118,7 @@ public class ZipfDistributionImpl extends AbstractIntegerDistribution
setExponentInternal(s);
invalidateParameterDependentMoments();
}
/**
* Set the exponent characterising the distribution.
* The parameter value must be positive; otherwise an
@ -216,19 +216,19 @@ public class ZipfDistributionImpl extends AbstractIntegerDistribution
/**
* {@inheritDoc}
*
*
* The lower bound of the support is always 1 no matter the parameters.
*
* @return lower bound of the support (always 1)
*/
@Override
public int getSupportLowerBound() {
public int getSupportLowerBound() {
return 1;
}
/**
* {@inheritDoc}
*
*
* The upper bound of the support is the number of elements
*
* @return upper bound of the support
@ -240,11 +240,11 @@ public class ZipfDistributionImpl extends AbstractIntegerDistribution
/**
* {@inheritDoc}
*
*
* For number of elements N and exponent s, the mean is
* <code>Hs1 / Hs</code> where
* <code>Hs1 / Hs</code> where
* <ul>
* <li><code>Hs1 = generalizedHarmonic(N, s - 1)</code></li>
* <li><code>Hs1 = generalizedHarmonic(N, s - 1)</code></li>
* <li><code>Hs = generalizedHarmonic(N, s)</code></li>
* </ul>
*
@ -254,7 +254,7 @@ public class ZipfDistributionImpl extends AbstractIntegerDistribution
protected double calculateNumericalMean() {
final int N = getNumberOfElements();
final double s = getExponent();
final double Hs1 = generalizedHarmonic(N, s - 1);
final double Hs = generalizedHarmonic(N, s);
@ -263,22 +263,22 @@ public class ZipfDistributionImpl extends AbstractIntegerDistribution
/**
* {@inheritDoc}
*
*
* For number of elements N and exponent s, the mean is
* <code>(Hs2 / Hs) - (Hs1^2 / Hs^2)</code> where
* <code>(Hs2 / Hs) - (Hs1^2 / Hs^2)</code> where
* <ul>
* <li><code>Hs2 = generalizedHarmonic(N, s - 2)</code></li>
* <li><code>Hs1 = generalizedHarmonic(N, s - 1)</code></li>
* <li><code>Hs1 = generalizedHarmonic(N, s - 1)</code></li>
* <li><code>Hs = generalizedHarmonic(N, s)</code></li>
* </ul>
*
*
* @return {@inheritDoc}
*/
@Override
protected double calculateNumericalVariance() {
final int N = getNumberOfElements();
final double s = getExponent();
final double Hs2 = generalizedHarmonic(N, s - 2);
final double Hs1 = generalizedHarmonic(N, s - 1);
final double Hs = generalizedHarmonic(N, s);

2
src/main/java/org/apache/commons/math/optimization/direct/PowellOptimizer.java
View File

@ -285,7 +285,7 @@ public class PowellOptimizer
/**
* Java 1.5 does not support Arrays.copyOf()
*
*
* @param source the array to be copied
* @param newLen the length of the copy to be returned
* @return the copied array, truncated or padded as necessary.

2
src/main/java/org/apache/commons/math/random/package.html
View File

@ -91,7 +91,7 @@
The WELL generators use 6 integer arrays with a size equal to the pool size, so for example the
WELL44497b generator uses about 33 kilobytes. This may be important if a very large number of
generator instances were used at the same time.
</p>
</p>
<p>
All generators are quite fast. As an example, here are some comparisons, obtained on a 64 bits JVM on a

8
src/main/java/org/apache/commons/math/special/Erf.java
View File

@ -41,7 +41,7 @@ public class Erf {
* <p>This implementation computes erf(x) using the
* {@link Gamma#regularizedGammaP(double, double, double, int) regularized gamma function},
* following <a href="http://mathworld.wolfram.com/Erf.html"> Erf</a>, equation (3)</p>
*
*
* <p>The value returned is always between -1 and 1 (inclusive). If {@code abs(x) > 40}, then
* {@code erf(x)} is indistinguishable from either 1 or -1 as a double, so the appropriate extreme
* value is returned.</p>
@ -61,7 +61,7 @@ public class Erf {
}
return ret;
}
/**
* <p>Returns the complementary error function</p>
* <p>erfc(x) = 2/&radic;&pi; <sub>x</sub>&int;<sup>&infin;</sup> e<sup>-t<sup>2</sup></sup>dt <br/>
@ -70,11 +70,11 @@ public class Erf {
* <p>This implementation computes erfc(x) using the
* {@link Gamma#regularizedGammaQ(double, double, double, int) regularized gamma function},
* following <a href="http://mathworld.wolfram.com/Erf.html"> Erf</a>, equation (3).</p>
*
*
* <p>The value returned is always between 0 and 2 (inclusive). If {@code abs(x) > 40}, then
* {@code erf(x)} is indistinguishable from either 0 or 2 as a double, so the appropriate extreme
* value is returned.</p>
*
*
* @param x the value
* @return the complementary error function erfc(x)
* @throws MathException if the algorithm fails to converge

6
src/main/java/org/apache/commons/math/stat/Frequency.java
View File

@ -287,12 +287,12 @@ public class Frequency implements Serializable {
public long getCount(char v) {
return getCount(Character.valueOf(v));
}
/**
* Returns the number of values in the frequency table.
*
*
* @return the number of unique values that have been added to the frequency table.
* @see #valuesIterator()
* @see #valuesIterator()
*/
public int getUniqueCount(){
return freqTable.keySet().size();

48
src/main/java/org/apache/commons/math/stat/StatUtils.java
View File

@ -629,34 +629,34 @@ public final class StatUtils {
}
return (sum1 - (sum2 * sum2 / n)) / (n - 1);
}
/**
* Normalize (standardize) the series, so in the end it is having a mean of 0 and a standard deviation of 1.
*
/**
* Normalize (standardize) the series, so in the end it is having a mean of 0 and a standard deviation of 1.
*
* @param sample sample to normalize
* @return normalized (standardized) sample
*/
public static double[] normalize(final double[] sample) {
DescriptiveStatistics stats = new DescriptiveStatistics();
* @return normalized (standardized) sample
*/
public static double[] normalize(final double[] sample) {
DescriptiveStatistics stats = new DescriptiveStatistics();
// Add the data from the series to stats
for (int i = 0; i < sample.length; i++) {
stats.addValue(sample[i]);
}
// Add the data from the series to stats
for (int i = 0; i < sample.length; i++) {
stats.addValue(sample[i]);
}
// Compute mean and standard deviation
double mean = stats.getMean();
double standardDeviation = stats.getStandardDeviation();
// Compute mean and standard deviation
double mean = stats.getMean();
double standardDeviation = stats.getStandardDeviation();
// initialize the standardizedSample, which has the same length as the sample
double[] standardizedSample = new double[sample.length];
// initialize the standardizedSample, which has the same length as the sample
double[] standardizedSample = new double[sample.length];
for (int i = 0; i < sample.length; i++) {
// z = (x- mean)/standardDeviation
standardizedSample[i] = (sample[i] - mean) / standardDeviation;
}
return standardizedSample;
}
for (int i = 0; i < sample.length; i++) {
// z = (x- mean)/standardDeviation
standardizedSample[i] = (sample[i] - mean) / standardDeviation;
}
return standardizedSample;
}
}

6
src/main/java/org/apache/commons/math/stat/descriptive/DescriptiveStatistics.java
View File

@ -126,7 +126,7 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
/**
* Construct a DescriptiveStatistics instance with an infinite window
* and the initial data values in double[] initialDoubleArray.
* If initialDoubleArray is null, then this constructor corresponds to
* If initialDoubleArray is null, then this constructor corresponds to
* DescriptiveStatistics()
*
* @param initialDoubleArray the initial double[].
@ -134,9 +134,9 @@ public class DescriptiveStatistics implements StatisticalSummary, Serializable {
public DescriptiveStatistics(double[] initialDoubleArray) {
if (initialDoubleArray != null) {
eDA = new ResizableDoubleArray(initialDoubleArray);
}
}
}
/**
* Copy constructor. Construct a new DescriptiveStatistics instance that
* is a copy of original.

2
src/main/java/org/apache/commons/math/stat/descriptive/StatisticalSummaryValues.java
View File

@ -160,7 +160,7 @@ public class StatisticalSummaryValues implements Serializable,
result = result * 31 + MathUtils.hash(getVariance());
return result;
}
/**
* Generates a text report displaying values of statistics.
* Each statistic is displayed on a separate line.

24
src/main/java/org/apache/commons/math/util/FastMath.java
View File

@ -156,9 +156,9 @@ public class FastMath {
/* Table of 2^((n+2)/3) */
private static final double CBRTTWO[] = { 0.6299605249474366,
0.7937005259840998,
1.0,
1.2599210498948732,
0.7937005259840998,
1.0,
1.2599210498948732,
1.5874010519681994 };
// Initialize tables
@ -494,7 +494,7 @@ public class FastMath {
result = ratioa + ratiob;
}
if (negate) {
result = -result;
}
@ -893,10 +893,10 @@ public class FastMath {
yb = -rb;
}
if (hiPrecOut != null) {
hiPrecOut[0] = ya;
hiPrecOut[1] = yb;
}
if (hiPrecOut != null) {
hiPrecOut[0] = ya;
hiPrecOut[1] = yb;
}
return ya + yb;
}
@ -3143,12 +3143,12 @@ public class FastMath {
int exp3 = exponent / 3;
/* p2 will be the nearest power of 2 to x with its exponent divided by 3 */
double p2 = Double.longBitsToDouble((inbits & 0x8000000000000000L) |
double p2 = Double.longBitsToDouble((inbits & 0x8000000000000000L) |
(long)(((exp3 + 1023) & 0x7ff)) << 52);
/* This will be a number between 1 and 2 */
final double mant = Double.longBitsToDouble((inbits & 0x000fffffffffffffL) | 0x3ff0000000000000L);
/* Estimate the cube root of mant by polynomial */
double est = -0.010714690733195933;
est = est * mant + 0.0875862700108075;
@ -3158,10 +3158,10 @@ public class FastMath {
est *= CBRTTWO[exponent % 3 + 2];
// est should now be good to about 15 bits of precision. Do 2 rounds of
// est should now be good to about 15 bits of precision. Do 2 rounds of
// Newton's method to get closer, this should get us full double precision
// Scale down x for the purpose of doing newtons method. This avoids over/under flows.
final double xs = x / (p2*p2*p2);
final double xs = x / (p2*p2*p2);
est += (xs - est*est*est) / (3*est*est);
est += (xs - est*est*est) / (3*est*est);

2
src/main/java/org/apache/commons/math/util/MultidimensionalCounter.java
View File

@ -302,7 +302,7 @@ public class MultidimensionalCounter implements Iterable<Integer> {
/**
* Java 1.5 does not support Arrays.copyOf()
*
*
* @param source the array to be copied
* @param newLen the length of the copy to be returned
* @return the copied array, truncated or padded as necessary.

12
src/main/java/org/apache/commons/math/util/ResizableDoubleArray.java
View File

@ -161,10 +161,10 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
}
/**
* Create a ResizableArray from an existing double[] with the
* initial capacity and numElements corresponding to the size of
* the supplied double[] array. If the supplied array is null, a
* new empty array with the default initial capacity will be created.
* Create a ResizableArray from an existing double[] with the
* initial capacity and numElements corresponding to the size of
* the supplied double[] array. If the supplied array is null, a
* new empty array with the default initial capacity will be created.
* Other properties take default values:
* <ul>
* <li><code>initialCapacity = 16</code></li>
@ -182,7 +182,7 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
numElements = initialArray.length;
}
}
/**
* <p>
* Create a ResizableArray with the specified initial capacity
@ -297,7 +297,7 @@ public class ResizableDoubleArray implements DoubleArray, Serializable {
contract();
}
}
/**
* Adds several element to the end of this expandable array.
*