You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by lu...@apache.org on 2013/03/29 08:25:18 UTC
svn commit: r1462423 - in
/commons/proper/math/trunk/src/main/java/org/apache/commons/math3:
analysis/differentiation/ dfp/ distribution/ linear/ random/
stat/inference/ util/
Author: luc
Date: Fri Mar 29 07:25:18 2013
New Revision: 1462423
URL: http://svn.apache.org/r1462423
Log:
Added missing @since 3.2.
Modified:
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/analysis/differentiation/DerivativeStructure.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/dfp/Dfp.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/distribution/NormalDistribution.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/linear/ArrayFieldVector.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/linear/QRDecomposition.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/random/RandomDataGenerator.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/stat/inference/OneWayAnova.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Decimal64.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MathArrays.java
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/analysis/differentiation/DerivativeStructure.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/analysis/differentiation/DerivativeStructure.java?rev=1462423&r1=1462422&r2=1462423&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math3/analysis/differentiation/DerivativeStructure.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math3/analysis/differentiation/DerivativeStructure.java Fri Mar 29 07:25:18 2013
@@ -232,7 +232,9 @@ public class DerivativeStructure impleme
return compiler.getOrder();
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public double getReal() {
return data[0];
}
@@ -268,7 +270,9 @@ public class DerivativeStructure impleme
return data.clone();
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure add(final double a) {
final DerivativeStructure ds = new DerivativeStructure(this);
ds.data[0] += a;
@@ -287,7 +291,9 @@ public class DerivativeStructure impleme
return ds;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure subtract(final double a) {
return add(-a);
}
@@ -309,7 +315,9 @@ public class DerivativeStructure impleme
return multiply((double) n);
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure multiply(final double a) {
final DerivativeStructure ds = new DerivativeStructure(this);
for (int i = 0; i < ds.data.length; ++i) {
@@ -330,7 +338,9 @@ public class DerivativeStructure impleme
return result;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure divide(final double a) {
final DerivativeStructure ds = new DerivativeStructure(this);
for (int i = 0; i < ds.data.length; ++i) {
@@ -361,6 +371,7 @@ public class DerivativeStructure impleme
/** {@inheritDoc}
* @exception DimensionMismatchException if number of free parameters
* or orders do not match
+ * @since 3.2
*/
public DerivativeStructure remainder(final DerivativeStructure a)
throws DimensionMismatchException {
@@ -379,7 +390,9 @@ public class DerivativeStructure impleme
return ds;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure abs() {
if (Double.doubleToLongBits(data[0]) < 0) {
// we use the bits representation to also handle -0.0
@@ -389,21 +402,27 @@ public class DerivativeStructure impleme
}
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure ceil() {
return new DerivativeStructure(compiler.getFreeParameters(),
compiler.getOrder(),
FastMath.ceil(data[0]));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure floor() {
return new DerivativeStructure(compiler.getFreeParameters(),
compiler.getOrder(),
FastMath.floor(data[0]));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure rint() {
return new DerivativeStructure(compiler.getFreeParameters(),
compiler.getOrder(),
@@ -415,14 +434,18 @@ public class DerivativeStructure impleme
return FastMath.round(data[0]);
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure signum() {
return new DerivativeStructure(compiler.getFreeParameters(),
compiler.getOrder(),
FastMath.signum(data[0]));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure copySign(final DerivativeStructure sign){
long m = Double.doubleToLongBits(data[0]);
long s = Double.doubleToLongBits(sign.data[0]);
@@ -432,7 +455,9 @@ public class DerivativeStructure impleme
return negate(); // flip sign
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure copySign(final double sign) {
long m = Double.doubleToLongBits(data[0]);
long s = Double.doubleToLongBits(sign);
@@ -454,7 +479,9 @@ public class DerivativeStructure impleme
return FastMath.getExponent(data[0]);
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure scalb(final int n) {
final DerivativeStructure ds = new DerivativeStructure(compiler);
for (int i = 0; i < ds.data.length; ++i) {
@@ -466,6 +493,7 @@ public class DerivativeStructure impleme
/** {@inheritDoc}
* @exception DimensionMismatchException if number of free parameters
* or orders do not match
+ * @since 3.2
*/
public DerivativeStructure hypot(final DerivativeStructure y)
throws DimensionMismatchException {
@@ -526,6 +554,7 @@ public class DerivativeStructure impleme
* @return sqrt(<i>x</i><sup>2</sup> +<i>y</i><sup>2</sup>)
* @exception DimensionMismatchException if number of free parameters
* or orders do not match
+ * @since 3.2
*/
public static DerivativeStructure hypot(final DerivativeStructure x, final DerivativeStructure y)
throws DimensionMismatchException {
@@ -557,17 +586,23 @@ public class DerivativeStructure impleme
return result;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure sqrt() {
return rootN(2);
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure cbrt() {
return rootN(3);
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure rootN(final int n) {
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.rootN(data, 0, n, result.data, 0);
@@ -596,14 +631,18 @@ public class DerivativeStructure impleme
};
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure pow(final double p) {
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.pow(data, 0, p, result.data, 0);
return result;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure pow(final int n) {
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.pow(data, 0, n, result.data, 0);
@@ -613,6 +652,7 @@ public class DerivativeStructure impleme
/** {@inheritDoc}
* @exception DimensionMismatchException if number of free parameters
* or orders do not match
+ * @since 3.2
*/
public DerivativeStructure pow(final DerivativeStructure e)
throws DimensionMismatchException {
@@ -622,28 +662,36 @@ public class DerivativeStructure impleme
return result;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure exp() {
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.exp(data, 0, result.data, 0);
return result;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure expm1() {
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.expm1(data, 0, result.data, 0);
return result;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure log() {
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.log(data, 0, result.data, 0);
return result;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure log1p() {
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.log1p(data, 0, result.data, 0);
@@ -659,49 +707,63 @@ public class DerivativeStructure impleme
return result;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure cos() {
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.cos(data, 0, result.data, 0);
return result;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure sin() {
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.sin(data, 0, result.data, 0);
return result;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure tan() {
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.tan(data, 0, result.data, 0);
return result;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure acos() {
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.acos(data, 0, result.data, 0);
return result;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure asin() {
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.asin(data, 0, result.data, 0);
return result;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure atan() {
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.atan(data, 0, result.data, 0);
return result;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure atan2(final DerivativeStructure x)
throws DimensionMismatchException {
compiler.checkCompatibility(x.compiler);
@@ -716,48 +778,61 @@ public class DerivativeStructure impleme
* @return atan2(y, x)
* @exception DimensionMismatchException if number of free parameters
* or orders do not match
+ * @since 3.2
*/
public static DerivativeStructure atan2(final DerivativeStructure y, final DerivativeStructure x)
throws DimensionMismatchException {
return y.atan2(x);
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure cosh() {
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.cosh(data, 0, result.data, 0);
return result;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure sinh() {
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.sinh(data, 0, result.data, 0);
return result;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure tanh() {
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.tanh(data, 0, result.data, 0);
return result;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure acosh() {
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.acosh(data, 0, result.data, 0);
return result;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure asinh() {
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.asinh(data, 0, result.data, 0);
return result;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public DerivativeStructure atanh() {
final DerivativeStructure result = new DerivativeStructure(compiler);
compiler.atanh(data, 0, result.data, 0);
@@ -798,6 +873,7 @@ public class DerivativeStructure impleme
/** {@inheritDoc}
* @exception DimensionMismatchException if number of free parameters
* or orders do not match
+ * @since 3.2
*/
public DerivativeStructure linearCombination(final DerivativeStructure[] a, final DerivativeStructure[] b)
throws DimensionMismatchException {
@@ -829,6 +905,7 @@ public class DerivativeStructure impleme
/** {@inheritDoc}
* @exception DimensionMismatchException if number of free parameters
* or orders do not match
+ * @since 3.2
*/
public DerivativeStructure linearCombination(final double[] a, final DerivativeStructure[] b)
throws DimensionMismatchException {
@@ -856,6 +933,7 @@ public class DerivativeStructure impleme
/** {@inheritDoc}
* @exception DimensionMismatchException if number of free parameters
* or orders do not match
+ * @since 3.2
*/
public DerivativeStructure linearCombination(final DerivativeStructure a1, final DerivativeStructure b1,
final DerivativeStructure a2, final DerivativeStructure b2)
@@ -878,6 +956,7 @@ public class DerivativeStructure impleme
/** {@inheritDoc}
* @exception DimensionMismatchException if number of free parameters
* or orders do not match
+ * @since 3.2
*/
public DerivativeStructure linearCombination(final double a1, final DerivativeStructure b1,
final double a2, final DerivativeStructure b2)
@@ -900,6 +979,7 @@ public class DerivativeStructure impleme
/** {@inheritDoc}
* @exception DimensionMismatchException if number of free parameters
* or orders do not match
+ * @since 3.2
*/
public DerivativeStructure linearCombination(final DerivativeStructure a1, final DerivativeStructure b1,
final DerivativeStructure a2, final DerivativeStructure b2,
@@ -924,6 +1004,7 @@ public class DerivativeStructure impleme
/** {@inheritDoc}
* @exception DimensionMismatchException if number of free parameters
* or orders do not match
+ * @since 3.2
*/
public DerivativeStructure linearCombination(final double a1, final DerivativeStructure b1,
final double a2, final DerivativeStructure b2,
@@ -948,6 +1029,7 @@ public class DerivativeStructure impleme
/** {@inheritDoc}
* @exception DimensionMismatchException if number of free parameters
* or orders do not match
+ * @since 3.2
*/
public DerivativeStructure linearCombination(final DerivativeStructure a1, final DerivativeStructure b1,
final DerivativeStructure a2, final DerivativeStructure b2,
@@ -974,6 +1056,7 @@ public class DerivativeStructure impleme
/** {@inheritDoc}
* @exception DimensionMismatchException if number of free parameters
* or orders do not match
+ * @since 3.2
*/
public DerivativeStructure linearCombination(final double a1, final DerivativeStructure b1,
final double a2, final DerivativeStructure b2,
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/dfp/Dfp.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/dfp/Dfp.java?rev=1462423&r1=1462422&r2=1462423&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math3/dfp/Dfp.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math3/dfp/Dfp.java Fri Mar 29 07:25:18 2013
@@ -860,6 +860,7 @@ public class Dfp implements RealFieldEle
/** Get the absolute value of instance.
* @return absolute value of instance
+ * @since 3.2
*/
public Dfp abs() {
Dfp result = newInstance(this);
@@ -1001,6 +1002,7 @@ public class Dfp implements RealFieldEle
* That is round to nearest integer unless both are equidistant.
* In which case round to the even one.
* @return rounded value
+ * @since 3.2
*/
public Dfp rint() {
return trunc(DfpField.RoundingMode.ROUND_HALF_EVEN);
@@ -1009,6 +1011,7 @@ public class Dfp implements RealFieldEle
/** Round to an integer using the round floor mode.
* That is, round toward -Infinity
* @return rounded value
+ * @since 3.2
*/
public Dfp floor() {
return trunc(DfpField.RoundingMode.ROUND_FLOOR);
@@ -1017,6 +1020,7 @@ public class Dfp implements RealFieldEle
/** Round to an integer using the round ceil mode.
* That is, round toward +Infinity
* @return rounded value
+ * @since 3.2
*/
public Dfp ceil() {
return trunc(DfpField.RoundingMode.ROUND_CEIL);
@@ -1025,6 +1029,7 @@ public class Dfp implements RealFieldEle
/** Returns the IEEE remainder.
* @param d divisor
* @return this less n × d, where n is the integer closest to this/d
+ * @since 3.2
*/
public Dfp remainder(final Dfp d) {
@@ -1179,6 +1184,7 @@ public class Dfp implements RealFieldEle
/** Get the exponent of the greatest power of 10 that is less than or equal to abs(this).
* @return integer base 10 logarithm
+ * @since 3.2
*/
public int intLog10() {
if (mant[mant.length-1] > 1000) {
@@ -1958,6 +1964,7 @@ public class Dfp implements RealFieldEle
/** Compute the square root.
* @return square root of the instance
+ * @since 3.2
*/
public Dfp sqrt() {
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/distribution/NormalDistribution.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/distribution/NormalDistribution.java?rev=1462423&r1=1462422&r2=1462423&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math3/distribution/NormalDistribution.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math3/distribution/NormalDistribution.java Fri Mar 29 07:25:18 2013
@@ -153,7 +153,9 @@ public class NormalDistribution extends
return 0.5 * (1 + Erf.erf(dev / (standardDeviation * SQRT2)));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
@Override
public double inverseCumulativeProbability(final double p) throws OutOfRangeException {
if (p < 0.0 || p > 1.0) {
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/linear/ArrayFieldVector.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/linear/ArrayFieldVector.java?rev=1462423&r1=1462422&r2=1462423&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math3/linear/ArrayFieldVector.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math3/linear/ArrayFieldVector.java Fri Mar 29 07:25:18 2013
@@ -322,6 +322,7 @@ public class ArrayFieldVector<T extends
* @param v2 Second vector (will be put at back of the new vector).
* @throws NullArgumentException if {@code v1} or {@code v2} is
* {@code null}.
+ * @since 3.2
*/
public ArrayFieldVector(FieldVector<T> v1, T[] v2)
throws NullArgumentException {
@@ -357,6 +358,7 @@ public class ArrayFieldVector<T extends
* @param v2 Second vector (will be put at back of the new vector).
* @throws NullArgumentException if {@code v1} or {@code v2} is
* {@code null}.
+ * @since 3.2
*/
public ArrayFieldVector(T[] v1, FieldVector<T> v2)
throws NullArgumentException {
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/linear/QRDecomposition.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/linear/QRDecomposition.java?rev=1462423&r1=1462422&r2=1462423&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math3/linear/QRDecomposition.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math3/linear/QRDecomposition.java Fri Mar 29 07:25:18 2013
@@ -106,6 +106,7 @@ public class QRDecomposition {
/** Decompose matrix.
* @param matrix transposed matrix
+ * @since 3.2
*/
protected void decompose(double[][] matrix) {
for (int minor = 0; minor < FastMath.min(qrt.length, qrt[0].length); minor++) {
@@ -116,6 +117,7 @@ public class QRDecomposition {
/** Perform Householder reflection for a minor A(minor, minor) of A.
* @param minor minor index
* @param matrix transposed matrix
+ * @since 3.2
*/
protected void performHouseholderReflection(int minor, double[][] matrix) {
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/random/RandomDataGenerator.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/random/RandomDataGenerator.java?rev=1462423&r1=1462422&r2=1462423&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math3/random/RandomDataGenerator.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math3/random/RandomDataGenerator.java Fri Mar 29 07:25:18 2013
@@ -822,6 +822,7 @@ public class RandomDataGenerator impleme
* </p>
*
* @return the Random used to generate random data
+ * @since 3.2
*/
public RandomGenerator getRandomGenerator() {
if (rand == null) {
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/stat/inference/OneWayAnova.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/stat/inference/OneWayAnova.java?rev=1462423&r1=1462422&r2=1462423&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math3/stat/inference/OneWayAnova.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math3/stat/inference/OneWayAnova.java Fri Mar 29 07:25:18 2013
@@ -160,6 +160,7 @@ public class OneWayAnova {
* at least two values
* @throws ConvergenceException if the p-value can not be computed due to a convergence error
* @throws MaxCountExceededException if the maximum number of iterations is exceeded
+ * @since 3.2
*/
public double anovaPValue(final Collection<SummaryStatistics> categoryData,
final boolean allowOneElementData)
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Decimal64.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Decimal64.java?rev=1462423&r1=1462422&r2=1462423&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Decimal64.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/Decimal64.java Fri Mar 29 07:25:18 2013
@@ -303,102 +303,142 @@ public class Decimal64 extends Number
return Double.isNaN(value);
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public double getReal() {
return value;
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 add(final double a) {
return new Decimal64(value + a);
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 subtract(final double a) {
return new Decimal64(value - a);
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 multiply(final double a) {
return new Decimal64(value * a);
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 divide(final double a) {
return new Decimal64(value / a);
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 remainder(final double a) {
return new Decimal64(FastMath.IEEEremainder(value, a));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 remainder(final Decimal64 a) {
return new Decimal64(FastMath.IEEEremainder(value, a.value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 abs() {
return new Decimal64(FastMath.abs(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 ceil() {
return new Decimal64(FastMath.ceil(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 floor() {
return new Decimal64(FastMath.floor(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 rint() {
return new Decimal64(FastMath.rint(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public long round() {
return FastMath.round(value);
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 signum() {
return new Decimal64(FastMath.signum(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 copySign(final Decimal64 sign) {
return new Decimal64(FastMath.copySign(value, sign.value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 copySign(final double sign) {
return new Decimal64(FastMath.copySign(value, sign));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 scalb(final int n) {
return new Decimal64(FastMath.scalb(value, n));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 hypot(final Decimal64 y) {
return new Decimal64(FastMath.hypot(value, y.value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 sqrt() {
return new Decimal64(FastMath.sqrt(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 cbrt() {
return new Decimal64(FastMath.cbrt(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 rootN(final int n) {
if (value < 0) {
return new Decimal64(-FastMath.pow(-value, 1.0 / n));
@@ -407,114 +447,157 @@ public class Decimal64 extends Number
}
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 pow(final double p) {
return new Decimal64(FastMath.pow(value, p));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 pow(final int n) {
return new Decimal64(FastMath.pow(value, n));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 pow(final Decimal64 e) {
return new Decimal64(FastMath.pow(value, e.value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 exp() {
return new Decimal64(FastMath.exp(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 expm1() {
return new Decimal64(FastMath.expm1(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 log() {
return new Decimal64(FastMath.log(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 log1p() {
return new Decimal64(FastMath.log1p(value));
}
/** Base 10 logarithm.
* @return base 10 logarithm of the instance
+ * @since 3.2
*/
public Decimal64 log10() {
return new Decimal64(FastMath.log10(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 cos() {
return new Decimal64(FastMath.cos(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 sin() {
return new Decimal64(FastMath.sin(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 tan() {
return new Decimal64(FastMath.tan(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 acos() {
return new Decimal64(FastMath.acos(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 asin() {
return new Decimal64(FastMath.asin(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 atan() {
return new Decimal64(FastMath.atan(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 atan2(final Decimal64 x) {
return new Decimal64(FastMath.atan2(value, x.value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 cosh() {
return new Decimal64(FastMath.cosh(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 sinh() {
return new Decimal64(FastMath.sinh(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 tanh() {
return new Decimal64(FastMath.tanh(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 acosh() {
return new Decimal64(FastMath.acosh(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 asinh() {
return new Decimal64(FastMath.asinh(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 atanh() {
return new Decimal64(FastMath.atanh(value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 linearCombination(final Decimal64[] a, final Decimal64[] b)
throws DimensionMismatchException {
if (a.length != b.length) {
@@ -529,7 +612,9 @@ public class Decimal64 extends Number
return new Decimal64(MathArrays.linearCombination(aDouble, bDouble));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 linearCombination(final double[] a, final Decimal64[] b)
throws DimensionMismatchException {
if (a.length != b.length) {
@@ -542,21 +627,27 @@ public class Decimal64 extends Number
return new Decimal64(MathArrays.linearCombination(a, bDouble));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 linearCombination(final Decimal64 a1, final Decimal64 b1,
final Decimal64 a2, final Decimal64 b2) {
return new Decimal64(MathArrays.linearCombination(a1.value, b1.value,
a2.value, b2.value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 linearCombination(final double a1, final Decimal64 b1,
final double a2, final Decimal64 b2) {
return new Decimal64(MathArrays.linearCombination(a1, b1.value,
a2, b2.value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 linearCombination(final Decimal64 a1, final Decimal64 b1,
final Decimal64 a2, final Decimal64 b2,
final Decimal64 a3, final Decimal64 b3) {
@@ -565,7 +656,9 @@ public class Decimal64 extends Number
a3.value, b3.value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 linearCombination(final double a1, final Decimal64 b1,
final double a2, final Decimal64 b2,
final double a3, final Decimal64 b3) {
@@ -574,7 +667,9 @@ public class Decimal64 extends Number
a3, b3.value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 linearCombination(final Decimal64 a1, final Decimal64 b1,
final Decimal64 a2, final Decimal64 b2,
final Decimal64 a3, final Decimal64 b3,
@@ -585,7 +680,9 @@ public class Decimal64 extends Number
a4.value, b4.value));
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
+ * @since 3.2
+ */
public Decimal64 linearCombination(final double a1, final Decimal64 b1,
final double a2, final Decimal64 b2,
final double a3, final Decimal64 b3,
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MathArrays.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MathArrays.java?rev=1462423&r1=1462422&r2=1462423&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MathArrays.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math3/util/MathArrays.java Fri Mar 29 07:25:18 2013
@@ -79,6 +79,7 @@ public class MathArrays {
* @param arr Array to scale.
* @param val Scalar.
* @return scaled copy of array with each entry multiplied by val.
+ * @since 3.2
*/
public static double[] scale(double val, final double[] arr) {
double[] newArr = new double[arr.length];
@@ -95,6 +96,7 @@ public class MathArrays {
*
* @param arr Array to scale
* @param val Scalar
+ * @since 3.2
*/
public static void scaleInPlace(double val, final double[] arr) {
for (int i = 0; i < arr.length; i++) {
@@ -1311,6 +1313,7 @@ public class MathArrays {
* @param field field to which array elements belong
* @param length of the array
* @return a new array
+ * @since 3.2
*/
public static <T> T[] buildArray(final Field<T> field, final int length) {
@SuppressWarnings("unchecked") // OK because field must be correct class
@@ -1326,9 +1329,10 @@ public class MathArrays {
* @param <T> the type of the field elements
* @param field field to which array elements belong
* @param rows number of rows in the array
- * @param columns number of columns (may be negative to build partial
- * arrays in the same way <code>new Field[rows][]</code> works)
+ * @param columns number of columns (may be negative to build partial
+ * arrays in the same way <code>new Field[rows][]</code> works)
* @return a new array
+ * @since 3.2
*/
@SuppressWarnings("unchecked")
public static <T> T[][] buildArray(final Field<T> field, final int rows, final int columns) {