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

fixed checkstyle warnings 

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/math/branches/MATH_2_0@705239 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Luc Maisonobe 2008-10-16 13:32:32 +00:00
parent 0e77ce68b3
commit 223168ee50
11 changed files with 42 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/java/org/apache/commons/math/distribution/BetaDistribution.java
View File

@ -21,7 +21,9 @@ import org.apache.commons.math.MathException;
/**
* Computes the cumulative, inverse cumulative and density functions for the beta distribuiton.
*
* See http://en.wikipedia.org/wiki/Beta_distribution
* @see <a href="http://en.wikipedia.org/wiki/Beta_distribution">Beta_distribution</a>
* @version $Revision$ $Date$
* @since 2.0
*/
public interface BetaDistribution extends ContinuousDistribution, HasDensity<Double> {
/**
@ -52,6 +54,7 @@ public interface BetaDistribution extends ContinuousDistribution, HasDensity<Dou
* Return the probability density for a particular point.
* @param x The point at which the density should be computed.
* @return The pdf at point x.
* @exception MathException if probability density cannot be computed
*/
double density(Double x) throws MathException;

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

@ -29,6 +29,8 @@ import org.apache.commons.math.special.Beta;
* Beta distribution</a></li>
* </ul>
* </p>
* @version $Revision$ $Date$
* @since 2.0
*/
public class BetaDistributionImpl
extends AbstractContinuousDistribution implements BetaDistribution {
@ -58,40 +60,24 @@ public class BetaDistributionImpl
z = Double.NaN;
}
/**
* Modify the shape parameter, alpha.
*
* @param alpha the new shape parameter.
*/
/** {@inheritDoc} */
public void setAlpha(double alpha) {
this.alpha = alpha;
z = Double.NaN;
}
/**
* Access the shape parameter, alpha
*
* @return alpha.
*/
/** {@inheritDoc} */
public double getAlpha() {
return alpha;
}
/**
* Modify the shape parameter, beta.
*
* @param beta the new scale parameter.
*/
/** {@inheritDoc} */
public void setBeta(double beta) {
this.beta = beta;
z = Double.NaN;
}
/**
* Access the shape parameter, beta
*
* @return beta.
*/
/** {@inheritDoc} */
public double getBeta() {
return beta;
}
@ -105,12 +91,7 @@ public class BetaDistributionImpl
}
}
/**
* Return the probability density for a particular point.
*
* @param x The point at which the density should be computed.
* @return The pdf at point x.
*/
/** {@inheritDoc} */
public double density(Double x) throws MathException {
recomputeZ();
if (x < 0 || x > 1) {
@ -132,15 +113,7 @@ public class BetaDistributionImpl
}
}
/**
* For this distribution, X, this method returns x such that P(X &lt; x) = p.
*
* @param p the cumulative probability.
* @return x.
* @throws org.apache.commons.math.MathException
* if the inverse cumulative probability can not be
* computed due to convergence or other numerical errors.
*/
/** {@inheritDoc} */
public double inverseCumulativeProbability(double p) throws MathException {
if (p == 0) {
return 0;
@ -151,57 +124,22 @@ public class BetaDistributionImpl
}
}
/**
* Access the initial domain value, based on <code>p</code>, used to
* bracket a CDF root. This method is used by
* {@link #inverseCumulativeProbability(double)} to find critical values.
*
* @param p the desired probability for the critical value
* @return initial domain value
*/
/** {@inheritDoc} */
protected double getInitialDomain(double p) {
return p;
}
/**
* Access the domain value lower bound, based on <code>p</code>, used to
* bracket a CDF root. This method is used by
* {@link #inverseCumulativeProbability(double)} to find critical values.
*
* @param p the desired probability for the critical value
* @return domain value lower bound, i.e.
* P(X &lt; <i>lower bound</i>) &lt; <code>p</code>
*/
/** {@inheritDoc} */
protected double getDomainLowerBound(double p) {
return 0;
}
/**
* Access the domain value upper bound, based on <code>p</code>, used to
* bracket a CDF root. This method is used by
* {@link #inverseCumulativeProbability(double)} to find critical values.
*
* @param p the desired probability for the critical value
* @return domain value upper bound, i.e.
* P(X &lt; <i>upper bound</i>) &gt; <code>p</code>
*/
/** {@inheritDoc} */
protected double getDomainUpperBound(double p) {
return 1;
}
/**
* For a random variable X whose values are distributed according
* to this distribution, this method returns P(X &le; x). In other words,
* this method represents the (cumulative) distribution function, or
* CDF, for this distribution.
*
* @param x the value at which the distribution function is evaluated.
* @return the probability that a random variable with this
* distribution takes a value less than or equal to <code>x</code>
* @throws org.apache.commons.math.MathException
* if the cumulative probability can not be
* computed due to convergence or other numerical errors.
*/
/** {@inheritDoc} */
public double cumulativeProbability(double x) throws MathException {
if (x <= 0) {
return 0;
@ -212,20 +150,7 @@ public class BetaDistributionImpl
}
}
/**
* For a random variable X whose values are distributed according
* to this distribution, this method returns P(x0 &le; X &le; x1).
*
* @param x0 the (inclusive) lower bound
* @param x1 the (inclusive) upper bound
* @return the probability that a random variable with this distribution
* will take a value between <code>x0</code> and <code>x1</code>,
* including the endpoints
* @throws org.apache.commons.math.MathException
* if the cumulative probability can not be
* computed due to convergence or other numerical errors.
* @throws IllegalArgumentException if <code>x0 > x1</code>
*/
/** {@inheritDoc} */
public double cumulativeProbability(double x0, double x1) throws MathException {
return cumulativeProbability(x1) - cumulativeProbability(x0);
}

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

@ -22,6 +22,8 @@ import org.apache.commons.math.MathException;
/**
* Interface that signals that a distribution can compute the probability density function
* for a particular point.
* @param <P> the type of the point at which density is to be computed, this
* may be for example <code>Double</code>
* @version $Revision$ $Date$
*/
public interface HasDensity<P> {

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

@ -35,12 +35,14 @@ public class NormalDistributionImpl extends AbstractContinuousDistribution
/** Serializable version identifier */
private static final long serialVersionUID = 8589540077390120676L;
/** &sqrt;(2 &pi;) */
private static final double SQRT2PI = Math.sqrt(2 * Math.PI);
/** The mean of this distribution. */
private double mean = 0;
/** The standard deviation of this distribution. */
private double standardDeviation = 1;
private static final double SQRT2PI = Math.sqrt(2 * Math.PI);
/**
* Create a normal distribution using the given mean and standard deviation.

2
src/java/org/apache/commons/math/linear/DecompositionSolver.java
View File

@ -40,7 +40,7 @@ public interface DecompositionSolver extends Serializable {
/**
* Decompose a matrix.
* @param matrix
* @param matrix matrix to decompose
* @exception InvalidMatrixException if matrix does not fulfill
* the decomposition requirements (for example non-square matrix
* for {@link LUDecomposition})

2
src/java/org/apache/commons/math/linear/EigenDecomposition.java
View File

@ -93,6 +93,7 @@ public interface EigenDecomposition extends DecompositionSolver {
/**
* Returns the i<sup>th</sup> eigenvalue of the original matrix.
* @param i index of the eigenvalue (counting from 0)
* @return i<sup>th</sup> eigenvalue of the original matrix
* @exception IllegalStateException if {@link
* DecompositionSolver#decompose(RealMatrix) decompose} has not been called
@ -103,6 +104,7 @@ public interface EigenDecomposition extends DecompositionSolver {
/**
* Returns a copy of the i<sup>th</sup> eigenvector of the original matrix.
* @param i index of the eigenvector (counting from 0)
* @return copy of the i<sup>th</sup> eigenvector of the original matrix
* @exception IllegalStateException if {@link
* DecompositionSolver#decompose(RealMatrix) decompose} has not been called

7
src/java/org/apache/commons/math/linear/GershgorinCirclesUnion.java
View File

@ -75,13 +75,18 @@ class GershgorinCirclesUnion implements Comparable<GershgorinCirclesUnion> {
* either circles union. It is mainly intended for circles unions
* that {@link #intersects(GershgorinCirclesUnion) intersect}
* each other beforehand.</p>
* @param other Gershgorin circles union to swallow
*/
public void swallow(final GershgorinCirclesUnion other) {
low = Math.min(low, other.low);
high = Math.max(high, other.high);
}
/** Comparator class for sorting intervals. */
/** Compare another Gershgorin circles union in interval start order.
* @param other Gershgorin circles union to compare to instance
* @return a negative, zero or positive value depending on the other
* union starting before, at same location or after instance
*/
public int compareTo(GershgorinCirclesUnion other) {
return Double.compare(low, other.low);
}

6
src/java/org/apache/commons/math/linear/LUDecompositionImpl.java
View File

@ -348,8 +348,10 @@ public class LUDecompositionImpl implements LUDecomposition {
* <p>The A matrix is implicit here. It is </p>
* @param b right-hand side of the equation A &times; X = B
* @return a vector X such that A &times; X = B
* @throws IllegalArgumentException if matrices dimensions don't match
* @throws InvalidMatrixException if decomposed matrix is singular
* @exception IllegalStateException if {@link #decompose(RealMatrix) decompose}
* has not been called
* @exception IllegalArgumentException if matrices dimensions don't match
* @exception InvalidMatrixException if decomposed matrix is singular
*/
public RealVectorImpl solve(RealVectorImpl b)
throws IllegalStateException, IllegalArgumentException, InvalidMatrixException {

2
src/java/org/apache/commons/math/linear/SingularValueDecomposition.java
View File

@ -56,7 +56,7 @@ public interface SingularValueDecomposition extends DecompositionSolver {
/**
* Decompose a matrix to find its largest singular values.
* @param matrix
* @param matrix matrix to decompose
* @param maxSingularValues maximal number of singular values to compute
* @exception InvalidMatrixException (wrapping a {@link ConvergenceException}
* if algorithm fails to converge

5
src/java/org/apache/commons/math/stat/regression/GLSMultipleLinearRegression.java
View File

@ -48,6 +48,11 @@ public class GLSMultipleLinearRegression extends AbstractMultipleLinearRegressio
/** Inverse of covariance matrix. */
private RealMatrix OmegaInverse;
/** Replace sample data, overriding any previous sample.
* @param y y values of the sample
* @param x x values of the sample
* @param covariance array representing the covariance matrix
*/
public void newSampleData(double[] y, double[][] x, double[][] covariance) {
validateSampleData(x, y);
newYSampleData(y);

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

@ -58,7 +58,7 @@ public class OLSMultipleLinearRegression extends AbstractMultipleLinearRegressio
/** Cached QR decomposition of X matrix */
private QRDecomposition qr = null;
/*
/**
* {@inheritDoc}
*
* Computes and caches QR decomposition of the X matrix.