+ * Classes implementing this interface will often be singletons. + *
+ * @param+ * The additive identity is the element e0 of the field such that + * for all elements a of the field, the equalities a + e0 = + * e0 + a = a hold. + *
+ * @return additive identity of the field + */ + T getZero(); + + /** Get the multiplicative identity of the field. + *+ * The multiplicative identity is the element e1 of the field such that + * for all elements a of the field, the equalities a × e1 = + * e1 × a = a hold. + *
+ * @return multiplicative identity of the field + */ + T getOne(); + + /** + * Returns the runtime class of the FieldElement. + * + * @return The {@code Class} object that represents the runtime + * class of this object. + */ + Class> getRuntimeClass(); + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/FieldElement.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/FieldElement.java new file mode 100644 index 000000000..f36405188 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/FieldElement.java @@ -0,0 +1,87 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3; + +import com.fr.third.org.apache.commons.math3.exception.MathArithmeticException; +import com.fr.third.org.apache.commons.math3.exception.NullArgumentException; + + +/** + * Interface representing field elements. + * @paramΣi ai bi.
+ * @throws DimensionMismatchException if arrays dimensions don't match
+ * @since 3.2
+ */
+ T linearCombination(T[] a, T[] b)
+ throws DimensionMismatchException;
+
+ /**
+ * Compute a linear combination.
+ * @param a Factors.
+ * @param b Factors.
+ * @return Σi ai bi.
+ * @throws DimensionMismatchException if arrays dimensions don't match
+ * @since 3.2
+ */
+ T linearCombination(double[] a, T[] b)
+ throws DimensionMismatchException;
+
+ /**
+ * Compute a linear combination.
+ * @param a1 first factor of the first term
+ * @param b1 second factor of the first term
+ * @param a2 first factor of the second term
+ * @param b2 second factor of the second term
+ * @return a1×b1 +
+ * a2×b2
+ * @see #linearCombination(Object, Object, Object, Object, Object, Object)
+ * @see #linearCombination(Object, Object, Object, Object, Object, Object, Object, Object)
+ * @since 3.2
+ */
+ T linearCombination(T a1, T b1, T a2, T b2);
+
+ /**
+ * Compute a linear combination.
+ * @param a1 first factor of the first term
+ * @param b1 second factor of the first term
+ * @param a2 first factor of the second term
+ * @param b2 second factor of the second term
+ * @return a1×b1 +
+ * a2×b2
+ * @see #linearCombination(double, Object, double, Object, double, Object)
+ * @see #linearCombination(double, Object, double, Object, double, Object, double, Object)
+ * @since 3.2
+ */
+ T linearCombination(double a1, T b1, double a2, T b2);
+
+ /**
+ * Compute a linear combination.
+ * @param a1 first factor of the first term
+ * @param b1 second factor of the first term
+ * @param a2 first factor of the second term
+ * @param b2 second factor of the second term
+ * @param a3 first factor of the third term
+ * @param b3 second factor of the third term
+ * @return a1×b1 +
+ * a2×b2 + a3×b3
+ * @see #linearCombination(Object, Object, Object, Object)
+ * @see #linearCombination(Object, Object, Object, Object, Object, Object, Object, Object)
+ * @since 3.2
+ */
+ T linearCombination(T a1, T b1, T a2, T b2, T a3, T b3);
+
+ /**
+ * Compute a linear combination.
+ * @param a1 first factor of the first term
+ * @param b1 second factor of the first term
+ * @param a2 first factor of the second term
+ * @param b2 second factor of the second term
+ * @param a3 first factor of the third term
+ * @param b3 second factor of the third term
+ * @return a1×b1 +
+ * a2×b2 + a3×b3
+ * @see #linearCombination(double, Object, double, Object)
+ * @see #linearCombination(double, Object, double, Object, double, Object, double, Object)
+ * @since 3.2
+ */
+ T linearCombination(double a1, T b1, double a2, T b2, double a3, T b3);
+
+ /**
+ * Compute a linear combination.
+ * @param a1 first factor of the first term
+ * @param b1 second factor of the first term
+ * @param a2 first factor of the second term
+ * @param b2 second factor of the second term
+ * @param a3 first factor of the third term
+ * @param b3 second factor of the third term
+ * @param a4 first factor of the third term
+ * @param b4 second factor of the third term
+ * @return a1×b1 +
+ * a2×b2 + a3×b3 +
+ * a4×b4
+ * @see #linearCombination(Object, Object, Object, Object)
+ * @see #linearCombination(Object, Object, Object, Object, Object, Object)
+ * @since 3.2
+ */
+ T linearCombination(T a1, T b1, T a2, T b2, T a3, T b3, T a4, T b4);
+
+ /**
+ * Compute a linear combination.
+ * @param a1 first factor of the first term
+ * @param b1 second factor of the first term
+ * @param a2 first factor of the second term
+ * @param b2 second factor of the second term
+ * @param a3 first factor of the third term
+ * @param b3 second factor of the third term
+ * @param a4 first factor of the third term
+ * @param b4 second factor of the third term
+ * @return a1×b1 +
+ * a2×b2 + a3×b3 +
+ * a4×b4
+ * @see #linearCombination(double, Object, double, Object)
+ * @see #linearCombination(double, Object, double, Object, double, Object)
+ * @since 3.2
+ */
+ T linearCombination(double a1, T b1, double a2, T b2, double a3, T b3, double a4, T b4);
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/BivariateFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/BivariateFunction.java
new file mode 100644
index 000000000..47429aeba
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/BivariateFunction.java
@@ -0,0 +1,35 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.fr.third.org.apache.commons.math3.analysis;
+
+/**
+ * An interface representing a bivariate real function.
+ *
+ * @since 2.1
+ */
+public interface BivariateFunction {
+ /**
+ * Compute the value for the function.
+ *
+ * @param x Abscissa for which the function value should be computed.
+ * @param y Ordinate for which the function value should be computed.
+ * @return the value.
+ */
+ double value(double x, double y);
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/DifferentiableMultivariateFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/DifferentiableMultivariateFunction.java
new file mode 100644
index 000000000..48dd824e4
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/DifferentiableMultivariateFunction.java
@@ -0,0 +1,54 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.fr.third.org.apache.commons.math3.analysis;
+
+import com.fr.third.org.apache.commons.math3.analysis.differentiation.MultivariateDifferentiableFunction;
+
+/**
+ * Extension of {@link MultivariateFunction} representing a differentiable
+ * multivariate real function.
+ * @since 2.0
+ * @deprecated as of 3.1 replaced by {@link MultivariateDifferentiableFunction}
+ */
+@Deprecated
+public interface DifferentiableMultivariateFunction extends MultivariateFunction {
+
+ /**
+ * Returns the partial derivative of the function with respect to a point coordinate.
+ * + * The partial derivative is defined with respect to point coordinate + * xk. If the partial derivatives with respect to all coordinates are + * needed, it may be more efficient to use the {@link #gradient()} method which will + * compute them all at once. + *
+ * @param k index of the coordinate with respect to which the partial + * derivative is computed + * @return the partial derivative function with respect to kth point coordinate + */ + MultivariateFunction partialDerivative(int k); + + /** + * Returns the gradient function. + *If only one partial derivative with respect to a specific coordinate is + * needed, it may be more efficient to use the {@link #partialDerivative(int)} method + * which will compute only the specified component.
+ * @return the gradient function + */ + MultivariateVectorFunction gradient(); + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/DifferentiableMultivariateVectorFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/DifferentiableMultivariateVectorFunction.java new file mode 100644 index 000000000..0f70a5b55 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/DifferentiableMultivariateVectorFunction.java @@ -0,0 +1,38 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.MultivariateDifferentiableVectorFunction; + +/** + * Extension of {@link MultivariateVectorFunction} representing a differentiable + * multivariate vectorial function. + * @since 2.0 + * @deprecated as of 3.1 replaced by {@link MultivariateDifferentiableVectorFunction} + */ +@Deprecated +public interface DifferentiableMultivariateVectorFunction + extends MultivariateVectorFunction { + + /** + * Returns the jacobian function. + * @return the jacobian function + */ + MultivariateMatrixFunction jacobian(); + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/DifferentiableUnivariateFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/DifferentiableUnivariateFunction.java new file mode 100644 index 000000000..1e4127e19 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/DifferentiableUnivariateFunction.java @@ -0,0 +1,37 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction; + +/** + * Extension of {@link UnivariateFunction} representing a differentiable univariate real function. + * + * @deprecated as of 3.1 replaced by {@link UnivariateDifferentiableFunction} + */ +@Deprecated +public interface DifferentiableUnivariateFunction + extends UnivariateFunction { + + /** + * Returns the derivative of the function + * + * @return the derivative function + */ + UnivariateFunction derivative(); + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/DifferentiableUnivariateMatrixFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/DifferentiableUnivariateMatrixFunction.java new file mode 100644 index 000000000..58b7b62d8 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/DifferentiableUnivariateMatrixFunction.java @@ -0,0 +1,38 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableMatrixFunction; + +/** + * Extension of {@link UnivariateMatrixFunction} representing a differentiable univariate matrix function. + * + * @since 2.0 + * @deprecated as of 3.1 replaced by {@link UnivariateDifferentiableMatrixFunction} + */ +@Deprecated +public interface DifferentiableUnivariateMatrixFunction + extends UnivariateMatrixFunction { + + /** + * Returns the derivative of the function + * + * @return the derivative function + */ + UnivariateMatrixFunction derivative(); + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/DifferentiableUnivariateVectorFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/DifferentiableUnivariateVectorFunction.java new file mode 100644 index 000000000..1b1bd0dda --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/DifferentiableUnivariateVectorFunction.java @@ -0,0 +1,38 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableVectorFunction; + +/** + * Extension of {@link UnivariateVectorFunction} representing a differentiable univariate vectorial function. + * + * @since 2.0 + * @deprecated as of 3.1 replaced by {@link UnivariateDifferentiableVectorFunction} + */ +@Deprecated +public interface DifferentiableUnivariateVectorFunction + extends UnivariateVectorFunction { + + /** + * Returns the derivative of the function + * + * @return the derivative function + */ + UnivariateVectorFunction derivative(); + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/FunctionUtils.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/FunctionUtils.java new file mode 100644 index 000000000..a5e474f35 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/FunctionUtils.java @@ -0,0 +1,806 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure; +import com.fr.third.org.apache.commons.math3.analysis.differentiation.MultivariateDifferentiableFunction; +import com.fr.third.org.apache.commons.math3.analysis.differentiation.MultivariateDifferentiableVectorFunction; +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction; +import com.fr.third.org.apache.commons.math3.analysis.function.Identity; +import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException; +import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException; +import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException; +import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats; + +/** + * Utilities for manipulating function objects. + * + * @since 3.0 + */ +public class FunctionUtils { + /** + * Class only contains static methods. + */ + private FunctionUtils() {} + + /** + * Composes functions. + *+ * The functions in the argument list are composed sequentially, in the + * given order. For example, compose(f1,f2,f3) acts like f1(f2(f3(x))).
+ * + * @param f List of functions. + * @return the composite function. + */ + public static UnivariateFunction compose(final UnivariateFunction ... f) { + return new UnivariateFunction() { + /** {@inheritDoc} */ + public double value(double x) { + double r = x; + for (int i = f.length - 1; i >= 0; i--) { + r = f[i].value(r); + } + return r; + } + }; + } + + /** + * Composes functions. + *+ * The functions in the argument list are composed sequentially, in the + * given order. For example, compose(f1,f2,f3) acts like f1(f2(f3(x))).
+ * + * @param f List of functions. + * @return the composite function. + * @since 3.1 + */ + public static UnivariateDifferentiableFunction compose(final UnivariateDifferentiableFunction ... f) { + return new UnivariateDifferentiableFunction() { + + /** {@inheritDoc} */ + public double value(final double t) { + double r = t; + for (int i = f.length - 1; i >= 0; i--) { + r = f[i].value(r); + } + return r; + } + + /** {@inheritDoc} */ + public DerivativeStructure value(final DerivativeStructure t) { + DerivativeStructure r = t; + for (int i = f.length - 1; i >= 0; i--) { + r = f[i].value(r); + } + return r; + } + + }; + } + + /** + * Composes functions. + *+ * The functions in the argument list are composed sequentially, in the + * given order. For example, compose(f1,f2,f3) acts like f1(f2(f3(x))).
+ * + * @param f List of functions. + * @return the composite function. + * @deprecated as of 3.1 replaced by {@link #compose(UnivariateDifferentiableFunction...)} + */ + @Deprecated + public static DifferentiableUnivariateFunction compose(final DifferentiableUnivariateFunction ... f) { + return new DifferentiableUnivariateFunction() { + /** {@inheritDoc} */ + public double value(double x) { + double r = x; + for (int i = f.length - 1; i >= 0; i--) { + r = f[i].value(r); + } + return r; + } + + /** {@inheritDoc} */ + public UnivariateFunction derivative() { + return new UnivariateFunction() { + /** {@inheritDoc} */ + public double value(double x) { + double p = 1; + double r = x; + for (int i = f.length - 1; i >= 0; i--) { + p *= f[i].derivative().value(r); + r = f[i].value(r); + } + return p; + } + }; + } + }; + } + + /** + * Adds functions. + * + * @param f List of functions. + * @return a function that computes the sum of the functions. + */ + public static UnivariateFunction add(final UnivariateFunction ... f) { + return new UnivariateFunction() { + /** {@inheritDoc} */ + public double value(double x) { + double r = f[0].value(x); + for (int i = 1; i < f.length; i++) { + r += f[i].value(x); + } + return r; + } + }; + } + + /** + * Adds functions. + * + * @param f List of functions. + * @return a function that computes the sum of the functions. + * @since 3.1 + */ + public static UnivariateDifferentiableFunction add(final UnivariateDifferentiableFunction ... f) { + return new UnivariateDifferentiableFunction() { + + /** {@inheritDoc} */ + public double value(final double t) { + double r = f[0].value(t); + for (int i = 1; i < f.length; i++) { + r += f[i].value(t); + } + return r; + } + + /** {@inheritDoc} + * @throws DimensionMismatchException if functions are not consistent with each other + */ + public DerivativeStructure value(final DerivativeStructure t) + throws DimensionMismatchException { + DerivativeStructure r = f[0].value(t); + for (int i = 1; i < f.length; i++) { + r = r.add(f[i].value(t)); + } + return r; + } + + }; + } + + /** + * Adds functions. + * + * @param f List of functions. + * @return a function that computes the sum of the functions. + * @deprecated as of 3.1 replaced by {@link #add(UnivariateDifferentiableFunction...)} + */ + @Deprecated + public static DifferentiableUnivariateFunction add(final DifferentiableUnivariateFunction ... f) { + return new DifferentiableUnivariateFunction() { + /** {@inheritDoc} */ + public double value(double x) { + double r = f[0].value(x); + for (int i = 1; i < f.length; i++) { + r += f[i].value(x); + } + return r; + } + + /** {@inheritDoc} */ + public UnivariateFunction derivative() { + return new UnivariateFunction() { + /** {@inheritDoc} */ + public double value(double x) { + double r = f[0].derivative().value(x); + for (int i = 1; i < f.length; i++) { + r += f[i].derivative().value(x); + } + return r; + } + }; + } + }; + } + + /** + * Multiplies functions. + * + * @param f List of functions. + * @return a function that computes the product of the functions. + */ + public static UnivariateFunction multiply(final UnivariateFunction ... f) { + return new UnivariateFunction() { + /** {@inheritDoc} */ + public double value(double x) { + double r = f[0].value(x); + for (int i = 1; i < f.length; i++) { + r *= f[i].value(x); + } + return r; + } + }; + } + + /** + * Multiplies functions. + * + * @param f List of functions. + * @return a function that computes the product of the functions. + * @since 3.1 + */ + public static UnivariateDifferentiableFunction multiply(final UnivariateDifferentiableFunction ... f) { + return new UnivariateDifferentiableFunction() { + + /** {@inheritDoc} */ + public double value(final double t) { + double r = f[0].value(t); + for (int i = 1; i < f.length; i++) { + r *= f[i].value(t); + } + return r; + } + + /** {@inheritDoc} */ + public DerivativeStructure value(final DerivativeStructure t) { + DerivativeStructure r = f[0].value(t); + for (int i = 1; i < f.length; i++) { + r = r.multiply(f[i].value(t)); + } + return r; + } + + }; + } + + /** + * Multiplies functions. + * + * @param f List of functions. + * @return a function that computes the product of the functions. + * @deprecated as of 3.1 replaced by {@link #multiply(UnivariateDifferentiableFunction...)} + */ + @Deprecated + public static DifferentiableUnivariateFunction multiply(final DifferentiableUnivariateFunction ... f) { + return new DifferentiableUnivariateFunction() { + /** {@inheritDoc} */ + public double value(double x) { + double r = f[0].value(x); + for (int i = 1; i < f.length; i++) { + r *= f[i].value(x); + } + return r; + } + + /** {@inheritDoc} */ + public UnivariateFunction derivative() { + return new UnivariateFunction() { + /** {@inheritDoc} */ + public double value(double x) { + double sum = 0; + for (int i = 0; i < f.length; i++) { + double prod = f[i].derivative().value(x); + for (int j = 0; j < f.length; j++) { + if (i != j) { + prod *= f[j].value(x); + } + } + sum += prod; + } + return sum; + } + }; + } + }; + } + + /** + * Returns the univariate function + * {@code h(x) = combiner(f(x), g(x)).} + * + * @param combiner Combiner function. + * @param f Function. + * @param g Function. + * @return the composite function. + */ + public static UnivariateFunction combine(final BivariateFunction combiner, + final UnivariateFunction f, + final UnivariateFunction g) { + return new UnivariateFunction() { + /** {@inheritDoc} */ + public double value(double x) { + return combiner.value(f.value(x), g.value(x)); + } + }; + } + + /** + * Returns a MultivariateFunction h(x[]) defined by
+ * h(x[]) = combiner(...combiner(combiner(initialValue,f(x[0])),f(x[1]))...),f(x[x.length-1]))
+ *
+ *
+ * @param combiner Combiner function.
+ * @param f Function.
+ * @param initialValue Initial value.
+ * @return a collector function.
+ */
+ public static MultivariateFunction collector(final BivariateFunction combiner,
+ final UnivariateFunction f,
+ final double initialValue) {
+ return new MultivariateFunction() {
+ /** {@inheritDoc} */
+ public double value(double[] point) {
+ double result = combiner.value(initialValue, f.value(point[0]));
+ for (int i = 1; i < point.length; i++) {
+ result = combiner.value(result, f.value(point[i]));
+ }
+ return result;
+ }
+ };
+ }
+
+ /**
+ * Returns a MultivariateFunction h(x[]) defined by
+ * h(x[]) = combiner(...combiner(combiner(initialValue,x[0]),x[1])...),x[x.length-1])
+ *
+ *
+ * @param combiner Combiner function.
+ * @param initialValue Initial value.
+ * @return a collector function.
+ */
+ public static MultivariateFunction collector(final BivariateFunction combiner,
+ final double initialValue) {
+ return collector(combiner, new Identity(), initialValue);
+ }
+
+ /**
+ * Creates a unary function by fixing the first argument of a binary function.
+ *
+ * @param f Binary function.
+ * @param fixed value to which the first argument of {@code f} is set.
+ * @return the unary function h(x) = f(fixed, x)
+ */
+ public static UnivariateFunction fix1stArgument(final BivariateFunction f,
+ final double fixed) {
+ return new UnivariateFunction() {
+ /** {@inheritDoc} */
+ public double value(double x) {
+ return f.value(fixed, x);
+ }
+ };
+ }
+ /**
+ * Creates a unary function by fixing the second argument of a binary function.
+ *
+ * @param f Binary function.
+ * @param fixed value to which the second argument of {@code f} is set.
+ * @return the unary function h(x) = f(x, fixed)
+ */
+ public static UnivariateFunction fix2ndArgument(final BivariateFunction f,
+ final double fixed) {
+ return new UnivariateFunction() {
+ /** {@inheritDoc} */
+ public double value(double x) {
+ return f.value(x, fixed);
+ }
+ };
+ }
+
+ /**
+ * Samples the specified univariate real function on the specified interval.
+ * + * The interval is divided equally into {@code n} sections and sample points + * are taken from {@code min} to {@code max - (max - min) / n}; therefore + * {@code f} is not sampled at the upper bound {@code max}.
+ * + * @param f Function to be sampled + * @param min Lower bound of the interval (included). + * @param max Upper bound of the interval (excluded). + * @param n Number of sample points. + * @return the array of samples. + * @throws NumberIsTooLargeException if the lower bound {@code min} is + * greater than, or equal to the upper bound {@code max}. + * @throws NotStrictlyPositiveException if the number of sample points + * {@code n} is negative. + */ + public static double[] sample(UnivariateFunction f, double min, double max, int n) + throws NumberIsTooLargeException, NotStrictlyPositiveException { + + if (n <= 0) { + throw new NotStrictlyPositiveException( + LocalizedFormats.NOT_POSITIVE_NUMBER_OF_SAMPLES, + Integer.valueOf(n)); + } + if (min >= max) { + throw new NumberIsTooLargeException(min, max, false); + } + + final double[] s = new double[n]; + final double h = (max - min) / n; + for (int i = 0; i < n; i++) { + s[i] = f.value(min + i * h); + } + return s; + } + + /** + * Convert a {@link UnivariateDifferentiableFunction} into a {@link DifferentiableUnivariateFunction}. + * + * @param f function to convert + * @return converted function + * @deprecated this conversion method is temporary in version 3.1, as the {@link + * DifferentiableUnivariateFunction} interface itself is deprecated + */ + @Deprecated + public static DifferentiableUnivariateFunction toDifferentiableUnivariateFunction(final UnivariateDifferentiableFunction f) { + return new DifferentiableUnivariateFunction() { + + /** {@inheritDoc} */ + public double value(final double x) { + return f.value(x); + } + + /** {@inheritDoc} */ + public UnivariateFunction derivative() { + return new UnivariateFunction() { + /** {@inheritDoc} */ + public double value(final double x) { + return f.value(new DerivativeStructure(1, 1, 0, x)).getPartialDerivative(1); + } + }; + } + + }; + } + + /** + * Convert a {@link DifferentiableUnivariateFunction} into a {@link UnivariateDifferentiableFunction}. + *+ * Note that the converted function is able to handle {@link DerivativeStructure} up to order one. + * If the function is called with higher order, a {@link NumberIsTooLargeException} is thrown. + *
+ * @param f function to convert + * @return converted function + * @deprecated this conversion method is temporary in version 3.1, as the {@link + * DifferentiableUnivariateFunction} interface itself is deprecated + */ + @Deprecated + public static UnivariateDifferentiableFunction toUnivariateDifferential(final DifferentiableUnivariateFunction f) { + return new UnivariateDifferentiableFunction() { + + /** {@inheritDoc} */ + public double value(final double x) { + return f.value(x); + } + + /** {@inheritDoc} + * @exception NumberIsTooLargeException if derivation order is greater than 1 + */ + public DerivativeStructure value(final DerivativeStructure t) + throws NumberIsTooLargeException { + switch (t.getOrder()) { + case 0 : + return new DerivativeStructure(t.getFreeParameters(), 0, f.value(t.getValue())); + case 1 : { + final int parameters = t.getFreeParameters(); + final double[] derivatives = new double[parameters + 1]; + derivatives[0] = f.value(t.getValue()); + final double fPrime = f.derivative().value(t.getValue()); + int[] orders = new int[parameters]; + for (int i = 0; i < parameters; ++i) { + orders[i] = 1; + derivatives[i + 1] = fPrime * t.getPartialDerivative(orders); + orders[i] = 0; + } + return new DerivativeStructure(parameters, 1, derivatives); + } + default : + throw new NumberIsTooLargeException(t.getOrder(), 1, true); + } + } + + }; + } + + /** + * Convert a {@link MultivariateDifferentiableFunction} into a {@link DifferentiableMultivariateFunction}. + * + * @param f function to convert + * @return converted function + * @deprecated this conversion method is temporary in version 3.1, as the {@link + * DifferentiableMultivariateFunction} interface itself is deprecated + */ + @Deprecated + public static DifferentiableMultivariateFunction toDifferentiableMultivariateFunction(final MultivariateDifferentiableFunction f) { + return new DifferentiableMultivariateFunction() { + + /** {@inheritDoc} */ + public double value(final double[] x) { + return f.value(x); + } + + /** {@inheritDoc} */ + public MultivariateFunction partialDerivative(final int k) { + return new MultivariateFunction() { + /** {@inheritDoc} */ + public double value(final double[] x) { + + final int n = x.length; + + // delegate computation to underlying function + final DerivativeStructure[] dsX = new DerivativeStructure[n]; + for (int i = 0; i < n; ++i) { + if (i == k) { + dsX[i] = new DerivativeStructure(1, 1, 0, x[i]); + } else { + dsX[i] = new DerivativeStructure(1, 1, x[i]); + } + } + final DerivativeStructure y = f.value(dsX); + + // extract partial derivative + return y.getPartialDerivative(1); + + } + }; + } + + /** {@inheritDoc} */ + public MultivariateVectorFunction gradient() { + return new MultivariateVectorFunction() { + /** {@inheritDoc} */ + public double[] value(final double[] x) { + + final int n = x.length; + + // delegate computation to underlying function + final DerivativeStructure[] dsX = new DerivativeStructure[n]; + for (int i = 0; i < n; ++i) { + dsX[i] = new DerivativeStructure(n, 1, i, x[i]); + } + final DerivativeStructure y = f.value(dsX); + + // extract gradient + final double[] gradient = new double[n]; + final int[] orders = new int[n]; + for (int i = 0; i < n; ++i) { + orders[i] = 1; + gradient[i] = y.getPartialDerivative(orders); + orders[i] = 0; + } + + return gradient; + + } + }; + } + + }; + } + + /** + * Convert a {@link DifferentiableMultivariateFunction} into a {@link MultivariateDifferentiableFunction}. + *+ * Note that the converted function is able to handle {@link DerivativeStructure} elements + * that all have the same number of free parameters and order, and with order at most 1. + * If the function is called with inconsistent numbers of free parameters or higher order, a + * {@link DimensionMismatchException} or a {@link NumberIsTooLargeException} will be thrown. + *
+ * @param f function to convert + * @return converted function + * @deprecated this conversion method is temporary in version 3.1, as the {@link + * DifferentiableMultivariateFunction} interface itself is deprecated + */ + @Deprecated + public static MultivariateDifferentiableFunction toMultivariateDifferentiableFunction(final DifferentiableMultivariateFunction f) { + return new MultivariateDifferentiableFunction() { + + /** {@inheritDoc} */ + public double value(final double[] x) { + return f.value(x); + } + + /** {@inheritDoc} + * @exception NumberIsTooLargeException if derivation order is higher than 1 + * @exception DimensionMismatchException if numbers of free parameters are inconsistent + */ + public DerivativeStructure value(final DerivativeStructure[] t) + throws DimensionMismatchException, NumberIsTooLargeException { + + // check parameters and orders limits + final int parameters = t[0].getFreeParameters(); + final int order = t[0].getOrder(); + final int n = t.length; + if (order > 1) { + throw new NumberIsTooLargeException(order, 1, true); + } + + // check all elements in the array are consistent + for (int i = 0; i < n; ++i) { + if (t[i].getFreeParameters() != parameters) { + throw new DimensionMismatchException(t[i].getFreeParameters(), parameters); + } + + if (t[i].getOrder() != order) { + throw new DimensionMismatchException(t[i].getOrder(), order); + } + } + + // delegate computation to underlying function + final double[] point = new double[n]; + for (int i = 0; i < n; ++i) { + point[i] = t[i].getValue(); + } + final double value = f.value(point); + final double[] gradient = f.gradient().value(point); + + // merge value and gradient into one DerivativeStructure + final double[] derivatives = new double[parameters + 1]; + derivatives[0] = value; + final int[] orders = new int[parameters]; + for (int i = 0; i < parameters; ++i) { + orders[i] = 1; + for (int j = 0; j < n; ++j) { + derivatives[i + 1] += gradient[j] * t[j].getPartialDerivative(orders); + } + orders[i] = 0; + } + + return new DerivativeStructure(parameters, order, derivatives); + + } + + }; + } + + /** + * Convert a {@link MultivariateDifferentiableVectorFunction} into a {@link DifferentiableMultivariateVectorFunction}. + * + * @param f function to convert + * @return converted function + * @deprecated this conversion method is temporary in version 3.1, as the {@link + * DifferentiableMultivariateVectorFunction} interface itself is deprecated + */ + @Deprecated + public static DifferentiableMultivariateVectorFunction toDifferentiableMultivariateVectorFunction(final MultivariateDifferentiableVectorFunction f) { + return new DifferentiableMultivariateVectorFunction() { + + /** {@inheritDoc} */ + public double[] value(final double[] x) { + return f.value(x); + } + + /** {@inheritDoc} */ + public MultivariateMatrixFunction jacobian() { + return new MultivariateMatrixFunction() { + /** {@inheritDoc} */ + public double[][] value(final double[] x) { + + final int n = x.length; + + // delegate computation to underlying function + final DerivativeStructure[] dsX = new DerivativeStructure[n]; + for (int i = 0; i < n; ++i) { + dsX[i] = new DerivativeStructure(n, 1, i, x[i]); + } + final DerivativeStructure[] y = f.value(dsX); + + // extract Jacobian + final double[][] jacobian = new double[y.length][n]; + final int[] orders = new int[n]; + for (int i = 0; i < y.length; ++i) { + for (int j = 0; j < n; ++j) { + orders[j] = 1; + jacobian[i][j] = y[i].getPartialDerivative(orders); + orders[j] = 0; + } + } + + return jacobian; + + } + }; + } + + }; + } + + /** + * Convert a {@link DifferentiableMultivariateVectorFunction} into a {@link MultivariateDifferentiableVectorFunction}. + *+ * Note that the converted function is able to handle {@link DerivativeStructure} elements + * that all have the same number of free parameters and order, and with order at most 1. + * If the function is called with inconsistent numbers of free parameters or higher order, a + * {@link DimensionMismatchException} or a {@link NumberIsTooLargeException} will be thrown. + *
+ * @param f function to convert + * @return converted function + * @deprecated this conversion method is temporary in version 3.1, as the {@link + * DifferentiableMultivariateFunction} interface itself is deprecated + */ + @Deprecated + public static MultivariateDifferentiableVectorFunction toMultivariateDifferentiableVectorFunction(final DifferentiableMultivariateVectorFunction f) { + return new MultivariateDifferentiableVectorFunction() { + + /** {@inheritDoc} */ + public double[] value(final double[] x) { + return f.value(x); + } + + /** {@inheritDoc} + * @exception NumberIsTooLargeException if derivation order is higher than 1 + * @exception DimensionMismatchException if numbers of free parameters are inconsistent + */ + public DerivativeStructure[] value(final DerivativeStructure[] t) + throws DimensionMismatchException, NumberIsTooLargeException { + + // check parameters and orders limits + final int parameters = t[0].getFreeParameters(); + final int order = t[0].getOrder(); + final int n = t.length; + if (order > 1) { + throw new NumberIsTooLargeException(order, 1, true); + } + + // check all elements in the array are consistent + for (int i = 0; i < n; ++i) { + if (t[i].getFreeParameters() != parameters) { + throw new DimensionMismatchException(t[i].getFreeParameters(), parameters); + } + + if (t[i].getOrder() != order) { + throw new DimensionMismatchException(t[i].getOrder(), order); + } + } + + // delegate computation to underlying function + final double[] point = new double[n]; + for (int i = 0; i < n; ++i) { + point[i] = t[i].getValue(); + } + final double[] value = f.value(point); + final double[][] jacobian = f.jacobian().value(point); + + // merge value and Jacobian into a DerivativeStructure array + final DerivativeStructure[] merged = new DerivativeStructure[value.length]; + for (int k = 0; k < merged.length; ++k) { + final double[] derivatives = new double[parameters + 1]; + derivatives[0] = value[k]; + final int[] orders = new int[parameters]; + for (int i = 0; i < parameters; ++i) { + orders[i] = 1; + for (int j = 0; j < n; ++j) { + derivatives[i + 1] += jacobian[k][j] * t[j].getPartialDerivative(orders); + } + orders[i] = 0; + } + merged[k] = new DerivativeStructure(parameters, order, derivatives); + } + + return merged; + + } + + }; + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/MultivariateFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/MultivariateFunction.java new file mode 100644 index 000000000..69f741bd5 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/MultivariateFunction.java @@ -0,0 +1,45 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis; + +import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException; +import com.fr.third.org.apache.commons.math3.exception.MathIllegalArgumentException; + +/** + * An interface representing a multivariate real function. + * + * @since 2.0 + */ +public interface MultivariateFunction { + + /** + * Compute the value for the function at the given point. + * + * @param point Point at which the function must be evaluated. + * @return the function value for the given point. + * @throws DimensionMismatchException + * if the parameter's dimension is wrong for the function being evaluated. + * @throws MathIllegalArgumentException + * when the activated method itself can ascertain that preconditions, + * specified in the API expressed at the level of the activated method, + * have been violated. In the vast majority of cases where Commons Math + * throws this exception, it is the result of argument checking of actual + * parameters immediately passed to a method. + */ + double value(double[] point); +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/MultivariateMatrixFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/MultivariateMatrixFunction.java new file mode 100644 index 000000000..a393b33a4 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/MultivariateMatrixFunction.java @@ -0,0 +1,35 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis; + +/** + * An interface representing a multivariate matrix function. + * @since 2.0 + */ +public interface MultivariateMatrixFunction { + + /** + * Compute the value for the function at the given point. + * @param point point at which the function must be evaluated + * @return function value for the given point + * @exception IllegalArgumentException if point's dimension is wrong + */ + double[][] value(double[] point) + throws IllegalArgumentException; + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/MultivariateVectorFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/MultivariateVectorFunction.java new file mode 100644 index 000000000..ad2d64f48 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/MultivariateVectorFunction.java @@ -0,0 +1,35 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis; + +/** + * An interface representing a multivariate vectorial function. + * @since 2.0 + */ +public interface MultivariateVectorFunction { + + /** + * Compute the value for the function at the given point. + * @param point point at which the function must be evaluated + * @return function value for the given point + * @exception IllegalArgumentException if point's dimension is wrong + */ + double[] value(double[] point) + throws IllegalArgumentException; + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/ParametricUnivariateFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/ParametricUnivariateFunction.java new file mode 100644 index 000000000..35e767dba --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/ParametricUnivariateFunction.java @@ -0,0 +1,44 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis; + +/** + * An interface representing a real function that depends on one independent + * variable plus some extra parameters. + * + * @since 3.0 + */ +public interface ParametricUnivariateFunction { + /** + * Compute the value of the function. + * + * @param x Point for which the function value should be computed. + * @param parameters Function parameters. + * @return the value. + */ + double value(double x, double ... parameters); + + /** + * Compute the gradient of the function with respect to its parameters. + * + * @param x Point for which the function value should be computed. + * @param parameters Function parameters. + * @return the value. + */ + double[] gradient(double x, double ... parameters); +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/RealFieldUnivariateFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/RealFieldUnivariateFunction.java new file mode 100644 index 000000000..30b555db3 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/RealFieldUnivariateFunction.java @@ -0,0 +1,86 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis; + +import com.fr.third.org.apache.commons.math3.RealFieldElement; + +/** + * An interface representing a univariate real function. + *+ * When a user-defined function encounters an error during + * evaluation, the {@link #value(RealFieldElement) value} method should throw a + * user-defined unchecked exception.
+ *+ * The following code excerpt shows the recommended way to do that using + * a root solver as an example, but the same construct is applicable to + * ODE integrators or optimizers.
+ * + *
+ * private static class LocalException extends RuntimeException {
+ * // The x value that caused the problem.
+ * private final SomeFieldType x;
+ *
+ * public LocalException(SomeFieldType x) {
+ * this.x = x;
+ * }
+ *
+ * public double getX() {
+ * return x;
+ * }
+ * }
+ *
+ * private static class MyFunction implements FieldUnivariateFunction<SomeFieldType> {
+ * public SomeFieldType value(SomeFieldType x) {
+ * SomeFieldType y = hugeFormula(x);
+ * if (somethingBadHappens) {
+ * throw new LocalException(x);
+ * }
+ * return y;
+ * }
+ * }
+ *
+ * public void compute() {
+ * try {
+ * solver.solve(maxEval, new MyFunction(a, b, c), min, max);
+ * } catch (LocalException le) {
+ * // Retrieve the x value.
+ * }
+ * }
+ *
+ *
+ * As shown, the exception is local to the user's code and it is guaranteed
+ * that Apache Commons Math will not catch it.
+ *
+ * @param + * When a user-defined function encounters an error during + * evaluation, the {@link #value(double) value} method should throw a + * user-defined unchecked exception.
+ *+ * The following code excerpt shows the recommended way to do that using + * a root solver as an example, but the same construct is applicable to + * ODE integrators or optimizers.
+ * + *
+ * private static class LocalException extends RuntimeException {
+ * // The x value that caused the problem.
+ * private final double x;
+ *
+ * public LocalException(double x) {
+ * this.x = x;
+ * }
+ *
+ * public double getX() {
+ * return x;
+ * }
+ * }
+ *
+ * private static class MyFunction implements UnivariateFunction {
+ * public double value(double x) {
+ * double y = hugeFormula(x);
+ * if (somethingBadHappens) {
+ * throw new LocalException(x);
+ * }
+ * return y;
+ * }
+ * }
+ *
+ * public void compute() {
+ * try {
+ * solver.solve(maxEval, new MyFunction(a, b, c), min, max);
+ * } catch (LocalException le) {
+ * // Retrieve the x value.
+ * }
+ * }
+ *
+ *
+ * As shown, the exception is local to the user's code and it is guaranteed
+ * that Apache Commons Math will not catch it.
+ *
+ */
+public interface UnivariateFunction {
+ /**
+ * Compute the value of the function.
+ *
+ * @param x Point at which the function value should be computed.
+ * @return the value of the function.
+ * @throws IllegalArgumentException when the activated method itself can
+ * ascertain that a precondition, specified in the API expressed at the
+ * level of the activated method, has been violated.
+ * When Commons Math throws an {@code IllegalArgumentException}, it is
+ * usually the consequence of checking the actual parameters passed to
+ * the method.
+ */
+ double value(double x);
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/UnivariateMatrixFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/UnivariateMatrixFunction.java
new file mode 100644
index 000000000..112b5abe4
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/UnivariateMatrixFunction.java
@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.analysis;
+
+/**
+ * An interface representing a univariate matrix function.
+ *
+ * @since 2.0
+ */
+public interface UnivariateMatrixFunction {
+
+ /**
+ * Compute the value for the function.
+ * @param x the point for which the function value should be computed
+ * @return the value
+ */
+ double[][] value(double x);
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/UnivariateVectorFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/UnivariateVectorFunction.java
new file mode 100644
index 000000000..da9019632
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/UnivariateVectorFunction.java
@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.analysis;
+
+/**
+ * An interface representing a univariate vectorial function.
+ *
+ * @since 2.0
+ */
+public interface UnivariateVectorFunction {
+
+ /**
+ * Compute the value for the function.
+ * @param x the point for which the function value should be computed
+ * @return the value
+ */
+ double[] value(double x);
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/DSCompiler.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/DSCompiler.java
new file mode 100644
index 000000000..bfde9cc96
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/DSCompiler.java
@@ -0,0 +1,1820 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.analysis.differentiation;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+
+import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException;
+import com.fr.third.org.apache.commons.math3.exception.MathArithmeticException;
+import com.fr.third.org.apache.commons.math3.exception.MathInternalError;
+import com.fr.third.org.apache.commons.math3.exception.NotPositiveException;
+import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException;
+import com.fr.third.org.apache.commons.math3.util.CombinatoricsUtils;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+import com.fr.third.org.apache.commons.math3.util.MathArrays;
+
+/** Class holding "compiled" computation rules for derivative structures.
+ * This class implements the computation rules described in Dan Kalman's paper Doubly + * Recursive Multivariate Automatic Differentiation, Mathematics Magazine, vol. 75, + * no. 3, June 2002. However, in order to avoid performances bottlenecks, the recursive + * rules are "compiled" once in an unfold form. This class does this recursion unrolling + * and stores the computation rules as simple loops with pre-computed indirection arrays.
+ *+ * This class maps all derivative computation into single dimension arrays that hold the + * value and partial derivatives. The class does not hold these arrays, which remains under + * the responsibility of the caller. For each combination of number of free parameters and + * derivation order, only one compiler is necessary, and this compiler will be used to + * perform computations on all arrays provided to it, which can represent hundreds or + * thousands of different parameters kept together with all theur partial derivatives. + *
+ *+ * The arrays on which compilers operate contain only the partial derivatives together + * with the 0th derivative, i.e. the value. The partial derivatives are stored in + * a compiler-specific order, which can be retrieved using methods {@link + * #getPartialDerivativeIndex(int...) getPartialDerivativeIndex} and {@link + * #getPartialDerivativeOrders(int)}. The value is guaranteed to be stored as the first element + * (i.e. the {@link #getPartialDerivativeIndex(int...) getPartialDerivativeIndex} method returns + * 0 when called with 0 for all derivation orders and {@link #getPartialDerivativeOrders(int) + * getPartialDerivativeOrders} returns an array filled with 0 when called with 0 as the index). + *
+ *+ * Note that the ordering changes with number of parameters and derivation order. For example + * given 2 parameters x and y, df/dy is stored at index 2 when derivation order is set to 1 (in + * this case the array has three elements: f, df/dx and df/dy). If derivation order is set to + * 2, then df/dy will be stored at index 3 (in this case the array has six elements: f, df/dx, + * df/dxdx, df/dy, df/dxdy and df/dydy). + *
+ *+ * Given this structure, users can perform some simple operations like adding, subtracting + * or multiplying constants and negating the elements by themselves, knowing if they want to + * mutate their array or create a new array. These simple operations are not provided by + * the compiler. The compiler provides only the more complex operations between several arrays. + *
+ *This class is mainly used as the engine for scalar variable {@link DerivativeStructure}. + * It can also be used directly to hold several variables in arrays for more complex data + * structures. User can for example store a vector of n variables depending on three x, y + * and z free parameters in one array as follows:
+ * // parameter 0 is x, parameter 1 is y, parameter 2 is z
+ * int parameters = 3;
+ * DSCompiler compiler = DSCompiler.getCompiler(parameters, order);
+ * int size = compiler.getSize();
+ *
+ * // pack all elements in a single array
+ * double[] array = new double[n * size];
+ * for (int i = 0; i < n; ++i) {
+ *
+ * // we know value is guaranteed to be the first element
+ * array[i * size] = v[i];
+ *
+ * // we don't know where first derivatives are stored, so we ask the compiler
+ * array[i * size + compiler.getPartialDerivativeIndex(1, 0, 0) = dvOnDx[i][0];
+ * array[i * size + compiler.getPartialDerivativeIndex(0, 1, 0) = dvOnDy[i][0];
+ * array[i * size + compiler.getPartialDerivativeIndex(0, 0, 1) = dvOnDz[i][0];
+ *
+ * // we let all higher order derivatives set to 0
+ *
+ * }
+ *
+ * Then in another function, user can perform some operations on all elements stored + * in the single array, such as a simple product of all variables:
+ * // compute the product of all elements
+ * double[] product = new double[size];
+ * prod[0] = 1.0;
+ * for (int i = 0; i < n; ++i) {
+ * double[] tmp = product.clone();
+ * compiler.multiply(tmp, 0, array, i * size, product, 0);
+ * }
+ *
+ * // value
+ * double p = product[0];
+ *
+ * // first derivatives
+ * double dPdX = product[compiler.getPartialDerivativeIndex(1, 0, 0)];
+ * double dPdY = product[compiler.getPartialDerivativeIndex(0, 1, 0)];
+ * double dPdZ = product[compiler.getPartialDerivativeIndex(0, 0, 1)];
+ *
+ * // cross derivatives (assuming order was at least 2)
+ * double dPdXdX = product[compiler.getPartialDerivativeIndex(2, 0, 0)];
+ * double dPdXdY = product[compiler.getPartialDerivativeIndex(1, 1, 0)];
+ * double dPdXdZ = product[compiler.getPartialDerivativeIndex(1, 0, 1)];
+ * double dPdYdY = product[compiler.getPartialDerivativeIndex(0, 2, 0)];
+ * double dPdYdZ = product[compiler.getPartialDerivativeIndex(0, 1, 1)];
+ * double dPdZdZ = product[compiler.getPartialDerivativeIndex(0, 0, 2)];
+ *
+ * @see DerivativeStructure
+ * @since 3.1
+ */
+public class DSCompiler {
+
+ /** Array of all compilers created so far. */
+ private static AtomicReference+ * This indirection array contains the indices of all elements + * except derivatives for last derivation order. + *
+ * @param parameters number of free parameters + * @param order derivation order + * @param valueCompiler compiler for the value part + * @param derivativeCompiler compiler for the derivative part + * @return lower derivatives indirection array + */ + private static int[] compileLowerIndirection(final int parameters, final int order, + final DSCompiler valueCompiler, + final DSCompiler derivativeCompiler) { + + if (parameters == 0 || order <= 1) { + return new int[] { 0 }; + } + + // this is an implementation of definition 6 in Dan Kalman's paper. + final int vSize = valueCompiler.lowerIndirection.length; + final int dSize = derivativeCompiler.lowerIndirection.length; + final int[] lowerIndirection = new int[vSize + dSize]; + System.arraycopy(valueCompiler.lowerIndirection, 0, lowerIndirection, 0, vSize); + for (int i = 0; i < dSize; ++i) { + lowerIndirection[vSize + i] = valueCompiler.getSize() + derivativeCompiler.lowerIndirection[i]; + } + + return lowerIndirection; + + } + + /** Compile the multiplication indirection array. + *+ * This indirection array contains the indices of all pairs of elements + * involved when computing a multiplication. This allows a straightforward + * loop-based multiplication (see {@link #multiply(double[], int, double[], int, double[], int)}). + *
+ * @param parameters number of free parameters + * @param order derivation order + * @param valueCompiler compiler for the value part + * @param derivativeCompiler compiler for the derivative part + * @param lowerIndirection lower derivatives indirection array + * @return multiplication indirection array + */ + private static int[][][] compileMultiplicationIndirection(final int parameters, final int order, + final DSCompiler valueCompiler, + final DSCompiler derivativeCompiler, + final int[] lowerIndirection) { + + if ((parameters == 0) || (order == 0)) { + return new int[][][] { { { 1, 0, 0 } } }; + } + + // this is an implementation of definition 3 in Dan Kalman's paper. + final int vSize = valueCompiler.multIndirection.length; + final int dSize = derivativeCompiler.multIndirection.length; + final int[][][] multIndirection = new int[vSize + dSize][][]; + + System.arraycopy(valueCompiler.multIndirection, 0, multIndirection, 0, vSize); + + for (int i = 0; i < dSize; ++i) { + final int[][] dRow = derivativeCompiler.multIndirection[i]; + List+ * This indirection array contains the indices of all sets of elements + * involved when computing a composition. This allows a straightforward + * loop-based composition (see {@link #compose(double[], int, double[], double[], int)}). + *
+ * @param parameters number of free parameters + * @param order derivation order + * @param valueCompiler compiler for the value part + * @param derivativeCompiler compiler for the derivative part + * @param sizes sizes array + * @param derivativesIndirection derivatives indirection array + * @return multiplication indirection array + * @throws NumberIsTooLargeException if order is too large + */ + private static int[][][] compileCompositionIndirection(final int parameters, final int order, + final DSCompiler valueCompiler, + final DSCompiler derivativeCompiler, + final int[][] sizes, + final int[][] derivativesIndirection) + throws NumberIsTooLargeException { + + if ((parameters == 0) || (order == 0)) { + return new int[][][] { { { 1, 0 } } }; + } + + final int vSize = valueCompiler.compIndirection.length; + final int dSize = derivativeCompiler.compIndirection.length; + final int[][][] compIndirection = new int[vSize + dSize][][]; + + // the composition rules from the value part can be reused as is + System.arraycopy(valueCompiler.compIndirection, 0, compIndirection, 0, vSize); + + // the composition rules for the derivative part are deduced by + // differentiation the rules from the underlying compiler once + // with respect to the parameter this compiler handles and the + // underlying one did not handle + for (int i = 0; i < dSize; ++i) { + List+ * If all orders are set to 0, then the 0th order derivative + * is returned, which is the value of the function. + *
+ *The indices of derivatives are between 0 and {@link #getSize() getSize()} - 1. + * Their specific order is fixed for a given compiler, but otherwise not + * publicly specified. There are however some simple cases which have guaranteed + * indices: + *
+ *+ * This method is the inverse of method {@link #getPartialDerivativeOrders(int)} + *
+ * @param orders derivation orders with respect to each parameter + * @return index of the partial derivative + * @exception DimensionMismatchException if the numbers of parameters does not + * match the instance + * @exception NumberIsTooLargeException if sum of derivation orders is larger + * than the instance limits + * @see #getPartialDerivativeOrders(int) + */ + public int getPartialDerivativeIndex(final int ... orders) + throws DimensionMismatchException, NumberIsTooLargeException { + + // safety check + if (orders.length != getFreeParameters()) { + throw new DimensionMismatchException(orders.length, getFreeParameters()); + } + + return getPartialDerivativeIndex(parameters, order, sizes, orders); + + } + + /** Get the index of a partial derivative in an array. + * @param parameters number of free parameters + * @param order derivation order + * @param sizes sizes array + * @param orders derivation orders with respect to each parameter + * (the lenght of this array must match the number of parameters) + * @return index of the partial derivative + * @exception NumberIsTooLargeException if sum of derivation orders is larger + * than the instance limits + */ + private static int getPartialDerivativeIndex(final int parameters, final int order, + final int[][] sizes, final int ... orders) + throws NumberIsTooLargeException { + + // the value is obtained by diving into the recursive Dan Kalman's structure + // this is theorem 2 of his paper, with recursion replaced by iteration + int index = 0; + int m = order; + int ordersSum = 0; + for (int i = parameters - 1; i >= 0; --i) { + + // derivative order for current free parameter + int derivativeOrder = orders[i]; + + // safety check + ordersSum += derivativeOrder; + if (ordersSum > order) { + throw new NumberIsTooLargeException(ordersSum, order, true); + } + + while (derivativeOrder-- > 0) { + // as long as we differentiate according to current free parameter, + // we have to skip the value part and dive into the derivative part + // so we add the size of the value part to the base index + index += sizes[i][m--]; + } + + } + + return index; + + } + + /** Convert an index from one (parameters, order) structure to another. + * @param index index of a partial derivative in source derivative structure + * @param srcP number of free parameters in source derivative structure + * @param srcDerivativesIndirection derivatives indirection array for the source + * derivative structure + * @param destP number of free parameters in destination derivative structure + * @param destO derivation order in destination derivative structure + * @param destSizes sizes array for the destination derivative structure + * @return index of the partial derivative with the same characteristics + * in destination derivative structure + * @throws NumberIsTooLargeException if order is too large + */ + private static int convertIndex(final int index, + final int srcP, final int[][] srcDerivativesIndirection, + final int destP, final int destO, final int[][] destSizes) + throws NumberIsTooLargeException { + int[] orders = new int[destP]; + System.arraycopy(srcDerivativesIndirection[index], 0, orders, 0, FastMath.min(srcP, destP)); + return getPartialDerivativeIndex(destP, destO, destSizes, orders); + } + + /** Get the derivation orders for a specific index in the array. + *+ * This method is the inverse of {@link #getPartialDerivativeIndex(int...)}. + *
+ * @param index of the partial derivative + * @return orders derivation orders with respect to each parameter + * @see #getPartialDerivativeIndex(int...) + */ + public int[] getPartialDerivativeOrders(final int index) { + return derivativesIndirection[index]; + } + + /** Get the number of free parameters. + * @return number of free parameters + */ + public int getFreeParameters() { + return parameters; + } + + /** Get the derivation order. + * @return derivation order + */ + public int getOrder() { + return order; + } + + /** Get the array size required for holding partial derivatives data. + *+ * This number includes the single 0 order derivative element, which is + * guaranteed to be stored in the first element of the array. + *
+ * @return array size required for holding partial derivatives data + */ + public int getSize() { + return sizes[parameters][order]; + } + + /** Compute linear combination. + * The derivative structure built will be a1 * ds1 + a2 * ds2 + * @param a1 first scale factor + * @param c1 first base (unscaled) component + * @param offset1 offset of first operand in its array + * @param a2 second scale factor + * @param c2 second base (unscaled) component + * @param offset2 offset of second operand in its array + * @param result array where result must be stored (it may be + * one of the input arrays) + * @param resultOffset offset of the result in its array + */ + public void linearCombination(final double a1, final double[] c1, final int offset1, + final double a2, final double[] c2, final int offset2, + final double[] result, final int resultOffset) { + for (int i = 0; i < getSize(); ++i) { + result[resultOffset + i] = + MathArrays.linearCombination(a1, c1[offset1 + i], a2, c2[offset2 + i]); + } + } + + /** Compute linear combination. + * The derivative structure built will be a1 * ds1 + a2 * ds2 + a3 * ds3 + a4 * ds4 + * @param a1 first scale factor + * @param c1 first base (unscaled) component + * @param offset1 offset of first operand in its array + * @param a2 second scale factor + * @param c2 second base (unscaled) component + * @param offset2 offset of second operand in its array + * @param a3 third scale factor + * @param c3 third base (unscaled) component + * @param offset3 offset of third operand in its array + * @param result array where result must be stored (it may be + * one of the input arrays) + * @param resultOffset offset of the result in its array + */ + public void linearCombination(final double a1, final double[] c1, final int offset1, + final double a2, final double[] c2, final int offset2, + final double a3, final double[] c3, final int offset3, + final double[] result, final int resultOffset) { + for (int i = 0; i < getSize(); ++i) { + result[resultOffset + i] = + MathArrays.linearCombination(a1, c1[offset1 + i], + a2, c2[offset2 + i], + a3, c3[offset3 + i]); + } + } + + /** Compute linear combination. + * The derivative structure built will be a1 * ds1 + a2 * ds2 + a3 * ds3 + a4 * ds4 + * @param a1 first scale factor + * @param c1 first base (unscaled) component + * @param offset1 offset of first operand in its array + * @param a2 second scale factor + * @param c2 second base (unscaled) component + * @param offset2 offset of second operand in its array + * @param a3 third scale factor + * @param c3 third base (unscaled) component + * @param offset3 offset of third operand in its array + * @param a4 fourth scale factor + * @param c4 fourth base (unscaled) component + * @param offset4 offset of fourth operand in its array + * @param result array where result must be stored (it may be + * one of the input arrays) + * @param resultOffset offset of the result in its array + */ + public void linearCombination(final double a1, final double[] c1, final int offset1, + final double a2, final double[] c2, final int offset2, + final double a3, final double[] c3, final int offset3, + final double a4, final double[] c4, final int offset4, + final double[] result, final int resultOffset) { + for (int i = 0; i < getSize(); ++i) { + result[resultOffset + i] = + MathArrays.linearCombination(a1, c1[offset1 + i], + a2, c2[offset2 + i], + a3, c3[offset3 + i], + a4, c4[offset4 + i]); + } + } + + /** Perform addition of two derivative structures. + * @param lhs array holding left hand side of addition + * @param lhsOffset offset of the left hand side in its array + * @param rhs array right hand side of addition + * @param rhsOffset offset of the right hand side in its array + * @param result array where result must be stored (it may be + * one of the input arrays) + * @param resultOffset offset of the result in its array + */ + public void add(final double[] lhs, final int lhsOffset, + final double[] rhs, final int rhsOffset, + final double[] result, final int resultOffset) { + for (int i = 0; i < getSize(); ++i) { + result[resultOffset + i] = lhs[lhsOffset + i] + rhs[rhsOffset + i]; + } + } + /** Perform subtraction of two derivative structures. + * @param lhs array holding left hand side of subtraction + * @param lhsOffset offset of the left hand side in its array + * @param rhs array right hand side of subtraction + * @param rhsOffset offset of the right hand side in its array + * @param result array where result must be stored (it may be + * one of the input arrays) + * @param resultOffset offset of the result in its array + */ + public void subtract(final double[] lhs, final int lhsOffset, + final double[] rhs, final int rhsOffset, + final double[] result, final int resultOffset) { + for (int i = 0; i < getSize(); ++i) { + result[resultOffset + i] = lhs[lhsOffset + i] - rhs[rhsOffset + i]; + } + } + + /** Perform multiplication of two derivative structures. + * @param lhs array holding left hand side of multiplication + * @param lhsOffset offset of the left hand side in its array + * @param rhs array right hand side of multiplication + * @param rhsOffset offset of the right hand side in its array + * @param result array where result must be stored (for + * multiplication the result array cannot be one of + * the input arrays) + * @param resultOffset offset of the result in its array + */ + public void multiply(final double[] lhs, final int lhsOffset, + final double[] rhs, final int rhsOffset, + final double[] result, final int resultOffset) { + for (int i = 0; i < multIndirection.length; ++i) { + final int[][] mappingI = multIndirection[i]; + double r = 0; + for (int j = 0; j < mappingI.length; ++j) { + r += mappingI[j][0] * + lhs[lhsOffset + mappingI[j][1]] * + rhs[rhsOffset + mappingI[j][2]]; + } + result[resultOffset + i] = r; + } + } + + /** Perform division of two derivative structures. + * @param lhs array holding left hand side of division + * @param lhsOffset offset of the left hand side in its array + * @param rhs array right hand side of division + * @param rhsOffset offset of the right hand side in its array + * @param result array where result must be stored (for + * division the result array cannot be one of + * the input arrays) + * @param resultOffset offset of the result in its array + */ + public void divide(final double[] lhs, final int lhsOffset, + final double[] rhs, final int rhsOffset, + final double[] result, final int resultOffset) { + final double[] reciprocal = new double[getSize()]; + pow(rhs, lhsOffset, -1, reciprocal, 0); + multiply(lhs, lhsOffset, reciprocal, 0, result, resultOffset); + } + + /** Perform remainder of two derivative structures. + * @param lhs array holding left hand side of remainder + * @param lhsOffset offset of the left hand side in its array + * @param rhs array right hand side of remainder + * @param rhsOffset offset of the right hand side in its array + * @param result array where result must be stored (it may be + * one of the input arrays) + * @param resultOffset offset of the result in its array + */ + public void remainder(final double[] lhs, final int lhsOffset, + final double[] rhs, final int rhsOffset, + final double[] result, final int resultOffset) { + + // compute k such that lhs % rhs = lhs - k rhs + final double rem = FastMath.IEEEremainder(lhs[lhsOffset], rhs[rhsOffset]); + final double k = FastMath.rint((lhs[lhsOffset] - rem) / rhs[rhsOffset]); + + // set up value + result[resultOffset] = rem; + + // set up partial derivatives + for (int i = 1; i < getSize(); ++i) { + result[resultOffset + i] = lhs[lhsOffset + i] - k * rhs[rhsOffset + i]; + } + + } + + /** Compute power of a double to a derivative structure. + * @param a number to exponentiate + * @param operand array holding the power + * @param operandOffset offset of the power in its array + * @param result array where result must be stored (for + * power the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + * @since 3.3 + */ + public void pow(final double a, + final double[] operand, final int operandOffset, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + // [a^x, ln(a) a^x, ln(a)^2 a^x,, ln(a)^3 a^x, ... ] + final double[] function = new double[1 + order]; + if (a == 0) { + if (operand[operandOffset] == 0) { + function[0] = 1; + double infinity = Double.POSITIVE_INFINITY; + for (int i = 1; i < function.length; ++i) { + infinity = -infinity; + function[i] = infinity; + } + } else if (operand[operandOffset] < 0) { + Arrays.fill(function, Double.NaN); + } + } else { + function[0] = FastMath.pow(a, operand[operandOffset]); + final double lnA = FastMath.log(a); + for (int i = 1; i < function.length; ++i) { + function[i] = lnA * function[i - 1]; + } + } + + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Compute power of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param p power to apply + * @param result array where result must be stored (for + * power the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void pow(final double[] operand, final int operandOffset, final double p, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + // [x^p, px^(p-1), p(p-1)x^(p-2), ... ] + double[] function = new double[1 + order]; + double xk = FastMath.pow(operand[operandOffset], p - order); + for (int i = order; i > 0; --i) { + function[i] = xk; + xk *= operand[operandOffset]; + } + function[0] = xk; + double coefficient = p; + for (int i = 1; i <= order; ++i) { + function[i] *= coefficient; + coefficient *= p - i; + } + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Compute integer power of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param n power to apply + * @param result array where result must be stored (for + * power the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void pow(final double[] operand, final int operandOffset, final int n, + final double[] result, final int resultOffset) { + + if (n == 0) { + // special case, x^0 = 1 for all x + result[resultOffset] = 1.0; + Arrays.fill(result, resultOffset + 1, resultOffset + getSize(), 0); + return; + } + + // create the power function value and derivatives + // [x^n, nx^(n-1), n(n-1)x^(n-2), ... ] + double[] function = new double[1 + order]; + + if (n > 0) { + // strictly positive power + final int maxOrder = FastMath.min(order, n); + double xk = FastMath.pow(operand[operandOffset], n - maxOrder); + for (int i = maxOrder; i > 0; --i) { + function[i] = xk; + xk *= operand[operandOffset]; + } + function[0] = xk; + } else { + // strictly negative power + final double inv = 1.0 / operand[operandOffset]; + double xk = FastMath.pow(inv, -n); + for (int i = 0; i <= order; ++i) { + function[i] = xk; + xk *= inv; + } + } + + double coefficient = n; + for (int i = 1; i <= order; ++i) { + function[i] *= coefficient; + coefficient *= n - i; + } + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Compute power of a derivative structure. + * @param x array holding the base + * @param xOffset offset of the base in its array + * @param y array holding the exponent + * @param yOffset offset of the exponent in its array + * @param result array where result must be stored (for + * power the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void pow(final double[] x, final int xOffset, + final double[] y, final int yOffset, + final double[] result, final int resultOffset) { + final double[] logX = new double[getSize()]; + log(x, xOffset, logX, 0); + final double[] yLogX = new double[getSize()]; + multiply(logX, 0, y, yOffset, yLogX, 0); + exp(yLogX, 0, result, resultOffset); + } + + /** Compute nth root of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param n order of the root + * @param result array where result must be stored (for + * nth root the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void rootN(final double[] operand, final int operandOffset, final int n, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + // [x^(1/n), (1/n)x^((1/n)-1), (1-n)/n^2x^((1/n)-2), ... ] + double[] function = new double[1 + order]; + double xk; + if (n == 2) { + function[0] = FastMath.sqrt(operand[operandOffset]); + xk = 0.5 / function[0]; + } else if (n == 3) { + function[0] = FastMath.cbrt(operand[operandOffset]); + xk = 1.0 / (3.0 * function[0] * function[0]); + } else { + function[0] = FastMath.pow(operand[operandOffset], 1.0 / n); + xk = 1.0 / (n * FastMath.pow(function[0], n - 1)); + } + final double nReciprocal = 1.0 / n; + final double xReciprocal = 1.0 / operand[operandOffset]; + for (int i = 1; i <= order; ++i) { + function[i] = xk; + xk *= xReciprocal * (nReciprocal - i); + } + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Compute exponential of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param result array where result must be stored (for + * exponential the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void exp(final double[] operand, final int operandOffset, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + double[] function = new double[1 + order]; + Arrays.fill(function, FastMath.exp(operand[operandOffset])); + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Compute exp(x) - 1 of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param result array where result must be stored (for + * exponential the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void expm1(final double[] operand, final int operandOffset, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + double[] function = new double[1 + order]; + function[0] = FastMath.expm1(operand[operandOffset]); + Arrays.fill(function, 1, 1 + order, FastMath.exp(operand[operandOffset])); + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Compute natural logarithm of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param result array where result must be stored (for + * logarithm the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void log(final double[] operand, final int operandOffset, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + double[] function = new double[1 + order]; + function[0] = FastMath.log(operand[operandOffset]); + if (order > 0) { + double inv = 1.0 / operand[operandOffset]; + double xk = inv; + for (int i = 1; i <= order; ++i) { + function[i] = xk; + xk *= -i * inv; + } + } + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Computes shifted logarithm of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param result array where result must be stored (for + * shifted logarithm the result array cannot be the input array) + * @param resultOffset offset of the result in its array + */ + public void log1p(final double[] operand, final int operandOffset, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + double[] function = new double[1 + order]; + function[0] = FastMath.log1p(operand[operandOffset]); + if (order > 0) { + double inv = 1.0 / (1.0 + operand[operandOffset]); + double xk = inv; + for (int i = 1; i <= order; ++i) { + function[i] = xk; + xk *= -i * inv; + } + } + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Computes base 10 logarithm of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param result array where result must be stored (for + * base 10 logarithm the result array cannot be the input array) + * @param resultOffset offset of the result in its array + */ + public void log10(final double[] operand, final int operandOffset, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + double[] function = new double[1 + order]; + function[0] = FastMath.log10(operand[operandOffset]); + if (order > 0) { + double inv = 1.0 / operand[operandOffset]; + double xk = inv / FastMath.log(10.0); + for (int i = 1; i <= order; ++i) { + function[i] = xk; + xk *= -i * inv; + } + } + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Compute cosine of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param result array where result must be stored (for + * cosine the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void cos(final double[] operand, final int operandOffset, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + double[] function = new double[1 + order]; + function[0] = FastMath.cos(operand[operandOffset]); + if (order > 0) { + function[1] = -FastMath.sin(operand[operandOffset]); + for (int i = 2; i <= order; ++i) { + function[i] = -function[i - 2]; + } + } + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Compute sine of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param result array where result must be stored (for + * sine the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void sin(final double[] operand, final int operandOffset, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + double[] function = new double[1 + order]; + function[0] = FastMath.sin(operand[operandOffset]); + if (order > 0) { + function[1] = FastMath.cos(operand[operandOffset]); + for (int i = 2; i <= order; ++i) { + function[i] = -function[i - 2]; + } + } + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Compute tangent of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param result array where result must be stored (for + * tangent the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void tan(final double[] operand, final int operandOffset, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + final double[] function = new double[1 + order]; + final double t = FastMath.tan(operand[operandOffset]); + function[0] = t; + + if (order > 0) { + + // the nth order derivative of tan has the form: + // dn(tan(x)/dxn = P_n(tan(x)) + // where P_n(t) is a degree n+1 polynomial with same parity as n+1 + // P_0(t) = t, P_1(t) = 1 + t^2, P_2(t) = 2 t (1 + t^2) ... + // the general recurrence relation for P_n is: + // P_n(x) = (1+t^2) P_(n-1)'(t) + // as per polynomial parity, we can store coefficients of both P_(n-1) and P_n in the same array + final double[] p = new double[order + 2]; + p[1] = 1; + final double t2 = t * t; + for (int n = 1; n <= order; ++n) { + + // update and evaluate polynomial P_n(t) + double v = 0; + p[n + 1] = n * p[n]; + for (int k = n + 1; k >= 0; k -= 2) { + v = v * t2 + p[k]; + if (k > 2) { + p[k - 2] = (k - 1) * p[k - 1] + (k - 3) * p[k - 3]; + } else if (k == 2) { + p[0] = p[1]; + } + } + if ((n & 0x1) == 0) { + v *= t; + } + + function[n] = v; + + } + } + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Compute arc cosine of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param result array where result must be stored (for + * arc cosine the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void acos(final double[] operand, final int operandOffset, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + double[] function = new double[1 + order]; + final double x = operand[operandOffset]; + function[0] = FastMath.acos(x); + if (order > 0) { + // the nth order derivative of acos has the form: + // dn(acos(x)/dxn = P_n(x) / [1 - x^2]^((2n-1)/2) + // where P_n(x) is a degree n-1 polynomial with same parity as n-1 + // P_1(x) = -1, P_2(x) = -x, P_3(x) = -2x^2 - 1 ... + // the general recurrence relation for P_n is: + // P_n(x) = (1-x^2) P_(n-1)'(x) + (2n-3) x P_(n-1)(x) + // as per polynomial parity, we can store coefficients of both P_(n-1) and P_n in the same array + final double[] p = new double[order]; + p[0] = -1; + final double x2 = x * x; + final double f = 1.0 / (1 - x2); + double coeff = FastMath.sqrt(f); + function[1] = coeff * p[0]; + for (int n = 2; n <= order; ++n) { + + // update and evaluate polynomial P_n(x) + double v = 0; + p[n - 1] = (n - 1) * p[n - 2]; + for (int k = n - 1; k >= 0; k -= 2) { + v = v * x2 + p[k]; + if (k > 2) { + p[k - 2] = (k - 1) * p[k - 1] + (2 * n - k) * p[k - 3]; + } else if (k == 2) { + p[0] = p[1]; + } + } + if ((n & 0x1) == 0) { + v *= x; + } + + coeff *= f; + function[n] = coeff * v; + + } + } + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Compute arc sine of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param result array where result must be stored (for + * arc sine the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void asin(final double[] operand, final int operandOffset, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + double[] function = new double[1 + order]; + final double x = operand[operandOffset]; + function[0] = FastMath.asin(x); + if (order > 0) { + // the nth order derivative of asin has the form: + // dn(asin(x)/dxn = P_n(x) / [1 - x^2]^((2n-1)/2) + // where P_n(x) is a degree n-1 polynomial with same parity as n-1 + // P_1(x) = 1, P_2(x) = x, P_3(x) = 2x^2 + 1 ... + // the general recurrence relation for P_n is: + // P_n(x) = (1-x^2) P_(n-1)'(x) + (2n-3) x P_(n-1)(x) + // as per polynomial parity, we can store coefficients of both P_(n-1) and P_n in the same array + final double[] p = new double[order]; + p[0] = 1; + final double x2 = x * x; + final double f = 1.0 / (1 - x2); + double coeff = FastMath.sqrt(f); + function[1] = coeff * p[0]; + for (int n = 2; n <= order; ++n) { + + // update and evaluate polynomial P_n(x) + double v = 0; + p[n - 1] = (n - 1) * p[n - 2]; + for (int k = n - 1; k >= 0; k -= 2) { + v = v * x2 + p[k]; + if (k > 2) { + p[k - 2] = (k - 1) * p[k - 1] + (2 * n - k) * p[k - 3]; + } else if (k == 2) { + p[0] = p[1]; + } + } + if ((n & 0x1) == 0) { + v *= x; + } + + coeff *= f; + function[n] = coeff * v; + + } + } + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Compute arc tangent of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param result array where result must be stored (for + * arc tangent the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void atan(final double[] operand, final int operandOffset, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + double[] function = new double[1 + order]; + final double x = operand[operandOffset]; + function[0] = FastMath.atan(x); + if (order > 0) { + // the nth order derivative of atan has the form: + // dn(atan(x)/dxn = Q_n(x) / (1 + x^2)^n + // where Q_n(x) is a degree n-1 polynomial with same parity as n-1 + // Q_1(x) = 1, Q_2(x) = -2x, Q_3(x) = 6x^2 - 2 ... + // the general recurrence relation for Q_n is: + // Q_n(x) = (1+x^2) Q_(n-1)'(x) - 2(n-1) x Q_(n-1)(x) + // as per polynomial parity, we can store coefficients of both Q_(n-1) and Q_n in the same array + final double[] q = new double[order]; + q[0] = 1; + final double x2 = x * x; + final double f = 1.0 / (1 + x2); + double coeff = f; + function[1] = coeff * q[0]; + for (int n = 2; n <= order; ++n) { + + // update and evaluate polynomial Q_n(x) + double v = 0; + q[n - 1] = -n * q[n - 2]; + for (int k = n - 1; k >= 0; k -= 2) { + v = v * x2 + q[k]; + if (k > 2) { + q[k - 2] = (k - 1) * q[k - 1] + (k - 1 - 2 * n) * q[k - 3]; + } else if (k == 2) { + q[0] = q[1]; + } + } + if ((n & 0x1) == 0) { + v *= x; + } + + coeff *= f; + function[n] = coeff * v; + + } + } + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Compute two arguments arc tangent of a derivative structure. + * @param y array holding the first operand + * @param yOffset offset of the first operand in its array + * @param x array holding the second operand + * @param xOffset offset of the second operand in its array + * @param result array where result must be stored (for + * two arguments arc tangent the result array cannot + * be the input array) + * @param resultOffset offset of the result in its array + */ + public void atan2(final double[] y, final int yOffset, + final double[] x, final int xOffset, + final double[] result, final int resultOffset) { + + // compute r = sqrt(x^2+y^2) + double[] tmp1 = new double[getSize()]; + multiply(x, xOffset, x, xOffset, tmp1, 0); // x^2 + double[] tmp2 = new double[getSize()]; + multiply(y, yOffset, y, yOffset, tmp2, 0); // y^2 + add(tmp1, 0, tmp2, 0, tmp2, 0); // x^2 + y^2 + rootN(tmp2, 0, 2, tmp1, 0); // r = sqrt(x^2 + y^2) + + if (x[xOffset] >= 0) { + + // compute atan2(y, x) = 2 atan(y / (r + x)) + add(tmp1, 0, x, xOffset, tmp2, 0); // r + x + divide(y, yOffset, tmp2, 0, tmp1, 0); // y /(r + x) + atan(tmp1, 0, tmp2, 0); // atan(y / (r + x)) + for (int i = 0; i < tmp2.length; ++i) { + result[resultOffset + i] = 2 * tmp2[i]; // 2 * atan(y / (r + x)) + } + + } else { + + // compute atan2(y, x) = +/- pi - 2 atan(y / (r - x)) + subtract(tmp1, 0, x, xOffset, tmp2, 0); // r - x + divide(y, yOffset, tmp2, 0, tmp1, 0); // y /(r - x) + atan(tmp1, 0, tmp2, 0); // atan(y / (r - x)) + result[resultOffset] = + ((tmp2[0] <= 0) ? -FastMath.PI : FastMath.PI) - 2 * tmp2[0]; // +/-pi - 2 * atan(y / (r - x)) + for (int i = 1; i < tmp2.length; ++i) { + result[resultOffset + i] = -2 * tmp2[i]; // +/-pi - 2 * atan(y / (r - x)) + } + + } + + // fix value to take special cases (+0/+0, +0/-0, -0/+0, -0/-0, +/-infinity) correctly + result[resultOffset] = FastMath.atan2(y[yOffset], x[xOffset]); + + } + + /** Compute hyperbolic cosine of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param result array where result must be stored (for + * hyperbolic cosine the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void cosh(final double[] operand, final int operandOffset, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + double[] function = new double[1 + order]; + function[0] = FastMath.cosh(operand[operandOffset]); + if (order > 0) { + function[1] = FastMath.sinh(operand[operandOffset]); + for (int i = 2; i <= order; ++i) { + function[i] = function[i - 2]; + } + } + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Compute hyperbolic sine of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param result array where result must be stored (for + * hyperbolic sine the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void sinh(final double[] operand, final int operandOffset, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + double[] function = new double[1 + order]; + function[0] = FastMath.sinh(operand[operandOffset]); + if (order > 0) { + function[1] = FastMath.cosh(operand[operandOffset]); + for (int i = 2; i <= order; ++i) { + function[i] = function[i - 2]; + } + } + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Compute hyperbolic tangent of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param result array where result must be stored (for + * hyperbolic tangent the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void tanh(final double[] operand, final int operandOffset, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + final double[] function = new double[1 + order]; + final double t = FastMath.tanh(operand[operandOffset]); + function[0] = t; + + if (order > 0) { + + // the nth order derivative of tanh has the form: + // dn(tanh(x)/dxn = P_n(tanh(x)) + // where P_n(t) is a degree n+1 polynomial with same parity as n+1 + // P_0(t) = t, P_1(t) = 1 - t^2, P_2(t) = -2 t (1 - t^2) ... + // the general recurrence relation for P_n is: + // P_n(x) = (1-t^2) P_(n-1)'(t) + // as per polynomial parity, we can store coefficients of both P_(n-1) and P_n in the same array + final double[] p = new double[order + 2]; + p[1] = 1; + final double t2 = t * t; + for (int n = 1; n <= order; ++n) { + + // update and evaluate polynomial P_n(t) + double v = 0; + p[n + 1] = -n * p[n]; + for (int k = n + 1; k >= 0; k -= 2) { + v = v * t2 + p[k]; + if (k > 2) { + p[k - 2] = (k - 1) * p[k - 1] - (k - 3) * p[k - 3]; + } else if (k == 2) { + p[0] = p[1]; + } + } + if ((n & 0x1) == 0) { + v *= t; + } + + function[n] = v; + + } + } + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Compute inverse hyperbolic cosine of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param result array where result must be stored (for + * inverse hyperbolic cosine the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void acosh(final double[] operand, final int operandOffset, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + double[] function = new double[1 + order]; + final double x = operand[operandOffset]; + function[0] = FastMath.acosh(x); + if (order > 0) { + // the nth order derivative of acosh has the form: + // dn(acosh(x)/dxn = P_n(x) / [x^2 - 1]^((2n-1)/2) + // where P_n(x) is a degree n-1 polynomial with same parity as n-1 + // P_1(x) = 1, P_2(x) = -x, P_3(x) = 2x^2 + 1 ... + // the general recurrence relation for P_n is: + // P_n(x) = (x^2-1) P_(n-1)'(x) - (2n-3) x P_(n-1)(x) + // as per polynomial parity, we can store coefficients of both P_(n-1) and P_n in the same array + final double[] p = new double[order]; + p[0] = 1; + final double x2 = x * x; + final double f = 1.0 / (x2 - 1); + double coeff = FastMath.sqrt(f); + function[1] = coeff * p[0]; + for (int n = 2; n <= order; ++n) { + + // update and evaluate polynomial P_n(x) + double v = 0; + p[n - 1] = (1 - n) * p[n - 2]; + for (int k = n - 1; k >= 0; k -= 2) { + v = v * x2 + p[k]; + if (k > 2) { + p[k - 2] = (1 - k) * p[k - 1] + (k - 2 * n) * p[k - 3]; + } else if (k == 2) { + p[0] = -p[1]; + } + } + if ((n & 0x1) == 0) { + v *= x; + } + + coeff *= f; + function[n] = coeff * v; + + } + } + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Compute inverse hyperbolic sine of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param result array where result must be stored (for + * inverse hyperbolic sine the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void asinh(final double[] operand, final int operandOffset, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + double[] function = new double[1 + order]; + final double x = operand[operandOffset]; + function[0] = FastMath.asinh(x); + if (order > 0) { + // the nth order derivative of asinh has the form: + // dn(asinh(x)/dxn = P_n(x) / [x^2 + 1]^((2n-1)/2) + // where P_n(x) is a degree n-1 polynomial with same parity as n-1 + // P_1(x) = 1, P_2(x) = -x, P_3(x) = 2x^2 - 1 ... + // the general recurrence relation for P_n is: + // P_n(x) = (x^2+1) P_(n-1)'(x) - (2n-3) x P_(n-1)(x) + // as per polynomial parity, we can store coefficients of both P_(n-1) and P_n in the same array + final double[] p = new double[order]; + p[0] = 1; + final double x2 = x * x; + final double f = 1.0 / (1 + x2); + double coeff = FastMath.sqrt(f); + function[1] = coeff * p[0]; + for (int n = 2; n <= order; ++n) { + + // update and evaluate polynomial P_n(x) + double v = 0; + p[n - 1] = (1 - n) * p[n - 2]; + for (int k = n - 1; k >= 0; k -= 2) { + v = v * x2 + p[k]; + if (k > 2) { + p[k - 2] = (k - 1) * p[k - 1] + (k - 2 * n) * p[k - 3]; + } else if (k == 2) { + p[0] = p[1]; + } + } + if ((n & 0x1) == 0) { + v *= x; + } + + coeff *= f; + function[n] = coeff * v; + + } + } + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Compute inverse hyperbolic tangent of a derivative structure. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param result array where result must be stored (for + * inverse hyperbolic tangent the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void atanh(final double[] operand, final int operandOffset, + final double[] result, final int resultOffset) { + + // create the function value and derivatives + double[] function = new double[1 + order]; + final double x = operand[operandOffset]; + function[0] = FastMath.atanh(x); + if (order > 0) { + // the nth order derivative of atanh has the form: + // dn(atanh(x)/dxn = Q_n(x) / (1 - x^2)^n + // where Q_n(x) is a degree n-1 polynomial with same parity as n-1 + // Q_1(x) = 1, Q_2(x) = 2x, Q_3(x) = 6x^2 + 2 ... + // the general recurrence relation for Q_n is: + // Q_n(x) = (1-x^2) Q_(n-1)'(x) + 2(n-1) x Q_(n-1)(x) + // as per polynomial parity, we can store coefficients of both Q_(n-1) and Q_n in the same array + final double[] q = new double[order]; + q[0] = 1; + final double x2 = x * x; + final double f = 1.0 / (1 - x2); + double coeff = f; + function[1] = coeff * q[0]; + for (int n = 2; n <= order; ++n) { + + // update and evaluate polynomial Q_n(x) + double v = 0; + q[n - 1] = n * q[n - 2]; + for (int k = n - 1; k >= 0; k -= 2) { + v = v * x2 + q[k]; + if (k > 2) { + q[k - 2] = (k - 1) * q[k - 1] + (2 * n - k + 1) * q[k - 3]; + } else if (k == 2) { + q[0] = q[1]; + } + } + if ((n & 0x1) == 0) { + v *= x; + } + + coeff *= f; + function[n] = coeff * v; + + } + } + + // apply function composition + compose(operand, operandOffset, function, result, resultOffset); + + } + + /** Compute composition of a derivative structure by a function. + * @param operand array holding the operand + * @param operandOffset offset of the operand in its array + * @param f array of value and derivatives of the function at + * the current point (i.e. at {@code operand[operandOffset]}). + * @param result array where result must be stored (for + * composition the result array cannot be the input + * array) + * @param resultOffset offset of the result in its array + */ + public void compose(final double[] operand, final int operandOffset, final double[] f, + final double[] result, final int resultOffset) { + for (int i = 0; i < compIndirection.length; ++i) { + final int[][] mappingI = compIndirection[i]; + double r = 0; + for (int j = 0; j < mappingI.length; ++j) { + final int[] mappingIJ = mappingI[j]; + double product = mappingIJ[0] * f[mappingIJ[1]]; + for (int k = 2; k < mappingIJ.length; ++k) { + product *= operand[operandOffset + mappingIJ[k]]; + } + r += product; + } + result[resultOffset + i] = r; + } + } + + /** Evaluate Taylor expansion of a derivative structure. + * @param ds array holding the derivative structure + * @param dsOffset offset of the derivative structure in its array + * @param delta parameters offsets (Δx, Δy, ...) + * @return value of the Taylor expansion at x + Δx, y + Δy, ... + * @throws MathArithmeticException if factorials becomes too large + */ + public double taylor(final double[] ds, final int dsOffset, final double ... delta) + throws MathArithmeticException { + double value = 0; + for (int i = getSize() - 1; i >= 0; --i) { + final int[] orders = getPartialDerivativeOrders(i); + double term = ds[dsOffset + i]; + for (int k = 0; k < orders.length; ++k) { + if (orders[k] > 0) { + try { + term *= FastMath.pow(delta[k], orders[k]) / + CombinatoricsUtils.factorial(orders[k]); + } catch (NotPositiveException e) { + // this cannot happen + throw new MathInternalError(e); + } + } + } + value += term; + } + return value; + } + + /** Check rules set compatibility. + * @param compiler other compiler to check against instance + * @exception DimensionMismatchException if number of free parameters or orders are inconsistent + */ + public void checkCompatibility(final DSCompiler compiler) + throws DimensionMismatchException { + if (parameters != compiler.parameters) { + throw new DimensionMismatchException(parameters, compiler.parameters); + } + if (order != compiler.order) { + throw new DimensionMismatchException(order, compiler.order); + } + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/DerivativeStructure.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/DerivativeStructure.java new file mode 100644 index 000000000..51c6a6ca3 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/DerivativeStructure.java @@ -0,0 +1,1195 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.differentiation; + +import java.io.Serializable; + +import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException; +import com.fr.third.org.apache.commons.math3.exception.MathArithmeticException; +import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException; +import com.fr.third.org.apache.commons.math3.Field; +import com.fr.third.org.apache.commons.math3.FieldElement; +import com.fr.third.org.apache.commons.math3.RealFieldElement; +import com.fr.third.org.apache.commons.math3.util.FastMath; +import com.fr.third.org.apache.commons.math3.util.MathArrays; +import com.fr.third.org.apache.commons.math3.util.MathUtils; + +/** Class representing both the value and the differentials of a function. + *This class is the workhorse of the differentiation package.
+ *This class is an implementation of the extension to Rall's + * numbers described in Dan Kalman's paper Doubly + * Recursive Multivariate Automatic Differentiation, Mathematics Magazine, vol. 75, + * no. 3, June 2002. Rall's numbers are an extension to the real numbers used + * throughout mathematical expressions; they hold the derivative together with the + * value of a function. Dan Kalman's derivative structures hold all partial derivatives + * up to any specified order, with respect to any number of free parameters. Rall's + * numbers therefore can be seen as derivative structures for order one derivative and + * one free parameter, and real numbers can be seen as derivative structures with zero + * order derivative and no free parameters.
+ *{@link DerivativeStructure} instances can be used directly thanks to + * the arithmetic operators to the mathematical functions provided as + * methods by this class (+, -, *, /, %, sin, cos ...).
+ *Implementing complex expressions by hand using these classes is + * a tedious and error-prone task but has the advantage of having no limitation + * on the derivation order despite no requiring users to compute the derivatives by + * themselves. Implementing complex expression can also be done by developing computation + * code using standard primitive double values and to use {@link + * UnivariateFunctionDifferentiator differentiators} to create the {@link + * DerivativeStructure}-based instances. This method is simpler but may be limited in + * the accuracy and derivation orders and may be computationally intensive (this is + * typically the case for {@link FiniteDifferencesDifferentiator finite differences + * differentiator}.
+ *Instances of this class are guaranteed to be immutable.
+ * @see DSCompiler + * @since 3.1 + */ +public class DerivativeStructure implements RealFieldElementInstances built using this constructor are considered + * to be the free variables with respect to which differentials + * are computed. As such, their differential with respect to + * themselves is +1.
+ * @param parameters number of free parameters + * @param order derivation order + * @param index index of the variable (from 0 to {@code parameters - 1}) + * @param value value of the variable + * @exception NumberIsTooLargeException if {@code index >= parameters}. + * @see #DerivativeStructure(int, int, double) + */ + public DerivativeStructure(final int parameters, final int order, + final int index, final double value) + throws NumberIsTooLargeException { + this(parameters, order, value); + + if (index >= parameters) { + throw new NumberIsTooLargeException(index, parameters, false); + } + + if (order > 0) { + // the derivative of the variable with respect to itself is 1. + data[DSCompiler.getCompiler(index, order).getSize()] = 1.0; + } + + } + + /** Linear combination constructor. + * The derivative structure built will be a1 * ds1 + a2 * ds2 + * @param a1 first scale factor + * @param ds1 first base (unscaled) derivative structure + * @param a2 second scale factor + * @param ds2 second base (unscaled) derivative structure + * @exception DimensionMismatchException if number of free parameters or orders are inconsistent + */ + public DerivativeStructure(final double a1, final DerivativeStructure ds1, + final double a2, final DerivativeStructure ds2) + throws DimensionMismatchException { + this(ds1.compiler); + compiler.checkCompatibility(ds2.compiler); + compiler.linearCombination(a1, ds1.data, 0, a2, ds2.data, 0, data, 0); + } + + /** Linear combination constructor. + * The derivative structure built will be a1 * ds1 + a2 * ds2 + a3 * ds3 + * @param a1 first scale factor + * @param ds1 first base (unscaled) derivative structure + * @param a2 second scale factor + * @param ds2 second base (unscaled) derivative structure + * @param a3 third scale factor + * @param ds3 third base (unscaled) derivative structure + * @exception DimensionMismatchException if number of free parameters or orders are inconsistent + */ + public DerivativeStructure(final double a1, final DerivativeStructure ds1, + final double a2, final DerivativeStructure ds2, + final double a3, final DerivativeStructure ds3) + throws DimensionMismatchException { + this(ds1.compiler); + compiler.checkCompatibility(ds2.compiler); + compiler.checkCompatibility(ds3.compiler); + compiler.linearCombination(a1, ds1.data, 0, a2, ds2.data, 0, a3, ds3.data, 0, data, 0); + } + + /** Linear combination constructor. + * The derivative structure built will be a1 * ds1 + a2 * ds2 + a3 * ds3 + a4 * ds4 + * @param a1 first scale factor + * @param ds1 first base (unscaled) derivative structure + * @param a2 second scale factor + * @param ds2 second base (unscaled) derivative structure + * @param a3 third scale factor + * @param ds3 third base (unscaled) derivative structure + * @param a4 fourth scale factor + * @param ds4 fourth base (unscaled) derivative structure + * @exception DimensionMismatchException if number of free parameters or orders are inconsistent + */ + public DerivativeStructure(final double a1, final DerivativeStructure ds1, + final double a2, final DerivativeStructure ds2, + final double a3, final DerivativeStructure ds3, + final double a4, final DerivativeStructure ds4) + throws DimensionMismatchException { + this(ds1.compiler); + compiler.checkCompatibility(ds2.compiler); + compiler.checkCompatibility(ds3.compiler); + compiler.checkCompatibility(ds4.compiler); + compiler.linearCombination(a1, ds1.data, 0, a2, ds2.data, 0, + a3, ds3.data, 0, a4, ds4.data, 0, + data, 0); + } + + /** Build an instance from all its derivatives. + * @param parameters number of free parameters + * @param order derivation order + * @param derivatives derivatives sorted according to + * {@link DSCompiler#getPartialDerivativeIndex(int...)} + * @exception DimensionMismatchException if derivatives array does not match the + * {@link DSCompiler#getSize() size} expected by the compiler + * @throws NumberIsTooLargeException if order is too large + * @see #getAllDerivatives() + */ + public DerivativeStructure(final int parameters, final int order, final double ... derivatives) + throws DimensionMismatchException, NumberIsTooLargeException { + this(parameters, order); + if (derivatives.length != data.length) { + throw new DimensionMismatchException(derivatives.length, data.length); + } + System.arraycopy(derivatives, 0, data, 0, data.length); + } + + /** Copy constructor. + * @param ds instance to copy + */ + private DerivativeStructure(final DerivativeStructure ds) { + this.compiler = ds.compiler; + this.data = ds.data.clone(); + } + + /** Get the number of free parameters. + * @return number of free parameters + */ + public int getFreeParameters() { + return compiler.getFreeParameters(); + } + + /** Get the derivation order. + * @return derivation order + */ + public int getOrder() { + return compiler.getOrder(); + } + + /** Create a constant compatible with instance order and number of parameters. + *+ * This method is a convenience factory method, it simply calls + * {@code new DerivativeStructure(getFreeParameters(), getOrder(), c)} + *
+ * @param c value of the constant + * @return a constant compatible with instance order and number of parameters + * @see #DerivativeStructure(int, int, double) + * @since 3.3 + */ + public DerivativeStructure createConstant(final double c) { + return new DerivativeStructure(getFreeParameters(), getOrder(), c); + } + + /** {@inheritDoc} + * @since 3.2 + */ + public double getReal() { + return data[0]; + } + + /** Get the value part of the derivative structure. + * @return value part of the derivative structure + * @see #getPartialDerivative(int...) + */ + public double getValue() { + return data[0]; + } + + /** Get a partial derivative. + * @param orders derivation orders with respect to each variable (if all orders are 0, + * the value is returned) + * @return partial derivative + * @see #getValue() + * @exception DimensionMismatchException if the numbers of variables does not + * match the instance + * @exception NumberIsTooLargeException if sum of derivation orders is larger + * than the instance limits + */ + public double getPartialDerivative(final int ... orders) + throws DimensionMismatchException, NumberIsTooLargeException { + return data[compiler.getPartialDerivativeIndex(orders)]; + } + + /** Get all partial derivatives. + * @return a fresh copy of partial derivatives, in an array sorted according to + * {@link DSCompiler#getPartialDerivativeIndex(int...)} + */ + public double[] getAllDerivatives() { + return data.clone(); + } + + /** {@inheritDoc} + * @since 3.2 + */ + public DerivativeStructure add(final double a) { + final DerivativeStructure ds = new DerivativeStructure(this); + ds.data[0] += a; + return ds; + } + + /** {@inheritDoc} + * @exception DimensionMismatchException if number of free parameters + * or orders do not match + */ + public DerivativeStructure add(final DerivativeStructure a) + throws DimensionMismatchException { + compiler.checkCompatibility(a.compiler); + final DerivativeStructure ds = new DerivativeStructure(this); + compiler.add(data, 0, a.data, 0, ds.data, 0); + return ds; + } + + /** {@inheritDoc} + * @since 3.2 + */ + public DerivativeStructure subtract(final double a) { + return add(-a); + } + + /** {@inheritDoc} + * @exception DimensionMismatchException if number of free parameters + * or orders do not match + */ + public DerivativeStructure subtract(final DerivativeStructure a) + throws DimensionMismatchException { + compiler.checkCompatibility(a.compiler); + final DerivativeStructure ds = new DerivativeStructure(this); + compiler.subtract(data, 0, a.data, 0, ds.data, 0); + return ds; + } + + /** {@inheritDoc} */ + public DerivativeStructure multiply(final int n) { + return multiply((double) n); + } + + /** {@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) { + ds.data[i] *= a; + } + return ds; + } + + /** {@inheritDoc} + * @exception DimensionMismatchException if number of free parameters + * or orders do not match + */ + public DerivativeStructure multiply(final DerivativeStructure a) + throws DimensionMismatchException { + compiler.checkCompatibility(a.compiler); + final DerivativeStructure result = new DerivativeStructure(compiler); + compiler.multiply(data, 0, a.data, 0, result.data, 0); + return result; + } + + /** {@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) { + ds.data[i] /= a; + } + return ds; + } + + /** {@inheritDoc} + * @exception DimensionMismatchException if number of free parameters + * or orders do not match + */ + public DerivativeStructure divide(final DerivativeStructure a) + throws DimensionMismatchException { + compiler.checkCompatibility(a.compiler); + final DerivativeStructure result = new DerivativeStructure(compiler); + compiler.divide(data, 0, a.data, 0, result.data, 0); + return result; + } + + /** {@inheritDoc} */ + public DerivativeStructure remainder(final double a) { + final DerivativeStructure ds = new DerivativeStructure(this); + ds.data[0] = FastMath.IEEEremainder(ds.data[0], a); + return ds; + } + + /** {@inheritDoc} + * @exception DimensionMismatchException if number of free parameters + * or orders do not match + * @since 3.2 + */ + public DerivativeStructure remainder(final DerivativeStructure a) + throws DimensionMismatchException { + compiler.checkCompatibility(a.compiler); + final DerivativeStructure result = new DerivativeStructure(compiler); + compiler.remainder(data, 0, a.data, 0, result.data, 0); + return result; + } + + /** {@inheritDoc} */ + public DerivativeStructure negate() { + final DerivativeStructure ds = new DerivativeStructure(compiler); + for (int i = 0; i < ds.data.length; ++i) { + ds.data[i] = -data[i]; + } + return ds; + } + + /** {@inheritDoc} + * @since 3.2 + */ + public DerivativeStructure abs() { + if (Double.doubleToLongBits(data[0]) < 0) { + // we use the bits representation to also handle -0.0 + return negate(); + } else { + return this; + } + } + + /** {@inheritDoc} + * @since 3.2 + */ + public DerivativeStructure ceil() { + return new DerivativeStructure(compiler.getFreeParameters(), + compiler.getOrder(), + FastMath.ceil(data[0])); + } + + /** {@inheritDoc} + * @since 3.2 + */ + public DerivativeStructure floor() { + return new DerivativeStructure(compiler.getFreeParameters(), + compiler.getOrder(), + FastMath.floor(data[0])); + } + + /** {@inheritDoc} + * @since 3.2 + */ + public DerivativeStructure rint() { + return new DerivativeStructure(compiler.getFreeParameters(), + compiler.getOrder(), + FastMath.rint(data[0])); + } + + /** {@inheritDoc} */ + public long round() { + return FastMath.round(data[0]); + } + + /** {@inheritDoc} + * @since 3.2 + */ + public DerivativeStructure signum() { + return new DerivativeStructure(compiler.getFreeParameters(), + compiler.getOrder(), + FastMath.signum(data[0])); + } + + /** {@inheritDoc} + * @since 3.2 + */ + public DerivativeStructure copySign(final DerivativeStructure sign){ + long m = Double.doubleToLongBits(data[0]); + long s = Double.doubleToLongBits(sign.data[0]); + if ((m >= 0 && s >= 0) || (m < 0 && s < 0)) { // Sign is currently OK + return this; + } + return negate(); // flip sign + } + + /** {@inheritDoc} + * @since 3.2 + */ + public DerivativeStructure copySign(final double sign) { + long m = Double.doubleToLongBits(data[0]); + long s = Double.doubleToLongBits(sign); + if ((m >= 0 && s >= 0) || (m < 0 && s < 0)) { // Sign is currently OK + return this; + } + return negate(); // flip sign + } + + /** + * Return the exponent of the instance value, removing the bias. + *+ * For double numbers of the form 2x, the unbiased + * exponent is exactly x. + *
+ * @return exponent for instance in IEEE754 representation, without bias + */ + public int getExponent() { + return FastMath.getExponent(data[0]); + } + + /** {@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) { + ds.data[i] = FastMath.scalb(data[i], n); + } + return ds; + } + + /** {@inheritDoc} + * @exception DimensionMismatchException if number of free parameters + * or orders do not match + * @since 3.2 + */ + public DerivativeStructure hypot(final DerivativeStructure y) + throws DimensionMismatchException { + + compiler.checkCompatibility(y.compiler); + + if (Double.isInfinite(data[0]) || Double.isInfinite(y.data[0])) { + return new DerivativeStructure(compiler.getFreeParameters(), + compiler.getFreeParameters(), + Double.POSITIVE_INFINITY); + } else if (Double.isNaN(data[0]) || Double.isNaN(y.data[0])) { + return new DerivativeStructure(compiler.getFreeParameters(), + compiler.getFreeParameters(), + Double.NaN); + } else { + + final int expX = getExponent(); + final int expY = y.getExponent(); + if (expX > expY + 27) { + // y is neglectible with respect to x + return abs(); + } else if (expY > expX + 27) { + // x is neglectible with respect to y + return y.abs(); + } else { + + // find an intermediate scale to avoid both overflow and underflow + final int middleExp = (expX + expY) / 2; + + // scale parameters without losing precision + final DerivativeStructure scaledX = scalb(-middleExp); + final DerivativeStructure scaledY = y.scalb(-middleExp); + + // compute scaled hypotenuse + final DerivativeStructure scaledH = + scaledX.multiply(scaledX).add(scaledY.multiply(scaledY)).sqrt(); + + // remove scaling + return scaledH.scalb(middleExp); + + } + + } + } + + /** + * Returns the hypotenuse of a triangle with sides {@code x} and {@code y} + * - sqrt(x2 +y2) + * avoiding intermediate overflow or underflow. + * + *+ * Derivative structures are considered equal if they have the same number + * of free parameters, the same derivation order, and the same derivatives. + *
+ * @param other Object to test for equality to this + * @return true if two derivative structures are equal + * @since 3.2 + */ + @Override + public boolean equals(Object other) { + + if (this == other) { + return true; + } + + if (other instanceof DerivativeStructure) { + final DerivativeStructure rhs = (DerivativeStructure)other; + return (getFreeParameters() == rhs.getFreeParameters()) && + (getOrder() == rhs.getOrder()) && + MathArrays.equals(data, rhs.data); + } + + return false; + + } + + /** + * Get a hashCode for the derivative structure. + * @return a hash code value for this object + * @since 3.2 + */ + @Override + public int hashCode() { + return 227 + 229 * getFreeParameters() + 233 * getOrder() + 239 * MathUtils.hash(data); + } + + /** + * Replace the instance with a data transfer object for serialization. + * @return data transfer object that will be serialized + */ + private Object writeReplace() { + return new DataTransferObject(compiler.getFreeParameters(), compiler.getOrder(), data); + } + + /** Internal class used only for serialization. */ + private static class DataTransferObject implements Serializable { + + /** Serializable UID. */ + private static final long serialVersionUID = 20120730L; + + /** Number of variables. + * @serial + */ + private final int variables; + + /** Derivation order. + * @serial + */ + private final int order; + + /** Partial derivatives. + * @serial + */ + private final double[] data; + + /** Simple constructor. + * @param variables number of variables + * @param order derivation order + * @param data partial derivatives + */ + DataTransferObject(final int variables, final int order, final double[] data) { + this.variables = variables; + this.order = order; + this.data = data; + } + + /** Replace the deserialized data transfer object with a {@link DerivativeStructure}. + * @return replacement {@link DerivativeStructure} + */ + private Object readResolve() { + return new DerivativeStructure(variables, order, data); + } + + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/FiniteDifferencesDifferentiator.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/FiniteDifferencesDifferentiator.java new file mode 100644 index 000000000..02f3afe00 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/FiniteDifferencesDifferentiator.java @@ -0,0 +1,384 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.differentiation; + +import java.io.Serializable; + +import com.fr.third.org.apache.commons.math3.exception.MathIllegalArgumentException; +import com.fr.third.org.apache.commons.math3.exception.NotPositiveException; +import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException; +import com.fr.third.org.apache.commons.math3.exception.NumberIsTooSmallException; +import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction; +import com.fr.third.org.apache.commons.math3.analysis.UnivariateMatrixFunction; +import com.fr.third.org.apache.commons.math3.analysis.UnivariateVectorFunction; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** Univariate functions differentiator using finite differences. + *+ * This class creates some wrapper objects around regular + * {@link UnivariateFunction univariate functions} (or {@link + * UnivariateVectorFunction univariate vector functions} or {@link + * UnivariateMatrixFunction univariate matrix functions}). These + * wrapper objects compute derivatives in addition to function + * values. + *
+ *+ * The wrapper objects work by calling the underlying function on + * a sampling grid around the current point and performing polynomial + * interpolation. A finite differences scheme with n points is + * theoretically able to compute derivatives up to order n-1, but + * it is generally better to have a slight margin. The step size must + * also be small enough in order for the polynomial approximation to + * be good in the current point neighborhood, but it should not be too + * small because numerical instability appears quickly (there are several + * differences of close points). Choosing the number of points and + * the step size is highly problem dependent. + *
+ *+ * As an example of good and bad settings, lets consider the quintic + * polynomial function {@code f(x) = (x-1)*(x-0.5)*x*(x+0.5)*(x+1)}. + * Since it is a polynomial, finite differences with at least 6 points + * should theoretically recover the exact same polynomial and hence + * compute accurate derivatives for any order. However, due to numerical + * errors, we get the following results for a 7 points finite differences + * for abscissae in the [-10, 10] range: + *
+ * This example shows that the small step size is really bad, even simply + * for second order derivative!
+ * + * @since 3.1 + */ +public class FiniteDifferencesDifferentiator + implements UnivariateFunctionDifferentiator, UnivariateVectorFunctionDifferentiator, + UnivariateMatrixFunctionDifferentiator, Serializable { + + /** Serializable UID. */ + private static final long serialVersionUID = 20120917L; + + /** Number of points to use. */ + private final int nbPoints; + + /** Step size. */ + private final double stepSize; + + /** Half sample span. */ + private final double halfSampleSpan; + + /** Lower bound for independent variable. */ + private final double tMin; + + /** Upper bound for independent variable. */ + private final double tMax; + + /** + * Build a differentiator with number of points and step size when independent variable is unbounded. + *+ * Beware that wrong settings for the finite differences differentiator + * can lead to highly unstable and inaccurate results, especially for + * high derivation orders. Using very small step sizes is often a + * bad idea. + *
+ * @param nbPoints number of points to use + * @param stepSize step size (gap between each point) + * @exception NotPositiveException if {@code stepsize <= 0} (note that + * {@link NotPositiveException} extends {@link NumberIsTooSmallException}) + * @exception NumberIsTooSmallException {@code nbPoint <= 1} + */ + public FiniteDifferencesDifferentiator(final int nbPoints, final double stepSize) + throws NotPositiveException, NumberIsTooSmallException { + this(nbPoints, stepSize, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY); + } + + /** + * Build a differentiator with number of points and step size when independent variable is bounded. + *+ * When the independent variable is bounded (tLower < t < tUpper), the sampling + * points used for differentiation will be adapted to ensure the constraint holds + * even near the boundaries. This means the sample will not be centered anymore in + * these cases. At an extreme case, computing derivatives exactly at the lower bound + * will lead the sample to be entirely on the right side of the derivation point. + *
+ *+ * Note that the boundaries are considered to be excluded for function evaluation. + *
+ *+ * Beware that wrong settings for the finite differences differentiator + * can lead to highly unstable and inaccurate results, especially for + * high derivation orders. Using very small step sizes is often a + * bad idea. + *
+ * @param nbPoints number of points to use + * @param stepSize step size (gap between each point) + * @param tLower lower bound for independent variable (may be {@code Double.NEGATIVE_INFINITY} + * if there are no lower bounds) + * @param tUpper upper bound for independent variable (may be {@code Double.POSITIVE_INFINITY} + * if there are no upper bounds) + * @exception NotPositiveException if {@code stepsize <= 0} (note that + * {@link NotPositiveException} extends {@link NumberIsTooSmallException}) + * @exception NumberIsTooSmallException {@code nbPoint <= 1} + * @exception NumberIsTooLargeException {@code stepSize * (nbPoints - 1) >= tUpper - tLower} + */ + public FiniteDifferencesDifferentiator(final int nbPoints, final double stepSize, + final double tLower, final double tUpper) + throws NotPositiveException, NumberIsTooSmallException, NumberIsTooLargeException { + + if (nbPoints <= 1) { + throw new NumberIsTooSmallException(stepSize, 1, false); + } + this.nbPoints = nbPoints; + + if (stepSize <= 0) { + throw new NotPositiveException(stepSize); + } + this.stepSize = stepSize; + + halfSampleSpan = 0.5 * stepSize * (nbPoints - 1); + if (2 * halfSampleSpan >= tUpper - tLower) { + throw new NumberIsTooLargeException(2 * halfSampleSpan, tUpper - tLower, false); + } + final double safety = FastMath.ulp(halfSampleSpan); + this.tMin = tLower + halfSampleSpan + safety; + this.tMax = tUpper - halfSampleSpan - safety; + + } + + /** + * Get the number of points to use. + * @return number of points to use + */ + public int getNbPoints() { + return nbPoints; + } + + /** + * Get the step size. + * @return step size + */ + public double getStepSize() { + return stepSize; + } + + /** + * Evaluate derivatives from a sample. + *+ * Evaluation is done using divided differences. + *
+ * @param t evaluation abscissa value and derivatives + * @param t0 first sample point abscissa + * @param y function values sample {@code y[i] = f(t[i]) = f(t0 + i * stepSize)} + * @return value and derivatives at {@code t} + * @exception NumberIsTooLargeException if the requested derivation order + * is larger or equal to the number of points + */ + private DerivativeStructure evaluate(final DerivativeStructure t, final double t0, + final double[] y) + throws NumberIsTooLargeException { + + // create divided differences diagonal arrays + final double[] top = new double[nbPoints]; + final double[] bottom = new double[nbPoints]; + + for (int i = 0; i < nbPoints; ++i) { + + // update the bottom diagonal of the divided differences array + bottom[i] = y[i]; + for (int j = 1; j <= i; ++j) { + bottom[i - j] = (bottom[i - j + 1] - bottom[i - j]) / (j * stepSize); + } + + // update the top diagonal of the divided differences array + top[i] = bottom[0]; + + } + + // evaluate interpolation polynomial (represented by top diagonal) at t + final int order = t.getOrder(); + final int parameters = t.getFreeParameters(); + final double[] derivatives = t.getAllDerivatives(); + final double dt0 = t.getValue() - t0; + DerivativeStructure interpolation = new DerivativeStructure(parameters, order, 0.0); + DerivativeStructure monomial = null; + for (int i = 0; i < nbPoints; ++i) { + if (i == 0) { + // start with monomial(t) = 1 + monomial = new DerivativeStructure(parameters, order, 1.0); + } else { + // monomial(t) = (t - t0) * (t - t1) * ... * (t - t(i-1)) + derivatives[0] = dt0 - (i - 1) * stepSize; + final DerivativeStructure deltaX = new DerivativeStructure(parameters, order, derivatives); + monomial = monomial.multiply(deltaX); + } + interpolation = interpolation.add(monomial.multiply(top[i])); + } + + return interpolation; + + } + + /** {@inheritDoc} + *The returned object cannot compute derivatives to arbitrary orders. The + * value function will throw a {@link NumberIsTooLargeException} if the requested + * derivation order is larger or equal to the number of points. + *
+ */ + public UnivariateDifferentiableFunction differentiate(final UnivariateFunction function) { + return new UnivariateDifferentiableFunction() { + + /** {@inheritDoc} */ + public double value(final double x) throws MathIllegalArgumentException { + return function.value(x); + } + + /** {@inheritDoc} */ + public DerivativeStructure value(final DerivativeStructure t) + throws MathIllegalArgumentException { + + // check we can achieve the requested derivation order with the sample + if (t.getOrder() >= nbPoints) { + throw new NumberIsTooLargeException(t.getOrder(), nbPoints, false); + } + + // compute sample position, trying to be centered if possible + final double t0 = FastMath.max(FastMath.min(t.getValue(), tMax), tMin) - halfSampleSpan; + + // compute sample points + final double[] y = new double[nbPoints]; + for (int i = 0; i < nbPoints; ++i) { + y[i] = function.value(t0 + i * stepSize); + } + + // evaluate derivatives + return evaluate(t, t0, y); + + } + + }; + } + + /** {@inheritDoc} + *The returned object cannot compute derivatives to arbitrary orders. The + * value function will throw a {@link NumberIsTooLargeException} if the requested + * derivation order is larger or equal to the number of points. + *
+ */ + public UnivariateDifferentiableVectorFunction differentiate(final UnivariateVectorFunction function) { + return new UnivariateDifferentiableVectorFunction() { + + /** {@inheritDoc} */ + public double[]value(final double x) throws MathIllegalArgumentException { + return function.value(x); + } + + /** {@inheritDoc} */ + public DerivativeStructure[] value(final DerivativeStructure t) + throws MathIllegalArgumentException { + + // check we can achieve the requested derivation order with the sample + if (t.getOrder() >= nbPoints) { + throw new NumberIsTooLargeException(t.getOrder(), nbPoints, false); + } + + // compute sample position, trying to be centered if possible + final double t0 = FastMath.max(FastMath.min(t.getValue(), tMax), tMin) - halfSampleSpan; + + // compute sample points + double[][] y = null; + for (int i = 0; i < nbPoints; ++i) { + final double[] v = function.value(t0 + i * stepSize); + if (i == 0) { + y = new double[v.length][nbPoints]; + } + for (int j = 0; j < v.length; ++j) { + y[j][i] = v[j]; + } + } + + // evaluate derivatives + final DerivativeStructure[] value = new DerivativeStructure[y.length]; + for (int j = 0; j < value.length; ++j) { + value[j] = evaluate(t, t0, y[j]); + } + + return value; + + } + + }; + } + + /** {@inheritDoc} + *The returned object cannot compute derivatives to arbitrary orders. The + * value function will throw a {@link NumberIsTooLargeException} if the requested + * derivation order is larger or equal to the number of points. + *
+ */ + public UnivariateDifferentiableMatrixFunction differentiate(final UnivariateMatrixFunction function) { + return new UnivariateDifferentiableMatrixFunction() { + + /** {@inheritDoc} */ + public double[][] value(final double x) throws MathIllegalArgumentException { + return function.value(x); + } + + /** {@inheritDoc} */ + public DerivativeStructure[][] value(final DerivativeStructure t) + throws MathIllegalArgumentException { + + // check we can achieve the requested derivation order with the sample + if (t.getOrder() >= nbPoints) { + throw new NumberIsTooLargeException(t.getOrder(), nbPoints, false); + } + + // compute sample position, trying to be centered if possible + final double t0 = FastMath.max(FastMath.min(t.getValue(), tMax), tMin) - halfSampleSpan; + + // compute sample points + double[][][] y = null; + for (int i = 0; i < nbPoints; ++i) { + final double[][] v = function.value(t0 + i * stepSize); + if (i == 0) { + y = new double[v.length][v[0].length][nbPoints]; + } + for (int j = 0; j < v.length; ++j) { + for (int k = 0; k < v[j].length; ++k) { + y[j][k][i] = v[j][k]; + } + } + } + + // evaluate derivatives + final DerivativeStructure[][] value = new DerivativeStructure[y.length][y[0].length]; + for (int j = 0; j < value.length; ++j) { + for (int k = 0; k < y[j].length; ++k) { + value[j][k] = evaluate(t, t0, y[j][k]); + } + } + + return value; + + } + + }; + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/GradientFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/GradientFunction.java new file mode 100644 index 000000000..3d1272186 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/GradientFunction.java @@ -0,0 +1,65 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.differentiation; + +import com.fr.third.org.apache.commons.math3.analysis.MultivariateVectorFunction; + +/** Class representing the gradient of a multivariate function. + *+ * The vectorial components of the function represent the derivatives + * with respect to each function parameters. + *
+ * @since 3.1 + */ +public class GradientFunction implements MultivariateVectorFunction { + + /** Underlying real-valued function. */ + private final MultivariateDifferentiableFunction f; + + /** Simple constructor. + * @param f underlying real-valued function + */ + public GradientFunction(final MultivariateDifferentiableFunction f) { + this.f = f; + } + + /** {@inheritDoc} */ + public double[] value(double[] point) { + + // set up parameters + final DerivativeStructure[] dsX = new DerivativeStructure[point.length]; + for (int i = 0; i < point.length; ++i) { + dsX[i] = new DerivativeStructure(point.length, 1, i, point[i]); + } + + // compute the derivatives + final DerivativeStructure dsY = f.value(dsX); + + // extract the gradient + final double[] y = new double[point.length]; + final int[] orders = new int[point.length]; + for (int i = 0; i < point.length; ++i) { + orders[i] = 1; + y[i] = dsY.getPartialDerivative(orders); + orders[i] = 0; + } + + return y; + + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/JacobianFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/JacobianFunction.java new file mode 100644 index 000000000..68c12c0ea --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/JacobianFunction.java @@ -0,0 +1,69 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.differentiation; + +import com.fr.third.org.apache.commons.math3.analysis.MultivariateMatrixFunction; + +/** Class representing the Jacobian of a multivariate vector function. + *+ * The rows iterate on the model functions while the columns iterate on the parameters; thus, + * the numbers of rows is equal to the dimension of the underlying function vector + * value and the number of columns is equal to the number of free parameters of + * the underlying function. + *
+ * @since 3.1 + */ +public class JacobianFunction implements MultivariateMatrixFunction { + + /** Underlying vector-valued function. */ + private final MultivariateDifferentiableVectorFunction f; + + /** Simple constructor. + * @param f underlying vector-valued function + */ + public JacobianFunction(final MultivariateDifferentiableVectorFunction f) { + this.f = f; + } + + /** {@inheritDoc} */ + public double[][] value(double[] point) { + + // set up parameters + final DerivativeStructure[] dsX = new DerivativeStructure[point.length]; + for (int i = 0; i < point.length; ++i) { + dsX[i] = new DerivativeStructure(point.length, 1, i, point[i]); + } + + // compute the derivatives + final DerivativeStructure[] dsY = f.value(dsX); + + // extract the Jacobian + final double[][] y = new double[dsY.length][point.length]; + final int[] orders = new int[point.length]; + for (int i = 0; i < dsY.length; ++i) { + for (int j = 0; j < point.length; ++j) { + orders[j] = 1; + y[i][j] = dsY[i].getPartialDerivative(orders); + orders[j] = 0; + } + } + + return y; + + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/MultivariateDifferentiableFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/MultivariateDifferentiableFunction.java new file mode 100644 index 000000000..c8efc5781 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/MultivariateDifferentiableFunction.java @@ -0,0 +1,42 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis.differentiation; + +import com.fr.third.org.apache.commons.math3.exception.MathIllegalArgumentException; +import com.fr.third.org.apache.commons.math3.analysis.MultivariateFunction; + +/** + * Extension of {@link MultivariateFunction} representing a + * multivariate differentiable real function. + * @since 3.1 + */ +public interface MultivariateDifferentiableFunction extends MultivariateFunction { + + /** + * Compute the value for the function at the given point. + * + * @param point Point at which the function must be evaluated. + * @return the function value for the given point. + * @exception MathIllegalArgumentException if {@code point} does not + * satisfy the function's constraints (wrong dimension, argument out of bound, + * or unsupported derivative order for example) + */ + DerivativeStructure value(DerivativeStructure[] point) + throws MathIllegalArgumentException; + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/MultivariateDifferentiableVectorFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/MultivariateDifferentiableVectorFunction.java new file mode 100644 index 000000000..acf608583 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/MultivariateDifferentiableVectorFunction.java @@ -0,0 +1,43 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis.differentiation; + +import com.fr.third.org.apache.commons.math3.exception.MathIllegalArgumentException; +import com.fr.third.org.apache.commons.math3.analysis.MultivariateVectorFunction; + + +/** + * Extension of {@link MultivariateVectorFunction} representing a + * multivariate differentiable vectorial function. + * @since 3.1 + */ +public interface MultivariateDifferentiableVectorFunction + extends MultivariateVectorFunction { + + /** + * Compute the value for the function at the given point. + * @param point point at which the function must be evaluated + * @return function value for the given point + * @exception MathIllegalArgumentException if {@code point} does not + * satisfy the function's constraints (wrong dimension, argument out of bound, + * or unsupported derivative order for example) + */ + DerivativeStructure[] value(DerivativeStructure[] point) + throws MathIllegalArgumentException; + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/SparseGradient.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/SparseGradient.java new file mode 100644 index 000000000..bcf9798d8 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/SparseGradient.java @@ -0,0 +1,877 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.differentiation; + +import java.io.Serializable; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException; +import com.fr.third.org.apache.commons.math3.Field; +import com.fr.third.org.apache.commons.math3.FieldElement; +import com.fr.third.org.apache.commons.math3.RealFieldElement; +import com.fr.third.org.apache.commons.math3.util.FastMath; +import com.fr.third.org.apache.commons.math3.util.MathArrays; +import com.fr.third.org.apache.commons.math3.util.MathUtils; +import com.fr.third.org.apache.commons.math3.util.Precision; + +/** + * First derivative computation with large number of variables. + *+ * This class plays a similar role to {@link DerivativeStructure}, with + * a focus on efficiency when dealing with large number of independent variables + * and most computation depend only on a few of them, and when only first derivative + * is desired. When these conditions are met, this class should be much faster than + * {@link DerivativeStructure} and use less memory. + *
+ * + * @since 3.3 + */ +public class SparseGradient implements RealFieldElement+ * This method is designed to be faster when used multiple times in a loop. + *
+ *+ * The instance is changed here, in order to not change the + * instance the {@link #add(SparseGradient)} method should + * be used. + *
+ * @param a instance to add + */ + public void addInPlace(final SparseGradient a) { + value += a.value; + for (final Map.Entry+ * This method is designed to be faster when used multiple times in a loop. + *
+ *+ * The instance is changed here, in order to not change the + * instance the {@link #add(SparseGradient)} method should + * be used. + *
+ * @param a instance to multiply + */ + public void multiplyInPlace(final SparseGradient a) { + // Derivatives. + for (Map.Entry+ * Sparse gradients are considered equal if they have the same value + * and the same derivatives. + *
+ * @param other Object to test for equality to this + * @return true if two sparse gradients are equal + */ + @Override + public boolean equals(Object other) { + + if (this == other) { + return true; + } + + if (other instanceof SparseGradient) { + final SparseGradient rhs = (SparseGradient)other; + if (!Precision.equals(value, rhs.value, 1)) { + return false; + } + if (derivatives.size() != rhs.derivatives.size()) { + return false; + } + for (final Map.EntryThis interface represents a simple function which computes + * both the value and the first derivative of a mathematical function. + * The derivative is computed with respect to the input variable.
+ * @see UnivariateDifferentiableFunction + * @see UnivariateFunctionDifferentiator + * @since 3.1 + */ +public interface UnivariateDifferentiableFunction extends UnivariateFunction { + + /** Simple mathematical function. + *{@link UnivariateDifferentiableFunction} classes compute both the + * value and the first derivative of the function.
+ * @param t function input value + * @return function result + * @exception DimensionMismatchException if t is inconsistent with the + * function's free parameters or order + */ + DerivativeStructure value(DerivativeStructure t) + throws DimensionMismatchException; + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/UnivariateDifferentiableMatrixFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/UnivariateDifferentiableMatrixFunction.java new file mode 100644 index 000000000..15eca0426 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/UnivariateDifferentiableMatrixFunction.java @@ -0,0 +1,40 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.differentiation; + +import com.fr.third.org.apache.commons.math3.exception.MathIllegalArgumentException; +import com.fr.third.org.apache.commons.math3.analysis.UnivariateMatrixFunction; + +/** + * Extension of {@link UnivariateMatrixFunction} representing a univariate differentiable matrix function. + * + * @since 3.1 + */ +public interface UnivariateDifferentiableMatrixFunction + extends UnivariateMatrixFunction { + + /** + * Compute the value for the function. + * @param x the point for which the function value should be computed + * @return the value + * @exception MathIllegalArgumentException if {@code x} does not + * satisfy the function's constraints (argument out of bound, or unsupported + * derivative order for example) + */ + DerivativeStructure[][] value(DerivativeStructure x) throws MathIllegalArgumentException; + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/UnivariateDifferentiableVectorFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/UnivariateDifferentiableVectorFunction.java new file mode 100644 index 000000000..69f145560 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/UnivariateDifferentiableVectorFunction.java @@ -0,0 +1,40 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.differentiation; + +import com.fr.third.org.apache.commons.math3.exception.MathIllegalArgumentException; +import com.fr.third.org.apache.commons.math3.analysis.UnivariateVectorFunction; + +/** + * Extension of {@link UnivariateVectorFunction} representing a univariate differentiable vectorial function. + * + * @since 3.1 + */ +public interface UnivariateDifferentiableVectorFunction + extends UnivariateVectorFunction { + + /** + * Compute the value for the function. + * @param x the point for which the function value should be computed + * @return the value + * @exception MathIllegalArgumentException if {@code x} does not + * satisfy the function's constraints (argument out of bound, or unsupported + * derivative order for example) + */ + DerivativeStructure[] value(DerivativeStructure x) throws MathIllegalArgumentException; + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/UnivariateFunctionDifferentiator.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/UnivariateFunctionDifferentiator.java new file mode 100644 index 000000000..f218c3589 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/UnivariateFunctionDifferentiator.java @@ -0,0 +1,33 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.differentiation; + +import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction; + +/** Interface defining the function differentiation operation. + * @since 3.1 + */ +public interface UnivariateFunctionDifferentiator { + + /** Create an implementation of a {@link UnivariateDifferentiableFunction + * differential} from a regular {@link UnivariateFunction function}. + * @param function function to differentiate + * @return differential function + */ + UnivariateDifferentiableFunction differentiate(UnivariateFunction function); + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/UnivariateMatrixFunctionDifferentiator.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/UnivariateMatrixFunctionDifferentiator.java new file mode 100644 index 000000000..dddd3231c --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/UnivariateMatrixFunctionDifferentiator.java @@ -0,0 +1,33 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.differentiation; + +import com.fr.third.org.apache.commons.math3.analysis.UnivariateMatrixFunction; + +/** Interface defining the function differentiation operation. + * @since 3.1 + */ +public interface UnivariateMatrixFunctionDifferentiator { + + /** Create an implementation of a {@link UnivariateDifferentiableMatrixFunction + * differential} from a regular {@link UnivariateMatrixFunction matrix function}. + * @param function function to differentiate + * @return differential function + */ + UnivariateDifferentiableMatrixFunction differentiate(UnivariateMatrixFunction function); + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/UnivariateVectorFunctionDifferentiator.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/UnivariateVectorFunctionDifferentiator.java new file mode 100644 index 000000000..6bf536a57 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/UnivariateVectorFunctionDifferentiator.java @@ -0,0 +1,33 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.differentiation; + +import com.fr.third.org.apache.commons.math3.analysis.UnivariateVectorFunction; + +/** Interface defining the function differentiation operation. + * @since 3.1 + */ +public interface UnivariateVectorFunctionDifferentiator { + + /** Create an implementation of a {@link UnivariateDifferentiableVectorFunction + * differential} from a regular {@link UnivariateVectorFunction vector function}. + * @param function function to differentiate + * @return differential function + */ + UnivariateDifferentiableVectorFunction differentiate(UnivariateVectorFunction function); + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/package-info.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/package-info.java new file mode 100644 index 000000000..8ce37f3b4 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/differentiation/package-info.java @@ -0,0 +1,42 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/** + * + *+ * This package holds the main interfaces and basic building block classes + * dealing with differentiation. + * The core class is {@link com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure + * DerivativeStructure} which holds the value and the differentials of a function. This class + * handles some arbitrary number of free parameters and arbitrary differentiation order. It is used + * both as the input and the output type for the {@link + * com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction + * UnivariateDifferentiableFunction} interface. Any differentiable function should implement this + * interface. + *
+ *+ * The {@link com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateFunctionDifferentiator + * UnivariateFunctionDifferentiator} interface defines a way to differentiate a simple {@link + * com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction UnivariateFunction} and get a {@link + * com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction + * UnivariateDifferentiableFunction}. + *
+ *+ * Similar interfaces also exist for multivariate functions and for vector or matrix valued functions. + *
+ * + */ +package com.fr.third.org.apache.commons.math3.analysis.differentiation; diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Abs.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Abs.java new file mode 100644 index 000000000..8d24d3f92 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Abs.java @@ -0,0 +1,33 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis.function; + +import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Absolute value function. + * + * @since 3.0 + */ +public class Abs implements UnivariateFunction { + /** {@inheritDoc} */ + public double value(double x) { + return FastMath.abs(x); + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Acos.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Acos.java new file mode 100644 index 000000000..f56a4a169 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Acos.java @@ -0,0 +1,53 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis.function; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure; +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction; +import com.fr.third.org.apache.commons.math3.analysis.FunctionUtils; +import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction; +import com.fr.third.org.apache.commons.math3.analysis.DifferentiableUnivariateFunction; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Arc-cosine function. + * + * @since 3.0 + */ +public class Acos implements UnivariateDifferentiableFunction, DifferentiableUnivariateFunction { + /** {@inheritDoc} */ + public double value(double x) { + return FastMath.acos(x); + } + + /** {@inheritDoc} + * @deprecated as of 3.1, replaced by {@link #value(DerivativeStructure)} + */ + @Deprecated + public UnivariateFunction derivative() { + return FunctionUtils.toDifferentiableUnivariateFunction(this).derivative(); + } + + /** {@inheritDoc} + * @since 3.1 + */ + public DerivativeStructure value(final DerivativeStructure t) { + return t.acos(); + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Acosh.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Acosh.java new file mode 100644 index 000000000..e78fcd958 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Acosh.java @@ -0,0 +1,53 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis.function; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure; +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction; +import com.fr.third.org.apache.commons.math3.analysis.FunctionUtils; +import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction; +import com.fr.third.org.apache.commons.math3.analysis.DifferentiableUnivariateFunction; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Hyperbolic arc-cosine function. + * + * @since 3.0 + */ +public class Acosh implements UnivariateDifferentiableFunction, DifferentiableUnivariateFunction { + /** {@inheritDoc} */ + public double value(double x) { + return FastMath.acosh(x); + } + + /** {@inheritDoc} + * @deprecated as of 3.1, replaced by {@link #value(DerivativeStructure)} + */ + @Deprecated + public UnivariateFunction derivative() { + return FunctionUtils.toDifferentiableUnivariateFunction(this).derivative(); + } + + /** {@inheritDoc} + * @since 3.1 + */ + public DerivativeStructure value(final DerivativeStructure t) { + return t.acosh(); + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Add.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Add.java new file mode 100644 index 000000000..0ba548d93 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Add.java @@ -0,0 +1,32 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis.function; + +import com.fr.third.org.apache.commons.math3.analysis.BivariateFunction; + +/** + * Add the two operands. + * + * @since 3.0 + */ +public class Add implements BivariateFunction { + /** {@inheritDoc} */ + public double value(double x, double y) { + return x + y; + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Asin.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Asin.java new file mode 100644 index 000000000..1969e0514 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Asin.java @@ -0,0 +1,53 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis.function; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure; +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction; +import com.fr.third.org.apache.commons.math3.analysis.FunctionUtils; +import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction; +import com.fr.third.org.apache.commons.math3.analysis.DifferentiableUnivariateFunction; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Arc-sine function. + * + * @since 3.0 + */ +public class Asin implements UnivariateDifferentiableFunction, DifferentiableUnivariateFunction { + /** {@inheritDoc} */ + public double value(double x) { + return FastMath.asin(x); + } + + /** {@inheritDoc} + * @deprecated as of 3.1, replaced by {@link #value(DerivativeStructure)} + */ + @Deprecated + public UnivariateFunction derivative() { + return FunctionUtils.toDifferentiableUnivariateFunction(this).derivative(); + } + + /** {@inheritDoc} + * @since 3.1 + */ + public DerivativeStructure value(final DerivativeStructure t) { + return t.asin(); + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Asinh.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Asinh.java new file mode 100644 index 000000000..c44a267df --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Asinh.java @@ -0,0 +1,53 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis.function; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure; +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction; +import com.fr.third.org.apache.commons.math3.analysis.FunctionUtils; +import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction; +import com.fr.third.org.apache.commons.math3.analysis.DifferentiableUnivariateFunction; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Hyperbolic arc-sine function. + * + * @since 3.0 + */ +public class Asinh implements UnivariateDifferentiableFunction, DifferentiableUnivariateFunction { + /** {@inheritDoc} */ + public double value(double x) { + return FastMath.asinh(x); + } + + /** {@inheritDoc} + * @deprecated as of 3.1, replaced by {@link #value(DerivativeStructure)} + */ + @Deprecated + public UnivariateFunction derivative() { + return FunctionUtils.toDifferentiableUnivariateFunction(this).derivative(); + } + + /** {@inheritDoc} + * @since 3.1 + */ + public DerivativeStructure value(final DerivativeStructure t) { + return t.asinh(); + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Atan.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Atan.java new file mode 100644 index 000000000..036e3399a --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Atan.java @@ -0,0 +1,53 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis.function; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure; +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction; +import com.fr.third.org.apache.commons.math3.analysis.FunctionUtils; +import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction; +import com.fr.third.org.apache.commons.math3.analysis.DifferentiableUnivariateFunction; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Arc-tangent function. + * + * @since 3.0 + */ +public class Atan implements UnivariateDifferentiableFunction, DifferentiableUnivariateFunction { + /** {@inheritDoc} */ + public double value(double x) { + return FastMath.atan(x); + } + + /** {@inheritDoc} + * @deprecated as of 3.1, replaced by {@link #value(DerivativeStructure)} + */ + @Deprecated + public UnivariateFunction derivative() { + return FunctionUtils.toDifferentiableUnivariateFunction(this).derivative(); + } + + /** {@inheritDoc} + * @since 3.1 + */ + public DerivativeStructure value(final DerivativeStructure t) { + return t.atan(); + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Atan2.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Atan2.java new file mode 100644 index 000000000..1796aaf8b --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Atan2.java @@ -0,0 +1,33 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis.function; + +import com.fr.third.org.apache.commons.math3.analysis.BivariateFunction; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Arc-tangent function. + * + * @since 3.0 + */ +public class Atan2 implements BivariateFunction { + /** {@inheritDoc} */ + public double value(double x, double y) { + return FastMath.atan2(x, y); + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Atanh.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Atanh.java new file mode 100644 index 000000000..09877ecaa --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Atanh.java @@ -0,0 +1,53 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis.function; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure; +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction; +import com.fr.third.org.apache.commons.math3.analysis.FunctionUtils; +import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction; +import com.fr.third.org.apache.commons.math3.analysis.DifferentiableUnivariateFunction; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Hyperbolic arc-tangent function. + * + * @since 3.0 + */ +public class Atanh implements UnivariateDifferentiableFunction, DifferentiableUnivariateFunction { + /** {@inheritDoc} */ + public double value(double x) { + return FastMath.atanh(x); + } + + /** {@inheritDoc} + * @deprecated as of 3.1, replaced by {@link #value(DerivativeStructure)} + */ + @Deprecated + public UnivariateFunction derivative() { + return FunctionUtils.toDifferentiableUnivariateFunction(this).derivative(); + } + + /** {@inheritDoc} + * @since 3.1 + */ + public DerivativeStructure value(final DerivativeStructure t) { + return t.atanh(); + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Cbrt.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Cbrt.java new file mode 100644 index 000000000..06a53ddbc --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Cbrt.java @@ -0,0 +1,53 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis.function; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure; +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction; +import com.fr.third.org.apache.commons.math3.analysis.FunctionUtils; +import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction; +import com.fr.third.org.apache.commons.math3.analysis.DifferentiableUnivariateFunction; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Cube root function. + * + * @since 3.0 + */ +public class Cbrt implements UnivariateDifferentiableFunction, DifferentiableUnivariateFunction { + /** {@inheritDoc} */ + public double value(double x) { + return FastMath.cbrt(x); + } + + /** {@inheritDoc} + * @deprecated as of 3.1, replaced by {@link #value(DerivativeStructure)} + */ + @Deprecated + public UnivariateFunction derivative() { + return FunctionUtils.toDifferentiableUnivariateFunction(this).derivative(); + } + + /** {@inheritDoc} + * @since 3.1 + */ + public DerivativeStructure value(final DerivativeStructure t) { + return t.cbrt(); + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Ceil.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Ceil.java new file mode 100644 index 000000000..e5bccb63f --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Ceil.java @@ -0,0 +1,33 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis.function; + +import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * {@code ceil} function. + * + * @since 3.0 + */ +public class Ceil implements UnivariateFunction { + /** {@inheritDoc} */ + public double value(double x) { + return FastMath.ceil(x); + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Constant.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Constant.java new file mode 100644 index 000000000..87e844fd7 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Constant.java @@ -0,0 +1,60 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis.function; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure; +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction; +import com.fr.third.org.apache.commons.math3.analysis.DifferentiableUnivariateFunction; + +/** + * Constant function. + * + * @since 3.0 + */ +public class Constant implements UnivariateDifferentiableFunction, DifferentiableUnivariateFunction { + /** Constant. */ + private final double c; + + /** + * @param c Constant. + */ + public Constant(double c) { + this.c = c; + } + + /** {@inheritDoc} */ + public double value(double x) { + return c; + } + + /** {@inheritDoc} + * @deprecated as of 3.1, replaced by {@link #value(DerivativeStructure)} + */ + @Deprecated + public DifferentiableUnivariateFunction derivative() { + return new Constant(0); + } + + /** {@inheritDoc} + * @since 3.1 + */ + public DerivativeStructure value(final DerivativeStructure t) { + return new DerivativeStructure(t.getFreeParameters(), t.getOrder(), c); + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Cos.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Cos.java new file mode 100644 index 000000000..aaeed0c80 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Cos.java @@ -0,0 +1,53 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis.function; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure; +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction; +import com.fr.third.org.apache.commons.math3.analysis.FunctionUtils; +import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction; +import com.fr.third.org.apache.commons.math3.analysis.DifferentiableUnivariateFunction; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Cosine function. + * + * @since 3.0 + */ +public class Cos implements UnivariateDifferentiableFunction, DifferentiableUnivariateFunction { + /** {@inheritDoc} */ + public double value(double x) { + return FastMath.cos(x); + } + + /** {@inheritDoc} + * @deprecated as of 3.1, replaced by {@link #value(DerivativeStructure)} + */ + @Deprecated + public UnivariateFunction derivative() { + return FunctionUtils.toDifferentiableUnivariateFunction(this).derivative(); + } + + /** {@inheritDoc} + * @since 3.1 + */ + public DerivativeStructure value(final DerivativeStructure t) { + return t.cos(); + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Cosh.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Cosh.java new file mode 100644 index 000000000..896b1decf --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Cosh.java @@ -0,0 +1,51 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis.function; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure; +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction; +import com.fr.third.org.apache.commons.math3.analysis.DifferentiableUnivariateFunction; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Hyperbolic cosine function. + * + * @since 3.0 + */ +public class Cosh implements UnivariateDifferentiableFunction, DifferentiableUnivariateFunction { + /** {@inheritDoc} */ + public double value(double x) { + return FastMath.cosh(x); + } + + /** {@inheritDoc} + * @deprecated as of 3.1, replaced by {@link #value(DerivativeStructure)} + */ + @Deprecated + public DifferentiableUnivariateFunction derivative() { + return new Sinh(); + } + + /** {@inheritDoc} + * @since 3.1 + */ + public DerivativeStructure value(final DerivativeStructure t) { + return t.cosh(); + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Divide.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Divide.java new file mode 100644 index 000000000..6e2de34f5 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Divide.java @@ -0,0 +1,32 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis.function; + +import com.fr.third.org.apache.commons.math3.analysis.BivariateFunction; + +/** + * Divide the first operand by the second. + * + * @since 3.0 + */ +public class Divide implements BivariateFunction { + /** {@inheritDoc} */ + public double value(double x, double y) { + return x / y; + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Exp.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Exp.java new file mode 100644 index 000000000..734514ad1 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Exp.java @@ -0,0 +1,53 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis.function; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure; +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction; +import com.fr.third.org.apache.commons.math3.analysis.FunctionUtils; +import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction; +import com.fr.third.org.apache.commons.math3.analysis.DifferentiableUnivariateFunction; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Exponential function. + * + * @since 3.0 + */ +public class Exp implements UnivariateDifferentiableFunction, DifferentiableUnivariateFunction { + /** {@inheritDoc} */ + public double value(double x) { + return FastMath.exp(x); + } + + /** {@inheritDoc} + * @deprecated as of 3.1, replaced by {@link #value(DerivativeStructure)} + */ + @Deprecated + public UnivariateFunction derivative() { + return FunctionUtils.toDifferentiableUnivariateFunction(this).derivative(); + } + + /** {@inheritDoc} + * @since 3.1 + */ + public DerivativeStructure value(final DerivativeStructure t) { + return t.exp(); + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Expm1.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Expm1.java new file mode 100644 index 000000000..bec8131c4 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Expm1.java @@ -0,0 +1,53 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.analysis.function; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure; +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction; +import com.fr.third.org.apache.commons.math3.analysis.FunctionUtils; +import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction; +import com.fr.third.org.apache.commons.math3.analysis.DifferentiableUnivariateFunction; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + *ex-1 function.
+ *
+ * @since 3.0
+ */
+public class Expm1 implements UnivariateDifferentiableFunction, DifferentiableUnivariateFunction {
+ /** {@inheritDoc} */
+ public double value(double x) {
+ return FastMath.expm1(x);
+ }
+
+ /** {@inheritDoc}
+ * @deprecated as of 3.1, replaced by {@link #value(DerivativeStructure)}
+ */
+ @Deprecated
+ public UnivariateFunction derivative() {
+ return FunctionUtils.toDifferentiableUnivariateFunction(this).derivative();
+ }
+
+ /** {@inheritDoc}
+ * @since 3.1
+ */
+ public DerivativeStructure value(final DerivativeStructure t) {
+ return t.expm1();
+ }
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Floor.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Floor.java
new file mode 100644
index 000000000..e4e7bb6e1
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Floor.java
@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.fr.third.org.apache.commons.math3.analysis.function;
+
+import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+
+/**
+ * {@code floor} function.
+ *
+ * @since 3.0
+ */
+public class Floor implements UnivariateFunction {
+ /** {@inheritDoc} */
+ public double value(double x) {
+ return FastMath.floor(x);
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Gaussian.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Gaussian.java
new file mode 100644
index 000000000..1701510b7
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Gaussian.java
@@ -0,0 +1,259 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.fr.third.org.apache.commons.math3.analysis.function;
+
+import java.util.Arrays;
+
+import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure;
+import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction;
+import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException;
+import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException;
+import com.fr.third.org.apache.commons.math3.exception.NullArgumentException;
+import com.fr.third.org.apache.commons.math3.analysis.FunctionUtils;
+import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction;
+import com.fr.third.org.apache.commons.math3.analysis.DifferentiableUnivariateFunction;
+import com.fr.third.org.apache.commons.math3.analysis.ParametricUnivariateFunction;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+import com.fr.third.org.apache.commons.math3.util.Precision;
+
+/**
+ *
+ * Gaussian function.
+ *
+ * @since 3.0
+ */
+public class Gaussian implements UnivariateDifferentiableFunction, DifferentiableUnivariateFunction {
+ /** Mean. */
+ private final double mean;
+ /** Inverse of the standard deviation. */
+ private final double is;
+ /** Inverse of twice the square of the standard deviation. */
+ private final double i2s2;
+ /** Normalization factor. */
+ private final double norm;
+
+ /**
+ * Gaussian with given normalization factor, mean and standard deviation.
+ *
+ * @param norm Normalization factor.
+ * @param mean Mean.
+ * @param sigma Standard deviation.
+ * @throws NotStrictlyPositiveException if {@code sigma <= 0}.
+ */
+ public Gaussian(double norm,
+ double mean,
+ double sigma)
+ throws NotStrictlyPositiveException {
+ if (sigma <= 0) {
+ throw new NotStrictlyPositiveException(sigma);
+ }
+
+ this.norm = norm;
+ this.mean = mean;
+ this.is = 1 / sigma;
+ this.i2s2 = 0.5 * is * is;
+ }
+
+ /**
+ * Normalized gaussian with given mean and standard deviation.
+ *
+ * @param mean Mean.
+ * @param sigma Standard deviation.
+ * @throws NotStrictlyPositiveException if {@code sigma <= 0}.
+ */
+ public Gaussian(double mean,
+ double sigma)
+ throws NotStrictlyPositiveException {
+ this(1 / (sigma * FastMath.sqrt(2 * Math.PI)), mean, sigma);
+ }
+
+ /**
+ * Normalized gaussian with zero mean and unit standard deviation.
+ */
+ public Gaussian() {
+ this(0, 1);
+ }
+
+ /** {@inheritDoc} */
+ public double value(double x) {
+ return value(x - mean, norm, i2s2);
+ }
+
+ /** {@inheritDoc}
+ * @deprecated as of 3.1, replaced by {@link #value(DerivativeStructure)}
+ */
+ @Deprecated
+ public UnivariateFunction derivative() {
+ return FunctionUtils.toDifferentiableUnivariateFunction(this).derivative();
+ }
+
+ /**
+ * Parametric function where the input array contains the parameters of
+ * the Gaussian, ordered as follows:
+ * log(1 + p) function.
+ *
+ * @since 3.0
+ */
+public class Log1p implements UnivariateDifferentiableFunction, DifferentiableUnivariateFunction {
+ /** {@inheritDoc} */
+ public double value(double x) {
+ return FastMath.log1p(x);
+ }
+
+ /** {@inheritDoc}
+ * @deprecated as of 3.1, replaced by {@link #value(DerivativeStructure)}
+ */
+ @Deprecated
+ public UnivariateFunction derivative() {
+ return FunctionUtils.toDifferentiableUnivariateFunction(this).derivative();
+ }
+
+ /** {@inheritDoc}
+ * @since 3.1
+ */
+ public DerivativeStructure value(final DerivativeStructure t) {
+ return t.log1p();
+ }
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Logistic.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Logistic.java
new file mode 100644
index 000000000..a726aabab
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Logistic.java
@@ -0,0 +1,228 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.fr.third.org.apache.commons.math3.analysis.function;
+
+import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure;
+import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction;
+import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException;
+import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException;
+import com.fr.third.org.apache.commons.math3.exception.NullArgumentException;
+import com.fr.third.org.apache.commons.math3.analysis.FunctionUtils;
+import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction;
+import com.fr.third.org.apache.commons.math3.analysis.DifferentiableUnivariateFunction;
+import com.fr.third.org.apache.commons.math3.analysis.ParametricUnivariateFunction;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+
+/**
+ *
+ * Generalised logistic function.
+ *
+ * @since 3.0
+ */
+public class Logistic implements UnivariateDifferentiableFunction, DifferentiableUnivariateFunction {
+ /** Lower asymptote. */
+ private final double a;
+ /** Upper asymptote. */
+ private final double k;
+ /** Growth rate. */
+ private final double b;
+ /** Parameter that affects near which asymptote maximum growth occurs. */
+ private final double oneOverN;
+ /** Parameter that affects the position of the curve along the ordinate axis. */
+ private final double q;
+ /** Abscissa of maximum growth. */
+ private final double m;
+
+ /**
+ * @param k If {@code b > 0}, value of the function for x going towards +∞.
+ * If {@code b < 0}, value of the function for x going towards -∞.
+ * @param m Abscissa of maximum growth.
+ * @param b Growth rate.
+ * @param q Parameter that affects the position of the curve along the
+ * ordinate axis.
+ * @param a If {@code b > 0}, value of the function for x going towards -∞.
+ * If {@code b < 0}, value of the function for x going towards +∞.
+ * @param n Parameter that affects near which asymptote the maximum
+ * growth occurs.
+ * @throws NotStrictlyPositiveException if {@code n <= 0}.
+ */
+ public Logistic(double k,
+ double m,
+ double b,
+ double q,
+ double a,
+ double n)
+ throws NotStrictlyPositiveException {
+ if (n <= 0) {
+ throw new NotStrictlyPositiveException(n);
+ }
+
+ this.k = k;
+ this.m = m;
+ this.b = b;
+ this.q = q;
+ this.a = a;
+ oneOverN = 1 / n;
+ }
+
+ /** {@inheritDoc} */
+ public double value(double x) {
+ return value(m - x, k, b, q, a, oneOverN);
+ }
+
+ /** {@inheritDoc}
+ * @deprecated as of 3.1, replaced by {@link #value(DerivativeStructure)}
+ */
+ @Deprecated
+ public UnivariateFunction derivative() {
+ return FunctionUtils.toDifferentiableUnivariateFunction(this).derivative();
+ }
+
+ /**
+ * Parametric function where the input array contains the parameters of
+ * the {@link Logistic#Logistic(double,double,double,double,double,double)
+ * logistic function}, ordered as follows:
+ *
+ * sinc(x) = 1 if x = 0,
+ * sin(x) / x otherwise.
+ * + * The Taylor series for sinc even order derivatives are: + *
+ * d^(2n)sinc/dx^(2n) = Sum_(k>=0) (-1)^(n+k) / ((2k)!(2n+2k+1)) x^(2k) + * = (-1)^n [ 1/(2n+1) - x^2/(4n+6) + x^4/(48n+120) - x^6/(1440n+5040) + O(x^8) ] + *+ * + *
+ * The Taylor series for sinc odd order derivatives are: + *
+ * d^(2n+1)sinc/dx^(2n+1) = Sum_(k>=0) (-1)^(n+k+1) / ((2k+1)!(2n+2k+3)) x^(2k+1) + * = (-1)^(n+1) [ x/(2n+3) - x^3/(12n+30) + x^5/(240n+840) - x^7/(10080n+45360) + O(x^9) ] + *+ * + *
+ * So the ratio of the fourth term with respect to the first term + * is always smaller than x^6/720, for all derivative orders. + * This implies that neglecting this term and using only the first three terms induces + * a relative error bounded by x^6/720. The SHORTCUT value is chosen such that this + * relative error is below double precision accuracy when |x| <= SHORTCUT. + *
+ */ + private static final double SHORTCUT = 6.0e-3; + /** For normalized sinc function. */ + private final boolean normalized; + + /** + * The sinc function, {@code sin(x) / x}. + */ + public Sinc() { + this(false); + } + + /** + * Instantiates the sinc function. + * + * @param normalized If {@code true}, the function is + * sin(πx) / πx, otherwise {@code sin(x) / x}.
+ */
+ public Sinc(boolean normalized) {
+ this.normalized = normalized;
+ }
+
+ /** {@inheritDoc} */
+ public double value(final double x) {
+ final double scaledX = normalized ? FastMath.PI * x : x;
+ if (FastMath.abs(scaledX) <= SHORTCUT) {
+ // use Taylor series
+ final double scaledX2 = scaledX * scaledX;
+ return ((scaledX2 - 20) * scaledX2 + 120) / 120;
+ } else {
+ // use definition expression
+ return FastMath.sin(scaledX) / scaledX;
+ }
+ }
+
+ /** {@inheritDoc}
+ * @deprecated as of 3.1, replaced by {@link #value(DerivativeStructure)}
+ */
+ @Deprecated
+ public UnivariateFunction derivative() {
+ return FunctionUtils.toDifferentiableUnivariateFunction(this).derivative();
+ }
+
+ /** {@inheritDoc}
+ * @since 3.1
+ */
+ public DerivativeStructure value(final DerivativeStructure t)
+ throws DimensionMismatchException {
+
+ final double scaledX = (normalized ? FastMath.PI : 1) * t.getValue();
+ final double scaledX2 = scaledX * scaledX;
+
+ double[] f = new double[t.getOrder() + 1];
+
+ if (FastMath.abs(scaledX) <= SHORTCUT) {
+
+ for (int i = 0; i < f.length; ++i) {
+ final int k = i / 2;
+ if ((i & 0x1) == 0) {
+ // even derivation order
+ f[i] = (((k & 0x1) == 0) ? 1 : -1) *
+ (1.0 / (i + 1) - scaledX2 * (1.0 / (2 * i + 6) - scaledX2 / (24 * i + 120)));
+ } else {
+ // odd derivation order
+ f[i] = (((k & 0x1) == 0) ? -scaledX : scaledX) *
+ (1.0 / (i + 2) - scaledX2 * (1.0 / (6 * i + 24) - scaledX2 / (120 * i + 720)));
+ }
+ }
+
+ } else {
+
+ final double inv = 1 / scaledX;
+ final double cos = FastMath.cos(scaledX);
+ final double sin = FastMath.sin(scaledX);
+
+ f[0] = inv * sin;
+
+ // the nth order derivative of sinc has the form:
+ // dn(sinc(x)/dxn = [S_n(x) sin(x) + C_n(x) cos(x)] / x^(n+1)
+ // where S_n(x) is an even polynomial with degree n-1 or n (depending on parity)
+ // and C_n(x) is an odd polynomial with degree n-1 or n (depending on parity)
+ // S_0(x) = 1, S_1(x) = -1, S_2(x) = -x^2 + 2, S_3(x) = 3x^2 - 6...
+ // C_0(x) = 0, C_1(x) = x, C_2(x) = -2x, C_3(x) = -x^3 + 6x...
+ // the general recurrence relations for S_n and C_n are:
+ // S_n(x) = x S_(n-1)'(x) - n S_(n-1)(x) - x C_(n-1)(x)
+ // C_n(x) = x C_(n-1)'(x) - n C_(n-1)(x) + x S_(n-1)(x)
+ // as per polynomials parity, we can store both S_n and C_n in the same array
+ final double[] sc = new double[f.length];
+ sc[0] = 1;
+
+ double coeff = inv;
+ for (int n = 1; n < f.length; ++n) {
+
+ double s = 0;
+ double c = 0;
+
+ // update and evaluate polynomials S_n(x) and C_n(x)
+ final int kStart;
+ if ((n & 0x1) == 0) {
+ // even derivation order, S_n is degree n and C_n is degree n-1
+ sc[n] = 0;
+ kStart = n;
+ } else {
+ // odd derivation order, S_n is degree n-1 and C_n is degree n
+ sc[n] = sc[n - 1];
+ c = sc[n];
+ kStart = n - 1;
+ }
+
+ // in this loop, k is always even
+ for (int k = kStart; k > 1; k -= 2) {
+
+ // sine part
+ sc[k] = (k - n) * sc[k] - sc[k - 1];
+ s = s * scaledX2 + sc[k];
+
+ // cosine part
+ sc[k - 1] = (k - 1 - n) * sc[k - 1] + sc[k -2];
+ c = c * scaledX2 + sc[k - 1];
+
+ }
+ sc[0] *= -n;
+ s = s * scaledX2 + sc[0];
+
+ coeff *= inv;
+ f[n] = coeff * (s * sin + c * scaledX * cos);
+
+ }
+
+ }
+
+ if (normalized) {
+ double scale = FastMath.PI;
+ for (int i = 1; i < f.length; ++i) {
+ f[i] *= scale;
+ scale *= FastMath.PI;
+ }
+ }
+
+ return t.compose(f);
+
+ }
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Sinh.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Sinh.java
new file mode 100644
index 000000000..ce2055937
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Sinh.java
@@ -0,0 +1,51 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.fr.third.org.apache.commons.math3.analysis.function;
+
+import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure;
+import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction;
+import com.fr.third.org.apache.commons.math3.analysis.DifferentiableUnivariateFunction;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+
+/**
+ * Hyperbolic sine function.
+ *
+ * @since 3.0
+ */
+public class Sinh implements UnivariateDifferentiableFunction, DifferentiableUnivariateFunction {
+ /** {@inheritDoc} */
+ public double value(double x) {
+ return FastMath.sinh(x);
+ }
+
+ /** {@inheritDoc}
+ * @deprecated as of 3.1, replaced by {@link #value(DerivativeStructure)}
+ */
+ @Deprecated
+ public DifferentiableUnivariateFunction derivative() {
+ return new Cosh();
+ }
+
+ /** {@inheritDoc}
+ * @since 3.1
+ */
+ public DerivativeStructure value(final DerivativeStructure t) {
+ return t.sinh();
+ }
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Sqrt.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Sqrt.java
new file mode 100644
index 000000000..61f2435f3
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/Sqrt.java
@@ -0,0 +1,53 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.fr.third.org.apache.commons.math3.analysis.function;
+
+import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure;
+import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction;
+import com.fr.third.org.apache.commons.math3.analysis.FunctionUtils;
+import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction;
+import com.fr.third.org.apache.commons.math3.analysis.DifferentiableUnivariateFunction;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+
+/**
+ * Square-root function.
+ *
+ * @since 3.0
+ */
+public class Sqrt implements UnivariateDifferentiableFunction, DifferentiableUnivariateFunction {
+ /** {@inheritDoc} */
+ public double value(double x) {
+ return FastMath.sqrt(x);
+ }
+
+ /** {@inheritDoc}
+ * @deprecated as of 3.1, replaced by {@link #value(DerivativeStructure)}
+ */
+ @Deprecated
+ public UnivariateFunction derivative() {
+ return FunctionUtils.toDifferentiableUnivariateFunction(this).derivative();
+ }
+
+ /** {@inheritDoc}
+ * @since 3.1
+ */
+ public DerivativeStructure value(final DerivativeStructure t) {
+ return t.sqrt();
+ }
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/StepFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/StepFunction.java
new file mode 100644
index 000000000..a28b5041f
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/function/StepFunction.java
@@ -0,0 +1,101 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.fr.third.org.apache.commons.math3.analysis.function;
+
+import java.util.Arrays;
+
+import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException;
+import com.fr.third.org.apache.commons.math3.exception.NoDataException;
+import com.fr.third.org.apache.commons.math3.exception.NonMonotonicSequenceException;
+import com.fr.third.org.apache.commons.math3.exception.NullArgumentException;
+import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction;
+import com.fr.third.org.apache.commons.math3.util.MathArrays;
+
+/**
+ *
+ * Step function.
+ *
+ * @since 3.0
+ */
+public class StepFunction implements UnivariateFunction {
+ /** Abscissae. */
+ private final double[] abscissa;
+ /** Ordinates. */
+ private final double[] ordinate;
+
+ /**
+ * Builds a step function from a list of arguments and the corresponding
+ * values. Specifically, returns the function h(x) defined by
+ * h(x) = y[0] for all x < x[1]
+ * y[1] for x[1] ≤ x < x[2]
+ * ...
+ * y[y.length - 1] for x ≥ x[x.length - 1]
+ * + * The {@code function} package contains function objects that wrap the + * methods contained in {@link java.lang.Math}, as well as common + * mathematical functions such as the gaussian and sinc functions. + *
+ * + */ +package com.fr.third.org.apache.commons.math3.analysis.function; diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/BaseAbstractUnivariateIntegrator.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/BaseAbstractUnivariateIntegrator.java new file mode 100644 index 000000000..5bc1991a1 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/BaseAbstractUnivariateIntegrator.java @@ -0,0 +1,299 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.integration; + +import com.fr.third.org.apache.commons.math3.exception.MathIllegalArgumentException; +import com.fr.third.org.apache.commons.math3.exception.MaxCountExceededException; +import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException; +import com.fr.third.org.apache.commons.math3.exception.NullArgumentException; +import com.fr.third.org.apache.commons.math3.exception.NumberIsTooSmallException; +import com.fr.third.org.apache.commons.math3.exception.TooManyEvaluationsException; +import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction; +import com.fr.third.org.apache.commons.math3.analysis.solvers.UnivariateSolverUtils; +import com.fr.third.org.apache.commons.math3.util.Incrementor; +import com.fr.third.org.apache.commons.math3.util.IntegerSequence; +import com.fr.third.org.apache.commons.math3.util.Precision; +import com.fr.third.org.apache.commons.math3.util.MathUtils; + +/** + * Provide a default implementation for several generic functions. + * + * @since 1.2 + */ +public abstract class BaseAbstractUnivariateIntegrator implements UnivariateIntegrator { + + /** Default absolute accuracy. */ + public static final double DEFAULT_ABSOLUTE_ACCURACY = 1.0e-15; + + /** Default relative accuracy. */ + public static final double DEFAULT_RELATIVE_ACCURACY = 1.0e-6; + + /** Default minimal iteration count. */ + public static final int DEFAULT_MIN_ITERATIONS_COUNT = 3; + + /** Default maximal iteration count. */ + public static final int DEFAULT_MAX_ITERATIONS_COUNT = Integer.MAX_VALUE; + + /** The iteration count. + * @deprecated as of 3.6, this field has been replaced with {@link #incrementCount()} + */ + @Deprecated + protected Incrementor iterations; + + /** The iteration count. */ + private IntegerSequence.Incrementor count; + + /** Maximum absolute error. */ + private final double absoluteAccuracy; + + /** Maximum relative error. */ + private final double relativeAccuracy; + + /** minimum number of iterations */ + private final int minimalIterationCount; + + /** The functions evaluation count. */ + private IntegerSequence.Incrementor evaluations; + + /** Function to integrate. */ + private UnivariateFunction function; + + /** Lower bound for the interval. */ + private double min; + + /** Upper bound for the interval. */ + private double max; + + /** + * Construct an integrator with given accuracies and iteration counts. + *+ * The meanings of the various parameters are: + *
+ * Legendre-Gauss integrators are efficient integrators that can + * accurately integrate functions with few function evaluations. A + * Legendre-Gauss integrator using an n-points quadrature formula can + * integrate 2n-1 degree polynomials exactly. + *
+ *+ * These integrators evaluate the function on n carefully chosen + * abscissas in each step interval (mapped to the canonical [-1,1] interval). + * The evaluation abscissas are not evenly spaced and none of them are + * at the interval endpoints. This implies the function integrated can be + * undefined at integration interval endpoints. + *
+ *+ * The evaluation abscissas xi are the roots of the degree n + * Legendre polynomial. The weights ai of the quadrature formula + * integrals from -1 to +1 ∫ Li2 where Li (x) = + * ∏ (x-xk)/(xi-xk) for k != i. + *
+ *+ * @since 1.2 + * @deprecated As of 3.1 (to be removed in 4.0). Please use + * {@link IterativeLegendreGaussIntegrator} instead. + */ +@Deprecated +public class LegendreGaussIntegrator extends BaseAbstractUnivariateIntegrator { + + /** Abscissas for the 2 points method. */ + private static final double[] ABSCISSAS_2 = { + -1.0 / FastMath.sqrt(3.0), + 1.0 / FastMath.sqrt(3.0) + }; + + /** Weights for the 2 points method. */ + private static final double[] WEIGHTS_2 = { + 1.0, + 1.0 + }; + + /** Abscissas for the 3 points method. */ + private static final double[] ABSCISSAS_3 = { + -FastMath.sqrt(0.6), + 0.0, + FastMath.sqrt(0.6) + }; + + /** Weights for the 3 points method. */ + private static final double[] WEIGHTS_3 = { + 5.0 / 9.0, + 8.0 / 9.0, + 5.0 / 9.0 + }; + + /** Abscissas for the 4 points method. */ + private static final double[] ABSCISSAS_4 = { + -FastMath.sqrt((15.0 + 2.0 * FastMath.sqrt(30.0)) / 35.0), + -FastMath.sqrt((15.0 - 2.0 * FastMath.sqrt(30.0)) / 35.0), + FastMath.sqrt((15.0 - 2.0 * FastMath.sqrt(30.0)) / 35.0), + FastMath.sqrt((15.0 + 2.0 * FastMath.sqrt(30.0)) / 35.0) + }; + + /** Weights for the 4 points method. */ + private static final double[] WEIGHTS_4 = { + (90.0 - 5.0 * FastMath.sqrt(30.0)) / 180.0, + (90.0 + 5.0 * FastMath.sqrt(30.0)) / 180.0, + (90.0 + 5.0 * FastMath.sqrt(30.0)) / 180.0, + (90.0 - 5.0 * FastMath.sqrt(30.0)) / 180.0 + }; + + /** Abscissas for the 5 points method. */ + private static final double[] ABSCISSAS_5 = { + -FastMath.sqrt((35.0 + 2.0 * FastMath.sqrt(70.0)) / 63.0), + -FastMath.sqrt((35.0 - 2.0 * FastMath.sqrt(70.0)) / 63.0), + 0.0, + FastMath.sqrt((35.0 - 2.0 * FastMath.sqrt(70.0)) / 63.0), + FastMath.sqrt((35.0 + 2.0 * FastMath.sqrt(70.0)) / 63.0) + }; + + /** Weights for the 5 points method. */ + private static final double[] WEIGHTS_5 = { + (322.0 - 13.0 * FastMath.sqrt(70.0)) / 900.0, + (322.0 + 13.0 * FastMath.sqrt(70.0)) / 900.0, + 128.0 / 225.0, + (322.0 + 13.0 * FastMath.sqrt(70.0)) / 900.0, + (322.0 - 13.0 * FastMath.sqrt(70.0)) / 900.0 + }; + + /** Abscissas for the current method. */ + private final double[] abscissas; + + /** Weights for the current method. */ + private final double[] weights; + + /** + * Build a Legendre-Gauss integrator with given accuracies and iterations counts. + * @param n number of points desired (must be between 2 and 5 inclusive) + * @param relativeAccuracy relative accuracy of the result + * @param absoluteAccuracy absolute accuracy of the result + * @param minimalIterationCount minimum number of iterations + * @param maximalIterationCount maximum number of iterations + * @exception MathIllegalArgumentException if number of points is out of [2; 5] + * @exception NotStrictlyPositiveException if minimal number of iterations + * is not strictly positive + * @exception NumberIsTooSmallException if maximal number of iterations + * is lesser than or equal to the minimal number of iterations + */ + public LegendreGaussIntegrator(final int n, + final double relativeAccuracy, + final double absoluteAccuracy, + final int minimalIterationCount, + final int maximalIterationCount) + throws MathIllegalArgumentException, NotStrictlyPositiveException, NumberIsTooSmallException { + super(relativeAccuracy, absoluteAccuracy, minimalIterationCount, maximalIterationCount); + switch(n) { + case 2 : + abscissas = ABSCISSAS_2; + weights = WEIGHTS_2; + break; + case 3 : + abscissas = ABSCISSAS_3; + weights = WEIGHTS_3; + break; + case 4 : + abscissas = ABSCISSAS_4; + weights = WEIGHTS_4; + break; + case 5 : + abscissas = ABSCISSAS_5; + weights = WEIGHTS_5; + break; + default : + throw new MathIllegalArgumentException( + LocalizedFormats.N_POINTS_GAUSS_LEGENDRE_INTEGRATOR_NOT_SUPPORTED, + n, 2, 5); + } + + } + + /** + * Build a Legendre-Gauss integrator with given accuracies. + * @param n number of points desired (must be between 2 and 5 inclusive) + * @param relativeAccuracy relative accuracy of the result + * @param absoluteAccuracy absolute accuracy of the result + * @exception MathIllegalArgumentException if number of points is out of [2; 5] + */ + public LegendreGaussIntegrator(final int n, + final double relativeAccuracy, + final double absoluteAccuracy) + throws MathIllegalArgumentException { + this(n, relativeAccuracy, absoluteAccuracy, + DEFAULT_MIN_ITERATIONS_COUNT, DEFAULT_MAX_ITERATIONS_COUNT); + } + + /** + * Build a Legendre-Gauss integrator with given iteration counts. + * @param n number of points desired (must be between 2 and 5 inclusive) + * @param minimalIterationCount minimum number of iterations + * @param maximalIterationCount maximum number of iterations + * @exception MathIllegalArgumentException if number of points is out of [2; 5] + * @exception NotStrictlyPositiveException if minimal number of iterations + * is not strictly positive + * @exception NumberIsTooSmallException if maximal number of iterations + * is lesser than or equal to the minimal number of iterations + */ + public LegendreGaussIntegrator(final int n, + final int minimalIterationCount, + final int maximalIterationCount) + throws MathIllegalArgumentException { + this(n, DEFAULT_RELATIVE_ACCURACY, DEFAULT_ABSOLUTE_ACCURACY, + minimalIterationCount, maximalIterationCount); + } + + /** {@inheritDoc} */ + @Override + protected double doIntegrate() + throws MathIllegalArgumentException, TooManyEvaluationsException, MaxCountExceededException { + + // compute first estimate with a single step + double oldt = stage(1); + + int n = 2; + while (true) { + + // improve integral with a larger number of steps + final double t = stage(n); + + // estimate error + final double delta = FastMath.abs(t - oldt); + final double limit = + FastMath.max(getAbsoluteAccuracy(), + getRelativeAccuracy() * (FastMath.abs(oldt) + FastMath.abs(t)) * 0.5); + + // check convergence + if ((getIterations() + 1 >= getMinimalIterationCount()) && (delta <= limit)) { + return t; + } + + // prepare next iteration + double ratio = FastMath.min(4, FastMath.pow(delta / limit, 0.5 / abscissas.length)); + n = FastMath.max((int) (ratio * n), n + 1); + oldt = t; + incrementCount(); + + } + + } + + /** + * Compute the n-th stage integral. + * @param n number of steps + * @return the value of n-th stage integral + * @throws TooManyEvaluationsException if the maximum number of evaluations + * is exceeded. + */ + private double stage(final int n) + throws TooManyEvaluationsException { + + // set up the step for the current stage + final double step = (getMax() - getMin()) / n; + final double halfStep = step / 2.0; + + // integrate over all elementary steps + double midPoint = getMin() + halfStep; + double sum = 0.0; + for (int i = 0; i < n; ++i) { + for (int j = 0; j < abscissas.length; ++j) { + sum += weights[j] * computeObjectiveValue(midPoint + halfStep * abscissas[j]); + } + midPoint += step; + } + + return halfStep * sum; + + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/MidPointIntegrator.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/MidPointIntegrator.java new file mode 100644 index 000000000..556802788 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/MidPointIntegrator.java @@ -0,0 +1,169 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.integration; + +import com.fr.third.org.apache.commons.math3.exception.MathIllegalArgumentException; +import com.fr.third.org.apache.commons.math3.exception.MaxCountExceededException; +import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException; +import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException; +import com.fr.third.org.apache.commons.math3.exception.NumberIsTooSmallException; +import com.fr.third.org.apache.commons.math3.exception.TooManyEvaluationsException; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Implements the + * Midpoint Rule for integration of real univariate functions. For + * reference, see Numerical Mathematics, ISBN 0387989595, + * chapter 9.2. + *
+ * The function should be integrable.
+ * + * @since 3.3 + */ +public class MidPointIntegrator extends BaseAbstractUnivariateIntegrator { + + /** Maximum number of iterations for midpoint. */ + public static final int MIDPOINT_MAX_ITERATIONS_COUNT = 64; + + /** + * Build a midpoint integrator with given accuracies and iterations counts. + * @param relativeAccuracy relative accuracy of the result + * @param absoluteAccuracy absolute accuracy of the result + * @param minimalIterationCount minimum number of iterations + * @param maximalIterationCount maximum number of iterations + * (must be less than or equal to {@link #MIDPOINT_MAX_ITERATIONS_COUNT} + * @exception NotStrictlyPositiveException if minimal number of iterations + * is not strictly positive + * @exception NumberIsTooSmallException if maximal number of iterations + * is lesser than or equal to the minimal number of iterations + * @exception NumberIsTooLargeException if maximal number of iterations + * is greater than {@link #MIDPOINT_MAX_ITERATIONS_COUNT} + */ + public MidPointIntegrator(final double relativeAccuracy, + final double absoluteAccuracy, + final int minimalIterationCount, + final int maximalIterationCount) + throws NotStrictlyPositiveException, NumberIsTooSmallException, NumberIsTooLargeException { + super(relativeAccuracy, absoluteAccuracy, minimalIterationCount, maximalIterationCount); + if (maximalIterationCount > MIDPOINT_MAX_ITERATIONS_COUNT) { + throw new NumberIsTooLargeException(maximalIterationCount, + MIDPOINT_MAX_ITERATIONS_COUNT, false); + } + } + + /** + * Build a midpoint integrator with given iteration counts. + * @param minimalIterationCount minimum number of iterations + * @param maximalIterationCount maximum number of iterations + * (must be less than or equal to {@link #MIDPOINT_MAX_ITERATIONS_COUNT} + * @exception NotStrictlyPositiveException if minimal number of iterations + * is not strictly positive + * @exception NumberIsTooSmallException if maximal number of iterations + * is lesser than or equal to the minimal number of iterations + * @exception NumberIsTooLargeException if maximal number of iterations + * is greater than {@link #MIDPOINT_MAX_ITERATIONS_COUNT} + */ + public MidPointIntegrator(final int minimalIterationCount, + final int maximalIterationCount) + throws NotStrictlyPositiveException, NumberIsTooSmallException, NumberIsTooLargeException { + super(minimalIterationCount, maximalIterationCount); + if (maximalIterationCount > MIDPOINT_MAX_ITERATIONS_COUNT) { + throw new NumberIsTooLargeException(maximalIterationCount, + MIDPOINT_MAX_ITERATIONS_COUNT, false); + } + } + + /** + * Construct a midpoint integrator with default settings. + * (max iteration count set to {@link #MIDPOINT_MAX_ITERATIONS_COUNT}) + */ + public MidPointIntegrator() { + super(DEFAULT_MIN_ITERATIONS_COUNT, MIDPOINT_MAX_ITERATIONS_COUNT); + } + + /** + * Compute the n-th stage integral of midpoint rule. + * This function should only be called by APIintegrate() in the package.
+ * To save time it does not verify arguments - caller does.
+ * + * The interval is divided equally into 2^n sections rather than an + * arbitrary m sections because this configuration can best utilize the + * already computed values.
+ * + * @param n the stage of 1/2 refinement. Must be larger than 0. + * @param previousStageResult Result from the previous call to the + * {@code stage} method. + * @param min Lower bound of the integration interval. + * @param diffMaxMin Difference between the lower bound and upper bound + * of the integration interval. + * @return the value of n-th stage integral + * @throws TooManyEvaluationsException if the maximal number of evaluations + * is exceeded. + */ + private double stage(final int n, + double previousStageResult, + double min, + double diffMaxMin) + throws TooManyEvaluationsException { + + // number of new points in this stage + final long np = 1L << (n - 1); + double sum = 0; + + // spacing between adjacent new points + final double spacing = diffMaxMin / np; + + // the first new point + double x = min + 0.5 * spacing; + for (long i = 0; i < np; i++) { + sum += computeObjectiveValue(x); + x += spacing; + } + // add the new sum to previously calculated result + return 0.5 * (previousStageResult + sum * spacing); + } + + + /** {@inheritDoc} */ + @Override + protected double doIntegrate() + throws MathIllegalArgumentException, TooManyEvaluationsException, MaxCountExceededException { + + final double min = getMin(); + final double diff = getMax() - min; + final double midPoint = min + 0.5 * diff; + + double oldt = diff * computeObjectiveValue(midPoint); + + while (true) { + incrementCount(); + final int i = getIterations(); + final double t = stage(i, oldt, min, diff); + if (i >= getMinimalIterationCount()) { + final double delta = FastMath.abs(t - oldt); + final double rLimit = + getRelativeAccuracy() * (FastMath.abs(oldt) + FastMath.abs(t)) * 0.5; + if ((delta <= rLimit) || (delta <= getAbsoluteAccuracy())) { + return t; + } + } + oldt = t; + } + + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/RombergIntegrator.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/RombergIntegrator.java new file mode 100644 index 000000000..c6f0c57a0 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/RombergIntegrator.java @@ -0,0 +1,142 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.integration; + +import com.fr.third.org.apache.commons.math3.exception.MaxCountExceededException; +import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException; +import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException; +import com.fr.third.org.apache.commons.math3.exception.NumberIsTooSmallException; +import com.fr.third.org.apache.commons.math3.exception.TooManyEvaluationsException; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Implements the + * Romberg Algorithm for integration of real univariate functions. For + * reference, see Introduction to Numerical Analysis, ISBN 038795452X, + * chapter 3. + *+ * Romberg integration employs k successive refinements of the trapezoid + * rule to remove error terms less than order O(N^(-2k)). Simpson's rule + * is a special case of k = 2.
+ * + * @since 1.2 + */ +public class RombergIntegrator extends BaseAbstractUnivariateIntegrator { + + /** Maximal number of iterations for Romberg. */ + public static final int ROMBERG_MAX_ITERATIONS_COUNT = 32; + + /** + * Build a Romberg integrator with given accuracies and iterations counts. + * @param relativeAccuracy relative accuracy of the result + * @param absoluteAccuracy absolute accuracy of the result + * @param minimalIterationCount minimum number of iterations + * @param maximalIterationCount maximum number of iterations + * (must be less than or equal to {@link #ROMBERG_MAX_ITERATIONS_COUNT}) + * @exception NotStrictlyPositiveException if minimal number of iterations + * is not strictly positive + * @exception NumberIsTooSmallException if maximal number of iterations + * is lesser than or equal to the minimal number of iterations + * @exception NumberIsTooLargeException if maximal number of iterations + * is greater than {@link #ROMBERG_MAX_ITERATIONS_COUNT} + */ + public RombergIntegrator(final double relativeAccuracy, + final double absoluteAccuracy, + final int minimalIterationCount, + final int maximalIterationCount) + throws NotStrictlyPositiveException, NumberIsTooSmallException, NumberIsTooLargeException { + super(relativeAccuracy, absoluteAccuracy, minimalIterationCount, maximalIterationCount); + if (maximalIterationCount > ROMBERG_MAX_ITERATIONS_COUNT) { + throw new NumberIsTooLargeException(maximalIterationCount, + ROMBERG_MAX_ITERATIONS_COUNT, false); + } + } + + /** + * Build a Romberg integrator with given iteration counts. + * @param minimalIterationCount minimum number of iterations + * @param maximalIterationCount maximum number of iterations + * (must be less than or equal to {@link #ROMBERG_MAX_ITERATIONS_COUNT}) + * @exception NotStrictlyPositiveException if minimal number of iterations + * is not strictly positive + * @exception NumberIsTooSmallException if maximal number of iterations + * is lesser than or equal to the minimal number of iterations + * @exception NumberIsTooLargeException if maximal number of iterations + * is greater than {@link #ROMBERG_MAX_ITERATIONS_COUNT} + */ + public RombergIntegrator(final int minimalIterationCount, + final int maximalIterationCount) + throws NotStrictlyPositiveException, NumberIsTooSmallException, NumberIsTooLargeException { + super(minimalIterationCount, maximalIterationCount); + if (maximalIterationCount > ROMBERG_MAX_ITERATIONS_COUNT) { + throw new NumberIsTooLargeException(maximalIterationCount, + ROMBERG_MAX_ITERATIONS_COUNT, false); + } + } + + /** + * Construct a Romberg integrator with default settings + * (max iteration count set to {@link #ROMBERG_MAX_ITERATIONS_COUNT}) + */ + public RombergIntegrator() { + super(DEFAULT_MIN_ITERATIONS_COUNT, ROMBERG_MAX_ITERATIONS_COUNT); + } + + /** {@inheritDoc} */ + @Override + protected double doIntegrate() + throws TooManyEvaluationsException, MaxCountExceededException { + + final int m = getMaximalIterationCount() + 1; + double previousRow[] = new double[m]; + double currentRow[] = new double[m]; + + TrapezoidIntegrator qtrap = new TrapezoidIntegrator(); + currentRow[0] = qtrap.stage(this, 0); + incrementCount(); + double olds = currentRow[0]; + while (true) { + + final int i = getIterations(); + + // switch rows + final double[] tmpRow = previousRow; + previousRow = currentRow; + currentRow = tmpRow; + + currentRow[0] = qtrap.stage(this, i); + incrementCount(); + for (int j = 1; j <= i; j++) { + // Richardson extrapolation coefficient + final double r = (1L << (2 * j)) - 1; + final double tIJm1 = currentRow[j - 1]; + currentRow[j] = tIJm1 + (tIJm1 - previousRow[j - 1]) / r; + } + final double s = currentRow[i]; + if (i >= getMinimalIterationCount()) { + final double delta = FastMath.abs(s - olds); + final double rLimit = getRelativeAccuracy() * (FastMath.abs(olds) + FastMath.abs(s)) * 0.5; + if ((delta <= rLimit) || (delta <= getAbsoluteAccuracy())) { + return s; + } + } + olds = s; + } + + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/SimpsonIntegrator.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/SimpsonIntegrator.java new file mode 100644 index 000000000..4f9905f50 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/SimpsonIntegrator.java @@ -0,0 +1,129 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.integration; + +import com.fr.third.org.apache.commons.math3.exception.MaxCountExceededException; +import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException; +import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException; +import com.fr.third.org.apache.commons.math3.exception.NumberIsTooSmallException; +import com.fr.third.org.apache.commons.math3.exception.TooManyEvaluationsException; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Implements + * Simpson's Rule for integration of real univariate functions. For + * reference, see Introduction to Numerical Analysis, ISBN 038795452X, + * chapter 3. + *+ * This implementation employs the basic trapezoid rule to calculate Simpson's + * rule.
+ * + * @since 1.2 + */ +public class SimpsonIntegrator extends BaseAbstractUnivariateIntegrator { + + /** Maximal number of iterations for Simpson. */ + public static final int SIMPSON_MAX_ITERATIONS_COUNT = 64; + + /** + * Build a Simpson integrator with given accuracies and iterations counts. + * @param relativeAccuracy relative accuracy of the result + * @param absoluteAccuracy absolute accuracy of the result + * @param minimalIterationCount minimum number of iterations + * @param maximalIterationCount maximum number of iterations + * (must be less than or equal to {@link #SIMPSON_MAX_ITERATIONS_COUNT}) + * @exception NotStrictlyPositiveException if minimal number of iterations + * is not strictly positive + * @exception NumberIsTooSmallException if maximal number of iterations + * is lesser than or equal to the minimal number of iterations + * @exception NumberIsTooLargeException if maximal number of iterations + * is greater than {@link #SIMPSON_MAX_ITERATIONS_COUNT} + */ + public SimpsonIntegrator(final double relativeAccuracy, + final double absoluteAccuracy, + final int minimalIterationCount, + final int maximalIterationCount) + throws NotStrictlyPositiveException, NumberIsTooSmallException, NumberIsTooLargeException { + super(relativeAccuracy, absoluteAccuracy, minimalIterationCount, maximalIterationCount); + if (maximalIterationCount > SIMPSON_MAX_ITERATIONS_COUNT) { + throw new NumberIsTooLargeException(maximalIterationCount, + SIMPSON_MAX_ITERATIONS_COUNT, false); + } + } + + /** + * Build a Simpson integrator with given iteration counts. + * @param minimalIterationCount minimum number of iterations + * @param maximalIterationCount maximum number of iterations + * (must be less than or equal to {@link #SIMPSON_MAX_ITERATIONS_COUNT}) + * @exception NotStrictlyPositiveException if minimal number of iterations + * is not strictly positive + * @exception NumberIsTooSmallException if maximal number of iterations + * is lesser than or equal to the minimal number of iterations + * @exception NumberIsTooLargeException if maximal number of iterations + * is greater than {@link #SIMPSON_MAX_ITERATIONS_COUNT} + */ + public SimpsonIntegrator(final int minimalIterationCount, + final int maximalIterationCount) + throws NotStrictlyPositiveException, NumberIsTooSmallException, NumberIsTooLargeException { + super(minimalIterationCount, maximalIterationCount); + if (maximalIterationCount > SIMPSON_MAX_ITERATIONS_COUNT) { + throw new NumberIsTooLargeException(maximalIterationCount, + SIMPSON_MAX_ITERATIONS_COUNT, false); + } + } + + /** + * Construct an integrator with default settings. + * (max iteration count set to {@link #SIMPSON_MAX_ITERATIONS_COUNT}) + */ + public SimpsonIntegrator() { + super(DEFAULT_MIN_ITERATIONS_COUNT, SIMPSON_MAX_ITERATIONS_COUNT); + } + + /** {@inheritDoc} */ + @Override + protected double doIntegrate() + throws TooManyEvaluationsException, MaxCountExceededException { + + TrapezoidIntegrator qtrap = new TrapezoidIntegrator(); + if (getMinimalIterationCount() == 1) { + return (4 * qtrap.stage(this, 1) - qtrap.stage(this, 0)) / 3.0; + } + + // Simpson's rule requires at least two trapezoid stages. + double olds = 0; + double oldt = qtrap.stage(this, 0); + while (true) { + final double t = qtrap.stage(this, getIterations()); + incrementCount(); + final double s = (4 * t - oldt) / 3.0; + if (getIterations() >= getMinimalIterationCount()) { + final double delta = FastMath.abs(s - olds); + final double rLimit = + getRelativeAccuracy() * (FastMath.abs(olds) + FastMath.abs(s)) * 0.5; + if ((delta <= rLimit) || (delta <= getAbsoluteAccuracy())) { + return s; + } + } + olds = s; + oldt = t; + } + + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/TrapezoidIntegrator.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/TrapezoidIntegrator.java new file mode 100644 index 000000000..a35a7b370 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/TrapezoidIntegrator.java @@ -0,0 +1,168 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.integration; + +import com.fr.third.org.apache.commons.math3.exception.MathIllegalArgumentException; +import com.fr.third.org.apache.commons.math3.exception.MaxCountExceededException; +import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException; +import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException; +import com.fr.third.org.apache.commons.math3.exception.NumberIsTooSmallException; +import com.fr.third.org.apache.commons.math3.exception.TooManyEvaluationsException; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Implements the + * Trapezoid Rule for integration of real univariate functions. For + * reference, see Introduction to Numerical Analysis, ISBN 038795452X, + * chapter 3. + *+ * The function should be integrable.
+ * + * @since 1.2 + */ +public class TrapezoidIntegrator extends BaseAbstractUnivariateIntegrator { + + /** Maximum number of iterations for trapezoid. */ + public static final int TRAPEZOID_MAX_ITERATIONS_COUNT = 64; + + /** Intermediate result. */ + private double s; + + /** + * Build a trapezoid integrator with given accuracies and iterations counts. + * @param relativeAccuracy relative accuracy of the result + * @param absoluteAccuracy absolute accuracy of the result + * @param minimalIterationCount minimum number of iterations + * @param maximalIterationCount maximum number of iterations + * (must be less than or equal to {@link #TRAPEZOID_MAX_ITERATIONS_COUNT} + * @exception NotStrictlyPositiveException if minimal number of iterations + * is not strictly positive + * @exception NumberIsTooSmallException if maximal number of iterations + * is lesser than or equal to the minimal number of iterations + * @exception NumberIsTooLargeException if maximal number of iterations + * is greater than {@link #TRAPEZOID_MAX_ITERATIONS_COUNT} + */ + public TrapezoidIntegrator(final double relativeAccuracy, + final double absoluteAccuracy, + final int minimalIterationCount, + final int maximalIterationCount) + throws NotStrictlyPositiveException, NumberIsTooSmallException, NumberIsTooLargeException { + super(relativeAccuracy, absoluteAccuracy, minimalIterationCount, maximalIterationCount); + if (maximalIterationCount > TRAPEZOID_MAX_ITERATIONS_COUNT) { + throw new NumberIsTooLargeException(maximalIterationCount, + TRAPEZOID_MAX_ITERATIONS_COUNT, false); + } + } + + /** + * Build a trapezoid integrator with given iteration counts. + * @param minimalIterationCount minimum number of iterations + * @param maximalIterationCount maximum number of iterations + * (must be less than or equal to {@link #TRAPEZOID_MAX_ITERATIONS_COUNT} + * @exception NotStrictlyPositiveException if minimal number of iterations + * is not strictly positive + * @exception NumberIsTooSmallException if maximal number of iterations + * is lesser than or equal to the minimal number of iterations + * @exception NumberIsTooLargeException if maximal number of iterations + * is greater than {@link #TRAPEZOID_MAX_ITERATIONS_COUNT} + */ + public TrapezoidIntegrator(final int minimalIterationCount, + final int maximalIterationCount) + throws NotStrictlyPositiveException, NumberIsTooSmallException, NumberIsTooLargeException { + super(minimalIterationCount, maximalIterationCount); + if (maximalIterationCount > TRAPEZOID_MAX_ITERATIONS_COUNT) { + throw new NumberIsTooLargeException(maximalIterationCount, + TRAPEZOID_MAX_ITERATIONS_COUNT, false); + } + } + + /** + * Construct a trapezoid integrator with default settings. + * (max iteration count set to {@link #TRAPEZOID_MAX_ITERATIONS_COUNT}) + */ + public TrapezoidIntegrator() { + super(DEFAULT_MIN_ITERATIONS_COUNT, TRAPEZOID_MAX_ITERATIONS_COUNT); + } + + /** + * Compute the n-th stage integral of trapezoid rule. This function + * should only be called by APIintegrate() in the package.
+ * To save time it does not verify arguments - caller does.
+ * + * The interval is divided equally into 2^n sections rather than an + * arbitrary m sections because this configuration can best utilize the + * already computed values.
+ * + * @param baseIntegrator integrator holding integration parameters + * @param n the stage of 1/2 refinement, n = 0 is no refinement + * @return the value of n-th stage integral + * @throws TooManyEvaluationsException if the maximal number of evaluations + * is exceeded. + */ + double stage(final BaseAbstractUnivariateIntegrator baseIntegrator, final int n) + throws TooManyEvaluationsException { + + if (n == 0) { + final double max = baseIntegrator.getMax(); + final double min = baseIntegrator.getMin(); + s = 0.5 * (max - min) * + (baseIntegrator.computeObjectiveValue(min) + + baseIntegrator.computeObjectiveValue(max)); + return s; + } else { + final long np = 1L << (n-1); // number of new points in this stage + double sum = 0; + final double max = baseIntegrator.getMax(); + final double min = baseIntegrator.getMin(); + // spacing between adjacent new points + final double spacing = (max - min) / np; + double x = min + 0.5 * spacing; // the first new point + for (long i = 0; i < np; i++) { + sum += baseIntegrator.computeObjectiveValue(x); + x += spacing; + } + // add the new sum to previously calculated result + s = 0.5 * (s + sum * spacing); + return s; + } + } + + /** {@inheritDoc} */ + @Override + protected double doIntegrate() + throws MathIllegalArgumentException, TooManyEvaluationsException, MaxCountExceededException { + + double oldt = stage(this, 0); + incrementCount(); + while (true) { + final int i = getIterations(); + final double t = stage(this, i); + if (i >= getMinimalIterationCount()) { + final double delta = FastMath.abs(t - oldt); + final double rLimit = + getRelativeAccuracy() * (FastMath.abs(oldt) + FastMath.abs(t)) * 0.5; + if ((delta <= rLimit) || (delta <= getAbsoluteAccuracy())) { + return t; + } + } + oldt = t; + incrementCount(); + } + + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/UnivariateIntegrator.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/UnivariateIntegrator.java new file mode 100644 index 000000000..46b12cc2e --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/UnivariateIntegrator.java @@ -0,0 +1,95 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.integration; + +import com.fr.third.org.apache.commons.math3.exception.MathIllegalArgumentException; +import com.fr.third.org.apache.commons.math3.exception.MaxCountExceededException; +import com.fr.third.org.apache.commons.math3.exception.NullArgumentException; +import com.fr.third.org.apache.commons.math3.exception.TooManyEvaluationsException; +import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction; + +/** + * Interface for univariate real integration algorithms. + * + * @since 1.2 + */ +public interface UnivariateIntegrator { + + /** + * Get the relative accuracy. + * + * @return the accuracy + */ + double getRelativeAccuracy(); + + /** + * Get the absolute accuracy. + * + * @return the accuracy + */ + double getAbsoluteAccuracy(); + + /** + * Get the min limit for the number of iterations. + * + * @return the actual min limit + */ + int getMinimalIterationCount(); + + /** + * Get the upper limit for the number of iterations. + * + * @return the actual upper limit + */ + int getMaximalIterationCount(); + + /** + * Integrate the function in the given interval. + * + * @param maxEval Maximum number of evaluations. + * @param f the integrand function + * @param min the lower bound for the interval + * @param max the upper bound for the interval + * @return the value of integral + * @throws TooManyEvaluationsException if the maximum number of function + * evaluations is exceeded + * @throws MaxCountExceededException if the maximum iteration count is exceeded + * or the integrator detects convergence problems otherwise + * @throws MathIllegalArgumentException if {@code min > max} or the endpoints do not + * satisfy the requirements specified by the integrator + * @throws NullArgumentException if {@code f} is {@code null}. + */ + double integrate(int maxEval, UnivariateFunction f, double min, + double max) + throws TooManyEvaluationsException, MaxCountExceededException, + MathIllegalArgumentException, NullArgumentException; + + /** + * Get the number of function evaluations of the last run of the integrator. + * + * @return number of function evaluations + */ + int getEvaluations(); + + /** + * Get the number of iterations of the last run of the integrator. + * + * @return number of iterations + */ + int getIterations(); + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/gauss/BaseRuleFactory.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/gauss/BaseRuleFactory.java new file mode 100644 index 000000000..54d240fbd --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/integration/gauss/BaseRuleFactory.java @@ -0,0 +1,154 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.integration.gauss; + +import java.util.Map; +import java.util.TreeMap; + +import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException; +import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException; +import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats; +import com.fr.third.org.apache.commons.math3.util.Pair; + +/** + * Base class for rules that determines the integration nodes and their + * weights. + * Subclasses must implement the {@link #computeRule(int) computeRule} method. + * + * @param+ * \(f(x) e^{-x^2}\) + *
+ * Recurrence relation and weights computation follow + * + * Abramowitz and Stegun, 1964. + *
+ * The coefficients of the standard Hermite polynomials grow very rapidly. + * In order to avoid overflows, each Hermite polynomial is normalized with + * respect to the underlying scalar product. + * The initial interval for the application of the bisection method is + * based on the roots of the previous Hermite polynomial (interlacing). + * Upper and lower bounds of these roots are provided by
+ *+ * I. Krasikov, + * Nonnegative quadratic forms and bounds on orthogonal polynomials, + * Journal of Approximation theory 111, 31-49 + *+ * + * @since 3.3 + */ +public class HermiteRuleFactory extends BaseRuleFactory
+ * This implementation is based on the Akima implementation in the CubicSpline + * class in the Math.NET Numerics library. The method referenced is + * CubicSpline.InterpolateAkimaSorted + *
+ *+ * The {@link #interpolate(double[], double[]) interpolate} method returns a + * {@link PolynomialSplineFunction} consisting of n cubic polynomials, defined + * over the subintervals determined by the x values, {@code x[0] < x[i] ... < x[n]}. + * The Akima algorithm requires that {@code n >= 5}. + *
+ */ +public class AkimaSplineInterpolator + implements UnivariateInterpolator { + /** The minimum number of points that are needed to compute the function. */ + private static final int MINIMUM_NUMBER_POINTS = 5; + + /** + * Computes an interpolating function for the data set. + * + * @param xvals the arguments for the interpolation points + * @param yvals the values for the interpolation points + * @return a function which interpolates the data set + * @throws DimensionMismatchException if {@code xvals} and {@code yvals} have + * different sizes. + * @throws NonMonotonicSequenceException if {@code xvals} is not sorted in + * strict increasing order. + * @throws NumberIsTooSmallException if the size of {@code xvals} is smaller + * than 5. + */ + public PolynomialSplineFunction interpolate(double[] xvals, + double[] yvals) + throws DimensionMismatchException, + NumberIsTooSmallException, + NonMonotonicSequenceException { + if (xvals == null || + yvals == null) { + throw new NullArgumentException(); + } + + if (xvals.length != yvals.length) { + throw new DimensionMismatchException(xvals.length, yvals.length); + } + + if (xvals.length < MINIMUM_NUMBER_POINTS) { + throw new NumberIsTooSmallException(LocalizedFormats.NUMBER_OF_POINTS, + xvals.length, + MINIMUM_NUMBER_POINTS, true); + } + + MathArrays.checkOrder(xvals); + + final int numberOfDiffAndWeightElements = xvals.length - 1; + + final double[] differences = new double[numberOfDiffAndWeightElements]; + final double[] weights = new double[numberOfDiffAndWeightElements]; + + for (int i = 0; i < differences.length; i++) { + differences[i] = (yvals[i + 1] - yvals[i]) / (xvals[i + 1] - xvals[i]); + } + + for (int i = 1; i < weights.length; i++) { + weights[i] = FastMath.abs(differences[i] - differences[i - 1]); + } + + // Prepare Hermite interpolation scheme. + final double[] firstDerivatives = new double[xvals.length]; + + for (int i = 2; i < firstDerivatives.length - 2; i++) { + final double wP = weights[i + 1]; + final double wM = weights[i - 1]; + if (Precision.equals(wP, 0.0) && + Precision.equals(wM, 0.0)) { + final double xv = xvals[i]; + final double xvP = xvals[i + 1]; + final double xvM = xvals[i - 1]; + firstDerivatives[i] = (((xvP - xv) * differences[i - 1]) + ((xv - xvM) * differences[i])) / (xvP - xvM); + } else { + firstDerivatives[i] = ((wP * differences[i - 1]) + (wM * differences[i])) / (wP + wM); + } + } + + firstDerivatives[0] = differentiateThreePoint(xvals, yvals, 0, 0, 1, 2); + firstDerivatives[1] = differentiateThreePoint(xvals, yvals, 1, 0, 1, 2); + firstDerivatives[xvals.length - 2] = differentiateThreePoint(xvals, yvals, xvals.length - 2, + xvals.length - 3, xvals.length - 2, + xvals.length - 1); + firstDerivatives[xvals.length - 1] = differentiateThreePoint(xvals, yvals, xvals.length - 1, + xvals.length - 3, xvals.length - 2, + xvals.length - 1); + + return interpolateHermiteSorted(xvals, yvals, firstDerivatives); + } + + /** + * Three point differentiation helper, modeled off of the same method in the + * Math.NET CubicSpline class. This is used by both the Apache Math and the + * Math.NET Akima Cubic Spline algorithms + * + * @param xvals x values to calculate the numerical derivative with + * @param yvals y values to calculate the numerical derivative with + * @param indexOfDifferentiation index of the elemnt we are calculating the derivative around + * @param indexOfFirstSample index of the first element to sample for the three point method + * @param indexOfSecondsample index of the second element to sample for the three point method + * @param indexOfThirdSample index of the third element to sample for the three point method + * @return the derivative + */ + private double differentiateThreePoint(double[] xvals, double[] yvals, + int indexOfDifferentiation, + int indexOfFirstSample, + int indexOfSecondsample, + int indexOfThirdSample) { + final double x0 = yvals[indexOfFirstSample]; + final double x1 = yvals[indexOfSecondsample]; + final double x2 = yvals[indexOfThirdSample]; + + final double t = xvals[indexOfDifferentiation] - xvals[indexOfFirstSample]; + final double t1 = xvals[indexOfSecondsample] - xvals[indexOfFirstSample]; + final double t2 = xvals[indexOfThirdSample] - xvals[indexOfFirstSample]; + + final double a = (x2 - x0 - (t2 / t1 * (x1 - x0))) / (t2 * t2 - t1 * t2); + final double b = (x1 - x0 - a * t1 * t1) / t1; + + return (2 * a * t) + b; + } + + /** + * Creates a Hermite cubic spline interpolation from the set of (x,y) value + * pairs and their derivatives. This is modeled off of the + * InterpolateHermiteSorted method in the Math.NET CubicSpline class. + * + * @param xvals x values for interpolation + * @param yvals y values for interpolation + * @param firstDerivatives first derivative values of the function + * @return polynomial that fits the function + */ + private PolynomialSplineFunction interpolateHermiteSorted(double[] xvals, + double[] yvals, + double[] firstDerivatives) { + if (xvals.length != yvals.length) { + throw new DimensionMismatchException(xvals.length, yvals.length); + } + + if (xvals.length != firstDerivatives.length) { + throw new DimensionMismatchException(xvals.length, + firstDerivatives.length); + } + + final int minimumLength = 2; + if (xvals.length < minimumLength) { + throw new NumberIsTooSmallException(LocalizedFormats.NUMBER_OF_POINTS, + xvals.length, minimumLength, + true); + } + + final int size = xvals.length - 1; + final PolynomialFunction[] polynomials = new PolynomialFunction[size]; + final double[] coefficients = new double[4]; + + for (int i = 0; i < polynomials.length; i++) { + final double w = xvals[i + 1] - xvals[i]; + final double w2 = w * w; + + final double yv = yvals[i]; + final double yvP = yvals[i + 1]; + + final double fd = firstDerivatives[i]; + final double fdP = firstDerivatives[i + 1]; + + coefficients[0] = yv; + coefficients[1] = firstDerivatives[i]; + coefficients[2] = (3 * (yvP - yv) / w - 2 * fd - fdP) / w; + coefficients[3] = (2 * (yv - yvP) / w + fd + fdP) / w2; + polynomials[i] = new PolynomialFunction(coefficients); + } + + return new PolynomialSplineFunction(xvals, polynomials); + + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/BicubicInterpolatingFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/BicubicInterpolatingFunction.java new file mode 100644 index 000000000..55217eb33 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/BicubicInterpolatingFunction.java @@ -0,0 +1,326 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.interpolation; + +import java.util.Arrays; + +import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException; +import com.fr.third.org.apache.commons.math3.exception.NoDataException; +import com.fr.third.org.apache.commons.math3.exception.NonMonotonicSequenceException; +import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException; +import com.fr.third.org.apache.commons.math3.analysis.BivariateFunction; +import com.fr.third.org.apache.commons.math3.util.MathArrays; + +/** + * Function that implements the + * + * bicubic spline interpolation. + * + * @since 3.4 + */ +public class BicubicInterpolatingFunction + implements BivariateFunction { + /** Number of coefficients. */ + private static final int NUM_COEFF = 16; + /** + * Matrix to compute the spline coefficients from the function values + * and function derivatives values + */ + private static final double[][] AINV = { + { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0 }, + { -3,3,0,0,-2,-1,0,0,0,0,0,0,0,0,0,0 }, + { 2,-2,0,0,1,1,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0 }, + { 0,0,0,0,0,0,0,0,-3,3,0,0,-2,-1,0,0 }, + { 0,0,0,0,0,0,0,0,2,-2,0,0,1,1,0,0 }, + { -3,0,3,0,0,0,0,0,-2,0,-1,0,0,0,0,0 }, + { 0,0,0,0,-3,0,3,0,0,0,0,0,-2,0,-1,0 }, + { 9,-9,-9,9,6,3,-6,-3,6,-6,3,-3,4,2,2,1 }, + { -6,6,6,-6,-3,-3,3,3,-4,4,-2,2,-2,-2,-1,-1 }, + { 2,0,-2,0,0,0,0,0,1,0,1,0,0,0,0,0 }, + { 0,0,0,0,2,0,-2,0,0,0,0,0,1,0,1,0 }, + { -6,6,6,-6,-4,-2,4,2,-3,3,-3,3,-2,-1,-2,-1 }, + { 4,-4,-4,4,2,2,-2,-2,2,-2,2,-2,1,1,1,1 } + }; + + /** Samples x-coordinates */ + private final double[] xval; + /** Samples y-coordinates */ + private final double[] yval; + /** Set of cubic splines patching the whole data grid */ + private final BicubicFunction[][] splines; + + /** + * @param x Sample values of the x-coordinate, in increasing order. + * @param y Sample values of the y-coordinate, in increasing order. + * @param f Values of the function on every grid point. + * @param dFdX Values of the partial derivative of function with respect + * to x on every grid point. + * @param dFdY Values of the partial derivative of function with respect + * to y on every grid point. + * @param d2FdXdY Values of the cross partial derivative of function on + * every grid point. + * @throws DimensionMismatchException if the various arrays do not contain + * the expected number of elements. + * @throws NonMonotonicSequenceException if {@code x} or {@code y} are + * not strictly increasing. + * @throws NoDataException if any of the arrays has zero length. + */ + public BicubicInterpolatingFunction(double[] x, + double[] y, + double[][] f, + double[][] dFdX, + double[][] dFdY, + double[][] d2FdXdY) + throws DimensionMismatchException, + NoDataException, + NonMonotonicSequenceException { + final int xLen = x.length; + final int yLen = y.length; + + if (xLen == 0 || yLen == 0 || f.length == 0 || f[0].length == 0) { + throw new NoDataException(); + } + if (xLen != f.length) { + throw new DimensionMismatchException(xLen, f.length); + } + if (xLen != dFdX.length) { + throw new DimensionMismatchException(xLen, dFdX.length); + } + if (xLen != dFdY.length) { + throw new DimensionMismatchException(xLen, dFdY.length); + } + if (xLen != d2FdXdY.length) { + throw new DimensionMismatchException(xLen, d2FdXdY.length); + } + + MathArrays.checkOrder(x); + MathArrays.checkOrder(y); + + xval = x.clone(); + yval = y.clone(); + + final int lastI = xLen - 1; + final int lastJ = yLen - 1; + splines = new BicubicFunction[lastI][lastJ]; + + for (int i = 0; i < lastI; i++) { + if (f[i].length != yLen) { + throw new DimensionMismatchException(f[i].length, yLen); + } + if (dFdX[i].length != yLen) { + throw new DimensionMismatchException(dFdX[i].length, yLen); + } + if (dFdY[i].length != yLen) { + throw new DimensionMismatchException(dFdY[i].length, yLen); + } + if (d2FdXdY[i].length != yLen) { + throw new DimensionMismatchException(d2FdXdY[i].length, yLen); + } + final int ip1 = i + 1; + final double xR = xval[ip1] - xval[i]; + for (int j = 0; j < lastJ; j++) { + final int jp1 = j + 1; + final double yR = yval[jp1] - yval[j]; + final double xRyR = xR * yR; + final double[] beta = new double[] { + f[i][j], f[ip1][j], f[i][jp1], f[ip1][jp1], + dFdX[i][j] * xR, dFdX[ip1][j] * xR, dFdX[i][jp1] * xR, dFdX[ip1][jp1] * xR, + dFdY[i][j] * yR, dFdY[ip1][j] * yR, dFdY[i][jp1] * yR, dFdY[ip1][jp1] * yR, + d2FdXdY[i][j] * xRyR, d2FdXdY[ip1][j] * xRyR, d2FdXdY[i][jp1] * xRyR, d2FdXdY[ip1][jp1] * xRyR + }; + + splines[i][j] = new BicubicFunction(computeSplineCoefficients(beta)); + } + } + } + + /** + * {@inheritDoc} + */ + public double value(double x, double y) + throws OutOfRangeException { + final int i = searchIndex(x, xval); + final int j = searchIndex(y, yval); + + final double xN = (x - xval[i]) / (xval[i + 1] - xval[i]); + final double yN = (y - yval[j]) / (yval[j + 1] - yval[j]); + + return splines[i][j].value(xN, yN); + } + + /** + * Indicates whether a point is within the interpolation range. + * + * @param x First coordinate. + * @param y Second coordinate. + * @return {@code true} if (x, y) is a valid point. + */ + public boolean isValidPoint(double x, double y) { + if (x < xval[0] || + x > xval[xval.length - 1] || + y < yval[0] || + y > yval[yval.length - 1]) { + return false; + } else { + return true; + } + } + + /** + * @param c Coordinate. + * @param val Coordinate samples. + * @return the index in {@code val} corresponding to the interval + * containing {@code c}. + * @throws OutOfRangeException if {@code c} is out of the + * range defined by the boundary values of {@code val}. + */ + private int searchIndex(double c, double[] val) { + final int r = Arrays.binarySearch(val, c); + + if (r == -1 || + r == -val.length - 1) { + throw new OutOfRangeException(c, val[0], val[val.length - 1]); + } + + if (r < 0) { + // "c" in within an interpolation sub-interval: Return the + // index of the sample at the lower end of the sub-interval. + return -r - 2; + } + final int last = val.length - 1; + if (r == last) { + // "c" is the last sample of the range: Return the index + // of the sample at the lower end of the last sub-interval. + return last - 1; + } + + // "c" is another sample point. + return r; + } + + /** + * Compute the spline coefficients from the list of function values and + * function partial derivatives values at the four corners of a grid + * element. They must be specified in the following order: + *+ * Caveat: Because the interpolation scheme requires that derivatives be + * specified at the sample points, those are approximated with finite + * differences (using the 2-points symmetric formulae). + * Since their values are undefined at the borders of the provided + * interpolation ranges, the interpolated values will be wrong at the + * edges of the patch. + * The {@code interpolate} method will return a function that overrides + * {@link BicubicInterpolatingFunction#isValidPoint(double,double)} to + * indicate points where the interpolation will be inaccurate. + *
+ * + * @since 3.4 + */ +public class BicubicInterpolator + implements BivariateGridInterpolator { + /** + * {@inheritDoc} + */ + public BicubicInterpolatingFunction interpolate(final double[] xval, + final double[] yval, + final double[][] fval) + throws NoDataException, DimensionMismatchException, + NonMonotonicSequenceException, NumberIsTooSmallException { + if (xval.length == 0 || yval.length == 0 || fval.length == 0) { + throw new NoDataException(); + } + if (xval.length != fval.length) { + throw new DimensionMismatchException(xval.length, fval.length); + } + + MathArrays.checkOrder(xval); + MathArrays.checkOrder(yval); + + final int xLen = xval.length; + final int yLen = yval.length; + + // Approximation to the partial derivatives using finite differences. + final double[][] dFdX = new double[xLen][yLen]; + final double[][] dFdY = new double[xLen][yLen]; + final double[][] d2FdXdY = new double[xLen][yLen]; + for (int i = 1; i < xLen - 1; i++) { + final int nI = i + 1; + final int pI = i - 1; + + final double nX = xval[nI]; + final double pX = xval[pI]; + + final double deltaX = nX - pX; + + for (int j = 1; j < yLen - 1; j++) { + final int nJ = j + 1; + final int pJ = j - 1; + + final double nY = yval[nJ]; + final double pY = yval[pJ]; + + final double deltaY = nY - pY; + + dFdX[i][j] = (fval[nI][j] - fval[pI][j]) / deltaX; + dFdY[i][j] = (fval[i][nJ] - fval[i][pJ]) / deltaY; + + final double deltaXY = deltaX * deltaY; + + d2FdXdY[i][j] = (fval[nI][nJ] - fval[nI][pJ] - fval[pI][nJ] + fval[pI][pJ]) / deltaXY; + } + } + + // Create the interpolating function. + return new BicubicInterpolatingFunction(xval, yval, fval, + dFdX, dFdY, d2FdXdY) { + /** {@inheritDoc} */ + @Override + public boolean isValidPoint(double x, double y) { + if (x < xval[1] || + x > xval[xval.length - 2] || + y < yval[1] || + y > yval[yval.length - 2]) { + return false; + } else { + return true; + } + } + }; + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/BicubicSplineInterpolatingFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/BicubicSplineInterpolatingFunction.java new file mode 100644 index 000000000..f3eecf720 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/BicubicSplineInterpolatingFunction.java @@ -0,0 +1,642 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.interpolation; + +import java.util.Arrays; + +import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException; +import com.fr.third.org.apache.commons.math3.exception.NoDataException; +import com.fr.third.org.apache.commons.math3.exception.NonMonotonicSequenceException; +import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException; +import com.fr.third.org.apache.commons.math3.analysis.BivariateFunction; +import com.fr.third.org.apache.commons.math3.util.MathArrays; + +/** + * Function that implements the + * + * bicubic spline interpolation. Due to numerical accuracy issues this should not + * be used. + * + * @since 2.1 + * @deprecated as of 3.4 replaced by + * {@link PiecewiseBicubicSplineInterpolatingFunction} + */ +@Deprecated +public class BicubicSplineInterpolatingFunction + implements BivariateFunction { + /** Number of coefficients. */ + private static final int NUM_COEFF = 16; + /** + * Matrix to compute the spline coefficients from the function values + * and function derivatives values + */ + private static final double[][] AINV = { + { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0 }, + { -3,3,0,0,-2,-1,0,0,0,0,0,0,0,0,0,0 }, + { 2,-2,0,0,1,1,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0 }, + { 0,0,0,0,0,0,0,0,-3,3,0,0,-2,-1,0,0 }, + { 0,0,0,0,0,0,0,0,2,-2,0,0,1,1,0,0 }, + { -3,0,3,0,0,0,0,0,-2,0,-1,0,0,0,0,0 }, + { 0,0,0,0,-3,0,3,0,0,0,0,0,-2,0,-1,0 }, + { 9,-9,-9,9,6,3,-6,-3,6,-6,3,-3,4,2,2,1 }, + { -6,6,6,-6,-3,-3,3,3,-4,4,-2,2,-2,-2,-1,-1 }, + { 2,0,-2,0,0,0,0,0,1,0,1,0,0,0,0,0 }, + { 0,0,0,0,2,0,-2,0,0,0,0,0,1,0,1,0 }, + { -6,6,6,-6,-4,-2,4,2,-3,3,-3,3,-2,-1,-2,-1 }, + { 4,-4,-4,4,2,2,-2,-2,2,-2,2,-2,1,1,1,1 } + }; + + /** Samples x-coordinates */ + private final double[] xval; + /** Samples y-coordinates */ + private final double[] yval; + /** Set of cubic splines patching the whole data grid */ + private final BicubicSplineFunction[][] splines; + /** + * Partial derivatives. + * The value of the first index determines the kind of derivatives: + * 0 = first partial derivatives wrt x + * 1 = first partial derivatives wrt y + * 2 = second partial derivatives wrt x + * 3 = second partial derivatives wrt y + * 4 = cross partial derivatives + */ + private final BivariateFunction[][][] partialDerivatives; + + /** + * @param x Sample values of the x-coordinate, in increasing order. + * @param y Sample values of the y-coordinate, in increasing order. + * @param f Values of the function on every grid point. + * @param dFdX Values of the partial derivative of function with respect + * to x on every grid point. + * @param dFdY Values of the partial derivative of function with respect + * to y on every grid point. + * @param d2FdXdY Values of the cross partial derivative of function on + * every grid point. + * @throws DimensionMismatchException if the various arrays do not contain + * the expected number of elements. + * @throws NonMonotonicSequenceException if {@code x} or {@code y} are + * not strictly increasing. + * @throws NoDataException if any of the arrays has zero length. + */ + public BicubicSplineInterpolatingFunction(double[] x, + double[] y, + double[][] f, + double[][] dFdX, + double[][] dFdY, + double[][] d2FdXdY) + throws DimensionMismatchException, + NoDataException, + NonMonotonicSequenceException { + this(x, y, f, dFdX, dFdY, d2FdXdY, false); + } + + /** + * @param x Sample values of the x-coordinate, in increasing order. + * @param y Sample values of the y-coordinate, in increasing order. + * @param f Values of the function on every grid point. + * @param dFdX Values of the partial derivative of function with respect + * to x on every grid point. + * @param dFdY Values of the partial derivative of function with respect + * to y on every grid point. + * @param d2FdXdY Values of the cross partial derivative of function on + * every grid point. + * @param initializeDerivatives Whether to initialize the internal data + * needed for calling any of the methods that compute the partial derivatives + * this function. + * @throws DimensionMismatchException if the various arrays do not contain + * the expected number of elements. + * @throws NonMonotonicSequenceException if {@code x} or {@code y} are + * not strictly increasing. + * @throws NoDataException if any of the arrays has zero length. + * + * @see #partialDerivativeX(double,double) + * @see #partialDerivativeY(double,double) + * @see #partialDerivativeXX(double,double) + * @see #partialDerivativeYY(double,double) + * @see #partialDerivativeXY(double,double) + */ + public BicubicSplineInterpolatingFunction(double[] x, + double[] y, + double[][] f, + double[][] dFdX, + double[][] dFdY, + double[][] d2FdXdY, + boolean initializeDerivatives) + throws DimensionMismatchException, + NoDataException, + NonMonotonicSequenceException { + final int xLen = x.length; + final int yLen = y.length; + + if (xLen == 0 || yLen == 0 || f.length == 0 || f[0].length == 0) { + throw new NoDataException(); + } + if (xLen != f.length) { + throw new DimensionMismatchException(xLen, f.length); + } + if (xLen != dFdX.length) { + throw new DimensionMismatchException(xLen, dFdX.length); + } + if (xLen != dFdY.length) { + throw new DimensionMismatchException(xLen, dFdY.length); + } + if (xLen != d2FdXdY.length) { + throw new DimensionMismatchException(xLen, d2FdXdY.length); + } + + MathArrays.checkOrder(x); + MathArrays.checkOrder(y); + + xval = x.clone(); + yval = y.clone(); + + final int lastI = xLen - 1; + final int lastJ = yLen - 1; + splines = new BicubicSplineFunction[lastI][lastJ]; + + for (int i = 0; i < lastI; i++) { + if (f[i].length != yLen) { + throw new DimensionMismatchException(f[i].length, yLen); + } + if (dFdX[i].length != yLen) { + throw new DimensionMismatchException(dFdX[i].length, yLen); + } + if (dFdY[i].length != yLen) { + throw new DimensionMismatchException(dFdY[i].length, yLen); + } + if (d2FdXdY[i].length != yLen) { + throw new DimensionMismatchException(d2FdXdY[i].length, yLen); + } + final int ip1 = i + 1; + for (int j = 0; j < lastJ; j++) { + final int jp1 = j + 1; + final double[] beta = new double[] { + f[i][j], f[ip1][j], f[i][jp1], f[ip1][jp1], + dFdX[i][j], dFdX[ip1][j], dFdX[i][jp1], dFdX[ip1][jp1], + dFdY[i][j], dFdY[ip1][j], dFdY[i][jp1], dFdY[ip1][jp1], + d2FdXdY[i][j], d2FdXdY[ip1][j], d2FdXdY[i][jp1], d2FdXdY[ip1][jp1] + }; + + splines[i][j] = new BicubicSplineFunction(computeSplineCoefficients(beta), + initializeDerivatives); + } + } + + if (initializeDerivatives) { + // Compute all partial derivatives. + partialDerivatives = new BivariateFunction[5][lastI][lastJ]; + + for (int i = 0; i < lastI; i++) { + for (int j = 0; j < lastJ; j++) { + final BicubicSplineFunction bcs = splines[i][j]; + partialDerivatives[0][i][j] = bcs.partialDerivativeX(); + partialDerivatives[1][i][j] = bcs.partialDerivativeY(); + partialDerivatives[2][i][j] = bcs.partialDerivativeXX(); + partialDerivatives[3][i][j] = bcs.partialDerivativeYY(); + partialDerivatives[4][i][j] = bcs.partialDerivativeXY(); + } + } + } else { + // Partial derivative methods cannot be used. + partialDerivatives = null; + } + } + + /** + * {@inheritDoc} + */ + public double value(double x, double y) + throws OutOfRangeException { + final int i = searchIndex(x, xval); + final int j = searchIndex(y, yval); + + final double xN = (x - xval[i]) / (xval[i + 1] - xval[i]); + final double yN = (y - yval[j]) / (yval[j + 1] - yval[j]); + + return splines[i][j].value(xN, yN); + } + + /** + * Indicates whether a point is within the interpolation range. + * + * @param x First coordinate. + * @param y Second coordinate. + * @return {@code true} if (x, y) is a valid point. + * @since 3.3 + */ + public boolean isValidPoint(double x, double y) { + if (x < xval[0] || + x > xval[xval.length - 1] || + y < yval[0] || + y > yval[yval.length - 1]) { + return false; + } else { + return true; + } + } + + /** + * @param x x-coordinate. + * @param y y-coordinate. + * @return the value at point (x, y) of the first partial derivative with + * respect to x. + * @throws OutOfRangeException if {@code x} (resp. {@code y}) is outside + * the range defined by the boundary values of {@code xval} (resp. + * {@code yval}). + * @throws NullPointerException if the internal data were not initialized + * (cf. {@link #BicubicSplineInterpolatingFunction(double[],double[],double[][], + * double[][],double[][],double[][],boolean) constructor}). + */ + public double partialDerivativeX(double x, double y) + throws OutOfRangeException { + return partialDerivative(0, x, y); + } + /** + * @param x x-coordinate. + * @param y y-coordinate. + * @return the value at point (x, y) of the first partial derivative with + * respect to y. + * @throws OutOfRangeException if {@code x} (resp. {@code y}) is outside + * the range defined by the boundary values of {@code xval} (resp. + * {@code yval}). + * @throws NullPointerException if the internal data were not initialized + * (cf. {@link #BicubicSplineInterpolatingFunction(double[],double[],double[][], + * double[][],double[][],double[][],boolean) constructor}). + */ + public double partialDerivativeY(double x, double y) + throws OutOfRangeException { + return partialDerivative(1, x, y); + } + /** + * @param x x-coordinate. + * @param y y-coordinate. + * @return the value at point (x, y) of the second partial derivative with + * respect to x. + * @throws OutOfRangeException if {@code x} (resp. {@code y}) is outside + * the range defined by the boundary values of {@code xval} (resp. + * {@code yval}). + * @throws NullPointerException if the internal data were not initialized + * (cf. {@link #BicubicSplineInterpolatingFunction(double[],double[],double[][], + * double[][],double[][],double[][],boolean) constructor}). + */ + public double partialDerivativeXX(double x, double y) + throws OutOfRangeException { + return partialDerivative(2, x, y); + } + /** + * @param x x-coordinate. + * @param y y-coordinate. + * @return the value at point (x, y) of the second partial derivative with + * respect to y. + * @throws OutOfRangeException if {@code x} (resp. {@code y}) is outside + * the range defined by the boundary values of {@code xval} (resp. + * {@code yval}). + * @throws NullPointerException if the internal data were not initialized + * (cf. {@link #BicubicSplineInterpolatingFunction(double[],double[],double[][], + * double[][],double[][],double[][],boolean) constructor}). + */ + public double partialDerivativeYY(double x, double y) + throws OutOfRangeException { + return partialDerivative(3, x, y); + } + /** + * @param x x-coordinate. + * @param y y-coordinate. + * @return the value at point (x, y) of the second partial cross-derivative. + * @throws OutOfRangeException if {@code x} (resp. {@code y}) is outside + * the range defined by the boundary values of {@code xval} (resp. + * {@code yval}). + * @throws NullPointerException if the internal data were not initialized + * (cf. {@link #BicubicSplineInterpolatingFunction(double[],double[],double[][], + * double[][],double[][],double[][],boolean) constructor}). + */ + public double partialDerivativeXY(double x, double y) + throws OutOfRangeException { + return partialDerivative(4, x, y); + } + + /** + * @param which First index in {@link #partialDerivatives}. + * @param x x-coordinate. + * @param y y-coordinate. + * @return the value at point (x, y) of the selected partial derivative. + * @throws OutOfRangeException if {@code x} (resp. {@code y}) is outside + * the range defined by the boundary values of {@code xval} (resp. + * {@code yval}). + * @throws NullPointerException if the internal data were not initialized + * (cf. {@link #BicubicSplineInterpolatingFunction(double[],double[],double[][], + * double[][],double[][],double[][],boolean) constructor}). + */ + private double partialDerivative(int which, double x, double y) + throws OutOfRangeException { + final int i = searchIndex(x, xval); + final int j = searchIndex(y, yval); + + final double xN = (x - xval[i]) / (xval[i + 1] - xval[i]); + final double yN = (y - yval[j]) / (yval[j + 1] - yval[j]); + + return partialDerivatives[which][i][j].value(xN, yN); + } + + /** + * @param c Coordinate. + * @param val Coordinate samples. + * @return the index in {@code val} corresponding to the interval + * containing {@code c}. + * @throws OutOfRangeException if {@code c} is out of the + * range defined by the boundary values of {@code val}. + */ + private int searchIndex(double c, double[] val) { + final int r = Arrays.binarySearch(val, c); + + if (r == -1 || + r == -val.length - 1) { + throw new OutOfRangeException(c, val[0], val[val.length - 1]); + } + + if (r < 0) { + // "c" in within an interpolation sub-interval: Return the + // index of the sample at the lower end of the sub-interval. + return -r - 2; + } + final int last = val.length - 1; + if (r == last) { + // "c" is the last sample of the range: Return the index + // of the sample at the lower end of the last sub-interval. + return last - 1; + } + + // "c" is another sample point. + return r; + } + + /** + * Compute the spline coefficients from the list of function values and + * function partial derivatives values at the four corners of a grid + * element. They must be specified in the following order: + *+ * The actual code of Neville's evaluation is in PolynomialFunctionLagrangeForm, + * this class provides an easy-to-use interface to it.
+ * + * @since 1.2 + */ +public class DividedDifferenceInterpolator + implements UnivariateInterpolator, Serializable { + /** serializable version identifier */ + private static final long serialVersionUID = 107049519551235069L; + + /** + * Compute an interpolating function for the dataset. + * + * @param x Interpolating points array. + * @param y Interpolating values array. + * @return a function which interpolates the dataset. + * @throws DimensionMismatchException if the array lengths are different. + * @throws NumberIsTooSmallException if the number of points is less than 2. + * @throws NonMonotonicSequenceException if {@code x} is not sorted in + * strictly increasing order. + */ + public PolynomialFunctionNewtonForm interpolate(double x[], double y[]) + throws DimensionMismatchException, + NumberIsTooSmallException, + NonMonotonicSequenceException { + /** + * a[] and c[] are defined in the general formula of Newton form: + * p(x) = a[0] + a[1](x-c[0]) + a[2](x-c[0])(x-c[1]) + ... + + * a[n](x-c[0])(x-c[1])...(x-c[n-1]) + */ + PolynomialFunctionLagrangeForm.verifyInterpolationArray(x, y, true); + + /** + * When used for interpolation, the Newton form formula becomes + * p(x) = f[x0] + f[x0,x1](x-x0) + f[x0,x1,x2](x-x0)(x-x1) + ... + + * f[x0,x1,...,x[n-1]](x-x0)(x-x1)...(x-x[n-2]) + * Therefore, a[k] = f[x0,x1,...,xk], c[k] = x[k]. + *+ * Note x[], y[], a[] have the same length but c[]'s size is one less.
+ */ + final double[] c = new double[x.length-1]; + System.arraycopy(x, 0, c, 0, c.length); + + final double[] a = computeDividedDifference(x, y); + return new PolynomialFunctionNewtonForm(a, c); + } + + /** + * Return a copy of the divided difference array. + *+ * The divided difference array is defined recursively by
+ * f[x0] = f(x0) + * f[x0,x1,...,xk] = (f[x1,...,xk] - f[x0,...,x[k-1]]) / (xk - x0) + *+ *
+ * The computational complexity is \(O(n^2)\) where \(n\) is the common + * length of {@code x} and {@code y}.
+ * + * @param x Interpolating points array. + * @param y Interpolating values array. + * @return a fresh copy of the divided difference array. + * @throws DimensionMismatchException if the array lengths are different. + * @throws NumberIsTooSmallException if the number of points is less than 2. + * @throws NonMonotonicSequenceException + * if {@code x} is not sorted in strictly increasing order. + */ + protected static double[] computeDividedDifference(final double x[], final double y[]) + throws DimensionMismatchException, + NumberIsTooSmallException, + NonMonotonicSequenceException { + PolynomialFunctionLagrangeForm.verifyInterpolationArray(x, y, true); + + final double[] divdiff = y.clone(); // initialization + + final int n = x.length; + final double[] a = new double [n]; + a[0] = divdiff[0]; + for (int i = 1; i < n; i++) { + for (int j = 0; j < n-i; j++) { + final double denominator = x[j+i] - x[j]; + divdiff[j] = (divdiff[j+1] - divdiff[j]) / denominator; + } + a[i] = divdiff[0]; + } + + return a; + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/FieldHermiteInterpolator.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/FieldHermiteInterpolator.java new file mode 100644 index 000000000..d9a8b7e80 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/FieldHermiteInterpolator.java @@ -0,0 +1,209 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.interpolation; + +import java.util.ArrayList; +import java.util.List; + +import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException; +import com.fr.third.org.apache.commons.math3.exception.MathArithmeticException; +import com.fr.third.org.apache.commons.math3.exception.NoDataException; +import com.fr.third.org.apache.commons.math3.exception.NullArgumentException; +import com.fr.third.org.apache.commons.math3.exception.ZeroException; +import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats; +import com.fr.third.org.apache.commons.math3.FieldElement; +import com.fr.third.org.apache.commons.math3.util.MathArrays; +import com.fr.third.org.apache.commons.math3.util.MathUtils; + +/** Polynomial interpolator using both sample values and sample derivatives. + *+ * The interpolation polynomials match all sample points, including both values + * and provided derivatives. There is one polynomial for each component of + * the values vector. All polynomials have the same degree. The degree of the + * polynomials depends on the number of points and number of derivatives at each + * point. For example the interpolation polynomials for n sample points without + * any derivatives all have degree n-1. The interpolation polynomials for n + * sample points with the two extreme points having value and first derivative + * and the remaining points having value only all have degree n+1. The + * interpolation polynomial for n sample points with value, first and second + * derivative for all points all have degree 3n-1. + *
+ * + * @param+ * This method must be called once for each sample point. It is allowed to + * mix some calls with values only with calls with values and first + * derivatives. + *
+ *+ * The point abscissae for all calls must be different. + *
+ * @param x abscissa of the sample point + * @param value value and derivatives of the sample point + * (if only one row is passed, it is the value, if two rows are + * passed the first one is the value and the second the derivative + * and so on) + * @exception ZeroException if the abscissa difference between added point + * and a previous point is zero (i.e. the two points are at same abscissa) + * @exception MathArithmeticException if the number of derivatives is larger + * than 20, which prevents computation of a factorial + * @throws DimensionMismatchException if derivative structures are inconsistent + * @throws NullArgumentException if x is null + */ + public void addSamplePoint(final T x, final T[] ... value) + throws ZeroException, MathArithmeticException, + DimensionMismatchException, NullArgumentException { + + MathUtils.checkNotNull(x); + T factorial = x.getField().getOne(); + for (int i = 0; i < value.length; ++i) { + + final T[] y = value[i].clone(); + if (i > 1) { + factorial = factorial.multiply(i); + final T inv = factorial.reciprocal(); + for (int j = 0; j < y.length; ++j) { + y[j] = y[j].multiply(inv); + } + } + + // update the bottom diagonal of the divided differences array + final int n = abscissae.size(); + bottomDiagonal.add(n - i, y); + T[] bottom0 = y; + for (int j = i; j < n; ++j) { + final T[] bottom1 = bottomDiagonal.get(n - (j + 1)); + if (x.equals(abscissae.get(n - (j + 1)))) { + throw new ZeroException(LocalizedFormats.DUPLICATED_ABSCISSA_DIVISION_BY_ZERO, x); + } + final T inv = x.subtract(abscissae.get(n - (j + 1))).reciprocal(); + for (int k = 0; k < y.length; ++k) { + bottom1[k] = inv.multiply(bottom0[k].subtract(bottom1[k])); + } + bottom0 = bottom1; + } + + // update the top diagonal of the divided differences array + topDiagonal.add(bottom0.clone()); + + // update the abscissae array + abscissae.add(x); + + } + + } + + /** Interpolate value at a specified abscissa. + * @param x interpolation abscissa + * @return interpolated value + * @exception NoDataException if sample is empty + * @throws NullArgumentException if x is null + */ + public T[] value(T x) throws NoDataException, NullArgumentException { + + // safety check + MathUtils.checkNotNull(x); + if (abscissae.isEmpty()) { + throw new NoDataException(LocalizedFormats.EMPTY_INTERPOLATION_SAMPLE); + } + + final T[] value = MathArrays.buildArray(x.getField(), topDiagonal.get(0).length); + T valueCoeff = x.getField().getOne(); + for (int i = 0; i < topDiagonal.size(); ++i) { + T[] dividedDifference = topDiagonal.get(i); + for (int k = 0; k < value.length; ++k) { + value[k] = value[k].add(dividedDifference[k].multiply(valueCoeff)); + } + final T deltaX = x.subtract(abscissae.get(i)); + valueCoeff = valueCoeff.multiply(deltaX); + } + + return value; + + } + + /** Interpolate value and first derivatives at a specified abscissa. + * @param x interpolation abscissa + * @param order maximum derivation order + * @return interpolated value and derivatives (value in row 0, + * 1st derivative in row 1, ... nth derivative in row n) + * @exception NoDataException if sample is empty + * @throws NullArgumentException if x is null + */ + public T[][] derivatives(T x, int order) throws NoDataException, NullArgumentException { + + // safety check + MathUtils.checkNotNull(x); + if (abscissae.isEmpty()) { + throw new NoDataException(LocalizedFormats.EMPTY_INTERPOLATION_SAMPLE); + } + + final T zero = x.getField().getZero(); + final T one = x.getField().getOne(); + final T[] tj = MathArrays.buildArray(x.getField(), order + 1); + tj[0] = zero; + for (int i = 0; i < order; ++i) { + tj[i + 1] = tj[i].add(one); + } + + final T[][] derivatives = + MathArrays.buildArray(x.getField(), order + 1, topDiagonal.get(0).length); + final T[] valueCoeff = MathArrays.buildArray(x.getField(), order + 1); + valueCoeff[0] = x.getField().getOne(); + for (int i = 0; i < topDiagonal.size(); ++i) { + T[] dividedDifference = topDiagonal.get(i); + final T deltaX = x.subtract(abscissae.get(i)); + for (int j = order; j >= 0; --j) { + for (int k = 0; k < derivatives[j].length; ++k) { + derivatives[j][k] = + derivatives[j][k].add(dividedDifference[k].multiply(valueCoeff[j])); + } + valueCoeff[j] = valueCoeff[j].multiply(deltaX); + if (j > 0) { + valueCoeff[j] = valueCoeff[j].add(tj[j].multiply(valueCoeff[j - 1])); + } + } + } + + return derivatives; + + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/HermiteInterpolator.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/HermiteInterpolator.java new file mode 100644 index 000000000..2e427eeef --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/HermiteInterpolator.java @@ -0,0 +1,239 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.interpolation; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure; +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableVectorFunction; +import com.fr.third.org.apache.commons.math3.exception.MathArithmeticException; +import com.fr.third.org.apache.commons.math3.exception.NoDataException; +import com.fr.third.org.apache.commons.math3.exception.ZeroException; +import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats; +import com.fr.third.org.apache.commons.math3.analysis.polynomials.PolynomialFunction; +import com.fr.third.org.apache.commons.math3.util.CombinatoricsUtils; + +/** Polynomial interpolator using both sample values and sample derivatives. + *+ * The interpolation polynomials match all sample points, including both values + * and provided derivatives. There is one polynomial for each component of + * the values vector. All polynomials have the same degree. The degree of the + * polynomials depends on the number of points and number of derivatives at each + * point. For example the interpolation polynomials for n sample points without + * any derivatives all have degree n-1. The interpolation polynomials for n + * sample points with the two extreme points having value and first derivative + * and the remaining points having value only all have degree n+1. The + * interpolation polynomial for n sample points with value, first and second + * derivative for all points all have degree 3n-1. + *
+ * + * @since 3.1 + */ +public class HermiteInterpolator implements UnivariateDifferentiableVectorFunction { + + /** Sample abscissae. */ + private final List+ * This method must be called once for each sample point. It is allowed to + * mix some calls with values only with calls with values and first + * derivatives. + *
+ *+ * The point abscissae for all calls must be different. + *
+ * @param x abscissa of the sample point + * @param value value and derivatives of the sample point + * (if only one row is passed, it is the value, if two rows are + * passed the first one is the value and the second the derivative + * and so on) + * @exception ZeroException if the abscissa difference between added point + * and a previous point is zero (i.e. the two points are at same abscissa) + * @exception MathArithmeticException if the number of derivatives is larger + * than 20, which prevents computation of a factorial + */ + public void addSamplePoint(final double x, final double[] ... value) + throws ZeroException, MathArithmeticException { + + for (int i = 0; i < value.length; ++i) { + + final double[] y = value[i].clone(); + if (i > 1) { + double inv = 1.0 / CombinatoricsUtils.factorial(i); + for (int j = 0; j < y.length; ++j) { + y[j] *= inv; + } + } + + // update the bottom diagonal of the divided differences array + final int n = abscissae.size(); + bottomDiagonal.add(n - i, y); + double[] bottom0 = y; + for (int j = i; j < n; ++j) { + final double[] bottom1 = bottomDiagonal.get(n - (j + 1)); + final double inv = 1.0 / (x - abscissae.get(n - (j + 1))); + if (Double.isInfinite(inv)) { + throw new ZeroException(LocalizedFormats.DUPLICATED_ABSCISSA_DIVISION_BY_ZERO, x); + } + for (int k = 0; k < y.length; ++k) { + bottom1[k] = inv * (bottom0[k] - bottom1[k]); + } + bottom0 = bottom1; + } + + // update the top diagonal of the divided differences array + topDiagonal.add(bottom0.clone()); + + // update the abscissae array + abscissae.add(x); + + } + + } + + /** Compute the interpolation polynomials. + * @return interpolation polynomials array + * @exception NoDataException if sample is empty + */ + public PolynomialFunction[] getPolynomials() + throws NoDataException { + + // safety check + checkInterpolation(); + + // iteration initialization + final PolynomialFunction zero = polynomial(0); + PolynomialFunction[] polynomials = new PolynomialFunction[topDiagonal.get(0).length]; + for (int i = 0; i < polynomials.length; ++i) { + polynomials[i] = zero; + } + PolynomialFunction coeff = polynomial(1); + + // build the polynomials by iterating on the top diagonal of the divided differences array + for (int i = 0; i < topDiagonal.size(); ++i) { + double[] tdi = topDiagonal.get(i); + for (int k = 0; k < polynomials.length; ++k) { + polynomials[k] = polynomials[k].add(coeff.multiply(polynomial(tdi[k]))); + } + coeff = coeff.multiply(polynomial(-abscissae.get(i), 1.0)); + } + + return polynomials; + + } + + /** Interpolate value at a specified abscissa. + *+ * Calling this method is equivalent to call the {@link PolynomialFunction#value(double) + * value} methods of all polynomials returned by {@link #getPolynomials() getPolynomials}, + * except it does not build the intermediate polynomials, so this method is faster and + * numerically more stable. + *
+ * @param x interpolation abscissa + * @return interpolated value + * @exception NoDataException if sample is empty + */ + public double[] value(double x) + throws NoDataException { + + // safety check + checkInterpolation(); + + final double[] value = new double[topDiagonal.get(0).length]; + double valueCoeff = 1; + for (int i = 0; i < topDiagonal.size(); ++i) { + double[] dividedDifference = topDiagonal.get(i); + for (int k = 0; k < value.length; ++k) { + value[k] += dividedDifference[k] * valueCoeff; + } + final double deltaX = x - abscissae.get(i); + valueCoeff *= deltaX; + } + + return value; + + } + + /** Interpolate value at a specified abscissa. + *+ * Calling this method is equivalent to call the {@link + * PolynomialFunction#value(DerivativeStructure) value} methods of all polynomials + * returned by {@link #getPolynomials() getPolynomials}, except it does not build the + * intermediate polynomials, so this method is faster and numerically more stable. + *
+ * @param x interpolation abscissa + * @return interpolated value + * @exception NoDataException if sample is empty + */ + public DerivativeStructure[] value(final DerivativeStructure x) + throws NoDataException { + + // safety check + checkInterpolation(); + + final DerivativeStructure[] value = new DerivativeStructure[topDiagonal.get(0).length]; + Arrays.fill(value, x.getField().getZero()); + DerivativeStructure valueCoeff = x.getField().getOne(); + for (int i = 0; i < topDiagonal.size(); ++i) { + double[] dividedDifference = topDiagonal.get(i); + for (int k = 0; k < value.length; ++k) { + value[k] = value[k].add(valueCoeff.multiply(dividedDifference[k])); + } + final DerivativeStructure deltaX = x.subtract(abscissae.get(i)); + valueCoeff = valueCoeff.multiply(deltaX); + } + + return value; + + } + + /** Check interpolation can be performed. + * @exception NoDataException if interpolation cannot be performed + * because sample is empty + */ + private void checkInterpolation() throws NoDataException { + if (abscissae.isEmpty()) { + throw new NoDataException(LocalizedFormats.EMPTY_INTERPOLATION_SAMPLE); + } + } + + /** Create a polynomial from its coefficients. + * @param c polynomials coefficients + * @return polynomial + */ + private PolynomialFunction polynomial(double ... c) { + return new PolynomialFunction(c); + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/InterpolatingMicrosphere.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/InterpolatingMicrosphere.java new file mode 100644 index 000000000..27cf5139e --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/InterpolatingMicrosphere.java @@ -0,0 +1,386 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.interpolation; + +import java.util.List; +import java.util.ArrayList; + +import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException; +import com.fr.third.org.apache.commons.math3.exception.MaxCountExceededException; +import com.fr.third.org.apache.commons.math3.exception.NotPositiveException; +import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException; +import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException; +import com.fr.third.org.apache.commons.math3.random.UnitSphereRandomVectorGenerator; +import com.fr.third.org.apache.commons.math3.util.FastMath; +import com.fr.third.org.apache.commons.math3.util.MathArrays; + +/** + * Utility class for the {@link MicrosphereProjectionInterpolator} algorithm. + * + * @since 3.6 + */ +public class InterpolatingMicrosphere { + /** Microsphere. */ + private final List+ * For reference, see + * + * William S. Cleveland - Robust Locally Weighted Regression and Smoothing + * Scatterplots + *
+ * This class implements both the loess method and serves as an interpolation + * adapter to it, allowing one to build a spline on the obtained loess fit. + * + * @since 2.0 + */ +public class LoessInterpolator + implements UnivariateInterpolator, Serializable { + /** Default value of the bandwidth parameter. */ + public static final double DEFAULT_BANDWIDTH = 0.3; + /** Default value of the number of robustness iterations. */ + public static final int DEFAULT_ROBUSTNESS_ITERS = 2; + /** + * Default value for accuracy. + * @since 2.1 + */ + public static final double DEFAULT_ACCURACY = 1e-12; + /** serializable version identifier. */ + private static final long serialVersionUID = 5204927143605193821L; + /** + * The bandwidth parameter: when computing the loess fit at + * a particular point, this fraction of source points closest + * to the current point is taken into account for computing + * a least-squares regression. + *+ * A sensible value is usually 0.25 to 0.5.
+ */ + private final double bandwidth; + /** + * The number of robustness iterations parameter: this many + * robustness iterations are done. + *+ * A sensible value is usually 0 (just the initial fit without any + * robustness iterations) to 4.
+ */ + private final int robustnessIters; + /** + * If the median residual at a certain robustness iteration + * is less than this amount, no more iterations are done. + */ + private final double accuracy; + + /** + * Constructs a new {@link LoessInterpolator} + * with a bandwidth of {@link #DEFAULT_BANDWIDTH}, + * {@link #DEFAULT_ROBUSTNESS_ITERS} robustness iterations + * and an accuracy of {#link #DEFAULT_ACCURACY}. + * See {@link #LoessInterpolator(double, int, double)} for an explanation of + * the parameters. + */ + public LoessInterpolator() { + this.bandwidth = DEFAULT_BANDWIDTH; + this.robustnessIters = DEFAULT_ROBUSTNESS_ITERS; + this.accuracy = DEFAULT_ACCURACY; + } + + /** + * Construct a new {@link LoessInterpolator} + * with given bandwidth and number of robustness iterations. + *+ * Calling this constructor is equivalent to calling {link {@link + * #LoessInterpolator(double, int, double) LoessInterpolator(bandwidth, + * robustnessIters, LoessInterpolator.DEFAULT_ACCURACY)} + *
+ * + * @param bandwidth when computing the loess fit at + * a particular point, this fraction of source points closest + * to the current point is taken into account for computing + * a least-squares regression. + * A sensible value is usually 0.25 to 0.5, the default value is + * {@link #DEFAULT_BANDWIDTH}. + * @param robustnessIters This many robustness iterations are done. + * A sensible value is usually 0 (just the initial fit without any + * robustness iterations) to 4, the default value is + * {@link #DEFAULT_ROBUSTNESS_ITERS}. + + * @see #LoessInterpolator(double, int, double) + */ + public LoessInterpolator(double bandwidth, int robustnessIters) { + this(bandwidth, robustnessIters, DEFAULT_ACCURACY); + } + + /** + * Construct a new {@link LoessInterpolator} + * with given bandwidth, number of robustness iterations and accuracy. + * + * @param bandwidth when computing the loess fit at + * a particular point, this fraction of source points closest + * to the current point is taken into account for computing + * a least-squares regression. + * A sensible value is usually 0.25 to 0.5, the default value is + * {@link #DEFAULT_BANDWIDTH}. + * @param robustnessIters This many robustness iterations are done. + * A sensible value is usually 0 (just the initial fit without any + * robustness iterations) to 4, the default value is + * {@link #DEFAULT_ROBUSTNESS_ITERS}. + * @param accuracy If the median residual at a certain robustness iteration + * is less than this amount, no more iterations are done. + * @throws OutOfRangeException if bandwidth does not lie in the interval [0,1]. + * @throws NotPositiveException if {@code robustnessIters} is negative. + * @see #LoessInterpolator(double, int) + * @since 2.1 + */ + public LoessInterpolator(double bandwidth, int robustnessIters, double accuracy) + throws OutOfRangeException, + NotPositiveException { + if (bandwidth < 0 || + bandwidth > 1) { + throw new OutOfRangeException(LocalizedFormats.BANDWIDTH, bandwidth, 0, 1); + } + this.bandwidth = bandwidth; + if (robustnessIters < 0) { + throw new NotPositiveException(LocalizedFormats.ROBUSTNESS_ITERATIONS, robustnessIters); + } + this.robustnessIters = robustnessIters; + this.accuracy = accuracy; + } + + /** + * Compute an interpolating function by performing a loess fit + * on the data at the original abscissae and then building a cubic spline + * with a + * {@link SplineInterpolator} + * on the resulting fit. + * + * @param xval the arguments for the interpolation points + * @param yval the values for the interpolation points + * @return A cubic spline built upon a loess fit to the data at the original abscissae + * @throws NonMonotonicSequenceException if {@code xval} not sorted in + * strictly increasing order. + * @throws DimensionMismatchException if {@code xval} and {@code yval} have + * different sizes. + * @throws NoDataException if {@code xval} or {@code yval} has zero size. + * @throws NotFiniteNumberException if any of the arguments and values are + * not finite real numbers. + * @throws NumberIsTooSmallException if the bandwidth is too small to + * accomodate the size of the input data (i.e. the bandwidth must be + * larger than 2/n). + */ + public final PolynomialSplineFunction interpolate(final double[] xval, + final double[] yval) + throws NonMonotonicSequenceException, + DimensionMismatchException, + NoDataException, + NotFiniteNumberException, + NumberIsTooSmallException { + return new SplineInterpolator().interpolate(xval, smooth(xval, yval)); + } + + /** + * Compute a weighted loess fit on the data at the original abscissae. + * + * @param xval Arguments for the interpolation points. + * @param yval Values for the interpolation points. + * @param weights point weights: coefficients by which the robustness weight + * of a point is multiplied. + * @return the values of the loess fit at corresponding original abscissae. + * @throws NonMonotonicSequenceException if {@code xval} not sorted in + * strictly increasing order. + * @throws DimensionMismatchException if {@code xval} and {@code yval} have + * different sizes. + * @throws NoDataException if {@code xval} or {@code yval} has zero size. + * @throws NotFiniteNumberException if any of the arguments and values are + not finite real numbers. + * @throws NumberIsTooSmallException if the bandwidth is too small to + * accomodate the size of the input data (i.e. the bandwidth must be + * larger than 2/n). + * @since 2.1 + */ + public final double[] smooth(final double[] xval, final double[] yval, + final double[] weights) + throws NonMonotonicSequenceException, + DimensionMismatchException, + NoDataException, + NotFiniteNumberException, + NumberIsTooSmallException { + if (xval.length != yval.length) { + throw new DimensionMismatchException(xval.length, yval.length); + } + + final int n = xval.length; + + if (n == 0) { + throw new NoDataException(); + } + + checkAllFiniteReal(xval); + checkAllFiniteReal(yval); + checkAllFiniteReal(weights); + + MathArrays.checkOrder(xval); + + if (n == 1) { + return new double[]{yval[0]}; + } + + if (n == 2) { + return new double[]{yval[0], yval[1]}; + } + + int bandwidthInPoints = (int) (bandwidth * n); + + if (bandwidthInPoints < 2) { + throw new NumberIsTooSmallException(LocalizedFormats.BANDWIDTH, + bandwidthInPoints, 2, true); + } + + final double[] res = new double[n]; + + final double[] residuals = new double[n]; + final double[] sortedResiduals = new double[n]; + + final double[] robustnessWeights = new double[n]; + + // Do an initial fit and 'robustnessIters' robustness iterations. + // This is equivalent to doing 'robustnessIters+1' robustness iterations + // starting with all robustness weights set to 1. + Arrays.fill(robustnessWeights, 1); + + for (int iter = 0; iter <= robustnessIters; ++iter) { + final int[] bandwidthInterval = {0, bandwidthInPoints - 1}; + // At each x, compute a local weighted linear regression + for (int i = 0; i < n; ++i) { + final double x = xval[i]; + + // Find out the interval of source points on which + // a regression is to be made. + if (i > 0) { + updateBandwidthInterval(xval, weights, i, bandwidthInterval); + } + + final int ileft = bandwidthInterval[0]; + final int iright = bandwidthInterval[1]; + + // Compute the point of the bandwidth interval that is + // farthest from x + final int edge; + if (xval[i] - xval[ileft] > xval[iright] - xval[i]) { + edge = ileft; + } else { + edge = iright; + } + + // Compute a least-squares linear fit weighted by + // the product of robustness weights and the tricube + // weight function. + // See http://en.wikipedia.org/wiki/Linear_regression + // (section "Univariate linear case") + // and http://en.wikipedia.org/wiki/Weighted_least_squares + // (section "Weighted least squares") + double sumWeights = 0; + double sumX = 0; + double sumXSquared = 0; + double sumY = 0; + double sumXY = 0; + double denom = FastMath.abs(1.0 / (xval[edge] - x)); + for (int k = ileft; k <= iright; ++k) { + final double xk = xval[k]; + final double yk = yval[k]; + final double dist = (k < i) ? x - xk : xk - x; + final double w = tricube(dist * denom) * robustnessWeights[k] * weights[k]; + final double xkw = xk * w; + sumWeights += w; + sumX += xkw; + sumXSquared += xk * xkw; + sumY += yk * w; + sumXY += yk * xkw; + } + + final double meanX = sumX / sumWeights; + final double meanY = sumY / sumWeights; + final double meanXY = sumXY / sumWeights; + final double meanXSquared = sumXSquared / sumWeights; + + final double beta; + if (FastMath.sqrt(FastMath.abs(meanXSquared - meanX * meanX)) < accuracy) { + beta = 0; + } else { + beta = (meanXY - meanX * meanY) / (meanXSquared - meanX * meanX); + } + + final double alpha = meanY - beta * meanX; + + res[i] = beta * x + alpha; + residuals[i] = FastMath.abs(yval[i] - res[i]); + } + + // No need to recompute the robustness weights at the last + // iteration, they won't be needed anymore + if (iter == robustnessIters) { + break; + } + + // Recompute the robustness weights. + + // Find the median residual. + // An arraycopy and a sort are completely tractable here, + // because the preceding loop is a lot more expensive + System.arraycopy(residuals, 0, sortedResiduals, 0, n); + Arrays.sort(sortedResiduals); + final double medianResidual = sortedResiduals[n / 2]; + + if (FastMath.abs(medianResidual) < accuracy) { + break; + } + + for (int i = 0; i < n; ++i) { + final double arg = residuals[i] / (6 * medianResidual); + if (arg >= 1) { + robustnessWeights[i] = 0; + } else { + final double w = 1 - arg * arg; + robustnessWeights[i] = w * w; + } + } + } + + return res; + } + + /** + * Compute a loess fit on the data at the original abscissae. + * + * @param xval the arguments for the interpolation points + * @param yval the values for the interpolation points + * @return values of the loess fit at corresponding original abscissae + * @throws NonMonotonicSequenceException if {@code xval} not sorted in + * strictly increasing order. + * @throws DimensionMismatchException if {@code xval} and {@code yval} have + * different sizes. + * @throws NoDataException if {@code xval} or {@code yval} has zero size. + * @throws NotFiniteNumberException if any of the arguments and values are + * not finite real numbers. + * @throws NumberIsTooSmallException if the bandwidth is too small to + * accomodate the size of the input data (i.e. the bandwidth must be + * larger than 2/n). + */ + public final double[] smooth(final double[] xval, final double[] yval) + throws NonMonotonicSequenceException, + DimensionMismatchException, + NoDataException, + NotFiniteNumberException, + NumberIsTooSmallException { + if (xval.length != yval.length) { + throw new DimensionMismatchException(xval.length, yval.length); + } + + final double[] unitWeights = new double[xval.length]; + Arrays.fill(unitWeights, 1.0); + + return smooth(xval, yval, unitWeights); + } + + /** + * Given an index interval into xval that embraces a certain number of + * points closest to {@code xval[i-1]}, update the interval so that it + * embraces the same number of points closest to {@code xval[i]}, + * ignoring zero weights. + * + * @param xval Arguments array. + * @param weights Weights array. + * @param i Index around which the new interval should be computed. + * @param bandwidthInterval a two-element array {left, right} such that: + * {@code (left==0 or xval[i] - xval[left-1] > xval[right] - xval[i])} + * and + * {@code (right==xval.length-1 or xval[right+1] - xval[i] > xval[i] - xval[left])}. + * The array will be updated. + */ + private static void updateBandwidthInterval(final double[] xval, final double[] weights, + final int i, + final int[] bandwidthInterval) { + final int left = bandwidthInterval[0]; + final int right = bandwidthInterval[1]; + + // The right edge should be adjusted if the next point to the right + // is closer to xval[i] than the leftmost point of the current interval + int nextRight = nextNonzero(weights, right); + if (nextRight < xval.length && xval[nextRight] - xval[i] < xval[i] - xval[left]) { + int nextLeft = nextNonzero(weights, bandwidthInterval[0]); + bandwidthInterval[0] = nextLeft; + bandwidthInterval[1] = nextRight; + } + } + + /** + * Return the smallest index {@code j} such that + * {@code j > i && (j == weights.length || weights[j] != 0)}. + * + * @param weights Weights array. + * @param i Index from which to start search. + * @return the smallest compliant index. + */ + private static int nextNonzero(final double[] weights, final int i) { + int j = i + 1; + while(j < weights.length && weights[j] == 0) { + ++j; + } + return j; + } + + /** + * Compute the + * tricube + * weight function + * + * @param x Argument. + * @return(1 - |x|3)3 for |x| < 1, 0 otherwise.
+ */
+ private static double tricube(final double x) {
+ final double absX = FastMath.abs(x);
+ if (absX >= 1.0) {
+ return 0.0;
+ }
+ final double tmp = 1 - absX * absX * absX;
+ return tmp * tmp * tmp;
+ }
+
+ /**
+ * Check that all elements of an array are finite real numbers.
+ *
+ * @param values Values array.
+ * @throws NotFiniteNumberException
+ * if one of the values is not a finite real number.
+ */
+ private static void checkAllFiniteReal(final double[] values) {
+ for (int i = 0; i < values.length; i++) {
+ MathUtils.checkFinite(values[i]);
+ }
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/MicrosphereInterpolatingFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/MicrosphereInterpolatingFunction.java
new file mode 100644
index 000000000..83b02a411
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/MicrosphereInterpolatingFunction.java
@@ -0,0 +1,253 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.analysis.interpolation;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException;
+import com.fr.third.org.apache.commons.math3.exception.NoDataException;
+import com.fr.third.org.apache.commons.math3.exception.NullArgumentException;
+import com.fr.third.org.apache.commons.math3.analysis.MultivariateFunction;
+import com.fr.third.org.apache.commons.math3.linear.ArrayRealVector;
+import com.fr.third.org.apache.commons.math3.linear.RealVector;
+import com.fr.third.org.apache.commons.math3.random.UnitSphereRandomVectorGenerator;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+
+/**
+ * Interpolating function that implements the
+ * Microsphere Projection.
+ *
+ * @deprecated Code will be removed in 4.0. Use {@link InterpolatingMicrosphere}
+ * and {@link MicrosphereProjectionInterpolator} instead.
+ */
+@Deprecated
+public class MicrosphereInterpolatingFunction
+ implements MultivariateFunction {
+ /**
+ * Space dimension.
+ */
+ private final int dimension;
+ /**
+ * Internal accounting data for the interpolation algorithm.
+ * Each element of the list corresponds to one surface element of
+ * the microsphere.
+ */
+ private final List+ * The actual code of Neville's algorithm is in PolynomialFunctionLagrangeForm, + * this class provides an easy-to-use interface to it.
+ * + * @since 1.2 + */ +public class NevilleInterpolator implements UnivariateInterpolator, + Serializable { + + /** serializable version identifier */ + static final long serialVersionUID = 3003707660147873733L; + + /** + * Computes an interpolating function for the data set. + * + * @param x Interpolating points. + * @param y Interpolating values. + * @return a function which interpolates the data set + * @throws DimensionMismatchException if the array lengths are different. + * @throws NumberIsTooSmallException if the number of points is less than 2. + * @throws NonMonotonicSequenceException if two abscissae have the same + * value. + */ + public PolynomialFunctionLagrangeForm interpolate(double x[], double y[]) + throws DimensionMismatchException, + NumberIsTooSmallException, + NonMonotonicSequenceException { + return new PolynomialFunctionLagrangeForm(x, y); + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunction.java new file mode 100644 index 000000000..5c15f87d1 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/PiecewiseBicubicSplineInterpolatingFunction.java @@ -0,0 +1,211 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.interpolation; + +import java.util.Arrays; + +import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException; +import com.fr.third.org.apache.commons.math3.exception.InsufficientDataException; +import com.fr.third.org.apache.commons.math3.exception.NoDataException; +import com.fr.third.org.apache.commons.math3.exception.NonMonotonicSequenceException; +import com.fr.third.org.apache.commons.math3.exception.NullArgumentException; +import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException; +import com.fr.third.org.apache.commons.math3.analysis.BivariateFunction; +import com.fr.third.org.apache.commons.math3.analysis.polynomials.PolynomialSplineFunction; +import com.fr.third.org.apache.commons.math3.util.MathArrays; + +/** + * Function that implements the + * bicubic spline + * interpolation. + * This implementation currently uses {@link AkimaSplineInterpolator} as the + * underlying one-dimensional interpolator, which requires 5 sample points; + * insufficient data will raise an exception when the + * {@link #value(double,double) value} method is called. + * + * @since 3.4 + */ +public class PiecewiseBicubicSplineInterpolatingFunction + implements BivariateFunction { + /** The minimum number of points that are needed to compute the function. */ + private static final int MIN_NUM_POINTS = 5; + /** Samples x-coordinates */ + private final double[] xval; + /** Samples y-coordinates */ + private final double[] yval; + /** Set of cubic splines patching the whole data grid */ + private final double[][] fval; + + /** + * @param x Sample values of the x-coordinate, in increasing order. + * @param y Sample values of the y-coordinate, in increasing order. + * @param f Values of the function on every grid point. the expected number + * of elements. + * @throws NonMonotonicSequenceException if {@code x} or {@code y} are not + * strictly increasing. + * @throws NullArgumentException if any of the arguments are null + * @throws NoDataException if any of the arrays has zero length. + * @throws DimensionMismatchException if the length of x and y don't match the row, column + * height of f + */ + public PiecewiseBicubicSplineInterpolatingFunction(double[] x, + double[] y, + double[][] f) + throws DimensionMismatchException, + NullArgumentException, + NoDataException, + NonMonotonicSequenceException { + if (x == null || + y == null || + f == null || + f[0] == null) { + throw new NullArgumentException(); + } + + final int xLen = x.length; + final int yLen = y.length; + + if (xLen == 0 || + yLen == 0 || + f.length == 0 || + f[0].length == 0) { + throw new NoDataException(); + } + + if (xLen < MIN_NUM_POINTS || + yLen < MIN_NUM_POINTS || + f.length < MIN_NUM_POINTS || + f[0].length < MIN_NUM_POINTS) { + throw new InsufficientDataException(); + } + + if (xLen != f.length) { + throw new DimensionMismatchException(xLen, f.length); + } + + if (yLen != f[0].length) { + throw new DimensionMismatchException(yLen, f[0].length); + } + + MathArrays.checkOrder(x); + MathArrays.checkOrder(y); + + xval = x.clone(); + yval = y.clone(); + fval = f.clone(); + } + + /** + * {@inheritDoc} + */ + public double value(double x, + double y) + throws OutOfRangeException { + final AkimaSplineInterpolator interpolator = new AkimaSplineInterpolator(); + final int offset = 2; + final int count = offset + 3; + final int i = searchIndex(x, xval, offset, count); + final int j = searchIndex(y, yval, offset, count); + + final double xArray[] = new double[count]; + final double yArray[] = new double[count]; + final double zArray[] = new double[count]; + final double interpArray[] = new double[count]; + + for (int index = 0; index < count; index++) { + xArray[index] = xval[i + index]; + yArray[index] = yval[j + index]; + } + + for (int zIndex = 0; zIndex < count; zIndex++) { + for (int index = 0; index < count; index++) { + zArray[index] = fval[i + index][j + zIndex]; + } + final PolynomialSplineFunction spline = interpolator.interpolate(xArray, zArray); + interpArray[zIndex] = spline.value(x); + } + + final PolynomialSplineFunction spline = interpolator.interpolate(yArray, interpArray); + + double returnValue = spline.value(y); + + return returnValue; + } + + /** + * Indicates whether a point is within the interpolation range. + * + * @param x First coordinate. + * @param y Second coordinate. + * @return {@code true} if (x, y) is a valid point. + * @since 3.3 + */ + public boolean isValidPoint(double x, + double y) { + if (x < xval[0] || + x > xval[xval.length - 1] || + y < yval[0] || + y > yval[yval.length - 1]) { + return false; + } else { + return true; + } + } + + /** + * @param c Coordinate. + * @param val Coordinate samples. + * @param offset how far back from found value to offset for querying + * @param count total number of elements forward from beginning that will be + * queried + * @return the index in {@code val} corresponding to the interval containing + * {@code c}. + * @throws OutOfRangeException if {@code c} is out of the range defined by + * the boundary values of {@code val}. + */ + private int searchIndex(double c, + double[] val, + int offset, + int count) { + int r = Arrays.binarySearch(val, c); + + if (r == -1 || r == -val.length - 1) { + throw new OutOfRangeException(c, val[0], val[val.length - 1]); + } + + if (r < 0) { + // "c" in within an interpolation sub-interval, which returns + // negative + // need to remove the negative sign for consistency + r = -r - offset - 1; + } else { + r -= offset; + } + + if (r < 0) { + r = 0; + } + + if ((r + count) >= val.length) { + // "c" is the last sample of the range: Return the index + // of the sample at the lower end of the last sub-interval. + r = val.length - count; + } + + return r; + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/PiecewiseBicubicSplineInterpolator.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/PiecewiseBicubicSplineInterpolator.java new file mode 100644 index 000000000..176ffbd01 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/PiecewiseBicubicSplineInterpolator.java @@ -0,0 +1,61 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.interpolation; + +import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException; +import com.fr.third.org.apache.commons.math3.exception.NoDataException; +import com.fr.third.org.apache.commons.math3.exception.NonMonotonicSequenceException; +import com.fr.third.org.apache.commons.math3.exception.NullArgumentException; +import com.fr.third.org.apache.commons.math3.util.MathArrays; + +/** + * Generates a piecewise-bicubic interpolating function. + * + * @since 2.2 + */ +public class PiecewiseBicubicSplineInterpolator + implements BivariateGridInterpolator { + + /** + * {@inheritDoc} + */ + public PiecewiseBicubicSplineInterpolatingFunction interpolate( final double[] xval, + final double[] yval, + final double[][] fval) + throws DimensionMismatchException, + NullArgumentException, + NoDataException, + NonMonotonicSequenceException { + if ( xval == null || + yval == null || + fval == null || + fval[0] == null ) { + throw new NullArgumentException(); + } + + if ( xval.length == 0 || + yval.length == 0 || + fval.length == 0 ) { + throw new NoDataException(); + } + + MathArrays.checkOrder(xval); + MathArrays.checkOrder(yval); + + return new PiecewiseBicubicSplineInterpolatingFunction( xval, yval, fval ); + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/SmoothingPolynomialBicubicSplineInterpolator.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/SmoothingPolynomialBicubicSplineInterpolator.java new file mode 100644 index 000000000..0f46290dd --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/SmoothingPolynomialBicubicSplineInterpolator.java @@ -0,0 +1,171 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.interpolation; + +import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException; +import com.fr.third.org.apache.commons.math3.exception.NoDataException; +import com.fr.third.org.apache.commons.math3.exception.NonMonotonicSequenceException; +import com.fr.third.org.apache.commons.math3.exception.NotPositiveException; +import com.fr.third.org.apache.commons.math3.exception.NullArgumentException; +import com.fr.third.org.apache.commons.math3.util.MathArrays; +import com.fr.third.org.apache.commons.math3.util.Precision; +import com.fr.third.org.apache.commons.math3.optim.nonlinear.vector.jacobian.GaussNewtonOptimizer; +import com.fr.third.org.apache.commons.math3.fitting.PolynomialFitter; +import com.fr.third.org.apache.commons.math3.analysis.polynomials.PolynomialFunction; +import com.fr.third.org.apache.commons.math3.optim.SimpleVectorValueChecker; + +/** + * Generates a bicubic interpolation function. + * Prior to generating the interpolating function, the input is smoothed using + * polynomial fitting. + * + * @since 2.2 + * @deprecated To be removed in 4.0 (see MATH-1166). + */ +@Deprecated +public class SmoothingPolynomialBicubicSplineInterpolator + extends BicubicSplineInterpolator { + /** Fitter for x. */ + private final PolynomialFitter xFitter; + /** Degree of the fitting polynomial. */ + private final int xDegree; + /** Fitter for y. */ + private final PolynomialFitter yFitter; + /** Degree of the fitting polynomial. */ + private final int yDegree; + + /** + * Default constructor. The degree of the fitting polynomials is set to 3. + */ + public SmoothingPolynomialBicubicSplineInterpolator() { + this(3); + } + + /** + * @param degree Degree of the polynomial fitting functions. + * @exception NotPositiveException if degree is not positive + */ + public SmoothingPolynomialBicubicSplineInterpolator(int degree) + throws NotPositiveException { + this(degree, degree); + } + + /** + * @param xDegree Degree of the polynomial fitting functions along the + * x-dimension. + * @param yDegree Degree of the polynomial fitting functions along the + * y-dimension. + * @exception NotPositiveException if degrees are not positive + */ + public SmoothingPolynomialBicubicSplineInterpolator(int xDegree, int yDegree) + throws NotPositiveException { + if (xDegree < 0) { + throw new NotPositiveException(xDegree); + } + if (yDegree < 0) { + throw new NotPositiveException(yDegree); + } + this.xDegree = xDegree; + this.yDegree = yDegree; + + final double safeFactor = 1e2; + final SimpleVectorValueChecker checker + = new SimpleVectorValueChecker(safeFactor * Precision.EPSILON, + safeFactor * Precision.SAFE_MIN); + xFitter = new PolynomialFitter(new GaussNewtonOptimizer(false, checker)); + yFitter = new PolynomialFitter(new GaussNewtonOptimizer(false, checker)); + } + + /** + * {@inheritDoc} + */ + @Override + public BicubicSplineInterpolatingFunction interpolate(final double[] xval, + final double[] yval, + final double[][] fval) + throws NoDataException, NullArgumentException, + DimensionMismatchException, NonMonotonicSequenceException { + if (xval.length == 0 || yval.length == 0 || fval.length == 0) { + throw new NoDataException(); + } + if (xval.length != fval.length) { + throw new DimensionMismatchException(xval.length, fval.length); + } + + final int xLen = xval.length; + final int yLen = yval.length; + + for (int i = 0; i < xLen; i++) { + if (fval[i].length != yLen) { + throw new DimensionMismatchException(fval[i].length, yLen); + } + } + + MathArrays.checkOrder(xval); + MathArrays.checkOrder(yval); + + // For each line y[j] (0 <= j < yLen), construct a polynomial, with + // respect to variable x, fitting array fval[][j] + final PolynomialFunction[] yPolyX = new PolynomialFunction[yLen]; + for (int j = 0; j < yLen; j++) { + xFitter.clearObservations(); + for (int i = 0; i < xLen; i++) { + xFitter.addObservedPoint(1, xval[i], fval[i][j]); + } + + // Initial guess for the fit is zero for each coefficients (of which + // there are "xDegree" + 1). + yPolyX[j] = new PolynomialFunction(xFitter.fit(new double[xDegree + 1])); + } + + // For every knot (xval[i], yval[j]) of the grid, calculate corrected + // values fval_1 + final double[][] fval_1 = new double[xLen][yLen]; + for (int j = 0; j < yLen; j++) { + final PolynomialFunction f = yPolyX[j]; + for (int i = 0; i < xLen; i++) { + fval_1[i][j] = f.value(xval[i]); + } + } + + // For each line x[i] (0 <= i < xLen), construct a polynomial, with + // respect to variable y, fitting array fval_1[i][] + final PolynomialFunction[] xPolyY = new PolynomialFunction[xLen]; + for (int i = 0; i < xLen; i++) { + yFitter.clearObservations(); + for (int j = 0; j < yLen; j++) { + yFitter.addObservedPoint(1, yval[j], fval_1[i][j]); + } + + // Initial guess for the fit is zero for each coefficients (of which + // there are "yDegree" + 1). + xPolyY[i] = new PolynomialFunction(yFitter.fit(new double[yDegree + 1])); + } + + // For every knot (xval[i], yval[j]) of the grid, calculate corrected + // values fval_2 + final double[][] fval_2 = new double[xLen][yLen]; + for (int i = 0; i < xLen; i++) { + final PolynomialFunction f = xPolyY[i]; + for (int j = 0; j < yLen; j++) { + fval_2[i][j] = f.value(yval[j]); + } + } + + return super.interpolate(xval, yval, fval_2); + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/SplineInterpolator.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/SplineInterpolator.java new file mode 100644 index 000000000..2376a9528 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/SplineInterpolator.java @@ -0,0 +1,127 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.interpolation; + +import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException; +import com.fr.third.org.apache.commons.math3.exception.NonMonotonicSequenceException; +import com.fr.third.org.apache.commons.math3.exception.NumberIsTooSmallException; +import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats; +import com.fr.third.org.apache.commons.math3.analysis.polynomials.PolynomialFunction; +import com.fr.third.org.apache.commons.math3.analysis.polynomials.PolynomialSplineFunction; +import com.fr.third.org.apache.commons.math3.util.MathArrays; + +/** + * Computes a natural (also known as "free", "unclamped") cubic spline interpolation for the data set. + *+ * The {@link #interpolate(double[], double[])} method returns a {@link PolynomialSplineFunction} + * consisting of n cubic polynomials, defined over the subintervals determined by the x values, + * {@code x[0] < x[i] ... < x[n].} The x values are referred to as "knot points." + *
+ * The value of the PolynomialSplineFunction at a point x that is greater than or equal to the smallest
+ * knot point and strictly less than the largest knot point is computed by finding the subinterval to which
+ * x belongs and computing the value of the corresponding polynomial at x - x[i] where
+ * i is the index of the subinterval. See {@link PolynomialSplineFunction} for more details.
+ *
+ * The interpolating polynomials satisfy:
+ * The cubic spline interpolation algorithm implemented is as described in R.L. Burden, J.D. Faires, + * Numerical Analysis, 4th Ed., 1989, PWS-Kent, ISBN 0-53491-585-X, pp 126-131. + *
+ * + */ +public class SplineInterpolator implements UnivariateInterpolator { + /** + * Computes an interpolating function for the data set. + * @param x the arguments for the interpolation points + * @param y the values for the interpolation points + * @return a function which interpolates the data set + * @throws DimensionMismatchException if {@code x} and {@code y} + * have different sizes. + * @throws NonMonotonicSequenceException if {@code x} is not sorted in + * strict increasing order. + * @throws NumberIsTooSmallException if the size of {@code x} is smaller + * than 3. + */ + public PolynomialSplineFunction interpolate(double x[], double y[]) + throws DimensionMismatchException, + NumberIsTooSmallException, + NonMonotonicSequenceException { + if (x.length != y.length) { + throw new DimensionMismatchException(x.length, y.length); + } + + if (x.length < 3) { + throw new NumberIsTooSmallException(LocalizedFormats.NUMBER_OF_POINTS, + x.length, 3, true); + } + + // Number of intervals. The number of data points is n + 1. + final int n = x.length - 1; + + MathArrays.checkOrder(x); + + // Differences between knot points + final double h[] = new double[n]; + for (int i = 0; i < n; i++) { + h[i] = x[i + 1] - x[i]; + } + + final double mu[] = new double[n]; + final double z[] = new double[n + 1]; + mu[0] = 0d; + z[0] = 0d; + double g = 0; + for (int i = 1; i < n; i++) { + g = 2d * (x[i+1] - x[i - 1]) - h[i - 1] * mu[i -1]; + mu[i] = h[i] / g; + z[i] = (3d * (y[i + 1] * h[i - 1] - y[i] * (x[i + 1] - x[i - 1])+ y[i - 1] * h[i]) / + (h[i - 1] * h[i]) - h[i - 1] * z[i - 1]) / g; + } + + // cubic spline coefficients -- b is linear, c quadratic, d is cubic (original y's are constants) + final double b[] = new double[n]; + final double c[] = new double[n + 1]; + final double d[] = new double[n]; + + z[n] = 0d; + c[n] = 0d; + + for (int j = n -1; j >=0; j--) { + c[j] = z[j] - mu[j] * c[j + 1]; + b[j] = (y[j + 1] - y[j]) / h[j] - h[j] * (c[j + 1] + 2d * c[j]) / 3d; + d[j] = (c[j + 1] - c[j]) / (3d * h[j]); + } + + final PolynomialFunction polynomials[] = new PolynomialFunction[n]; + final double coefficients[] = new double[4]; + for (int i = 0; i < n; i++) { + coefficients[0] = y[i]; + coefficients[1] = b[i]; + coefficients[2] = c[i]; + coefficients[3] = d[i]; + polynomials[i] = new PolynomialFunction(coefficients); + } + + return new PolynomialSplineFunction(x, polynomials); + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/TricubicInterpolatingFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/TricubicInterpolatingFunction.java new file mode 100644 index 000000000..929f802ae --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/interpolation/TricubicInterpolatingFunction.java @@ -0,0 +1,508 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.interpolation; + +import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException; +import com.fr.third.org.apache.commons.math3.exception.NoDataException; +import com.fr.third.org.apache.commons.math3.exception.NonMonotonicSequenceException; +import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException; +import com.fr.third.org.apache.commons.math3.analysis.TrivariateFunction; +import com.fr.third.org.apache.commons.math3.util.MathArrays; + +/** + * Function that implements the + * + * tricubic spline interpolation, as proposed in + *+ * Tricubic interpolation in three dimensions, + * F. Lekien and J. Marsden, + * Int. J. Numer. Meth. Eng 2005; 63:455-471 + *+ * + * @since 3.4. + */ +public class TricubicInterpolatingFunction + implements TrivariateFunction { + /** + * Matrix to compute the spline coefficients from the function values + * and function derivatives values + */ + private static final double[][] AINV = { + { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { -3,3,0,0,0,0,0,0,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 2,-2,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { -3,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,-3,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 9,-9,-9,9,0,0,0,0,6,3,-6,-3,0,0,0,0,6,-6,3,-3,0,0,0,0,0,0,0,0,0,0,0,0,4,2,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { -6,6,6,-6,0,0,0,0,-3,-3,3,3,0,0,0,0,-4,4,-2,2,0,0,0,0,0,0,0,0,0,0,0,0,-2,-2,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 2,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,2,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { -6,6,6,-6,0,0,0,0,-4,-2,4,2,0,0,0,0,-3,3,-3,3,0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 4,-4,-4,4,0,0,0,0,2,2,-2,-2,0,0,0,0,2,-2,2,-2,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,3,0,0,0,0,0,0,-2,-1,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-2,0,0,0,0,0,0,1,1,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,-1,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,-9,-9,9,0,0,0,0,0,0,0,0,0,0,0,0,6,3,-6,-3,0,0,0,0,6,-6,3,-3,0,0,0,0,4,2,2,1,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-6,6,6,-6,0,0,0,0,0,0,0,0,0,0,0,0,-3,-3,3,3,0,0,0,0,-4,4,-2,2,0,0,0,0,-2,-2,-1,-1,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-6,6,6,-6,0,0,0,0,0,0,0,0,0,0,0,0,-4,-2,4,2,0,0,0,0,-3,3,-3,3,0,0,0,0,-2,-1,-2,-1,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,-4,-4,4,0,0,0,0,0,0,0,0,0,0,0,0,2,2,-2,-2,0,0,0,0,2,-2,2,-2,0,0,0,0,1,1,1,1,0,0,0,0 }, + {-3,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,-3,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 9,-9,0,0,-9,9,0,0,6,3,0,0,-6,-3,0,0,0,0,0,0,0,0,0,0,6,-6,0,0,3,-3,0,0,0,0,0,0,0,0,0,0,4,2,0,0,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { -6,6,0,0,6,-6,0,0,-3,-3,0,0,3,3,0,0,0,0,0,0,0,0,0,0,-4,4,0,0,-2,2,0,0,0,0,0,0,0,0,0,0,-2,-2,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,0,0,-1,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,-9,0,0,-9,9,0,0,0,0,0,0,0,0,0,0,6,3,0,0,-6,-3,0,0,0,0,0,0,0,0,0,0,6,-6,0,0,3,-3,0,0,4,2,0,0,2,1,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-6,6,0,0,6,-6,0,0,0,0,0,0,0,0,0,0,-3,-3,0,0,3,3,0,0,0,0,0,0,0,0,0,0,-4,4,0,0,-2,2,0,0,-2,-2,0,0,-1,-1,0,0 }, + { 9,0,-9,0,-9,0,9,0,0,0,0,0,0,0,0,0,6,0,3,0,-6,0,-3,0,6,0,-6,0,3,0,-3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,2,0,2,0,1,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,9,0,-9,0,-9,0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,3,0,-6,0,-3,0,6,0,-6,0,3,0,-3,0,0,0,0,0,0,0,0,0,4,0,2,0,2,0,1,0 }, + { -27,27,27,-27,27,-27,-27,27,-18,-9,18,9,18,9,-18,-9,-18,18,-9,9,18,-18,9,-9,-18,18,18,-18,-9,9,9,-9,-12,-6,-6,-3,12,6,6,3,-12,-6,12,6,-6,-3,6,3,-12,12,-6,6,-6,6,-3,3,-8,-4,-4,-2,-4,-2,-2,-1 }, + { 18,-18,-18,18,-18,18,18,-18,9,9,-9,-9,-9,-9,9,9,12,-12,6,-6,-12,12,-6,6,12,-12,-12,12,6,-6,-6,6,6,6,3,3,-6,-6,-3,-3,6,6,-6,-6,3,3,-3,-3,8,-8,4,-4,4,-4,2,-2,4,4,2,2,2,2,1,1 }, + { -6,0,6,0,6,0,-6,0,0,0,0,0,0,0,0,0,-3,0,-3,0,3,0,3,0,-4,0,4,0,-2,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,-2,0,-1,0,-1,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,-6,0,6,0,6,0,-6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,0,-3,0,3,0,3,0,-4,0,4,0,-2,0,2,0,0,0,0,0,0,0,0,0,-2,0,-2,0,-1,0,-1,0 }, + { 18,-18,-18,18,-18,18,18,-18,12,6,-12,-6,-12,-6,12,6,9,-9,9,-9,-9,9,-9,9,12,-12,-12,12,6,-6,-6,6,6,3,6,3,-6,-3,-6,-3,8,4,-8,-4,4,2,-4,-2,6,-6,6,-6,3,-3,3,-3,4,2,4,2,2,1,2,1 }, + { -12,12,12,-12,12,-12,-12,12,-6,-6,6,6,6,6,-6,-6,-6,6,-6,6,6,-6,6,-6,-8,8,8,-8,-4,4,4,-4,-3,-3,-3,-3,3,3,3,3,-4,-4,4,4,-2,-2,2,2,-4,4,-4,4,-2,2,-2,2,-2,-2,-2,-2,-1,-1,-1,-1 }, + { 2,0,0,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,2,0,0,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { -6,6,0,0,6,-6,0,0,-4,-2,0,0,4,2,0,0,0,0,0,0,0,0,0,0,-3,3,0,0,-3,3,0,0,0,0,0,0,0,0,0,0,-2,-1,0,0,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 4,-4,0,0,-4,4,0,0,2,2,0,0,-2,-2,0,0,0,0,0,0,0,0,0,0,2,-2,0,0,2,-2,0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-6,6,0,0,6,-6,0,0,0,0,0,0,0,0,0,0,-4,-2,0,0,4,2,0,0,0,0,0,0,0,0,0,0,-3,3,0,0,-3,3,0,0,-2,-1,0,0,-2,-1,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,-4,0,0,-4,4,0,0,0,0,0,0,0,0,0,0,2,2,0,0,-2,-2,0,0,0,0,0,0,0,0,0,0,2,-2,0,0,2,-2,0,0,1,1,0,0,1,1,0,0 }, + { -6,0,6,0,6,0,-6,0,0,0,0,0,0,0,0,0,-4,0,-2,0,4,0,2,0,-3,0,3,0,-3,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,-1,0,-2,0,-1,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,-6,0,6,0,6,0,-6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-4,0,-2,0,4,0,2,0,-3,0,3,0,-3,0,3,0,0,0,0,0,0,0,0,0,-2,0,-1,0,-2,0,-1,0 }, + { 18,-18,-18,18,-18,18,18,-18,12,6,-12,-6,-12,-6,12,6,12,-12,6,-6,-12,12,-6,6,9,-9,-9,9,9,-9,-9,9,8,4,4,2,-8,-4,-4,-2,6,3,-6,-3,6,3,-6,-3,6,-6,3,-3,6,-6,3,-3,4,2,2,1,4,2,2,1 }, + { -12,12,12,-12,12,-12,-12,12,-6,-6,6,6,6,6,-6,-6,-8,8,-4,4,8,-8,4,-4,-6,6,6,-6,-6,6,6,-6,-4,-4,-2,-2,4,4,2,2,-3,-3,3,3,-3,-3,3,3,-4,4,-2,2,-4,4,-2,2,-2,-2,-1,-1,-2,-2,-1,-1 }, + { 4,0,-4,0,-4,0,4,0,0,0,0,0,0,0,0,0,2,0,2,0,-2,0,-2,0,2,0,-2,0,2,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,4,0,-4,0,-4,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,2,0,-2,0,-2,0,2,0,-2,0,2,0,-2,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0 }, + { -12,12,12,-12,12,-12,-12,12,-8,-4,8,4,8,4,-8,-4,-6,6,-6,6,6,-6,6,-6,-6,6,6,-6,-6,6,6,-6,-4,-2,-4,-2,4,2,4,2,-4,-2,4,2,-4,-2,4,2,-3,3,-3,3,-3,3,-3,3,-2,-1,-2,-1,-2,-1,-2,-1 }, + { 8,-8,-8,8,-8,8,8,-8,4,4,-4,-4,-4,-4,4,4,4,-4,4,-4,-4,4,-4,4,4,-4,-4,4,4,-4,-4,4,2,2,2,2,-2,-2,-2,-2,2,2,-2,-2,2,2,-2,-2,2,-2,2,-2,2,-2,2,-2,1,1,1,1,1,1,1,1 } + }; + + /** Samples x-coordinates */ + private final double[] xval; + /** Samples y-coordinates */ + private final double[] yval; + /** Samples z-coordinates */ + private final double[] zval; + /** Set of cubic splines patching the whole data grid */ + private final TricubicFunction[][][] splines; + + /** + * @param x Sample values of the x-coordinate, in increasing order. + * @param y Sample values of the y-coordinate, in increasing order. + * @param z Sample values of the y-coordinate, in increasing order. + * @param f Values of the function on every grid point. + * @param dFdX Values of the partial derivative of function with respect to x on every grid point. + * @param dFdY Values of the partial derivative of function with respect to y on every grid point. + * @param dFdZ Values of the partial derivative of function with respect to z on every grid point. + * @param d2FdXdY Values of the cross partial derivative of function on every grid point. + * @param d2FdXdZ Values of the cross partial derivative of function on every grid point. + * @param d2FdYdZ Values of the cross partial derivative of function on every grid point. + * @param d3FdXdYdZ Values of the cross partial derivative of function on every grid point. + * @throws NoDataException if any of the arrays has zero length. + * @throws DimensionMismatchException if the various arrays do not contain the expected number of elements. + * @throws NonMonotonicSequenceException if {@code x}, {@code y} or {@code z} are not strictly increasing. + */ + public TricubicInterpolatingFunction(double[] x, + double[] y, + double[] z, + double[][][] f, + double[][][] dFdX, + double[][][] dFdY, + double[][][] dFdZ, + double[][][] d2FdXdY, + double[][][] d2FdXdZ, + double[][][] d2FdYdZ, + double[][][] d3FdXdYdZ) + throws NoDataException, + DimensionMismatchException, + NonMonotonicSequenceException { + final int xLen = x.length; + final int yLen = y.length; + final int zLen = z.length; + + if (xLen == 0 || yLen == 0 || z.length == 0 || f.length == 0 || f[0].length == 0) { + throw new NoDataException(); + } + if (xLen != f.length) { + throw new DimensionMismatchException(xLen, f.length); + } + if (xLen != dFdX.length) { + throw new DimensionMismatchException(xLen, dFdX.length); + } + if (xLen != dFdY.length) { + throw new DimensionMismatchException(xLen, dFdY.length); + } + if (xLen != dFdZ.length) { + throw new DimensionMismatchException(xLen, dFdZ.length); + } + if (xLen != d2FdXdY.length) { + throw new DimensionMismatchException(xLen, d2FdXdY.length); + } + if (xLen != d2FdXdZ.length) { + throw new DimensionMismatchException(xLen, d2FdXdZ.length); + } + if (xLen != d2FdYdZ.length) { + throw new DimensionMismatchException(xLen, d2FdYdZ.length); + } + if (xLen != d3FdXdYdZ.length) { + throw new DimensionMismatchException(xLen, d3FdXdYdZ.length); + } + + MathArrays.checkOrder(x); + MathArrays.checkOrder(y); + MathArrays.checkOrder(z); + + xval = x.clone(); + yval = y.clone(); + zval = z.clone(); + + final int lastI = xLen - 1; + final int lastJ = yLen - 1; + final int lastK = zLen - 1; + splines = new TricubicFunction[lastI][lastJ][lastK]; + + for (int i = 0; i < lastI; i++) { + if (f[i].length != yLen) { + throw new DimensionMismatchException(f[i].length, yLen); + } + if (dFdX[i].length != yLen) { + throw new DimensionMismatchException(dFdX[i].length, yLen); + } + if (dFdY[i].length != yLen) { + throw new DimensionMismatchException(dFdY[i].length, yLen); + } + if (dFdZ[i].length != yLen) { + throw new DimensionMismatchException(dFdZ[i].length, yLen); + } + if (d2FdXdY[i].length != yLen) { + throw new DimensionMismatchException(d2FdXdY[i].length, yLen); + } + if (d2FdXdZ[i].length != yLen) { + throw new DimensionMismatchException(d2FdXdZ[i].length, yLen); + } + if (d2FdYdZ[i].length != yLen) { + throw new DimensionMismatchException(d2FdYdZ[i].length, yLen); + } + if (d3FdXdYdZ[i].length != yLen) { + throw new DimensionMismatchException(d3FdXdYdZ[i].length, yLen); + } + + final int ip1 = i + 1; + final double xR = xval[ip1] - xval[i]; + for (int j = 0; j < lastJ; j++) { + if (f[i][j].length != zLen) { + throw new DimensionMismatchException(f[i][j].length, zLen); + } + if (dFdX[i][j].length != zLen) { + throw new DimensionMismatchException(dFdX[i][j].length, zLen); + } + if (dFdY[i][j].length != zLen) { + throw new DimensionMismatchException(dFdY[i][j].length, zLen); + } + if (dFdZ[i][j].length != zLen) { + throw new DimensionMismatchException(dFdZ[i][j].length, zLen); + } + if (d2FdXdY[i][j].length != zLen) { + throw new DimensionMismatchException(d2FdXdY[i][j].length, zLen); + } + if (d2FdXdZ[i][j].length != zLen) { + throw new DimensionMismatchException(d2FdXdZ[i][j].length, zLen); + } + if (d2FdYdZ[i][j].length != zLen) { + throw new DimensionMismatchException(d2FdYdZ[i][j].length, zLen); + } + if (d3FdXdYdZ[i][j].length != zLen) { + throw new DimensionMismatchException(d3FdXdYdZ[i][j].length, zLen); + } + + final int jp1 = j + 1; + final double yR = yval[jp1] - yval[j]; + final double xRyR = xR * yR; + for (int k = 0; k < lastK; k++) { + final int kp1 = k + 1; + final double zR = zval[kp1] - zval[k]; + final double xRzR = xR * zR; + final double yRzR = yR * zR; + final double xRyRzR = xR * yRzR; + + final double[] beta = new double[] { + f[i][j][k], f[ip1][j][k], + f[i][jp1][k], f[ip1][jp1][k], + f[i][j][kp1], f[ip1][j][kp1], + f[i][jp1][kp1], f[ip1][jp1][kp1], + + dFdX[i][j][k] * xR, dFdX[ip1][j][k] * xR, + dFdX[i][jp1][k] * xR, dFdX[ip1][jp1][k] * xR, + dFdX[i][j][kp1] * xR, dFdX[ip1][j][kp1] * xR, + dFdX[i][jp1][kp1] * xR, dFdX[ip1][jp1][kp1] * xR, + + dFdY[i][j][k] * yR, dFdY[ip1][j][k] * yR, + dFdY[i][jp1][k] * yR, dFdY[ip1][jp1][k] * yR, + dFdY[i][j][kp1] * yR, dFdY[ip1][j][kp1] * yR, + dFdY[i][jp1][kp1] * yR, dFdY[ip1][jp1][kp1] * yR, + + dFdZ[i][j][k] * zR, dFdZ[ip1][j][k] * zR, + dFdZ[i][jp1][k] * zR, dFdZ[ip1][jp1][k] * zR, + dFdZ[i][j][kp1] * zR, dFdZ[ip1][j][kp1] * zR, + dFdZ[i][jp1][kp1] * zR, dFdZ[ip1][jp1][kp1] * zR, + + d2FdXdY[i][j][k] * xRyR, d2FdXdY[ip1][j][k] * xRyR, + d2FdXdY[i][jp1][k] * xRyR, d2FdXdY[ip1][jp1][k] * xRyR, + d2FdXdY[i][j][kp1] * xRyR, d2FdXdY[ip1][j][kp1] * xRyR, + d2FdXdY[i][jp1][kp1] * xRyR, d2FdXdY[ip1][jp1][kp1] * xRyR, + + d2FdXdZ[i][j][k] * xRzR, d2FdXdZ[ip1][j][k] * xRzR, + d2FdXdZ[i][jp1][k] * xRzR, d2FdXdZ[ip1][jp1][k] * xRzR, + d2FdXdZ[i][j][kp1] * xRzR, d2FdXdZ[ip1][j][kp1] * xRzR, + d2FdXdZ[i][jp1][kp1] * xRzR, d2FdXdZ[ip1][jp1][kp1] * xRzR, + + d2FdYdZ[i][j][k] * yRzR, d2FdYdZ[ip1][j][k] * yRzR, + d2FdYdZ[i][jp1][k] * yRzR, d2FdYdZ[ip1][jp1][k] * yRzR, + d2FdYdZ[i][j][kp1] * yRzR, d2FdYdZ[ip1][j][kp1] * yRzR, + d2FdYdZ[i][jp1][kp1] * yRzR, d2FdYdZ[ip1][jp1][kp1] * yRzR, + + d3FdXdYdZ[i][j][k] * xRyRzR, d3FdXdYdZ[ip1][j][k] * xRyRzR, + d3FdXdYdZ[i][jp1][k] * xRyRzR, d3FdXdYdZ[ip1][jp1][k] * xRyRzR, + d3FdXdYdZ[i][j][kp1] * xRyRzR, d3FdXdYdZ[ip1][j][kp1] * xRyRzR, + d3FdXdYdZ[i][jp1][kp1] * xRyRzR, d3FdXdYdZ[ip1][jp1][kp1] * xRyRzR, + }; + + splines[i][j][k] = new TricubicFunction(computeCoefficients(beta)); + } + } + } + } + + /** + * {@inheritDoc} + * + * @throws OutOfRangeException if any of the variables is outside its interpolation range. + */ + public double value(double x, double y, double z) + throws OutOfRangeException { + final int i = searchIndex(x, xval); + if (i == -1) { + throw new OutOfRangeException(x, xval[0], xval[xval.length - 1]); + } + final int j = searchIndex(y, yval); + if (j == -1) { + throw new OutOfRangeException(y, yval[0], yval[yval.length - 1]); + } + final int k = searchIndex(z, zval); + if (k == -1) { + throw new OutOfRangeException(z, zval[0], zval[zval.length - 1]); + } + + final double xN = (x - xval[i]) / (xval[i + 1] - xval[i]); + final double yN = (y - yval[j]) / (yval[j + 1] - yval[j]); + final double zN = (z - zval[k]) / (zval[k + 1] - zval[k]); + + return splines[i][j][k].value(xN, yN, zN); + } + + /** + * Indicates whether a point is within the interpolation range. + * + * @param x First coordinate. + * @param y Second coordinate. + * @param z Third coordinate. + * @return {@code true} if (x, y, z) is a valid point. + */ + public boolean isValidPoint(double x, double y, double z) { + if (x < xval[0] || + x > xval[xval.length - 1] || + y < yval[0] || + y > yval[yval.length - 1] || + z < zval[0] || + z > zval[zval.length - 1]) { + return false; + } else { + return true; + } + } + + /** + * @param c Coordinate. + * @param val Coordinate samples. + * @return the index in {@code val} corresponding to the interval containing {@code c}, or {@code -1} + * if {@code c} is out of the range defined by the end values of {@code val}. + */ + private int searchIndex(double c, double[] val) { + if (c < val[0]) { + return -1; + } + + final int max = val.length; + for (int i = 1; i < max; i++) { + if (c <= val[i]) { + return i - 1; + } + } + + return -1; + } + + /** + * Compute the spline coefficients from the list of function values and + * function partial derivatives values at the four corners of a grid + * element. They must be specified in the following order: + *
+ * Tricubic interpolation in three dimensions, + * F. Lekien and J. Marsden, + * Int. J. Numer. Meth. Engng 2005; 63:455-471 + *+ * + * @since 2.2 + * @deprecated To be removed in 4.0 (see MATH-1166). + */ +@Deprecated +public class TricubicSplineInterpolatingFunction + implements TrivariateFunction { + /** + * Matrix to compute the spline coefficients from the function values + * and function derivatives values + */ + private static final double[][] AINV = { + { 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { -3,3,0,0,0,0,0,0,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 2,-2,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { -3,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,-3,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 9,-9,-9,9,0,0,0,0,6,3,-6,-3,0,0,0,0,6,-6,3,-3,0,0,0,0,0,0,0,0,0,0,0,0,4,2,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { -6,6,6,-6,0,0,0,0,-3,-3,3,3,0,0,0,0,-4,4,-2,2,0,0,0,0,0,0,0,0,0,0,0,0,-2,-2,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 2,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,2,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { -6,6,6,-6,0,0,0,0,-4,-2,4,2,0,0,0,0,-3,3,-3,3,0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 4,-4,-4,4,0,0,0,0,2,2,-2,-2,0,0,0,0,2,-2,2,-2,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,3,0,0,0,0,0,0,-2,-1,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-2,0,0,0,0,0,0,1,1,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,-1,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,-9,-9,9,0,0,0,0,0,0,0,0,0,0,0,0,6,3,-6,-3,0,0,0,0,6,-6,3,-3,0,0,0,0,4,2,2,1,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-6,6,6,-6,0,0,0,0,0,0,0,0,0,0,0,0,-3,-3,3,3,0,0,0,0,-4,4,-2,2,0,0,0,0,-2,-2,-1,-1,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-6,6,6,-6,0,0,0,0,0,0,0,0,0,0,0,0,-4,-2,4,2,0,0,0,0,-3,3,-3,3,0,0,0,0,-2,-1,-2,-1,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,-4,-4,4,0,0,0,0,0,0,0,0,0,0,0,0,2,2,-2,-2,0,0,0,0,2,-2,2,-2,0,0,0,0,1,1,1,1,0,0,0,0 }, + {-3,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,-3,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 9,-9,0,0,-9,9,0,0,6,3,0,0,-6,-3,0,0,0,0,0,0,0,0,0,0,6,-6,0,0,3,-3,0,0,0,0,0,0,0,0,0,0,4,2,0,0,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { -6,6,0,0,6,-6,0,0,-3,-3,0,0,3,3,0,0,0,0,0,0,0,0,0,0,-4,4,0,0,-2,2,0,0,0,0,0,0,0,0,0,0,-2,-2,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,0,0,-1,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,-9,0,0,-9,9,0,0,0,0,0,0,0,0,0,0,6,3,0,0,-6,-3,0,0,0,0,0,0,0,0,0,0,6,-6,0,0,3,-3,0,0,4,2,0,0,2,1,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-6,6,0,0,6,-6,0,0,0,0,0,0,0,0,0,0,-3,-3,0,0,3,3,0,0,0,0,0,0,0,0,0,0,-4,4,0,0,-2,2,0,0,-2,-2,0,0,-1,-1,0,0 }, + { 9,0,-9,0,-9,0,9,0,0,0,0,0,0,0,0,0,6,0,3,0,-6,0,-3,0,6,0,-6,0,3,0,-3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,2,0,2,0,1,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,9,0,-9,0,-9,0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,3,0,-6,0,-3,0,6,0,-6,0,3,0,-3,0,0,0,0,0,0,0,0,0,4,0,2,0,2,0,1,0 }, + { -27,27,27,-27,27,-27,-27,27,-18,-9,18,9,18,9,-18,-9,-18,18,-9,9,18,-18,9,-9,-18,18,18,-18,-9,9,9,-9,-12,-6,-6,-3,12,6,6,3,-12,-6,12,6,-6,-3,6,3,-12,12,-6,6,-6,6,-3,3,-8,-4,-4,-2,-4,-2,-2,-1 }, + { 18,-18,-18,18,-18,18,18,-18,9,9,-9,-9,-9,-9,9,9,12,-12,6,-6,-12,12,-6,6,12,-12,-12,12,6,-6,-6,6,6,6,3,3,-6,-6,-3,-3,6,6,-6,-6,3,3,-3,-3,8,-8,4,-4,4,-4,2,-2,4,4,2,2,2,2,1,1 }, + { -6,0,6,0,6,0,-6,0,0,0,0,0,0,0,0,0,-3,0,-3,0,3,0,3,0,-4,0,4,0,-2,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,-2,0,-1,0,-1,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,-6,0,6,0,6,0,-6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,0,-3,0,3,0,3,0,-4,0,4,0,-2,0,2,0,0,0,0,0,0,0,0,0,-2,0,-2,0,-1,0,-1,0 }, + { 18,-18,-18,18,-18,18,18,-18,12,6,-12,-6,-12,-6,12,6,9,-9,9,-9,-9,9,-9,9,12,-12,-12,12,6,-6,-6,6,6,3,6,3,-6,-3,-6,-3,8,4,-8,-4,4,2,-4,-2,6,-6,6,-6,3,-3,3,-3,4,2,4,2,2,1,2,1 }, + { -12,12,12,-12,12,-12,-12,12,-6,-6,6,6,6,6,-6,-6,-6,6,-6,6,6,-6,6,-6,-8,8,8,-8,-4,4,4,-4,-3,-3,-3,-3,3,3,3,3,-4,-4,4,4,-2,-2,2,2,-4,4,-4,4,-2,2,-2,2,-2,-2,-2,-2,-1,-1,-1,-1 }, + { 2,0,0,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,2,0,0,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { -6,6,0,0,6,-6,0,0,-4,-2,0,0,4,2,0,0,0,0,0,0,0,0,0,0,-3,3,0,0,-3,3,0,0,0,0,0,0,0,0,0,0,-2,-1,0,0,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 4,-4,0,0,-4,4,0,0,2,2,0,0,-2,-2,0,0,0,0,0,0,0,0,0,0,2,-2,0,0,2,-2,0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-6,6,0,0,6,-6,0,0,0,0,0,0,0,0,0,0,-4,-2,0,0,4,2,0,0,0,0,0,0,0,0,0,0,-3,3,0,0,-3,3,0,0,-2,-1,0,0,-2,-1,0,0 }, + { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,-4,0,0,-4,4,0,0,0,0,0,0,0,0,0,0,2,2,0,0,-2,-2,0,0,0,0,0,0,0,0,0,0,2,-2,0,0,2,-2,0,0,1,1,0,0,1,1,0,0 }, + { -6,0,6,0,6,0,-6,0,0,0,0,0,0,0,0,0,-4,0,-2,0,4,0,2,0,-3,0,3,0,-3,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,-1,0,-2,0,-1,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,-6,0,6,0,6,0,-6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-4,0,-2,0,4,0,2,0,-3,0,3,0,-3,0,3,0,0,0,0,0,0,0,0,0,-2,0,-1,0,-2,0,-1,0 }, + { 18,-18,-18,18,-18,18,18,-18,12,6,-12,-6,-12,-6,12,6,12,-12,6,-6,-12,12,-6,6,9,-9,-9,9,9,-9,-9,9,8,4,4,2,-8,-4,-4,-2,6,3,-6,-3,6,3,-6,-3,6,-6,3,-3,6,-6,3,-3,4,2,2,1,4,2,2,1 }, + { -12,12,12,-12,12,-12,-12,12,-6,-6,6,6,6,6,-6,-6,-8,8,-4,4,8,-8,4,-4,-6,6,6,-6,-6,6,6,-6,-4,-4,-2,-2,4,4,2,2,-3,-3,3,3,-3,-3,3,3,-4,4,-2,2,-4,4,-2,2,-2,-2,-1,-1,-2,-2,-1,-1 }, + { 4,0,-4,0,-4,0,4,0,0,0,0,0,0,0,0,0,2,0,2,0,-2,0,-2,0,2,0,-2,0,2,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0 }, + { 0,0,0,0,0,0,0,0,4,0,-4,0,-4,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,2,0,-2,0,-2,0,2,0,-2,0,2,0,-2,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,0 }, + { -12,12,12,-12,12,-12,-12,12,-8,-4,8,4,8,4,-8,-4,-6,6,-6,6,6,-6,6,-6,-6,6,6,-6,-6,6,6,-6,-4,-2,-4,-2,4,2,4,2,-4,-2,4,2,-4,-2,4,2,-3,3,-3,3,-3,3,-3,3,-2,-1,-2,-1,-2,-1,-2,-1 }, + { 8,-8,-8,8,-8,8,8,-8,4,4,-4,-4,-4,-4,4,4,4,-4,4,-4,-4,4,-4,4,4,-4,-4,4,4,-4,-4,4,2,2,2,2,-2,-2,-2,-2,2,2,-2,-2,2,2,-2,-2,2,-2,2,-2,2,-2,2,-2,1,1,1,1,1,1,1,1 } + }; + + /** Samples x-coordinates */ + private final double[] xval; + /** Samples y-coordinates */ + private final double[] yval; + /** Samples z-coordinates */ + private final double[] zval; + /** Set of cubic splines pacthing the whole data grid */ + private final TricubicSplineFunction[][][] splines; + + /** + * @param x Sample values of the x-coordinate, in increasing order. + * @param y Sample values of the y-coordinate, in increasing order. + * @param z Sample values of the y-coordinate, in increasing order. + * @param f Values of the function on every grid point. + * @param dFdX Values of the partial derivative of function with respect to x on every grid point. + * @param dFdY Values of the partial derivative of function with respect to y on every grid point. + * @param dFdZ Values of the partial derivative of function with respect to z on every grid point. + * @param d2FdXdY Values of the cross partial derivative of function on every grid point. + * @param d2FdXdZ Values of the cross partial derivative of function on every grid point. + * @param d2FdYdZ Values of the cross partial derivative of function on every grid point. + * @param d3FdXdYdZ Values of the cross partial derivative of function on every grid point. + * @throws NoDataException if any of the arrays has zero length. + * @throws DimensionMismatchException if the various arrays do not contain the expected number of elements. + * @throws NonMonotonicSequenceException if {@code x}, {@code y} or {@code z} are not strictly increasing. + */ + public TricubicSplineInterpolatingFunction(double[] x, + double[] y, + double[] z, + double[][][] f, + double[][][] dFdX, + double[][][] dFdY, + double[][][] dFdZ, + double[][][] d2FdXdY, + double[][][] d2FdXdZ, + double[][][] d2FdYdZ, + double[][][] d3FdXdYdZ) + throws NoDataException, + DimensionMismatchException, + NonMonotonicSequenceException { + final int xLen = x.length; + final int yLen = y.length; + final int zLen = z.length; + + if (xLen == 0 || yLen == 0 || z.length == 0 || f.length == 0 || f[0].length == 0) { + throw new NoDataException(); + } + if (xLen != f.length) { + throw new DimensionMismatchException(xLen, f.length); + } + if (xLen != dFdX.length) { + throw new DimensionMismatchException(xLen, dFdX.length); + } + if (xLen != dFdY.length) { + throw new DimensionMismatchException(xLen, dFdY.length); + } + if (xLen != dFdZ.length) { + throw new DimensionMismatchException(xLen, dFdZ.length); + } + if (xLen != d2FdXdY.length) { + throw new DimensionMismatchException(xLen, d2FdXdY.length); + } + if (xLen != d2FdXdZ.length) { + throw new DimensionMismatchException(xLen, d2FdXdZ.length); + } + if (xLen != d2FdYdZ.length) { + throw new DimensionMismatchException(xLen, d2FdYdZ.length); + } + if (xLen != d3FdXdYdZ.length) { + throw new DimensionMismatchException(xLen, d3FdXdYdZ.length); + } + + MathArrays.checkOrder(x); + MathArrays.checkOrder(y); + MathArrays.checkOrder(z); + + xval = x.clone(); + yval = y.clone(); + zval = z.clone(); + + final int lastI = xLen - 1; + final int lastJ = yLen - 1; + final int lastK = zLen - 1; + splines = new TricubicSplineFunction[lastI][lastJ][lastK]; + + for (int i = 0; i < lastI; i++) { + if (f[i].length != yLen) { + throw new DimensionMismatchException(f[i].length, yLen); + } + if (dFdX[i].length != yLen) { + throw new DimensionMismatchException(dFdX[i].length, yLen); + } + if (dFdY[i].length != yLen) { + throw new DimensionMismatchException(dFdY[i].length, yLen); + } + if (dFdZ[i].length != yLen) { + throw new DimensionMismatchException(dFdZ[i].length, yLen); + } + if (d2FdXdY[i].length != yLen) { + throw new DimensionMismatchException(d2FdXdY[i].length, yLen); + } + if (d2FdXdZ[i].length != yLen) { + throw new DimensionMismatchException(d2FdXdZ[i].length, yLen); + } + if (d2FdYdZ[i].length != yLen) { + throw new DimensionMismatchException(d2FdYdZ[i].length, yLen); + } + if (d3FdXdYdZ[i].length != yLen) { + throw new DimensionMismatchException(d3FdXdYdZ[i].length, yLen); + } + + final int ip1 = i + 1; + for (int j = 0; j < lastJ; j++) { + if (f[i][j].length != zLen) { + throw new DimensionMismatchException(f[i][j].length, zLen); + } + if (dFdX[i][j].length != zLen) { + throw new DimensionMismatchException(dFdX[i][j].length, zLen); + } + if (dFdY[i][j].length != zLen) { + throw new DimensionMismatchException(dFdY[i][j].length, zLen); + } + if (dFdZ[i][j].length != zLen) { + throw new DimensionMismatchException(dFdZ[i][j].length, zLen); + } + if (d2FdXdY[i][j].length != zLen) { + throw new DimensionMismatchException(d2FdXdY[i][j].length, zLen); + } + if (d2FdXdZ[i][j].length != zLen) { + throw new DimensionMismatchException(d2FdXdZ[i][j].length, zLen); + } + if (d2FdYdZ[i][j].length != zLen) { + throw new DimensionMismatchException(d2FdYdZ[i][j].length, zLen); + } + if (d3FdXdYdZ[i][j].length != zLen) { + throw new DimensionMismatchException(d3FdXdYdZ[i][j].length, zLen); + } + + final int jp1 = j + 1; + for (int k = 0; k < lastK; k++) { + final int kp1 = k + 1; + + final double[] beta = new double[] { + f[i][j][k], f[ip1][j][k], + f[i][jp1][k], f[ip1][jp1][k], + f[i][j][kp1], f[ip1][j][kp1], + f[i][jp1][kp1], f[ip1][jp1][kp1], + + dFdX[i][j][k], dFdX[ip1][j][k], + dFdX[i][jp1][k], dFdX[ip1][jp1][k], + dFdX[i][j][kp1], dFdX[ip1][j][kp1], + dFdX[i][jp1][kp1], dFdX[ip1][jp1][kp1], + + dFdY[i][j][k], dFdY[ip1][j][k], + dFdY[i][jp1][k], dFdY[ip1][jp1][k], + dFdY[i][j][kp1], dFdY[ip1][j][kp1], + dFdY[i][jp1][kp1], dFdY[ip1][jp1][kp1], + + dFdZ[i][j][k], dFdZ[ip1][j][k], + dFdZ[i][jp1][k], dFdZ[ip1][jp1][k], + dFdZ[i][j][kp1], dFdZ[ip1][j][kp1], + dFdZ[i][jp1][kp1], dFdZ[ip1][jp1][kp1], + + d2FdXdY[i][j][k], d2FdXdY[ip1][j][k], + d2FdXdY[i][jp1][k], d2FdXdY[ip1][jp1][k], + d2FdXdY[i][j][kp1], d2FdXdY[ip1][j][kp1], + d2FdXdY[i][jp1][kp1], d2FdXdY[ip1][jp1][kp1], + + d2FdXdZ[i][j][k], d2FdXdZ[ip1][j][k], + d2FdXdZ[i][jp1][k], d2FdXdZ[ip1][jp1][k], + d2FdXdZ[i][j][kp1], d2FdXdZ[ip1][j][kp1], + d2FdXdZ[i][jp1][kp1], d2FdXdZ[ip1][jp1][kp1], + + d2FdYdZ[i][j][k], d2FdYdZ[ip1][j][k], + d2FdYdZ[i][jp1][k], d2FdYdZ[ip1][jp1][k], + d2FdYdZ[i][j][kp1], d2FdYdZ[ip1][j][kp1], + d2FdYdZ[i][jp1][kp1], d2FdYdZ[ip1][jp1][kp1], + + d3FdXdYdZ[i][j][k], d3FdXdYdZ[ip1][j][k], + d3FdXdYdZ[i][jp1][k], d3FdXdYdZ[ip1][jp1][k], + d3FdXdYdZ[i][j][kp1], d3FdXdYdZ[ip1][j][kp1], + d3FdXdYdZ[i][jp1][kp1], d3FdXdYdZ[ip1][jp1][kp1], + }; + + splines[i][j][k] = new TricubicSplineFunction(computeSplineCoefficients(beta)); + } + } + } + } + + /** + * {@inheritDoc} + * + * @throws OutOfRangeException if any of the variables is outside its interpolation range. + */ + public double value(double x, double y, double z) + throws OutOfRangeException { + final int i = searchIndex(x, xval); + if (i == -1) { + throw new OutOfRangeException(x, xval[0], xval[xval.length - 1]); + } + final int j = searchIndex(y, yval); + if (j == -1) { + throw new OutOfRangeException(y, yval[0], yval[yval.length - 1]); + } + final int k = searchIndex(z, zval); + if (k == -1) { + throw new OutOfRangeException(z, zval[0], zval[zval.length - 1]); + } + + final double xN = (x - xval[i]) / (xval[i + 1] - xval[i]); + final double yN = (y - yval[j]) / (yval[j + 1] - yval[j]); + final double zN = (z - zval[k]) / (zval[k + 1] - zval[k]); + + return splines[i][j][k].value(xN, yN, zN); + } + + /** + * @param c Coordinate. + * @param val Coordinate samples. + * @return the index in {@code val} corresponding to the interval containing {@code c}, or {@code -1} + * if {@code c} is out of the range defined by the end values of {@code val}. + */ + private int searchIndex(double c, double[] val) { + if (c < val[0]) { + return -1; + } + + final int max = val.length; + for (int i = 1; i < max; i++) { + if (c <= val[i]) { + return i - 1; + } + } + + return -1; + } + + /** + * Compute the spline coefficients from the list of function values and + * function partial derivatives values at the four corners of a grid + * element. They must be specified in the following order: + *
+ * Parent package for common numerical analysis procedures, including root finding, + * function interpolation and integration. Note that optimization (i.e. minimization + * and maximization) is a separate top-level package. + *
+ *+ * Function interfaces are intended to be implemented by user code to represent + * domain problems. The algorithms provided by the library operate on these + * functions to find their roots, or integrate them, or ... Functions can be multivariate + * or univariate, real vectorial or matrix-valued, and they can be differentiable or not. + *
+ * + */ +package com.fr.third.org.apache.commons.math3.analysis; diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/polynomials/PolynomialFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/polynomials/PolynomialFunction.java new file mode 100644 index 000000000..ea2683f15 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/polynomials/PolynomialFunction.java @@ -0,0 +1,412 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.polynomials; + +import java.io.Serializable; +import java.util.Arrays; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure; +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction; +import com.fr.third.org.apache.commons.math3.exception.NoDataException; +import com.fr.third.org.apache.commons.math3.exception.NullArgumentException; +import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats; +import com.fr.third.org.apache.commons.math3.analysis.DifferentiableUnivariateFunction; +import com.fr.third.org.apache.commons.math3.analysis.ParametricUnivariateFunction; +import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction; +import com.fr.third.org.apache.commons.math3.util.FastMath; +import com.fr.third.org.apache.commons.math3.util.MathUtils; + +/** + * Immutable representation of a real polynomial function with real coefficients. + *+ * Horner's Method + * is used to evaluate the function.
+ * + */ +public class PolynomialFunction implements UnivariateDifferentiableFunction, DifferentiableUnivariateFunction, Serializable { + /** + * Serialization identifier + */ + private static final long serialVersionUID = -7726511984200295583L; + /** + * The coefficients of the polynomial, ordered by degree -- i.e., + * coefficients[0] is the constant term and coefficients[n] is the + * coefficient of x^n where n is the degree of the polynomial. + */ + private final double coefficients[]; + + /** + * Construct a polynomial with the given coefficients. The first element + * of the coefficients array is the constant term. Higher degree + * coefficients follow in sequence. The degree of the resulting polynomial + * is the index of the last non-null element of the array, or 0 if all elements + * are null. + *+ * The constructor makes a copy of the input array and assigns the copy to + * the coefficients property.
+ * + * @param c Polynomial coefficients. + * @throws NullArgumentException if {@code c} is {@code null}. + * @throws NoDataException if {@code c} is empty. + */ + public PolynomialFunction(double c[]) + throws NullArgumentException, NoDataException { + super(); + MathUtils.checkNotNull(c); + int n = c.length; + if (n == 0) { + throw new NoDataException(LocalizedFormats.EMPTY_POLYNOMIALS_COEFFICIENTS_ARRAY); + } + while ((n > 1) && (c[n - 1] == 0)) { + --n; + } + this.coefficients = new double[n]; + System.arraycopy(c, 0, this.coefficients, 0, n); + } + + /** + * Compute the value of the function for the given argument. + *+ * The value returned is
+ * {@code coefficients[n] * x^n + ... + coefficients[1] * x + coefficients[0]} + *
+ * + * @param x Argument for which the function value should be computed. + * @return the value of the polynomial at the given point. + * @see UnivariateFunction#value(double) + */ + public double value(double x) { + return evaluate(coefficients, x); + } + + /** + * Returns the degree of the polynomial. + * + * @return the degree of the polynomial. + */ + public int degree() { + return coefficients.length - 1; + } + + /** + * Returns a copy of the coefficients array. + *+ * Changes made to the returned copy will not affect the coefficients of + * the polynomial.
+ * + * @return a fresh copy of the coefficients array. + */ + public double[] getCoefficients() { + return coefficients.clone(); + } + + /** + * Uses Horner's Method to evaluate the polynomial with the given coefficients at + * the argument. + * + * @param coefficients Coefficients of the polynomial to evaluate. + * @param argument Input value. + * @return the value of the polynomial. + * @throws NoDataException if {@code coefficients} is empty. + * @throws NullArgumentException if {@code coefficients} is {@code null}. + */ + protected static double evaluate(double[] coefficients, double argument) + throws NullArgumentException, NoDataException { + MathUtils.checkNotNull(coefficients); + int n = coefficients.length; + if (n == 0) { + throw new NoDataException(LocalizedFormats.EMPTY_POLYNOMIALS_COEFFICIENTS_ARRAY); + } + double result = coefficients[n - 1]; + for (int j = n - 2; j >= 0; j--) { + result = argument * result + coefficients[j]; + } + return result; + } + + + /** {@inheritDoc} + * @since 3.1 + * @throws NoDataException if {@code coefficients} is empty. + * @throws NullArgumentException if {@code coefficients} is {@code null}. + */ + public DerivativeStructure value(final DerivativeStructure t) + throws NullArgumentException, NoDataException { + MathUtils.checkNotNull(coefficients); + int n = coefficients.length; + if (n == 0) { + throw new NoDataException(LocalizedFormats.EMPTY_POLYNOMIALS_COEFFICIENTS_ARRAY); + } + DerivativeStructure result = + new DerivativeStructure(t.getFreeParameters(), t.getOrder(), coefficients[n - 1]); + for (int j = n - 2; j >= 0; j--) { + result = result.multiply(t).add(coefficients[j]); + } + return result; + } + + /** + * Add a polynomial to the instance. + * + * @param p Polynomial to add. + * @return a new polynomial which is the sum of the instance and {@code p}. + */ + public PolynomialFunction add(final PolynomialFunction p) { + // identify the lowest degree polynomial + final int lowLength = FastMath.min(coefficients.length, p.coefficients.length); + final int highLength = FastMath.max(coefficients.length, p.coefficients.length); + + // build the coefficients array + double[] newCoefficients = new double[highLength]; + for (int i = 0; i < lowLength; ++i) { + newCoefficients[i] = coefficients[i] + p.coefficients[i]; + } + System.arraycopy((coefficients.length < p.coefficients.length) ? + p.coefficients : coefficients, + lowLength, + newCoefficients, lowLength, + highLength - lowLength); + + return new PolynomialFunction(newCoefficients); + } + + /** + * Subtract a polynomial from the instance. + * + * @param p Polynomial to subtract. + * @return a new polynomial which is the instance minus {@code p}. + */ + public PolynomialFunction subtract(final PolynomialFunction p) { + // identify the lowest degree polynomial + int lowLength = FastMath.min(coefficients.length, p.coefficients.length); + int highLength = FastMath.max(coefficients.length, p.coefficients.length); + + // build the coefficients array + double[] newCoefficients = new double[highLength]; + for (int i = 0; i < lowLength; ++i) { + newCoefficients[i] = coefficients[i] - p.coefficients[i]; + } + if (coefficients.length < p.coefficients.length) { + for (int i = lowLength; i < highLength; ++i) { + newCoefficients[i] = -p.coefficients[i]; + } + } else { + System.arraycopy(coefficients, lowLength, newCoefficients, lowLength, + highLength - lowLength); + } + + return new PolynomialFunction(newCoefficients); + } + + /** + * Negate the instance. + * + * @return a new polynomial with all coefficients negated + */ + public PolynomialFunction negate() { + double[] newCoefficients = new double[coefficients.length]; + for (int i = 0; i < coefficients.length; ++i) { + newCoefficients[i] = -coefficients[i]; + } + return new PolynomialFunction(newCoefficients); + } + + /** + * Multiply the instance by a polynomial. + * + * @param p Polynomial to multiply by. + * @return a new polynomial equal to this times {@code p} + */ + public PolynomialFunction multiply(final PolynomialFunction p) { + double[] newCoefficients = new double[coefficients.length + p.coefficients.length - 1]; + + for (int i = 0; i < newCoefficients.length; ++i) { + newCoefficients[i] = 0.0; + for (int j = FastMath.max(0, i + 1 - p.coefficients.length); + j < FastMath.min(coefficients.length, i + 1); + ++j) { + newCoefficients[i] += coefficients[j] * p.coefficients[i-j]; + } + } + + return new PolynomialFunction(newCoefficients); + } + + /** + * Returns the coefficients of the derivative of the polynomial with the given coefficients. + * + * @param coefficients Coefficients of the polynomial to differentiate. + * @return the coefficients of the derivative or {@code null} if coefficients has length 1. + * @throws NoDataException if {@code coefficients} is empty. + * @throws NullArgumentException if {@code coefficients} is {@code null}. + */ + protected static double[] differentiate(double[] coefficients) + throws NullArgumentException, NoDataException { + MathUtils.checkNotNull(coefficients); + int n = coefficients.length; + if (n == 0) { + throw new NoDataException(LocalizedFormats.EMPTY_POLYNOMIALS_COEFFICIENTS_ARRAY); + } + if (n == 1) { + return new double[]{0}; + } + double[] result = new double[n - 1]; + for (int i = n - 1; i > 0; i--) { + result[i - 1] = i * coefficients[i]; + } + return result; + } + + /** + * Returns the derivative as a {@link PolynomialFunction}. + * + * @return the derivative polynomial. + */ + public PolynomialFunction polynomialDerivative() { + return new PolynomialFunction(differentiate(coefficients)); + } + + /** + * Returns the derivative as a {@link UnivariateFunction}. + * + * @return the derivative function. + */ + public UnivariateFunction derivative() { + return polynomialDerivative(); + } + + /** + * Returns a string representation of the polynomial. + * + *The representation is user oriented. Terms are displayed lowest
+ * degrees first. The multiplications signs, coefficients equals to
+ * one and null terms are not displayed (except if the polynomial is 0,
+ * in which case the 0 constant term is displayed). Addition of terms
+ * with negative coefficients are replaced by subtraction of terms
+ * with positive coefficients except for the first displayed term
+ * (i.e. we display -3 for a constant negative polynomial,
+ * but 1 - 3 x + x^2 if the negative coefficient is not
+ * the first one displayed).
+ * The approximated function should be smooth enough for Lagrange polynomial + * to work well. Otherwise, consider using splines instead.
+ * + * @since 1.2 + */ +public class PolynomialFunctionLagrangeForm implements UnivariateFunction { + /** + * The coefficients of the polynomial, ordered by degree -- i.e. + * coefficients[0] is the constant term and coefficients[n] is the + * coefficient of x^n where n is the degree of the polynomial. + */ + private double coefficients[]; + /** + * Interpolating points (abscissas). + */ + private final double x[]; + /** + * Function values at interpolating points. + */ + private final double y[]; + /** + * Whether the polynomial coefficients are available. + */ + private boolean coefficientsComputed; + + /** + * Construct a Lagrange polynomial with the given abscissas and function + * values. The order of interpolating points are not important. + *+ * The constructor makes copy of the input arrays and assigns them.
+ * + * @param x interpolating points + * @param y function values at interpolating points + * @throws DimensionMismatchException if the array lengths are different. + * @throws NumberIsTooSmallException if the number of points is less than 2. + * @throws NonMonotonicSequenceException + * if two abscissae have the same value. + */ + public PolynomialFunctionLagrangeForm(double x[], double y[]) + throws DimensionMismatchException, NumberIsTooSmallException, NonMonotonicSequenceException { + this.x = new double[x.length]; + this.y = new double[y.length]; + System.arraycopy(x, 0, this.x, 0, x.length); + System.arraycopy(y, 0, this.y, 0, y.length); + coefficientsComputed = false; + + if (!verifyInterpolationArray(x, y, false)) { + MathArrays.sortInPlace(this.x, this.y); + // Second check in case some abscissa is duplicated. + verifyInterpolationArray(this.x, this.y, true); + } + } + + /** + * Calculate the function value at the given point. + * + * @param z Point at which the function value is to be computed. + * @return the function value. + * @throws DimensionMismatchException if {@code x} and {@code y} have + * different lengths. + * @throws NonMonotonicSequenceException + * if {@code x} is not sorted in strictly increasing order. + * @throws NumberIsTooSmallException if the size of {@code x} is less + * than 2. + */ + public double value(double z) { + return evaluateInternal(x, y, z); + } + + /** + * Returns the degree of the polynomial. + * + * @return the degree of the polynomial + */ + public int degree() { + return x.length - 1; + } + + /** + * Returns a copy of the interpolating points array. + *+ * Changes made to the returned copy will not affect the polynomial.
+ * + * @return a fresh copy of the interpolating points array + */ + public double[] getInterpolatingPoints() { + double[] out = new double[x.length]; + System.arraycopy(x, 0, out, 0, x.length); + return out; + } + + /** + * Returns a copy of the interpolating values array. + *+ * Changes made to the returned copy will not affect the polynomial.
+ * + * @return a fresh copy of the interpolating values array + */ + public double[] getInterpolatingValues() { + double[] out = new double[y.length]; + System.arraycopy(y, 0, out, 0, y.length); + return out; + } + + /** + * Returns a copy of the coefficients array. + *+ * Changes made to the returned copy will not affect the polynomial.
+ *+ * Note that coefficients computation can be ill-conditioned. Use with caution + * and only when it is necessary.
+ * + * @return a fresh copy of the coefficients array + */ + public double[] getCoefficients() { + if (!coefficientsComputed) { + computeCoefficients(); + } + double[] out = new double[coefficients.length]; + System.arraycopy(coefficients, 0, out, 0, coefficients.length); + return out; + } + + /** + * Evaluate the Lagrange polynomial using + * + * Neville's Algorithm. It takes O(n^2) time. + * + * @param x Interpolating points array. + * @param y Interpolating values array. + * @param z Point at which the function value is to be computed. + * @return the function value. + * @throws DimensionMismatchException if {@code x} and {@code y} have + * different lengths. + * @throws NonMonotonicSequenceException + * if {@code x} is not sorted in strictly increasing order. + * @throws NumberIsTooSmallException if the size of {@code x} is less + * than 2. + */ + public static double evaluate(double x[], double y[], double z) + throws DimensionMismatchException, NumberIsTooSmallException, NonMonotonicSequenceException { + if (verifyInterpolationArray(x, y, false)) { + return evaluateInternal(x, y, z); + } + + // Array is not sorted. + final double[] xNew = new double[x.length]; + final double[] yNew = new double[y.length]; + System.arraycopy(x, 0, xNew, 0, x.length); + System.arraycopy(y, 0, yNew, 0, y.length); + + MathArrays.sortInPlace(xNew, yNew); + // Second check in case some abscissa is duplicated. + verifyInterpolationArray(xNew, yNew, true); + return evaluateInternal(xNew, yNew, z); + } + + /** + * Evaluate the Lagrange polynomial using + * + * Neville's Algorithm. It takes O(n^2) time. + * + * @param x Interpolating points array. + * @param y Interpolating values array. + * @param z Point at which the function value is to be computed. + * @return the function value. + * @throws DimensionMismatchException if {@code x} and {@code y} have + * different lengths. + * @throws NonMonotonicSequenceException + * if {@code x} is not sorted in strictly increasing order. + * @throws NumberIsTooSmallException if the size of {@code x} is less + * than 2. + */ + private static double evaluateInternal(double x[], double y[], double z) { + int nearest = 0; + final int n = x.length; + final double[] c = new double[n]; + final double[] d = new double[n]; + double min_dist = Double.POSITIVE_INFINITY; + for (int i = 0; i < n; i++) { + // initialize the difference arrays + c[i] = y[i]; + d[i] = y[i]; + // find out the abscissa closest to z + final double dist = FastMath.abs(z - x[i]); + if (dist < min_dist) { + nearest = i; + min_dist = dist; + } + } + + // initial approximation to the function value at z + double value = y[nearest]; + + for (int i = 1; i < n; i++) { + for (int j = 0; j < n-i; j++) { + final double tc = x[j] - z; + final double td = x[i+j] - z; + final double divider = x[j] - x[i+j]; + // update the difference arrays + final double w = (c[j+1] - d[j]) / divider; + c[j] = tc * w; + d[j] = td * w; + } + // sum up the difference terms to get the final value + if (nearest < 0.5*(n-i+1)) { + value += c[nearest]; // fork down + } else { + nearest--; + value += d[nearest]; // fork up + } + } + + return value; + } + + /** + * Calculate the coefficients of Lagrange polynomial from the + * interpolation data. It takes O(n^2) time. + * Note that this computation can be ill-conditioned: Use with caution + * and only when it is necessary. + */ + protected void computeCoefficients() { + final int n = degree() + 1; + coefficients = new double[n]; + for (int i = 0; i < n; i++) { + coefficients[i] = 0.0; + } + + // c[] are the coefficients of P(x) = (x-x[0])(x-x[1])...(x-x[n-1]) + final double[] c = new double[n+1]; + c[0] = 1.0; + for (int i = 0; i < n; i++) { + for (int j = i; j > 0; j--) { + c[j] = c[j-1] - c[j] * x[i]; + } + c[0] *= -x[i]; + c[i+1] = 1; + } + + final double[] tc = new double[n]; + for (int i = 0; i < n; i++) { + // d = (x[i]-x[0])...(x[i]-x[i-1])(x[i]-x[i+1])...(x[i]-x[n-1]) + double d = 1; + for (int j = 0; j < n; j++) { + if (i != j) { + d *= x[i] - x[j]; + } + } + final double t = y[i] / d; + // Lagrange polynomial is the sum of n terms, each of which is a + // polynomial of degree n-1. tc[] are the coefficients of the i-th + // numerator Pi(x) = (x-x[0])...(x-x[i-1])(x-x[i+1])...(x-x[n-1]). + tc[n-1] = c[n]; // actually c[n] = 1 + coefficients[n-1] += t * tc[n-1]; + for (int j = n-2; j >= 0; j--) { + tc[j] = c[j+1] + tc[j+1] * x[i]; + coefficients[j] += t * tc[j]; + } + } + + coefficientsComputed = true; + } + + /** + * Check that the interpolation arrays are valid. + * The arrays features checked by this method are that both arrays have the + * same length and this length is at least 2. + * + * @param x Interpolating points array. + * @param y Interpolating values array. + * @param abort Whether to throw an exception if {@code x} is not sorted. + * @throws DimensionMismatchException if the array lengths are different. + * @throws NumberIsTooSmallException if the number of points is less than 2. + * @throws NonMonotonicSequenceException + * if {@code x} is not sorted in strictly increasing order and {@code abort} + * is {@code true}. + * @return {@code false} if the {@code x} is not sorted in increasing order, + * {@code true} otherwise. + * @see #evaluate(double[], double[], double) + * @see #computeCoefficients() + */ + public static boolean verifyInterpolationArray(double x[], double y[], boolean abort) + throws DimensionMismatchException, NumberIsTooSmallException, NonMonotonicSequenceException { + if (x.length != y.length) { + throw new DimensionMismatchException(x.length, y.length); + } + if (x.length < 2) { + throw new NumberIsTooSmallException(LocalizedFormats.WRONG_NUMBER_OF_POINTS, 2, x.length, true); + } + + return MathArrays.checkOrder(x, MathArrays.OrderDirection.INCREASING, true, abort); + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/polynomials/PolynomialFunctionNewtonForm.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/polynomials/PolynomialFunctionNewtonForm.java new file mode 100644 index 000000000..8509160a9 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/polynomials/PolynomialFunctionNewtonForm.java @@ -0,0 +1,246 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.polynomials; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure; +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction; +import com.fr.third.org.apache.commons.math3.analysis.interpolation.DividedDifferenceInterpolator; +import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException; +import com.fr.third.org.apache.commons.math3.exception.NoDataException; +import com.fr.third.org.apache.commons.math3.exception.NullArgumentException; +import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats; +import com.fr.third.org.apache.commons.math3.util.MathUtils; + +/** + * Implements the representation of a real polynomial function in + * Newton Form. For reference, see Elementary Numerical Analysis, + * ISBN 0070124477, chapter 2. + *+ * The formula of polynomial in Newton form is + * p(x) = a[0] + a[1](x-c[0]) + a[2](x-c[0])(x-c[1]) + ... + + * a[n](x-c[0])(x-c[1])...(x-c[n-1]) + * Note that the length of a[] is one more than the length of c[]
+ * + * @since 1.2 + */ +public class PolynomialFunctionNewtonForm implements UnivariateDifferentiableFunction { + + /** + * The coefficients of the polynomial, ordered by degree -- i.e. + * coefficients[0] is the constant term and coefficients[n] is the + * coefficient of x^n where n is the degree of the polynomial. + */ + private double coefficients[]; + + /** + * Centers of the Newton polynomial. + */ + private final double c[]; + + /** + * When all c[i] = 0, a[] becomes normal polynomial coefficients, + * i.e. a[i] = coefficients[i]. + */ + private final double a[]; + + /** + * Whether the polynomial coefficients are available. + */ + private boolean coefficientsComputed; + + /** + * Construct a Newton polynomial with the given a[] and c[]. The order of + * centers are important in that if c[] shuffle, then values of a[] would + * completely change, not just a permutation of old a[]. + *+ * The constructor makes copy of the input arrays and assigns them.
+ * + * @param a Coefficients in Newton form formula. + * @param c Centers. + * @throws NullArgumentException if any argument is {@code null}. + * @throws NoDataException if any array has zero length. + * @throws DimensionMismatchException if the size difference between + * {@code a} and {@code c} is not equal to 1. + */ + public PolynomialFunctionNewtonForm(double a[], double c[]) + throws NullArgumentException, NoDataException, DimensionMismatchException { + + verifyInputArray(a, c); + this.a = new double[a.length]; + this.c = new double[c.length]; + System.arraycopy(a, 0, this.a, 0, a.length); + System.arraycopy(c, 0, this.c, 0, c.length); + coefficientsComputed = false; + } + + /** + * Calculate the function value at the given point. + * + * @param z Point at which the function value is to be computed. + * @return the function value. + */ + public double value(double z) { + return evaluate(a, c, z); + } + + /** + * {@inheritDoc} + * @since 3.1 + */ + public DerivativeStructure value(final DerivativeStructure t) { + verifyInputArray(a, c); + + final int n = c.length; + DerivativeStructure value = new DerivativeStructure(t.getFreeParameters(), t.getOrder(), a[n]); + for (int i = n - 1; i >= 0; i--) { + value = t.subtract(c[i]).multiply(value).add(a[i]); + } + + return value; + + } + + /** + * Returns the degree of the polynomial. + * + * @return the degree of the polynomial + */ + public int degree() { + return c.length; + } + + /** + * Returns a copy of coefficients in Newton form formula. + *+ * Changes made to the returned copy will not affect the polynomial.
+ * + * @return a fresh copy of coefficients in Newton form formula + */ + public double[] getNewtonCoefficients() { + double[] out = new double[a.length]; + System.arraycopy(a, 0, out, 0, a.length); + return out; + } + + /** + * Returns a copy of the centers array. + *+ * Changes made to the returned copy will not affect the polynomial.
+ * + * @return a fresh copy of the centers array. + */ + public double[] getCenters() { + double[] out = new double[c.length]; + System.arraycopy(c, 0, out, 0, c.length); + return out; + } + + /** + * Returns a copy of the coefficients array. + *+ * Changes made to the returned copy will not affect the polynomial.
+ * + * @return a fresh copy of the coefficients array. + */ + public double[] getCoefficients() { + if (!coefficientsComputed) { + computeCoefficients(); + } + double[] out = new double[coefficients.length]; + System.arraycopy(coefficients, 0, out, 0, coefficients.length); + return out; + } + + /** + * Evaluate the Newton polynomial using nested multiplication. It is + * also called + * Horner's Rule and takes O(N) time. + * + * @param a Coefficients in Newton form formula. + * @param c Centers. + * @param z Point at which the function value is to be computed. + * @return the function value. + * @throws NullArgumentException if any argument is {@code null}. + * @throws NoDataException if any array has zero length. + * @throws DimensionMismatchException if the size difference between + * {@code a} and {@code c} is not equal to 1. + */ + public static double evaluate(double a[], double c[], double z) + throws NullArgumentException, DimensionMismatchException, NoDataException { + verifyInputArray(a, c); + + final int n = c.length; + double value = a[n]; + for (int i = n - 1; i >= 0; i--) { + value = a[i] + (z - c[i]) * value; + } + + return value; + } + + /** + * Calculate the normal polynomial coefficients given the Newton form. + * It also uses nested multiplication but takes O(N^2) time. + */ + protected void computeCoefficients() { + final int n = degree(); + + coefficients = new double[n+1]; + for (int i = 0; i <= n; i++) { + coefficients[i] = 0.0; + } + + coefficients[0] = a[n]; + for (int i = n-1; i >= 0; i--) { + for (int j = n-i; j > 0; j--) { + coefficients[j] = coefficients[j-1] - c[i] * coefficients[j]; + } + coefficients[0] = a[i] - c[i] * coefficients[0]; + } + + coefficientsComputed = true; + } + + /** + * Verifies that the input arrays are valid. + *+ * The centers must be distinct for interpolation purposes, but not + * for general use. Thus it is not verified here.
+ * + * @param a the coefficients in Newton form formula + * @param c the centers + * @throws NullArgumentException if any argument is {@code null}. + * @throws NoDataException if any array has zero length. + * @throws DimensionMismatchException if the size difference between + * {@code a} and {@code c} is not equal to 1. + * @see DividedDifferenceInterpolator#computeDividedDifference(double[], + * double[]) + */ + protected static void verifyInputArray(double a[], double c[]) + throws NullArgumentException, NoDataException, DimensionMismatchException { + MathUtils.checkNotNull(a); + MathUtils.checkNotNull(c); + if (a.length == 0 || c.length == 0) { + throw new NoDataException(LocalizedFormats.EMPTY_POLYNOMIALS_COEFFICIENTS_ARRAY); + } + if (a.length != c.length + 1) { + throw new DimensionMismatchException(LocalizedFormats.ARRAY_SIZES_SHOULD_HAVE_DIFFERENCE_1, + a.length, c.length); + } + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/polynomials/PolynomialSplineFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/polynomials/PolynomialSplineFunction.java new file mode 100644 index 000000000..a3b5f0f5a --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/polynomials/PolynomialSplineFunction.java @@ -0,0 +1,246 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.analysis.polynomials; + +import java.util.Arrays; + +import com.fr.third.org.apache.commons.math3.analysis.differentiation.DerivativeStructure; +import com.fr.third.org.apache.commons.math3.analysis.differentiation.UnivariateDifferentiableFunction; +import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException; +import com.fr.third.org.apache.commons.math3.exception.NonMonotonicSequenceException; +import com.fr.third.org.apache.commons.math3.exception.NullArgumentException; +import com.fr.third.org.apache.commons.math3.exception.NumberIsTooSmallException; +import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException; +import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats; +import com.fr.third.org.apache.commons.math3.analysis.DifferentiableUnivariateFunction; +import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction; +import com.fr.third.org.apache.commons.math3.util.MathArrays; + +/** + * Represents a polynomial spline function. + *
+ * A polynomial spline function consists of a set of
+ * interpolating polynomials and an ascending array of domain
+ * knot points, determining the intervals over which the spline function
+ * is defined by the constituent polynomials. The polynomials are assumed to
+ * have been computed to match the values of another function at the knot
+ * points. The value consistency constraints are not currently enforced by
+ * PolynomialSplineFunction itself, but are assumed to hold among
+ * the polynomials and knot points passed to the constructor.
+ * N.B.: The polynomials in the polynomials property must be
+ * centered on the knot points to compute the spline function values.
+ * See below.
+ * The domain of the polynomial spline function is
+ * [smallest knot, largest knot]. Attempts to evaluate the
+ * function at values outside of this range generate IllegalArgumentExceptions.
+ *
+ * The value of the polynomial spline function for an argument x
+ * is computed as follows:
+ *
x
+ * belongs. If x is less than the smallest knot point or greater
+ * than the largest one, an IllegalArgumentException
+ * is thrown.j be the index of the largest knot point that is less
+ * than or equal to x. The value returned is
+ * {@code polynomials[j](x - knot[j])}Chebyshev + * polynomials of the first kind are orthogonal polynomials. + * They can be defined by the following recurrence relations:
+ * \( + * T_0(x) = 1 \\ + * T_1(x) = x \\ + * T_{k+1}(x) = 2x T_k(x) - T_{k-1}(x) + * \) + *
+ * @param degree degree of the polynomial + * @return Chebyshev polynomial of specified degree + */ + public static PolynomialFunction createChebyshevPolynomial(final int degree) { + return buildPolynomial(degree, CHEBYSHEV_COEFFICIENTS, + new RecurrenceCoefficientsGenerator() { + /** Fixed recurrence coefficients. */ + private final BigFraction[] coeffs = { BigFraction.ZERO, BigFraction.TWO, BigFraction.ONE }; + /** {@inheritDoc} */ + public BigFraction[] generate(int k) { + return coeffs; + } + }); + } + + /** + * Create a Hermite polynomial. + *Hermite + * polynomials are orthogonal polynomials. + * They can be defined by the following recurrence relations:
+ * \( + * H_0(x) = 1 \\ + * H_1(x) = 2x \\ + * H_{k+1}(x) = 2x H_k(X) - 2k H_{k-1}(x) + * \) + *
+ + * @param degree degree of the polynomial + * @return Hermite polynomial of specified degree + */ + public static PolynomialFunction createHermitePolynomial(final int degree) { + return buildPolynomial(degree, HERMITE_COEFFICIENTS, + new RecurrenceCoefficientsGenerator() { + /** {@inheritDoc} */ + public BigFraction[] generate(int k) { + return new BigFraction[] { + BigFraction.ZERO, + BigFraction.TWO, + new BigFraction(2 * k)}; + } + }); + } + + /** + * Create a Laguerre polynomial. + *Laguerre + * polynomials are orthogonal polynomials. + * They can be defined by the following recurrence relations:
+ * \( + * L_0(x) = 1 \\ + * L_1(x) = 1 - x \\ + * (k+1) L_{k+1}(x) = (2k + 1 - x) L_k(x) - k L_{k-1}(x) + * \) + *
+ * @param degree degree of the polynomial + * @return Laguerre polynomial of specified degree + */ + public static PolynomialFunction createLaguerrePolynomial(final int degree) { + return buildPolynomial(degree, LAGUERRE_COEFFICIENTS, + new RecurrenceCoefficientsGenerator() { + /** {@inheritDoc} */ + public BigFraction[] generate(int k) { + final int kP1 = k + 1; + return new BigFraction[] { + new BigFraction(2 * k + 1, kP1), + new BigFraction(-1, kP1), + new BigFraction(k, kP1)}; + } + }); + } + + /** + * Create a Legendre polynomial. + *Legendre + * polynomials are orthogonal polynomials. + * They can be defined by the following recurrence relations:
+ * \( + * P_0(x) = 1 \\ + * P_1(x) = x \\ + * (k+1) P_{k+1}(x) = (2k+1) x P_k(x) - k P_{k-1}(x) + * \) + *
+ * @param degree degree of the polynomial + * @return Legendre polynomial of specified degree + */ + public static PolynomialFunction createLegendrePolynomial(final int degree) { + return buildPolynomial(degree, LEGENDRE_COEFFICIENTS, + new RecurrenceCoefficientsGenerator() { + /** {@inheritDoc} */ + public BigFraction[] generate(int k) { + final int kP1 = k + 1; + return new BigFraction[] { + BigFraction.ZERO, + new BigFraction(k + kP1, kP1), + new BigFraction(k, kP1)}; + } + }); + } + + /** + * Create a Jacobi polynomial. + *Jacobi + * polynomials are orthogonal polynomials. + * They can be defined by the following recurrence relations:
+ * \( + * P_0^{vw}(x) = 1 \\ + * P_{-1}^{vw}(x) = 0 \\ + * 2k(k + v + w)(2k + v + w - 2) P_k^{vw}(x) = \\ + * (2k + v + w - 1)[(2k + v + w)(2k + v + w - 2) x + v^2 - w^2] P_{k-1}^{vw}(x) \\ + * - 2(k + v - 1)(k + w - 1)(2k + v + w) P_{k-2}^{vw}(x) + * \) + *
+ * @param degree degree of the polynomial + * @param v first exponent + * @param w second exponent + * @return Jacobi polynomial of specified degree + */ + public static PolynomialFunction createJacobiPolynomial(final int degree, final int v, final int w) { + + // select the appropriate list + final JacobiKey key = new JacobiKey(v, w); + + if (!JACOBI_COEFFICIENTS.containsKey(key)) { + + // allocate a new list for v, w + final List
+ * More precisely, let \(\Delta = \) {@code shift} and let
+ * \(P_s(x) = P(x + \Delta)\). The returned array
+ * consists of the coefficients of \(P_s\). So if \(a_0, ..., a_{n-1}\)
+ * are the coefficients of \(P\), then the returned array
+ * \(b_0, ..., b_{n-1}\) satisfies the identity
+ * \(\sum_{i=0}^{n-1} b_i x^i = \sum_{i=0}^{n-1} a_i (x + \Delta)^i\) for all \(x\).
+ *
+ * @param coefficients Coefficients of the original polynomial.
+ * @param shift Shift value.
+ * @return the coefficients \(b_i\) of the shifted
+ * polynomial.
+ */
+ public static double[] shift(final double[] coefficients,
+ final double shift) {
+ final int dp1 = coefficients.length;
+ final double[] newCoefficients = new double[dp1];
+
+ // Pascal triangle.
+ final int[][] coeff = new int[dp1][dp1];
+ for (int i = 0; i < dp1; i++){
+ for(int j = 0; j <= i; j++){
+ coeff[i][j] = (int) CombinatoricsUtils.binomialCoefficient(i, j);
+ }
+ }
+
+ // First polynomial coefficient.
+ for (int i = 0; i < dp1; i++){
+ newCoefficients[0] += coefficients[i] * FastMath.pow(shift, i);
+ }
+
+ // Superior order.
+ final int d = dp1 - 1;
+ for (int i = 0; i < d; i++) {
+ for (int j = i; j < d; j++){
+ newCoefficients[i + 1] += coeff[j + 1][j - i] *
+ coefficients[j + 1] * FastMath.pow(shift, j - i);
+ }
+ }
+
+ return newCoefficients;
+ }
+
+
+ /** Get the coefficients array for a given degree.
+ * @param degree degree of the polynomial
+ * @param coefficients list where the computed coefficients are stored
+ * @param generator recurrence coefficients generator
+ * @return coefficients array
+ */
+ private static PolynomialFunction buildPolynomial(final int degree,
+ final List If all solutions are accepted ({@link #ANY_SIDE}), then the solution
+ * that the root-finding algorithm returns for a given root may be equal to the
+ * actual root, but it may also be an approximation that is slightly smaller
+ * or slightly larger than the actual root. Root-finding algorithms generally
+ * only guarantee that the returned solution is within the requested
+ * tolerances. In certain cases however, in particular for
+ * {@link EventHandler state events} of
+ * {@link ODEIntegrator ODE solvers}, it
+ * may be necessary to guarantee that a solution is returned that lies on a
+ * specific side the solution. Implementation of the {@link RegulaFalsiSolver Regula Falsi} and
+ * {@link IllinoisSolver Illinois} methods is based on the
+ * following article: M. Dowell and P. Jarratt,
+ * A modified regula falsi method for computing the root of an
+ * equation, BIT Numerical Mathematics, volume 11, number 2,
+ * pages 168-174, Springer, 1971. Implementation of the {@link PegasusSolver Pegasus} method is
+ * based on the following article: M. Dowell and P. Jarratt,
+ * The "Pegasus" method for computing the root of an equation,
+ * BIT Numerical Mathematics, volume 12, number 4, pages 503-508, Springer,
+ * 1972. The {@link SecantSolver Secant} method is not a
+ * bracketing method, so it is not implemented here. It has a separate
+ * implementation.
+ * The function should be continuous but not necessarily smooth. For backwards compatibility, all root-finding algorithms must have
+ * {@link AllowedSolution#ANY_SIDE ANY_SIDE} as default for the allowed
+ * solutions. For backwards compatibility, all root-finding algorithms must have
+ * {@link AllowedSolution#ANY_SIDE ANY_SIDE} as default for the allowed
+ * solutions.
+ * The changes with respect to the original Brent algorithm are:
+ *
+ * The given interval must bracket the root.
+ * The x value is guessed by evaluating polynomial Q(y) at y = targetY, where Q
+ * is built such that for all considered points (xi, yi),
+ * Q(yi) = xi.
+ * The given interval must bracket the root.
+ * The reference implementation is given in chapter 4 of
+ *
+ * The changes with respect to the original Brent algorithm are:
+ *
+ * The given interval must bracket the root.
+ * The x value is guessed by evaluating polynomial Q(y) at y = targetY, where Q
+ * is built such that for all considered points (xi, yi),
+ * Q(yi) = xi.
+ * Like the Regula Falsi method, convergence is guaranteed by
+ * maintaining a bracketed solution. The Illinois method however,
+ * should converge much faster than the original Regula Falsi
+ * method. Furthermore, this implementation of the Illinois method
+ * should not suffer from the same implementation issues as the Regula
+ * Falsi method, which may fail to convergence in certain cases. The Illinois method assumes that the function is continuous,
+ * but not necessarily smooth. Implementation based on the following article: M. Dowell and P. Jarratt,
+ * A modified regula falsi method for computing the root of an
+ * equation, BIT Numerical Mathematics, volume 11, number 2,
+ * pages 168-174, Springer, 1971.
+ * Note: This method is not part of the API of {@link BaseUnivariateSolver}.
+ * Note: This method is not part of the API of {@link BaseUnivariateSolver}.
+ * Note: This method is not part of the API of {@link BaseUnivariateSolver}.
+ * Note: This method is not part of the API of {@link BaseUnivariateSolver}.
+ * Muller's method applies to both real and complex functions, but here we
+ * restrict ourselves to real functions.
+ * This class differs from {@link MullerSolver} in the way it avoids complex
+ * operations.
+ * Muller's original method would have function evaluation at complex point.
+ * Since our f(x) is real, we have to find ways to avoid that. Bracketing
+ * condition is one way to go: by requiring bracketing in every iteration,
+ * the newly computed approximation is guaranteed to be real.
+ * Normally Muller's method converges quadratically in the vicinity of a
+ * zero, however it may be very slow in regions far away from zeros. For
+ * example, f(x) = exp(x) - 1, min = -50, max = 100. In such case we use
+ * bisection as a safety backup if it performs very poorly.
+ * The formulas here use divided differences directly.
+ * Muller's method applies to both real and complex functions, but here we
+ * restrict ourselves to real functions.
+ * This class differs from {@link MullerSolver} in the way it avoids complex
+ * operations.
+ * Except for the initial [min, max], it does not require bracketing
+ * condition, e.g. f(x0), f(x1), f(x2) can have the same sign. If a complex
+ * number arises in the computation, we simply use its modulus as a real
+ * approximation.
+ * Because the interval may not be bracketing, the bisection alternative is
+ * not applicable here. However in practice our treatment usually works
+ * well, especially near real zeroes where the imaginary part of the complex
+ * approximation is often negligible.
+ * The formulas here do not use divided differences directly.
+ * The function should be continuous but not necessarily smooth. Like the Regula Falsi method, convergence is guaranteed by
+ * maintaining a bracketed solution. The Pegasus method however,
+ * should converge much faster than the original Regula Falsi
+ * method. Furthermore, this implementation of the Pegasus method
+ * should not suffer from the same implementation issues as the Regula
+ * Falsi method, which may fail to convergence in certain cases. Also,
+ * the Pegasus method should converge faster than the
+ * {@link IllinoisSolver Illinois} method, another Regula
+ * Falsi-based method. The Pegasus method assumes that the function is continuous,
+ * but not necessarily smooth. Implementation based on the following article: M. Dowell and P. Jarratt,
+ * The "Pegasus" method for computing the root of an equation,
+ * BIT Numerical Mathematics, volume 12, number 4, pages 503-508, Springer,
+ * 1972. The Regula Falsi method is included for completeness, for
+ * testing purposes, for educational purposes, for comparison to other
+ * algorithms, etc. It is however not intended to be used
+ * for actual problems, as one of the bounds often remains fixed, resulting
+ * in very slow convergence. Instead, one of the well-known modified
+ * Regula Falsi algorithms can be used ({@link IllinoisSolver
+ * Illinois} or {@link PegasusSolver Pegasus}). These two
+ * algorithms solve the fundamental issues of the original Regula
+ * Falsi algorithm, and greatly out-performs it for most, if not all,
+ * (practical) functions.
+ *
+ * Unlike the Secant method, the Regula Falsi guarantees
+ * convergence, by maintaining a bracketed solution. Note however, that due to
+ * the finite/limited precision of Java's {@link Double double} type, which is
+ * used in this implementation, the algorithm may get stuck in a situation
+ * where it no longer makes any progress. Such cases are detected and result
+ * in a {@code ConvergenceException} exception being thrown. In other words,
+ * the algorithm theoretically guarantees convergence, but the implementation
+ * does not. The Regula Falsi method assumes that the function is continuous,
+ * but not necessarily smooth. Implementation based on the following article: M. Dowell and P. Jarratt,
+ * A modified regula falsi method for computing the root of an
+ * equation, BIT Numerical Mathematics, volume 11, number 2,
+ * pages 168-174, Springer, 1971.
+ * The function should be continuous but not necessarily smooth. Implementation based on the following article: M. Dowell and P. Jarratt,
+ * A modified regula falsi method for computing the root of an
+ * equation, BIT Numerical Mathematics, volume 11, number 2,
+ * pages 168-174, Springer, 1971. Note that since release 3.0 this class implements the actual
+ * Secant algorithm, and not a modified one. As such, the 3.0 version
+ * is not backwards compatible with previous versions. To use an algorithm
+ * similar to the pre-3.0 releases, use the
+ * {@link IllinoisSolver Illinois} algorithm or the
+ * {@link PegasusSolver Pegasus} algorithm.
+ * Note: this method can take {@code Integer.MAX_VALUE}
+ * iterations to throw a {@code ConvergenceException.} Unless you are
+ * confident that there is a root between {@code lowerBound} and
+ * {@code upperBound} near {@code initial}, it is better to use
+ * {@link #bracket(UnivariateFunction, double, double, double, double,double, int)
+ * bracket(function, initial, lowerBound, upperBound, q, r, maximumIterations)},
+ * explicitly specifying the maximum number of iterations.
+ * The algorithm checks the sign of \( f(l_k) \) and \( f(u_k) \) for increasing
+ * values of k, where \( l_k = max(lower, initial - \delta_k) \),
+ * \( u_k = min(upper, initial + \delta_k) \), using recurrence
+ * \( \delta_{k+1} = r \delta_k + q, \delta_0 = 0\) and starting search with \( k=1 \).
+ * The algorithm stops when one of the following happens:
+ * If different signs are found at first iteration ({@code k=1}), then the returned
+ * interval will be \( [a, b] = [l_1, u_1] \). If different signs are found at a later
+ * iteration {@code k>1}, then the returned interval will be either
+ * \( [a, b] = [l_{k+1}, l_{k}] \) or \( [a, b] = [u_{k}, u_{k+1}] \). A root solver called
+ * with these parameters will therefore start with the smallest bracketing interval known
+ * at this step.
+ *
+ * Interval expansion rate is tuned by changing the recurrence parameters {@code r} and
+ * {@code q}. When the multiplicative factor {@code r} is set to 1, the sequence is a
+ * simple arithmetic sequence with linear increase. When the multiplicative factor {@code r}
+ * is larger than 1, the sequence has an asymptotically exponential rate. Note than the
+ * additive parameter {@code q} should never be set to zero, otherwise the interval would
+ * degenerate to the single initial point for all values of {@code k}.
+ *
+ * As a rule of thumb, when the location of the root is expected to be approximately known
+ * within some error margin, {@code r} should be set to 1 and {@code q} should be set to the
+ * order of magnitude of the error margin. When the location of the root is really a wild guess,
+ * then {@code r} should be set to a value larger than 1 (typically 2 to double the interval
+ * length at each iteration) and {@code q} should be set according to half the initial
+ * search interval length.
+ *
+ * As an example, if we consider the trivial function {@code f(x) = 1 - x} and use
+ * {@code initial = 4}, {@code r = 1}, {@code q = 2}, the algorithm will compute
+ * {@code f(4-2) = f(2) = -1} and {@code f(4+2) = f(6) = -5} for {@code k = 1}, then
+ * {@code f(4-4) = f(0) = +1} and {@code f(4+4) = f(8) = -7} for {@code k = 2}. Then it will
+ * return the interval {@code [0, 2]} as the smallest one known to be bracketing the root.
+ * As shown by this example, the initial value (here {@code 4}) may lie outside of the returned
+ * bracketing interval.
+ *
+ * Implementations of arithmetic operations handle {@code NaN} and
+ * infinite values according to the rules for {@link java.lang.Double}, i.e.
+ * {@link #equals} is an equivalence relation for all instances that have
+ * a {@code NaN} in either real or imaginary part, e.g. the following are
+ * considered equal:
+ *
+ * Note that this contradicts the IEEE-754 standard for floating
+ * point numbers (according to which the test {@code x == x} must fail if
+ * {@code x} is {@code NaN}). The method
+ * {@link Precision#equals(double,double,int)
+ * equals for primitive double} in {@link Precision}
+ * conforms with IEEE-754 while this class conforms with the standard behavior
+ * for Java object types.
+ * {@code (a + bi) + (c + di) = (a+c) + (b+d)i}
+ *
+ * {@link #NaN} is returned if either the real or imaginary
+ * part of this Complex number equals {@code Double.NaN}.
+ *
+ * If the imaginary part is infinite, and the real part is not
+ * {@code NaN}, the returned value has infinite imaginary part
+ * of the opposite sign, e.g. the conjugate of
+ * {@code 1 + POSITIVE_INFINITY i} is {@code 1 - NEGATIVE_INFINITY i}.
+ *
+ * {@code Infinite} and {@code NaN} values are handled according to the
+ * following rules, applied in the order presented:
+ *
+ * {@code (a + bi)(c + di) = (ac - bd) + (ad + bc)i}
+ *
+ * Returns {@link #INF} if neither {@code this} nor {@code factor} has one
+ * or more {@code NaN} parts and if either {@code this} or {@code factor}
+ * has one or more infinite parts (same result is returned regardless of
+ * the sign of the components).
+ *
+ * Returns finite values in components of the result per the definitional
+ * formula in all remaining cases.
+ * {@code (a + bi) - (c + di) = (a-c) + (b-d)i}
+ *
+ * {@code acos(z) = -i (log(z + i (sqrt(1 - z2))))}
+ *
+ * {@code asin(z) = -i (log(sqrt(1 - z2) + iz))}
+ *
+ * Returns {@link Complex#NaN} if either real or imaginary part of the
+ * input argument is {@code NaN} or infinite.
+ * {@code atan(z) = (i/2) log((i + z)/(i - z))}
+ *
+ * Returns {@link Complex#NaN} if either real or imaginary part of the
+ * input argument is {@code NaN} or infinite.
+ * {@code cos(a + bi) = cos(a)cosh(b) - sin(a)sinh(b)i}
+ *
+ * where the (real) functions on the right-hand side are
+ * {@link FastMath#sin}, {@link FastMath#cos},
+ * {@link FastMath#cosh} and {@link FastMath#sinh}.
+ *
+ * Returns {@link Complex#NaN} if either real or imaginary part of the
+ * input argument is {@code NaN}.
+ *
+ * Infinite values in real or imaginary parts of the input may result in
+ * infinite or NaN values returned in parts of the result.
+ * Returns {@link Complex#NaN} if either real or imaginary part of the
+ * input argument is {@code NaN}.
+ *
+ * Returns {@link Complex#NaN} if either real or imaginary part of the
+ * input argument is {@code NaN}.
+ *
+ * Returns {@link Complex#NaN} if either real or imaginary part of the
+ * input argument is {@code NaN}.
+ *
+ * Returns {@link Complex#NaN} if either real or imaginary part of the
+ * input argument is {@code NaN} or infinite, or if {@code y}
+ * equals {@link Complex#ZERO}.
+ * Returns {@link Complex#NaN} if either real or imaginary part of the
+ * input argument is {@code NaN}.
+ *
+ * Infinite values in real or imaginary parts of the input may result in
+ * infinite or {@code NaN} values returned in parts of the result.
+ *
+ * Returns {@link Complex#NaN} if either real or imaginary part of the
+ * input argument is {@code NaN}.
+ *
+ * Infinite values in real or imaginary parts of the input may result in
+ * infinite or NaN values returned in parts of the result.
+ *
+ * Returns {@link Complex#NaN} if either real or imaginary part of the
+ * input argument is {@code NaN}.
+ *
+ * Returns {@link Complex#NaN} if either real or imaginary part of the
+ * input argument is {@code NaN}.
+ *
+ * Returns {@link Complex#NaN} if either real or imaginary part of the
+ * input argument is {@code NaN}.
+ *
+ * Returns {@link Complex#NaN} if either real or imaginary part of the
+ * input argument is {@code NaN}.
+ *
+ * If either real or imaginary part (or both) is NaN, NaN is returned.
+ * Infinite parts are handled as {@code Math.atan2} handles them,
+ * essentially treating finite parts as zero in the presence of an
+ * infinite coordinate and returning a multiple of pi/4 depending on
+ * the signs of the infinite parts.
+ * See the javadoc for {@code Math.atan2} for full details.
+ *
+ * @return the argument of {@code this}.
+ */
+ public double getArgument() {
+ return FastMath.atan2(getImaginary(), getReal());
+ }
+
+ /**
+ * Computes the n-th roots of this complex number.
+ * The nth roots are defined by the formula:
+ *
+ * If one or both parts of this complex number is NaN, a list with just
+ * one element, {@link #NaN} is returned.
+ * if neither part is NaN, but at least one part is infinite, the result
+ * is a one-element list containing {@link #INF}.
+ *
+ * @param n Degree of root.
+ * @return a List of all {@code n}-th roots of {@code this}.
+ * @throws NotPositiveException if {@code n <= 0}.
+ * @since 2.0
+ */
+ public List
+ * This class is a singleton.
+ * We use here the Initialization On Demand Holder Idiom. This is the same set as the {@link NumberFormat} set.
+ * The value returned is
+ * If either
+ * If
+ * Computes the {@code n}-th roots of unity. The roots are stored in
+ * {@code omega[]}, such that {@code omega[k] = w ^ k}, where
+ * {@code k = 0, ..., n - 1}, {@code w = exp(2 * pi * i / n)} and
+ * {@code i = sqrt(-1)}.
+ *
+ * Note that {@code n} can be positive of negative
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ * Algorithms for Minimization Without Derivatives,
+ * Richard P. Brent,
+ * Dover, 2002
+ *
+ *
+ * @see BaseAbstractUnivariateSolver
+ */
+public class BrentSolver extends AbstractUnivariateSolver {
+
+ /** Default absolute accuracy. */
+ private static final double DEFAULT_ABSOLUTE_ACCURACY = 1e-6;
+
+ /**
+ * Construct a solver with default absolute accuracy (1e-6).
+ */
+ public BrentSolver() {
+ this(DEFAULT_ABSOLUTE_ACCURACY);
+ }
+ /**
+ * Construct a solver.
+ *
+ * @param absoluteAccuracy Absolute accuracy.
+ */
+ public BrentSolver(double absoluteAccuracy) {
+ super(absoluteAccuracy);
+ }
+ /**
+ * Construct a solver.
+ *
+ * @param relativeAccuracy Relative accuracy.
+ * @param absoluteAccuracy Absolute accuracy.
+ */
+ public BrentSolver(double relativeAccuracy,
+ double absoluteAccuracy) {
+ super(relativeAccuracy, absoluteAccuracy);
+ }
+ /**
+ * Construct a solver.
+ *
+ * @param relativeAccuracy Relative accuracy.
+ * @param absoluteAccuracy Absolute accuracy.
+ * @param functionValueAccuracy Function value accuracy.
+ *
+ * @see BaseAbstractUnivariateSolver#BaseAbstractUnivariateSolver(double,double,double)
+ */
+ public BrentSolver(double relativeAccuracy,
+ double absoluteAccuracy,
+ double functionValueAccuracy) {
+ super(relativeAccuracy, absoluteAccuracy, functionValueAccuracy);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ protected double doSolve()
+ throws NoBracketingException,
+ TooManyEvaluationsException,
+ NumberIsTooLargeException {
+ double min = getMin();
+ double max = getMax();
+ final double initial = getStartValue();
+ final double functionValueAccuracy = getFunctionValueAccuracy();
+
+ verifySequence(min, initial, max);
+
+ // Return the initial guess if it is good enough.
+ double yInitial = computeObjectiveValue(initial);
+ if (FastMath.abs(yInitial) <= functionValueAccuracy) {
+ return initial;
+ }
+
+ // Return the first endpoint if it is good enough.
+ double yMin = computeObjectiveValue(min);
+ if (FastMath.abs(yMin) <= functionValueAccuracy) {
+ return min;
+ }
+
+ // Reduce interval if min and initial bracket the root.
+ if (yInitial * yMin < 0) {
+ return brent(min, initial, yMin, yInitial);
+ }
+
+ // Return the second endpoint if it is good enough.
+ double yMax = computeObjectiveValue(max);
+ if (FastMath.abs(yMax) <= functionValueAccuracy) {
+ return max;
+ }
+
+ // Reduce interval if initial and max bracket the root.
+ if (yInitial * yMax < 0) {
+ return brent(initial, max, yInitial, yMax);
+ }
+
+ throw new NoBracketingException(min, max, yMin, yMax);
+ }
+
+ /**
+ * Search for a zero inside the provided interval.
+ * This implementation is based on the algorithm described at page 58 of
+ * the book
+ *
+ * Algorithms for Minimization Without Derivatives,
+ *
+ *
+ * @param lo Lower bound of the search interval.
+ * @param hi Higher bound of the search interval.
+ * @param fLo Function value at the lower bound of the search interval.
+ * @param fHi Function value at the higher bound of the search interval.
+ * @return the value where the function is zero.
+ */
+ private double brent(double lo, double hi,
+ double fLo, double fHi) {
+ double a = lo;
+ double fa = fLo;
+ double b = hi;
+ double fb = fHi;
+ double c = a;
+ double fc = fa;
+ double d = b - a;
+ double e = d;
+
+ final double t = getAbsoluteAccuracy();
+ final double eps = getRelativeAccuracy();
+
+ while (true) {
+ if (FastMath.abs(fc) < FastMath.abs(fb)) {
+ a = b;
+ b = c;
+ c = a;
+ fa = fb;
+ fb = fc;
+ fc = fa;
+ }
+
+ final double tol = 2 * eps * FastMath.abs(b) + t;
+ final double m = 0.5 * (c - b);
+
+ if (FastMath.abs(m) <= tol ||
+ Precision.equals(fb, 0)) {
+ return b;
+ }
+ if (FastMath.abs(e) < tol ||
+ FastMath.abs(fa) <= FastMath.abs(fb)) {
+ // Force bisection.
+ d = m;
+ e = d;
+ } else {
+ double s = fb / fa;
+ double p;
+ double q;
+ // The equality test (a == c) is intentional,
+ // it is part of the original Brent's method and
+ // it should NOT be replaced by proximity test.
+ if (a == c) {
+ // Linear interpolation.
+ p = 2 * m * s;
+ q = 1 - s;
+ } else {
+ // Inverse quadratic interpolation.
+ q = fa / fc;
+ final double r = fb / fc;
+ p = s * (2 * m * q * (q - r) - (b - a) * (r - 1));
+ q = (q - 1) * (r - 1) * (s - 1);
+ }
+ if (p > 0) {
+ q = -q;
+ } else {
+ p = -p;
+ }
+ s = e;
+ e = d;
+ if (p >= 1.5 * m * q - FastMath.abs(tol * q) ||
+ p >= FastMath.abs(0.5 * s * q)) {
+ // Inverse quadratic interpolation gives a value
+ // in the wrong direction, or progress is slow.
+ // Fall back to bisection.
+ d = m;
+ e = d;
+ } else {
+ d = p / q;
+ }
+ }
+ a = b;
+ fa = fb;
+
+ if (FastMath.abs(d) > tol) {
+ b += d;
+ } else if (m > 0) {
+ b += tol;
+ } else {
+ b -= tol;
+ }
+ fb = computeObjectiveValue(b);
+ if ((fb > 0 && fc > 0) ||
+ (fb <= 0 && fc <= 0)) {
+ c = a;
+ fc = fa;
+ d = b - a;
+ e = d;
+ }
+ }
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/solvers/DifferentiableUnivariateSolver.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/solvers/DifferentiableUnivariateSolver.java
new file mode 100644
index 000000000..bd93a1d2b
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/analysis/solvers/DifferentiableUnivariateSolver.java
@@ -0,0 +1,30 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.analysis.solvers;
+
+import com.fr.third.org.apache.commons.math3.analysis.DifferentiableUnivariateFunction;
+
+
+/**
+ * Interface for (univariate real) rootfinding algorithms.
+ * Implementations will search for only one zero in the given interval.
+ *
+ * @deprecated as of 3.1, replaced by {@link UnivariateDifferentiableSolver}
+ */
+@Deprecated
+public interface DifferentiableUnivariateSolver
+ extends BaseUnivariateSolver
+ *
+ * A First Course in Numerical Analysis,
+ * ISBN 048641454X, chapter 8.
+ *
+ * Laguerre's method is global in the sense that it can start with any initial
+ * approximation and be able to solve all roots from that point.
+ * The algorithm requires a bracketing condition.
+ *
+ * @since 1.2
+ */
+public class LaguerreSolver extends AbstractPolynomialSolver {
+ /** Default absolute accuracy. */
+ private static final double DEFAULT_ABSOLUTE_ACCURACY = 1e-6;
+ /** Complex solver. */
+ private final ComplexSolver complexSolver = new ComplexSolver();
+
+ /**
+ * Construct a solver with default accuracy (1e-6).
+ */
+ public LaguerreSolver() {
+ this(DEFAULT_ABSOLUTE_ACCURACY);
+ }
+ /**
+ * Construct a solver.
+ *
+ * @param absoluteAccuracy Absolute accuracy.
+ */
+ public LaguerreSolver(double absoluteAccuracy) {
+ super(absoluteAccuracy);
+ }
+ /**
+ * Construct a solver.
+ *
+ * @param relativeAccuracy Relative accuracy.
+ * @param absoluteAccuracy Absolute accuracy.
+ */
+ public LaguerreSolver(double relativeAccuracy,
+ double absoluteAccuracy) {
+ super(relativeAccuracy, absoluteAccuracy);
+ }
+ /**
+ * Construct a solver.
+ *
+ * @param relativeAccuracy Relative accuracy.
+ * @param absoluteAccuracy Absolute accuracy.
+ * @param functionValueAccuracy Function value accuracy.
+ */
+ public LaguerreSolver(double relativeAccuracy,
+ double absoluteAccuracy,
+ double functionValueAccuracy) {
+ super(relativeAccuracy, absoluteAccuracy, functionValueAccuracy);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public double doSolve()
+ throws TooManyEvaluationsException,
+ NumberIsTooLargeException,
+ NoBracketingException {
+ final double min = getMin();
+ final double max = getMax();
+ final double initial = getStartValue();
+ final double functionValueAccuracy = getFunctionValueAccuracy();
+
+ verifySequence(min, initial, max);
+
+ // Return the initial guess if it is good enough.
+ final double yInitial = computeObjectiveValue(initial);
+ if (FastMath.abs(yInitial) <= functionValueAccuracy) {
+ return initial;
+ }
+
+ // Return the first endpoint if it is good enough.
+ final double yMin = computeObjectiveValue(min);
+ if (FastMath.abs(yMin) <= functionValueAccuracy) {
+ return min;
+ }
+
+ // Reduce interval if min and initial bracket the root.
+ if (yInitial * yMin < 0) {
+ return laguerre(min, initial, yMin, yInitial);
+ }
+
+ // Return the second endpoint if it is good enough.
+ final double yMax = computeObjectiveValue(max);
+ if (FastMath.abs(yMax) <= functionValueAccuracy) {
+ return max;
+ }
+
+ // Reduce interval if initial and max bracket the root.
+ if (yInitial * yMax < 0) {
+ return laguerre(initial, max, yInitial, yMax);
+ }
+
+ throw new NoBracketingException(min, max, yMin, yMax);
+ }
+
+ /**
+ * Find a real root in the given interval.
+ *
+ * Despite the bracketing condition, the root returned by
+ * {@link LaguerreSolver.ComplexSolver#solve(Complex[],Complex)} may
+ * not be a real zero inside {@code [min, max]}.
+ * For example, p(x) = x3 + 1,
+ * with {@code min = -2}, {@code max = 2}, {@code initial = 0}.
+ * When it occurs, this code calls
+ * {@link LaguerreSolver.ComplexSolver#solveAll(Complex[],Complex)}
+ * in order to obtain all roots and picks up one real root.
+ *
+ * @param lo Lower bound of the search interval.
+ * @param hi Higher bound of the search interval.
+ * @param fLo Function value at the lower bound of the search interval.
+ * @param fHi Function value at the higher bound of the search interval.
+ * @return the point at which the function value is zero.
+ * @deprecated This method should not be part of the public API: It will
+ * be made private in version 4.0.
+ */
+ @Deprecated
+ public double laguerre(double lo, double hi,
+ double fLo, double fHi) {
+ final Complex c[] = ComplexUtils.convertToComplex(getCoefficients());
+
+ final Complex initial = new Complex(0.5 * (lo + hi), 0);
+ final Complex z = complexSolver.solve(c, initial);
+ if (complexSolver.isRoot(lo, hi, z)) {
+ return z.getReal();
+ } else {
+ double r = Double.NaN;
+ // Solve all roots and select the one we are seeking.
+ Complex[] root = complexSolver.solveAll(c, initial);
+ for (int i = 0; i < root.length; i++) {
+ if (complexSolver.isRoot(lo, hi, root[i])) {
+ r = root[i].getReal();
+ break;
+ }
+ }
+ return r;
+ }
+ }
+
+ /**
+ * Find all complex roots for the polynomial with the given
+ * coefficients, starting from the given initial value.
+ *
+ *
+ * If {@code f} is continuous on {@code [a,b]}, this means that {@code a}
+ * and {@code b} bracket a root of {@code f}.
+ *
+ *
+ *
+ *
+ *
+ * but uses
+ *
+ * prescaling of operands to limit the effects of overflows and
+ * underflows in the computation.
+ *
+ * a + bi ac + bd + (bc - ad)i
+ * ----------- = -------------------------
+ * c + di c2 + d2
+ *
+ *
+ *
+ *
+ * @param divisor Value by which this {@code Complex} is to be divided.
+ * @return {@code this / divisor}.
+ * @throws NullArgumentException if {@code divisor} is {@code null}.
+ */
+ public Complex divide(Complex divisor)
+ throws NullArgumentException {
+ MathUtils.checkNotNull(divisor);
+ if (isNaN || divisor.isNaN) {
+ return NaN;
+ }
+
+ final double c = divisor.getReal();
+ final double d = divisor.getImaginary();
+ if (c == 0.0 && d == 0.0) {
+ return NaN;
+ }
+
+ if (divisor.isInfinite() && !isInfinite()) {
+ return ZERO;
+ }
+
+ if (FastMath.abs(c) < FastMath.abs(d)) {
+ double q = c / d;
+ double denominator = c * q + d;
+ return createComplex((real * q + imaginary) / denominator,
+ (imaginary * q - real) / denominator);
+ } else {
+ double q = d / c;
+ double denominator = d * q + c;
+ return createComplex((imaginary * q + real) / denominator,
+ (imaginary - real * q) / denominator);
+ }
+ }
+
+ /**
+ * Returns a {@code Complex} whose value is {@code (this / divisor)},
+ * with {@code divisor} interpreted as a real number.
+ *
+ * @param divisor Value by which this {@code Complex} is to be divided.
+ * @return {@code this / divisor}.
+ * @see #divide(Complex)
+ */
+ public Complex divide(double divisor) {
+ if (isNaN || Double.isNaN(divisor)) {
+ return NaN;
+ }
+ if (divisor == 0d) {
+ return NaN;
+ }
+ if (Double.isInfinite(divisor)) {
+ return !isInfinite() ? ZERO : NaN;
+ }
+ return createComplex(real / divisor,
+ imaginary / divisor);
+ }
+
+ /** {@inheritDoc} */
+ public Complex reciprocal() {
+ if (isNaN) {
+ return NaN;
+ }
+
+ if (real == 0.0 && imaginary == 0.0) {
+ return INF;
+ }
+
+ if (isInfinite) {
+ return ZERO;
+ }
+
+ if (FastMath.abs(real) < FastMath.abs(imaginary)) {
+ double q = real / imaginary;
+ double scale = 1. / (real * q + imaginary);
+ return createComplex(scale * q, -scale);
+ } else {
+ double q = imaginary / real;
+ double scale = 1. / (imaginary * q + real);
+ return createComplex(scale, -scale * q);
+ }
+ }
+
+ /**
+ * Test for equality with another object.
+ * If both the real and imaginary parts of two complex numbers
+ * are exactly the same, and neither is {@code Double.NaN}, the two
+ * Complex objects are considered to be equal.
+ * The behavior is the same as for JDK's {@link Double#equals(Object)
+ * Double}:
+ *
+ *
+ *
+ * @param other Object to test for equality with this instance.
+ * @return {@code true} if the objects are equal, {@code false} if object
+ * is {@code null}, not an instance of {@code Complex}, or not equal to
+ * this instance.
+ */
+ @Override
+ public boolean equals(Object other) {
+ if (this == other) {
+ return true;
+ }
+ if (other instanceof Complex){
+ Complex c = (Complex) other;
+ if (c.isNaN) {
+ return isNaN;
+ } else {
+ return MathUtils.equals(real, c.real) &&
+ MathUtils.equals(imaginary, c.imaginary);
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Test for the floating-point equality between Complex objects.
+ * It returns {@code true} if both arguments are equal or within the
+ * range of allowed error (inclusive).
+ *
+ * @param x First value (cannot be {@code null}).
+ * @param y Second value (cannot be {@code null}).
+ * @param maxUlps {@code (maxUlps - 1)} is the number of floating point
+ * values between the real (resp. imaginary) parts of {@code x} and
+ * {@code y}.
+ * @return {@code true} if there are fewer than {@code maxUlps} floating
+ * point values between the real (resp. imaginary) parts of {@code x}
+ * and {@code y}.
+ *
+ * @see Precision#equals(double,double,int)
+ * @since 3.3
+ */
+ public static boolean equals(Complex x, Complex y, int maxUlps) {
+ return Precision.equals(x.real, y.real, maxUlps) &&
+ Precision.equals(x.imaginary, y.imaginary, maxUlps);
+ }
+
+ /**
+ * Returns {@code true} iff the values are equal as defined by
+ * {@link #equals(Complex,Complex,int) equals(x, y, 1)}.
+ *
+ * @param x First value (cannot be {@code null}).
+ * @param y Second value (cannot be {@code null}).
+ * @return {@code true} if the values are equal.
+ *
+ * @since 3.3
+ */
+ public static boolean equals(Complex x, Complex y) {
+ return equals(x, y, 1);
+ }
+
+ /**
+ * Returns {@code true} if, both for the real part and for the imaginary
+ * part, there is no double value strictly between the arguments or the
+ * difference between them is within the range of allowed error
+ * (inclusive). Returns {@code false} if either of the arguments is NaN.
+ *
+ * @param x First value (cannot be {@code null}).
+ * @param y Second value (cannot be {@code null}).
+ * @param eps Amount of allowed absolute error.
+ * @return {@code true} if the values are two adjacent floating point
+ * numbers or they are within range of each other.
+ *
+ * @see Precision#equals(double,double,double)
+ * @since 3.3
+ */
+ public static boolean equals(Complex x, Complex y, double eps) {
+ return Precision.equals(x.real, y.real, eps) &&
+ Precision.equals(x.imaginary, y.imaginary, eps);
+ }
+
+ /**
+ * Returns {@code true} if, both for the real part and for the imaginary
+ * part, there is no double value strictly between the arguments or the
+ * relative difference between them is smaller or equal to the given
+ * tolerance. Returns {@code false} if either of the arguments is NaN.
+ *
+ * @param x First value (cannot be {@code null}).
+ * @param y Second value (cannot be {@code null}).
+ * @param eps Amount of allowed relative error.
+ * @return {@code true} if the values are two adjacent floating point
+ * numbers or they are within range of each other.
+ *
+ * @see Precision#equalsWithRelativeTolerance(double,double,double)
+ * @since 3.3
+ */
+ public static boolean equalsWithRelativeTolerance(Complex x, Complex y,
+ double eps) {
+ return Precision.equalsWithRelativeTolerance(x.real, y.real, eps) &&
+ Precision.equalsWithRelativeTolerance(x.imaginary, y.imaginary, eps);
+ }
+
+ /**
+ * Get a hashCode for the complex number.
+ * Any {@code Double.NaN} value in real or imaginary part produces
+ * the same hash code {@code 7}.
+ *
+ * @return a hash code value for this object.
+ */
+ @Override
+ public int hashCode() {
+ if (isNaN) {
+ return 7;
+ }
+ return 37 * (17 * MathUtils.hash(imaginary) +
+ MathUtils.hash(real));
+ }
+
+ /**
+ * Access the imaginary part.
+ *
+ * @return the imaginary part.
+ */
+ public double getImaginary() {
+ return imaginary;
+ }
+
+ /**
+ * Access the real part.
+ *
+ * @return the real part.
+ */
+ public double getReal() {
+ return real;
+ }
+
+ /**
+ * Checks whether either or both parts of this complex number is
+ * {@code NaN}.
+ *
+ * @return true if either or both parts of this complex number is
+ * {@code NaN}; false otherwise.
+ */
+ public boolean isNaN() {
+ return isNaN;
+ }
+
+ /**
+ * Checks whether either the real or imaginary part of this complex number
+ * takes an infinite value (either {@code Double.POSITIVE_INFINITY} or
+ * {@code Double.NEGATIVE_INFINITY}) and neither part
+ * is {@code NaN}.
+ *
+ * @return true if one or both parts of this complex number are infinite
+ * and neither part is {@code NaN}.
+ */
+ public boolean isInfinite() {
+ return isInfinite;
+ }
+
+ /**
+ * Returns a {@code Complex} whose value is {@code this * factor}.
+ * Implements preliminary checks for {@code NaN} and infinity followed by
+ * the definitional formula:
+ *
+ * Examples:
+ *
+ *
+ * @return the cosine of this complex number.
+ * @since 1.2
+ */
+ public Complex cos() {
+ if (isNaN) {
+ return NaN;
+ }
+
+ return createComplex(FastMath.cos(real) * FastMath.cosh(imaginary),
+ -FastMath.sin(real) * FastMath.sinh(imaginary));
+ }
+
+ /**
+ * Compute the
+ *
+ * hyperbolic cosine of this complex number.
+ * Implements the formula:
+ *
+ * cos(1 ± INFINITY i) = 1 \u2213 INFINITY i
+ * cos(±INFINITY + i) = NaN + NaN i
+ * cos(±INFINITY ± INFINITY i) = NaN + NaN i
+ *
+ *
+ *
+ * where the (real) functions on the right-hand side are
+ * {@link FastMath#sin}, {@link FastMath#cos},
+ * {@link FastMath#cosh} and {@link FastMath#sinh}.
+ *
+ * cosh(a + bi) = cosh(a)cos(b) + sinh(a)sin(b)i
+ *
+ *
+ * Examples:
+ *
+ *
+ * @return the hyperbolic cosine of this complex number.
+ * @since 1.2
+ */
+ public Complex cosh() {
+ if (isNaN) {
+ return NaN;
+ }
+
+ return createComplex(FastMath.cosh(real) * FastMath.cos(imaginary),
+ FastMath.sinh(real) * FastMath.sin(imaginary));
+ }
+
+ /**
+ * Compute the
+ *
+ * exponential function of this complex number.
+ * Implements the formula:
+ *
+ * cosh(1 ± INFINITY i) = NaN + NaN i
+ * cosh(±INFINITY + i) = INFINITY ± INFINITY i
+ * cosh(±INFINITY ± INFINITY i) = NaN + NaN i
+ *
+ *
+ *
+ * where the (real) functions on the right-hand side are
+ * {@link FastMath#exp}, {@link FastMath#cos}, and
+ * {@link FastMath#sin}.
+ *
+ * exp(a + bi) = exp(a)cos(b) + exp(a)sin(b)i
+ *
+ *
+ * Examples:
+ *
+ *
+ * @return
+ * exp(1 ± INFINITY i) = NaN + NaN i
+ * exp(INFINITY + i) = INFINITY + INFINITY i
+ * exp(-INFINITY + i) = 0 + 0i
+ * exp(±INFINITY ± INFINITY i) = NaN + NaN i
+ *
+ * ethis.
+ * @since 1.2
+ */
+ public Complex exp() {
+ if (isNaN) {
+ return NaN;
+ }
+
+ double expReal = FastMath.exp(real);
+ return createComplex(expReal * FastMath.cos(imaginary),
+ expReal * FastMath.sin(imaginary));
+ }
+
+ /**
+ * Compute the
+ *
+ * natural logarithm of this complex number.
+ * Implements the formula:
+ *
+ *
+ * where ln on the right hand side is {@link FastMath#log},
+ * {@code |a + bi|} is the modulus, {@link Complex#abs}, and
+ * {@code arg(a + bi) = }{@link FastMath#atan2}(b, a).
+ *
+ * log(a + bi) = ln(|a + bi|) + arg(a + bi)i
+ *
+ *
+ * Examples:
+ *
+ *
+ * @return the value
+ * log(1 ± INFINITY i) = INFINITY ± (π/2)i
+ * log(INFINITY + i) = INFINITY + 0i
+ * log(-INFINITY + i) = INFINITY + πi
+ * log(INFINITY ± INFINITY i) = INFINITY ± (π/4)i
+ * log(-INFINITY ± INFINITY i) = INFINITY ± (3π/4)i
+ * log(0 + 0i) = -INFINITY + 0i
+ *
+ * ln this, the natural logarithm
+ * of {@code this}.
+ * @since 1.2
+ */
+ public Complex log() {
+ if (isNaN) {
+ return NaN;
+ }
+
+ return createComplex(FastMath.log(abs()),
+ FastMath.atan2(imaginary, real));
+ }
+
+ /**
+ * Returns of value of this complex number raised to the power of {@code x}.
+ * Implements the formula:
+ *
+ *
+ * where {@code exp} and {@code log} are {@link #exp} and
+ * {@link #log}, respectively.
+ *
+ * yx = exp(x·log(y))
+ *
+ * thisx.
+ * @throws NullArgumentException if x is {@code null}.
+ * @since 1.2
+ */
+ public Complex pow(Complex x)
+ throws NullArgumentException {
+ MathUtils.checkNotNull(x);
+ return this.log().multiply(x).exp();
+ }
+
+ /**
+ * Returns of value of this complex number raised to the power of {@code x}.
+ *
+ * @param x exponent to which this {@code Complex} is to be raised.
+ * @return thisx.
+ * @see #pow(Complex)
+ */
+ public Complex pow(double x) {
+ return this.log().multiply(x).exp();
+ }
+
+ /**
+ * Compute the
+ *
+ * sine
+ * of this complex number.
+ * Implements the formula:
+ *
+ *
+ * where the (real) functions on the right-hand side are
+ * {@link FastMath#sin}, {@link FastMath#cos},
+ * {@link FastMath#cosh} and {@link FastMath#sinh}.
+ *
+ * sin(a + bi) = sin(a)cosh(b) - cos(a)sinh(b)i
+ *
+ *
+ * Examples:
+ *
+ *
+ * @return the sine of this complex number.
+ * @since 1.2
+ */
+ public Complex sin() {
+ if (isNaN) {
+ return NaN;
+ }
+
+ return createComplex(FastMath.sin(real) * FastMath.cosh(imaginary),
+ FastMath.cos(real) * FastMath.sinh(imaginary));
+ }
+
+ /**
+ * Compute the
+ *
+ * hyperbolic sine of this complex number.
+ * Implements the formula:
+ *
+ * sin(1 ± INFINITY i) = 1 ± INFINITY i
+ * sin(±INFINITY + i) = NaN + NaN i
+ * sin(±INFINITY ± INFINITY i) = NaN + NaN i
+ *
+ *
+ *
+ * where the (real) functions on the right-hand side are
+ * {@link FastMath#sin}, {@link FastMath#cos},
+ * {@link FastMath#cosh} and {@link FastMath#sinh}.
+ *
+ * sinh(a + bi) = sinh(a)cos(b)) + cosh(a)sin(b)i
+ *
+ *
+ * Examples:
+ *
+ *
+ * @return the hyperbolic sine of {@code this}.
+ * @since 1.2
+ */
+ public Complex sinh() {
+ if (isNaN) {
+ return NaN;
+ }
+
+ return createComplex(FastMath.sinh(real) * FastMath.cos(imaginary),
+ FastMath.cosh(real) * FastMath.sin(imaginary));
+ }
+
+ /**
+ * Compute the
+ *
+ * square root of this complex number.
+ * Implements the following algorithm to compute {@code sqrt(a + bi)}:
+ *
+ * sinh(1 ± INFINITY i) = NaN + NaN i
+ * sinh(±INFINITY + i) = ± INFINITY + INFINITY i
+ * sinh(±INFINITY ± INFINITY i) = NaN + NaN i
+ *
+ *
+ * where if {@code a ≥ 0} return {@code t + (b/2t)i}
+ * else return {@code |b|/2t + sign(b)t i }
+ *
+ *
+ * Examples:
+ *
+ *
+ * @return the square root of {@code this}.
+ * @since 1.2
+ */
+ public Complex sqrt() {
+ if (isNaN) {
+ return NaN;
+ }
+
+ if (real == 0.0 && imaginary == 0.0) {
+ return createComplex(0.0, 0.0);
+ }
+
+ double t = FastMath.sqrt((FastMath.abs(real) + abs()) / 2.0);
+ if (real >= 0.0) {
+ return createComplex(t, imaginary / (2.0 * t));
+ } else {
+ return createComplex(FastMath.abs(imaginary) / (2.0 * t),
+ FastMath.copySign(1d, imaginary) * t);
+ }
+ }
+
+ /**
+ * Compute the
+ *
+ * square root of
+ * sqrt(1 ± INFINITY i) = INFINITY + NaN i
+ * sqrt(INFINITY + i) = INFINITY + 0i
+ * sqrt(-INFINITY + i) = 0 + INFINITY i
+ * sqrt(INFINITY ± INFINITY i) = INFINITY + NaN i
+ * sqrt(-INFINITY ± INFINITY i) = NaN ± INFINITY i
+ *
+ * 1 - this2 for this complex
+ * number.
+ * Computes the result directly as
+ * {@code sqrt(ONE.subtract(z.multiply(z)))}.
+ * 1 - this2.
+ * @since 1.2
+ */
+ public Complex sqrt1z() {
+ return createComplex(1.0, 0.0).subtract(this.multiply(this)).sqrt();
+ }
+
+ /**
+ * Compute the
+ *
+ * tangent of this complex number.
+ * Implements the formula:
+ *
+ *
+ * where the (real) functions on the right-hand side are
+ * {@link FastMath#sin}, {@link FastMath#cos}, {@link FastMath#cosh} and
+ * {@link FastMath#sinh}.
+ *
+ * tan(a + bi) = sin(2a)/(cos(2a)+cosh(2b)) + [sinh(2b)/(cos(2a)+cosh(2b))]i
+ *
+ *
+ * Examples:
+ *
+ *
+ * @return the tangent of {@code this}.
+ * @since 1.2
+ */
+ public Complex tan() {
+ if (isNaN || Double.isInfinite(real)) {
+ return NaN;
+ }
+ if (imaginary > 20.0) {
+ return createComplex(0.0, 1.0);
+ }
+ if (imaginary < -20.0) {
+ return createComplex(0.0, -1.0);
+ }
+
+ double real2 = 2.0 * real;
+ double imaginary2 = 2.0 * imaginary;
+ double d = FastMath.cos(real2) + FastMath.cosh(imaginary2);
+
+ return createComplex(FastMath.sin(real2) / d,
+ FastMath.sinh(imaginary2) / d);
+ }
+
+ /**
+ * Compute the
+ *
+ * hyperbolic tangent of this complex number.
+ * Implements the formula:
+ *
+ * tan(a ± INFINITY i) = 0 ± i
+ * tan(±INFINITY + bi) = NaN + NaN i
+ * tan(±INFINITY ± INFINITY i) = NaN + NaN i
+ * tan(±π/2 + 0 i) = ±INFINITY + NaN i
+ *
+ *
+ *
+ * where the (real) functions on the right-hand side are
+ * {@link FastMath#sin}, {@link FastMath#cos}, {@link FastMath#cosh} and
+ * {@link FastMath#sinh}.
+ *
+ * tan(a + bi) = sinh(2a)/(cosh(2a)+cos(2b)) + [sin(2b)/(cosh(2a)+cos(2b))]i
+ *
+ *
+ * Examples:
+ *
+ *
+ * @return the hyperbolic tangent of {@code this}.
+ * @since 1.2
+ */
+ public Complex tanh() {
+ if (isNaN || Double.isInfinite(imaginary)) {
+ return NaN;
+ }
+ if (real > 20.0) {
+ return createComplex(1.0, 0.0);
+ }
+ if (real < -20.0) {
+ return createComplex(-1.0, 0.0);
+ }
+ double real2 = 2.0 * real;
+ double imaginary2 = 2.0 * imaginary;
+ double d = FastMath.cosh(real2) + FastMath.cos(imaginary2);
+
+ return createComplex(FastMath.sinh(real2) / d,
+ FastMath.sin(imaginary2) / d);
+ }
+
+
+
+ /**
+ * Compute the argument of this complex number.
+ * The argument is the angle phi between the positive real axis and
+ * the point representing this number in the complex plane.
+ * The value returned is between -PI (not inclusive)
+ * and PI (inclusive), with negative values returned for numbers with
+ * negative imaginary parts.
+ *
+ * tanh(a ± INFINITY i) = NaN + NaN i
+ * tanh(±INFINITY + bi) = ±1 + 0 i
+ * tanh(±INFINITY ± INFINITY i) = NaN + NaN i
+ * tanh(0 + (π/2)i) = NaN + INFINITY i
+ *
+ *
+ *
+ * for {@code k=0, 1, ..., n-1}, where {@code abs} and {@code phi}
+ * are respectively the {@link #abs() modulus} and
+ * {@link #getArgument() argument} of this complex number.
+ *
+ * zk = abs1/n (cos(phi + 2πk/n) + i (sin(phi + 2πk/n))
+ *
+ * r·ei·theta,
+ * computed as r·cos(theta) + r·sin(theta)ir or theta is NaN, or
+ * theta is infinite, {@link Complex#NaN} is returned.r is infinite and theta is finite,
+ * infinite or NaN values may be returned in parts of the result, following
+ * the rules for double arithmetic.
+ * Examples:
+ *
+ * polar2Complex(INFINITY, π/4) = INFINITY + INFINITY i
+ * polar2Complex(INFINITY, 0) = INFINITY + NaN i
+ * polar2Complex(INFINITY, -π/4) = INFINITY - INFINITY i
+ * polar2Complex(INFINITY, 5π/4) = -INFINITY - INFINITY i r·ei·theta
+ * @throws MathIllegalArgumentException if {@code r} is negative.
+ * @since 1.1
+ */
+ public static Complex polar2Complex(double r, double theta) throws MathIllegalArgumentException {
+ if (r < 0) {
+ throw new MathIllegalArgumentException(
+ LocalizedFormats.NEGATIVE_COMPLEX_MODULE, r);
+ }
+ return new Complex(r * FastMath.cos(theta), r * FastMath.sin(theta));
+ }
+
+ /**
+ * Convert an array of primitive doubles to an array of {@code Complex} objects.
+ *
+ * @param real Array of numbers to be converted to their {@code Complex}
+ * equivalent.
+ * @return an array of {@code Complex} objects.
+ *
+ * @since 3.1
+ */
+ public static Complex[] convertToComplex(double[] real) {
+ final Complex c[] = new Complex[real.length];
+ for (int i = 0; i < real.length; i++) {
+ c[i] = new Complex(real[i], 0);
+ }
+
+ return c;
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/complex/Quaternion.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/complex/Quaternion.java
new file mode 100644
index 000000000..f32b8f33b
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/complex/Quaternion.java
@@ -0,0 +1,465 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.fr.third.org.apache.commons.math3.complex;
+
+import java.io.Serializable;
+
+import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException;
+import com.fr.third.org.apache.commons.math3.exception.ZeroException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+import com.fr.third.org.apache.commons.math3.util.MathUtils;
+import com.fr.third.org.apache.commons.math3.util.Precision;
+
+/**
+ * This class implements
+ * quaternions (Hamilton's hypercomplex numbers).
+ *
+ * Instance of this class are guaranteed to be immutable.
+ *
+ * @since 3.1
+ */
+public final class Quaternion implements Serializable {
+ /** Identity quaternion. */
+ public static final Quaternion IDENTITY = new Quaternion(1, 0, 0, 0);
+ /** Zero quaternion. */
+ public static final Quaternion ZERO = new Quaternion(0, 0, 0, 0);
+ /** i */
+ public static final Quaternion I = new Quaternion(0, 1, 0, 0);
+ /** j */
+ public static final Quaternion J = new Quaternion(0, 0, 1, 0);
+ /** k */
+ public static final Quaternion K = new Quaternion(0, 0, 0, 1);
+
+ /** Serializable version identifier. */
+ private static final long serialVersionUID = 20092012L;
+
+ /** First component (scalar part). */
+ private final double q0;
+ /** Second component (first vector part). */
+ private final double q1;
+ /** Third component (second vector part). */
+ private final double q2;
+ /** Fourth component (third vector part). */
+ private final double q3;
+
+ /**
+ * Builds a quaternion from its components.
+ *
+ * @param a Scalar component.
+ * @param b First vector component.
+ * @param c Second vector component.
+ * @param d Third vector component.
+ */
+ public Quaternion(final double a,
+ final double b,
+ final double c,
+ final double d) {
+ this.q0 = a;
+ this.q1 = b;
+ this.q2 = c;
+ this.q3 = d;
+ }
+
+ /**
+ * Builds a quaternion from scalar and vector parts.
+ *
+ * @param scalar Scalar part of the quaternion.
+ * @param v Components of the vector part of the quaternion.
+ *
+ * @throws DimensionMismatchException if the array length is not 3.
+ */
+ public Quaternion(final double scalar,
+ final double[] v)
+ throws DimensionMismatchException {
+ if (v.length != 3) {
+ throw new DimensionMismatchException(v.length, 3);
+ }
+ this.q0 = scalar;
+ this.q1 = v[0];
+ this.q2 = v[1];
+ this.q3 = v[2];
+ }
+
+ /**
+ * Builds a pure quaternion from a vector (assuming that the scalar
+ * part is zero).
+ *
+ * @param v Components of the vector part of the pure quaternion.
+ */
+ public Quaternion(final double[] v) {
+ this(0, v);
+ }
+
+ /**
+ * Returns the conjugate quaternion of the instance.
+ *
+ * @return the conjugate quaternion
+ */
+ public Quaternion getConjugate() {
+ return new Quaternion(q0, -q1, -q2, -q3);
+ }
+
+ /**
+ * Returns the Hamilton product of two quaternions.
+ *
+ * @param q1 First quaternion.
+ * @param q2 Second quaternion.
+ * @return the product {@code q1} and {@code q2}, in that order.
+ */
+ public static Quaternion multiply(final Quaternion q1, final Quaternion q2) {
+ // Components of the first quaternion.
+ final double q1a = q1.getQ0();
+ final double q1b = q1.getQ1();
+ final double q1c = q1.getQ2();
+ final double q1d = q1.getQ3();
+
+ // Components of the second quaternion.
+ final double q2a = q2.getQ0();
+ final double q2b = q2.getQ1();
+ final double q2c = q2.getQ2();
+ final double q2d = q2.getQ3();
+
+ // Components of the product.
+ final double w = q1a * q2a - q1b * q2b - q1c * q2c - q1d * q2d;
+ final double x = q1a * q2b + q1b * q2a + q1c * q2d - q1d * q2c;
+ final double y = q1a * q2c - q1b * q2d + q1c * q2a + q1d * q2b;
+ final double z = q1a * q2d + q1b * q2c - q1c * q2b + q1d * q2a;
+
+ return new Quaternion(w, x, y, z);
+ }
+
+ /**
+ * Returns the Hamilton product of the instance by a quaternion.
+ *
+ * @param q Quaternion.
+ * @return the product of this instance with {@code q}, in that order.
+ */
+ public Quaternion multiply(final Quaternion q) {
+ return multiply(this, q);
+ }
+
+ /**
+ * Computes the sum of two quaternions.
+ *
+ * @param q1 Quaternion.
+ * @param q2 Quaternion.
+ * @return the sum of {@code q1} and {@code q2}.
+ */
+ public static Quaternion add(final Quaternion q1,
+ final Quaternion q2) {
+ return new Quaternion(q1.getQ0() + q2.getQ0(),
+ q1.getQ1() + q2.getQ1(),
+ q1.getQ2() + q2.getQ2(),
+ q1.getQ3() + q2.getQ3());
+ }
+
+ /**
+ * Computes the sum of the instance and another quaternion.
+ *
+ * @param q Quaternion.
+ * @return the sum of this instance and {@code q}
+ */
+ public Quaternion add(final Quaternion q) {
+ return add(this, q);
+ }
+
+ /**
+ * Subtracts two quaternions.
+ *
+ * @param q1 First Quaternion.
+ * @param q2 Second quaternion.
+ * @return the difference between {@code q1} and {@code q2}.
+ */
+ public static Quaternion subtract(final Quaternion q1,
+ final Quaternion q2) {
+ return new Quaternion(q1.getQ0() - q2.getQ0(),
+ q1.getQ1() - q2.getQ1(),
+ q1.getQ2() - q2.getQ2(),
+ q1.getQ3() - q2.getQ3());
+ }
+
+ /**
+ * Subtracts a quaternion from the instance.
+ *
+ * @param q Quaternion.
+ * @return the difference between this instance and {@code q}.
+ */
+ public Quaternion subtract(final Quaternion q) {
+ return subtract(this, q);
+ }
+
+ /**
+ * Computes the dot-product of two quaternions.
+ *
+ * @param q1 Quaternion.
+ * @param q2 Quaternion.
+ * @return the dot product of {@code q1} and {@code q2}.
+ */
+ public static double dotProduct(final Quaternion q1,
+ final Quaternion q2) {
+ return q1.getQ0() * q2.getQ0() +
+ q1.getQ1() * q2.getQ1() +
+ q1.getQ2() * q2.getQ2() +
+ q1.getQ3() * q2.getQ3();
+ }
+
+ /**
+ * Computes the dot-product of the instance by a quaternion.
+ *
+ * @param q Quaternion.
+ * @return the dot product of this instance and {@code q}.
+ */
+ public double dotProduct(final Quaternion q) {
+ return dotProduct(this, q);
+ }
+
+ /**
+ * Computes the norm of the quaternion.
+ *
+ * @return the norm.
+ */
+ public double getNorm() {
+ return FastMath.sqrt(q0 * q0 +
+ q1 * q1 +
+ q2 * q2 +
+ q3 * q3);
+ }
+
+ /**
+ * Computes the normalized quaternion (the versor of the instance).
+ * The norm of the quaternion must not be zero.
+ *
+ * @return a normalized quaternion.
+ * @throws ZeroException if the norm of the quaternion is zero.
+ */
+ public Quaternion normalize() {
+ final double norm = getNorm();
+
+ if (norm < Precision.SAFE_MIN) {
+ throw new ZeroException(LocalizedFormats.NORM, norm);
+ }
+
+ return new Quaternion(q0 / norm,
+ q1 / norm,
+ q2 / norm,
+ q3 / norm);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean equals(Object other) {
+ if (this == other) {
+ return true;
+ }
+ if (other instanceof Quaternion) {
+ final Quaternion q = (Quaternion) other;
+ return q0 == q.getQ0() &&
+ q1 == q.getQ1() &&
+ q2 == q.getQ2() &&
+ q3 == q.getQ3();
+ }
+
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int hashCode() {
+ // "Effective Java" (second edition, p. 47).
+ int result = 17;
+ for (double comp : new double[] { q0, q1, q2, q3 }) {
+ final int c = MathUtils.hash(comp);
+ result = 31 * result + c;
+ }
+ return result;
+ }
+
+ /**
+ * Checks whether this instance is equal to another quaternion
+ * within a given tolerance.
+ *
+ * @param q Quaternion with which to compare the current quaternion.
+ * @param eps Tolerance.
+ * @return {@code true} if the each of the components are equal
+ * within the allowed absolute error.
+ */
+ public boolean equals(final Quaternion q,
+ final double eps) {
+ return Precision.equals(q0, q.getQ0(), eps) &&
+ Precision.equals(q1, q.getQ1(), eps) &&
+ Precision.equals(q2, q.getQ2(), eps) &&
+ Precision.equals(q3, q.getQ3(), eps);
+ }
+
+ /**
+ * Checks whether the instance is a unit quaternion within a given
+ * tolerance.
+ *
+ * @param eps Tolerance (absolute error).
+ * @return {@code true} if the norm is 1 within the given tolerance,
+ * {@code false} otherwise
+ */
+ public boolean isUnitQuaternion(double eps) {
+ return Precision.equals(getNorm(), 1d, eps);
+ }
+
+ /**
+ * Checks whether the instance is a pure quaternion within a given
+ * tolerance.
+ *
+ * @param eps Tolerance (absolute error).
+ * @return {@code true} if the scalar part of the quaternion is zero.
+ */
+ public boolean isPureQuaternion(double eps) {
+ return FastMath.abs(getQ0()) <= eps;
+ }
+
+ /**
+ * Returns the polar form of the quaternion.
+ *
+ * @return the unit quaternion with positive scalar part.
+ */
+ public Quaternion getPositivePolarForm() {
+ if (getQ0() < 0) {
+ final Quaternion unitQ = normalize();
+ // The quaternion of rotation (normalized quaternion) q and -q
+ // are equivalent (i.e. represent the same rotation).
+ return new Quaternion(-unitQ.getQ0(),
+ -unitQ.getQ1(),
+ -unitQ.getQ2(),
+ -unitQ.getQ3());
+ } else {
+ return this.normalize();
+ }
+ }
+
+ /**
+ * Returns the inverse of this instance.
+ * The norm of the quaternion must not be zero.
+ *
+ * @return the inverse.
+ * @throws ZeroException if the norm (squared) of the quaternion is zero.
+ */
+ public Quaternion getInverse() {
+ final double squareNorm = q0 * q0 + q1 * q1 + q2 * q2 + q3 * q3;
+ if (squareNorm < Precision.SAFE_MIN) {
+ throw new ZeroException(LocalizedFormats.NORM, squareNorm);
+ }
+
+ return new Quaternion(q0 / squareNorm,
+ -q1 / squareNorm,
+ -q2 / squareNorm,
+ -q3 / squareNorm);
+ }
+
+ /**
+ * Gets the first component of the quaternion (scalar part).
+ *
+ * @return the scalar part.
+ */
+ public double getQ0() {
+ return q0;
+ }
+
+ /**
+ * Gets the second component of the quaternion (first component
+ * of the vector part).
+ *
+ * @return the first component of the vector part.
+ */
+ public double getQ1() {
+ return q1;
+ }
+
+ /**
+ * Gets the third component of the quaternion (second component
+ * of the vector part).
+ *
+ * @return the second component of the vector part.
+ */
+ public double getQ2() {
+ return q2;
+ }
+
+ /**
+ * Gets the fourth component of the quaternion (third component
+ * of the vector part).
+ *
+ * @return the third component of the vector part.
+ */
+ public double getQ3() {
+ return q3;
+ }
+
+ /**
+ * Gets the scalar part of the quaternion.
+ *
+ * @return the scalar part.
+ * @see #getQ0()
+ */
+ public double getScalarPart() {
+ return getQ0();
+ }
+
+ /**
+ * Gets the three components of the vector part of the quaternion.
+ *
+ * @return the vector part.
+ * @see #getQ1()
+ * @see #getQ2()
+ * @see #getQ3()
+ */
+ public double[] getVectorPart() {
+ return new double[] { getQ1(), getQ2(), getQ3() };
+ }
+
+ /**
+ * Multiplies the instance by a scalar.
+ *
+ * @param alpha Scalar factor.
+ * @return a scaled quaternion.
+ */
+ public Quaternion multiply(final double alpha) {
+ return new Quaternion(alpha * q0,
+ alpha * q1,
+ alpha * q2,
+ alpha * q3);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public String toString() {
+ final String sp = " ";
+ final StringBuilder s = new StringBuilder();
+ s.append("[")
+ .append(q0).append(sp)
+ .append(q1).append(sp)
+ .append(q2).append(sp)
+ .append(q3)
+ .append("]");
+
+ return s.toString();
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/complex/RootsOfUnity.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/complex/RootsOfUnity.java
new file mode 100644
index 000000000..b3d38ee0b
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/complex/RootsOfUnity.java
@@ -0,0 +1,218 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.complex;
+
+import java.io.Serializable;
+
+import com.fr.third.org.apache.commons.math3.exception.MathIllegalArgumentException;
+import com.fr.third.org.apache.commons.math3.exception.MathIllegalStateException;
+import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException;
+import com.fr.third.org.apache.commons.math3.exception.ZeroException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+
+/**
+ * A helper class for the computation and caching of the {@code n}-th roots of
+ * unity.
+ *
+ * @since 3.0
+ */
+public class RootsOfUnity implements Serializable {
+
+ /** Serializable version id. */
+ private static final long serialVersionUID = 20120201L;
+
+ /** Number of roots of unity. */
+ private int omegaCount;
+
+ /** Real part of the roots. */
+ private double[] omegaReal;
+
+ /**
+ * Imaginary part of the {@code n}-th roots of unity, for positive values
+ * of {@code n}. In this array, the roots are stored in counter-clockwise
+ * order.
+ */
+ private double[] omegaImaginaryCounterClockwise;
+
+ /**
+ * Imaginary part of the {@code n}-th roots of unity, for negative values
+ * of {@code n}. In this array, the roots are stored in clockwise order.
+ */
+ private double[] omegaImaginaryClockwise;
+
+ /**
+ * {@code true} if {@link #computeRoots(int)} was called with a positive
+ * value of its argument {@code n}. In this case, counter-clockwise ordering
+ * of the roots of unity should be used.
+ */
+ private boolean isCounterClockWise;
+
+ /**
+ * Build an engine for computing the {@code n}-th roots of unity.
+ */
+ public RootsOfUnity() {
+
+ omegaCount = 0;
+ omegaReal = null;
+ omegaImaginaryCounterClockwise = null;
+ omegaImaginaryClockwise = null;
+ isCounterClockWise = true;
+ }
+
+ /**
+ * Returns {@code true} if {@link #computeRoots(int)} was called with a
+ * positive value of its argument {@code n}. If {@code true}, then
+ * counter-clockwise ordering of the roots of unity should be used.
+ *
+ * @return {@code true} if the roots of unity are stored in
+ * counter-clockwise order
+ * @throws MathIllegalStateException if no roots of unity have been computed
+ * yet
+ */
+ public synchronized boolean isCounterClockWise()
+ throws MathIllegalStateException {
+
+ if (omegaCount == 0) {
+ throw new MathIllegalStateException(
+ LocalizedFormats.ROOTS_OF_UNITY_NOT_COMPUTED_YET);
+ }
+ return isCounterClockWise;
+ }
+
+ /**
+ *
+ *
+ * The changes with respect to the original Brent algorithm are: + *
Another floating point class. This one is built using radix 10000 + * which is 104, so its almost decimal.
+ * + *The design goals here are: + *
Trade offs: + *
Numbers are represented in the following form: + *
+ * n = sign × mant × (radix)exp; + *+ * where sign is ±1, mantissa represents a fractional number between + * zero and one. mant[0] is the least significant digit. + * exp is in the range of -32767 to 32768 + * + *
IEEE 854-1987 Notes and differences
+ * + *IEEE 854 requires the radix to be either 2 or 10. The radix here is + * 10000, so that requirement is not met, but it is possible that a + * subclassed can be made to make it behave as a radix 10 + * number. It is my opinion that if it looks and behaves as a radix + * 10 number then it is one and that requirement would be met.
+ * + *The radix of 10000 was chosen because it should be faster to operate + * on 4 decimal digits at once instead of one at a time. Radix 10 behavior + * can be realized by adding an additional rounding step to ensure that + * the number of decimal digits represented is constant.
+ * + *The IEEE standard specifically leaves out internal data encoding, + * so it is reasonable to conclude that such a subclass of this radix + * 10000 system is merely an encoding of a radix 10 system.
+ * + *IEEE 854 also specifies the existence of "sub-normal" numbers. This + * class does not contain any such entities. The most significant radix + * 10000 digit is always non-zero. Instead, we support "gradual underflow" + * by raising the underflow flag for numbers less with exponent less than + * expMin, but don't flush to zero until the exponent reaches MIN_EXP-digits. + * Thus the smallest number we can represent would be: + * 1E(-(MIN_EXP-digits-1)*4), eg, for digits=5, MIN_EXP=-32767, that would + * be 1e-131092.
+ * + *IEEE 854 defines that the implied radix point lies just to the right + * of the most significant digit and to the left of the remaining digits. + * This implementation puts the implied radix point to the left of all + * digits including the most significant one. The most significant digit + * here is the one just to the right of the radix point. This is a fine + * detail and is really only a matter of definition. Any side effects of + * this can be rendered invisible by a subclass.
+ * @see DfpField + * @since 2.2 + */ +public class Dfp implements RealFieldElement+ * The field is linked to the number of digits and acts as a factory + * for {@link Dfp} instances. + *
+ * @return {@link Field Field} (really a {@link DfpField}) to which the instance belongs + */ + public DfpField getField() { + return field; + } + + /** Get the number of radix digits of the instance. + * @return number of radix digits + */ + public int getRadixDigits() { + return field.getRadixDigits(); + } + + /** Get the constant 0. + * @return a Dfp with value zero + */ + public Dfp getZero() { + return field.getZero(); + } + + /** Get the constant 1. + * @return a Dfp with value one + */ + public Dfp getOne() { + return field.getOne(); + } + + /** Get the constant 2. + * @return a Dfp with value two + */ + public Dfp getTwo() { + return field.getTwo(); + } + + /** Shift the mantissa left, and adjust the exponent to compensate. + */ + protected void shiftLeft() { + for (int i = mant.length - 1; i > 0; i--) { + mant[i] = mant[i-1]; + } + mant[0] = 0; + exp--; + } + + /* Note that shiftRight() does not call round() as that round() itself + uses shiftRight() */ + /** Shift the mantissa right, and adjust the exponent to compensate. + */ + protected void shiftRight() { + for (int i = 0; i < mant.length - 1; i++) { + mant[i] = mant[i+1]; + } + mant[mant.length - 1] = 0; + exp++; + } + + /** Make our exp equal to the supplied one, this may cause rounding. + * Also causes de-normalized numbers. These numbers are generally + * dangerous because most routines assume normalized numbers. + * Align doesn't round, so it will return the last digit destroyed + * by shifting right. + * @param e desired exponent + * @return last digit destroyed by shifting right + */ + protected int align(int e) { + int lostdigit = 0; + boolean inexact = false; + + int diff = exp - e; + + int adiff = diff; + if (adiff < 0) { + adiff = -adiff; + } + + if (diff == 0) { + return 0; + } + + if (adiff > (mant.length + 1)) { + // Special case + Arrays.fill(mant, 0); + exp = e; + + field.setIEEEFlagsBits(DfpField.FLAG_INEXACT); + dotrap(DfpField.FLAG_INEXACT, ALIGN_TRAP, this, this); + + return 0; + } + + for (int i = 0; i < adiff; i++) { + if (diff < 0) { + /* Keep track of loss -- only signal inexact after losing 2 digits. + * the first lost digit is returned to add() and may be incorporated + * into the result. + */ + if (lostdigit != 0) { + inexact = true; + } + + lostdigit = mant[0]; + + shiftRight(); + } else { + shiftLeft(); + } + } + + if (inexact) { + field.setIEEEFlagsBits(DfpField.FLAG_INEXACT); + dotrap(DfpField.FLAG_INEXACT, ALIGN_TRAP, this, this); + } + + return lostdigit; + + } + + /** Check if instance is less than x. + * @param x number to check instance against + * @return true if instance is less than x and neither are NaN, false otherwise + */ + public boolean lessThan(final Dfp x) { + + // make sure we don't mix number with different precision + if (field.getRadixDigits() != x.field.getRadixDigits()) { + field.setIEEEFlagsBits(DfpField.FLAG_INVALID); + final Dfp result = newInstance(getZero()); + result.nans = QNAN; + dotrap(DfpField.FLAG_INVALID, LESS_THAN_TRAP, x, result); + return false; + } + + /* if a nan is involved, signal invalid and return false */ + if (isNaN() || x.isNaN()) { + field.setIEEEFlagsBits(DfpField.FLAG_INVALID); + dotrap(DfpField.FLAG_INVALID, LESS_THAN_TRAP, x, newInstance(getZero())); + return false; + } + + return compare(this, x) < 0; + } + + /** Check if instance is greater than x. + * @param x number to check instance against + * @return true if instance is greater than x and neither are NaN, false otherwise + */ + public boolean greaterThan(final Dfp x) { + + // make sure we don't mix number with different precision + if (field.getRadixDigits() != x.field.getRadixDigits()) { + field.setIEEEFlagsBits(DfpField.FLAG_INVALID); + final Dfp result = newInstance(getZero()); + result.nans = QNAN; + dotrap(DfpField.FLAG_INVALID, GREATER_THAN_TRAP, x, result); + return false; + } + + /* if a nan is involved, signal invalid and return false */ + if (isNaN() || x.isNaN()) { + field.setIEEEFlagsBits(DfpField.FLAG_INVALID); + dotrap(DfpField.FLAG_INVALID, GREATER_THAN_TRAP, x, newInstance(getZero())); + return false; + } + + return compare(this, x) > 0; + } + + /** Check if instance is less than or equal to 0. + * @return true if instance is not NaN and less than or equal to 0, false otherwise + */ + public boolean negativeOrNull() { + + if (isNaN()) { + field.setIEEEFlagsBits(DfpField.FLAG_INVALID); + dotrap(DfpField.FLAG_INVALID, LESS_THAN_TRAP, this, newInstance(getZero())); + return false; + } + + return (sign < 0) || ((mant[mant.length - 1] == 0) && !isInfinite()); + + } + + /** Check if instance is strictly less than 0. + * @return true if instance is not NaN and less than or equal to 0, false otherwise + */ + public boolean strictlyNegative() { + + if (isNaN()) { + field.setIEEEFlagsBits(DfpField.FLAG_INVALID); + dotrap(DfpField.FLAG_INVALID, LESS_THAN_TRAP, this, newInstance(getZero())); + return false; + } + + return (sign < 0) && ((mant[mant.length - 1] != 0) || isInfinite()); + + } + + /** Check if instance is greater than or equal to 0. + * @return true if instance is not NaN and greater than or equal to 0, false otherwise + */ + public boolean positiveOrNull() { + + if (isNaN()) { + field.setIEEEFlagsBits(DfpField.FLAG_INVALID); + dotrap(DfpField.FLAG_INVALID, LESS_THAN_TRAP, this, newInstance(getZero())); + return false; + } + + return (sign > 0) || ((mant[mant.length - 1] == 0) && !isInfinite()); + + } + + /** Check if instance is strictly greater than 0. + * @return true if instance is not NaN and greater than or equal to 0, false otherwise + */ + public boolean strictlyPositive() { + + if (isNaN()) { + field.setIEEEFlagsBits(DfpField.FLAG_INVALID); + dotrap(DfpField.FLAG_INVALID, LESS_THAN_TRAP, this, newInstance(getZero())); + return false; + } + + return (sign > 0) && ((mant[mant.length - 1] != 0) || isInfinite()); + + } + + /** Get the absolute value of instance. + * @return absolute value of instance + * @since 3.2 + */ + public Dfp abs() { + Dfp result = newInstance(this); + result.sign = 1; + return result; + } + + /** Check if instance is infinite. + * @return true if instance is infinite + */ + public boolean isInfinite() { + return nans == INFINITE; + } + + /** Check if instance is not a number. + * @return true if instance is not a number + */ + public boolean isNaN() { + return (nans == QNAN) || (nans == SNAN); + } + + /** Check if instance is equal to zero. + * @return true if instance is equal to zero + */ + public boolean isZero() { + + if (isNaN()) { + field.setIEEEFlagsBits(DfpField.FLAG_INVALID); + dotrap(DfpField.FLAG_INVALID, LESS_THAN_TRAP, this, newInstance(getZero())); + return false; + } + + return (mant[mant.length - 1] == 0) && !isInfinite(); + + } + + /** Check if instance is equal to x. + * @param other object to check instance against + * @return true if instance is equal to x and neither are NaN, false otherwise + */ + @Override + public boolean equals(final Object other) { + + if (other instanceof Dfp) { + final Dfp x = (Dfp) other; + if (isNaN() || x.isNaN() || field.getRadixDigits() != x.field.getRadixDigits()) { + return false; + } + + return compare(this, x) == 0; + } + + return false; + + } + + /** + * Gets a hashCode for the instance. + * @return a hash code value for this object + */ + @Override + public int hashCode() { + return 17 + (isZero() ? 0 : (sign << 8)) + (nans << 16) + exp + Arrays.hashCode(mant); + } + + /** Check if instance is not equal to x. + * @param x number to check instance against + * @return true if instance is not equal to x and neither are NaN, false otherwise + */ + public boolean unequal(final Dfp x) { + if (isNaN() || x.isNaN() || field.getRadixDigits() != x.field.getRadixDigits()) { + return false; + } + + return greaterThan(x) || lessThan(x); + } + + /** Compare two instances. + * @param a first instance in comparison + * @param b second instance in comparison + * @return -1 if a+ * Note that since the {@link Dfp} class uses 10000 as its radix, each radix + * digit is equivalent to 4 decimal digits. This implies that asking for + * 13, 14, 15 or 16 decimal digits will really lead to a 4 radix 10000 digits in + * all cases. + *
+ * @param decimalDigits minimal number of decimal digits. + */ + public DfpField(final int decimalDigits) { + this(decimalDigits, true); + } + + /** Create a factory for the specified number of radix digits. + *+ * Note that since the {@link Dfp} class uses 10000 as its radix, each radix + * digit is equivalent to 4 decimal digits. This implies that asking for + * 13, 14, 15 or 16 decimal digits will really lead to a 4 radix 10000 digits in + * all cases. + *
+ * @param decimalDigits minimal number of decimal digits + * @param computeConstants if true, the transcendental constants for the given precision + * must be computed (setting this flag to false is RESERVED for the internal recursive call) + */ + private DfpField(final int decimalDigits, final boolean computeConstants) { + + this.radixDigits = (decimalDigits < 13) ? 4 : (decimalDigits + 3) / 4; + this.rMode = RoundingMode.ROUND_HALF_EVEN; + this.ieeeFlags = 0; + this.zero = new Dfp(this, 0); + this.one = new Dfp(this, 1); + this.two = new Dfp(this, 2); + + if (computeConstants) { + // set up transcendental constants + synchronized (DfpField.class) { + + // as a heuristic to circumvent Table-Maker's Dilemma, we set the string + // representation of the constants to be at least 3 times larger than the + // number of decimal digits, also as an attempt to really compute these + // constants only once, we set a minimum number of digits + computeStringConstants((decimalDigits < 67) ? 200 : (3 * decimalDigits)); + + // set up the constants at current field accuracy + sqr2 = new Dfp(this, sqr2String); + sqr2Split = split(sqr2String); + sqr2Reciprocal = new Dfp(this, sqr2ReciprocalString); + sqr3 = new Dfp(this, sqr3String); + sqr3Reciprocal = new Dfp(this, sqr3ReciprocalString); + pi = new Dfp(this, piString); + piSplit = split(piString); + e = new Dfp(this, eString); + eSplit = split(eString); + ln2 = new Dfp(this, ln2String); + ln2Split = split(ln2String); + ln5 = new Dfp(this, ln5String); + ln5Split = split(ln5String); + ln10 = new Dfp(this, ln10String); + + } + } else { + // dummy settings for unused constants + sqr2 = null; + sqr2Split = null; + sqr2Reciprocal = null; + sqr3 = null; + sqr3Reciprocal = null; + pi = null; + piSplit = null; + e = null; + eSplit = null; + ln2 = null; + ln2Split = null; + ln5 = null; + ln5Split = null; + ln10 = null; + } + + } + + /** Get the number of radix digits of the {@link Dfp} instances built by this factory. + * @return number of radix digits + */ + public int getRadixDigits() { + return radixDigits; + } + + /** Set the rounding mode. + * If not set, the default value is {@link RoundingMode#ROUND_HALF_EVEN}. + * @param mode desired rounding mode + * Note that the rounding mode is common to all {@link Dfp} instances + * belonging to the current {@link DfpField} in the system and will + * affect all future calculations. + */ + public void setRoundingMode(final RoundingMode mode) { + rMode = mode; + } + + /** Get the current rounding mode. + * @return current rounding mode + */ + public RoundingMode getRoundingMode() { + return rMode; + } + + /** Get the IEEE 854 status flags. + * @return IEEE 854 status flags + * @see #clearIEEEFlags() + * @see #setIEEEFlags(int) + * @see #setIEEEFlagsBits(int) + * @see #FLAG_INVALID + * @see #FLAG_DIV_ZERO + * @see #FLAG_OVERFLOW + * @see #FLAG_UNDERFLOW + * @see #FLAG_INEXACT + */ + public int getIEEEFlags() { + return ieeeFlags; + } + + /** Clears the IEEE 854 status flags. + * @see #getIEEEFlags() + * @see #setIEEEFlags(int) + * @see #setIEEEFlagsBits(int) + * @see #FLAG_INVALID + * @see #FLAG_DIV_ZERO + * @see #FLAG_OVERFLOW + * @see #FLAG_UNDERFLOW + * @see #FLAG_INEXACT + */ + public void clearIEEEFlags() { + ieeeFlags = 0; + } + + /** Sets the IEEE 854 status flags. + * @param flags desired value for the flags + * @see #getIEEEFlags() + * @see #clearIEEEFlags() + * @see #setIEEEFlagsBits(int) + * @see #FLAG_INVALID + * @see #FLAG_DIV_ZERO + * @see #FLAG_OVERFLOW + * @see #FLAG_UNDERFLOW + * @see #FLAG_INEXACT + */ + public void setIEEEFlags(final int flags) { + ieeeFlags = flags & (FLAG_INVALID | FLAG_DIV_ZERO | FLAG_OVERFLOW | FLAG_UNDERFLOW | FLAG_INEXACT); + } + + /** Sets some bits in the IEEE 854 status flags, without changing the already set bits. + *+ * Calling this method is equivalent to call {@code setIEEEFlags(getIEEEFlags() | bits)} + *
+ * @param bits bits to set + * @see #getIEEEFlags() + * @see #clearIEEEFlags() + * @see #setIEEEFlags(int) + * @see #FLAG_INVALID + * @see #FLAG_DIV_ZERO + * @see #FLAG_OVERFLOW + * @see #FLAG_UNDERFLOW + * @see #FLAG_INEXACT + */ + public void setIEEEFlagsBits(final int bits) { + ieeeFlags |= bits & (FLAG_INVALID | FLAG_DIV_ZERO | FLAG_OVERFLOW | FLAG_UNDERFLOW | FLAG_INEXACT); + } + + /** Makes a {@link Dfp} with a value of 0. + * @return a new {@link Dfp} with a value of 0 + */ + public Dfp newDfp() { + return new Dfp(this); + } + + /** Create an instance from a byte value. + * @param x value to convert to an instance + * @return a new {@link Dfp} with the same value as x + */ + public Dfp newDfp(final byte x) { + return new Dfp(this, x); + } + + /** Create an instance from an int value. + * @param x value to convert to an instance + * @return a new {@link Dfp} with the same value as x + */ + public Dfp newDfp(final int x) { + return new Dfp(this, x); + } + + /** Create an instance from a long value. + * @param x value to convert to an instance + * @return a new {@link Dfp} with the same value as x + */ + public Dfp newDfp(final long x) { + return new Dfp(this, x); + } + + /** Create an instance from a double value. + * @param x value to convert to an instance + * @return a new {@link Dfp} with the same value as x + */ + public Dfp newDfp(final double x) { + return new Dfp(this, x); + } + + /** Copy constructor. + * @param d instance to copy + * @return a new {@link Dfp} with the same value as d + */ + public Dfp newDfp(Dfp d) { + return new Dfp(d); + } + + /** Create a {@link Dfp} given a String representation. + * @param s string representation of the instance + * @return a new {@link Dfp} parsed from specified string + */ + public Dfp newDfp(final String s) { + return new Dfp(this, s); + } + + /** Creates a {@link Dfp} with a non-finite value. + * @param sign sign of the Dfp to create + * @param nans code of the value, must be one of {@link Dfp#INFINITE}, + * {@link Dfp#SNAN}, {@link Dfp#QNAN} + * @return a new {@link Dfp} with a non-finite value + */ + public Dfp newDfp(final byte sign, final byte nans) { + return new Dfp(this, sign, nans); + } + + /** Get the constant 0. + * @return a {@link Dfp} with value 0 + */ + public Dfp getZero() { + return zero; + } + + /** Get the constant 1. + * @return a {@link Dfp} with value 1 + */ + public Dfp getOne() { + return one; + } + + /** {@inheritDoc} */ + public Class> getRuntimeClass() { + return Dfp.class; + } + + /** Get the constant 2. + * @return a {@link Dfp} with value 2 + */ + public Dfp getTwo() { + return two; + } + + /** Get the constant √2. + * @return a {@link Dfp} with value √2 + */ + public Dfp getSqr2() { + return sqr2; + } + + /** Get the constant √2 split in two pieces. + * @return a {@link Dfp} with value √2 split in two pieces + */ + public Dfp[] getSqr2Split() { + return sqr2Split.clone(); + } + + /** Get the constant √2 / 2. + * @return a {@link Dfp} with value √2 / 2 + */ + public Dfp getSqr2Reciprocal() { + return sqr2Reciprocal; + } + + /** Get the constant √3. + * @return a {@link Dfp} with value √3 + */ + public Dfp getSqr3() { + return sqr3; + } + + /** Get the constant √3 / 3. + * @return a {@link Dfp} with value √3 / 3 + */ + public Dfp getSqr3Reciprocal() { + return sqr3Reciprocal; + } + + /** Get the constant π. + * @return a {@link Dfp} with value π + */ + public Dfp getPi() { + return pi; + } + + /** Get the constant π split in two pieces. + * @return a {@link Dfp} with value π split in two pieces + */ + public Dfp[] getPiSplit() { + return piSplit.clone(); + } + + /** Get the constant e. + * @return a {@link Dfp} with value e + */ + public Dfp getE() { + return e; + } + + /** Get the constant e split in two pieces. + * @return a {@link Dfp} with value e split in two pieces + */ + public Dfp[] getESplit() { + return eSplit.clone(); + } + + /** Get the constant ln(2). + * @return a {@link Dfp} with value ln(2) + */ + public Dfp getLn2() { + return ln2; + } + + /** Get the constant ln(2) split in two pieces. + * @return a {@link Dfp} with value ln(2) split in two pieces + */ + public Dfp[] getLn2Split() { + return ln2Split.clone(); + } + + /** Get the constant ln(5). + * @return a {@link Dfp} with value ln(5) + */ + public Dfp getLn5() { + return ln5; + } + + /** Get the constant ln(5) split in two pieces. + * @return a {@link Dfp} with value ln(5) split in two pieces + */ + public Dfp[] getLn5Split() { + return ln5Split.clone(); + } + + /** Get the constant ln(10). + * @return a {@link Dfp} with value ln(10) + */ + public Dfp getLn10() { + return ln10; + } + + /** Breaks a string representation up into two {@link Dfp}'s. + * The split is such that the sum of them is equivalent to the input string, + * but has higher precision than using a single Dfp. + * @param a string representation of the number to split + * @return an array of two {@link Dfp Dfp} instances which sum equals a + */ + private Dfp[] split(final String a) { + Dfp result[] = new Dfp[2]; + boolean leading = true; + int sp = 0; + int sig = 0; + + char[] buf = new char[a.length()]; + + for (int i = 0; i < buf.length; i++) { + buf[i] = a.charAt(i); + + if (buf[i] >= '1' && buf[i] <= '9') { + leading = false; + } + + if (buf[i] == '.') { + sig += (400 - sig) % 4; + leading = false; + } + + if (sig == (radixDigits / 2) * 4) { + sp = i; + break; + } + + if (buf[i] >= '0' && buf[i] <= '9' && !leading) { + sig ++; + } + } + + result[0] = new Dfp(this, new String(buf, 0, sp)); + + for (int i = 0; i < buf.length; i++) { + buf[i] = a.charAt(i); + if (buf[i] >= '0' && buf[i] <= '9' && i < sp) { + buf[i] = '0'; + } + } + + result[1] = new Dfp(this, new String(buf)); + + return result; + + } + + /** Recompute the high precision string constants. + * @param highPrecisionDecimalDigits precision at which the string constants mus be computed + */ + private static void computeStringConstants(final int highPrecisionDecimalDigits) { + if (sqr2String == null || sqr2String.length() < highPrecisionDecimalDigits - 3) { + + // recompute the string representation of the transcendental constants + final DfpField highPrecisionField = new DfpField(highPrecisionDecimalDigits, false); + final Dfp highPrecisionOne = new Dfp(highPrecisionField, 1); + final Dfp highPrecisionTwo = new Dfp(highPrecisionField, 2); + final Dfp highPrecisionThree = new Dfp(highPrecisionField, 3); + + final Dfp highPrecisionSqr2 = highPrecisionTwo.sqrt(); + sqr2String = highPrecisionSqr2.toString(); + sqr2ReciprocalString = highPrecisionOne.divide(highPrecisionSqr2).toString(); + + final Dfp highPrecisionSqr3 = highPrecisionThree.sqrt(); + sqr3String = highPrecisionSqr3.toString(); + sqr3ReciprocalString = highPrecisionOne.divide(highPrecisionSqr3).toString(); + + piString = computePi(highPrecisionOne, highPrecisionTwo, highPrecisionThree).toString(); + eString = computeExp(highPrecisionOne, highPrecisionOne).toString(); + ln2String = computeLn(highPrecisionTwo, highPrecisionOne, highPrecisionTwo).toString(); + ln5String = computeLn(new Dfp(highPrecisionField, 5), highPrecisionOne, highPrecisionTwo).toString(); + ln10String = computeLn(new Dfp(highPrecisionField, 10), highPrecisionOne, highPrecisionTwo).toString(); + + } + } + + /** Compute π using Jonathan and Peter Borwein quartic formula. + * @param one constant with value 1 at desired precision + * @param two constant with value 2 at desired precision + * @param three constant with value 3 at desired precision + * @return π + */ + private static Dfp computePi(final Dfp one, final Dfp two, final Dfp three) { + + Dfp sqrt2 = two.sqrt(); + Dfp yk = sqrt2.subtract(one); + Dfp four = two.add(two); + Dfp two2kp3 = two; + Dfp ak = two.multiply(three.subtract(two.multiply(sqrt2))); + + // The formula converges quartically. This means the number of correct + // digits is multiplied by 4 at each iteration! Five iterations are + // sufficient for about 160 digits, eight iterations give about + // 10000 digits (this has been checked) and 20 iterations more than + // 160 billions of digits (this has NOT been checked). + // So the limit here is considered sufficient for most purposes ... + for (int i = 1; i < 20; i++) { + final Dfp ykM1 = yk; + + final Dfp y2 = yk.multiply(yk); + final Dfp oneMinusY4 = one.subtract(y2.multiply(y2)); + final Dfp s = oneMinusY4.sqrt().sqrt(); + yk = one.subtract(s).divide(one.add(s)); + + two2kp3 = two2kp3.multiply(four); + + final Dfp p = one.add(yk); + final Dfp p2 = p.multiply(p); + ak = ak.multiply(p2.multiply(p2)).subtract(two2kp3.multiply(yk).multiply(one.add(yk).add(yk.multiply(yk)))); + + if (yk.equals(ykM1)) { + break; + } + } + + return one.divide(ak); + + } + + /** Compute exp(a). + * @param a number for which we want the exponential + * @param one constant with value 1 at desired precision + * @return exp(a) + */ + public static Dfp computeExp(final Dfp a, final Dfp one) { + + Dfp y = new Dfp(one); + Dfp py = new Dfp(one); + Dfp f = new Dfp(one); + Dfp fi = new Dfp(one); + Dfp x = new Dfp(one); + + for (int i = 0; i < 10000; i++) { + x = x.multiply(a); + y = y.add(x.divide(f)); + fi = fi.add(one); + f = f.multiply(fi); + if (y.equals(py)) { + break; + } + py = new Dfp(y); + } + + return y; + + } + + + /** Compute ln(a). + * + * Let f(x) = ln(x), + * + * We know that f'(x) = 1/x, thus from Taylor's theorem we have: + * + * ----- n+1 n + * f(x) = \ (-1) (x - 1) + * / ---------------- for 1 <= n <= infinity + * ----- n + * + * or + * 2 3 4 + * (x-1) (x-1) (x-1) + * ln(x) = (x-1) - ----- + ------ - ------ + ... + * 2 3 4 + * + * alternatively, + * + * 2 3 4 + * x x x + * ln(x+1) = x - - + - - - + ... + * 2 3 4 + * + * This series can be used to compute ln(x), but it converges too slowly. + * + * If we substitute -x for x above, we get + * + * 2 3 4 + * x x x + * ln(1-x) = -x - - - - - - + ... + * 2 3 4 + * + * Note that all terms are now negative. Because the even powered ones + * absorbed the sign. Now, subtract the series above from the previous + * one to get ln(x+1) - ln(1-x). Note the even terms cancel out leaving + * only the odd ones + * + * 3 5 7 + * 2x 2x 2x + * ln(x+1) - ln(x-1) = 2x + --- + --- + ---- + ... + * 3 5 7 + * + * By the property of logarithms that ln(a) - ln(b) = ln (a/b) we have: + * + * 3 5 7 + * x+1 / x x x \ + * ln ----- = 2 * | x + ---- + ---- + ---- + ... | + * x-1 \ 3 5 7 / + * + * But now we want to find ln(a), so we need to find the value of x + * such that a = (x+1)/(x-1). This is easily solved to find that + * x = (a-1)/(a+1). + * @param a number for which we want the exponential + * @param one constant with value 1 at desired precision + * @param two constant with value 2 at desired precision + * @return ln(a) + */ + + public static Dfp computeLn(final Dfp a, final Dfp one, final Dfp two) { + + int den = 1; + Dfp x = a.add(new Dfp(a.getField(), -1)).divide(a.add(one)); + + Dfp y = new Dfp(x); + Dfp num = new Dfp(x); + Dfp py = new Dfp(y); + for (int i = 0; i < 10000; i++) { + num = num.multiply(x); + num = num.multiply(x); + den += 2; + Dfp t = num.divide(den); + y = y.add(t); + if (y.equals(py)) { + break; + } + py = new Dfp(y); + } + + return y.multiply(two); + + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/dfp/DfpMath.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/dfp/DfpMath.java new file mode 100644 index 000000000..c33db4bfb --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/dfp/DfpMath.java @@ -0,0 +1,962 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.dfp; + +/** Mathematical routines for use with {@link Dfp}. + * The constants are defined in {@link DfpField} + * @since 2.2 + */ +public class DfpMath { + + /** Name for traps triggered by pow. */ + private static final String POW_TRAP = "pow"; + + /** + * Private Constructor. + */ + private DfpMath() { + } + + /** Breaks a string representation up into two dfp's. + *The two dfp are such that the sum of them is equivalent + * to the input string, but has higher precision than using a + * single dfp. This is useful for improving accuracy of + * exponentiation and critical multiplies. + * @param field field to which the Dfp must belong + * @param a string representation to split + * @return an array of two {@link Dfp} which sum is a + */ + protected static Dfp[] split(final DfpField field, final String a) { + Dfp result[] = new Dfp[2]; + char[] buf; + boolean leading = true; + int sp = 0; + int sig = 0; + + buf = new char[a.length()]; + + for (int i = 0; i < buf.length; i++) { + buf[i] = a.charAt(i); + + if (buf[i] >= '1' && buf[i] <= '9') { + leading = false; + } + + if (buf[i] == '.') { + sig += (400 - sig) % 4; + leading = false; + } + + if (sig == (field.getRadixDigits() / 2) * 4) { + sp = i; + break; + } + + if (buf[i] >= '0' && buf[i] <= '9' && !leading) { + sig ++; + } + } + + result[0] = field.newDfp(new String(buf, 0, sp)); + + for (int i = 0; i < buf.length; i++) { + buf[i] = a.charAt(i); + if (buf[i] >= '0' && buf[i] <= '9' && i < sp) { + buf[i] = '0'; + } + } + + result[1] = field.newDfp(new String(buf)); + + return result; + } + + /** Splits a {@link Dfp} into 2 {@link Dfp}'s such that their sum is equal to the input {@link Dfp}. + * @param a number to split + * @return two elements array containing the split number + */ + protected static Dfp[] split(final Dfp a) { + final Dfp[] result = new Dfp[2]; + final Dfp shift = a.multiply(a.power10K(a.getRadixDigits() / 2)); + result[0] = a.add(shift).subtract(shift); + result[1] = a.subtract(result[0]); + return result; + } + + /** Multiply two numbers that are split in to two pieces that are + * meant to be added together. + * Use binomial multiplication so ab = a0 b0 + a0 b1 + a1 b0 + a1 b1 + * Store the first term in result0, the rest in result1 + * @param a first factor of the multiplication, in split form + * @param b second factor of the multiplication, in split form + * @return a × b, in split form + */ + protected static Dfp[] splitMult(final Dfp[] a, final Dfp[] b) { + final Dfp[] result = new Dfp[2]; + + result[1] = a[0].getZero(); + result[0] = a[0].multiply(b[0]); + + /* If result[0] is infinite or zero, don't compute result[1]. + * Attempting to do so may produce NaNs. + */ + + if (result[0].classify() == Dfp.INFINITE || result[0].equals(result[1])) { + return result; + } + + result[1] = a[0].multiply(b[1]).add(a[1].multiply(b[0])).add(a[1].multiply(b[1])); + + return result; + } + + /** Divide two numbers that are split in to two pieces that are meant to be added together. + * Inverse of split multiply above: + * (a+b) / (c+d) = (a/c) + ( (bc-ad)/(c**2+cd) ) + * @param a dividend, in split form + * @param b divisor, in split form + * @return a / b, in split form + */ + protected static Dfp[] splitDiv(final Dfp[] a, final Dfp[] b) { + final Dfp[] result; + + result = new Dfp[2]; + + result[0] = a[0].divide(b[0]); + result[1] = a[1].multiply(b[0]).subtract(a[0].multiply(b[1])); + result[1] = result[1].divide(b[0].multiply(b[0]).add(b[0].multiply(b[1]))); + + return result; + } + + /** Raise a split base to the a power. + * @param base number to raise + * @param a power + * @return basea + */ + protected static Dfp splitPow(final Dfp[] base, int a) { + boolean invert = false; + + Dfp[] r = new Dfp[2]; + + Dfp[] result = new Dfp[2]; + result[0] = base[0].getOne(); + result[1] = base[0].getZero(); + + if (a == 0) { + // Special case a = 0 + return result[0].add(result[1]); + } + + if (a < 0) { + // If a is less than zero + invert = true; + a = -a; + } + + // Exponentiate by successive squaring + do { + r[0] = new Dfp(base[0]); + r[1] = new Dfp(base[1]); + int trial = 1; + + int prevtrial; + while (true) { + prevtrial = trial; + trial *= 2; + if (trial > a) { + break; + } + r = splitMult(r, r); + } + + trial = prevtrial; + + a -= trial; + result = splitMult(result, r); + + } while (a >= 1); + + result[0] = result[0].add(result[1]); + + if (invert) { + result[0] = base[0].getOne().divide(result[0]); + } + + return result[0]; + + } + + /** Raises base to the power a by successive squaring. + * @param base number to raise + * @param a power + * @return basea + */ + public static Dfp pow(Dfp base, int a) + { + boolean invert = false; + + Dfp result = base.getOne(); + + if (a == 0) { + // Special case + return result; + } + + if (a < 0) { + invert = true; + a = -a; + } + + // Exponentiate by successive squaring + do { + Dfp r = new Dfp(base); + Dfp prevr; + int trial = 1; + int prevtrial; + + do { + prevr = new Dfp(r); + prevtrial = trial; + r = r.multiply(r); + trial *= 2; + } while (a>trial); + + r = prevr; + trial = prevtrial; + + a -= trial; + result = result.multiply(r); + + } while (a >= 1); + + if (invert) { + result = base.getOne().divide(result); + } + + return base.newInstance(result); + + } + + /** Computes e to the given power. + * a is broken into two parts, such that a = n+m where n is an integer. + * We use pow() to compute en and a Taylor series to compute + * em. We return e*n × em + * @param a power at which e should be raised + * @return ea + */ + public static Dfp exp(final Dfp a) { + + final Dfp inta = a.rint(); + final Dfp fraca = a.subtract(inta); + + final int ia = inta.intValue(); + if (ia > 2147483646) { + // return +Infinity + return a.newInstance((byte)1, Dfp.INFINITE); + } + + if (ia < -2147483646) { + // return 0; + return a.newInstance(); + } + + final Dfp einta = splitPow(a.getField().getESplit(), ia); + final Dfp efraca = expInternal(fraca); + + return einta.multiply(efraca); + } + + /** Computes e to the given power. + * Where -1 < a < 1. Use the classic Taylor series. 1 + x**2/2! + x**3/3! + x**4/4! ... + * @param a power at which e should be raised + * @return ea + */ + protected static Dfp expInternal(final Dfp a) { + Dfp y = a.getOne(); + Dfp x = a.getOne(); + Dfp fact = a.getOne(); + Dfp py = new Dfp(y); + + for (int i = 1; i < 90; i++) { + x = x.multiply(a); + fact = fact.divide(i); + y = y.add(x.multiply(fact)); + if (y.equals(py)) { + break; + } + py = new Dfp(y); + } + + return y; + } + + /** Returns the natural logarithm of a. + * a is first split into three parts such that a = (10000^h)(2^j)k. + * ln(a) is computed by ln(a) = ln(5)*h + ln(2)*(h+j) + ln(k) + * k is in the range 2/3 < k <4/3 and is passed on to a series expansion. + * @param a number from which logarithm is requested + * @return log(a) + */ + public static Dfp log(Dfp a) { + int lr; + Dfp x; + int ix; + int p2 = 0; + + // Check the arguments somewhat here + if (a.equals(a.getZero()) || a.lessThan(a.getZero()) || a.isNaN()) { + // negative, zero or NaN + a.getField().setIEEEFlagsBits(DfpField.FLAG_INVALID); + return a.dotrap(DfpField.FLAG_INVALID, "ln", a, a.newInstance((byte)1, Dfp.QNAN)); + } + + if (a.classify() == Dfp.INFINITE) { + return a; + } + + x = new Dfp(a); + lr = x.log10K(); + + x = x.divide(pow(a.newInstance(10000), lr)); /* This puts x in the range 0-10000 */ + ix = x.floor().intValue(); + + while (ix > 2) { + ix >>= 1; + p2++; + } + + + Dfp[] spx = split(x); + Dfp[] spy = new Dfp[2]; + spy[0] = pow(a.getTwo(), p2); // use spy[0] temporarily as a divisor + spx[0] = spx[0].divide(spy[0]); + spx[1] = spx[1].divide(spy[0]); + + spy[0] = a.newInstance("1.33333"); // Use spy[0] for comparison + while (spx[0].add(spx[1]).greaterThan(spy[0])) { + spx[0] = spx[0].divide(2); + spx[1] = spx[1].divide(2); + p2++; + } + + // X is now in the range of 2/3 < x < 4/3 + Dfp[] spz = logInternal(spx); + + spx[0] = a.newInstance(new StringBuilder().append(p2+4*lr).toString()); + spx[1] = a.getZero(); + spy = splitMult(a.getField().getLn2Split(), spx); + + spz[0] = spz[0].add(spy[0]); + spz[1] = spz[1].add(spy[1]); + + spx[0] = a.newInstance(new StringBuilder().append(4*lr).toString()); + spx[1] = a.getZero(); + spy = splitMult(a.getField().getLn5Split(), spx); + + spz[0] = spz[0].add(spy[0]); + spz[1] = spz[1].add(spy[1]); + + return a.newInstance(spz[0].add(spz[1])); + + } + + /** Computes the natural log of a number between 0 and 2. + * Let f(x) = ln(x), + * + * We know that f'(x) = 1/x, thus from Taylor's theorum we have: + * + * ----- n+1 n + * f(x) = \ (-1) (x - 1) + * / ---------------- for 1 <= n <= infinity + * ----- n + * + * or + * 2 3 4 + * (x-1) (x-1) (x-1) + * ln(x) = (x-1) - ----- + ------ - ------ + ... + * 2 3 4 + * + * alternatively, + * + * 2 3 4 + * x x x + * ln(x+1) = x - - + - - - + ... + * 2 3 4 + * + * This series can be used to compute ln(x), but it converges too slowly. + * + * If we substitute -x for x above, we get + * + * 2 3 4 + * x x x + * ln(1-x) = -x - - - - - - + ... + * 2 3 4 + * + * Note that all terms are now negative. Because the even powered ones + * absorbed the sign. Now, subtract the series above from the previous + * one to get ln(x+1) - ln(1-x). Note the even terms cancel out leaving + * only the odd ones + * + * 3 5 7 + * 2x 2x 2x + * ln(x+1) - ln(x-1) = 2x + --- + --- + ---- + ... + * 3 5 7 + * + * By the property of logarithms that ln(a) - ln(b) = ln (a/b) we have: + * + * 3 5 7 + * x+1 / x x x \ + * ln ----- = 2 * | x + ---- + ---- + ---- + ... | + * x-1 \ 3 5 7 / + * + * But now we want to find ln(a), so we need to find the value of x + * such that a = (x+1)/(x-1). This is easily solved to find that + * x = (a-1)/(a+1). + * @param a number from which logarithm is requested, in split form + * @return log(a) + */ + protected static Dfp[] logInternal(final Dfp a[]) { + + /* Now we want to compute x = (a-1)/(a+1) but this is prone to + * loss of precision. So instead, compute x = (a/4 - 1/4) / (a/4 + 1/4) + */ + Dfp t = a[0].divide(4).add(a[1].divide(4)); + Dfp x = t.add(a[0].newInstance("-0.25")).divide(t.add(a[0].newInstance("0.25"))); + + Dfp y = new Dfp(x); + Dfp num = new Dfp(x); + Dfp py = new Dfp(y); + int den = 1; + for (int i = 0; i < 10000; i++) { + num = num.multiply(x); + num = num.multiply(x); + den += 2; + t = num.divide(den); + y = y.add(t); + if (y.equals(py)) { + break; + } + py = new Dfp(y); + } + + y = y.multiply(a[0].getTwo()); + + return split(y); + + } + + /** Computes x to the y power.
+ * + * Uses the following method:
+ * + *
+ * + * Special Cases
+ *
Another floating point class. This one is built using radix 10000 + * which is 104, so its almost decimal.
+ * + *The design goals here are: + *
Trade offs: + *
Numbers are represented in the following form: + *
+ * n = sign × mant × (radix)exp; + *+ * where sign is ±1, mantissa represents a fractional number between + * zero and one. mant[0] is the least significant digit. + * exp is in the range of -32767 to 32768 + * + *
IEEE 854-1987 Notes and differences
+ * + *IEEE 854 requires the radix to be either 2 or 10. The radix here is + * 10000, so that requirement is not met, but it is possible that a + * subclassed can be made to make it behave as a radix 10 + * number. It is my opinion that if it looks and behaves as a radix + * 10 number then it is one and that requirement would be met.
+ * + *The radix of 10000 was chosen because it should be faster to operate + * on 4 decimal digits at once instead of one at a time. Radix 10 behavior + * can be realized by add an additional rounding step to ensure that + * the number of decimal digits represented is constant.
+ * + *The IEEE standard specifically leaves out internal data encoding, + * so it is reasonable to conclude that such a subclass of this radix + * 10000 system is merely an encoding of a radix 10 system.
+ * + *IEEE 854 also specifies the existence of "sub-normal" numbers. This + * class does not contain any such entities. The most significant radix + * 10000 digit is always non-zero. Instead, we support "gradual underflow" + * by raising the underflow flag for numbers less with exponent less than + * expMin, but don't flush to zero until the exponent reaches MIN_EXP-digits. + * Thus the smallest number we can represent would be: + * 1E(-(MIN_EXP-digits-1)∗4), eg, for digits=5, MIN_EXP=-32767, that would + * be 1e-131092.
+ * + *IEEE 854 defines that the implied radix point lies just to the right + * of the most significant digit and to the left of the remaining digits. + * This implementation puts the implied radix point to the left of all + * digits including the most significant one. The most significant digit + * here is the one just to the right of the radix point. This is a fine + * detail and is really only a matter of definition. Any side effects of + * this can be rendered invisible by a subclass.
+ * + */ +package com.fr.third.org.apache.commons.math3.dfp; diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/AbstractIntegerDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/AbstractIntegerDistribution.java new file mode 100644 index 000000000..4b8806fae --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/AbstractIntegerDistribution.java @@ -0,0 +1,254 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.distribution; + +import java.io.Serializable; + +import com.fr.third.org.apache.commons.math3.exception.MathInternalError; +import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException; +import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException; +import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException; +import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats; +import com.fr.third.org.apache.commons.math3.random.RandomDataImpl; +import com.fr.third.org.apache.commons.math3.random.RandomGenerator; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Base class for integer-valued discrete distributions. Default + * implementations are provided for some of the methods that do not vary + * from distribution to distribution. + * + */ +public abstract class AbstractIntegerDistribution implements IntegerDistribution, Serializable { + + /** Serializable version identifier */ + private static final long serialVersionUID = -1146319659338487221L; + + /** + * RandomData instance used to generate samples from the distribution. + * @deprecated As of 3.1, to be removed in 4.0. Please use the + * {@link #random} instance variable instead. + */ + @Deprecated + protected final RandomDataImpl randomData = + new RandomDataImpl(); + + /** + * RNG instance used to generate samples from the distribution. + * @since 3.1 + */ + protected final RandomGenerator random; + + /** + * @deprecated As of 3.1, to be removed in 4.0. Please use + * {@link #AbstractIntegerDistribution(RandomGenerator)} instead. + */ + @Deprecated + protected AbstractIntegerDistribution() { + // Legacy users are only allowed to access the deprecated "randomData". + // New users are forbidden to use this constructor. + random = null; + } + + /** + * @param rng Random number generator. + * @since 3.1 + */ + protected AbstractIntegerDistribution(RandomGenerator rng) { + random = rng; + } + + /** + * {@inheritDoc} + * + * The default implementation uses the identity + *{@code P(x0 < X <= x1) = P(X <= x1) - P(X <= x0)}
+ */ + public double cumulativeProbability(int x0, int x1) throws NumberIsTooLargeException { + if (x1 < x0) { + throw new NumberIsTooLargeException(LocalizedFormats.LOWER_ENDPOINT_ABOVE_UPPER_ENDPOINT, + x0, x1, true); + } + return cumulativeProbability(x1) - cumulativeProbability(x0); + } + + /** + * {@inheritDoc} + * + * The default implementation returns + *inf{x in Z | P(X<=x) >= p}.
+ *
+ * @param p the cumulative probability
+ * @param lower a value satisfying {@code cumulativeProbability(lower) < p}
+ * @param upper a value satisfying {@code p <= cumulativeProbability(upper)}
+ * @return the smallest {@code p}-quantile of this distribution
+ */
+ protected int solveInverseCumulativeProbability(final double p, int lower, int upper) {
+ while (lower + 1 < upper) {
+ int xm = (lower + upper) / 2;
+ if (xm < lower || xm > upper) {
+ /*
+ * Overflow.
+ * There will never be an overflow in both calculation methods
+ * for xm at the same time
+ */
+ xm = lower + (upper - lower) / 2;
+ }
+
+ double pm = checkedCumulativeProbability(xm);
+ if (pm >= p) {
+ upper = xm;
+ } else {
+ lower = xm;
+ }
+ }
+ return upper;
+ }
+
+ /** {@inheritDoc} */
+ public void reseedRandomGenerator(long seed) {
+ random.setSeed(seed);
+ randomData.reSeed(seed);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The default implementation uses the
+ *
+ * inversion method.
+ */
+ public int sample() {
+ return inverseCumulativeProbability(random.nextDouble());
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The default implementation generates the sample by calling
+ * {@link #sample()} in a loop.
+ */
+ public int[] sample(int sampleSize) {
+ if (sampleSize <= 0) {
+ throw new NotStrictlyPositiveException(
+ LocalizedFormats.NUMBER_OF_SAMPLES, sampleSize);
+ }
+ int[] out = new int[sampleSize];
+ for (int i = 0; i < sampleSize; i++) {
+ out[i] = sample();
+ }
+ return out;
+ }
+
+ /**
+ * Computes the cumulative probability function and checks for {@code NaN}
+ * values returned. Throws {@code MathInternalError} if the value is
+ * {@code NaN}. Rethrows any exception encountered evaluating the cumulative
+ * probability function. Throws {@code MathInternalError} if the cumulative
+ * probability function returns {@code NaN}.
+ *
+ * @param argument input value
+ * @return the cumulative probability
+ * @throws MathInternalError if the cumulative probability is {@code NaN}
+ */
+ private double checkedCumulativeProbability(int argument)
+ throws MathInternalError {
+ double result = Double.NaN;
+ result = cumulativeProbability(argument);
+ if (Double.isNaN(result)) {
+ throw new MathInternalError(LocalizedFormats
+ .DISCRETE_CUMULATIVE_PROBABILITY_RETURNED_NAN, argument);
+ }
+ return result;
+ }
+
+ /**
+ * For a random variable {@code X} whose values are distributed according to
+ * this distribution, this method returns {@code log(P(X = x))}, where
+ * {@code log} is the natural logarithm. In other words, this method
+ * represents the logarithm of the probability mass function (PMF) for the
+ * distribution. Note that due to the floating point precision and
+ * under/overflow issues, this method will for some distributions be more
+ * precise and faster than computing the logarithm of
+ * {@link #probability(int)}.
+ * + * The default implementation simply computes the logarithm of {@code probability(x)}.
+ * + * @param x the point at which the PMF is evaluated + * @return the logarithm of the value of the probability mass function at {@code x} + */ + public double logProbability(int x) { + return FastMath.log(probability(x)); + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/AbstractMultivariateRealDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/AbstractMultivariateRealDistribution.java new file mode 100644 index 000000000..8d9598df9 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/AbstractMultivariateRealDistribution.java @@ -0,0 +1,70 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.distribution; + +import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException; +import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats; +import com.fr.third.org.apache.commons.math3.random.RandomGenerator; + +/** + * Base class for multivariate probability distributions. + * + * @since 3.1 + */ +public abstract class AbstractMultivariateRealDistribution + implements MultivariateRealDistribution { + /** RNG instance used to generate samples from the distribution. */ + protected final RandomGenerator random; + /** The number of dimensions or columns in the multivariate distribution. */ + private final int dimension; + + /** + * @param rng Random number generator. + * @param n Number of dimensions. + */ + protected AbstractMultivariateRealDistribution(RandomGenerator rng, + int n) { + random = rng; + dimension = n; + } + + /** {@inheritDoc} */ + public void reseedRandomGenerator(long seed) { + random.setSeed(seed); + } + + /** {@inheritDoc} */ + public int getDimension() { + return dimension; + } + + /** {@inheritDoc} */ + public abstract double[] sample(); + + /** {@inheritDoc} */ + public double[][] sample(final int sampleSize) { + if (sampleSize <= 0) { + throw new NotStrictlyPositiveException(LocalizedFormats.NUMBER_OF_SAMPLES, + sampleSize); + } + final double[][] out = new double[sampleSize][dimension]; + for (int i = 0; i < sampleSize; i++) { + out[i] = sample(); + } + return out; + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/AbstractRealDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/AbstractRealDistribution.java new file mode 100644 index 000000000..0bfcc4c39 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/AbstractRealDistribution.java @@ -0,0 +1,308 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.distribution; + +import java.io.Serializable; + +import com.fr.third.org.apache.commons.math3.analysis.UnivariateFunction; +import com.fr.third.org.apache.commons.math3.analysis.solvers.UnivariateSolverUtils; +import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException; +import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException; +import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException; +import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats; +import com.fr.third.org.apache.commons.math3.random.RandomDataImpl; +import com.fr.third.org.apache.commons.math3.random.RandomGenerator; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Base class for probability distributions on the reals. + * Default implementations are provided for some of the methods + * that do not vary from distribution to distribution. + * + * @since 3.0 + */ +public abstract class AbstractRealDistribution +implements RealDistribution, Serializable { + /** Default accuracy. */ + public static final double SOLVER_DEFAULT_ABSOLUTE_ACCURACY = 1e-6; + /** Serializable version identifier */ + private static final long serialVersionUID = -38038050983108802L; + /** + * RandomData instance used to generate samples from the distribution. + * @deprecated As of 3.1, to be removed in 4.0. Please use the + * {@link #random} instance variable instead. + */ + @Deprecated + protected RandomDataImpl randomData = + new RandomDataImpl(); + + /** + * RNG instance used to generate samples from the distribution. + * @since 3.1 + */ + protected final RandomGenerator random; + + /** Solver absolute accuracy for inverse cumulative computation */ + private double solverAbsoluteAccuracy = SOLVER_DEFAULT_ABSOLUTE_ACCURACY; + + /** + * @deprecated As of 3.1, to be removed in 4.0. Please use + * {@link #AbstractRealDistribution(RandomGenerator)} instead. + */ + @Deprecated + protected AbstractRealDistribution() { + // Legacy users are only allowed to access the deprecated "randomData". + // New users are forbidden to use this constructor. + random = null; + } + /** + * @param rng Random number generator. + * @since 3.1 + */ + protected AbstractRealDistribution(RandomGenerator rng) { + random = rng; + } + + /** + * {@inheritDoc} + * + * The default implementation uses the identity + *{@code P(x0 < X <= x1) = P(X <= x1) - P(X <= x0)}
+ * + * @deprecated As of 3.1 (to be removed in 4.0). Please use + * {@link #probability(double,double)} instead. + */ + @Deprecated + public double cumulativeProbability(double x0, double x1) throws NumberIsTooLargeException { + return probability(x0, x1); + } + + /** + * For a random variable {@code X} whose values are distributed according + * to this distribution, this method returns {@code P(x0 < X <= x1)}. + * + * @param x0 Lower bound (excluded). + * @param x1 Upper bound (included). + * @return the probability that a random variable with this distribution + * takes a value between {@code x0} and {@code x1}, excluding the lower + * and including the upper endpoint. + * @throws NumberIsTooLargeException if {@code x0 > x1}. + * + * The default implementation uses the identity + * {@code P(x0 < X <= x1) = P(X <= x1) - P(X <= x0)} + * + * @since 3.1 + */ + public double probability(double x0, + double x1) { + if (x0 > x1) { + throw new NumberIsTooLargeException(LocalizedFormats.LOWER_ENDPOINT_ABOVE_UPPER_ENDPOINT, + x0, x1, true); + } + return cumulativeProbability(x1) - cumulativeProbability(x0); + } + + /** + * {@inheritDoc} + * + * The default implementation returns + *+ * Note: this constructor will implicitly create an instance of + * {@link Well19937c} as random generator to be used for sampling only (see + * {@link #sample()} and {@link #sample(int)}). In case no sampling is + * needed for the created distribution, it is advised to pass {@code null} + * as random generator via the appropriate constructors to avoid the + * additional initialisation overhead. + * + * @param alpha First shape parameter (must be positive). + * @param beta Second shape parameter (must be positive). + */ + public BetaDistribution(double alpha, double beta) { + this(alpha, beta, DEFAULT_INVERSE_ABSOLUTE_ACCURACY); + } + + /** + * Build a new instance. + *
+ * Note: this constructor will implicitly create an instance of + * {@link Well19937c} as random generator to be used for sampling only (see + * {@link #sample()} and {@link #sample(int)}). In case no sampling is + * needed for the created distribution, it is advised to pass {@code null} + * as random generator via the appropriate constructors to avoid the + * additional initialisation overhead. + * + * @param alpha First shape parameter (must be positive). + * @param beta Second shape parameter (must be positive). + * @param inverseCumAccuracy Maximum absolute error in inverse + * cumulative probability estimates (defaults to + * {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}). + * @since 2.1 + */ + public BetaDistribution(double alpha, double beta, double inverseCumAccuracy) { + this(new Well19937c(), alpha, beta, inverseCumAccuracy); + } + + /** + * Creates a β distribution. + * + * @param rng Random number generator. + * @param alpha First shape parameter (must be positive). + * @param beta Second shape parameter (must be positive). + * @since 3.3 + */ + public BetaDistribution(RandomGenerator rng, double alpha, double beta) { + this(rng, alpha, beta, DEFAULT_INVERSE_ABSOLUTE_ACCURACY); + } + + /** + * Creates a β distribution. + * + * @param rng Random number generator. + * @param alpha First shape parameter (must be positive). + * @param beta Second shape parameter (must be positive). + * @param inverseCumAccuracy Maximum absolute error in inverse + * cumulative probability estimates (defaults to + * {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}). + * @since 3.1 + */ + public BetaDistribution(RandomGenerator rng, + double alpha, + double beta, + double inverseCumAccuracy) { + super(rng); + + this.alpha = alpha; + this.beta = beta; + z = Double.NaN; + solverAbsoluteAccuracy = inverseCumAccuracy; + } + + /** + * Access the first shape parameter, {@code alpha}. + * + * @return the first shape parameter. + */ + public double getAlpha() { + return alpha; + } + + /** + * Access the second shape parameter, {@code beta}. + * + * @return the second shape parameter. + */ + public double getBeta() { + return beta; + } + + /** Recompute the normalization factor. */ + private void recomputeZ() { + if (Double.isNaN(z)) { + z = Gamma.logGamma(alpha) + Gamma.logGamma(beta) - Gamma.logGamma(alpha + beta); + } + } + + /** {@inheritDoc} */ + public double density(double x) { + final double logDensity = logDensity(x); + return logDensity == Double.NEGATIVE_INFINITY ? 0 : FastMath.exp(logDensity); + } + + /** {@inheritDoc} **/ + @Override + public double logDensity(double x) { + recomputeZ(); + if (x < 0 || x > 1) { + return Double.NEGATIVE_INFINITY; + } else if (x == 0) { + if (alpha < 1) { + throw new NumberIsTooSmallException(LocalizedFormats.CANNOT_COMPUTE_BETA_DENSITY_AT_0_FOR_SOME_ALPHA, alpha, 1, false); + } + return Double.NEGATIVE_INFINITY; + } else if (x == 1) { + if (beta < 1) { + throw new NumberIsTooSmallException(LocalizedFormats.CANNOT_COMPUTE_BETA_DENSITY_AT_1_FOR_SOME_BETA, beta, 1, false); + } + return Double.NEGATIVE_INFINITY; + } else { + double logX = FastMath.log(x); + double log1mX = FastMath.log1p(-x); + return (alpha - 1) * logX + (beta - 1) * log1mX - z; + } + } + + /** {@inheritDoc} */ + public double cumulativeProbability(double x) { + if (x <= 0) { + return 0; + } else if (x >= 1) { + return 1; + } else { + return Beta.regularizedBeta(x, alpha, beta); + } + } + + /** + * Return the absolute accuracy setting of the solver used to estimate + * inverse cumulative probabilities. + * + * @return the solver absolute accuracy. + * @since 2.1 + */ + @Override + protected double getSolverAbsoluteAccuracy() { + return solverAbsoluteAccuracy; + } + + /** + * {@inheritDoc} + * + * For first shape parameter {@code alpha} and second shape parameter + * {@code beta}, the mean is {@code alpha / (alpha + beta)}. + */ + public double getNumericalMean() { + final double a = getAlpha(); + return a / (a + getBeta()); + } + + /** + * {@inheritDoc} + * + * For first shape parameter {@code alpha} and second shape parameter + * {@code beta}, the variance is + * {@code (alpha * beta) / [(alpha + beta)^2 * (alpha + beta + 1)]}. + */ + public double getNumericalVariance() { + final double a = getAlpha(); + final double b = getBeta(); + final double alphabetasum = a + b; + return (a * b) / ((alphabetasum * alphabetasum) * (alphabetasum + 1)); + } + + /** + * {@inheritDoc} + * + * The lower bound of the support is always 0 no matter the parameters. + * + * @return lower bound of the support (always 0) + */ + public double getSupportLowerBound() { + return 0; + } + + /** + * {@inheritDoc} + * + * The upper bound of the support is always 1 no matter the parameters. + * + * @return upper bound of the support (always 1) + */ + public double getSupportUpperBound() { + return 1; + } + + /** {@inheritDoc} */ + public boolean isSupportLowerBoundInclusive() { + return false; + } + + /** {@inheritDoc} */ + public boolean isSupportUpperBoundInclusive() { + return false; + } + + /** + * {@inheritDoc} + * + * The support of this distribution is connected. + * + * @return {@code true} + */ + public boolean isSupportConnected() { + return true; + } + + + /** {@inheritDoc} + *
+ * Sampling is performed using Cheng algorithms: + *
+ *+ * R. C. H. Cheng, "Generating beta variates with nonintegral shape parameters.". + * Communications of the ACM, 21, 317–322, 1978. + *
+ */ + @Override + public double sample() { + return ChengBetaSampler.sample(random, alpha, beta); + } + + /** Utility class implementing Cheng's algorithms for beta distribution sampling. + *+ * R. C. H. Cheng, "Generating beta variates with nonintegral shape parameters.". + * Communications of the ACM, 21, 317–322, 1978. + *
+ * @since 3.6 + */ + private static final class ChengBetaSampler { + + /** + * Returns one sample using Cheng's sampling algorithm. + * @param random random generator to use + * @param alpha distribution first shape parameter + * @param beta distribution second shape parameter + * @return sampled value + */ + static double sample(RandomGenerator random, final double alpha, final double beta) { + final double a = FastMath.min(alpha, beta); + final double b = FastMath.max(alpha, beta); + + if (a > 1) { + return algorithmBB(random, alpha, a, b); + } else { + return algorithmBC(random, alpha, b, a); + } + } + + /** + * Returns one sample using Cheng's BB algorithm, when both α and β are greater than 1. + * @param random random generator to use + * @param a0 distribution first shape parameter (α) + * @param a min(α, β) where α, β are the two distribution shape parameters + * @param b max(α, β) where α, β are the two distribution shape parameters + * @return sampled value + */ + private static double algorithmBB(RandomGenerator random, + final double a0, + final double a, + final double b) { + final double alpha = a + b; + final double beta = FastMath.sqrt((alpha - 2.) / (2. * a * b - alpha)); + final double gamma = a + 1. / beta; + + double r; + double w; + double t; + do { + final double u1 = random.nextDouble(); + final double u2 = random.nextDouble(); + final double v = beta * (FastMath.log(u1) - FastMath.log1p(-u1)); + w = a * FastMath.exp(v); + final double z = u1 * u1 * u2; + r = gamma * v - 1.3862944; + final double s = a + r - w; + if (s + 2.609438 >= 5 * z) { + break; + } + + t = FastMath.log(z); + if (s >= t) { + break; + } + } while (r + alpha * (FastMath.log(alpha) - FastMath.log(b + w)) < t); + + w = FastMath.min(w, Double.MAX_VALUE); + return Precision.equals(a, a0) ? w / (b + w) : b / (b + w); + } + + /** + * Returns one sample using Cheng's BC algorithm, when at least one of α and β is smaller than 1. + * @param random random generator to use + * @param a0 distribution first shape parameter (α) + * @param a max(α, β) where α, β are the two distribution shape parameters + * @param b min(α, β) where α, β are the two distribution shape parameters + * @return sampled value + */ + private static double algorithmBC(RandomGenerator random, + final double a0, + final double a, + final double b) { + final double alpha = a + b; + final double beta = 1. / b; + final double delta = 1. + a - b; + final double k1 = delta * (0.0138889 + 0.0416667 * b) / (a * beta - 0.777778); + final double k2 = 0.25 + (0.5 + 0.25 / delta) * b; + + double w; + for (;;) { + final double u1 = random.nextDouble(); + final double u2 = random.nextDouble(); + final double y = u1 * u2; + final double z = u1 * y; + if (u1 < 0.5) { + if (0.25 * u2 + z - y >= k1) { + continue; + } + } else { + if (z <= 0.25) { + final double v = beta * (FastMath.log(u1) - FastMath.log1p(-u1)); + w = a * FastMath.exp(v); + break; + } + + if (z >= k2) { + continue; + } + } + + final double v = beta * (FastMath.log(u1) - FastMath.log1p(-u1)); + w = a * FastMath.exp(v); + if (alpha * (FastMath.log(alpha) - FastMath.log(b + w) + v) - 1.3862944 >= FastMath.log(z)) { + break; + } + } + + w = FastMath.min(w, Double.MAX_VALUE); + return Precision.equals(a, a0) ? w / (b + w) : b / (b + w); + } + + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/BinomialDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/BinomialDistribution.java new file mode 100644 index 000000000..9749bdf45 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/BinomialDistribution.java @@ -0,0 +1,198 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.distribution; + +import com.fr.third.org.apache.commons.math3.exception.NotPositiveException; +import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException; +import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats; +import com.fr.third.org.apache.commons.math3.random.RandomGenerator; +import com.fr.third.org.apache.commons.math3.random.Well19937c; +import com.fr.third.org.apache.commons.math3.special.Beta; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Implementation of the binomial distribution. + * + * @see Binomial distribution (Wikipedia) + * @see Binomial Distribution (MathWorld) + */ +public class BinomialDistribution extends AbstractIntegerDistribution { + /** Serializable version identifier. */ + private static final long serialVersionUID = 6751309484392813623L; + /** The number of trials. */ + private final int numberOfTrials; + /** The probability of success. */ + private final double probabilityOfSuccess; + + /** + * Create a binomial distribution with the given number of trials and + * probability of success. + *+ * Note: this constructor will implicitly create an instance of + * {@link Well19937c} as random generator to be used for sampling only (see + * {@link #sample()} and {@link #sample(int)}). In case no sampling is + * needed for the created distribution, it is advised to pass {@code null} + * as random generator via the appropriate constructors to avoid the + * additional initialisation overhead. + * + * @param trials Number of trials. + * @param p Probability of success. + * @throws NotPositiveException if {@code trials < 0}. + * @throws OutOfRangeException if {@code p < 0} or {@code p > 1}. + */ + public BinomialDistribution(int trials, double p) { + this(new Well19937c(), trials, p); + } + + /** + * Creates a binomial distribution. + * + * @param rng Random number generator. + * @param trials Number of trials. + * @param p Probability of success. + * @throws NotPositiveException if {@code trials < 0}. + * @throws OutOfRangeException if {@code p < 0} or {@code p > 1}. + * @since 3.1 + */ + public BinomialDistribution(RandomGenerator rng, + int trials, + double p) { + super(rng); + + if (trials < 0) { + throw new NotPositiveException(LocalizedFormats.NUMBER_OF_TRIALS, + trials); + } + if (p < 0 || p > 1) { + throw new OutOfRangeException(p, 0, 1); + } + + probabilityOfSuccess = p; + numberOfTrials = trials; + } + + /** + * Access the number of trials for this distribution. + * + * @return the number of trials. + */ + public int getNumberOfTrials() { + return numberOfTrials; + } + + /** + * Access the probability of success for this distribution. + * + * @return the probability of success. + */ + public double getProbabilityOfSuccess() { + return probabilityOfSuccess; + } + + /** {@inheritDoc} */ + public double probability(int x) { + final double logProbability = logProbability(x); + return logProbability == Double.NEGATIVE_INFINITY ? 0 : FastMath.exp(logProbability); + } + + /** {@inheritDoc} **/ + @Override + public double logProbability(int x) { + if (numberOfTrials == 0) { + return (x == 0) ? 0. : Double.NEGATIVE_INFINITY; + } + double ret; + if (x < 0 || x > numberOfTrials) { + ret = Double.NEGATIVE_INFINITY; + } else { + ret = SaddlePointExpansion.logBinomialProbability(x, + numberOfTrials, probabilityOfSuccess, + 1.0 - probabilityOfSuccess); + } + return ret; + } + + /** {@inheritDoc} */ + public double cumulativeProbability(int x) { + double ret; + if (x < 0) { + ret = 0.0; + } else if (x >= numberOfTrials) { + ret = 1.0; + } else { + ret = 1.0 - Beta.regularizedBeta(probabilityOfSuccess, + x + 1.0, numberOfTrials - x); + } + return ret; + } + + /** + * {@inheritDoc} + * + * For {@code n} trials and probability parameter {@code p}, the mean is + * {@code n * p}. + */ + public double getNumericalMean() { + return numberOfTrials * probabilityOfSuccess; + } + + /** + * {@inheritDoc} + * + * For {@code n} trials and probability parameter {@code p}, the variance is + * {@code n * p * (1 - p)}. + */ + public double getNumericalVariance() { + final double p = probabilityOfSuccess; + return numberOfTrials * p * (1 - p); + } + + /** + * {@inheritDoc} + * + * The lower bound of the support is always 0 except for the probability + * parameter {@code p = 1}. + * + * @return lower bound of the support (0 or the number of trials) + */ + public int getSupportLowerBound() { + return probabilityOfSuccess < 1.0 ? 0 : numberOfTrials; + } + + /** + * {@inheritDoc} + * + * The upper bound of the support is the number of trials except for the + * probability parameter {@code p = 0}. + * + * @return upper bound of the support (number of trials or 0) + */ + public int getSupportUpperBound() { + return probabilityOfSuccess > 0.0 ? numberOfTrials : 0; + } + + /** + * {@inheritDoc} + * + * The support of this distribution is connected. + * + * @return {@code true} + */ + public boolean isSupportConnected() { + return true; + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/CauchyDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/CauchyDistribution.java new file mode 100644 index 000000000..c3251313f --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/CauchyDistribution.java @@ -0,0 +1,256 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.distribution; + +import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException; +import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException; +import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats; +import com.fr.third.org.apache.commons.math3.random.RandomGenerator; +import com.fr.third.org.apache.commons.math3.random.Well19937c; +import com.fr.third.org.apache.commons.math3.util.FastMath; + +/** + * Implementation of the Cauchy distribution. + * + * @see Cauchy distribution (Wikipedia) + * @see Cauchy Distribution (MathWorld) + * @since 1.1 (changed to concrete class in 3.0) + */ +public class CauchyDistribution extends AbstractRealDistribution { + /** + * Default inverse cumulative probability accuracy. + * @since 2.1 + */ + public static final double DEFAULT_INVERSE_ABSOLUTE_ACCURACY = 1e-9; + /** Serializable version identifier */ + private static final long serialVersionUID = 8589540077390120676L; + /** The median of this distribution. */ + private final double median; + /** The scale of this distribution. */ + private final double scale; + /** Inverse cumulative probability accuracy */ + private final double solverAbsoluteAccuracy; + + /** + * Creates a Cauchy distribution with the median equal to zero and scale + * equal to one. + */ + public CauchyDistribution() { + this(0, 1); + } + + /** + * Creates a Cauchy distribution using the given median and scale. + *
+ * Note: this constructor will implicitly create an instance of + * {@link Well19937c} as random generator to be used for sampling only (see + * {@link #sample()} and {@link #sample(int)}). In case no sampling is + * needed for the created distribution, it is advised to pass {@code null} + * as random generator via the appropriate constructors to avoid the + * additional initialisation overhead. + * + * @param median Median for this distribution. + * @param scale Scale parameter for this distribution. + */ + public CauchyDistribution(double median, double scale) { + this(median, scale, DEFAULT_INVERSE_ABSOLUTE_ACCURACY); + } + + /** + * Creates a Cauchy distribution using the given median and scale. + *
+ * Note: this constructor will implicitly create an instance of + * {@link Well19937c} as random generator to be used for sampling only (see + * {@link #sample()} and {@link #sample(int)}). In case no sampling is + * needed for the created distribution, it is advised to pass {@code null} + * as random generator via the appropriate constructors to avoid the + * additional initialisation overhead. + * + * @param median Median for this distribution. + * @param scale Scale parameter for this distribution. + * @param inverseCumAccuracy Maximum absolute error in inverse + * cumulative probability estimates + * (defaults to {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}). + * @throws NotStrictlyPositiveException if {@code scale <= 0}. + * @since 2.1 + */ + public CauchyDistribution(double median, double scale, + double inverseCumAccuracy) { + this(new Well19937c(), median, scale, inverseCumAccuracy); + } + + /** + * Creates a Cauchy distribution. + * + * @param rng Random number generator. + * @param median Median for this distribution. + * @param scale Scale parameter for this distribution. + * @throws NotStrictlyPositiveException if {@code scale <= 0}. + * @since 3.3 + */ + public CauchyDistribution(RandomGenerator rng, double median, double scale) { + this(rng, median, scale, DEFAULT_INVERSE_ABSOLUTE_ACCURACY); + } + + /** + * Creates a Cauchy distribution. + * + * @param rng Random number generator. + * @param median Median for this distribution. + * @param scale Scale parameter for this distribution. + * @param inverseCumAccuracy Maximum absolute error in inverse + * cumulative probability estimates + * (defaults to {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}). + * @throws NotStrictlyPositiveException if {@code scale <= 0}. + * @since 3.1 + */ + public CauchyDistribution(RandomGenerator rng, + double median, + double scale, + double inverseCumAccuracy) { + super(rng); + if (scale <= 0) { + throw new NotStrictlyPositiveException(LocalizedFormats.SCALE, scale); + } + this.scale = scale; + this.median = median; + solverAbsoluteAccuracy = inverseCumAccuracy; + } + + /** {@inheritDoc} */ + public double cumulativeProbability(double x) { + return 0.5 + (FastMath.atan((x - median) / scale) / FastMath.PI); + } + + /** + * Access the median. + * + * @return the median for this distribution. + */ + public double getMedian() { + return median; + } + + /** + * Access the scale parameter. + * + * @return the scale parameter for this distribution. + */ + public double getScale() { + return scale; + } + + /** {@inheritDoc} */ + public double density(double x) { + final double dev = x - median; + return (1 / FastMath.PI) * (scale / (dev * dev + scale * scale)); + } + + /** + * {@inheritDoc} + * + * Returns {@code Double.NEGATIVE_INFINITY} when {@code p == 0} + * and {@code Double.POSITIVE_INFINITY} when {@code p == 1}. + */ + @Override + public double inverseCumulativeProbability(double p) throws OutOfRangeException { + double ret; + if (p < 0 || p > 1) { + throw new OutOfRangeException(p, 0, 1); + } else if (p == 0) { + ret = Double.NEGATIVE_INFINITY; + } else if (p == 1) { + ret = Double.POSITIVE_INFINITY; + } else { + ret = median + scale * FastMath.tan(FastMath.PI * (p - .5)); + } + return ret; + } + + /** {@inheritDoc} */ + @Override + protected double getSolverAbsoluteAccuracy() { + return solverAbsoluteAccuracy; + } + + /** + * {@inheritDoc} + * + * The mean is always undefined no matter the parameters. + * + * @return mean (always Double.NaN) + */ + public double getNumericalMean() { + return Double.NaN; + } + + /** + * {@inheritDoc} + * + * The variance is always undefined no matter the parameters. + * + * @return variance (always Double.NaN) + */ + public double getNumericalVariance() { + return Double.NaN; + } + + /** + * {@inheritDoc} + * + * The lower bound of the support is always negative infinity no matter + * the parameters. + * + * @return lower bound of the support (always Double.NEGATIVE_INFINITY) + */ + public double getSupportLowerBound() { + return Double.NEGATIVE_INFINITY; + } + + /** + * {@inheritDoc} + * + * The upper bound of the support is always positive infinity no matter + * the parameters. + * + * @return upper bound of the support (always Double.POSITIVE_INFINITY) + */ + public double getSupportUpperBound() { + return Double.POSITIVE_INFINITY; + } + + /** {@inheritDoc} */ + public boolean isSupportLowerBoundInclusive() { + return false; + } + + /** {@inheritDoc} */ + public boolean isSupportUpperBoundInclusive() { + return false; + } + + /** + * {@inheritDoc} + * + * The support of this distribution is connected. + * + * @return {@code true} + */ + public boolean isSupportConnected() { + return true; + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/ChiSquaredDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/ChiSquaredDistribution.java new file mode 100644 index 000000000..dad721539 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/ChiSquaredDistribution.java @@ -0,0 +1,196 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.distribution; + +import com.fr.third.org.apache.commons.math3.random.RandomGenerator; +import com.fr.third.org.apache.commons.math3.random.Well19937c; + +/** + * Implementation of the chi-squared distribution. + * + * @see Chi-squared distribution (Wikipedia) + * @see Chi-squared Distribution (MathWorld) + */ +public class ChiSquaredDistribution extends AbstractRealDistribution { + /** + * Default inverse cumulative probability accuracy + * @since 2.1 + */ + public static final double DEFAULT_INVERSE_ABSOLUTE_ACCURACY = 1e-9; + /** Serializable version identifier */ + private static final long serialVersionUID = -8352658048349159782L; + /** Internal Gamma distribution. */ + private final GammaDistribution gamma; + /** Inverse cumulative probability accuracy */ + private final double solverAbsoluteAccuracy; + + /** + * Create a Chi-Squared distribution with the given degrees of freedom. + * + * @param degreesOfFreedom Degrees of freedom. + */ + public ChiSquaredDistribution(double degreesOfFreedom) { + this(degreesOfFreedom, DEFAULT_INVERSE_ABSOLUTE_ACCURACY); + } + + /** + * Create a Chi-Squared distribution with the given degrees of freedom and + * inverse cumulative probability accuracy. + *
+ * Note: this constructor will implicitly create an instance of + * {@link Well19937c} as random generator to be used for sampling only (see + * {@link #sample()} and {@link #sample(int)}). In case no sampling is + * needed for the created distribution, it is advised to pass {@code null} + * as random generator via the appropriate constructors to avoid the + * additional initialisation overhead. + * + * @param degreesOfFreedom Degrees of freedom. + * @param inverseCumAccuracy the maximum absolute error in inverse + * cumulative probability estimates (defaults to + * {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}). + * @since 2.1 + */ + public ChiSquaredDistribution(double degreesOfFreedom, + double inverseCumAccuracy) { + this(new Well19937c(), degreesOfFreedom, inverseCumAccuracy); + } + + /** + * Create a Chi-Squared distribution with the given degrees of freedom. + * + * @param rng Random number generator. + * @param degreesOfFreedom Degrees of freedom. + * @since 3.3 + */ + public ChiSquaredDistribution(RandomGenerator rng, double degreesOfFreedom) { + this(rng, degreesOfFreedom, DEFAULT_INVERSE_ABSOLUTE_ACCURACY); + } + + /** + * Create a Chi-Squared distribution with the given degrees of freedom and + * inverse cumulative probability accuracy. + * + * @param rng Random number generator. + * @param degreesOfFreedom Degrees of freedom. + * @param inverseCumAccuracy the maximum absolute error in inverse + * cumulative probability estimates (defaults to + * {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}). + * @since 3.1 + */ + public ChiSquaredDistribution(RandomGenerator rng, + double degreesOfFreedom, + double inverseCumAccuracy) { + super(rng); + + gamma = new GammaDistribution(degreesOfFreedom / 2, 2); + solverAbsoluteAccuracy = inverseCumAccuracy; + } + + /** + * Access the number of degrees of freedom. + * + * @return the degrees of freedom. + */ + public double getDegreesOfFreedom() { + return gamma.getShape() * 2.0; + } + + /** {@inheritDoc} */ + public double density(double x) { + return gamma.density(x); + } + + /** {@inheritDoc} **/ + @Override + public double logDensity(double x) { + return gamma.logDensity(x); + } + + /** {@inheritDoc} */ + public double cumulativeProbability(double x) { + return gamma.cumulativeProbability(x); + } + + /** {@inheritDoc} */ + @Override + protected double getSolverAbsoluteAccuracy() { + return solverAbsoluteAccuracy; + } + + /** + * {@inheritDoc} + * + * For {@code k} degrees of freedom, the mean is {@code k}. + */ + public double getNumericalMean() { + return getDegreesOfFreedom(); + } + + /** + * {@inheritDoc} + * + * @return {@code 2 * k}, where {@code k} is the number of degrees of freedom. + */ + public double getNumericalVariance() { + return 2 * getDegreesOfFreedom(); + } + + /** + * {@inheritDoc} + * + * The lower bound of the support is always 0 no matter the + * degrees of freedom. + * + * @return zero. + */ + public double getSupportLowerBound() { + return 0; + } + + /** + * {@inheritDoc} + * + * The upper bound of the support is always positive infinity no matter the + * degrees of freedom. + * + * @return {@code Double.POSITIVE_INFINITY}. + */ + public double getSupportUpperBound() { + return Double.POSITIVE_INFINITY; + } + + /** {@inheritDoc} */ + public boolean isSupportLowerBoundInclusive() { + return true; + } + + /** {@inheritDoc} */ + public boolean isSupportUpperBoundInclusive() { + return false; + } + + /** + * {@inheritDoc} + * + * The support of this distribution is connected. + * + * @return {@code true} + */ + public boolean isSupportConnected() { + return true; + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/ConstantRealDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/ConstantRealDistribution.java new file mode 100644 index 000000000..2fc5fc838 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/ConstantRealDistribution.java @@ -0,0 +1,122 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.distribution; + +import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException; + +/** + * Implementation of the constant real distribution. + * + * @since 3.4 + */ +public class ConstantRealDistribution extends AbstractRealDistribution { + + /** Serialization ID */ + private static final long serialVersionUID = -4157745166772046273L; + + /** Constant value of the distribution */ + private final double value; + + /** + * Create a constant real distribution with the given value. + * + * @param value the constant value of this distribution + */ + public ConstantRealDistribution(double value) { + super(null); // Avoid creating RandomGenerator + this.value = value; + } + + /** {@inheritDoc} */ + public double density(double x) { + return x == value ? 1 : 0; + } + + /** {@inheritDoc} */ + public double cumulativeProbability(double x) { + return x < value ? 0 : 1; + } + + /** {@inheritDoc} */ + @Override + public double inverseCumulativeProbability(final double p) + throws OutOfRangeException { + if (p < 0.0 || p > 1.0) { + throw new OutOfRangeException(p, 0, 1); + } + return value; + } + + /** + * {@inheritDoc} + */ + public double getNumericalMean() { + return value; + } + + /** + * {@inheritDoc} + */ + public double getNumericalVariance() { + return 0; + } + + /** + * {@inheritDoc} + */ + public double getSupportLowerBound() { + return value; + } + + /** + * {@inheritDoc} + */ + public double getSupportUpperBound() { + return value; + } + + /** {@inheritDoc} */ + public boolean isSupportLowerBoundInclusive() { + return true; + } + + /** {@inheritDoc} */ + public boolean isSupportUpperBoundInclusive() { + return true; + } + + /** + * {@inheritDoc} + */ + public boolean isSupportConnected() { + return true; + } + + /** {@inheritDoc} */ + @Override + public double sample() { + return value; + } + + /** + * Override with no-op (there is no generator). + * @param seed (ignored) + */ + @Override + public void reseedRandomGenerator(long seed) {} +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/EnumeratedDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/EnumeratedDistribution.java new file mode 100644 index 000000000..f63c554e7 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/EnumeratedDistribution.java @@ -0,0 +1,291 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.distribution; + +import java.io.Serializable; +import java.lang.reflect.Array; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import com.fr.third.org.apache.commons.math3.exception.MathArithmeticException; +import com.fr.third.org.apache.commons.math3.exception.NotANumberException; +import com.fr.third.org.apache.commons.math3.exception.NotFiniteNumberException; +import com.fr.third.org.apache.commons.math3.exception.NotPositiveException; +import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException; +import com.fr.third.org.apache.commons.math3.exception.NullArgumentException; +import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats; +import com.fr.third.org.apache.commons.math3.random.RandomGenerator; +import com.fr.third.org.apache.commons.math3.random.Well19937c; +import com.fr.third.org.apache.commons.math3.util.MathArrays; +import com.fr.third.org.apache.commons.math3.util.Pair; + +/** + *
A generic implementation of a + * + * discrete probability distribution (Wikipedia) over a finite sample space, + * based on an enumerated list of <value, probability> pairs. Input probabilities must all be non-negative, + * but zero values are allowed and their sum does not have to equal one. Constructors will normalize input + * probabilities to make them sum to one.
+ * + *The list of
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param pmf probability mass function enumerated as a list of For a random variable {@code X} whose values are distributed according to
+ * this distribution, this method returns {@code P(X = x)}. In other words,
+ * this method represents the probability mass function (PMF) for the
+ * distribution. Note that if {@code x1} and {@code x2} satisfy {@code x1.equals(x2)},
+ * or both are null, then {@code probability(x1) = probability(x2)}. Return the probability mass function as a list of Note that if duplicate and / or null values were provided to the constructor
+ * when creating this EnumeratedDistribution, the returned list will contain these
+ * values. If duplicates values exist, what is returned will not represent
+ * a pmf (i.e., it is up to the caller to consolidate duplicate mass points).
+ * If the requested samples fit in the specified array, it is returned
+ * therein. Otherwise, a new array is allocated with the runtime type of
+ * the specified array and the size of this collection.
+ *
+ * @param sampleSize the number of random values to generate.
+ * @param array the array to populate.
+ * @return an array representing the random sample.
+ * @throws NotStrictlyPositiveException if {@code sampleSize} is not positive.
+ * @throws NullArgumentException if {@code array} is null
+ */
+ public T[] sample(int sampleSize, final T[] array) throws NotStrictlyPositiveException {
+ if (sampleSize <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.NUMBER_OF_SAMPLES, sampleSize);
+ }
+
+ if (array == null) {
+ throw new NullArgumentException(LocalizedFormats.INPUT_ARRAY);
+ }
+
+ T[] out;
+ if (array.length < sampleSize) {
+ @SuppressWarnings("unchecked") // safe as both are of type T
+ final T[] unchecked = (T[]) Array.newInstance(array.getClass().getComponentType(), sampleSize);
+ out = unchecked;
+ } else {
+ out = array;
+ }
+
+ for (int i = 0; i < sampleSize; i++) {
+ out[i] = sample();
+ }
+
+ return out;
+
+ }
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/EnumeratedIntegerDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/EnumeratedIntegerDistribution.java
new file mode 100644
index 000000000..246139dd3
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/EnumeratedIntegerDistribution.java
@@ -0,0 +1,276 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException;
+import com.fr.third.org.apache.commons.math3.exception.MathArithmeticException;
+import com.fr.third.org.apache.commons.math3.exception.NotANumberException;
+import com.fr.third.org.apache.commons.math3.exception.NotFiniteNumberException;
+import com.fr.third.org.apache.commons.math3.exception.NotPositiveException;
+import com.fr.third.org.apache.commons.math3.random.RandomGenerator;
+import com.fr.third.org.apache.commons.math3.random.Well19937c;
+import com.fr.third.org.apache.commons.math3.util.Pair;
+
+/**
+ * Implementation of an integer-valued {@link EnumeratedDistribution}. Values with zero-probability are allowed but they do not extend the
+ * support.
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param singletons array of random variable values.
+ * @param probabilities array of probabilities.
+ * @throws DimensionMismatchException if
+ * {@code singletons.length != probabilities.length}
+ * @throws NotPositiveException if any of the probabilities are negative.
+ * @throws NotFiniteNumberException if any of the probabilities are infinite.
+ * @throws NotANumberException if any of the probabilities are NaN.
+ * @throws MathArithmeticException all of the probabilities are 0.
+ */
+ public EnumeratedIntegerDistribution(final int[] singletons, final double[] probabilities)
+ throws DimensionMismatchException, NotPositiveException, MathArithmeticException,
+ NotFiniteNumberException, NotANumberException{
+ this(new Well19937c(), singletons, probabilities);
+ }
+
+ /**
+ * Create a discrete distribution using the given random number generator
+ * and probability mass function definition.
+ *
+ * @param rng random number generator.
+ * @param singletons array of random variable values.
+ * @param probabilities array of probabilities.
+ * @throws DimensionMismatchException if
+ * {@code singletons.length != probabilities.length}
+ * @throws NotPositiveException if any of the probabilities are negative.
+ * @throws NotFiniteNumberException if any of the probabilities are infinite.
+ * @throws NotANumberException if any of the probabilities are NaN.
+ * @throws MathArithmeticException all of the probabilities are 0.
+ */
+ public EnumeratedIntegerDistribution(final RandomGenerator rng,
+ final int[] singletons, final double[] probabilities)
+ throws DimensionMismatchException, NotPositiveException, MathArithmeticException,
+ NotFiniteNumberException, NotANumberException {
+ super(rng);
+ innerDistribution = new EnumeratedDistribution Implementation of a real-valued {@link EnumeratedDistribution}.
+ *
+ * Values with zero-probability are allowed but they do not extend the
+ * support.
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param singletons array of random variable values.
+ * @param probabilities array of probabilities.
+ * @throws DimensionMismatchException if
+ * {@code singletons.length != probabilities.length}
+ * @throws NotPositiveException if any of the probabilities are negative.
+ * @throws NotFiniteNumberException if any of the probabilities are infinite.
+ * @throws NotANumberException if any of the probabilities are NaN.
+ * @throws MathArithmeticException all of the probabilities are 0.
+ */
+ public EnumeratedRealDistribution(final double[] singletons, final double[] probabilities)
+ throws DimensionMismatchException, NotPositiveException, MathArithmeticException,
+ NotFiniteNumberException, NotANumberException {
+ this(new Well19937c(), singletons, probabilities);
+ }
+
+ /**
+ * Create a discrete real-valued distribution using the given random number generator
+ * and probability mass function enumeration.
+ *
+ * @param rng random number generator.
+ * @param singletons array of random variable values.
+ * @param probabilities array of probabilities.
+ * @throws DimensionMismatchException if
+ * {@code singletons.length != probabilities.length}
+ * @throws NotPositiveException if any of the probabilities are negative.
+ * @throws NotFiniteNumberException if any of the probabilities are infinite.
+ * @throws NotANumberException if any of the probabilities are NaN.
+ * @throws MathArithmeticException all of the probabilities are 0.
+ */
+ public EnumeratedRealDistribution(final RandomGenerator rng,
+ final double[] singletons, final double[] probabilities)
+ throws DimensionMismatchException, NotPositiveException, MathArithmeticException,
+ NotFiniteNumberException, NotANumberException {
+ super(rng);
+
+ innerDistribution = new EnumeratedDistribution
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param mean mean of this distribution.
+ */
+ public ExponentialDistribution(double mean) {
+ this(mean, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
+ }
+
+ /**
+ * Create an exponential distribution with the given mean.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param mean Mean of this distribution.
+ * @param inverseCumAccuracy Maximum absolute error in inverse
+ * cumulative probability estimates (defaults to
+ * {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}).
+ * @throws NotStrictlyPositiveException if {@code mean <= 0}.
+ * @since 2.1
+ */
+ public ExponentialDistribution(double mean, double inverseCumAccuracy) {
+ this(new Well19937c(), mean, inverseCumAccuracy);
+ }
+
+ /**
+ * Creates an exponential distribution.
+ *
+ * @param rng Random number generator.
+ * @param mean Mean of this distribution.
+ * @throws NotStrictlyPositiveException if {@code mean <= 0}.
+ * @since 3.3
+ */
+ public ExponentialDistribution(RandomGenerator rng, double mean)
+ throws NotStrictlyPositiveException {
+ this(rng, mean, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
+ }
+
+ /**
+ * Creates an exponential distribution.
+ *
+ * @param rng Random number generator.
+ * @param mean Mean of this distribution.
+ * @param inverseCumAccuracy Maximum absolute error in inverse
+ * cumulative probability estimates (defaults to
+ * {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}).
+ * @throws NotStrictlyPositiveException if {@code mean <= 0}.
+ * @since 3.1
+ */
+ public ExponentialDistribution(RandomGenerator rng,
+ double mean,
+ double inverseCumAccuracy)
+ throws NotStrictlyPositiveException {
+ super(rng);
+
+ if (mean <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.MEAN, mean);
+ }
+ this.mean = mean;
+ logMean = FastMath.log(mean);
+ solverAbsoluteAccuracy = inverseCumAccuracy;
+ }
+
+ /**
+ * Access the mean.
+ *
+ * @return the mean.
+ */
+ public double getMean() {
+ return mean;
+ }
+
+ /** {@inheritDoc} */
+ public double density(double x) {
+ final double logDensity = logDensity(x);
+ return logDensity == Double.NEGATIVE_INFINITY ? 0 : FastMath.exp(logDensity);
+ }
+
+ /** {@inheritDoc} **/
+ @Override
+ public double logDensity(double x) {
+ if (x < 0) {
+ return Double.NEGATIVE_INFINITY;
+ }
+ return -x / mean - logMean;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The implementation of this method is based on:
+ * Algorithm Description: this implementation uses the
+ *
+ * Inversion Method to generate exponentially distributed random values
+ * from uniform deviates.
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param numeratorDegreesOfFreedom Numerator degrees of freedom.
+ * @param denominatorDegreesOfFreedom Denominator degrees of freedom.
+ * @throws NotStrictlyPositiveException if
+ * {@code numeratorDegreesOfFreedom <= 0} or
+ * {@code denominatorDegreesOfFreedom <= 0}.
+ */
+ public FDistribution(double numeratorDegreesOfFreedom,
+ double denominatorDegreesOfFreedom)
+ throws NotStrictlyPositiveException {
+ this(numeratorDegreesOfFreedom, denominatorDegreesOfFreedom,
+ DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
+ }
+
+ /**
+ * Creates an F distribution using the given degrees of freedom
+ * and inverse cumulative probability accuracy.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param numeratorDegreesOfFreedom Numerator degrees of freedom.
+ * @param denominatorDegreesOfFreedom Denominator degrees of freedom.
+ * @param inverseCumAccuracy the maximum absolute error in inverse
+ * cumulative probability estimates.
+ * @throws NotStrictlyPositiveException if
+ * {@code numeratorDegreesOfFreedom <= 0} or
+ * {@code denominatorDegreesOfFreedom <= 0}.
+ * @since 2.1
+ */
+ public FDistribution(double numeratorDegreesOfFreedom,
+ double denominatorDegreesOfFreedom,
+ double inverseCumAccuracy)
+ throws NotStrictlyPositiveException {
+ this(new Well19937c(), numeratorDegreesOfFreedom,
+ denominatorDegreesOfFreedom, inverseCumAccuracy);
+ }
+
+ /**
+ * Creates an F distribution.
+ *
+ * @param rng Random number generator.
+ * @param numeratorDegreesOfFreedom Numerator degrees of freedom.
+ * @param denominatorDegreesOfFreedom Denominator degrees of freedom.
+ * @throws NotStrictlyPositiveException if {@code numeratorDegreesOfFreedom <= 0} or
+ * {@code denominatorDegreesOfFreedom <= 0}.
+ * @since 3.3
+ */
+ public FDistribution(RandomGenerator rng,
+ double numeratorDegreesOfFreedom,
+ double denominatorDegreesOfFreedom)
+ throws NotStrictlyPositiveException {
+ this(rng, numeratorDegreesOfFreedom, denominatorDegreesOfFreedom, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
+ }
+
+ /**
+ * Creates an F distribution.
+ *
+ * @param rng Random number generator.
+ * @param numeratorDegreesOfFreedom Numerator degrees of freedom.
+ * @param denominatorDegreesOfFreedom Denominator degrees of freedom.
+ * @param inverseCumAccuracy the maximum absolute error in inverse
+ * cumulative probability estimates.
+ * @throws NotStrictlyPositiveException if {@code numeratorDegreesOfFreedom <= 0} or
+ * {@code denominatorDegreesOfFreedom <= 0}.
+ * @since 3.1
+ */
+ public FDistribution(RandomGenerator rng,
+ double numeratorDegreesOfFreedom,
+ double denominatorDegreesOfFreedom,
+ double inverseCumAccuracy)
+ throws NotStrictlyPositiveException {
+ super(rng);
+
+ if (numeratorDegreesOfFreedom <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.DEGREES_OF_FREEDOM,
+ numeratorDegreesOfFreedom);
+ }
+ if (denominatorDegreesOfFreedom <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.DEGREES_OF_FREEDOM,
+ denominatorDegreesOfFreedom);
+ }
+ this.numeratorDegreesOfFreedom = numeratorDegreesOfFreedom;
+ this.denominatorDegreesOfFreedom = denominatorDegreesOfFreedom;
+ solverAbsoluteAccuracy = inverseCumAccuracy;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @since 2.1
+ */
+ public double density(double x) {
+ return FastMath.exp(logDensity(x));
+ }
+
+ /** {@inheritDoc} **/
+ @Override
+ public double logDensity(double x) {
+ final double nhalf = numeratorDegreesOfFreedom / 2;
+ final double mhalf = denominatorDegreesOfFreedom / 2;
+ final double logx = FastMath.log(x);
+ final double logn = FastMath.log(numeratorDegreesOfFreedom);
+ final double logm = FastMath.log(denominatorDegreesOfFreedom);
+ final double lognxm = FastMath.log(numeratorDegreesOfFreedom * x +
+ denominatorDegreesOfFreedom);
+ return nhalf * logn + nhalf * logx - logx +
+ mhalf * logm - nhalf * lognxm - mhalf * lognxm -
+ Beta.logBeta(nhalf, mhalf);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The implementation of this method is based on
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param shape the shape parameter
+ * @param scale the scale parameter
+ * @throws NotStrictlyPositiveException if {@code shape <= 0} or
+ * {@code scale <= 0}.
+ */
+ public GammaDistribution(double shape, double scale) throws NotStrictlyPositiveException {
+ this(shape, scale, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
+ }
+
+ /**
+ * Creates a new gamma distribution with specified values of the shape and
+ * scale parameters.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param shape the shape parameter
+ * @param scale the scale parameter
+ * @param inverseCumAccuracy the maximum absolute error in inverse
+ * cumulative probability estimates (defaults to
+ * {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}).
+ * @throws NotStrictlyPositiveException if {@code shape <= 0} or
+ * {@code scale <= 0}.
+ * @since 2.1
+ */
+ public GammaDistribution(double shape, double scale, double inverseCumAccuracy)
+ throws NotStrictlyPositiveException {
+ this(new Well19937c(), shape, scale, inverseCumAccuracy);
+ }
+
+ /**
+ * Creates a Gamma distribution.
+ *
+ * @param rng Random number generator.
+ * @param shape the shape parameter
+ * @param scale the scale parameter
+ * @throws NotStrictlyPositiveException if {@code shape <= 0} or
+ * {@code scale <= 0}.
+ * @since 3.3
+ */
+ public GammaDistribution(RandomGenerator rng, double shape, double scale)
+ throws NotStrictlyPositiveException {
+ this(rng, shape, scale, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
+ }
+
+ /**
+ * Creates a Gamma distribution.
+ *
+ * @param rng Random number generator.
+ * @param shape the shape parameter
+ * @param scale the scale parameter
+ * @param inverseCumAccuracy the maximum absolute error in inverse
+ * cumulative probability estimates (defaults to
+ * {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}).
+ * @throws NotStrictlyPositiveException if {@code shape <= 0} or
+ * {@code scale <= 0}.
+ * @since 3.1
+ */
+ public GammaDistribution(RandomGenerator rng,
+ double shape,
+ double scale,
+ double inverseCumAccuracy)
+ throws NotStrictlyPositiveException {
+ super(rng);
+
+ if (shape <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.SHAPE, shape);
+ }
+ if (scale <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.SCALE, scale);
+ }
+
+ this.shape = shape;
+ this.scale = scale;
+ this.solverAbsoluteAccuracy = inverseCumAccuracy;
+ this.shiftedShape = shape + Gamma.LANCZOS_G + 0.5;
+ final double aux = FastMath.E / (2.0 * FastMath.PI * shiftedShape);
+ this.densityPrefactor2 = shape * FastMath.sqrt(aux) / Gamma.lanczos(shape);
+ this.logDensityPrefactor2 = FastMath.log(shape) + 0.5 * FastMath.log(aux) -
+ FastMath.log(Gamma.lanczos(shape));
+ this.densityPrefactor1 = this.densityPrefactor2 / scale *
+ FastMath.pow(shiftedShape, -shape) *
+ FastMath.exp(shape + Gamma.LANCZOS_G);
+ this.logDensityPrefactor1 = this.logDensityPrefactor2 - FastMath.log(scale) -
+ FastMath.log(shiftedShape) * shape +
+ shape + Gamma.LANCZOS_G;
+ this.minY = shape + Gamma.LANCZOS_G - FastMath.log(Double.MAX_VALUE);
+ this.maxLogY = FastMath.log(Double.MAX_VALUE) / (shape - 1.0);
+ }
+
+ /**
+ * Returns the shape parameter of {@code this} distribution.
+ *
+ * @return the shape parameter
+ * @deprecated as of version 3.1, {@link #getShape()} should be preferred.
+ * This method will be removed in version 4.0.
+ */
+ @Deprecated
+ public double getAlpha() {
+ return shape;
+ }
+
+ /**
+ * Returns the shape parameter of {@code this} distribution.
+ *
+ * @return the shape parameter
+ * @since 3.1
+ */
+ public double getShape() {
+ return shape;
+ }
+
+ /**
+ * Returns the scale parameter of {@code this} distribution.
+ *
+ * @return the scale parameter
+ * @deprecated as of version 3.1, {@link #getScale()} should be preferred.
+ * This method will be removed in version 4.0.
+ */
+ @Deprecated
+ public double getBeta() {
+ return scale;
+ }
+
+ /**
+ * Returns the scale parameter of {@code this} distribution.
+ *
+ * @return the scale parameter
+ * @since 3.1
+ */
+ public double getScale() {
+ return scale;
+ }
+
+ /** {@inheritDoc} */
+ public double density(double x) {
+ /* The present method must return the value of
+ *
+ * 1 x a - x
+ * ---------- (-) exp(---)
+ * x Gamma(a) b b
+ *
+ * where a is the shape parameter, and b the scale parameter.
+ * Substituting the Lanczos approximation of Gamma(a) leads to the
+ * following expression of the density
+ *
+ * a e 1 y a
+ * - sqrt(------------------) ---- (-----------) exp(a - y + g),
+ * x 2 pi (a + g + 0.5) L(a) a + g + 0.5
+ *
+ * where y = x / b. The above formula is the "natural" computation, which
+ * is implemented when no overflow is likely to occur. If overflow occurs
+ * with the natural computation, the following identity is used. It is
+ * based on the BOOST library
+ * http://www.boost.org/doc/libs/1_35_0/libs/math/doc/sf_and_dist/html/math_toolkit/special/sf_gamma/igamma.html
+ * Formula (15) needs adaptations, which are detailed below.
+ *
+ * y a
+ * (-----------) exp(a - y + g)
+ * a + g + 0.5
+ * y - a - g - 0.5 y (g + 0.5)
+ * = exp(a log1pm(---------------) - ----------- + g),
+ * a + g + 0.5 a + g + 0.5
+ *
+ * where log1pm(z) = log(1 + z) - z. Therefore, the value to be
+ * returned is
+ *
+ * a e 1
+ * - sqrt(------------------) ----
+ * x 2 pi (a + g + 0.5) L(a)
+ * y - a - g - 0.5 y (g + 0.5)
+ * * exp(a log1pm(---------------) - ----------- + g).
+ * a + g + 0.5 a + g + 0.5
+ */
+ if (x < 0) {
+ return 0;
+ }
+ final double y = x / scale;
+ if ((y <= minY) || (FastMath.log(y) >= maxLogY)) {
+ /*
+ * Overflow.
+ */
+ final double aux1 = (y - shiftedShape) / shiftedShape;
+ final double aux2 = shape * (FastMath.log1p(aux1) - aux1);
+ final double aux3 = -y * (Gamma.LANCZOS_G + 0.5) / shiftedShape +
+ Gamma.LANCZOS_G + aux2;
+ return densityPrefactor2 / x * FastMath.exp(aux3);
+ }
+ /*
+ * Natural calculation.
+ */
+ return densityPrefactor1 * FastMath.exp(-y) * FastMath.pow(y, shape - 1);
+ }
+
+ /** {@inheritDoc} **/
+ @Override
+ public double logDensity(double x) {
+ /*
+ * see the comment in {@link #density(double)} for computation details
+ */
+ if (x < 0) {
+ return Double.NEGATIVE_INFINITY;
+ }
+ final double y = x / scale;
+ if ((y <= minY) || (FastMath.log(y) >= maxLogY)) {
+ /*
+ * Overflow.
+ */
+ final double aux1 = (y - shiftedShape) / shiftedShape;
+ final double aux2 = shape * (FastMath.log1p(aux1) - aux1);
+ final double aux3 = -y * (Gamma.LANCZOS_G + 0.5) / shiftedShape +
+ Gamma.LANCZOS_G + aux2;
+ return logDensityPrefactor2 - FastMath.log(x) + aux3;
+ }
+ /*
+ * Natural calculation.
+ */
+ return logDensityPrefactor1 - y + FastMath.log(y) * (shape - 1);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The implementation of this method is based on:
+ * This implementation uses the following algorithms: For 0 < shape < 1: For shape >= 1:
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param p probability of success.
+ * @throws OutOfRangeException if {@code p <= 0} or {@code p > 1}.
+ */
+ public GeometricDistribution(double p) {
+ this(new Well19937c(), p);
+ }
+
+ /**
+ * Creates a geometric distribution.
+ *
+ * @param rng Random number generator.
+ * @param p Probability of success.
+ * @throws OutOfRangeException if {@code p <= 0} or {@code p > 1}.
+ */
+ public GeometricDistribution(RandomGenerator rng, double p) {
+ super(rng);
+
+ if (p <= 0 || p > 1) {
+ throw new OutOfRangeException(LocalizedFormats.OUT_OF_RANGE_LEFT, p, 0, 1);
+ }
+
+ probabilityOfSuccess = p;
+ logProbabilityOfSuccess = FastMath.log(p);
+ log1mProbabilityOfSuccess = FastMath.log1p(-p);
+ }
+
+ /**
+ * Access the probability of success for this distribution.
+ *
+ * @return the probability of success.
+ */
+ public double getProbabilityOfSuccess() {
+ return probabilityOfSuccess;
+ }
+
+ /** {@inheritDoc} */
+ public double probability(int x) {
+ if (x < 0) {
+ return 0.0;
+ } else {
+ return FastMath.exp(log1mProbabilityOfSuccess * x) * probabilityOfSuccess;
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double logProbability(int x) {
+ if (x < 0) {
+ return Double.NEGATIVE_INFINITY;
+ } else {
+ return x * log1mProbabilityOfSuccess + logProbabilityOfSuccess;
+ }
+ }
+
+ /** {@inheritDoc} */
+ public double cumulativeProbability(int x) {
+ if (x < 0) {
+ return 0.0;
+ } else {
+ return -FastMath.expm1(log1mProbabilityOfSuccess * (x + 1));
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For probability parameter {@code p}, the mean is {@code (1 - p) / p}.
+ */
+ public double getNumericalMean() {
+ return (1 - probabilityOfSuccess) / probabilityOfSuccess;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For probability parameter {@code p}, the variance is
+ * {@code (1 - p) / (p * p)}.
+ */
+ public double getNumericalVariance() {
+ return (1 - probabilityOfSuccess) / (probabilityOfSuccess * probabilityOfSuccess);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The lower bound of the support is always 0.
+ *
+ * @return lower bound of the support (always 0)
+ */
+ public int getSupportLowerBound() {
+ return 0;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The upper bound of the support is infinite (which we approximate as
+ * {@code Integer.MAX_VALUE}).
+ *
+ * @return upper bound of the support (always Integer.MAX_VALUE)
+ */
+ public int getSupportUpperBound() {
+ return Integer.MAX_VALUE;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The support of this distribution is connected.
+ *
+ * @return {@code true}
+ */
+ public boolean isSupportConnected() {
+ return true;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int inverseCumulativeProbability(double p) throws OutOfRangeException {
+ if (p < 0 || p > 1) {
+ throw new OutOfRangeException(p, 0, 1);
+ }
+ if (p == 1) {
+ return Integer.MAX_VALUE;
+ }
+ if (p == 0) {
+ return 0;
+ }
+ return Math.max(0, (int) Math.ceil(FastMath.log1p(-p)/log1mProbabilityOfSuccess-1));
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/GumbelDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/GumbelDistribution.java
new file mode 100644
index 000000000..88aae8bbc
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/GumbelDistribution.java
@@ -0,0 +1,167 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException;
+import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.random.RandomGenerator;
+import com.fr.third.org.apache.commons.math3.random.Well19937c;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+import com.fr.third.org.apache.commons.math3.util.MathUtils;
+
+/**
+ * This class implements the Gumbel distribution.
+ *
+ * @see Gumbel Distribution (Wikipedia)
+ * @see Gumbel Distribution (Mathworld)
+ *
+ * @since 3.4
+ */
+public class GumbelDistribution extends AbstractRealDistribution {
+
+ /** Serializable version identifier. */
+ private static final long serialVersionUID = 20141003;
+
+ /**
+ * Approximation of Euler's constant
+ * see http://mathworld.wolfram.com/Euler-MascheroniConstantApproximations.html
+ */
+ private static final double EULER = FastMath.PI / (2 * FastMath.E);
+
+ /** The location parameter. */
+ private final double mu;
+ /** The scale parameter. */
+ private final double beta;
+
+ /**
+ * Build a new instance.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param mu location parameter
+ * @param beta scale parameter (must be positive)
+ * @throws NotStrictlyPositiveException if {@code beta <= 0}
+ */
+ public GumbelDistribution(double mu, double beta) {
+ this(new Well19937c(), mu, beta);
+ }
+
+ /**
+ * Build a new instance.
+ *
+ * @param rng Random number generator
+ * @param mu location parameter
+ * @param beta scale parameter (must be positive)
+ * @throws NotStrictlyPositiveException if {@code beta <= 0}
+ */
+ public GumbelDistribution(RandomGenerator rng, double mu, double beta) {
+ super(rng);
+
+ if (beta <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.SCALE, beta);
+ }
+
+ this.beta = beta;
+ this.mu = mu;
+ }
+
+ /**
+ * Access the location parameter, {@code mu}.
+ *
+ * @return the location parameter.
+ */
+ public double getLocation() {
+ return mu;
+ }
+
+ /**
+ * Access the scale parameter, {@code beta}.
+ *
+ * @return the scale parameter.
+ */
+ public double getScale() {
+ return beta;
+ }
+
+ /** {@inheritDoc} */
+ public double density(double x) {
+ final double z = (x - mu) / beta;
+ final double t = FastMath.exp(-z);
+ return FastMath.exp(-z - t) / beta;
+ }
+
+ /** {@inheritDoc} */
+ public double cumulativeProbability(double x) {
+ final double z = (x - mu) / beta;
+ return FastMath.exp(-FastMath.exp(-z));
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double inverseCumulativeProbability(double p) throws OutOfRangeException {
+ if (p < 0.0 || p > 1.0) {
+ throw new OutOfRangeException(p, 0.0, 1.0);
+ } else if (p == 0) {
+ return Double.NEGATIVE_INFINITY;
+ } else if (p == 1) {
+ return Double.POSITIVE_INFINITY;
+ }
+ return mu - FastMath.log(-FastMath.log(p)) * beta;
+ }
+
+ /** {@inheritDoc} */
+ public double getNumericalMean() {
+ return mu + EULER * beta;
+ }
+
+ /** {@inheritDoc} */
+ public double getNumericalVariance() {
+ return (MathUtils.PI_SQUARED) / 6.0 * (beta * beta);
+ }
+
+ /** {@inheritDoc} */
+ public double getSupportLowerBound() {
+ return Double.NEGATIVE_INFINITY;
+ }
+
+ /** {@inheritDoc} */
+ public double getSupportUpperBound() {
+ return Double.POSITIVE_INFINITY;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportLowerBoundInclusive() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportUpperBoundInclusive() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportConnected() {
+ return true;
+ }
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/HypergeometricDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/HypergeometricDistribution.java
new file mode 100644
index 000000000..f28e81639
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/HypergeometricDistribution.java
@@ -0,0 +1,347 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import com.fr.third.org.apache.commons.math3.exception.NotPositiveException;
+import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException;
+import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.random.RandomGenerator;
+import com.fr.third.org.apache.commons.math3.random.Well19937c;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+
+/**
+ * Implementation of the hypergeometric distribution.
+ *
+ * @see Hypergeometric distribution (Wikipedia)
+ * @see Hypergeometric distribution (MathWorld)
+ */
+public class HypergeometricDistribution extends AbstractIntegerDistribution {
+ /** Serializable version identifier. */
+ private static final long serialVersionUID = -436928820673516179L;
+ /** The number of successes in the population. */
+ private final int numberOfSuccesses;
+ /** The population size. */
+ private final int populationSize;
+ /** The sample size. */
+ private final int sampleSize;
+ /** Cached numerical variance */
+ private double numericalVariance = Double.NaN;
+ /** Whether or not the numerical variance has been calculated */
+ private boolean numericalVarianceIsCalculated = false;
+
+ /**
+ * Construct a new hypergeometric distribution with the specified population
+ * size, number of successes in the population, and sample size.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param populationSize Population size.
+ * @param numberOfSuccesses Number of successes in the population.
+ * @param sampleSize Sample size.
+ * @throws NotPositiveException if {@code numberOfSuccesses < 0}.
+ * @throws NotStrictlyPositiveException if {@code populationSize <= 0}.
+ * @throws NumberIsTooLargeException if {@code numberOfSuccesses > populationSize},
+ * or {@code sampleSize > populationSize}.
+ */
+ public HypergeometricDistribution(int populationSize, int numberOfSuccesses, int sampleSize)
+ throws NotPositiveException, NotStrictlyPositiveException, NumberIsTooLargeException {
+ this(new Well19937c(), populationSize, numberOfSuccesses, sampleSize);
+ }
+
+ /**
+ * Creates a new hypergeometric distribution.
+ *
+ * @param rng Random number generator.
+ * @param populationSize Population size.
+ * @param numberOfSuccesses Number of successes in the population.
+ * @param sampleSize Sample size.
+ * @throws NotPositiveException if {@code numberOfSuccesses < 0}.
+ * @throws NotStrictlyPositiveException if {@code populationSize <= 0}.
+ * @throws NumberIsTooLargeException if {@code numberOfSuccesses > populationSize},
+ * or {@code sampleSize > populationSize}.
+ * @since 3.1
+ */
+ public HypergeometricDistribution(RandomGenerator rng,
+ int populationSize,
+ int numberOfSuccesses,
+ int sampleSize)
+ throws NotPositiveException, NotStrictlyPositiveException, NumberIsTooLargeException {
+ super(rng);
+
+ if (populationSize <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.POPULATION_SIZE,
+ populationSize);
+ }
+ if (numberOfSuccesses < 0) {
+ throw new NotPositiveException(LocalizedFormats.NUMBER_OF_SUCCESSES,
+ numberOfSuccesses);
+ }
+ if (sampleSize < 0) {
+ throw new NotPositiveException(LocalizedFormats.NUMBER_OF_SAMPLES,
+ sampleSize);
+ }
+
+ if (numberOfSuccesses > populationSize) {
+ throw new NumberIsTooLargeException(LocalizedFormats.NUMBER_OF_SUCCESS_LARGER_THAN_POPULATION_SIZE,
+ numberOfSuccesses, populationSize, true);
+ }
+ if (sampleSize > populationSize) {
+ throw new NumberIsTooLargeException(LocalizedFormats.SAMPLE_SIZE_LARGER_THAN_POPULATION_SIZE,
+ sampleSize, populationSize, true);
+ }
+
+ this.numberOfSuccesses = numberOfSuccesses;
+ this.populationSize = populationSize;
+ this.sampleSize = sampleSize;
+ }
+
+ /** {@inheritDoc} */
+ public double cumulativeProbability(int x) {
+ double ret;
+
+ int[] domain = getDomain(populationSize, numberOfSuccesses, sampleSize);
+ if (x < domain[0]) {
+ ret = 0.0;
+ } else if (x >= domain[1]) {
+ ret = 1.0;
+ } else {
+ ret = innerCumulativeProbability(domain[0], x, 1);
+ }
+
+ return ret;
+ }
+
+ /**
+ * Return the domain for the given hypergeometric distribution parameters.
+ *
+ * @param n Population size.
+ * @param m Number of successes in the population.
+ * @param k Sample size.
+ * @return a two element array containing the lower and upper bounds of the
+ * hypergeometric distribution.
+ */
+ private int[] getDomain(int n, int m, int k) {
+ return new int[] { getLowerDomain(n, m, k), getUpperDomain(m, k) };
+ }
+
+ /**
+ * Return the lowest domain value for the given hypergeometric distribution
+ * parameters.
+ *
+ * @param n Population size.
+ * @param m Number of successes in the population.
+ * @param k Sample size.
+ * @return the lowest domain value of the hypergeometric distribution.
+ */
+ private int getLowerDomain(int n, int m, int k) {
+ return FastMath.max(0, m - (n - k));
+ }
+
+ /**
+ * Access the number of successes.
+ *
+ * @return the number of successes.
+ */
+ public int getNumberOfSuccesses() {
+ return numberOfSuccesses;
+ }
+
+ /**
+ * Access the population size.
+ *
+ * @return the population size.
+ */
+ public int getPopulationSize() {
+ return populationSize;
+ }
+
+ /**
+ * Access the sample size.
+ *
+ * @return the sample size.
+ */
+ public int getSampleSize() {
+ return sampleSize;
+ }
+
+ /**
+ * Return the highest domain value for the given hypergeometric distribution
+ * parameters.
+ *
+ * @param m Number of successes in the population.
+ * @param k Sample size.
+ * @return the highest domain value of the hypergeometric distribution.
+ */
+ private int getUpperDomain(int m, int k) {
+ return FastMath.min(k, m);
+ }
+
+ /** {@inheritDoc} */
+ public double probability(int x) {
+ final double logProbability = logProbability(x);
+ return logProbability == Double.NEGATIVE_INFINITY ? 0 : FastMath.exp(logProbability);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double logProbability(int x) {
+ double ret;
+
+ int[] domain = getDomain(populationSize, numberOfSuccesses, sampleSize);
+ if (x < domain[0] || x > domain[1]) {
+ ret = Double.NEGATIVE_INFINITY;
+ } else {
+ double p = (double) sampleSize / (double) populationSize;
+ double q = (double) (populationSize - sampleSize) / (double) populationSize;
+ double p1 = SaddlePointExpansion.logBinomialProbability(x,
+ numberOfSuccesses, p, q);
+ double p2 =
+ SaddlePointExpansion.logBinomialProbability(sampleSize - x,
+ populationSize - numberOfSuccesses, p, q);
+ double p3 =
+ SaddlePointExpansion.logBinomialProbability(sampleSize, populationSize, p, q);
+ ret = p1 + p2 - p3;
+ }
+
+ return ret;
+ }
+
+ /**
+ * For this distribution, {@code X}, this method returns {@code P(X >= x)}.
+ *
+ * @param x Value at which the CDF is evaluated.
+ * @return the upper tail CDF for this distribution.
+ * @since 1.1
+ */
+ public double upperCumulativeProbability(int x) {
+ double ret;
+
+ final int[] domain = getDomain(populationSize, numberOfSuccesses, sampleSize);
+ if (x <= domain[0]) {
+ ret = 1.0;
+ } else if (x > domain[1]) {
+ ret = 0.0;
+ } else {
+ ret = innerCumulativeProbability(domain[1], x, -1);
+ }
+
+ return ret;
+ }
+
+ /**
+ * For this distribution, {@code X}, this method returns
+ * {@code P(x0 <= X <= x1)}.
+ * This probability is computed by summing the point probabilities for the
+ * values {@code x0, x0 + 1, x0 + 2, ..., x1}, in the order directed by
+ * {@code dx}.
+ *
+ * @param x0 Inclusive lower bound.
+ * @param x1 Inclusive upper bound.
+ * @param dx Direction of summation (1 indicates summing from x0 to x1, and
+ * 0 indicates summing from x1 to x0).
+ * @return {@code P(x0 <= X <= x1)}.
+ */
+ private double innerCumulativeProbability(int x0, int x1, int dx) {
+ double ret = probability(x0);
+ while (x0 != x1) {
+ x0 += dx;
+ ret += probability(x0);
+ }
+ return ret;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For population size {@code N}, number of successes {@code m}, and sample
+ * size {@code n}, the mean is {@code n * m / N}.
+ */
+ public double getNumericalMean() {
+ return getSampleSize() * (getNumberOfSuccesses() / (double) getPopulationSize());
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For population size {@code N}, number of successes {@code m}, and sample
+ * size {@code n}, the variance is
+ * {@code [n * m * (N - n) * (N - m)] / [N^2 * (N - 1)]}.
+ */
+ public double getNumericalVariance() {
+ if (!numericalVarianceIsCalculated) {
+ numericalVariance = calculateNumericalVariance();
+ numericalVarianceIsCalculated = true;
+ }
+ return numericalVariance;
+ }
+
+ /**
+ * Used by {@link #getNumericalVariance()}.
+ *
+ * @return the variance of this distribution
+ */
+ protected double calculateNumericalVariance() {
+ final double N = getPopulationSize();
+ final double m = getNumberOfSuccesses();
+ final double n = getSampleSize();
+ return (n * m * (N - n) * (N - m)) / (N * N * (N - 1));
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For population size {@code N}, number of successes {@code m}, and sample
+ * size {@code n}, the lower bound of the support is
+ * {@code max(0, n + m - N)}.
+ *
+ * @return lower bound of the support
+ */
+ public int getSupportLowerBound() {
+ return FastMath.max(0,
+ getSampleSize() + getNumberOfSuccesses() - getPopulationSize());
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For number of successes {@code m} and sample size {@code n}, the upper
+ * bound of the support is {@code min(m, n)}.
+ *
+ * @return upper bound of the support
+ */
+ public int getSupportUpperBound() {
+ return FastMath.min(getNumberOfSuccesses(), getSampleSize());
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The support of this distribution is connected.
+ *
+ * @return {@code true}
+ */
+ public boolean isSupportConnected() {
+ return true;
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/IntegerDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/IntegerDistribution.java
new file mode 100644
index 000000000..4c206542c
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/IntegerDistribution.java
@@ -0,0 +1,156 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException;
+import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException;
+import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException;
+
+/**
+ * Interface for distributions on the integers.
+ *
+ */
+public interface IntegerDistribution {
+ /**
+ * For a random variable {@code X} whose values are distributed according
+ * to this distribution, this method returns {@code P(X = x)}. In other
+ * words, this method represents the probability mass function (PMF)
+ * for the distribution.
+ *
+ * @param x the point at which the PMF is evaluated
+ * @return the value of the probability mass function at {@code x}
+ */
+ double probability(int x);
+
+ /**
+ * For a random variable {@code X} whose values are distributed according
+ * to this distribution, this method returns {@code P(X <= x)}. In other
+ * words, this method represents the (cumulative) distribution function
+ * (CDF) for this distribution.
+ *
+ * @param x the point at which the CDF is evaluated
+ * @return the probability that a random variable with this
+ * distribution takes a value less than or equal to {@code x}
+ */
+ double cumulativeProbability(int x);
+
+ /**
+ * For a random variable {@code X} whose values are distributed according
+ * to this distribution, this method returns {@code P(x0 < X <= x1)}.
+ *
+ * @param x0 the exclusive 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} and {@code x1},
+ * excluding the lower and including the upper endpoint
+ * @throws NumberIsTooLargeException if {@code x0 > x1}
+ */
+ double cumulativeProbability(int x0, int x1) throws NumberIsTooLargeException;
+
+ /**
+ * Computes the quantile function of this distribution.
+ * For a random variable {@code X} distributed according to this distribution,
+ * the returned value is
+ *
+ * Treats the distribution of the two-sided {@code P(D_n < d)} where
+ * {@code D_n = sup_x |G(x) - G_n (x)|} for the theoretical cdf {@code G} and
+ * the empirical cdf {@code G_n}.
+ *
+ * This implementation is based on [1] with certain quick decisions for extreme
+ * values given in [2].
+ *
+ * In short, when wanting to evaluate {@code P(D_n < d)}, the method in [1] is
+ * to write {@code d = (k - h) / n} for positive integer {@code k} and
+ * {@code 0 <= h < 1}. Then {@code P(D_n < d) = (n! / n^n) * t_kk}, where
+ * {@code t_kk} is the {@code (k, k)}'th entry in the special matrix
+ * {@code H^n}, i.e. {@code H} to the {@code n}'th power.
+ *
+ * References:
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param mu location parameter
+ * @param beta scale parameter (must be positive)
+ * @throws NotStrictlyPositiveException if {@code beta <= 0}
+ */
+ public LaplaceDistribution(double mu, double beta) {
+ this(new Well19937c(), mu, beta);
+ }
+
+ /**
+ * Build a new instance.
+ *
+ * @param rng Random number generator
+ * @param mu location parameter
+ * @param beta scale parameter (must be positive)
+ * @throws NotStrictlyPositiveException if {@code beta <= 0}
+ */
+ public LaplaceDistribution(RandomGenerator rng, double mu, double beta) {
+ super(rng);
+
+ if (beta <= 0.0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.NOT_POSITIVE_SCALE, beta);
+ }
+
+ this.mu = mu;
+ this.beta = beta;
+ }
+
+ /**
+ * Access the location parameter, {@code mu}.
+ *
+ * @return the location parameter.
+ */
+ public double getLocation() {
+ return mu;
+ }
+
+ /**
+ * Access the scale parameter, {@code beta}.
+ *
+ * @return the scale parameter.
+ */
+ public double getScale() {
+ return beta;
+ }
+
+ /** {@inheritDoc} */
+ public double density(double x) {
+ return FastMath.exp(-FastMath.abs(x - mu) / beta) / (2.0 * beta);
+ }
+
+ /** {@inheritDoc} */
+ public double cumulativeProbability(double x) {
+ if (x <= mu) {
+ return FastMath.exp((x - mu) / beta) / 2.0;
+ } else {
+ return 1.0 - FastMath.exp((mu - x) / beta) / 2.0;
+ }
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double inverseCumulativeProbability(double p) throws OutOfRangeException {
+ if (p < 0.0 || p > 1.0) {
+ throw new OutOfRangeException(p, 0.0, 1.0);
+ } else if (p == 0) {
+ return Double.NEGATIVE_INFINITY;
+ } else if (p == 1) {
+ return Double.POSITIVE_INFINITY;
+ }
+ double x = (p > 0.5) ? -Math.log(2.0 - 2.0 * p) : Math.log(2.0 * p);
+ return mu + beta * x;
+ }
+
+ /** {@inheritDoc} */
+ public double getNumericalMean() {
+ return mu;
+ }
+
+ /** {@inheritDoc} */
+ public double getNumericalVariance() {
+ return 2.0 * beta * beta;
+ }
+
+ /** {@inheritDoc} */
+ public double getSupportLowerBound() {
+ return Double.NEGATIVE_INFINITY;
+ }
+
+ /** {@inheritDoc} */
+ public double getSupportUpperBound() {
+ return Double.POSITIVE_INFINITY;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportLowerBoundInclusive() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportUpperBoundInclusive() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportConnected() {
+ return true;
+ }
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/LevyDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/LevyDistribution.java
new file mode 100644
index 000000000..e2a23a471
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/LevyDistribution.java
@@ -0,0 +1,192 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException;
+import com.fr.third.org.apache.commons.math3.random.RandomGenerator;
+import com.fr.third.org.apache.commons.math3.random.Well19937c;
+import com.fr.third.org.apache.commons.math3.special.Erf;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+
+/**
+ * This class implements the
+ * Lévy distribution.
+ *
+ * @since 3.2
+ */
+public class LevyDistribution extends AbstractRealDistribution {
+
+ /** Serializable UID. */
+ private static final long serialVersionUID = 20130314L;
+
+ /** Location parameter. */
+ private final double mu;
+
+ /** Scale parameter. */
+ private final double c; // Setting this to 1 returns a cumProb of 1.0
+
+ /** Half of c (for calculations). */
+ private final double halfC;
+
+ /**
+ * Build a new instance.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param mu location parameter
+ * @param c scale parameter
+ * @since 3.4
+ */
+ public LevyDistribution(final double mu, final double c) {
+ this(new Well19937c(), mu, c);
+ }
+
+ /**
+ * Creates a LevyDistribution.
+ * @param rng random generator to be used for sampling
+ * @param mu location
+ * @param c scale parameter
+ */
+ public LevyDistribution(final RandomGenerator rng, final double mu, final double c) {
+ super(rng);
+ this.mu = mu;
+ this.c = c;
+ this.halfC = 0.5 * c;
+ }
+
+ /** {@inheritDoc}
+ *
+ * From Wikipedia: The probability density function of the Lévy distribution
+ * over the domain is
+ *
+ * For this distribution, {@code X}, this method returns {@code P(X < x)}.
+ * If {@code x} is less than location parameter μ, {@code Double.NaN} is
+ * returned, as in these cases the distribution is not defined.
+ *
+ * From Wikipedia: the cumulative distribution function is
+ *
+ * Parameters:
+ * {@code X} is log-normally distributed if its natural logarithm {@code log(X)}
+ * is normally distributed. The probability distribution function of {@code X}
+ * is given by (for {@code x > 0})
+ *
+ * {@code exp(-0.5 * ((ln(x) - m) / s)^2) / (s * sqrt(2 * pi) * x)}
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ */
+ public LogNormalDistribution() {
+ this(0, 1);
+ }
+
+ /**
+ * Create a log-normal distribution using the specified scale and shape.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param scale the scale parameter of this distribution
+ * @param shape the shape parameter of this distribution
+ * @throws NotStrictlyPositiveException if {@code shape <= 0}.
+ */
+ public LogNormalDistribution(double scale, double shape)
+ throws NotStrictlyPositiveException {
+ this(scale, shape, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
+ }
+
+ /**
+ * Create a log-normal distribution using the specified scale, shape and
+ * inverse cumulative distribution accuracy.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param scale the scale parameter of this distribution
+ * @param shape the shape parameter of this distribution
+ * @param inverseCumAccuracy Inverse cumulative probability accuracy.
+ * @throws NotStrictlyPositiveException if {@code shape <= 0}.
+ */
+ public LogNormalDistribution(double scale, double shape, double inverseCumAccuracy)
+ throws NotStrictlyPositiveException {
+ this(new Well19937c(), scale, shape, inverseCumAccuracy);
+ }
+
+ /**
+ * Creates a log-normal distribution.
+ *
+ * @param rng Random number generator.
+ * @param scale Scale parameter of this distribution.
+ * @param shape Shape parameter of this distribution.
+ * @throws NotStrictlyPositiveException if {@code shape <= 0}.
+ * @since 3.3
+ */
+ public LogNormalDistribution(RandomGenerator rng, double scale, double shape)
+ throws NotStrictlyPositiveException {
+ this(rng, scale, shape, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
+ }
+
+ /**
+ * Creates a log-normal distribution.
+ *
+ * @param rng Random number generator.
+ * @param scale Scale parameter of this distribution.
+ * @param shape Shape parameter of this distribution.
+ * @param inverseCumAccuracy Inverse cumulative probability accuracy.
+ * @throws NotStrictlyPositiveException if {@code shape <= 0}.
+ * @since 3.1
+ */
+ public LogNormalDistribution(RandomGenerator rng,
+ double scale,
+ double shape,
+ double inverseCumAccuracy)
+ throws NotStrictlyPositiveException {
+ super(rng);
+
+ if (shape <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.SHAPE, shape);
+ }
+
+ this.scale = scale;
+ this.shape = shape;
+ this.logShapePlusHalfLog2Pi = FastMath.log(shape) + 0.5 * FastMath.log(2 * FastMath.PI);
+ this.solverAbsoluteAccuracy = inverseCumAccuracy;
+ }
+
+ /**
+ * Returns the scale parameter of this distribution.
+ *
+ * @return the scale parameter
+ */
+ public double getScale() {
+ return scale;
+ }
+
+ /**
+ * Returns the shape parameter of this distribution.
+ *
+ * @return the shape parameter
+ */
+ public double getShape() {
+ return shape;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For scale {@code m}, and shape {@code s} of this distribution, the PDF
+ * is given by
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param mu location parameter
+ * @param s scale parameter (must be positive)
+ * @throws NotStrictlyPositiveException if {@code beta <= 0}
+ */
+ public LogisticDistribution(double mu, double s) {
+ this(new Well19937c(), mu, s);
+ }
+
+ /**
+ * Build a new instance.
+ *
+ * @param rng Random number generator
+ * @param mu location parameter
+ * @param s scale parameter (must be positive)
+ * @throws NotStrictlyPositiveException if {@code beta <= 0}
+ */
+ public LogisticDistribution(RandomGenerator rng, double mu, double s) {
+ super(rng);
+
+ if (s <= 0.0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.NOT_POSITIVE_SCALE, s);
+ }
+
+ this.mu = mu;
+ this.s = s;
+ }
+
+ /**
+ * Access the location parameter, {@code mu}.
+ *
+ * @return the location parameter.
+ */
+ public double getLocation() {
+ return mu;
+ }
+
+ /**
+ * Access the scale parameter, {@code s}.
+ *
+ * @return the scale parameter.
+ */
+ public double getScale() {
+ return s;
+ }
+
+ /** {@inheritDoc} */
+ public double density(double x) {
+ double z = (x - mu) / s;
+ double v = FastMath.exp(-z);
+ return 1 / s * v / ((1.0 + v) * (1.0 + v));
+ }
+
+ /** {@inheritDoc} */
+ public double cumulativeProbability(double x) {
+ double z = 1 / s * (x - mu);
+ return 1.0 / (1.0 + FastMath.exp(-z));
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double inverseCumulativeProbability(double p) throws OutOfRangeException {
+ if (p < 0.0 || p > 1.0) {
+ throw new OutOfRangeException(p, 0.0, 1.0);
+ } else if (p == 0) {
+ return 0.0;
+ } else if (p == 1) {
+ return Double.POSITIVE_INFINITY;
+ }
+ return s * Math.log(p / (1.0 - p)) + mu;
+ }
+
+ /** {@inheritDoc} */
+ public double getNumericalMean() {
+ return mu;
+ }
+
+ /** {@inheritDoc} */
+ public double getNumericalVariance() {
+ return (MathUtils.PI_SQUARED / 3.0) * (1.0 / (s * s));
+ }
+
+ /** {@inheritDoc} */
+ public double getSupportLowerBound() {
+ return Double.NEGATIVE_INFINITY;
+ }
+
+ /** {@inheritDoc} */
+ public double getSupportUpperBound() {
+ return Double.POSITIVE_INFINITY;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportLowerBoundInclusive() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportUpperBoundInclusive() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportConnected() {
+ return true;
+ }
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/MixtureMultivariateNormalDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/MixtureMultivariateNormalDistribution.java
new file mode 100644
index 000000000..a0aea1213
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/MixtureMultivariateNormalDistribution.java
@@ -0,0 +1,114 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException;
+import com.fr.third.org.apache.commons.math3.exception.NotPositiveException;
+import com.fr.third.org.apache.commons.math3.random.RandomGenerator;
+import com.fr.third.org.apache.commons.math3.random.Well19937c;
+import com.fr.third.org.apache.commons.math3.util.Pair;
+
+/**
+ * Multivariate normal mixture distribution.
+ * This class is mainly syntactic sugar.
+ *
+ * @see MixtureMultivariateRealDistribution
+ * @since 3.2
+ */
+public class MixtureMultivariateNormalDistribution
+ extends MixtureMultivariateRealDistribution
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c Well19937c} as random
+ * generator to be used for sampling only (see {@link #sample()} and
+ * {@link #sample(int)}). In case no sampling is needed for the created
+ * distribution, it is advised to pass {@code null} as random generator via
+ * the appropriate constructors to avoid the additional initialisation
+ * overhead.
+ *
+ * @param weights Weights of each component.
+ * @param means Mean vector for each component.
+ * @param covariances Covariance matrix for each component.
+ */
+ public MixtureMultivariateNormalDistribution(double[] weights,
+ double[][] means,
+ double[][][] covariances) {
+ super(createComponents(weights, means, covariances));
+ }
+
+ /**
+ * Creates a mixture model from a list of distributions and their
+ * associated weights.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c Well19937c} as random
+ * generator to be used for sampling only (see {@link #sample()} and
+ * {@link #sample(int)}). In case no sampling is needed for the created
+ * distribution, it is advised to pass {@code null} as random generator via
+ * the appropriate constructors to avoid the additional initialisation
+ * overhead.
+ *
+ * @param components List of (weight, distribution) pairs from which to sample.
+ */
+ public MixtureMultivariateNormalDistribution(List
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param components List of (weight, distribution) pairs from which to sample.
+ */
+ public MixtureMultivariateRealDistribution(List
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param means Vector of means.
+ * @param covariances Covariance matrix.
+ * @throws DimensionMismatchException if the arrays length are
+ * inconsistent.
+ * @throws SingularMatrixException if the eigenvalue decomposition cannot
+ * be performed on the provided covariance matrix.
+ * @throws NonPositiveDefiniteMatrixException if any of the eigenvalues is
+ * negative.
+ */
+ public MultivariateNormalDistribution(final double[] means,
+ final double[][] covariances)
+ throws SingularMatrixException,
+ DimensionMismatchException,
+ NonPositiveDefiniteMatrixException {
+ this(new Well19937c(), means, covariances);
+ }
+
+ /**
+ * Creates a multivariate normal distribution with the given mean vector and
+ * covariance matrix.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param mu shape parameter
+ * @param omega scale parameter (must be positive)
+ * @throws NumberIsTooSmallException if {@code mu < 0.5}
+ * @throws NotStrictlyPositiveException if {@code omega <= 0}
+ */
+ public NakagamiDistribution(double mu, double omega) {
+ this(mu, omega, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
+ }
+
+ /**
+ * Build a new instance.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param mu shape parameter
+ * @param omega scale parameter (must be positive)
+ * @param inverseAbsoluteAccuracy the maximum absolute error in inverse
+ * cumulative probability estimates (defaults to {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}).
+ * @throws NumberIsTooSmallException if {@code mu < 0.5}
+ * @throws NotStrictlyPositiveException if {@code omega <= 0}
+ */
+ public NakagamiDistribution(double mu, double omega, double inverseAbsoluteAccuracy) {
+ this(new Well19937c(), mu, omega, inverseAbsoluteAccuracy);
+ }
+
+ /**
+ * Build a new instance.
+ *
+ * @param rng Random number generator
+ * @param mu shape parameter
+ * @param omega scale parameter (must be positive)
+ * @param inverseAbsoluteAccuracy the maximum absolute error in inverse
+ * cumulative probability estimates (defaults to {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}).
+ * @throws NumberIsTooSmallException if {@code mu < 0.5}
+ * @throws NotStrictlyPositiveException if {@code omega <= 0}
+ */
+ public NakagamiDistribution(RandomGenerator rng, double mu, double omega, double inverseAbsoluteAccuracy) {
+ super(rng);
+
+ if (mu < 0.5) {
+ throw new NumberIsTooSmallException(mu, 0.5, true);
+ }
+ if (omega <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.NOT_POSITIVE_SCALE, omega);
+ }
+
+ this.mu = mu;
+ this.omega = omega;
+ this.inverseAbsoluteAccuracy = inverseAbsoluteAccuracy;
+ }
+
+ /**
+ * Access the shape parameter, {@code mu}.
+ *
+ * @return the shape parameter.
+ */
+ public double getShape() {
+ return mu;
+ }
+
+ /**
+ * Access the scale parameter, {@code omega}.
+ *
+ * @return the scale parameter.
+ */
+ public double getScale() {
+ return omega;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ protected double getSolverAbsoluteAccuracy() {
+ return inverseAbsoluteAccuracy;
+ }
+
+ /** {@inheritDoc} */
+ public double density(double x) {
+ if (x <= 0) {
+ return 0.0;
+ }
+ return 2.0 * FastMath.pow(mu, mu) / (Gamma.gamma(mu) * FastMath.pow(omega, mu)) *
+ FastMath.pow(x, 2 * mu - 1) * FastMath.exp(-mu * x * x / omega);
+ }
+
+ /** {@inheritDoc} */
+ public double cumulativeProbability(double x) {
+ return Gamma.regularizedGammaP(mu, mu * x * x / omega);
+ }
+
+ /** {@inheritDoc} */
+ public double getNumericalMean() {
+ return Gamma.gamma(mu + 0.5) / Gamma.gamma(mu) * FastMath.sqrt(omega / mu);
+ }
+
+ /** {@inheritDoc} */
+ public double getNumericalVariance() {
+ double v = Gamma.gamma(mu + 0.5) / Gamma.gamma(mu);
+ return omega * (1 - 1 / mu * v * v);
+ }
+
+ /** {@inheritDoc} */
+ public double getSupportLowerBound() {
+ return 0;
+ }
+
+ /** {@inheritDoc} */
+ public double getSupportUpperBound() {
+ return Double.POSITIVE_INFINITY;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportLowerBoundInclusive() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportUpperBoundInclusive() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportConnected() {
+ return true;
+ }
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/NormalDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/NormalDistribution.java
new file mode 100644
index 000000000..44dfa677d
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/NormalDistribution.java
@@ -0,0 +1,311 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException;
+import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException;
+import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.random.RandomGenerator;
+import com.fr.third.org.apache.commons.math3.random.Well19937c;
+import com.fr.third.org.apache.commons.math3.special.Erf;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+
+/**
+ * Implementation of the normal (gaussian) distribution.
+ *
+ * @see Normal distribution (Wikipedia)
+ * @see Normal distribution (MathWorld)
+ */
+public class NormalDistribution extends AbstractRealDistribution {
+ /**
+ * Default inverse cumulative probability accuracy.
+ * @since 2.1
+ */
+ public static final double DEFAULT_INVERSE_ABSOLUTE_ACCURACY = 1e-9;
+ /** Serializable version identifier. */
+ private static final long serialVersionUID = 8589540077390120676L;
+ /** √(2) */
+ private static final double SQRT2 = FastMath.sqrt(2.0);
+ /** Mean of this distribution. */
+ private final double mean;
+ /** Standard deviation of this distribution. */
+ private final double standardDeviation;
+ /** The value of {@code log(sd) + 0.5*log(2*pi)} stored for faster computation. */
+ private final double logStandardDeviationPlusHalfLog2Pi;
+ /** Inverse cumulative probability accuracy. */
+ private final double solverAbsoluteAccuracy;
+
+ /**
+ * Create a normal distribution with mean equal to zero and standard
+ * deviation equal to one.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ */
+ public NormalDistribution() {
+ this(0, 1);
+ }
+
+ /**
+ * Create a normal distribution using the given mean and standard deviation.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param mean Mean for this distribution.
+ * @param sd Standard deviation for this distribution.
+ * @throws NotStrictlyPositiveException if {@code sd <= 0}.
+ */
+ public NormalDistribution(double mean, double sd)
+ throws NotStrictlyPositiveException {
+ this(mean, sd, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
+ }
+
+ /**
+ * Create a normal distribution using the given mean, standard deviation and
+ * inverse cumulative distribution accuracy.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param mean Mean for this distribution.
+ * @param sd Standard deviation for this distribution.
+ * @param inverseCumAccuracy Inverse cumulative probability accuracy.
+ * @throws NotStrictlyPositiveException if {@code sd <= 0}.
+ * @since 2.1
+ */
+ public NormalDistribution(double mean, double sd, double inverseCumAccuracy)
+ throws NotStrictlyPositiveException {
+ this(new Well19937c(), mean, sd, inverseCumAccuracy);
+ }
+
+ /**
+ * Creates a normal distribution.
+ *
+ * @param rng Random number generator.
+ * @param mean Mean for this distribution.
+ * @param sd Standard deviation for this distribution.
+ * @throws NotStrictlyPositiveException if {@code sd <= 0}.
+ * @since 3.3
+ */
+ public NormalDistribution(RandomGenerator rng, double mean, double sd)
+ throws NotStrictlyPositiveException {
+ this(rng, mean, sd, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
+ }
+
+ /**
+ * Creates a normal distribution.
+ *
+ * @param rng Random number generator.
+ * @param mean Mean for this distribution.
+ * @param sd Standard deviation for this distribution.
+ * @param inverseCumAccuracy Inverse cumulative probability accuracy.
+ * @throws NotStrictlyPositiveException if {@code sd <= 0}.
+ * @since 3.1
+ */
+ public NormalDistribution(RandomGenerator rng,
+ double mean,
+ double sd,
+ double inverseCumAccuracy)
+ throws NotStrictlyPositiveException {
+ super(rng);
+
+ if (sd <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.STANDARD_DEVIATION, sd);
+ }
+
+ this.mean = mean;
+ standardDeviation = sd;
+ logStandardDeviationPlusHalfLog2Pi = FastMath.log(sd) + 0.5 * FastMath.log(2 * FastMath.PI);
+ solverAbsoluteAccuracy = inverseCumAccuracy;
+ }
+
+ /**
+ * Access the mean.
+ *
+ * @return the mean for this distribution.
+ */
+ public double getMean() {
+ return mean;
+ }
+
+ /**
+ * Access the standard deviation.
+ *
+ * @return the standard deviation for this distribution.
+ */
+ public double getStandardDeviation() {
+ return standardDeviation;
+ }
+
+ /** {@inheritDoc} */
+ public double density(double x) {
+ return FastMath.exp(logDensity(x));
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double logDensity(double x) {
+ final double x0 = x - mean;
+ final double x1 = x0 / standardDeviation;
+ return -0.5 * x1 * x1 - logStandardDeviationPlusHalfLog2Pi;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * If {@code x} 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} of 0 or 1.
+ */
+ public double cumulativeProbability(double x) {
+ final double dev = x - mean;
+ if (FastMath.abs(dev) > 40 * standardDeviation) {
+ return dev < 0 ? 0.0d : 1.0d;
+ }
+ return 0.5 * Erf.erfc(-dev / (standardDeviation * SQRT2));
+ }
+
+ /** {@inheritDoc}
+ * @since 3.2
+ */
+ @Override
+ public double inverseCumulativeProbability(final double p) throws OutOfRangeException {
+ if (p < 0.0 || p > 1.0) {
+ throw new OutOfRangeException(p, 0, 1);
+ }
+ return mean + standardDeviation * SQRT2 * Erf.erfInv(2 * p - 1);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @deprecated See {@link RealDistribution#cumulativeProbability(double,double)}
+ */
+ @Override@Deprecated
+ public double cumulativeProbability(double x0, double x1)
+ throws NumberIsTooLargeException {
+ return probability(x0, x1);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double probability(double x0,
+ double x1)
+ throws NumberIsTooLargeException {
+ if (x0 > x1) {
+ throw new NumberIsTooLargeException(LocalizedFormats.LOWER_ENDPOINT_ABOVE_UPPER_ENDPOINT,
+ x0, x1, true);
+ }
+ final double denom = standardDeviation * SQRT2;
+ final double v0 = (x0 - mean) / denom;
+ final double v1 = (x1 - mean) / denom;
+ return 0.5 * Erf.erf(v0, v1);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ protected double getSolverAbsoluteAccuracy() {
+ return solverAbsoluteAccuracy;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For mean parameter {@code mu}, the mean is {@code mu}.
+ */
+ public double getNumericalMean() {
+ return getMean();
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For standard deviation parameter {@code s}, the variance is {@code s^2}.
+ */
+ public double getNumericalVariance() {
+ final double s = getStandardDeviation();
+ return s * s;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The lower bound of the support is always negative infinity
+ * no matter the parameters.
+ *
+ * @return lower bound of the support (always
+ * {@code Double.NEGATIVE_INFINITY})
+ */
+ public double getSupportLowerBound() {
+ return Double.NEGATIVE_INFINITY;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The upper bound of the support is always positive infinity
+ * no matter the parameters.
+ *
+ * @return upper bound of the support (always
+ * {@code Double.POSITIVE_INFINITY})
+ */
+ public double getSupportUpperBound() {
+ return Double.POSITIVE_INFINITY;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportLowerBoundInclusive() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportUpperBoundInclusive() {
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The support of this distribution is connected.
+ *
+ * @return {@code true}
+ */
+ public boolean isSupportConnected() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double sample() {
+ return standardDeviation * random.nextGaussian() + mean;
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/ParetoDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/ParetoDistribution.java
new file mode 100644
index 000000000..49f4517a8
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/ParetoDistribution.java
@@ -0,0 +1,318 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException;
+import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.random.RandomGenerator;
+import com.fr.third.org.apache.commons.math3.random.Well19937c;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+
+/**
+ * Implementation of the Pareto distribution.
+ *
+ *
+ * Parameters:
+ * The probability distribution function of {@code X} is given by (for {@code x >= k}):
+ *
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param scale the scale parameter of this distribution
+ * @param shape the shape parameter of this distribution
+ * @throws NotStrictlyPositiveException if {@code scale <= 0} or {@code shape <= 0}.
+ */
+ public ParetoDistribution(double scale, double shape)
+ throws NotStrictlyPositiveException {
+ this(scale, shape, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
+ }
+
+ /**
+ * Create a Pareto distribution using the specified scale, shape and
+ * inverse cumulative distribution accuracy.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param scale the scale parameter of this distribution
+ * @param shape the shape parameter of this distribution
+ * @param inverseCumAccuracy Inverse cumulative probability accuracy.
+ * @throws NotStrictlyPositiveException if {@code scale <= 0} or {@code shape <= 0}.
+ */
+ public ParetoDistribution(double scale, double shape, double inverseCumAccuracy)
+ throws NotStrictlyPositiveException {
+ this(new Well19937c(), scale, shape, inverseCumAccuracy);
+ }
+
+ /**
+ * Creates a Pareto distribution.
+ *
+ * @param rng Random number generator.
+ * @param scale Scale parameter of this distribution.
+ * @param shape Shape parameter of this distribution.
+ * @throws NotStrictlyPositiveException if {@code scale <= 0} or {@code shape <= 0}.
+ */
+ public ParetoDistribution(RandomGenerator rng, double scale, double shape)
+ throws NotStrictlyPositiveException {
+ this(rng, scale, shape, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
+ }
+
+ /**
+ * Creates a Pareto distribution.
+ *
+ * @param rng Random number generator.
+ * @param scale Scale parameter of this distribution.
+ * @param shape Shape parameter of this distribution.
+ * @param inverseCumAccuracy Inverse cumulative probability accuracy.
+ * @throws NotStrictlyPositiveException if {@code scale <= 0} or {@code shape <= 0}.
+ */
+ public ParetoDistribution(RandomGenerator rng,
+ double scale,
+ double shape,
+ double inverseCumAccuracy)
+ throws NotStrictlyPositiveException {
+ super(rng);
+
+ if (scale <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.SCALE, scale);
+ }
+
+ if (shape <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.SHAPE, shape);
+ }
+
+ this.scale = scale;
+ this.shape = shape;
+ this.solverAbsoluteAccuracy = inverseCumAccuracy;
+ }
+
+ /**
+ * Returns the scale parameter of this distribution.
+ *
+ * @return the scale parameter
+ */
+ public double getScale() {
+ return scale;
+ }
+
+ /**
+ * Returns the shape parameter of this distribution.
+ *
+ * @return the shape parameter
+ */
+ public double getShape() {
+ return shape;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For scale {@code k}, and shape {@code α} of this distribution, the PDF
+ * is given by
+ *
+ * For scale {@code k}, and shape {@code α} of this distribution, the CDF is given by
+ *
+ * For scale {@code k} and shape {@code α}, the mean is given by
+ *
+ * For scale {@code k} and shape {@code α}, the variance is given by
+ *
+ * The lower bound of the support is equal to the scale parameter {@code k}.
+ *
+ * @return lower bound of the support
+ */
+ public double getSupportLowerBound() {
+ return scale;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The upper bound of the support is always positive infinity no matter the parameters.
+ *
+ * @return upper bound of the support (always {@code Double.POSITIVE_INFINITY})
+ */
+ public double getSupportUpperBound() {
+ return Double.POSITIVE_INFINITY;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportLowerBoundInclusive() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportUpperBoundInclusive() {
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The support of this distribution is connected.
+ *
+ * @return {@code true}
+ */
+ public boolean isSupportConnected() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double sample() {
+ final double n = random.nextDouble();
+ return scale / FastMath.pow(n, 1 / shape);
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/PascalDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/PascalDistribution.java
new file mode 100644
index 000000000..29ee2e1af
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/PascalDistribution.java
@@ -0,0 +1,248 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException;
+import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.random.RandomGenerator;
+import com.fr.third.org.apache.commons.math3.random.Well19937c;
+import com.fr.third.org.apache.commons.math3.special.Beta;
+import com.fr.third.org.apache.commons.math3.util.CombinatoricsUtils;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+
+/**
+ *
+ * Implementation of the Pascal distribution. The Pascal distribution is a
+ * special case of the Negative Binomial distribution where the number of
+ * successes parameter is an integer.
+ *
+ * There are various ways to express the probability mass and distribution
+ * functions for the Pascal distribution. The present implementation represents
+ * the distribution of the number of failures before {@code r} successes occur.
+ * This is the convention adopted in e.g.
+ * MathWorld,
+ * but not in
+ * Wikipedia.
+ *
+ * For a random variable {@code X} whose values are distributed according to this
+ * distribution, the probability mass function is given by
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param r Number of successes.
+ * @param p Probability of success.
+ * @throws NotStrictlyPositiveException if the number of successes is not positive
+ * @throws OutOfRangeException if the probability of success is not in the
+ * range {@code [0, 1]}.
+ */
+ public PascalDistribution(int r, double p)
+ throws NotStrictlyPositiveException, OutOfRangeException {
+ this(new Well19937c(), r, p);
+ }
+
+ /**
+ * Create a Pascal distribution with the given number of successes and
+ * probability of success.
+ *
+ * @param rng Random number generator.
+ * @param r Number of successes.
+ * @param p Probability of success.
+ * @throws NotStrictlyPositiveException if the number of successes is not positive
+ * @throws OutOfRangeException if the probability of success is not in the
+ * range {@code [0, 1]}.
+ * @since 3.1
+ */
+ public PascalDistribution(RandomGenerator rng,
+ int r,
+ double p)
+ throws NotStrictlyPositiveException, OutOfRangeException {
+ super(rng);
+
+ if (r <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.NUMBER_OF_SUCCESSES,
+ r);
+ }
+ if (p < 0 || p > 1) {
+ throw new OutOfRangeException(p, 0, 1);
+ }
+
+ numberOfSuccesses = r;
+ probabilityOfSuccess = p;
+ logProbabilityOfSuccess = FastMath.log(p);
+ log1mProbabilityOfSuccess = FastMath.log1p(-p);
+ }
+
+ /**
+ * Access the number of successes for this distribution.
+ *
+ * @return the number of successes.
+ */
+ public int getNumberOfSuccesses() {
+ return numberOfSuccesses;
+ }
+
+ /**
+ * Access the probability of success for this distribution.
+ *
+ * @return the probability of success.
+ */
+ public double getProbabilityOfSuccess() {
+ return probabilityOfSuccess;
+ }
+
+ /** {@inheritDoc} */
+ public double probability(int x) {
+ double ret;
+ if (x < 0) {
+ ret = 0.0;
+ } else {
+ ret = CombinatoricsUtils.binomialCoefficientDouble(x +
+ numberOfSuccesses - 1, numberOfSuccesses - 1) *
+ FastMath.pow(probabilityOfSuccess, numberOfSuccesses) *
+ FastMath.pow(1.0 - probabilityOfSuccess, x);
+ }
+ return ret;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double logProbability(int x) {
+ double ret;
+ if (x < 0) {
+ ret = Double.NEGATIVE_INFINITY;
+ } else {
+ ret = CombinatoricsUtils.binomialCoefficientLog(x +
+ numberOfSuccesses - 1, numberOfSuccesses - 1) +
+ logProbabilityOfSuccess * numberOfSuccesses +
+ log1mProbabilityOfSuccess * x;
+ }
+ return ret;
+ }
+
+ /** {@inheritDoc} */
+ public double cumulativeProbability(int x) {
+ double ret;
+ if (x < 0) {
+ ret = 0.0;
+ } else {
+ ret = Beta.regularizedBeta(probabilityOfSuccess,
+ numberOfSuccesses, x + 1.0);
+ }
+ return ret;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For number of successes {@code r} and probability of success {@code p},
+ * the mean is {@code r * (1 - p) / p}.
+ */
+ public double getNumericalMean() {
+ final double p = getProbabilityOfSuccess();
+ final double r = getNumberOfSuccesses();
+ return (r * (1 - p)) / p;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For number of successes {@code r} and probability of success {@code p},
+ * the variance is {@code r * (1 - p) / p^2}.
+ */
+ public double getNumericalVariance() {
+ final double p = getProbabilityOfSuccess();
+ final double r = getNumberOfSuccesses();
+ return r * (1 - p) / (p * p);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The lower bound of the support is always 0 no matter the parameters.
+ *
+ * @return lower bound of the support (always 0)
+ */
+ public int getSupportLowerBound() {
+ return 0;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The upper bound of the support is always positive infinity no matter the
+ * parameters. Positive infinity is symbolized by {@code Integer.MAX_VALUE}.
+ *
+ * @return upper bound of the support (always {@code Integer.MAX_VALUE}
+ * for positive infinity)
+ */
+ public int getSupportUpperBound() {
+ return Integer.MAX_VALUE;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The support of this distribution is connected.
+ *
+ * @return {@code true}
+ */
+ public boolean isSupportConnected() {
+ return true;
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/PoissonDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/PoissonDistribution.java
new file mode 100644
index 000000000..2f37d8154
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/PoissonDistribution.java
@@ -0,0 +1,395 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.random.RandomGenerator;
+import com.fr.third.org.apache.commons.math3.random.Well19937c;
+import com.fr.third.org.apache.commons.math3.special.Gamma;
+import com.fr.third.org.apache.commons.math3.util.CombinatoricsUtils;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+import com.fr.third.org.apache.commons.math3.util.MathUtils;
+
+/**
+ * Implementation of the Poisson distribution.
+ *
+ * @see Poisson distribution (Wikipedia)
+ * @see Poisson distribution (MathWorld)
+ */
+public class PoissonDistribution extends AbstractIntegerDistribution {
+ /**
+ * Default maximum number of iterations for cumulative probability calculations.
+ * @since 2.1
+ */
+ public static final int DEFAULT_MAX_ITERATIONS = 10000000;
+ /**
+ * Default convergence criterion.
+ * @since 2.1
+ */
+ public static final double DEFAULT_EPSILON = 1e-12;
+ /** Serializable version identifier. */
+ private static final long serialVersionUID = -3349935121172596109L;
+ /** Distribution used to compute normal approximation. */
+ private final NormalDistribution normal;
+ /** Distribution needed for the {@link #sample()} method. */
+ private final ExponentialDistribution exponential;
+ /** Mean of the distribution. */
+ private final double mean;
+
+ /**
+ * Maximum number of iterations for cumulative probability. Cumulative
+ * probabilities are estimated using either Lanczos series approximation
+ * of {@link Gamma#regularizedGammaP(double, double, double, int)}
+ * or continued fraction approximation of
+ * {@link Gamma#regularizedGammaQ(double, double, double, int)}.
+ */
+ private final int maxIterations;
+
+ /** Convergence criterion for cumulative probability. */
+ private final double epsilon;
+
+ /**
+ * Creates a new Poisson distribution with specified mean.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param p the Poisson mean
+ * @throws NotStrictlyPositiveException if {@code p <= 0}.
+ */
+ public PoissonDistribution(double p) throws NotStrictlyPositiveException {
+ this(p, DEFAULT_EPSILON, DEFAULT_MAX_ITERATIONS);
+ }
+
+ /**
+ * Creates a new Poisson distribution with specified mean, convergence
+ * criterion and maximum number of iterations.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param p Poisson mean.
+ * @param epsilon Convergence criterion for cumulative probabilities.
+ * @param maxIterations the maximum number of iterations for cumulative
+ * probabilities.
+ * @throws NotStrictlyPositiveException if {@code p <= 0}.
+ * @since 2.1
+ */
+ public PoissonDistribution(double p, double epsilon, int maxIterations)
+ throws NotStrictlyPositiveException {
+ this(new Well19937c(), p, epsilon, maxIterations);
+ }
+
+ /**
+ * Creates a new Poisson distribution with specified mean, convergence
+ * criterion and maximum number of iterations.
+ *
+ * @param rng Random number generator.
+ * @param p Poisson mean.
+ * @param epsilon Convergence criterion for cumulative probabilities.
+ * @param maxIterations the maximum number of iterations for cumulative
+ * probabilities.
+ * @throws NotStrictlyPositiveException if {@code p <= 0}.
+ * @since 3.1
+ */
+ public PoissonDistribution(RandomGenerator rng,
+ double p,
+ double epsilon,
+ int maxIterations)
+ throws NotStrictlyPositiveException {
+ super(rng);
+
+ if (p <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.MEAN, p);
+ }
+ mean = p;
+ this.epsilon = epsilon;
+ this.maxIterations = maxIterations;
+
+ // Use the same RNG instance as the parent class.
+ normal = new NormalDistribution(rng, p, FastMath.sqrt(p),
+ NormalDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
+ exponential = new ExponentialDistribution(rng, 1,
+ ExponentialDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
+ }
+
+ /**
+ * Creates a new Poisson distribution with the specified mean and
+ * convergence criterion.
+ *
+ * @param p Poisson mean.
+ * @param epsilon Convergence criterion for cumulative probabilities.
+ * @throws NotStrictlyPositiveException if {@code p <= 0}.
+ * @since 2.1
+ */
+ public PoissonDistribution(double p, double epsilon)
+ throws NotStrictlyPositiveException {
+ this(p, epsilon, DEFAULT_MAX_ITERATIONS);
+ }
+
+ /**
+ * Creates a new Poisson distribution with the specified mean and maximum
+ * number of iterations.
+ *
+ * @param p Poisson mean.
+ * @param maxIterations Maximum number of iterations for cumulative
+ * probabilities.
+ * @since 2.1
+ */
+ public PoissonDistribution(double p, int maxIterations) {
+ this(p, DEFAULT_EPSILON, maxIterations);
+ }
+
+ /**
+ * Get the mean for the distribution.
+ *
+ * @return the mean for the distribution.
+ */
+ public double getMean() {
+ return mean;
+ }
+
+ /** {@inheritDoc} */
+ public double probability(int x) {
+ final double logProbability = logProbability(x);
+ return logProbability == Double.NEGATIVE_INFINITY ? 0 : FastMath.exp(logProbability);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double logProbability(int x) {
+ double ret;
+ if (x < 0 || x == Integer.MAX_VALUE) {
+ ret = Double.NEGATIVE_INFINITY;
+ } else if (x == 0) {
+ ret = -mean;
+ } else {
+ ret = -SaddlePointExpansion.getStirlingError(x) -
+ SaddlePointExpansion.getDeviancePart(x, mean) -
+ 0.5 * FastMath.log(MathUtils.TWO_PI) - 0.5 * FastMath.log(x);
+ }
+ return ret;
+ }
+
+ /** {@inheritDoc} */
+ public double cumulativeProbability(int x) {
+ if (x < 0) {
+ return 0;
+ }
+ if (x == Integer.MAX_VALUE) {
+ return 1;
+ }
+ return Gamma.regularizedGammaQ((double) x + 1, mean, epsilon,
+ maxIterations);
+ }
+
+ /**
+ * Calculates the Poisson distribution function using a normal
+ * approximation. The {@code N(mean, sqrt(mean))} distribution is used
+ * to approximate the Poisson distribution. The computation uses
+ * "half-correction" (evaluating the normal distribution function at
+ * {@code x + 0.5}).
+ *
+ * @param x Upper bound, inclusive.
+ * @return the distribution function value calculated using a normal
+ * approximation.
+ */
+ public double normalApproximateProbability(int x) {
+ // calculate the probability using half-correction
+ return normal.cumulativeProbability(x + 0.5);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For mean parameter {@code p}, the mean is {@code p}.
+ */
+ public double getNumericalMean() {
+ return getMean();
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For mean parameter {@code p}, the variance is {@code p}.
+ */
+ public double getNumericalVariance() {
+ return getMean();
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The lower bound of the support is always 0 no matter the mean parameter.
+ *
+ * @return lower bound of the support (always 0)
+ */
+ public int getSupportLowerBound() {
+ return 0;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * 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}.
+ *
+ * @return upper bound of the support (always {@code Integer.MAX_VALUE} for
+ * positive infinity)
+ */
+ public int getSupportUpperBound() {
+ return Integer.MAX_VALUE;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The support of this distribution is connected.
+ *
+ * @return {@code true}
+ */
+ public boolean isSupportConnected() {
+ return true;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * Algorithm Description:
+ *
+ * Utility class used by various distributions to accurately compute their
+ * respective probability mass functions. The implementation for this class is
+ * based on the Catherine Loader's dbinom routines.
+ *
+ * This class is not intended to be called directly.
+ *
+ * References:
+ *
+ * References:
+ *
+ * References:
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param degreesOfFreedom Degrees of freedom.
+ * @throws NotStrictlyPositiveException if {@code degreesOfFreedom <= 0}
+ */
+ public TDistribution(double degreesOfFreedom)
+ throws NotStrictlyPositiveException {
+ this(degreesOfFreedom, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
+ }
+
+ /**
+ * Create a t distribution using the given degrees of freedom and the
+ * specified inverse cumulative probability absolute accuracy.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param degreesOfFreedom Degrees of freedom.
+ * @param inverseCumAccuracy the maximum absolute error in inverse
+ * cumulative probability estimates
+ * (defaults to {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}).
+ * @throws NotStrictlyPositiveException if {@code degreesOfFreedom <= 0}
+ * @since 2.1
+ */
+ public TDistribution(double degreesOfFreedom, double inverseCumAccuracy)
+ throws NotStrictlyPositiveException {
+ this(new Well19937c(), degreesOfFreedom, inverseCumAccuracy);
+ }
+
+ /**
+ * Creates a t distribution.
+ *
+ * @param rng Random number generator.
+ * @param degreesOfFreedom Degrees of freedom.
+ * @throws NotStrictlyPositiveException if {@code degreesOfFreedom <= 0}
+ * @since 3.3
+ */
+ public TDistribution(RandomGenerator rng, double degreesOfFreedom)
+ throws NotStrictlyPositiveException {
+ this(rng, degreesOfFreedom, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
+ }
+
+ /**
+ * Creates a t distribution.
+ *
+ * @param rng Random number generator.
+ * @param degreesOfFreedom Degrees of freedom.
+ * @param inverseCumAccuracy the maximum absolute error in inverse
+ * cumulative probability estimates
+ * (defaults to {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}).
+ * @throws NotStrictlyPositiveException if {@code degreesOfFreedom <= 0}
+ * @since 3.1
+ */
+ public TDistribution(RandomGenerator rng,
+ double degreesOfFreedom,
+ double inverseCumAccuracy)
+ throws NotStrictlyPositiveException {
+ super(rng);
+
+ if (degreesOfFreedom <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.DEGREES_OF_FREEDOM,
+ degreesOfFreedom);
+ }
+ this.degreesOfFreedom = degreesOfFreedom;
+ solverAbsoluteAccuracy = inverseCumAccuracy;
+
+ final double n = degreesOfFreedom;
+ final double nPlus1Over2 = (n + 1) / 2;
+ factor = Gamma.logGamma(nPlus1Over2) -
+ 0.5 * (FastMath.log(FastMath.PI) + FastMath.log(n)) -
+ Gamma.logGamma(n / 2);
+ }
+
+ /**
+ * Access the degrees of freedom.
+ *
+ * @return the degrees of freedom.
+ */
+ public double getDegreesOfFreedom() {
+ return degreesOfFreedom;
+ }
+
+ /** {@inheritDoc} */
+ public double density(double x) {
+ return FastMath.exp(logDensity(x));
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double logDensity(double x) {
+ final double n = degreesOfFreedom;
+ final double nPlus1Over2 = (n + 1) / 2;
+ return factor - nPlus1Over2 * FastMath.log(1 + x * x / n);
+ }
+
+ /** {@inheritDoc} */
+ public double cumulativeProbability(double x) {
+ double ret;
+ if (x == 0) {
+ ret = 0.5;
+ } else {
+ double t =
+ Beta.regularizedBeta(
+ degreesOfFreedom / (degreesOfFreedom + (x * x)),
+ 0.5 * degreesOfFreedom,
+ 0.5);
+ if (x < 0.0) {
+ ret = 0.5 * t;
+ } else {
+ ret = 1.0 - 0.5 * t;
+ }
+ }
+
+ return ret;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ protected double getSolverAbsoluteAccuracy() {
+ return solverAbsoluteAccuracy;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For degrees of freedom parameter {@code df}, the mean is
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param a Lower limit of this distribution (inclusive).
+ * @param b Upper limit of this distribution (inclusive).
+ * @param c Mode of this distribution.
+ * @throws NumberIsTooLargeException if {@code a >= b} or if {@code c > b}.
+ * @throws NumberIsTooSmallException if {@code c < a}.
+ */
+ public TriangularDistribution(double a, double c, double b)
+ throws NumberIsTooLargeException, NumberIsTooSmallException {
+ this(new Well19937c(), a, c, b);
+ }
+
+ /**
+ * Creates a triangular distribution.
+ *
+ * @param rng Random number generator.
+ * @param a Lower limit of this distribution (inclusive).
+ * @param b Upper limit of this distribution (inclusive).
+ * @param c Mode of this distribution.
+ * @throws NumberIsTooLargeException if {@code a >= b} or if {@code c > b}.
+ * @throws NumberIsTooSmallException if {@code c < a}.
+ * @since 3.1
+ */
+ public TriangularDistribution(RandomGenerator rng,
+ double a,
+ double c,
+ double b)
+ throws NumberIsTooLargeException, NumberIsTooSmallException {
+ super(rng);
+
+ if (a >= b) {
+ throw new NumberIsTooLargeException(
+ LocalizedFormats.LOWER_BOUND_NOT_BELOW_UPPER_BOUND,
+ a, b, false);
+ }
+ if (c < a) {
+ throw new NumberIsTooSmallException(
+ LocalizedFormats.NUMBER_TOO_SMALL, c, a, true);
+ }
+ if (c > b) {
+ throw new NumberIsTooLargeException(
+ LocalizedFormats.NUMBER_TOO_LARGE, c, b, true);
+ }
+
+ this.a = a;
+ this.c = c;
+ this.b = b;
+ solverAbsoluteAccuracy = FastMath.max(FastMath.ulp(a), FastMath.ulp(b));
+ }
+
+ /**
+ * Returns the mode {@code c} of this distribution.
+ *
+ * @return the mode {@code c} of this distribution
+ */
+ public double getMode() {
+ return c;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ *
+ * For this distribution, the returned value is not really meaningful,
+ * since exact formulas are implemented for the computation of the
+ * {@link #inverseCumulativeProbability(double)} (no solver is invoked).
+ *
+ * For lower limit {@code a} and upper limit {@code b}, the current
+ * implementation returns {@code max(ulp(a), ulp(b)}.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param lower Lower bound (inclusive) of this distribution.
+ * @param upper Upper bound (inclusive) of this distribution.
+ * @throws NumberIsTooLargeException if {@code lower >= upper}.
+ */
+ public UniformIntegerDistribution(int lower, int upper)
+ throws NumberIsTooLargeException {
+ this(new Well19937c(), lower, upper);
+ }
+
+ /**
+ * Creates a new uniform integer distribution using the given lower and
+ * upper bounds (both inclusive).
+ *
+ * @param rng Random number generator.
+ * @param lower Lower bound (inclusive) of this distribution.
+ * @param upper Upper bound (inclusive) of this distribution.
+ * @throws NumberIsTooLargeException if {@code lower > upper}.
+ * @since 3.1
+ */
+ public UniformIntegerDistribution(RandomGenerator rng,
+ int lower,
+ int upper)
+ throws NumberIsTooLargeException {
+ super(rng);
+
+ if (lower > upper) {
+ throw new NumberIsTooLargeException(
+ LocalizedFormats.LOWER_BOUND_NOT_BELOW_UPPER_BOUND,
+ lower, upper, true);
+ }
+ this.lower = lower;
+ this.upper = upper;
+ }
+
+ /** {@inheritDoc} */
+ public double probability(int x) {
+ if (x < lower || x > upper) {
+ return 0;
+ }
+ return 1.0 / (upper - lower + 1);
+ }
+
+ /** {@inheritDoc} */
+ public double cumulativeProbability(int x) {
+ if (x < lower) {
+ return 0;
+ }
+ if (x > upper) {
+ return 1;
+ }
+ return (x - lower + 1.0) / (upper - lower + 1.0);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For lower bound {@code lower} and upper bound {@code upper}, the mean is
+ * {@code 0.5 * (lower + upper)}.
+ */
+ public double getNumericalMean() {
+ return 0.5 * (lower + upper);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For lower bound {@code lower} and upper bound {@code upper}, and
+ * {@code n = upper - lower + 1}, the variance is {@code (n^2 - 1) / 12}.
+ */
+ public double getNumericalVariance() {
+ double n = upper - lower + 1;
+ return (n * n - 1) / 12.0;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The lower bound of the support is equal to the lower bound parameter
+ * of the distribution.
+ *
+ * @return lower bound of the support
+ */
+ public int getSupportLowerBound() {
+ return lower;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The upper bound of the support is equal to the upper bound parameter
+ * of the distribution.
+ *
+ * @return upper bound of the support
+ */
+ public int getSupportUpperBound() {
+ return upper;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The support of this distribution is connected.
+ *
+ * @return {@code true}
+ */
+ public boolean isSupportConnected() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public int sample() {
+ final int max = (upper - lower) + 1;
+ if (max <= 0) {
+ // The range is too wide to fit in a positive int (larger
+ // than 2^31); as it covers more than half the integer range,
+ // we use a simple rejection method.
+ while (true) {
+ final int r = random.nextInt();
+ if (r >= lower &&
+ r <= upper) {
+ return r;
+ }
+ }
+ } else {
+ // We can shift the range and directly generate a positive int.
+ return lower + random.nextInt(max);
+ }
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/UniformRealDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/UniformRealDistribution.java
new file mode 100644
index 000000000..3a5973956
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/UniformRealDistribution.java
@@ -0,0 +1,244 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException;
+import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.random.RandomGenerator;
+import com.fr.third.org.apache.commons.math3.random.Well19937c;
+
+/**
+ * Implementation of the uniform real distribution.
+ *
+ * @see Uniform distribution (continuous), at Wikipedia
+ *
+ * @since 3.0
+ */
+public class UniformRealDistribution extends AbstractRealDistribution {
+ /** Default inverse cumulative probability accuracy.
+ * @deprecated as of 3.2 not used anymore, will be removed in 4.0
+ */
+ @Deprecated
+ public static final double DEFAULT_INVERSE_ABSOLUTE_ACCURACY = 1e-9;
+ /** Serializable version identifier. */
+ private static final long serialVersionUID = 20120109L;
+ /** Lower bound of this distribution (inclusive). */
+ private final double lower;
+ /** Upper bound of this distribution (exclusive). */
+ private final double upper;
+
+ /**
+ * Create a standard uniform real distribution with lower bound (inclusive)
+ * equal to zero and upper bound (exclusive) equal to one.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ */
+ public UniformRealDistribution() {
+ this(0, 1);
+ }
+
+ /**
+ * Create a uniform real distribution using the given lower and upper
+ * bounds.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param lower Lower bound of this distribution (inclusive).
+ * @param upper Upper bound of this distribution (exclusive).
+ * @throws NumberIsTooLargeException if {@code lower >= upper}.
+ */
+ public UniformRealDistribution(double lower, double upper)
+ throws NumberIsTooLargeException {
+ this(new Well19937c(), lower, upper);
+ }
+
+ /**
+ * Create a uniform distribution.
+ *
+ * @param lower Lower bound of this distribution (inclusive).
+ * @param upper Upper bound of this distribution (exclusive).
+ * @param inverseCumAccuracy Inverse cumulative probability accuracy.
+ * @throws NumberIsTooLargeException if {@code lower >= upper}.
+ * @deprecated as of 3.2, inverse CDF is now calculated analytically, use
+ * {@link #UniformRealDistribution(double, double)} instead.
+ */
+ @Deprecated
+ public UniformRealDistribution(double lower, double upper, double inverseCumAccuracy)
+ throws NumberIsTooLargeException {
+ this(new Well19937c(), lower, upper);
+ }
+
+ /**
+ * Creates a uniform distribution.
+ *
+ * @param rng Random number generator.
+ * @param lower Lower bound of this distribution (inclusive).
+ * @param upper Upper bound of this distribution (exclusive).
+ * @param inverseCumAccuracy Inverse cumulative probability accuracy.
+ * @throws NumberIsTooLargeException if {@code lower >= upper}.
+ * @since 3.1
+ * @deprecated as of 3.2, inverse CDF is now calculated analytically, use
+ * {@link #UniformRealDistribution(RandomGenerator, double, double)}
+ * instead.
+ */
+ @Deprecated
+ public UniformRealDistribution(RandomGenerator rng,
+ double lower,
+ double upper,
+ double inverseCumAccuracy){
+ this(rng, lower, upper);
+ }
+
+ /**
+ * Creates a uniform distribution.
+ *
+ * @param rng Random number generator.
+ * @param lower Lower bound of this distribution (inclusive).
+ * @param upper Upper bound of this distribution (exclusive).
+ * @throws NumberIsTooLargeException if {@code lower >= upper}.
+ * @since 3.1
+ */
+ public UniformRealDistribution(RandomGenerator rng,
+ double lower,
+ double upper)
+ throws NumberIsTooLargeException {
+ super(rng);
+ if (lower >= upper) {
+ throw new NumberIsTooLargeException(
+ LocalizedFormats.LOWER_BOUND_NOT_BELOW_UPPER_BOUND,
+ lower, upper, false);
+ }
+
+ this.lower = lower;
+ this.upper = upper;
+ }
+
+ /** {@inheritDoc} */
+ public double density(double x) {
+ if (x < lower || x > upper) {
+ return 0.0;
+ }
+ return 1 / (upper - lower);
+ }
+
+ /** {@inheritDoc} */
+ public double cumulativeProbability(double x) {
+ if (x <= lower) {
+ return 0;
+ }
+ if (x >= upper) {
+ return 1;
+ }
+ return (x - lower) / (upper - lower);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double inverseCumulativeProbability(final double p)
+ throws OutOfRangeException {
+ if (p < 0.0 || p > 1.0) {
+ throw new OutOfRangeException(p, 0, 1);
+ }
+ return p * (upper - lower) + lower;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For lower bound {@code lower} and upper bound {@code upper}, the mean is
+ * {@code 0.5 * (lower + upper)}.
+ */
+ public double getNumericalMean() {
+ return 0.5 * (lower + upper);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For lower bound {@code lower} and upper bound {@code upper}, the
+ * variance is {@code (upper - lower)^2 / 12}.
+ */
+ public double getNumericalVariance() {
+ double ul = upper - lower;
+ return ul * ul / 12;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The lower bound of the support is equal to the lower bound parameter
+ * of the distribution.
+ *
+ * @return lower bound of the support
+ */
+ public double getSupportLowerBound() {
+ return lower;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The upper bound of the support is equal to the upper bound parameter
+ * of the distribution.
+ *
+ * @return upper bound of the support
+ */
+ public double getSupportUpperBound() {
+ return upper;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportLowerBoundInclusive() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportUpperBoundInclusive() {
+ return true;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The support of this distribution is connected.
+ *
+ * @return {@code true}
+ */
+ public boolean isSupportConnected() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double sample() {
+ final double u = random.nextDouble();
+ return u * upper + (1 - u) * lower;
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/WeibullDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/WeibullDistribution.java
new file mode 100644
index 000000000..917ed71d0
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/WeibullDistribution.java
@@ -0,0 +1,353 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException;
+import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.random.RandomGenerator;
+import com.fr.third.org.apache.commons.math3.random.Well19937c;
+import com.fr.third.org.apache.commons.math3.special.Gamma;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+
+/**
+ * Implementation of the Weibull distribution. This implementation uses the
+ * two parameter form of the distribution defined by
+ *
+ * Weibull Distribution, equations (1) and (2).
+ *
+ * @see Weibull distribution (Wikipedia)
+ * @see Weibull distribution (MathWorld)
+ * @since 1.1 (changed to concrete class in 3.0)
+ */
+public class WeibullDistribution extends AbstractRealDistribution {
+ /**
+ * Default inverse cumulative probability accuracy.
+ * @since 2.1
+ */
+ public static final double DEFAULT_INVERSE_ABSOLUTE_ACCURACY = 1e-9;
+ /** Serializable version identifier. */
+ private static final long serialVersionUID = 8589540077390120676L;
+ /** The shape parameter. */
+ private final double shape;
+ /** The scale parameter. */
+ private final double scale;
+ /** Inverse cumulative probability accuracy. */
+ private final double solverAbsoluteAccuracy;
+ /** Cached numerical mean */
+ private double numericalMean = Double.NaN;
+ /** Whether or not the numerical mean has been calculated */
+ private boolean numericalMeanIsCalculated = false;
+ /** Cached numerical variance */
+ private double numericalVariance = Double.NaN;
+ /** Whether or not the numerical variance has been calculated */
+ private boolean numericalVarianceIsCalculated = false;
+
+ /**
+ * Create a Weibull distribution with the given shape and scale and a
+ * location equal to zero.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param alpha Shape parameter.
+ * @param beta Scale parameter.
+ * @throws NotStrictlyPositiveException if {@code alpha <= 0} or
+ * {@code beta <= 0}.
+ */
+ public WeibullDistribution(double alpha, double beta)
+ throws NotStrictlyPositiveException {
+ this(alpha, beta, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
+ }
+
+ /**
+ * Create a Weibull distribution with the given shape, scale and inverse
+ * cumulative probability accuracy and a location equal to zero.
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param alpha Shape parameter.
+ * @param beta Scale parameter.
+ * @param inverseCumAccuracy Maximum absolute error in inverse
+ * cumulative probability estimates
+ * (defaults to {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}).
+ * @throws NotStrictlyPositiveException if {@code alpha <= 0} or
+ * {@code beta <= 0}.
+ * @since 2.1
+ */
+ public WeibullDistribution(double alpha, double beta,
+ double inverseCumAccuracy) {
+ this(new Well19937c(), alpha, beta, inverseCumAccuracy);
+ }
+
+ /**
+ * Creates a Weibull distribution.
+ *
+ * @param rng Random number generator.
+ * @param alpha Shape parameter.
+ * @param beta Scale parameter.
+ * @throws NotStrictlyPositiveException if {@code alpha <= 0} or {@code beta <= 0}.
+ * @since 3.3
+ */
+ public WeibullDistribution(RandomGenerator rng, double alpha, double beta)
+ throws NotStrictlyPositiveException {
+ this(rng, alpha, beta, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
+ }
+
+ /**
+ * Creates a Weibull distribution.
+ *
+ * @param rng Random number generator.
+ * @param alpha Shape parameter.
+ * @param beta Scale parameter.
+ * @param inverseCumAccuracy Maximum absolute error in inverse
+ * cumulative probability estimates
+ * (defaults to {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}).
+ * @throws NotStrictlyPositiveException if {@code alpha <= 0} or {@code beta <= 0}.
+ * @since 3.1
+ */
+ public WeibullDistribution(RandomGenerator rng,
+ double alpha,
+ double beta,
+ double inverseCumAccuracy)
+ throws NotStrictlyPositiveException {
+ super(rng);
+
+ if (alpha <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.SHAPE,
+ alpha);
+ }
+ if (beta <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.SCALE,
+ beta);
+ }
+ scale = beta;
+ shape = alpha;
+ solverAbsoluteAccuracy = inverseCumAccuracy;
+ }
+
+ /**
+ * Access the shape parameter, {@code alpha}.
+ *
+ * @return the shape parameter, {@code alpha}.
+ */
+ public double getShape() {
+ return shape;
+ }
+
+ /**
+ * Access the scale parameter, {@code beta}.
+ *
+ * @return the scale parameter, {@code beta}.
+ */
+ public double getScale() {
+ return scale;
+ }
+
+ /** {@inheritDoc} */
+ public double density(double x) {
+ if (x < 0) {
+ return 0;
+ }
+
+ final double xscale = x / scale;
+ final double xscalepow = FastMath.pow(xscale, shape - 1);
+
+ /*
+ * FastMath.pow(x / scale, shape) =
+ * FastMath.pow(xscale, shape) =
+ * FastMath.pow(xscale, shape - 1) * xscale
+ */
+ final double xscalepowshape = xscalepow * xscale;
+
+ return (shape / scale) * xscalepow * FastMath.exp(-xscalepowshape);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double logDensity(double x) {
+ if (x < 0) {
+ return Double.NEGATIVE_INFINITY;
+ }
+
+ final double xscale = x / scale;
+ final double logxscalepow = FastMath.log(xscale) * (shape - 1);
+
+ /*
+ * FastMath.pow(x / scale, shape) =
+ * FastMath.pow(xscale, shape) =
+ * FastMath.pow(xscale, shape - 1) * xscale
+ */
+ final double xscalepowshape = FastMath.exp(logxscalepow) * xscale;
+
+ return FastMath.log(shape / scale) + logxscalepow - xscalepowshape;
+ }
+
+ /** {@inheritDoc} */
+ public double cumulativeProbability(double x) {
+ double ret;
+ if (x <= 0.0) {
+ ret = 0.0;
+ } else {
+ ret = 1.0 - FastMath.exp(-FastMath.pow(x / scale, shape));
+ }
+ return ret;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * Returns {@code 0} when {@code p == 0} and
+ * {@code Double.POSITIVE_INFINITY} when {@code p == 1}.
+ */
+ @Override
+ public double inverseCumulativeProbability(double p) {
+ double ret;
+ if (p < 0.0 || p > 1.0) {
+ throw new OutOfRangeException(p, 0.0, 1.0);
+ } else if (p == 0) {
+ ret = 0.0;
+ } else if (p == 1) {
+ ret = Double.POSITIVE_INFINITY;
+ } else {
+ ret = scale * FastMath.pow(-FastMath.log1p(-p), 1.0 / shape);
+ }
+ return ret;
+ }
+
+ /**
+ * Return the absolute accuracy setting of the solver used to estimate
+ * inverse cumulative probabilities.
+ *
+ * @return the solver absolute accuracy.
+ * @since 2.1
+ */
+ @Override
+ protected double getSolverAbsoluteAccuracy() {
+ return solverAbsoluteAccuracy;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The mean is {@code scale * Gamma(1 + (1 / shape))}, where {@code Gamma()}
+ * is the Gamma-function.
+ */
+ public double getNumericalMean() {
+ if (!numericalMeanIsCalculated) {
+ numericalMean = calculateNumericalMean();
+ numericalMeanIsCalculated = true;
+ }
+ return numericalMean;
+ }
+
+ /**
+ * used by {@link #getNumericalMean()}
+ *
+ * @return the mean of this distribution
+ */
+ protected double calculateNumericalMean() {
+ final double sh = getShape();
+ final double sc = getScale();
+
+ return sc * FastMath.exp(Gamma.logGamma(1 + (1 / sh)));
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The variance is {@code scale^2 * Gamma(1 + (2 / shape)) - mean^2}
+ * where {@code Gamma()} is the Gamma-function.
+ */
+ public double getNumericalVariance() {
+ if (!numericalVarianceIsCalculated) {
+ numericalVariance = calculateNumericalVariance();
+ numericalVarianceIsCalculated = true;
+ }
+ return numericalVariance;
+ }
+
+ /**
+ * used by {@link #getNumericalVariance()}
+ *
+ * @return the variance of this distribution
+ */
+ protected double calculateNumericalVariance() {
+ final double sh = getShape();
+ final double sc = getScale();
+ final double mn = getNumericalMean();
+
+ return (sc * sc) * FastMath.exp(Gamma.logGamma(1 + (2 / sh))) -
+ (mn * mn);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The lower bound of the support is always 0 no matter the parameters.
+ *
+ * @return lower bound of the support (always 0)
+ */
+ public double getSupportLowerBound() {
+ return 0;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The upper bound of the support is always positive infinity
+ * no matter the parameters.
+ *
+ * @return upper bound of the support (always
+ * {@code Double.POSITIVE_INFINITY})
+ */
+ public double getSupportUpperBound() {
+ return Double.POSITIVE_INFINITY;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportLowerBoundInclusive() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportUpperBoundInclusive() {
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The support of this distribution is connected.
+ *
+ * @return {@code true}
+ */
+ public boolean isSupportConnected() {
+ return true;
+ }
+}
+
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/ZipfDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/ZipfDistribution.java
new file mode 100644
index 000000000..0cc12ffd8
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/ZipfDistribution.java
@@ -0,0 +1,488 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.random.RandomGenerator;
+import com.fr.third.org.apache.commons.math3.random.Well19937c;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+
+/**
+ * Implementation of the Zipf distribution.
+ *
+ * Parameters:
+ * For a random variable {@code X} whose values are distributed according to this
+ * distribution, the probability mass function is given by
+ *
+ *
+ * Note: this constructor will implicitly create an instance of
+ * {@link Well19937c} as random generator to be used for sampling only (see
+ * {@link #sample()} and {@link #sample(int)}). In case no sampling is
+ * needed for the created distribution, it is advised to pass {@code null}
+ * as random generator via the appropriate constructors to avoid the
+ * additional initialisation overhead.
+ *
+ * @param numberOfElements Number of elements.
+ * @param exponent Exponent.
+ * @exception NotStrictlyPositiveException if {@code numberOfElements <= 0}
+ * or {@code exponent <= 0}.
+ */
+ public ZipfDistribution(final int numberOfElements, final double exponent) {
+ this(new Well19937c(), numberOfElements, exponent);
+ }
+
+ /**
+ * Creates a Zipf distribution.
+ *
+ * @param rng Random number generator.
+ * @param numberOfElements Number of elements.
+ * @param exponent Exponent.
+ * @exception NotStrictlyPositiveException if {@code numberOfElements <= 0}
+ * or {@code exponent <= 0}.
+ * @since 3.1
+ */
+ public ZipfDistribution(RandomGenerator rng,
+ int numberOfElements,
+ double exponent)
+ throws NotStrictlyPositiveException {
+ super(rng);
+
+ if (numberOfElements <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.DIMENSION,
+ numberOfElements);
+ }
+ if (exponent <= 0) {
+ throw new NotStrictlyPositiveException(LocalizedFormats.EXPONENT,
+ exponent);
+ }
+
+ this.numberOfElements = numberOfElements;
+ this.exponent = exponent;
+ }
+
+ /**
+ * Get the number of elements (e.g. corpus size) for the distribution.
+ *
+ * @return the number of elements
+ */
+ public int getNumberOfElements() {
+ return numberOfElements;
+ }
+
+ /**
+ * Get the exponent characterizing the distribution.
+ *
+ * @return the exponent
+ */
+ public double getExponent() {
+ return exponent;
+ }
+
+ /** {@inheritDoc} */
+ public double probability(final int x) {
+ if (x <= 0 || x > numberOfElements) {
+ return 0.0;
+ }
+
+ return (1.0 / FastMath.pow(x, exponent)) / generalizedHarmonic(numberOfElements, exponent);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double logProbability(int x) {
+ if (x <= 0 || x > numberOfElements) {
+ return Double.NEGATIVE_INFINITY;
+ }
+
+ return -FastMath.log(x) * exponent - FastMath.log(generalizedHarmonic(numberOfElements, exponent));
+ }
+
+ /** {@inheritDoc} */
+ public double cumulativeProbability(final int x) {
+ if (x <= 0) {
+ return 0.0;
+ } else if (x >= numberOfElements) {
+ return 1.0;
+ }
+
+ return generalizedHarmonic(x, exponent) / generalizedHarmonic(numberOfElements, exponent);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For number of elements {@code N} and exponent {@code s}, the mean is
+ * {@code Hs1 / Hs}, where
+ *
+ * Wolfgang Hörmann and Gerhard Derflinger
+ * "Rejection-inversion to generate variates from monotone discrete distributions."
+ * ACM Transactions on Modeling and Computer Simulation (TOMACS) 6.3 (1996): 169-184.
+ *
+ * The paper describes an algorithm for exponents larger than 1 (Algorithm ZRI).
+ * The original method uses {@code H(x) := (v + x)^(1 - q) / (1 - q)}
+ * as the integral of the hat function. This function is undefined for
+ * q = 1, which is the reason for the limitation of the exponent.
+ * If instead the integral function
+ * {@code H(x) := ((v + x)^(1 - q) - 1) / (1 - q)} is used,
+ * for which a meaningful limit exists for q = 1,
+ * the method works for all positive exponents.
+ *
+ * The following implementation uses v := 0 and generates integral numbers
+ * in the range [1, numberOfElements]. This is different to the original method
+ * where v is defined to be positive and numbers are taken from [0, i_max].
+ * This explains why the implementation looks slightly different.
+ *
+ * @since 3.6
+ */
+ static final class ZipfRejectionInversionSampler {
+
+ /** Exponent parameter of the distribution. */
+ private final double exponent;
+ /** Number of elements. */
+ private final int numberOfElements;
+ /** Constant equal to {@code hIntegral(1.5) - 1}. */
+ private final double hIntegralX1;
+ /** Constant equal to {@code hIntegral(numberOfElements + 0.5)}. */
+ private final double hIntegralNumberOfElements;
+ /** Constant equal to {@code 2 - hIntegralInverse(hIntegral(2.5) - h(2)}. */
+ private final double s;
+
+ /** Simple constructor.
+ * @param numberOfElements number of elements
+ * @param exponent exponent parameter of the distribution
+ */
+ ZipfRejectionInversionSampler(final int numberOfElements, final double exponent) {
+ this.exponent = exponent;
+ this.numberOfElements = numberOfElements;
+ this.hIntegralX1 = hIntegral(1.5) - 1d;
+ this.hIntegralNumberOfElements = hIntegral(numberOfElements + 0.5);
+ this.s = 2d - hIntegralInverse(hIntegral(2.5) - h(2));
+ }
+
+ /** Generate one integral number in the range [1, numberOfElements].
+ * @param random random generator to use
+ * @return generated integral number in the range [1, numberOfElements]
+ */
+ int sample(final RandomGenerator random) {
+ while(true) {
+
+ final double u = hIntegralNumberOfElements + random.nextDouble() * (hIntegralX1 - hIntegralNumberOfElements);
+ // u is uniformly distributed in (hIntegralX1, hIntegralNumberOfElements]
+
+ double x = hIntegralInverse(u);
+
+ int k = (int)(x + 0.5);
+
+ // Limit k to the range [1, numberOfElements]
+ // (k could be outside due to numerical inaccuracies)
+ if (k < 1) {
+ k = 1;
+ }
+ else if (k > numberOfElements) {
+ k = numberOfElements;
+ }
+
+ // Here, the distribution of k is given by:
+ //
+ // P(k = 1) = C * (hIntegral(1.5) - hIntegralX1) = C
+ // P(k = m) = C * (hIntegral(m + 1/2) - hIntegral(m - 1/2)) for m >= 2
+ //
+ // where C := 1 / (hIntegralNumberOfElements - hIntegralX1)
+
+ if (k - x <= s || u >= hIntegral(k + 0.5) - h(k)) {
+
+ // Case k = 1:
+ //
+ // The right inequality is always true, because replacing k by 1 gives
+ // u >= hIntegral(1.5) - h(1) = hIntegralX1 and u is taken from
+ // (hIntegralX1, hIntegralNumberOfElements].
+ //
+ // Therefore, the acceptance rate for k = 1 is P(accepted | k = 1) = 1
+ // and the probability that 1 is returned as random value is
+ // P(k = 1 and accepted) = P(accepted | k = 1) * P(k = 1) = C = C / 1^exponent
+ //
+ // Case k >= 2:
+ //
+ // The left inequality (k - x <= s) is just a short cut
+ // to avoid the more expensive evaluation of the right inequality
+ // (u >= hIntegral(k + 0.5) - h(k)) in many cases.
+ //
+ // If the left inequality is true, the right inequality is also true:
+ // Theorem 2 in the paper is valid for all positive exponents, because
+ // the requirements h'(x) = -exponent/x^(exponent + 1) < 0 and
+ // (-1/hInverse'(x))'' = (1+1/exponent) * x^(1/exponent-1) >= 0
+ // are both fulfilled.
+ // Therefore, f(x) := x - hIntegralInverse(hIntegral(x + 0.5) - h(x))
+ // is a non-decreasing function. If k - x <= s holds,
+ // k - x <= s + f(k) - f(2) is obviously also true which is equivalent to
+ // -x <= -hIntegralInverse(hIntegral(k + 0.5) - h(k)),
+ // -hIntegralInverse(u) <= -hIntegralInverse(hIntegral(k + 0.5) - h(k)),
+ // and finally u >= hIntegral(k + 0.5) - h(k).
+ //
+ // Hence, the right inequality determines the acceptance rate:
+ // P(accepted | k = m) = h(m) / (hIntegrated(m+1/2) - hIntegrated(m-1/2))
+ // The probability that m is returned is given by
+ // P(k = m and accepted) = P(accepted | k = m) * P(k = m) = C * h(m) = C / m^exponent.
+ //
+ // In both cases the probabilities are proportional to the probability mass function
+ // of the Zipf distribution.
+
+ return k;
+ }
+ }
+ }
+
+ /**
+ * {@code H(x) :=}
+ *
+ * A Taylor series expansion is used, if x is close to 0.
+ *
+ * @param x a value larger than or equal to -1
+ * @return {@code log(1+x)/x}
+ */
+ static double helper1(final double x) {
+ if (FastMath.abs(x)>1e-8) {
+ return FastMath.log1p(x)/x;
+ }
+ else {
+ return 1.-x*((1./2.)-x*((1./3.)-x*(1./4.)));
+ }
+ }
+
+ /**
+ * Helper function to calculate {@code (exp(x)-1)/x}.
+ *
+ * A Taylor series expansion is used, if x is close to 0.
+ *
+ * @param x free parameter
+ * @return {@code (exp(x)-1)/x} if x is non-zero, or 1 if x=0
+ */
+ static double helper2(final double x) {
+ if (FastMath.abs(x)>1e-8) {
+ return FastMath.expm1(x)/x;
+ }
+ else {
+ return 1.+x*(1./2.)*(1.+x*(1./3.)*(1.+x*(1./4.)));
+ }
+ }
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/fitting/MultivariateNormalMixtureExpectationMaximization.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/fitting/MultivariateNormalMixtureExpectationMaximization.java
new file mode 100644
index 000000000..40fcefc70
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/fitting/MultivariateNormalMixtureExpectationMaximization.java
@@ -0,0 +1,454 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.distribution.fitting;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import com.fr.third.org.apache.commons.math3.distribution.MixtureMultivariateNormalDistribution;
+import com.fr.third.org.apache.commons.math3.distribution.MultivariateNormalDistribution;
+import com.fr.third.org.apache.commons.math3.exception.ConvergenceException;
+import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException;
+import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException;
+import com.fr.third.org.apache.commons.math3.exception.NumberIsTooSmallException;
+import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.linear.Array2DRowRealMatrix;
+import com.fr.third.org.apache.commons.math3.linear.RealMatrix;
+import com.fr.third.org.apache.commons.math3.linear.SingularMatrixException;
+import com.fr.third.org.apache.commons.math3.stat.correlation.Covariance;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+import com.fr.third.org.apache.commons.math3.util.MathArrays;
+import com.fr.third.org.apache.commons.math3.util.Pair;
+
+/**
+ * Expectation-Maximization algorithm for fitting the parameters of
+ * multivariate normal mixture model distributions.
+ *
+ * This implementation is pure original code based on
+ * EM Demystified: An Expectation-Maximization Tutorial by Yihua Chen and Maya R. Gupta,
+ * Department of Electrical Engineering, University of Washington, Seattle, WA 98195.
+ * It was verified using external tools like CRAN Mixtools
+ * (see the JUnit test cases) but it is not based on Mixtools code at all.
+ * The discussion of the origin of this class can be seen in the comments of the MATH-817 JIRA issue.
+ * @since 3.2
+ */
+public class MultivariateNormalMixtureExpectationMaximization {
+ /**
+ * Default maximum number of iterations allowed per fitting process.
+ */
+ private static final int DEFAULT_MAX_ITERATIONS = 1000;
+ /**
+ * Default convergence threshold for fitting.
+ */
+ private static final double DEFAULT_THRESHOLD = 1E-5;
+ /**
+ * The data to fit.
+ */
+ private final double[][] data;
+ /**
+ * The model fit against the data.
+ */
+ private MixtureMultivariateNormalDistribution fittedModel;
+ /**
+ * The log likelihood of the data given the fitted model.
+ */
+ private double logLikelihood = 0d;
+
+ /**
+ * Creates an object to fit a multivariate normal mixture model to data.
+ *
+ * @param data Data to use in fitting procedure
+ * @throws NotStrictlyPositiveException if data has no rows
+ * @throws DimensionMismatchException if rows of data have different numbers
+ * of columns
+ * @throws NumberIsTooSmallException if the number of columns in the data is
+ * less than 2
+ */
+ public MultivariateNormalMixtureExpectationMaximization(double[][] data)
+ throws NotStrictlyPositiveException,
+ DimensionMismatchException,
+ NumberIsTooSmallException {
+ if (data.length < 1) {
+ throw new NotStrictlyPositiveException(data.length);
+ }
+
+ this.data = new double[data.length][data[0].length];
+
+ for (int i = 0; i < data.length; i++) {
+ if (data[i].length != data[0].length) {
+ // Jagged arrays not allowed
+ throw new DimensionMismatchException(data[i].length,
+ data[0].length);
+ }
+ if (data[i].length < 2) {
+ throw new NumberIsTooSmallException(LocalizedFormats.NUMBER_TOO_SMALL,
+ data[i].length, 2, true);
+ }
+ this.data[i] = MathArrays.copyOf(data[i], data[i].length);
+ }
+ }
+
+ /**
+ * Fit a mixture model to the data supplied to the constructor.
+ *
+ * The quality of the fit depends on the concavity of the data provided to
+ * the constructor and the initial mixture provided to this function. If the
+ * data has many local optima, multiple runs of the fitting function with
+ * different initial mixtures may be required to find the optimal solution.
+ * If a SingularMatrixException is encountered, it is possible that another
+ * initialization would work.
+ *
+ * @param initialMixture Model containing initial values of weights and
+ * multivariate normals
+ * @param maxIterations Maximum iterations allowed for fit
+ * @param threshold Convergence threshold computed as difference in
+ * logLikelihoods between successive iterations
+ * @throws SingularMatrixException if any component's covariance matrix is
+ * singular during fitting
+ * @throws NotStrictlyPositiveException if numComponents is less than one
+ * or threshold is less than Double.MIN_VALUE
+ * @throws DimensionMismatchException if initialMixture mean vector and data
+ * number of columns are not equal
+ */
+ public void fit(final MixtureMultivariateNormalDistribution initialMixture,
+ final int maxIterations,
+ final double threshold)
+ throws SingularMatrixException,
+ NotStrictlyPositiveException,
+ DimensionMismatchException {
+ if (maxIterations < 1) {
+ throw new NotStrictlyPositiveException(maxIterations);
+ }
+
+ if (threshold < Double.MIN_VALUE) {
+ throw new NotStrictlyPositiveException(threshold);
+ }
+
+ final int n = data.length;
+
+ // Number of data columns. Jagged data already rejected in constructor,
+ // so we can assume the lengths of each row are equal.
+ final int numCols = data[0].length;
+ final int k = initialMixture.getComponents().size();
+
+ final int numMeanColumns
+ = initialMixture.getComponents().get(0).getSecond().getMeans().length;
+
+ if (numMeanColumns != numCols) {
+ throw new DimensionMismatchException(numMeanColumns, numCols);
+ }
+
+ int numIterations = 0;
+ double previousLogLikelihood = 0d;
+
+ logLikelihood = Double.NEGATIVE_INFINITY;
+
+ // Initialize model to fit to initial mixture.
+ fittedModel = new MixtureMultivariateNormalDistribution(initialMixture.getComponents());
+
+ while (numIterations++ <= maxIterations &&
+ FastMath.abs(previousLogLikelihood - logLikelihood) > threshold) {
+ previousLogLikelihood = logLikelihood;
+ double sumLogLikelihood = 0d;
+
+ // Mixture components
+ final List We can remove S between these expressions :
+ *
+ * Duplicate values are allowed. Probabilities of duplicate values are combined
+ * when computing cumulative probabilities and statistics.
+ * Duplicate values are allowed. Probabilities of duplicate values are combined
+ * when computing cumulative probabilities and statistics.
+ *
+ */
+ public double cumulativeProbability(double x) {
+ double ret;
+ if (x <= 0.0) {
+ ret = 0.0;
+ } else {
+ ret = 1.0 - FastMath.exp(-x / mean);
+ }
+ return ret;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * Returns {@code 0} when {@code p= = 0} and
+ * {@code Double.POSITIVE_INFINITY} when {@code p == 1}.
+ */
+ @Override
+ public double inverseCumulativeProbability(double p) throws OutOfRangeException {
+ double ret;
+
+ if (p < 0.0 || p > 1.0) {
+ throw new OutOfRangeException(p, 0.0, 1.0);
+ } else if (p == 1.0) {
+ ret = Double.POSITIVE_INFINITY;
+ } else {
+ ret = -mean * FastMath.log(1.0 - p);
+ }
+
+ return ret;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ *
+ *
+ */
+ public double cumulativeProbability(double x) {
+ double ret;
+ if (x <= 0) {
+ ret = 0;
+ } else {
+ double n = numeratorDegreesOfFreedom;
+ double m = denominatorDegreesOfFreedom;
+
+ ret = Beta.regularizedBeta((n * x) / (m + n * x),
+ 0.5 * n,
+ 0.5 * m);
+ }
+ return ret;
+ }
+
+ /**
+ * Access the numerator degrees of freedom.
+ *
+ * @return the numerator degrees of freedom.
+ */
+ public double getNumeratorDegreesOfFreedom() {
+ return numeratorDegreesOfFreedom;
+ }
+
+ /**
+ * Access the denominator degrees of freedom.
+ *
+ * @return the denominator degrees of freedom.
+ */
+ public double getDenominatorDegreesOfFreedom() {
+ return denominatorDegreesOfFreedom;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ protected double getSolverAbsoluteAccuracy() {
+ return solverAbsoluteAccuracy;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For denominator degrees of freedom parameter {@code b}, the mean is
+ *
+ *
+ */
+ public double getNumericalMean() {
+ final double denominatorDF = getDenominatorDegreesOfFreedom();
+
+ if (denominatorDF > 2) {
+ return denominatorDF / (denominatorDF - 2);
+ }
+
+ return Double.NaN;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For numerator degrees of freedom parameter {@code a} and denominator
+ * degrees of freedom parameter {@code b}, the variance is
+ *
+ *
+ */
+ public double getNumericalVariance() {
+ if (!numericalVarianceIsCalculated) {
+ numericalVariance = calculateNumericalVariance();
+ numericalVarianceIsCalculated = true;
+ }
+ return numericalVariance;
+ }
+
+ /**
+ * used by {@link #getNumericalVariance()}
+ *
+ * @return the variance of this distribution
+ */
+ protected double calculateNumericalVariance() {
+ final double denominatorDF = getDenominatorDegreesOfFreedom();
+
+ 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;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The lower bound of the support is always 0 no matter the parameters.
+ *
+ * @return lower bound of the support (always 0)
+ */
+ public double getSupportLowerBound() {
+ return 0;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The upper bound of the support is always positive infinity
+ * no matter the parameters.
+ *
+ * @return upper bound of the support (always Double.POSITIVE_INFINITY)
+ */
+ public double getSupportUpperBound() {
+ return Double.POSITIVE_INFINITY;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportLowerBoundInclusive() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportUpperBoundInclusive() {
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The support of this distribution is connected.
+ *
+ * @return {@code true}
+ */
+ public boolean isSupportConnected() {
+ return true;
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/GammaDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/GammaDistribution.java
new file mode 100644
index 000000000..fcc7a1ac2
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/GammaDistribution.java
@@ -0,0 +1,513 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.random.RandomGenerator;
+import com.fr.third.org.apache.commons.math3.random.Well19937c;
+import com.fr.third.org.apache.commons.math3.special.Gamma;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+
+/**
+ * Implementation of the Gamma distribution.
+ *
+ * @see Gamma distribution (Wikipedia)
+ * @see Gamma distribution (MathWorld)
+ */
+public class GammaDistribution extends AbstractRealDistribution {
+ /**
+ * Default inverse cumulative probability accuracy.
+ * @since 2.1
+ */
+ public static final double DEFAULT_INVERSE_ABSOLUTE_ACCURACY = 1e-9;
+ /** Serializable version identifier. */
+ private static final long serialVersionUID = 20120524L;
+ /** The shape parameter. */
+ private final double shape;
+ /** The scale parameter. */
+ private final double scale;
+ /**
+ * The constant value of {@code shape + g + 0.5}, where {@code g} is the
+ * Lanczos constant {@link Gamma#LANCZOS_G}.
+ */
+ private final double shiftedShape;
+ /**
+ * The constant value of
+ * {@code shape / scale * sqrt(e / (2 * pi * (shape + g + 0.5))) / L(shape)},
+ * where {@code L(shape)} is the Lanczos approximation returned by
+ * {@link Gamma#lanczos(double)}. This prefactor is used in
+ * {@link #density(double)}, when no overflow occurs with the natural
+ * calculation.
+ */
+ private final double densityPrefactor1;
+ /**
+ * The constant value of
+ * {@code log(shape / scale * sqrt(e / (2 * pi * (shape + g + 0.5))) / L(shape))},
+ * where {@code L(shape)} is the Lanczos approximation returned by
+ * {@link Gamma#lanczos(double)}. This prefactor is used in
+ * {@link #logDensity(double)}, when no overflow occurs with the natural
+ * calculation.
+ */
+ private final double logDensityPrefactor1;
+ /**
+ * The constant value of
+ * {@code shape * sqrt(e / (2 * pi * (shape + g + 0.5))) / L(shape)},
+ * where {@code L(shape)} is the Lanczos approximation returned by
+ * {@link Gamma#lanczos(double)}. This prefactor is used in
+ * {@link #density(double)}, when overflow occurs with the natural
+ * calculation.
+ */
+ private final double densityPrefactor2;
+ /**
+ * The constant value of
+ * {@code log(shape * sqrt(e / (2 * pi * (shape + g + 0.5))) / L(shape))},
+ * where {@code L(shape)} is the Lanczos approximation returned by
+ * {@link Gamma#lanczos(double)}. This prefactor is used in
+ * {@link #logDensity(double)}, when overflow occurs with the natural
+ * calculation.
+ */
+ private final double logDensityPrefactor2;
+ /**
+ * Lower bound on {@code y = x / scale} for the selection of the computation
+ * method in {@link #density(double)}. For {@code y <= minY}, the natural
+ * calculation overflows.
+ */
+ private final double minY;
+ /**
+ * Upper bound on {@code log(y)} ({@code y = x / scale}) for the selection
+ * of the computation method in {@link #density(double)}. For
+ * {@code log(y) >= maxLogY}, the natural calculation overflows.
+ */
+ private final double maxLogY;
+ /** Inverse cumulative probability accuracy. */
+ private final double solverAbsoluteAccuracy;
+
+ /**
+ * Creates a new gamma distribution with specified values of the shape and
+ * scale parameters.
+ *
+ *
+ */
+ public double cumulativeProbability(double x) {
+ double ret;
+
+ if (x <= 0) {
+ ret = 0;
+ } else {
+ ret = Gamma.regularizedGammaP(shape, x / scale);
+ }
+
+ return ret;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ protected double getSolverAbsoluteAccuracy() {
+ return solverAbsoluteAccuracy;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For shape parameter {@code alpha} and scale parameter {@code beta}, the
+ * mean is {@code alpha * beta}.
+ */
+ public double getNumericalMean() {
+ return shape * scale;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For shape parameter {@code alpha} and scale parameter {@code beta}, the
+ * variance is {@code alpha * beta^2}.
+ *
+ * @return {@inheritDoc}
+ */
+ public double getNumericalVariance() {
+ return shape * scale * scale;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The lower bound of the support is always 0 no matter the parameters.
+ *
+ * @return lower bound of the support (always 0)
+ */
+ public double getSupportLowerBound() {
+ return 0;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The upper bound of the support is always positive infinity
+ * no matter the parameters.
+ *
+ * @return upper bound of the support (always Double.POSITIVE_INFINITY)
+ */
+ public double getSupportUpperBound() {
+ return Double.POSITIVE_INFINITY;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportLowerBoundInclusive() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportUpperBoundInclusive() {
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The support of this distribution is connected.
+ *
+ * @return {@code true}
+ */
+ public boolean isSupportConnected() {
+ return true;
+ }
+
+ /**
+ *
+ * Ahrens, J. H. and Dieter, U., Computer methods for
+ * sampling from gamma, beta, Poisson and binomial distributions.
+ * Computing, 12, 223-246, 1974.
+ * Marsaglia and Tsang, A Simple Method for Generating
+ * Gamma Variables. ACM Transactions on Mathematical Software,
+ * Volume 26 Issue 3, September, 2000.
+ *
+ * If the result exceeds the range of the data type {@code int},
+ * then {@code Integer.MIN_VALUE} or {@code Integer.MAX_VALUE} is returned.
+ *
+ * @param p the cumulative probability
+ * @return the smallest {@code p}-quantile of this distribution
+ * (largest 0-quantile for {@code p = 0})
+ * @throws OutOfRangeException if {@code p < 0} or {@code p > 1}
+ */
+ int inverseCumulativeProbability(double p) throws OutOfRangeException;
+
+ /**
+ * Use this method to get the numerical value of the mean of this
+ * distribution.
+ *
+ * @return the mean or {@code Double.NaN} if it is not defined
+ */
+ double getNumericalMean();
+
+ /**
+ * Use this method to get the numerical value of the variance of this
+ * distribution.
+ *
+ * @return the variance (possibly {@code Double.POSITIVE_INFINITY} or
+ * {@code Double.NaN} if it is not defined)
+ */
+ double getNumericalVariance();
+
+ /**
+ * Access the lower bound of the support. This method must return the same
+ * value as {@code inverseCumulativeProbability(0)}. In other words, this
+ * method must return
+ * inf{x in Z | P(X<=x) >= p} for {@code 0 < p <= 1},inf{x in Z | P(X<=x) > 0} for {@code p = 0}.inf {x in Z | P(X <= x) > 0}.inf {x in R | P(X <= x) = 1}.
+ *
+ * Note that [1] contains an error in computing h, refer to
+ * MATH-437 for details.
+ *
+ * f(x; μ, c) = √(c / 2π) * e-c / 2 (x - μ) / (x - μ)3/2
+ *
+ *
+ * f(x; u, c) = erfc (√ (c / 2 (x - u )))
+ *
+ */
+ public double cumulativeProbability(final double x) {
+ if (x < mu) {
+ return Double.NaN;
+ }
+ return Erf.erfc(FastMath.sqrt(halfC / (x - mu)));
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double inverseCumulativeProbability(final double p) throws OutOfRangeException {
+ if (p < 0.0 || p > 1.0) {
+ throw new OutOfRangeException(p, 0, 1);
+ }
+ final double t = Erf.erfcInv(p);
+ return mu + halfC / (t * t);
+ }
+
+ /** Get the scale parameter of the distribution.
+ * @return scale parameter of the distribution
+ */
+ public double getScale() {
+ return c;
+ }
+
+ /** Get the location parameter of the distribution.
+ * @return location parameter of the distribution
+ */
+ public double getLocation() {
+ return mu;
+ }
+
+ /** {@inheritDoc} */
+ public double getNumericalMean() {
+ return Double.POSITIVE_INFINITY;
+ }
+
+ /** {@inheritDoc} */
+ public double getNumericalVariance() {
+ return Double.POSITIVE_INFINITY;
+ }
+
+ /** {@inheritDoc} */
+ public double getSupportLowerBound() {
+ return mu;
+ }
+
+ /** {@inheritDoc} */
+ public double getSupportUpperBound() {
+ return Double.POSITIVE_INFINITY;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportLowerBoundInclusive() {
+ // there is a division by x-mu in the computation, so density
+ // is not finite at lower bound, bound must be excluded
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportUpperBoundInclusive() {
+ // upper bound is infinite, so it must be excluded
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportConnected() {
+ return true;
+ }
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/LogNormalDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/LogNormalDistribution.java
new file mode 100644
index 000000000..6f429ae63
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/LogNormalDistribution.java
@@ -0,0 +1,366 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException;
+import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.random.RandomGenerator;
+import com.fr.third.org.apache.commons.math3.random.Well19937c;
+import com.fr.third.org.apache.commons.math3.special.Erf;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+
+/**
+ * Implementation of the log-normal (gaussian) distribution.
+ *
+ *
+ *
+ *
+ * @see
+ * Log-normal distribution (Wikipedia)
+ * @see
+ * Log Normal distribution (MathWorld)
+ *
+ * @since 3.0
+ */
+public class LogNormalDistribution extends AbstractRealDistribution {
+ /** Default inverse cumulative probability accuracy. */
+ public static final double DEFAULT_INVERSE_ABSOLUTE_ACCURACY = 1e-9;
+
+ /** Serializable version identifier. */
+ private static final long serialVersionUID = 20120112;
+
+ /** √(2 π) */
+ private static final double SQRT2PI = FastMath.sqrt(2 * FastMath.PI);
+
+ /** √(2) */
+ private static final double SQRT2 = FastMath.sqrt(2.0);
+
+ /** The scale parameter of this distribution. */
+ private final double scale;
+
+ /** The shape parameter of this distribution. */
+ private final double shape;
+ /** The value of {@code log(shape) + 0.5 * log(2*PI)} stored for faster computation. */
+ private final double logShapePlusHalfLog2Pi;
+
+ /** Inverse cumulative probability accuracy. */
+ private final double solverAbsoluteAccuracy;
+
+ /**
+ * Create a log-normal distribution, where the mean and standard deviation
+ * of the {@link NormalDistribution normally distributed} natural
+ * logarithm of the log-normal distribution are equal to zero and one
+ * respectively. In other words, the scale of the returned distribution is
+ * {@code 0}, while its shape is {@code 1}.
+ *
+ *
+ */
+ public double density(double x) {
+ if (x <= 0) {
+ return 0;
+ }
+ final double x0 = FastMath.log(x) - scale;
+ final double x1 = x0 / shape;
+ return FastMath.exp(-0.5 * x1 * x1) / (shape * SQRT2PI * x);
+ }
+
+ /** {@inheritDoc}
+ *
+ * See documentation of {@link #density(double)} for computation details.
+ */
+ @Override
+ public double logDensity(double x) {
+ if (x <= 0) {
+ return Double.NEGATIVE_INFINITY;
+ }
+ final double logX = FastMath.log(x);
+ final double x0 = logX - scale;
+ final double x1 = x0 / shape;
+ return -0.5 * x1 * x1 - (logShapePlusHalfLog2Pi + logX);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For scale {@code m}, and shape {@code s} of this distribution, the CDF
+ * is given by
+ *
+ *
+ */
+ public double cumulativeProbability(double x) {
+ if (x <= 0) {
+ return 0;
+ }
+ final double dev = FastMath.log(x) - scale;
+ if (FastMath.abs(dev) > 40 * shape) {
+ return dev < 0 ? 0.0d : 1.0d;
+ }
+ return 0.5 + 0.5 * Erf.erf(dev / (shape * SQRT2));
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @deprecated See {@link RealDistribution#cumulativeProbability(double,double)}
+ */
+ @Override@Deprecated
+ public double cumulativeProbability(double x0, double x1)
+ throws NumberIsTooLargeException {
+ return probability(x0, x1);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double probability(double x0,
+ double x1)
+ throws NumberIsTooLargeException {
+ if (x0 > x1) {
+ throw new NumberIsTooLargeException(LocalizedFormats.LOWER_ENDPOINT_ABOVE_UPPER_ENDPOINT,
+ x0, x1, true);
+ }
+ if (x0 <= 0 || x1 <= 0) {
+ return super.probability(x0, x1);
+ }
+ final double denom = shape * SQRT2;
+ final double v0 = (FastMath.log(x0) - scale) / denom;
+ final double v1 = (FastMath.log(x1) - scale) / denom;
+ return 0.5 * Erf.erf(v0, v1);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ protected double getSolverAbsoluteAccuracy() {
+ return solverAbsoluteAccuracy;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For scale {@code m} and shape {@code s}, the mean is
+ * {@code exp(m + s^2 / 2)}.
+ */
+ public double getNumericalMean() {
+ double s = shape;
+ return FastMath.exp(scale + (s * s / 2));
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For scale {@code m} and shape {@code s}, the variance is
+ * {@code (exp(s^2) - 1) * exp(2 * m + s^2)}.
+ */
+ public double getNumericalVariance() {
+ final double s = shape;
+ final double ss = s * s;
+ return (FastMath.expm1(ss)) * FastMath.exp(2 * scale + ss);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The lower bound of the support is always 0 no matter the parameters.
+ *
+ * @return lower bound of the support (always 0)
+ */
+ public double getSupportLowerBound() {
+ return 0;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The upper bound of the support is always positive infinity
+ * no matter the parameters.
+ *
+ * @return upper bound of the support (always
+ * {@code Double.POSITIVE_INFINITY})
+ */
+ public double getSupportUpperBound() {
+ return Double.POSITIVE_INFINITY;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportLowerBoundInclusive() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportUpperBoundInclusive() {
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The support of this distribution is connected.
+ *
+ * @return {@code true}
+ */
+ public boolean isSupportConnected() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double sample() {
+ final double n = random.nextGaussian();
+ return FastMath.exp(scale + shape * n);
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/LogisticDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/LogisticDistribution.java
new file mode 100644
index 000000000..996c513cd
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/LogisticDistribution.java
@@ -0,0 +1,161 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException;
+import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.random.RandomGenerator;
+import com.fr.third.org.apache.commons.math3.random.Well19937c;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+import com.fr.third.org.apache.commons.math3.util.MathUtils;
+
+/**
+ * This class implements the Logistic distribution.
+ *
+ * @see Logistic Distribution (Wikipedia)
+ * @see Logistic Distribution (Mathworld)
+ *
+ * @since 3.4
+ */
+public class LogisticDistribution extends AbstractRealDistribution {
+
+ /** Serializable version identifier. */
+ private static final long serialVersionUID = 20141003;
+
+ /** The location parameter. */
+ private final double mu;
+ /** The scale parameter. */
+ private final double s;
+
+ /**
+ * Build a new instance.
+ *
+ * The number of dimensions is equal to the length of the mean vector
+ * and to the number of rows and columns of the covariance matrix.
+ * It is frequently written as "p" in formulae.
+ *
+ * The number of dimensions is equal to the length of the mean vector
+ * and to the number of rows and columns of the covariance matrix.
+ * It is frequently written as "p" in formulae.
+ *
+ * @param rng Random Number Generator.
+ * @param means Vector of means.
+ * @param covariances Covariance matrix.
+ * @throws DimensionMismatchException if the arrays length are
+ * inconsistent.
+ * @throws SingularMatrixException if the eigenvalue decomposition cannot
+ * be performed on the provided covariance matrix.
+ * @throws NonPositiveDefiniteMatrixException if any of the eigenvalues is
+ * negative.
+ */
+ public MultivariateNormalDistribution(RandomGenerator rng,
+ final double[] means,
+ final double[][] covariances)
+ throws SingularMatrixException,
+ DimensionMismatchException,
+ NonPositiveDefiniteMatrixException {
+ super(rng, means.length);
+
+ final int dim = means.length;
+
+ if (covariances.length != dim) {
+ throw new DimensionMismatchException(covariances.length, dim);
+ }
+
+ for (int i = 0; i < dim; i++) {
+ if (dim != covariances[i].length) {
+ throw new DimensionMismatchException(covariances[i].length, dim);
+ }
+ }
+
+ this.means = MathArrays.copyOf(means);
+
+ covarianceMatrix = new Array2DRowRealMatrix(covariances);
+
+ // Covariance matrix eigen decomposition.
+ final EigenDecomposition covMatDec = new EigenDecomposition(covarianceMatrix);
+
+ // Compute and store the inverse.
+ covarianceMatrixInverse = covMatDec.getSolver().getInverse();
+ // Compute and store the determinant.
+ covarianceMatrixDeterminant = covMatDec.getDeterminant();
+
+ // Eigenvalues of the covariance matrix.
+ final double[] covMatEigenvalues = covMatDec.getRealEigenvalues();
+
+ for (int i = 0; i < covMatEigenvalues.length; i++) {
+ if (covMatEigenvalues[i] < 0) {
+ throw new NonPositiveDefiniteMatrixException(covMatEigenvalues[i], i, 0);
+ }
+ }
+
+ // Matrix where each column is an eigenvector of the covariance matrix.
+ final Array2DRowRealMatrix covMatEigenvectors = new Array2DRowRealMatrix(dim, dim);
+ for (int v = 0; v < dim; v++) {
+ final double[] evec = covMatDec.getEigenvector(v).toArray();
+ covMatEigenvectors.setColumn(v, evec);
+ }
+
+ final RealMatrix tmpMatrix = covMatEigenvectors.transpose();
+
+ // Scale each eigenvector by the square root of its eigenvalue.
+ for (int row = 0; row < dim; row++) {
+ final double factor = FastMath.sqrt(covMatEigenvalues[row]);
+ for (int col = 0; col < dim; col++) {
+ tmpMatrix.multiplyEntry(row, col, factor);
+ }
+ }
+
+ samplingMatrix = covMatEigenvectors.multiply(tmpMatrix);
+ }
+
+ /**
+ * Gets the mean vector.
+ *
+ * @return the mean vector.
+ */
+ public double[] getMeans() {
+ return MathArrays.copyOf(means);
+ }
+
+ /**
+ * Gets the covariance matrix.
+ *
+ * @return the covariance matrix.
+ */
+ public RealMatrix getCovariances() {
+ return covarianceMatrix.copy();
+ }
+
+ /** {@inheritDoc} */
+ public double density(final double[] vals) throws DimensionMismatchException {
+ final int dim = getDimension();
+ if (vals.length != dim) {
+ throw new DimensionMismatchException(vals.length, dim);
+ }
+
+ return FastMath.pow(2 * FastMath.PI, -0.5 * dim) *
+ FastMath.pow(covarianceMatrixDeterminant, -0.5) *
+ getExponentTerm(vals);
+ }
+
+ /**
+ * Gets the square root of each element on the diagonal of the covariance
+ * matrix.
+ *
+ * @return the standard deviations.
+ */
+ public double[] getStandardDeviations() {
+ final int dim = getDimension();
+ final double[] std = new double[dim];
+ final double[][] s = covarianceMatrix.getData();
+ for (int i = 0; i < dim; i++) {
+ std[i] = FastMath.sqrt(s[i][i]);
+ }
+ return std;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double[] sample() {
+ final int dim = getDimension();
+ final double[] normalVals = new double[dim];
+
+ for (int i = 0; i < dim; i++) {
+ normalVals[i] = random.nextGaussian();
+ }
+
+ final double[] vals = samplingMatrix.operate(normalVals);
+
+ for (int i = 0; i < dim; i++) {
+ vals[i] += means[i];
+ }
+
+ return vals;
+ }
+
+ /**
+ * Computes the term used in the exponent (see definition of the distribution).
+ *
+ * @param values Values at which to compute density.
+ * @return the multiplication factor of density calculations.
+ */
+ private double getExponentTerm(final double[] values) {
+ final double[] centered = new double[values.length];
+ for (int i = 0; i < centered.length; i++) {
+ centered[i] = values[i] - getMeans()[i];
+ }
+ final double[] preMultiplied = covarianceMatrixInverse.preMultiply(centered);
+ double sum = 0;
+ for (int i = 0; i < preMultiplied.length; i++) {
+ sum += preMultiplied[i] * centered[i];
+ }
+ return FastMath.exp(-0.5 * sum);
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/MultivariateRealDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/MultivariateRealDistribution.java
new file mode 100644
index 000000000..dc0d5870d
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/MultivariateRealDistribution.java
@@ -0,0 +1,78 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException;
+
+/**
+ * Base interface for multivariate distributions on the reals.
+ *
+ * This is based largely on the RealDistribution interface, but cumulative
+ * distribution functions are not required because they are often quite
+ * difficult to compute for multivariate distributions.
+ *
+ * @since 3.1
+ */
+public interface MultivariateRealDistribution {
+ /**
+ * Returns the probability density function (PDF) of this distribution
+ * evaluated at the specified point {@code x}. In general, the PDF is the
+ * derivative of the cumulative distribution function. If the derivative
+ * does not exist at {@code x}, then an appropriate replacement should be
+ * returned, e.g. {@code Double.POSITIVE_INFINITY}, {@code Double.NaN}, or
+ * the limit inferior or limit superior of the difference quotient.
+ *
+ * @param x Point at which the PDF is evaluated.
+ * @return the value of the probability density function at point {@code x}.
+ */
+ double density(double[] x);
+
+ /**
+ * Reseeds the random generator used to generate samples.
+ *
+ * @param seed Seed with which to initialize the random number generator.
+ */
+ void reseedRandomGenerator(long seed);
+
+ /**
+ * Gets the number of random variables of the distribution.
+ * It is the size of the array returned by the {@link #sample() sample}
+ * method.
+ *
+ * @return the number of variables.
+ */
+ int getDimension();
+
+ /**
+ * Generates a random value vector sampled from this distribution.
+ *
+ * @return a random value vector.
+ */
+ double[] sample();
+
+ /**
+ * Generates a list of a random value vectors from the distribution.
+ *
+ * @param sampleSize the number of random vectors to generate.
+ * @return an array representing the random samples.
+ * @throws NotStrictlyPositiveException
+ * if {@code sampleSize} is not positive.
+ *
+ * @see #sample()
+ */
+ double[][] sample(int sampleSize) throws NotStrictlyPositiveException;
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/NakagamiDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/NakagamiDistribution.java
new file mode 100644
index 000000000..70614e703
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/NakagamiDistribution.java
@@ -0,0 +1,189 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import com.fr.third.org.apache.commons.math3.exception.NotStrictlyPositiveException;
+import com.fr.third.org.apache.commons.math3.exception.NumberIsTooSmallException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.random.RandomGenerator;
+import com.fr.third.org.apache.commons.math3.random.Well19937c;
+import com.fr.third.org.apache.commons.math3.special.Gamma;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+
+/**
+ * This class implements the Nakagami distribution.
+ *
+ * @see Nakagami Distribution (Wikipedia)
+ *
+ * @since 3.4
+ */
+public class NakagamiDistribution extends AbstractRealDistribution {
+
+ /** Default inverse cumulative probability accuracy. */
+ public static final double DEFAULT_INVERSE_ABSOLUTE_ACCURACY = 1e-9;
+
+ /** Serializable version identifier. */
+ private static final long serialVersionUID = 20141003;
+
+ /** The shape parameter. */
+ private final double mu;
+ /** The scale parameter. */
+ private final double omega;
+ /** Inverse cumulative probability accuracy. */
+ private final double inverseAbsoluteAccuracy;
+
+ /**
+ * Build a new instance.
+ *
+ * α * k^α / x^(α + 1)
+ *
+ *
+ *
+ *
+ * @see
+ * Pareto distribution (Wikipedia)
+ * @see
+ * Pareto distribution (MathWorld)
+ *
+ * @since 3.3
+ */
+public class ParetoDistribution extends AbstractRealDistribution {
+
+ /** Default inverse cumulative probability accuracy. */
+ public static final double DEFAULT_INVERSE_ABSOLUTE_ACCURACY = 1e-9;
+
+ /** Serializable version identifier. */
+ private static final long serialVersionUID = 20130424;
+
+ /** The scale parameter of this distribution. */
+ private final double scale;
+
+ /** The shape parameter of this distribution. */
+ private final double shape;
+
+ /** Inverse cumulative probability accuracy. */
+ private final double solverAbsoluteAccuracy;
+
+ /**
+ * Create a Pareto distribution with a scale of {@code 1} and a shape of {@code 1}.
+ */
+ public ParetoDistribution() {
+ this(1, 1);
+ }
+
+ /**
+ * Create a Pareto distribution using the specified scale and shape.
+ *
+ *
+ */
+ public double density(double x) {
+ if (x < scale) {
+ return 0;
+ }
+ return FastMath.pow(scale, shape) / FastMath.pow(x, shape + 1) * shape;
+ }
+
+ /** {@inheritDoc}
+ *
+ * See documentation of {@link #density(double)} for computation details.
+ */
+ @Override
+ public double logDensity(double x) {
+ if (x < scale) {
+ return Double.NEGATIVE_INFINITY;
+ }
+ return FastMath.log(scale) * shape - FastMath.log(x) * (shape + 1) + FastMath.log(shape);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ *
+ */
+ public double cumulativeProbability(double x) {
+ if (x <= scale) {
+ return 0;
+ }
+ return 1 - FastMath.pow(scale / x, shape);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @deprecated See {@link RealDistribution#cumulativeProbability(double,double)}
+ */
+ @Override
+ @Deprecated
+ public double cumulativeProbability(double x0, double x1)
+ throws NumberIsTooLargeException {
+ return probability(x0, x1);
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ protected double getSolverAbsoluteAccuracy() {
+ return solverAbsoluteAccuracy;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ *
+ */
+ public double getNumericalMean() {
+ if (shape <= 1) {
+ return Double.POSITIVE_INFINITY;
+ }
+ return shape * scale / (shape - 1);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ *
+ */
+ public double getNumericalVariance() {
+ if (shape <= 2) {
+ return Double.POSITIVE_INFINITY;
+ }
+ double s = shape - 1;
+ return scale * scale * shape / (s * s) / (shape - 2);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * {@code P(X = k) = C(k + r - 1, r - 1) * p^r * (1 - p)^k,}
+ * where {@code r} is the number of successes, {@code p} is the probability of
+ * success, and {@code X} is the total number of failures. {@code C(n, k)} is
+ * the binomial coefficient ({@code n} choose {@code k}). The mean and variance
+ * of {@code X} are
+ * {@code E(X) = (1 - p) * r / p, var(X) = (1 - p) * r / p^2.}
+ * Finally, the cumulative distribution function is given by
+ * {@code P(X <= k) = I(p, r, k + 1)},
+ * where I is the regularized incomplete Beta function.
+ *
+ *
+ *
+ * Devroye, Luc. (1981).The Computer Generation of Poisson Random Variables
+ *
+ * Computing vol. 26 pp. 197-207.
+ *
+ *
+ *
+ * @param p the cumulative probability
+ * @return the smallest {@code p}-quantile of this distribution
+ * (largest 0-quantile for {@code p = 0})
+ * @throws OutOfRangeException if {@code p < 0} or {@code p > 1}
+ */
+ double inverseCumulativeProbability(double p) throws OutOfRangeException;
+
+ /**
+ * Use this method to get the numerical value of the mean of this
+ * distribution.
+ *
+ * @return the mean or {@code Double.NaN} if it is not defined
+ */
+ double getNumericalMean();
+
+ /**
+ * Use this method to get the numerical value of the variance of this
+ * distribution.
+ *
+ * @return the variance (possibly {@code Double.POSITIVE_INFINITY} as
+ * for certain cases in {@link TDistribution}) or {@code Double.NaN} if it
+ * is not defined
+ */
+ double getNumericalVariance();
+
+ /**
+ * Access the lower bound of the support. This method must return the same
+ * value as {@code inverseCumulativeProbability(0)}. In other words, this
+ * method must return
+ * inf{x in R | P(X<=x) >= p} for {@code 0 < p <= 1},inf{x in R | P(X<=x) > 0} for {@code p = 0}.inf {x in R | P(X <= x) > 0}.inf {x in R | P(X <= x) = 1}.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+ public double getNumericalMean() {
+ final double df = getDegreesOfFreedom();
+
+ if (df > 1) {
+ return 0;
+ }
+
+ return Double.NaN;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For degrees of freedom parameter {@code df}, the variance is
+ *
+ *
+ */
+ public double getNumericalVariance() {
+ final double df = getDegreesOfFreedom();
+
+ if (df > 2) {
+ return df / (df - 2);
+ }
+
+ if (df > 1 && df <= 2) {
+ return Double.POSITIVE_INFINITY;
+ }
+
+ return Double.NaN;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The lower bound of the support is always negative infinity no matter the
+ * parameters.
+ *
+ * @return lower bound of the support (always
+ * {@code Double.NEGATIVE_INFINITY})
+ */
+ public double getSupportLowerBound() {
+ return Double.NEGATIVE_INFINITY;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The upper bound of the support is always positive infinity no matter the
+ * parameters.
+ *
+ * @return upper bound of the support (always
+ * {@code Double.POSITIVE_INFINITY})
+ */
+ public double getSupportUpperBound() {
+ return Double.POSITIVE_INFINITY;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportLowerBoundInclusive() {
+ return false;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportUpperBoundInclusive() {
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The support of this distribution is connected.
+ *
+ * @return {@code true}
+ */
+ public boolean isSupportConnected() {
+ return true;
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/TriangularDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/TriangularDistribution.java
new file mode 100644
index 000000000..2cae574e5
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/TriangularDistribution.java
@@ -0,0 +1,283 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException;
+import com.fr.third.org.apache.commons.math3.exception.NumberIsTooSmallException;
+import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.random.RandomGenerator;
+import com.fr.third.org.apache.commons.math3.random.Well19937c;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+
+/**
+ * Implementation of the triangular real distribution.
+ *
+ * @see
+ * Triangular distribution (Wikipedia)
+ *
+ * @since 3.0
+ */
+public class TriangularDistribution extends AbstractRealDistribution {
+ /** Serializable version identifier. */
+ private static final long serialVersionUID = 20120112L;
+ /** Lower limit of this distribution (inclusive). */
+ private final double a;
+ /** Upper limit of this distribution (inclusive). */
+ private final double b;
+ /** Mode of this distribution. */
+ private final double c;
+ /** Inverse cumulative probability accuracy. */
+ private final double solverAbsoluteAccuracy;
+
+ /**
+ * Creates a triangular real distribution using the given lower limit,
+ * upper limit, and mode.
+ *
+ *
+ */
+ public double density(double x) {
+ if (x < a) {
+ return 0;
+ }
+ if (a <= x && x < c) {
+ double divident = 2 * (x - a);
+ double divisor = (b - a) * (c - a);
+ return divident / divisor;
+ }
+ if (x == c) {
+ return 2 / (b - a);
+ }
+ if (c < x && x <= b) {
+ double divident = 2 * (b - x);
+ double divisor = (b - a) * (b - c);
+ return divident / divisor;
+ }
+ return 0;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For lower limit {@code a}, upper limit {@code b} and mode {@code c}, the
+ * CDF is given by
+ *
+ *
+ */
+ public double cumulativeProbability(double x) {
+ if (x < a) {
+ return 0;
+ }
+ if (a <= x && x < c) {
+ double divident = (x - a) * (x - a);
+ double divisor = (b - a) * (c - a);
+ return divident / divisor;
+ }
+ if (x == c) {
+ return (c - a) / (b - a);
+ }
+ if (c < x && x <= b) {
+ double divident = (b - x) * (b - x);
+ double divisor = (b - a) * (b - c);
+ return 1 - (divident / divisor);
+ }
+ return 1;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For lower limit {@code a}, upper limit {@code b}, and mode {@code c},
+ * the mean is {@code (a + b + c) / 3}.
+ */
+ public double getNumericalMean() {
+ return (a + b + c) / 3;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For lower limit {@code a}, upper limit {@code b}, and mode {@code c},
+ * the variance is {@code (a^2 + b^2 + c^2 - a * b - a * c - b * c) / 18}.
+ */
+ public double getNumericalVariance() {
+ return (a * a + b * b + c * c - a * b - a * c - b * c) / 18;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The lower bound of the support is equal to the lower limit parameter
+ * {@code a} of the distribution.
+ *
+ * @return lower bound of the support
+ */
+ public double getSupportLowerBound() {
+ return a;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The upper bound of the support is equal to the upper limit parameter
+ * {@code b} of the distribution.
+ *
+ * @return upper bound of the support
+ */
+ public double getSupportUpperBound() {
+ return b;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportLowerBoundInclusive() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ public boolean isSupportUpperBoundInclusive() {
+ return true;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The support of this distribution is connected.
+ *
+ * @return {@code true}
+ */
+ public boolean isSupportConnected() {
+ return true;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public double inverseCumulativeProbability(double p)
+ throws OutOfRangeException {
+ if (p < 0 || p > 1) {
+ throw new OutOfRangeException(p, 0, 1);
+ }
+ if (p == 0) {
+ return a;
+ }
+ if (p == 1) {
+ return b;
+ }
+ if (p < (c - a) / (b - a)) {
+ return a + FastMath.sqrt(p * (b - a) * (c - a));
+ }
+ return b - FastMath.sqrt((1 - p) * (b - a) * (b - c));
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/UniformIntegerDistribution.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/UniformIntegerDistribution.java
new file mode 100644
index 000000000..8df7caa83
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/distribution/UniformIntegerDistribution.java
@@ -0,0 +1,181 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.fr.third.org.apache.commons.math3.distribution;
+
+import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.random.RandomGenerator;
+import com.fr.third.org.apache.commons.math3.random.Well19937c;
+
+/**
+ * Implementation of the uniform integer distribution.
+ *
+ * @see Uniform distribution (discrete), at Wikipedia
+ *
+ * @since 3.0
+ */
+public class UniformIntegerDistribution extends AbstractIntegerDistribution {
+ /** Serializable version identifier. */
+ private static final long serialVersionUID = 20120109L;
+ /** Lower bound (inclusive) of this distribution. */
+ private final int lower;
+ /** Upper bound (inclusive) of this distribution. */
+ private final int upper;
+
+ /**
+ * Creates a new uniform integer distribution using the given lower and
+ * upper bounds (both inclusive).
+ *
+ * P(X = k) = H(N,s) * 1 / k^s for {@code k = 1,2,...,N}.
+ *
+ * {@code H(N,s)} is the normalizing constant
+ * which corresponds to the generalized harmonic number of order N of s.
+ *
+ *
+ * @see Zipf's law (Wikipedia)
+ * @see Generalized harmonic numbers
+ */
+public class ZipfDistribution extends AbstractIntegerDistribution {
+ /** Serializable version identifier. */
+ private static final long serialVersionUID = -140627372283420404L;
+ /** Number of elements. */
+ private final int numberOfElements;
+ /** Exponent parameter of the distribution. */
+ private final double exponent;
+ /** Cached numerical mean */
+ private double numericalMean = Double.NaN;
+ /** Whether or not the numerical mean has been calculated */
+ private boolean numericalMeanIsCalculated = false;
+ /** Cached numerical variance */
+ private double numericalVariance = Double.NaN;
+ /** Whether or not the numerical variance has been calculated */
+ private boolean numericalVarianceIsCalculated = false;
+ /** The sampler to be used for the sample() method */
+ private transient ZipfRejectionInversionSampler sampler;
+
+ /**
+ * Create a new Zipf distribution with the given number of elements and
+ * exponent.
+ *
+ *
+ */
+ public double getNumericalMean() {
+ if (!numericalMeanIsCalculated) {
+ numericalMean = calculateNumericalMean();
+ numericalMeanIsCalculated = true;
+ }
+ return numericalMean;
+ }
+
+ /**
+ * Used by {@link #getNumericalMean()}.
+ *
+ * @return the mean of this distribution
+ */
+ protected double calculateNumericalMean() {
+ final int N = getNumberOfElements();
+ final double s = getExponent();
+
+ final double Hs1 = generalizedHarmonic(N, s - 1);
+ final double Hs = generalizedHarmonic(N, s);
+
+ return Hs1 / Hs;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * For number of elements {@code N} and exponent {@code s}, the mean is
+ * {@code (Hs2 / Hs) - (Hs1^2 / Hs^2)}, where
+ *
+ *
+ */
+ public double getNumericalVariance() {
+ if (!numericalVarianceIsCalculated) {
+ numericalVariance = calculateNumericalVariance();
+ numericalVarianceIsCalculated = true;
+ }
+ return numericalVariance;
+ }
+
+ /**
+ * Used by {@link #getNumericalVariance()}.
+ *
+ * @return the variance of this distribution
+ */
+ 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);
+
+ return (Hs2 / Hs) - ((Hs1 * Hs1) / (Hs * Hs));
+ }
+
+ /**
+ * Calculates the Nth generalized harmonic number. See
+ * Harmonic
+ * Series.
+ *
+ * @param n Term in the series to calculate (must be larger than 1)
+ * @param m Exponent (special case {@code m = 1} is the harmonic series).
+ * @return the nth generalized harmonic number.
+ */
+ private double generalizedHarmonic(final int n, final double m) {
+ double value = 0;
+ for (int k = n; k > 0; --k) {
+ value += 1.0 / FastMath.pow(k, m);
+ }
+ return value;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The lower bound of the support is always 1 no matter the parameters.
+ *
+ * @return lower bound of the support (always 1)
+ */
+ public int getSupportLowerBound() {
+ return 1;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The upper bound of the support is the number of elements.
+ *
+ * @return upper bound of the support
+ */
+ public int getSupportUpperBound() {
+ return getNumberOfElements();
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The support of this distribution is connected.
+ *
+ * @return {@code true}
+ */
+ public boolean isSupportConnected() {
+ return true;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int sample() {
+ if (sampler == null) {
+ sampler = new ZipfRejectionInversionSampler(numberOfElements, exponent);
+ }
+ return sampler.sample(random);
+ }
+
+ /**
+ * Utility class implementing a rejection inversion sampling method for a discrete,
+ * bounded Zipf distribution that is based on the method described in
+ *
+ *
+ * H(x) is an integral function of h(x),
+ * the derivative of H(x) is h(x).
+ *
+ * @param x free parameter
+ * @return {@code H(x)}
+ */
+ private double hIntegral(final double x) {
+ final double logX = FastMath.log(x);
+ return helper2((1d-exponent)*logX)*logX;
+ }
+
+ /**
+ * {@code h(x) := 1/x^exponent}
+ *
+ * @param x free parameter
+ * @return h(x)
+ */
+ private double h(final double x) {
+ return FastMath.exp(-exponent * FastMath.log(x));
+ }
+
+ /**
+ * The inverse function of H(x).
+ *
+ * @param x free parameter
+ * @return y for which {@code H(y) = x}
+ */
+ private double hIntegralInverse(final double x) {
+ double t = x*(1d-exponent);
+ if (t < -1d) {
+ // Limit value to the range [-1, +inf).
+ // t could be smaller than -1 in some rare cases due to numerical errors.
+ t = -1;
+ }
+ return FastMath.exp(helper1(t)*x);
+ }
+
+ /**
+ * Helper function that calculates {@code log(1+x)/x}.
+ *
+ * If'2 (t) = a2 ω2 t - ω2 If2 (t)
+ *
+ *
The preceding expression shows that If'2 (t) is a linear + * combination of both t and If2 (t): If'2 (t) = A × t + B × If2 (t) + *
+ * + *From the primitive, we can deduce the same form for definite + * integrals between t1 and ti for each ti : + *
+ * If2 (ti) - If2 (t1) = A × (ti - t1) + B × (If2 (ti) - If2 (t1)) + *+ * + * + *
We can find the coefficients A and B that best fit the sample + * to this linear expression by computing the definite integrals for + * each sample points. + *
+ * + *For a bilinear expression z (xi, yi) = A × xi + B × yi, the + * coefficients A and B that minimize a least square criterion + * ∑ (zi - z (xi, yi))2 are given by these expressions:
+ *+ * + * ∑yiyi ∑xizi - ∑xiyi ∑yizi + * A = ------------------------ + * ∑xixi ∑yiyi - ∑xiyi ∑xiyi + * + * ∑xixi ∑yizi - ∑xiyi ∑xizi + * B = ------------------------ + * ∑xixi ∑yiyi - ∑xiyi ∑xiyi + *+ * + * + * + *
In fact, we can assume both a and ω are positive and + * compute them directly, knowing that A = a2 ω2 and that + * B = - ω2. The complete algorithm is therefore:
+ *+ * + * for each ti from t1 to tn-1, compute: + * f (ti) + * f' (ti) = (f (ti+1) - f(ti-1)) / (ti+1 - ti-1) + * xi = ti - t1 + * yi = ∫ f2 from t1 to ti + * zi = ∫ f'2 from t1 to ti + * update the sums ∑xixi, ∑yiyi, ∑xiyi, ∑xizi and ∑yizi + * end for + * + * |-------------------------- + * \ | ∑yiyi ∑xizi - ∑xiyi ∑yizi + * a = \ | ------------------------ + * \| ∑xiyi ∑xizi - ∑xixi ∑yizi + * + * + * |-------------------------- + * \ | ∑xiyi ∑xizi - ∑xixi ∑yizi + * ω = \ | ------------------------ + * \| ∑xixi ∑yiyi - ∑xiyi ∑xiyi + * + *+ * + * + *
Once we know ω, we can compute: + *
+ * fc = ω f (t) cos (ω t) - f' (t) sin (ω t) + * fs = ω f (t) sin (ω t) + f' (t) cos (ω t) + *+ * + * + *
It appears that fc = a ω cos (φ) and
+ * fs = -a ω sin (φ), so we can use these
+ * expressions to compute φ. The best estimate over the sample is
+ * given by averaging these expressions.
+ *
Since integrals and means are involved in the preceding + * estimations, these operations run in O(n) time, where n is the + * number of measurements.
+ */ + public static class ParameterGuesser { + /** Amplitude. */ + private final double a; + /** Angular frequency. */ + private final double omega; + /** Phase. */ + private final double phi; + + /** + * Simple constructor. + * + * @param observations Sampled observations. + * @throws NumberIsTooSmallException if the sample is too short. + * @throws ZeroException if the abscissa range is zero. + * @throws MathIllegalStateException when the guessing procedure cannot + * produce sensible results. + */ + public ParameterGuesser(WeightedObservedPoint[] observations) { + if (observations.length < 4) { + throw new NumberIsTooSmallException(LocalizedFormats.INSUFFICIENT_OBSERVED_POINTS_IN_SAMPLE, + observations.length, 4, true); + } + + final WeightedObservedPoint[] sorted = sortObservations(observations); + + final double aOmega[] = guessAOmega(sorted); + a = aOmega[0]; + omega = aOmega[1]; + + phi = guessPhi(sorted); + } + + /** + * Gets an estimation of the parameters. + * + * @return the guessed parameters, in the following order: + *Instances of this class are guaranteed to be immutable.
+ * @since 2.0 + */ +public class WeightedObservedPoint implements Serializable { + /** Serializable version id. */ + private static final long serialVersionUID = 5306874947404636157L; + /** Weight of the measurement in the fitting process. */ + private final double weight; + /** Abscissa of the point. */ + private final double x; + /** Observed value of the function at x. */ + private final double y; + + /** + * Simple constructor. + * + * @param weight Weight of the measurement in the fitting process. + * @param x Abscissa of the measurement. + * @param y Ordinate of the measurement. + */ + public WeightedObservedPoint(final double weight, final double x, final double y) { + this.weight = weight; + this.x = x; + this.y = y; + } + + /** + * Gets the weight of the measurement in the fitting process. + * + * @return the weight of the measurement in the fitting process. + */ + public double getWeight() { + return weight; + } + + /** + * Gets the abscissa of the point. + * + * @return the abscissa of the point. + */ + public double getX() { + return x; + } + + /** + * Gets the observed value of the function at x. + * + * @return the observed value of the function at x. + */ + public double getY() { + return y; + } + +} + diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fitting/WeightedObservedPoints.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fitting/WeightedObservedPoints.java new file mode 100644 index 000000000..c4db74c25 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fitting/WeightedObservedPoints.java @@ -0,0 +1,112 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.fitting; + +import java.util.List; +import java.util.ArrayList; +import java.io.Serializable; + +/** + * Simple container for weighted observed points used + * in {@link AbstractCurveFitter curve fitting} algorithms. + * + * @since 3.3 + */ +public class WeightedObservedPoints implements Serializable { + /** Serializable version id. */ + private static final long serialVersionUID = 20130813L; + + /** Observed points. */ + private final ListConvenience constructor for when the relative and absolute tolerances are the + * same. Same as {@code new EvaluationRmsChecker(tol, tol)}. + * + * @param tol the relative and absolute tolerance. + * @see #EvaluationRmsChecker(double, double) + */ + public EvaluationRmsChecker(final double tol) { + this(tol, tol); + } + + /** + * Create a convergence checker for the RMS with a relative and absolute tolerance. + * + *
The optimization has converged when the RMS of consecutive evaluations are equal + * to within the given relative tolerance or absolute tolerance. + * + * @param relTol the relative tolerance. + * @param absTol the absolute tolerance. + * @see Precision#equals(double, double, double) + * @see Precision#equalsWithRelativeTolerance(double, double, double) + */ + public EvaluationRmsChecker(final double relTol, final double absTol) { + this.relTol = relTol; + this.absTol = absTol; + } + + /** {@inheritDoc} */ + public boolean converged(final int iteration, + final LeastSquaresProblem.Evaluation previous, + final LeastSquaresProblem.Evaluation current) { + final double prevRms = previous.getRMS(); + final double currRms = current.getRMS(); + return Precision.equals(prevRms, currRms, this.absTol) || + Precision.equalsWithRelativeTolerance(prevRms, currRms, this.relTol); + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fitting/leastsquares/GaussNewtonOptimizer.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fitting/leastsquares/GaussNewtonOptimizer.java new file mode 100644 index 000000000..fc5870735 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fitting/leastsquares/GaussNewtonOptimizer.java @@ -0,0 +1,298 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.fitting.leastsquares; + +import com.fr.third.org.apache.commons.math3.exception.ConvergenceException; +import com.fr.third.org.apache.commons.math3.exception.NullArgumentException; +import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats; +import com.fr.third.org.apache.commons.math3.linear.ArrayRealVector; +import com.fr.third.org.apache.commons.math3.linear.CholeskyDecomposition; +import com.fr.third.org.apache.commons.math3.linear.LUDecomposition; +import com.fr.third.org.apache.commons.math3.linear.MatrixUtils; +import com.fr.third.org.apache.commons.math3.linear.NonPositiveDefiniteMatrixException; +import com.fr.third.org.apache.commons.math3.linear.QRDecomposition; +import com.fr.third.org.apache.commons.math3.linear.RealMatrix; +import com.fr.third.org.apache.commons.math3.linear.RealVector; +import com.fr.third.org.apache.commons.math3.linear.SingularMatrixException; +import com.fr.third.org.apache.commons.math3.linear.SingularValueDecomposition; +import com.fr.third.org.apache.commons.math3.optim.ConvergenceChecker; +import com.fr.third.org.apache.commons.math3.util.Incrementor; +import com.fr.third.org.apache.commons.math3.util.Pair; + +/** + * Gauss-Newton least-squares solver. + *
This class solve a least-square problem by + * solving the normal equations of the linearized problem at each iteration. Either LU + * decomposition or Cholesky decomposition can be used to solve the normal equations, + * or QR decomposition or SVD decomposition can be used to solve the linear system. LU + * decomposition is faster but QR decomposition is more robust for difficult problems, + * and SVD can compute a solution for rank-deficient problems. + *
+ * + * @since 3.3 + */ +public class GaussNewtonOptimizer implements LeastSquaresOptimizer { + + /** The decomposition algorithm to use to solve the normal equations. */ + //TODO move to linear package and expand options? + public enum Decomposition { + /** + * Solve by forming the normal equations (JTJx=JTr) and + * using the {@link LUDecomposition}. + * + *Theoretically this method takes mn2/2 operations to compute the + * normal matrix and n3/3 operations (m > n) to solve the system using + * the LU decomposition.
+ */ + LU { + @Override + protected RealVector solve(final RealMatrix jacobian, + final RealVector residuals) { + try { + final PairTheoretically this method takes mn2 - n3/3 operations + * (m > n) and has better numerical accuracy than any method that forms the normal + * equations.
+ */ + QR { + @Override + protected RealVector solve(final RealMatrix jacobian, + final RealVector residuals) { + try { + return new QRDecomposition(jacobian, SINGULARITY_THRESHOLD) + .getSolver() + .solve(residuals); + } catch (SingularMatrixException e) { + throw new ConvergenceException(LocalizedFormats.UNABLE_TO_SOLVE_SINGULAR_PROBLEM, e); + } + } + }, + /** + * Solve by forming the normal equations (JTJx=JTr) and + * using the {@link CholeskyDecomposition}. + * + *Theoretically this method takes mn2/2 operations to compute the + * normal matrix and n3/6 operations (m > n) to solve the system using + * the Cholesky decomposition.
+ */ + CHOLESKY { + @Override + protected RealVector solve(final RealMatrix jacobian, + final RealVector residuals) { + try { + final PairThis method is slower, but can provide a solution for rank deficient and + * nearly singular systems. + */ + SVD { + @Override + protected RealVector solve(final RealMatrix jacobian, + final RealVector residuals) { + return new SingularValueDecomposition(jacobian) + .getSolver() + .solve(residuals); + } + }; + + /** + * Solve the linear least squares problem Jx=r. + * + * @param jacobian the Jacobian matrix, J. the number of rows >= the number or + * columns. + * @param residuals the computed residuals, r. + * @return the solution x, to the linear least squares problem Jx=r. + * @throws ConvergenceException if the matrix properties (e.g. singular) do not + * permit a solution. + */ + protected abstract RealVector solve(RealMatrix jacobian, + RealVector residuals); + } + + /** + * The singularity threshold for matrix decompositions. Determines when a {@link + * ConvergenceException} is thrown. The current value was the default value for {@link + * LUDecomposition}. + */ + private static final double SINGULARITY_THRESHOLD = 1e-11; + + /** Indicator for using LU decomposition. */ + private final Decomposition decomposition; + + /** + * Creates a Gauss Newton optimizer. + *
+ * The default for the algorithm is to solve the normal equations using QR + * decomposition. + */ + public GaussNewtonOptimizer() { + this(Decomposition.QR); + } + + /** + * Create a Gauss Newton optimizer that uses the given decomposition algorithm to + * solve the normal equations. + * + * @param decomposition the {@link Decomposition} algorithm. + */ + public GaussNewtonOptimizer(final Decomposition decomposition) { + this.decomposition = decomposition; + } + + /** + * Get the matrix decomposition algorithm used to solve the normal equations. + * + * @return the matrix {@link Decomposition} algoritm. + */ + public Decomposition getDecomposition() { + return this.decomposition; + } + + /** + * Configure the decomposition algorithm. + * + * @param newDecomposition the {@link Decomposition} algorithm to use. + * @return a new instance. + */ + public GaussNewtonOptimizer withDecomposition(final Decomposition newDecomposition) { + return new GaussNewtonOptimizer(newDecomposition); + } + + /** {@inheritDoc} */ + public Optimum optimize(final LeastSquaresProblem lsp) { + //create local evaluation and iteration counts + final Incrementor evaluationCounter = lsp.getEvaluationCounter(); + final Incrementor iterationCounter = lsp.getIterationCounter(); + final ConvergenceChecker
+ * This factory method is provided for continuity with previous interfaces. Newer
+ * applications should use {@link #create(MultivariateJacobianFunction, RealVector,
+ * RealVector, ConvergenceChecker, int, int)}, or {@link #create(MultivariateJacobianFunction,
+ * RealVector, RealVector, RealMatrix, ConvergenceChecker, int, int)}.
+ *
+ * @param model the model function. Produces the computed values.
+ * @param jacobian the jacobian of the model with respect to the parameters
+ * @param observed the observed (target) values
+ * @param start the initial guess.
+ * @param weight the weight matrix
+ * @param checker convergence checker
+ * @param maxEvaluations the maximum number of times to evaluate the model
+ * @param maxIterations the maximum number to times to iterate in the algorithm
+ * @return the specified General Least Squares problem.
+ */
+ public static LeastSquaresProblem create(final MultivariateVectorFunction model,
+ final MultivariateMatrixFunction jacobian,
+ final double[] observed,
+ final double[] start,
+ final RealMatrix weight,
+ final ConvergenceChecker
+ * Includes the observed values, computed model function, and
+ * convergence/divergence criteria. Weights are implicit in {@link
+ * Evaluation#getResiduals()} and {@link Evaluation#getJacobian()}.
+ *
+ * Instances are typically either created progressively using a {@link
+ * LeastSquaresBuilder builder} or created at once using a {@link LeastSquaresFactory
+ * factory}.
+ * This implementation should work even for over-determined systems
+ * (i.e. systems having more point than equations). Over-determined systems
+ * are solved by ignoring the point which have the smallest impact according
+ * to their jacobian column norm. Only the rank of the matrix and some loop bounds
+ * are changed to implement this. The resolution engine is a simple translation of the MINPACK lmder routine with minor
+ * changes. The changes include the over-determined resolution, the use of
+ * inherited convergence checker and the Q.R. decomposition which has been
+ * rewritten following the algorithm described in the
+ * P. Lascaux and R. Theodor book Analyse numérique matricielle
+ * appliquée à l'art de l'ingénieur, Masson 1986. The authors of the original fortran version are:
+ *
Note that this
+ * operation involves the inversion of the JTJ matrix,
+ * where {@code J} is the Jacobian matrix. The {@code threshold} parameter is a
+ * way for the caller to specify that the result of this computation should be
+ * considered meaningless, and thus trigger an exception.
+ *
+ *
+ * @param threshold Singularity threshold.
+ * @return the covariance matrix.
+ * @throws SingularMatrixException
+ * if the covariance matrix cannot be computed (singular problem).
+ */
+ RealMatrix getCovariances(double threshold);
+
+ /**
+ * Get an estimate of the standard deviation of the parameters. The returned
+ * values are the square root of the diagonal coefficients of the covariance
+ * matrix, {@code sd(a[i]) ~= sqrt(C[i][i])}, where {@code a[i]} is the optimized
+ * value of the {@code i}-th parameter, and {@code C} is the covariance matrix.
+ *
+ *
+ * @param covarianceSingularityThreshold Singularity threshold (see {@link
+ * #getCovariances(double) computeCovariances}).
+ * @return an estimate of the standard deviation of the optimized parameters
+ * @throws SingularMatrixException
+ * if the covariance matrix cannot be computed.
+ */
+ RealVector getSigma(double covarianceSingularityThreshold);
+
+ /**
+ * Get the normalized cost. It is the square-root of the sum of squared of
+ * the residuals, divided by the number of measurements.
+ *
+ * @return the cost.
+ */
+ double getRMS();
+
+ /**
+ * Get the weighted Jacobian matrix.
+ *
+ * @return the weighted Jacobian: W1/2 J.
+ * @throws DimensionMismatchException
+ * if the Jacobian dimension does not match problem dimension.
+ */
+ RealMatrix getJacobian();
+
+ /**
+ * Get the cost.
+ *
+ * @return the cost.
+ * @see #getResiduals()
+ */
+ double getCost();
+
+ /**
+ * Get the weighted residuals. The residual is the difference between the
+ * observed (target) values and the model (objective function) value. There is one
+ * residual for each element of the vector-valued function. The raw residuals are
+ * then multiplied by the square root of the weight matrix.
+ *
+ * @return the weighted residuals: W1/2 K.
+ * @throws DimensionMismatchException
+ * if the residuals have the wrong length.
+ */
+ RealVector getResiduals();
+
+ /**
+ * Get the abscissa (independent variables) of this evaluation.
+ *
+ * @return the point provided to {@link #evaluate(RealVector)}.
+ */
+ RealVector getPoint();
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fitting/leastsquares/LevenbergMarquardtOptimizer.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fitting/leastsquares/LevenbergMarquardtOptimizer.java
new file mode 100644
index 000000000..9f25debf8
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fitting/leastsquares/LevenbergMarquardtOptimizer.java
@@ -0,0 +1,1042 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.fitting.leastsquares;
+
+import java.util.Arrays;
+
+import com.fr.third.org.apache.commons.math3.exception.ConvergenceException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.fitting.leastsquares.LeastSquaresProblem.Evaluation;
+import com.fr.third.org.apache.commons.math3.linear.ArrayRealVector;
+import com.fr.third.org.apache.commons.math3.linear.RealMatrix;
+import com.fr.third.org.apache.commons.math3.optim.ConvergenceChecker;
+import com.fr.third.org.apache.commons.math3.util.Incrementor;
+import com.fr.third.org.apache.commons.math3.util.Precision;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+
+
+/**
+ * This class solves a least-squares problem using the Levenberg-Marquardt
+ * algorithm.
+ *
+ *
+ *
+ * The redistribution policy for MINPACK is available here, for convenience, it
+ * is reproduced below.
| + * Minpack Copyright Notice (1999) University of Chicago. + * All rights reserved + * |
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
|
+ * The default values for the algorithm settings are: + *
This implementation is a translation in Java of the MINPACK + * lmpar + * routine.
+ *This method sets the lmPar and lmDir attributes.
+ *The authors of the original fortran function are:
+ *Luc Maisonobe did the Java translation.
+ * + * @param qy Array containing qTy. + * @param delta Upper bound on the euclidean norm of diagR * lmDir. + * @param diag Diagonal matrix. + * @param internalData Data (modified in-place in this method). + * @param solvedCols Number of solved point. + * @param work1 work array + * @param work2 work array + * @param work3 work array + * @param lmDir the "returned" LM direction will be stored in this array. + * @param lmPar the value of the LM parameter from the previous iteration. + * @return the new LM parameter + */ + private double determineLMParameter(double[] qy, double delta, double[] diag, + InternalData internalData, int solvedCols, + double[] work1, double[] work2, double[] work3, + double[] lmDir, double lmPar) { + final double[][] weightedJacobian = internalData.weightedJacobian; + final int[] permutation = internalData.permutation; + final int rank = internalData.rank; + final double[] diagR = internalData.diagR; + + final int nC = weightedJacobian[0].length; + + // compute and store in x the gauss-newton direction, if the + // jacobian is rank-deficient, obtain a least squares solution + for (int j = 0; j < rank; ++j) { + lmDir[permutation[j]] = qy[j]; + } + for (int j = rank; j < nC; ++j) { + lmDir[permutation[j]] = 0; + } + for (int k = rank - 1; k >= 0; --k) { + int pk = permutation[k]; + double ypk = lmDir[pk] / diagR[pk]; + for (int i = 0; i < k; ++i) { + lmDir[permutation[i]] -= ypk * weightedJacobian[i][pk]; + } + lmDir[pk] = ypk; + } + + // evaluate the function at the origin, and test + // for acceptance of the Gauss-Newton direction + double dxNorm = 0; + for (int j = 0; j < solvedCols; ++j) { + int pj = permutation[j]; + double s = diag[pj] * lmDir[pj]; + work1[pj] = s; + dxNorm += s * s; + } + dxNorm = FastMath.sqrt(dxNorm); + double fp = dxNorm - delta; + if (fp <= 0.1 * delta) { + lmPar = 0; + return lmPar; + } + + // if the jacobian is not rank deficient, the Newton step provides + // a lower bound, parl, for the zero of the function, + // otherwise set this bound to zero + double sum2; + double parl = 0; + if (rank == solvedCols) { + for (int j = 0; j < solvedCols; ++j) { + int pj = permutation[j]; + work1[pj] *= diag[pj] / dxNorm; + } + sum2 = 0; + for (int j = 0; j < solvedCols; ++j) { + int pj = permutation[j]; + double sum = 0; + for (int i = 0; i < j; ++i) { + sum += weightedJacobian[i][pj] * work1[permutation[i]]; + } + double s = (work1[pj] - sum) / diagR[pj]; + work1[pj] = s; + sum2 += s * s; + } + parl = fp / (delta * sum2); + } + + // calculate an upper bound, paru, for the zero of the function + sum2 = 0; + for (int j = 0; j < solvedCols; ++j) { + int pj = permutation[j]; + double sum = 0; + for (int i = 0; i <= j; ++i) { + sum += weightedJacobian[i][pj] * qy[i]; + } + sum /= diag[pj]; + sum2 += sum * sum; + } + double gNorm = FastMath.sqrt(sum2); + double paru = gNorm / delta; + if (paru == 0) { + paru = Precision.SAFE_MIN / FastMath.min(delta, 0.1); + } + + // if the input par lies outside of the interval (parl,paru), + // set par to the closer endpoint + lmPar = FastMath.min(paru, FastMath.max(lmPar, parl)); + if (lmPar == 0) { + lmPar = gNorm / dxNorm; + } + + for (int countdown = 10; countdown >= 0; --countdown) { + + // evaluate the function at the current value of lmPar + if (lmPar == 0) { + lmPar = FastMath.max(Precision.SAFE_MIN, 0.001 * paru); + } + double sPar = FastMath.sqrt(lmPar); + for (int j = 0; j < solvedCols; ++j) { + int pj = permutation[j]; + work1[pj] = sPar * diag[pj]; + } + determineLMDirection(qy, work1, work2, internalData, solvedCols, work3, lmDir); + + dxNorm = 0; + for (int j = 0; j < solvedCols; ++j) { + int pj = permutation[j]; + double s = diag[pj] * lmDir[pj]; + work3[pj] = s; + dxNorm += s * s; + } + dxNorm = FastMath.sqrt(dxNorm); + double previousFP = fp; + fp = dxNorm - delta; + + // if the function is small enough, accept the current value + // of lmPar, also test for the exceptional cases where parl is zero + if (FastMath.abs(fp) <= 0.1 * delta || + (parl == 0 && + fp <= previousFP && + previousFP < 0)) { + return lmPar; + } + + // compute the Newton correction + for (int j = 0; j < solvedCols; ++j) { + int pj = permutation[j]; + work1[pj] = work3[pj] * diag[pj] / dxNorm; + } + for (int j = 0; j < solvedCols; ++j) { + int pj = permutation[j]; + work1[pj] /= work2[j]; + double tmp = work1[pj]; + for (int i = j + 1; i < solvedCols; ++i) { + work1[permutation[i]] -= weightedJacobian[i][pj] * tmp; + } + } + sum2 = 0; + for (int j = 0; j < solvedCols; ++j) { + double s = work1[permutation[j]]; + sum2 += s * s; + } + double correction = fp / (delta * sum2); + + // depending on the sign of the function, update parl or paru. + if (fp > 0) { + parl = FastMath.max(parl, lmPar); + } else if (fp < 0) { + paru = FastMath.min(paru, lmPar); + } + + // compute an improved estimate for lmPar + lmPar = FastMath.max(parl, lmPar + correction); + } + + return lmPar; + } + + /** + * Solve a*x = b and d*x = 0 in the least squares sense. + *This implementation is a translation in Java of the MINPACK + * qrsolv + * routine.
+ *This method sets the lmDir and lmDiag attributes.
+ *The authors of the original fortran function are:
+ *Luc Maisonobe did the Java translation.
+ * + * @param qy array containing qTy + * @param diag diagonal matrix + * @param lmDiag diagonal elements associated with lmDir + * @param internalData Data (modified in-place in this method). + * @param solvedCols Number of sloved point. + * @param work work array + * @param lmDir the "returned" LM direction is stored in this array + */ + private void determineLMDirection(double[] qy, double[] diag, + double[] lmDiag, + InternalData internalData, + int solvedCols, + double[] work, + double[] lmDir) { + final int[] permutation = internalData.permutation; + final double[][] weightedJacobian = internalData.weightedJacobian; + final double[] diagR = internalData.diagR; + + // copy R and Qty to preserve input and initialize s + // in particular, save the diagonal elements of R in lmDir + for (int j = 0; j < solvedCols; ++j) { + int pj = permutation[j]; + for (int i = j + 1; i < solvedCols; ++i) { + weightedJacobian[i][pj] = weightedJacobian[j][permutation[i]]; + } + lmDir[j] = diagR[pj]; + work[j] = qy[j]; + } + + // eliminate the diagonal matrix d using a Givens rotation + for (int j = 0; j < solvedCols; ++j) { + + // prepare the row of d to be eliminated, locating the + // diagonal element using p from the Q.R. factorization + int pj = permutation[j]; + double dpj = diag[pj]; + if (dpj != 0) { + Arrays.fill(lmDiag, j + 1, lmDiag.length, 0); + } + lmDiag[j] = dpj; + + // the transformations to eliminate the row of d + // modify only a single element of Qty + // beyond the first n, which is initially zero. + double qtbpj = 0; + for (int k = j; k < solvedCols; ++k) { + int pk = permutation[k]; + + // determine a Givens rotation which eliminates the + // appropriate element in the current row of d + if (lmDiag[k] != 0) { + + final double sin; + final double cos; + double rkk = weightedJacobian[k][pk]; + if (FastMath.abs(rkk) < FastMath.abs(lmDiag[k])) { + final double cotan = rkk / lmDiag[k]; + sin = 1.0 / FastMath.sqrt(1.0 + cotan * cotan); + cos = sin * cotan; + } else { + final double tan = lmDiag[k] / rkk; + cos = 1.0 / FastMath.sqrt(1.0 + tan * tan); + sin = cos * tan; + } + + // compute the modified diagonal element of R and + // the modified element of (Qty,0) + weightedJacobian[k][pk] = cos * rkk + sin * lmDiag[k]; + final double temp = cos * work[k] + sin * qtbpj; + qtbpj = -sin * work[k] + cos * qtbpj; + work[k] = temp; + + // accumulate the tranformation in the row of s + for (int i = k + 1; i < solvedCols; ++i) { + double rik = weightedJacobian[i][pk]; + final double temp2 = cos * rik + sin * lmDiag[i]; + lmDiag[i] = -sin * rik + cos * lmDiag[i]; + weightedJacobian[i][pk] = temp2; + } + } + } + + // store the diagonal element of s and restore + // the corresponding diagonal element of R + lmDiag[j] = weightedJacobian[j][permutation[j]]; + weightedJacobian[j][permutation[j]] = lmDir[j]; + } + + // solve the triangular system for z, if the system is + // singular, then obtain a least squares solution + int nSing = solvedCols; + for (int j = 0; j < solvedCols; ++j) { + if ((lmDiag[j] == 0) && (nSing == solvedCols)) { + nSing = j; + } + if (nSing < solvedCols) { + work[j] = 0; + } + } + if (nSing > 0) { + for (int j = nSing - 1; j >= 0; --j) { + int pj = permutation[j]; + double sum = 0; + for (int i = j + 1; i < nSing; ++i) { + sum += weightedJacobian[i][pj] * work[i]; + } + work[j] = (work[j] - sum) / lmDiag[j]; + } + } + + // permute the components of z back to components of lmDir + for (int j = 0; j < lmDir.length; ++j) { + lmDir[permutation[j]] = work[j]; + } + } + + /** + * Decompose a matrix A as A.P = Q.R using Householder transforms. + *As suggested in the P. Lascaux and R. Theodor book + * Analyse numérique matricielle appliquée à + * l'art de l'ingénieur (Masson, 1986), instead of representing + * the Householder transforms with uk unit vectors such that: + *
+ * Hk = I - 2uk.ukt + *+ * we use k non-unit vectors such that: + *
+ * Hk = I - betakvk.vkt + *+ * where vk = ak - alphak ek. + * The betak coefficients are provided upon exit as recomputing + * them from the vk vectors would be costly. + *
This decomposition handles rank deficient cases since the tranformations + * are performed in non-increasing columns norms order thanks to columns + * pivoting. The diagonal elements of the R matrix are therefore also in + * non-increasing absolute values order.
+ * + * @param jacobian Weighted Jacobian matrix at the current point. + * @param solvedCols Number of solved point. + * @return data used in other methods of this class. + * @throws ConvergenceException if the decomposition cannot be performed. + */ + private InternalData qrDecomposition(RealMatrix jacobian, + int solvedCols) throws ConvergenceException { + // Code in this class assumes that the weighted Jacobian is -(W^(1/2) J), + // hence the multiplication by -1. + final double[][] weightedJacobian = jacobian.scalarMultiply(-1).getData(); + + final int nR = weightedJacobian.length; + final int nC = weightedJacobian[0].length; + + final int[] permutation = new int[nC]; + final double[] diagR = new double[nC]; + final double[] jacNorm = new double[nC]; + final double[] beta = new double[nC]; + + // initializations + for (int k = 0; k < nC; ++k) { + permutation[k] = k; + double norm2 = 0; + for (int i = 0; i < nR; ++i) { + double akk = weightedJacobian[i][k]; + norm2 += akk * akk; + } + jacNorm[k] = FastMath.sqrt(norm2); + } + + // transform the matrix column after column + for (int k = 0; k < nC; ++k) { + + // select the column with the greatest norm on active components + int nextColumn = -1; + double ak2 = Double.NEGATIVE_INFINITY; + for (int i = k; i < nC; ++i) { + double norm2 = 0; + for (int j = k; j < nR; ++j) { + double aki = weightedJacobian[j][permutation[i]]; + norm2 += aki * aki; + } + if (Double.isInfinite(norm2) || Double.isNaN(norm2)) { + throw new ConvergenceException(LocalizedFormats.UNABLE_TO_PERFORM_QR_DECOMPOSITION_ON_JACOBIAN, + nR, nC); + } + if (norm2 > ak2) { + nextColumn = i; + ak2 = norm2; + } + } + if (ak2 <= qrRankingThreshold) { + return new InternalData(weightedJacobian, permutation, k, diagR, jacNorm, beta); + } + int pk = permutation[nextColumn]; + permutation[nextColumn] = permutation[k]; + permutation[k] = pk; + + // choose alpha such that Hk.u = alpha ek + double akk = weightedJacobian[k][pk]; + double alpha = (akk > 0) ? -FastMath.sqrt(ak2) : FastMath.sqrt(ak2); + double betak = 1.0 / (ak2 - akk * alpha); + beta[pk] = betak; + + // transform the current column + diagR[pk] = alpha; + weightedJacobian[k][pk] -= alpha; + + // transform the remaining columns + for (int dk = nC - 1 - k; dk > 0; --dk) { + double gamma = 0; + for (int j = k; j < nR; ++j) { + gamma += weightedJacobian[j][pk] * weightedJacobian[j][permutation[k + dk]]; + } + gamma *= betak; + for (int j = k; j < nR; ++j) { + weightedJacobian[j][permutation[k + dk]] -= gamma * weightedJacobian[j][pk]; + } + } + } + + return new InternalData(weightedJacobian, permutation, solvedCols, diagR, jacNorm, beta); + } + + /** + * Compute the product Qt.y for some Q.R. decomposition. + * + * @param y vector to multiply (will be overwritten with the result) + * @param internalData Data. + */ + private void qTy(double[] y, + InternalData internalData) { + final double[][] weightedJacobian = internalData.weightedJacobian; + final int[] permutation = internalData.permutation; + final double[] beta = internalData.beta; + + final int nR = weightedJacobian.length; + final int nC = weightedJacobian[0].length; + + for (int k = 0; k < nC; ++k) { + int pk = permutation[k]; + double gamma = 0; + for (int i = k; i < nR; ++i) { + gamma += weightedJacobian[i][pk] * y[i]; + } + gamma *= beta[pk]; + for (int i = k; i < nR; ++i) { + y[i] -= gamma * weightedJacobian[i][pk]; + } + } + } +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fitting/leastsquares/MultivariateJacobianFunction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fitting/leastsquares/MultivariateJacobianFunction.java new file mode 100644 index 000000000..70e50fe02 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fitting/leastsquares/MultivariateJacobianFunction.java @@ -0,0 +1,39 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.fr.third.org.apache.commons.math3.fitting.leastsquares; + +import com.fr.third.org.apache.commons.math3.linear.RealMatrix; +import com.fr.third.org.apache.commons.math3.linear.RealVector; +import com.fr.third.org.apache.commons.math3.util.Pair; + +/** + * A interface for functions that compute a vector of values and can compute their + * derivatives (Jacobian). + * + * @since 3.3 + */ +public interface MultivariateJacobianFunction { + + /** + * Compute the function value and its Jacobian. + * + * @param point the abscissae + * @return the values and their Jacobian of this vector valued function. + */ + Pairsource until a non-whitespace character is found.
+ * @param source the string to parse
+ * @param pos input/output parsing parameter. On output, pos
+ * holds the index of the next non-whitespace character.
+ */
+ protected static void parseAndIgnoreWhitespace(final String source,
+ final ParsePosition pos) {
+ parseNextCharacter(source, pos);
+ pos.setIndex(pos.getIndex() - 1);
+ }
+
+ /**
+ * Parses source until a non-whitespace character is found.
+ * @param source the string to parse
+ * @param pos input/output parsing parameter.
+ * @return the first non-whitespace character.
+ */
+ protected static char parseNextCharacter(final String source,
+ final ParsePosition pos) {
+ int index = pos.getIndex();
+ final int n = source.length();
+ char ret = 0;
+
+ if (index < n) {
+ char c;
+ do {
+ c = source.charAt(index++);
+ } while (Character.isWhitespace(c) && index < n);
+ pos.setIndex(index);
+
+ if (index < n) {
+ ret = c;
+ }
+ }
+
+ return ret;
+ }
+
+ /**
+ * Formats a double value as a fraction and appends the result to a StringBuffer.
+ *
+ * @param value the double value to format
+ * @param buffer StringBuffer to append to
+ * @param position On input: an alignment field, if desired. On output: the
+ * offsets of the alignment field
+ * @return a reference to the appended buffer
+ * @see #format(Object, StringBuffer, FieldPosition)
+ */
+ @Override
+ public StringBuffer format(final double value,
+ final StringBuffer buffer, final FieldPosition position) {
+ return format(Double.valueOf(value), buffer, position);
+ }
+
+
+ /**
+ * Formats a long value as a fraction and appends the result to a StringBuffer.
+ *
+ * @param value the long value to format
+ * @param buffer StringBuffer to append to
+ * @param position On input: an alignment field, if desired. On output: the
+ * offsets of the alignment field
+ * @return a reference to the appended buffer
+ * @see #format(Object, StringBuffer, FieldPosition)
+ */
+ @Override
+ public StringBuffer format(final long value,
+ final StringBuffer buffer, final FieldPosition position) {
+ return format(Long.valueOf(value), buffer, position);
+ }
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/BigFraction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/BigFraction.java
new file mode 100644
index 000000000..73ef88b68
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/BigFraction.java
@@ -0,0 +1,1226 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.fraction;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
+import com.fr.third.org.apache.commons.math3.exception.MathArithmeticException;
+import com.fr.third.org.apache.commons.math3.exception.MathIllegalArgumentException;
+import com.fr.third.org.apache.commons.math3.exception.NullArgumentException;
+import com.fr.third.org.apache.commons.math3.exception.ZeroException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.FieldElement;
+import com.fr.third.org.apache.commons.math3.util.ArithmeticUtils;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+import com.fr.third.org.apache.commons.math3.util.MathUtils;
+
+/**
+ * Representation of a rational number without any overflow. This class is
+ * immutable.
+ *
+ * @since 2.0
+ */
+public class BigFraction
+ extends Number
+ implements FieldElementBigInteger representation of 100. */
+ private static final BigInteger ONE_HUNDRED = BigInteger.valueOf(100);
+
+ /** The numerator. */
+ private final BigInteger numerator;
+
+ /** The denominator. */
+ private final BigInteger denominator;
+
+ /**
+ * + * Create a {@link BigFraction} equivalent to the passed {@code BigInteger}, ie + * "num / 1". + *
+ * + * @param num + * the numerator. + */ + public BigFraction(final BigInteger num) { + this(num, BigInteger.ONE); + } + + /** + * Create a {@link BigFraction} given the numerator and denominator as + * {@code BigInteger}. The {@link BigFraction} is reduced to lowest terms. + * + * @param num the numerator, must not be {@code null}. + * @param den the denominator, must not be {@code null}. + * @throws ZeroException if the denominator is zero. + * @throws NullArgumentException if either of the arguments is null + */ + public BigFraction(BigInteger num, BigInteger den) { + MathUtils.checkNotNull(num, LocalizedFormats.NUMERATOR); + MathUtils.checkNotNull(den, LocalizedFormats.DENOMINATOR); + if (den.signum() == 0) { + throw new ZeroException(LocalizedFormats.ZERO_DENOMINATOR); + } + if (num.signum() == 0) { + numerator = BigInteger.ZERO; + denominator = BigInteger.ONE; + } else { + + // reduce numerator and denominator by greatest common denominator + final BigInteger gcd = num.gcd(den); + if (BigInteger.ONE.compareTo(gcd) < 0) { + num = num.divide(gcd); + den = den.divide(gcd); + } + + // move sign to numerator + if (den.signum() == -1) { + num = num.negate(); + den = den.negate(); + } + + // store the values in the final fields + numerator = num; + denominator = den; + + } + } + + /** + * Create a fraction given the double value. + *+ * This constructor behaves differently from + * {@link #BigFraction(double, double, int)}. It converts the double value + * exactly, considering its internal bits representation. This works for all + * values except NaN and infinities and does not requires any loop or + * convergence threshold. + *
+ *
+ * Since this conversion is exact and since double numbers are sometimes
+ * approximated, the fraction created may seem strange in some cases. For example,
+ * calling new BigFraction(1.0 / 3.0) does not create
+ * the fraction 1/3, but the fraction 6004799503160661 / 18014398509481984
+ * because the double number passed to the constructor is not exactly 1/3
+ * (this number cannot be stored exactly in IEEE754).
+ *
+ * References: + *
epsilon of value, in absolute terms.
+ * @param maxIterations
+ * maximum number of convergents.
+ * @throws FractionConversionException
+ * if the continued fraction failed to converge.
+ * @see #BigFraction(double)
+ */
+ public BigFraction(final double value, final double epsilon,
+ final int maxIterations)
+ throws FractionConversionException {
+ this(value, epsilon, Integer.MAX_VALUE, maxIterations);
+ }
+
+ /**
+ * Create a fraction given the double value and either the maximum error
+ * allowed or the maximum number of denominator digits.
+ * + * + * NOTE: This constructor is called with EITHER - a valid epsilon value and + * the maxDenominator set to Integer.MAX_VALUE (that way the maxDenominator + * has no effect). OR - a valid maxDenominator value and the epsilon value + * set to zero (that way epsilon only has effect if there is an exact match + * before the maxDenominator value is reached). + *
+ *+ * + * It has been done this way so that the same code can be (re)used for both + * scenarios. However this could be confusing to users if it were part of + * the public API and this constructor should therefore remain PRIVATE. + *
+ * + * See JIRA issue ticket MATH-181 for more details: + * + * https://issues.apache.org/jira/browse/MATH-181 + * + * @param value + * the double value to convert to a fraction. + * @param epsilon + * maximum error allowed. The resulting fraction is within + *epsilon of value, in absolute terms.
+ * @param maxDenominator
+ * maximum denominator value allowed.
+ * @param maxIterations
+ * maximum number of convergents.
+ * @throws FractionConversionException
+ * if the continued fraction failed to converge.
+ */
+ private BigFraction(final double value, final double epsilon,
+ final int maxDenominator, int maxIterations)
+ throws FractionConversionException {
+ long overflow = Integer.MAX_VALUE;
+ double r0 = value;
+ long a0 = (long) FastMath.floor(r0);
+
+ if (FastMath.abs(a0) > overflow) {
+ throw new FractionConversionException(value, a0, 1l);
+ }
+
+ // check for (almost) integer arguments, which should not go
+ // to iterations.
+ if (FastMath.abs(a0 - value) < epsilon) {
+ numerator = BigInteger.valueOf(a0);
+ denominator = BigInteger.ONE;
+ return;
+ }
+
+ long p0 = 1;
+ long q0 = 0;
+ long p1 = a0;
+ long q1 = 1;
+
+ long p2 = 0;
+ long q2 = 1;
+
+ int n = 0;
+ boolean stop = false;
+ do {
+ ++n;
+ final double r1 = 1.0 / (r0 - a0);
+ final long a1 = (long) FastMath.floor(r1);
+ p2 = (a1 * p1) + p0;
+ q2 = (a1 * q1) + q0;
+ if ((p2 > overflow) || (q2 > overflow)) {
+ // in maxDenominator mode, if the last fraction was very close to the actual value
+ // q2 may overflow in the next iteration; in this case return the last one.
+ if (epsilon == 0.0 && FastMath.abs(q1) < maxDenominator) {
+ break;
+ }
+ throw new FractionConversionException(value, p2, q2);
+ }
+
+ final double convergent = (double) p2 / (double) q2;
+ if ((n < maxIterations) &&
+ (FastMath.abs(convergent - value) > epsilon) &&
+ (q2 < maxDenominator)) {
+ p0 = p1;
+ p1 = p2;
+ q0 = q1;
+ q1 = q2;
+ a0 = a1;
+ r0 = r1;
+ } else {
+ stop = true;
+ }
+ } while (!stop);
+
+ if (n >= maxIterations) {
+ throw new FractionConversionException(value, maxIterations);
+ }
+
+ if (q2 < maxDenominator) {
+ numerator = BigInteger.valueOf(p2);
+ denominator = BigInteger.valueOf(q2);
+ } else {
+ numerator = BigInteger.valueOf(p1);
+ denominator = BigInteger.valueOf(q1);
+ }
+ }
+
+ /**
+ * Create a fraction given the double value and maximum denominator.
+ * + * References: + *
+ * Create a {@link BigFraction} equivalent to the passed {@code int}, ie + * "num / 1". + *
+ * + * @param num + * the numerator. + */ + public BigFraction(final int num) { + this(BigInteger.valueOf(num), BigInteger.ONE); + } + + /** + *+ * Create a {@link BigFraction} given the numerator and denominator as simple + * {@code int}. The {@link BigFraction} is reduced to lowest terms. + *
+ * + * @param num + * the numerator. + * @param den + * the denominator. + */ + public BigFraction(final int num, final int den) { + this(BigInteger.valueOf(num), BigInteger.valueOf(den)); + } + + /** + *+ * Create a {@link BigFraction} equivalent to the passed long, ie "num / 1". + *
+ * + * @param num + * the numerator. + */ + public BigFraction(final long num) { + this(BigInteger.valueOf(num), BigInteger.ONE); + } + + /** + *+ * Create a {@link BigFraction} given the numerator and denominator as simple + * {@code long}. The {@link BigFraction} is reduced to lowest terms. + *
+ * + * @param num + * the numerator. + * @param den + * the denominator. + */ + public BigFraction(final long num, final long den) { + this(BigInteger.valueOf(num), BigInteger.valueOf(den)); + } + + /** + *
+ * Creates a BigFraction instance with the 2 parts of a fraction
+ * Y/Z.
+ *
+ * Any negative signs are resolved to be on the numerator. + *
+ * + * @param numerator + * the numerator, for example the three in 'three sevenths'. + * @param denominator + * the denominator, for example the seven in 'three sevenths'. + * @return a new fraction instance, with the numerator and denominator + * reduced. + * @throws ArithmeticException + * if the denominator iszero.
+ */
+ public static BigFraction getReducedFraction(final int numerator,
+ final int denominator) {
+ if (numerator == 0) {
+ return ZERO; // normalize zero.
+ }
+
+ return new BigFraction(numerator, denominator);
+ }
+
+ /**
+ * + * Returns the absolute value of this {@link BigFraction}. + *
+ * + * @return the absolute value as a {@link BigFraction}. + */ + public BigFraction abs() { + return (numerator.signum() == 1) ? this : negate(); + } + + /** + *+ * Adds the value of this fraction to the passed {@link BigInteger}, + * returning the result in reduced form. + *
+ * + * @param bg + * the {@link BigInteger} to add, must'nt benull.
+ * @return a BigFraction instance with the resulting values.
+ * @throws NullArgumentException
+ * if the {@link BigInteger} is null.
+ */
+ public BigFraction add(final BigInteger bg) throws NullArgumentException {
+ MathUtils.checkNotNull(bg);
+
+ if (numerator.signum() == 0) {
+ return new BigFraction(bg);
+ }
+ if (bg.signum() == 0) {
+ return this;
+ }
+
+ return new BigFraction(numerator.add(denominator.multiply(bg)), denominator);
+ }
+
+ /**
+ * + * Adds the value of this fraction to the passed {@code integer}, returning + * the result in reduced form. + *
+ * + * @param i + * the {@code integer} to add. + * @return aBigFraction instance with the resulting values.
+ */
+ public BigFraction add(final int i) {
+ return add(BigInteger.valueOf(i));
+ }
+
+ /**
+ * + * Adds the value of this fraction to the passed {@code long}, returning + * the result in reduced form. + *
+ * + * @param l + * the {@code long} to add. + * @return aBigFraction instance with the resulting values.
+ */
+ public BigFraction add(final long l) {
+ return add(BigInteger.valueOf(l));
+ }
+
+ /**
+ * + * Adds the value of this fraction to another, returning the result in + * reduced form. + *
+ * + * @param fraction + * the {@link BigFraction} to add, must not benull.
+ * @return a {@link BigFraction} instance with the resulting values.
+ * @throws NullArgumentException if the {@link BigFraction} is {@code null}.
+ */
+ public BigFraction add(final BigFraction fraction) {
+ if (fraction == null) {
+ throw new NullArgumentException(LocalizedFormats.FRACTION);
+ }
+ if (fraction.numerator.signum() == 0) {
+ return this;
+ }
+ if (numerator.signum() == 0) {
+ return fraction;
+ }
+
+ BigInteger num = null;
+ BigInteger den = null;
+
+ if (denominator.equals(fraction.denominator)) {
+ num = numerator.add(fraction.numerator);
+ den = denominator;
+ } else {
+ num = (numerator.multiply(fraction.denominator)).add((fraction.numerator).multiply(denominator));
+ den = denominator.multiply(fraction.denominator);
+ }
+
+ if (num.signum() == 0) {
+ return ZERO;
+ }
+
+ return new BigFraction(num, den);
+
+ }
+
+ /**
+ *
+ * Gets the fraction as a BigDecimal. This calculates the
+ * fraction as the numerator divided by denominator.
+ *
BigDecimal.
+ * @throws ArithmeticException
+ * if the exact quotient does not have a terminating decimal
+ * expansion.
+ * @see BigDecimal
+ */
+ public BigDecimal bigDecimalValue() {
+ return new BigDecimal(numerator).divide(new BigDecimal(denominator));
+ }
+
+ /**
+ *
+ * Gets the fraction as a BigDecimal following the passed
+ * rounding mode. This calculates the fraction as the numerator divided by
+ * denominator.
+ *
BigDecimal.
+ * @throws IllegalArgumentException
+ * if {@code roundingMode} does not represent a valid rounding
+ * mode.
+ * @see BigDecimal
+ */
+ public BigDecimal bigDecimalValue(final int roundingMode) {
+ return new BigDecimal(numerator).divide(new BigDecimal(denominator), roundingMode);
+ }
+
+ /**
+ *
+ * Gets the fraction as a BigDecimal following the passed scale
+ * and rounding mode. This calculates the fraction as the numerator divided
+ * by denominator.
+ *
BigDecimal quotient to be returned.
+ * see {@link BigDecimal} for more information.
+ * @param roundingMode
+ * rounding mode to apply. see {@link BigDecimal} constants.
+ * @return the fraction as a BigDecimal.
+ * @see BigDecimal
+ */
+ public BigDecimal bigDecimalValue(final int scale, final int roundingMode) {
+ return new BigDecimal(numerator).divide(new BigDecimal(denominator), scale, roundingMode);
+ }
+
+ /**
+ * + * Compares this object to another based on size. + *
+ * + * @param object + * the object to compare to, must not benull.
+ * @return -1 if this is less than {@code object}, +1 if this is greater
+ * than {@code object}, 0 if they are equal.
+ * @see java.lang.Comparable#compareTo(java.lang.Object)
+ */
+ public int compareTo(final BigFraction object) {
+ int lhsSigNum = numerator.signum();
+ int rhsSigNum = object.numerator.signum();
+
+ if (lhsSigNum != rhsSigNum) {
+ return (lhsSigNum > rhsSigNum) ? 1 : -1;
+ }
+ if (lhsSigNum == 0) {
+ return 0;
+ }
+
+ BigInteger nOd = numerator.multiply(object.denominator);
+ BigInteger dOn = denominator.multiply(object.numerator);
+ return nOd.compareTo(dOn);
+ }
+
+ /**
+ * + * Divide the value of this fraction by the passed {@code BigInteger}, + * ie {@code this * 1 / bg}, returning the result in reduced form. + *
+ * + * @param bg the {@code BigInteger} to divide by, must not be {@code null} + * @return a {@link BigFraction} instance with the resulting values + * @throws NullArgumentException if the {@code BigInteger} is {@code null} + * @throws MathArithmeticException if the fraction to divide by is zero + */ + public BigFraction divide(final BigInteger bg) { + if (bg == null) { + throw new NullArgumentException(LocalizedFormats.FRACTION); + } + if (bg.signum() == 0) { + throw new MathArithmeticException(LocalizedFormats.ZERO_DENOMINATOR); + } + if (numerator.signum() == 0) { + return ZERO; + } + return new BigFraction(numerator, denominator.multiply(bg)); + } + + /** + *+ * Divide the value of this fraction by the passed {@code int}, ie + * {@code this * 1 / i}, returning the result in reduced form. + *
+ * + * @param i the {@code int} to divide by + * @return a {@link BigFraction} instance with the resulting values + * @throws MathArithmeticException if the fraction to divide by is zero + */ + public BigFraction divide(final int i) { + return divide(BigInteger.valueOf(i)); + } + + /** + *+ * Divide the value of this fraction by the passed {@code long}, ie + * {@code this * 1 / l}, returning the result in reduced form. + *
+ * + * @param l the {@code long} to divide by + * @return a {@link BigFraction} instance with the resulting values + * @throws MathArithmeticException if the fraction to divide by is zero + */ + public BigFraction divide(final long l) { + return divide(BigInteger.valueOf(l)); + } + + /** + *+ * Divide the value of this fraction by another, returning the result in + * reduced form. + *
+ * + * @param fraction Fraction to divide by, must not be {@code null}. + * @return a {@link BigFraction} instance with the resulting values. + * @throws NullArgumentException if the {@code fraction} is {@code null}. + * @throws MathArithmeticException if the fraction to divide by is zero + */ + public BigFraction divide(final BigFraction fraction) { + if (fraction == null) { + throw new NullArgumentException(LocalizedFormats.FRACTION); + } + if (fraction.numerator.signum() == 0) { + throw new MathArithmeticException(LocalizedFormats.ZERO_DENOMINATOR); + } + if (numerator.signum() == 0) { + return ZERO; + } + + return multiply(fraction.reciprocal()); + } + + /** + *+ * Gets the fraction as a {@code double}. This calculates the fraction as + * the numerator divided by denominator. + *
+ * + * @return the fraction as a {@code double} + * @see java.lang.Number#doubleValue() + */ + @Override + public double doubleValue() { + double result = numerator.doubleValue() / denominator.doubleValue(); + if (Double.isNaN(result)) { + // Numerator and/or denominator must be out of range: + // Calculate how far to shift them to put them in range. + int shift = FastMath.max(numerator.bitLength(), + denominator.bitLength()) - FastMath.getExponent(Double.MAX_VALUE); + result = numerator.shiftRight(shift).doubleValue() / + denominator.shiftRight(shift).doubleValue(); + } + return result; + } + + /** + *+ * Test for the equality of two fractions. If the lowest term numerator and + * denominators are the same for both fractions, the two fractions are + * considered to be equal. + *
+ * + * @param other + * fraction to test for equality to this fraction, can be + *null.
+ * @return true if two fractions are equal, false if object is
+ * null, not an instance of {@link BigFraction}, or not
+ * equal to this fraction instance.
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(final Object other) {
+ boolean ret = false;
+
+ if (this == other) {
+ ret = true;
+ } else if (other instanceof BigFraction) {
+ BigFraction rhs = ((BigFraction) other).reduce();
+ BigFraction thisOne = this.reduce();
+ ret = thisOne.numerator.equals(rhs.numerator) && thisOne.denominator.equals(rhs.denominator);
+ }
+
+ return ret;
+ }
+
+ /**
+ * + * Gets the fraction as a {@code float}. This calculates the fraction as + * the numerator divided by denominator. + *
+ * + * @return the fraction as a {@code float}. + * @see java.lang.Number#floatValue() + */ + @Override + public float floatValue() { + float result = numerator.floatValue() / denominator.floatValue(); + if (Double.isNaN(result)) { + // Numerator and/or denominator must be out of range: + // Calculate how far to shift them to put them in range. + int shift = FastMath.max(numerator.bitLength(), + denominator.bitLength()) - FastMath.getExponent(Float.MAX_VALUE); + result = numerator.shiftRight(shift).floatValue() / + denominator.shiftRight(shift).floatValue(); + } + return result; + } + + /** + *
+ * Access the denominator as a BigInteger.
+ *
BigInteger.
+ */
+ public BigInteger getDenominator() {
+ return denominator;
+ }
+
+ /**
+ * + * Access the denominator as a {@code int}. + *
+ * + * @return the denominator as a {@code int}. + */ + public int getDenominatorAsInt() { + return denominator.intValue(); + } + + /** + *+ * Access the denominator as a {@code long}. + *
+ * + * @return the denominator as a {@code long}. + */ + public long getDenominatorAsLong() { + return denominator.longValue(); + } + + /** + *
+ * Access the numerator as a BigInteger.
+ *
BigInteger.
+ */
+ public BigInteger getNumerator() {
+ return numerator;
+ }
+
+ /**
+ * + * Access the numerator as a {@code int}. + *
+ * + * @return the numerator as a {@code int}. + */ + public int getNumeratorAsInt() { + return numerator.intValue(); + } + + /** + *+ * Access the numerator as a {@code long}. + *
+ * + * @return the numerator as a {@code long}. + */ + public long getNumeratorAsLong() { + return numerator.longValue(); + } + + /** + *+ * Gets a hashCode for the fraction. + *
+ * + * @return a hash code value for this object. + * @see java.lang.Object#hashCode() + */ + @Override + public int hashCode() { + return 37 * (37 * 17 + numerator.hashCode()) + denominator.hashCode(); + } + + /** + *+ * Gets the fraction as an {@code int}. This returns the whole number part + * of the fraction. + *
+ * + * @return the whole number fraction part. + * @see java.lang.Number#intValue() + */ + @Override + public int intValue() { + return numerator.divide(denominator).intValue(); + } + + /** + *+ * Gets the fraction as a {@code long}. This returns the whole number part + * of the fraction. + *
+ * + * @return the whole number fraction part. + * @see java.lang.Number#longValue() + */ + @Override + public long longValue() { + return numerator.divide(denominator).longValue(); + } + + /** + *
+ * Multiplies the value of this fraction by the passed
+ * BigInteger, returning the result in reduced form.
+ *
+ * Multiply the value of this fraction by the passed {@code int}, returning + * the result in reduced form. + *
+ * + * @param i + * the {@code int} to multiply by. + * @return a {@link BigFraction} instance with the resulting values. + */ + public BigFraction multiply(final int i) { + if (i == 0 || numerator.signum() == 0) { + return ZERO; + } + + return multiply(BigInteger.valueOf(i)); + } + + /** + *+ * Multiply the value of this fraction by the passed {@code long}, + * returning the result in reduced form. + *
+ * + * @param l + * the {@code long} to multiply by. + * @return a {@link BigFraction} instance with the resulting values. + */ + public BigFraction multiply(final long l) { + if (l == 0 || numerator.signum() == 0) { + return ZERO; + } + + return multiply(BigInteger.valueOf(l)); + } + + /** + *+ * Multiplies the value of this fraction by another, returning the result in + * reduced form. + *
+ * + * @param fraction Fraction to multiply by, must not be {@code null}. + * @return a {@link BigFraction} instance with the resulting values. + * @throws NullArgumentException if {@code fraction} is {@code null}. + */ + public BigFraction multiply(final BigFraction fraction) { + if (fraction == null) { + throw new NullArgumentException(LocalizedFormats.FRACTION); + } + if (numerator.signum() == 0 || + fraction.numerator.signum() == 0) { + return ZERO; + } + return new BigFraction(numerator.multiply(fraction.numerator), + denominator.multiply(fraction.denominator)); + } + + /** + *+ * Return the additive inverse of this fraction, returning the result in + * reduced form. + *
+ * + * @return the negation of this fraction. + */ + public BigFraction negate() { + return new BigFraction(numerator.negate(), denominator); + } + + /** + *+ * Gets the fraction percentage as a {@code double}. This calculates the + * fraction as the numerator divided by denominator multiplied by 100. + *
+ * + * @return the fraction percentage as a {@code double}. + */ + public double percentageValue() { + return multiply(ONE_HUNDRED).doubleValue(); + } + + /** + *+ * Returns a {@code BigFraction} whose value is + * {@code (thisexponent)}, returning the result in reduced form. + *
+ * + * @param exponent + * exponent to which this {@code BigFraction} is to be + * raised. + * @return thisexponent. + */ + public BigFraction pow(final int exponent) { + if (exponent == 0) { + return ONE; + } + if (numerator.signum() == 0) { + return this; + } + + if (exponent < 0) { + return new BigFraction(denominator.pow(-exponent), numerator.pow(-exponent)); + } + return new BigFraction(numerator.pow(exponent), denominator.pow(exponent)); + } + + /** + *
+ * Returns a BigFraction whose value is
+ * (thisexponent), returning the result in reduced form.
+ *
BigFraction is to be raised.
+ * @return thisexponent as a BigFraction.
+ */
+ public BigFraction pow(final long exponent) {
+ if (exponent == 0) {
+ return ONE;
+ }
+ if (numerator.signum() == 0) {
+ return this;
+ }
+
+ if (exponent < 0) {
+ return new BigFraction(ArithmeticUtils.pow(denominator, -exponent),
+ ArithmeticUtils.pow(numerator, -exponent));
+ }
+ return new BigFraction(ArithmeticUtils.pow(numerator, exponent),
+ ArithmeticUtils.pow(denominator, exponent));
+ }
+
+ /**
+ *
+ * Returns a BigFraction whose value is
+ * (thisexponent), returning the result in reduced form.
+ *
BigFraction is to be raised.
+ * @return thisexponent as a BigFraction.
+ */
+ public BigFraction pow(final BigInteger exponent) {
+ if (exponent.signum() == 0) {
+ return ONE;
+ }
+ if (numerator.signum() == 0) {
+ return this;
+ }
+
+ if (exponent.signum() == -1) {
+ final BigInteger eNeg = exponent.negate();
+ return new BigFraction(ArithmeticUtils.pow(denominator, eNeg),
+ ArithmeticUtils.pow(numerator, eNeg));
+ }
+ return new BigFraction(ArithmeticUtils.pow(numerator, exponent),
+ ArithmeticUtils.pow(denominator, exponent));
+ }
+
+ /**
+ *
+ * Returns a double whose value is
+ * (thisexponent), returning the result in reduced form.
+ *
BigFraction is to be raised.
+ * @return thisexponent.
+ */
+ public double pow(final double exponent) {
+ return FastMath.pow(numerator.doubleValue(), exponent) /
+ FastMath.pow(denominator.doubleValue(), exponent);
+ }
+
+ /**
+ * + * Return the multiplicative inverse of this fraction. + *
+ * + * @return the reciprocal fraction. + */ + public BigFraction reciprocal() { + return new BigFraction(denominator, numerator); + } + + /** + *
+ * Reduce this BigFraction to its lowest terms.
+ *
BigFraction. It doesn't change anything if
+ * the fraction can be reduced.
+ */
+ public BigFraction reduce() {
+ final BigInteger gcd = numerator.gcd(denominator);
+
+ if (BigInteger.ONE.compareTo(gcd) < 0) {
+ return new BigFraction(numerator.divide(gcd), denominator.divide(gcd));
+ } else {
+ return this;
+ }
+ }
+
+ /**
+ * + * Subtracts the value of an {@link BigInteger} from the value of this + * {@code BigFraction}, returning the result in reduced form. + *
+ * + * @param bg the {@link BigInteger} to subtract, cannot be {@code null}. + * @return a {@code BigFraction} instance with the resulting values. + * @throws NullArgumentException if the {@link BigInteger} is {@code null}. + */ + public BigFraction subtract(final BigInteger bg) { + if (bg == null) { + throw new NullArgumentException(); + } + if (bg.signum() == 0) { + return this; + } + if (numerator.signum() == 0) { + return new BigFraction(bg.negate()); + } + + return new BigFraction(numerator.subtract(denominator.multiply(bg)), denominator); + } + + /** + *+ * Subtracts the value of an {@code integer} from the value of this + * {@code BigFraction}, returning the result in reduced form. + *
+ * + * @param i the {@code integer} to subtract. + * @return a {@code BigFraction} instance with the resulting values. + */ + public BigFraction subtract(final int i) { + return subtract(BigInteger.valueOf(i)); + } + + /** + *+ * Subtracts the value of a {@code long} from the value of this + * {@code BigFraction}, returning the result in reduced form. + *
+ * + * @param l the {@code long} to subtract. + * @return a {@code BigFraction} instance with the resulting values. + */ + public BigFraction subtract(final long l) { + return subtract(BigInteger.valueOf(l)); + } + + /** + *+ * Subtracts the value of another fraction from the value of this one, + * returning the result in reduced form. + *
+ * + * @param fraction {@link BigFraction} to subtract, must not be {@code null}. + * @return a {@link BigFraction} instance with the resulting values + * @throws NullArgumentException if the {@code fraction} is {@code null}. + */ + public BigFraction subtract(final BigFraction fraction) { + if (fraction == null) { + throw new NullArgumentException(LocalizedFormats.FRACTION); + } + if (fraction.numerator.signum() == 0) { + return this; + } + if (numerator.signum() == 0) { + return fraction.negate(); + } + + BigInteger num = null; + BigInteger den = null; + if (denominator.equals(fraction.denominator)) { + num = numerator.subtract(fraction.numerator); + den = denominator; + } else { + num = (numerator.multiply(fraction.denominator)).subtract((fraction.numerator).multiply(denominator)); + den = denominator.multiply(fraction.denominator); + } + return new BigFraction(num, den); + + } + + /** + *
+ * Returns the String representing this fraction, ie
+ * "num / dem" or just "num" if the denominator is one.
+ *
+ * This class is a singleton. + *
+ * @see Fraction + * @since 2.0 + */ +public class BigFractionField implements FieldWe use here the Initialization On Demand Holder Idiom.
+ */ + private static class LazyHolder { + /** Cached field instance. */ + private static final BigFractionField INSTANCE = new BigFractionField(); + } + // CHECKSTYLE: resume HideUtilityClassConstructor + + /** Handle deserialization of the singleton. + * @return the singleton instance + */ + private Object readResolve() { + // return the singleton instance + return LazyHolder.INSTANCE; + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/BigFractionFormat.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/BigFractionFormat.java new file mode 100644 index 000000000..37c45a97c --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/BigFractionFormat.java @@ -0,0 +1,287 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.fraction; + +import java.io.Serializable; +import java.math.BigInteger; +import java.text.FieldPosition; +import java.text.NumberFormat; +import java.text.ParsePosition; +import java.util.Locale; + +import com.fr.third.org.apache.commons.math3.exception.MathIllegalArgumentException; +import com.fr.third.org.apache.commons.math3.exception.MathParseException; +import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats; + +/** + * Formats a BigFraction number in proper format or improper format. + *+ * The number format for each of the whole number, numerator and, + * denominator can be configured. + *
+ * + * @since 2.0 + */ +public class BigFractionFormat extends AbstractFormat implements Serializable { + + /** Serializable version identifier */ + private static final long serialVersionUID = -2932167925527338976L; + + /** + * Create an improper formatting instance with the default number format + * for the numerator and denominator. + */ + public BigFractionFormat() { + } + + /** + * Create an improper formatting instance with a custom number format for + * both the numerator and denominator. + * @param format the custom format for both the numerator and denominator. + */ + public BigFractionFormat(final NumberFormat format) { + super(format); + } + + /** + * Create an improper formatting instance with a custom number format for + * the numerator and a custom number format for the denominator. + * @param numeratorFormat the custom format for the numerator. + * @param denominatorFormat the custom format for the denominator. + */ + public BigFractionFormat(final NumberFormat numeratorFormat, + final NumberFormat denominatorFormat) { + super(numeratorFormat, denominatorFormat); + } + + /** + * Get the set of locales for which complex formats are available. This + * is the same set as the {@link NumberFormat} set. + * @return available complex format locales. + */ + public static Locale[] getAvailableLocales() { + return NumberFormat.getAvailableLocales(); + } + + /** + * This static method calls formatBigFraction() on a default instance of + * BigFractionFormat. + * + * @param f BigFraction object to format + * @return A formatted BigFraction in proper form. + */ + public static String formatBigFraction(final BigFraction f) { + return getImproperInstance().format(f); + } + + /** + * Returns the default complex format for the current locale. + * @return the default complex format. + */ + public static BigFractionFormat getImproperInstance() { + return getImproperInstance(Locale.getDefault()); + } + + /** + * Returns the default complex format for the given locale. + * @param locale the specific locale used by the format. + * @return the complex format specific to the given locale. + */ + public static BigFractionFormat getImproperInstance(final Locale locale) { + return new BigFractionFormat(getDefaultNumberFormat(locale)); + } + + /** + * Returns the default complex format for the current locale. + * @return the default complex format. + */ + public static BigFractionFormat getProperInstance() { + return getProperInstance(Locale.getDefault()); + } + + /** + * Returns the default complex format for the given locale. + * @param locale the specific locale used by the format. + * @return the complex format specific to the given locale. + */ + public static BigFractionFormat getProperInstance(final Locale locale) { + return new ProperBigFractionFormat(getDefaultNumberFormat(locale)); + } + + /** + * Formats a {@link BigFraction} object to produce a string. The BigFraction is + * output in improper format. + * + * @param BigFraction the object to format. + * @param toAppendTo where the text is to be appended + * @param pos On input: an alignment field, if desired. On output: the + * offsets of the alignment field + * @return the value passed in as toAppendTo. + */ + public StringBuffer format(final BigFraction BigFraction, + final StringBuffer toAppendTo, final FieldPosition pos) { + + pos.setBeginIndex(0); + pos.setEndIndex(0); + + getNumeratorFormat().format(BigFraction.getNumerator(), toAppendTo, pos); + toAppendTo.append(" / "); + getDenominatorFormat().format(BigFraction.getDenominator(), toAppendTo, pos); + + return toAppendTo; + } + + /** + * Formats an object and appends the result to a StringBuffer. + *obj must be either a {@link BigFraction} object or a
+ * {@link BigInteger} object or a {@link Number} object. Any other type of
+ * object will result in an {@link IllegalArgumentException} being thrown.
+ *
+ * @param obj the object to format.
+ * @param toAppendTo where the text is to be appended
+ * @param pos On input: an alignment field, if desired. On output: the
+ * offsets of the alignment field
+ * @return the value passed in as toAppendTo.
+ * @see java.text.Format#format(java.lang.Object, java.lang.StringBuffer, java.text.FieldPosition)
+ * @throws MathIllegalArgumentException if obj is not a valid type.
+ */
+ @Override
+ public StringBuffer format(final Object obj,
+ final StringBuffer toAppendTo, final FieldPosition pos) {
+
+ final StringBuffer ret;
+ if (obj instanceof BigFraction) {
+ ret = format((BigFraction) obj, toAppendTo, pos);
+ } else if (obj instanceof BigInteger) {
+ ret = format(new BigFraction((BigInteger) obj), toAppendTo, pos);
+ } else if (obj instanceof Number) {
+ ret = format(new BigFraction(((Number) obj).doubleValue()),
+ toAppendTo, pos);
+ } else {
+ throw new MathIllegalArgumentException(LocalizedFormats.CANNOT_FORMAT_OBJECT_TO_FRACTION);
+ }
+
+ return ret;
+ }
+
+ /**
+ * Parses a string to produce a {@link BigFraction} object.
+ * @param source the string to parse
+ * @return the parsed {@link BigFraction} object.
+ * @exception MathParseException if the beginning of the specified string
+ * cannot be parsed.
+ */
+ @Override
+ public BigFraction parse(final String source) throws MathParseException {
+ final ParsePosition parsePosition = new ParsePosition(0);
+ final BigFraction result = parse(source, parsePosition);
+ if (parsePosition.getIndex() == 0) {
+ throw new MathParseException(source, parsePosition.getErrorIndex(), BigFraction.class);
+ }
+ return result;
+ }
+
+ /**
+ * Parses a string to produce a {@link BigFraction} object.
+ * This method expects the string to be formatted as an improper BigFraction.
+ * @param source the string to parse
+ * @param pos input/output parsing parameter.
+ * @return the parsed {@link BigFraction} object.
+ */
+ @Override
+ public BigFraction parse(final String source, final ParsePosition pos) {
+ final int initialIndex = pos.getIndex();
+
+ // parse whitespace
+ parseAndIgnoreWhitespace(source, pos);
+
+ // parse numerator
+ final BigInteger num = parseNextBigInteger(source, pos);
+ if (num == null) {
+ // invalid integer number
+ // set index back to initial, error index should already be set
+ // character examined.
+ pos.setIndex(initialIndex);
+ return null;
+ }
+
+ // parse '/'
+ final int startIndex = pos.getIndex();
+ final char c = parseNextCharacter(source, pos);
+ switch (c) {
+ case 0 :
+ // no '/'
+ // return num as a BigFraction
+ return new BigFraction(num);
+ case '/' :
+ // found '/', continue parsing denominator
+ break;
+ default :
+ // invalid '/'
+ // set index back to initial, error index should be the last
+ // character examined.
+ pos.setIndex(initialIndex);
+ pos.setErrorIndex(startIndex);
+ return null;
+ }
+
+ // parse whitespace
+ parseAndIgnoreWhitespace(source, pos);
+
+ // parse denominator
+ final BigInteger den = parseNextBigInteger(source, pos);
+ if (den == null) {
+ // invalid integer number
+ // set index back to initial, error index should already be set
+ // character examined.
+ pos.setIndex(initialIndex);
+ return null;
+ }
+
+ return new BigFraction(num, den);
+ }
+
+ /**
+ * Parses a string to produce a BigInteger.
+ * @param source the string to parse
+ * @param pos input/output parsing parameter.
+ * @return a parsed BigInteger or null if string does not
+ * contain a BigInteger at the specified position
+ */
+ protected BigInteger parseNextBigInteger(final String source,
+ final ParsePosition pos) {
+
+ final int start = pos.getIndex();
+ int end = (source.charAt(start) == '-') ? (start + 1) : start;
+ while((end < source.length()) &&
+ Character.isDigit(source.charAt(end))) {
+ ++end;
+ }
+
+ try {
+ BigInteger n = new BigInteger(source.substring(start, end));
+ pos.setIndex(end);
+ return n;
+ } catch (NumberFormatException nfe) {
+ pos.setErrorIndex(start);
+ return null;
+ }
+
+ }
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/Fraction.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/Fraction.java
new file mode 100644
index 000000000..69ff6f4b6
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/Fraction.java
@@ -0,0 +1,673 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.fraction;
+
+import java.io.Serializable;
+import java.math.BigInteger;
+
+import com.fr.third.org.apache.commons.math3.exception.MathArithmeticException;
+import com.fr.third.org.apache.commons.math3.exception.NullArgumentException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.FieldElement;
+import com.fr.third.org.apache.commons.math3.util.ArithmeticUtils;
+import com.fr.third.org.apache.commons.math3.util.FastMath;
+
+/**
+ * Representation of a rational number.
+ *
+ * implements Serializable since 2.0
+ *
+ * @since 1.1
+ */
+public class Fraction
+ extends Number
+ implements FieldElement+ * References: + *
+ * References: + *
+ * + * NOTE: This constructor is called with EITHER + * - a valid epsilon value and the maxDenominator set to Integer.MAX_VALUE + * (that way the maxDenominator has no effect). + * OR + * - a valid maxDenominator value and the epsilon value set to zero + * (that way epsilon only has effect if there is an exact match before + * the maxDenominator value is reached). + *
+ * + * It has been done this way so that the same code can be (re)used for both + * scenarios. However this could be confusing to users if it were part of + * the public API and this constructor should therefore remain PRIVATE. + *
+ * + * See JIRA issue ticket MATH-181 for more details: + * + * https://issues.apache.org/jira/browse/MATH-181 + * + * @param value the double value to convert to a fraction. + * @param epsilon maximum error allowed. The resulting fraction is within + * {@code epsilon} of {@code value}, in absolute terms. + * @param maxDenominator maximum denominator value allowed. + * @param maxIterations maximum number of convergents + * @throws FractionConversionException if the continued fraction failed to + * converge. + */ + private Fraction(double value, double epsilon, int maxDenominator, int maxIterations) + throws FractionConversionException + { + long overflow = Integer.MAX_VALUE; + double r0 = value; + long a0 = (long)FastMath.floor(r0); + if (FastMath.abs(a0) > overflow) { + throw new FractionConversionException(value, a0, 1l); + } + + // check for (almost) integer arguments, which should not go to iterations. + if (FastMath.abs(a0 - value) < epsilon) { + this.numerator = (int) a0; + this.denominator = 1; + return; + } + + long p0 = 1; + long q0 = 0; + long p1 = a0; + long q1 = 1; + + long p2 = 0; + long q2 = 1; + + int n = 0; + boolean stop = false; + do { + ++n; + double r1 = 1.0 / (r0 - a0); + long a1 = (long)FastMath.floor(r1); + p2 = (a1 * p1) + p0; + q2 = (a1 * q1) + q0; + + if ((FastMath.abs(p2) > overflow) || (FastMath.abs(q2) > overflow)) { + // in maxDenominator mode, if the last fraction was very close to the actual value + // q2 may overflow in the next iteration; in this case return the last one. + if (epsilon == 0.0 && FastMath.abs(q1) < maxDenominator) { + break; + } + throw new FractionConversionException(value, p2, q2); + } + + double convergent = (double)p2 / (double)q2; + if (n < maxIterations && FastMath.abs(convergent - value) > epsilon && q2 < maxDenominator) { + p0 = p1; + p1 = p2; + q0 = q1; + q1 = q2; + a0 = a1; + r0 = r1; + } else { + stop = true; + } + } while (!stop); + + if (n >= maxIterations) { + throw new FractionConversionException(value, maxIterations); + } + + if (q2 < maxDenominator) { + this.numerator = (int) p2; + this.denominator = (int) q2; + } else { + this.numerator = (int) p1; + this.denominator = (int) q1; + } + + } + + /** + * Create a fraction from an int. + * The fraction is num / 1. + * @param num the numerator. + */ + public Fraction(int num) { + this(num, 1); + } + + /** + * Create a fraction given the numerator and denominator. The fraction is + * reduced to lowest terms. + * @param num the numerator. + * @param den the denominator. + * @throws MathArithmeticException if the denominator is {@code zero} + */ + public Fraction(int num, int den) { + if (den == 0) { + throw new MathArithmeticException(LocalizedFormats.ZERO_DENOMINATOR_IN_FRACTION, + num, den); + } + if (den < 0) { + if (num == Integer.MIN_VALUE || + den == Integer.MIN_VALUE) { + throw new MathArithmeticException(LocalizedFormats.OVERFLOW_IN_FRACTION, + num, den); + } + num = -num; + den = -den; + } + // reduce numerator and denominator by greatest common denominator. + final int d = ArithmeticUtils.gcd(num, den); + if (d > 1) { + num /= d; + den /= d; + } + + // move sign to numerator. + if (den < 0) { + num = -num; + den = -den; + } + this.numerator = num; + this.denominator = den; + } + + /** + * Returns the absolute value of this fraction. + * @return the absolute value. + */ + public Fraction abs() { + Fraction ret; + if (numerator >= 0) { + ret = this; + } else { + ret = negate(); + } + return ret; + } + + /** + * Compares this object to another based on size. + * @param object the object to compare to + * @return -1 if this is less than {@code object}, +1 if this is greater + * than {@code object}, 0 if they are equal. + */ + public int compareTo(Fraction object) { + long nOd = ((long) numerator) * object.denominator; + long dOn = ((long) denominator) * object.numerator; + return (nOd < dOn) ? -1 : ((nOd > dOn) ? +1 : 0); + } + + /** + * Gets the fraction as a {@code double}. This calculates the fraction as + * the numerator divided by denominator. + * @return the fraction as a {@code double} + */ + @Override + public double doubleValue() { + return (double)numerator / (double)denominator; + } + + /** + * Test for the equality of two fractions. If the lowest term + * numerator and denominators are the same for both fractions, the two + * fractions are considered to be equal. + * @param other fraction to test for equality to this fraction + * @return true if two fractions are equal, false if object is + * {@code null}, not an instance of {@link Fraction}, or not equal + * to this fraction instance. + */ + @Override + public boolean equals(Object other) { + if (this == other) { + return true; + } + if (other instanceof Fraction) { + // since fractions are always in lowest terms, numerators and + // denominators can be compared directly for equality. + Fraction rhs = (Fraction)other; + return (numerator == rhs.numerator) && + (denominator == rhs.denominator); + } + return false; + } + + /** + * Gets the fraction as a {@code float}. This calculates the fraction as + * the numerator divided by denominator. + * @return the fraction as a {@code float} + */ + @Override + public float floatValue() { + return (float)doubleValue(); + } + + /** + * Access the denominator. + * @return the denominator. + */ + public int getDenominator() { + return denominator; + } + + /** + * Access the numerator. + * @return the numerator. + */ + public int getNumerator() { + return numerator; + } + + /** + * Gets a hashCode for the fraction. + * @return a hash code value for this object + */ + @Override + public int hashCode() { + return 37 * (37 * 17 + numerator) + denominator; + } + + /** + * Gets the fraction as an {@code int}. This returns the whole number part + * of the fraction. + * @return the whole number fraction part + */ + @Override + public int intValue() { + return (int)doubleValue(); + } + + /** + * Gets the fraction as a {@code long}. This returns the whole number part + * of the fraction. + * @return the whole number fraction part + */ + @Override + public long longValue() { + return (long)doubleValue(); + } + + /** + * Return the additive inverse of this fraction. + * @return the negation of this fraction. + */ + public Fraction negate() { + if (numerator==Integer.MIN_VALUE) { + throw new MathArithmeticException(LocalizedFormats.OVERFLOW_IN_FRACTION, numerator, denominator); + } + return new Fraction(-numerator, denominator); + } + + /** + * Return the multiplicative inverse of this fraction. + * @return the reciprocal fraction + */ + public Fraction reciprocal() { + return new Fraction(denominator, numerator); + } + + /** + *Adds the value of this fraction to another, returning the result in reduced form. + * The algorithm follows Knuth, 4.5.1.
+ * + * @param fraction the fraction to add, must not be {@code null} + * @return a {@code Fraction} instance with the resulting values + * @throws NullArgumentException if the fraction is {@code null} + * @throws MathArithmeticException if the resulting numerator or denominator exceeds + * {@code Integer.MAX_VALUE} + */ + public Fraction add(Fraction fraction) { + return addSub(fraction, true /* add */); + } + + /** + * Add an integer to the fraction. + * @param i the {@code integer} to add. + * @return this + i + */ + public Fraction add(final int i) { + return new Fraction(numerator + i * denominator, denominator); + } + + /** + *Subtracts the value of another fraction from the value of this one, + * returning the result in reduced form.
+ * + * @param fraction the fraction to subtract, must not be {@code null} + * @return a {@code Fraction} instance with the resulting values + * @throws NullArgumentException if the fraction is {@code null} + * @throws MathArithmeticException if the resulting numerator or denominator + * cannot be represented in an {@code int}. + */ + public Fraction subtract(Fraction fraction) { + return addSub(fraction, false /* subtract */); + } + + /** + * Subtract an integer from the fraction. + * @param i the {@code integer} to subtract. + * @return this - i + */ + public Fraction subtract(final int i) { + return new Fraction(numerator - i * denominator, denominator); + } + + /** + * Implement add and subtract using algorithm described in Knuth 4.5.1. + * + * @param fraction the fraction to subtract, must not be {@code null} + * @param isAdd true to add, false to subtract + * @return a {@code Fraction} instance with the resulting values + * @throws NullArgumentException if the fraction is {@code null} + * @throws MathArithmeticException if the resulting numerator or denominator + * cannot be represented in an {@code int}. + */ + private Fraction addSub(Fraction fraction, boolean isAdd) { + if (fraction == null) { + throw new NullArgumentException(LocalizedFormats.FRACTION); + } + // zero is identity for addition. + if (numerator == 0) { + return isAdd ? fraction : fraction.negate(); + } + if (fraction.numerator == 0) { + return this; + } + // if denominators are randomly distributed, d1 will be 1 about 61% + // of the time. + int d1 = ArithmeticUtils.gcd(denominator, fraction.denominator); + if (d1==1) { + // result is ( (u*v' +/- u'v) / u'v') + int uvp = ArithmeticUtils.mulAndCheck(numerator, fraction.denominator); + int upv = ArithmeticUtils.mulAndCheck(fraction.numerator, denominator); + return new Fraction + (isAdd ? ArithmeticUtils.addAndCheck(uvp, upv) : + ArithmeticUtils.subAndCheck(uvp, upv), + ArithmeticUtils.mulAndCheck(denominator, fraction.denominator)); + } + // the quantity 't' requires 65 bits of precision; see knuth 4.5.1 + // exercise 7. we're going to use a BigInteger. + // t = u(v'/d1) +/- v(u'/d1) + BigInteger uvp = BigInteger.valueOf(numerator) + .multiply(BigInteger.valueOf(fraction.denominator/d1)); + BigInteger upv = BigInteger.valueOf(fraction.numerator) + .multiply(BigInteger.valueOf(denominator/d1)); + BigInteger t = isAdd ? uvp.add(upv) : uvp.subtract(upv); + // but d2 doesn't need extra precision because + // d2 = gcd(t,d1) = gcd(t mod d1, d1) + int tmodd1 = t.mod(BigInteger.valueOf(d1)).intValue(); + int d2 = (tmodd1==0)?d1:ArithmeticUtils.gcd(tmodd1, d1); + + // result is (t/d2) / (u'/d1)(v'/d2) + BigInteger w = t.divide(BigInteger.valueOf(d2)); + if (w.bitLength() > 31) { + throw new MathArithmeticException(LocalizedFormats.NUMERATOR_OVERFLOW_AFTER_MULTIPLY, + w); + } + return new Fraction (w.intValue(), + ArithmeticUtils.mulAndCheck(denominator/d1, + fraction.denominator/d2)); + } + + /** + *Multiplies the value of this fraction by another, returning the + * result in reduced form.
+ * + * @param fraction the fraction to multiply by, must not be {@code null} + * @return a {@code Fraction} instance with the resulting values + * @throws NullArgumentException if the fraction is {@code null} + * @throws MathArithmeticException if the resulting numerator or denominator exceeds + * {@code Integer.MAX_VALUE} + */ + public Fraction multiply(Fraction fraction) { + if (fraction == null) { + throw new NullArgumentException(LocalizedFormats.FRACTION); + } + if (numerator == 0 || fraction.numerator == 0) { + return ZERO; + } + // knuth 4.5.1 + // make sure we don't overflow unless the result *must* overflow. + int d1 = ArithmeticUtils.gcd(numerator, fraction.denominator); + int d2 = ArithmeticUtils.gcd(fraction.numerator, denominator); + return getReducedFraction + (ArithmeticUtils.mulAndCheck(numerator/d1, fraction.numerator/d2), + ArithmeticUtils.mulAndCheck(denominator/d2, fraction.denominator/d1)); + } + + /** + * Multiply the fraction by an integer. + * @param i the {@code integer} to multiply by. + * @return this * i + */ + public Fraction multiply(final int i) { + return multiply(new Fraction(i)); + } + + /** + *Divide the value of this fraction by another.
+ * + * @param fraction the fraction to divide by, must not be {@code null} + * @return a {@code Fraction} instance with the resulting values + * @throws IllegalArgumentException if the fraction is {@code null} + * @throws MathArithmeticException if the fraction to divide by is zero + * @throws MathArithmeticException if the resulting numerator or denominator exceeds + * {@code Integer.MAX_VALUE} + */ + public Fraction divide(Fraction fraction) { + if (fraction == null) { + throw new NullArgumentException(LocalizedFormats.FRACTION); + } + if (fraction.numerator == 0) { + throw new MathArithmeticException(LocalizedFormats.ZERO_FRACTION_TO_DIVIDE_BY, + fraction.numerator, fraction.denominator); + } + return multiply(fraction.reciprocal()); + } + + /** + * Divide the fraction by an integer. + * @param i the {@code integer} to divide by. + * @return this * i + */ + public Fraction divide(final int i) { + return divide(new Fraction(i)); + } + + /** + *+ * Gets the fraction percentage as a {@code double}. This calculates the + * fraction as the numerator divided by denominator multiplied by 100. + *
+ * + * @return the fraction percentage as a {@code double}. + */ + public double percentageValue() { + return 100 * doubleValue(); + } + + /** + *Creates a {@code Fraction} instance with the 2 parts + * of a fraction Y/Z.
+ * + *Any negative signs are resolved to be on the numerator.
+ * + * @param numerator the numerator, for example the three in 'three sevenths' + * @param denominator the denominator, for example the seven in 'three sevenths' + * @return a new fraction instance, with the numerator and denominator reduced + * @throws MathArithmeticException if the denominator is {@code zero} + */ + public static Fraction getReducedFraction(int numerator, int denominator) { + if (denominator == 0) { + throw new MathArithmeticException(LocalizedFormats.ZERO_DENOMINATOR_IN_FRACTION, + numerator, denominator); + } + if (numerator==0) { + return ZERO; // normalize zero. + } + // allow 2^k/-2^31 as a valid fraction (where k>0) + if (denominator==Integer.MIN_VALUE && (numerator&1)==0) { + numerator/=2; denominator/=2; + } + if (denominator < 0) { + if (numerator==Integer.MIN_VALUE || + denominator==Integer.MIN_VALUE) { + throw new MathArithmeticException(LocalizedFormats.OVERFLOW_IN_FRACTION, + numerator, denominator); + } + numerator = -numerator; + denominator = -denominator; + } + // simplify fraction. + int gcd = ArithmeticUtils.gcd(numerator, denominator); + numerator /= gcd; + denominator /= gcd; + return new Fraction(numerator, denominator); + } + + /** + *+ * Returns the {@code String} representing this fraction, ie + * "num / dem" or just "num" if the denominator is one. + *
+ * + * @return a string representation of the fraction. + * @see java.lang.Object#toString() + */ + @Override + public String toString() { + String str = null; + if (denominator == 1) { + str = Integer.toString(numerator); + } else if (numerator == 0) { + str = "0"; + } else { + str = numerator + " / " + denominator; + } + return str; + } + + /** {@inheritDoc} */ + public FractionField getField() { + return FractionField.getInstance(); + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/FractionConversionException.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/FractionConversionException.java new file mode 100644 index 000000000..6ea3e6b00 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/FractionConversionException.java @@ -0,0 +1,55 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.fraction; + +import com.fr.third.org.apache.commons.math3.exception.ConvergenceException; +import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats; + +/** + * Error thrown when a double value cannot be converted to a fraction + * in the allowed number of iterations. + * + * @since 1.2 + */ +public class FractionConversionException extends ConvergenceException { + + /** Serializable version identifier. */ + private static final long serialVersionUID = -4661812640132576263L; + + /** + * Constructs an exception with specified formatted detail message. + * Message formatting is delegated to {@link java.text.MessageFormat}. + * @param value double value to convert + * @param maxIterations maximal number of iterations allowed + */ + public FractionConversionException(double value, int maxIterations) { + super(LocalizedFormats.FAILED_FRACTION_CONVERSION, value, maxIterations); + } + + /** + * Constructs an exception with specified formatted detail message. + * Message formatting is delegated to {@link java.text.MessageFormat}. + * @param value double value to convert + * @param p current numerator + * @param q current denominator + */ + public FractionConversionException(double value, long p, long q) { + super(LocalizedFormats.FRACTION_CONVERSION_OVERFLOW, value, p, q); + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/FractionField.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/FractionField.java new file mode 100644 index 000000000..0037e07a5 --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/FractionField.java @@ -0,0 +1,82 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.fraction; + +import java.io.Serializable; + +import com.fr.third.org.apache.commons.math3.Field; +import com.fr.third.org.apache.commons.math3.FieldElement; + +/** + * Representation of the fractional numbers field. + *+ * This class is a singleton. + *
+ * @see Fraction + * @since 2.0 + */ +public class FractionField implements FieldWe use here the Initialization On Demand Holder Idiom.
+ */ + private static class LazyHolder { + /** Cached field instance. */ + private static final FractionField INSTANCE = new FractionField(); + } + // CHECKSTYLE: resume HideUtilityClassConstructor + + /** Handle deserialization of the singleton. + * @return the singleton instance + */ + private Object readResolve() { + // return the singleton instance + return LazyHolder.INSTANCE; + } + +} diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/FractionFormat.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/FractionFormat.java new file mode 100644 index 000000000..a0ea1d15b --- /dev/null +++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/FractionFormat.java @@ -0,0 +1,264 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.fr.third.org.apache.commons.math3.fraction; + +import java.text.FieldPosition; +import java.text.NumberFormat; +import java.text.ParsePosition; +import java.util.Locale; + +import com.fr.third.org.apache.commons.math3.exception.MathIllegalArgumentException; +import com.fr.third.org.apache.commons.math3.exception.MathParseException; +import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats; + +/** + * Formats a Fraction number in proper format or improper format. The number + * format for each of the whole number, numerator and, denominator can be + * configured. + * + * @since 1.1 + */ +public class FractionFormat extends AbstractFormat { + + /** Serializable version identifier */ + private static final long serialVersionUID = 3008655719530972611L; + + /** + * Create an improper formatting instance with the default number format + * for the numerator and denominator. + */ + public FractionFormat() { + } + + /** + * Create an improper formatting instance with a custom number format for + * both the numerator and denominator. + * @param format the custom format for both the numerator and denominator. + */ + public FractionFormat(final NumberFormat format) { + super(format); + } + + /** + * Create an improper formatting instance with a custom number format for + * the numerator and a custom number format for the denominator. + * @param numeratorFormat the custom format for the numerator. + * @param denominatorFormat the custom format for the denominator. + */ + public FractionFormat(final NumberFormat numeratorFormat, + final NumberFormat denominatorFormat) { + super(numeratorFormat, denominatorFormat); + } + + /** + * Get the set of locales for which complex formats are available. This + * is the same set as the {@link NumberFormat} set. + * @return available complex format locales. + */ + public static Locale[] getAvailableLocales() { + return NumberFormat.getAvailableLocales(); + } + + /** + * This static method calls formatFraction() on a default instance of + * FractionFormat. + * + * @param f Fraction object to format + * @return a formatted fraction in proper form. + */ + public static String formatFraction(Fraction f) { + return getImproperInstance().format(f); + } + + /** + * Returns the default complex format for the current locale. + * @return the default complex format. + */ + public static FractionFormat getImproperInstance() { + return getImproperInstance(Locale.getDefault()); + } + + /** + * Returns the default complex format for the given locale. + * @param locale the specific locale used by the format. + * @return the complex format specific to the given locale. + */ + public static FractionFormat getImproperInstance(final Locale locale) { + return new FractionFormat(getDefaultNumberFormat(locale)); + } + + /** + * Returns the default complex format for the current locale. + * @return the default complex format. + */ + public static FractionFormat getProperInstance() { + return getProperInstance(Locale.getDefault()); + } + + /** + * Returns the default complex format for the given locale. + * @param locale the specific locale used by the format. + * @return the complex format specific to the given locale. + */ + public static FractionFormat getProperInstance(final Locale locale) { + return new ProperFractionFormat(getDefaultNumberFormat(locale)); + } + + /** + * Create a default number format. The default number format is based on + * {@link NumberFormat#getNumberInstance(java.util.Locale)} with the only + * customizing is the maximum number of fraction digits, which is set to 0. + * @return the default number format. + */ + protected static NumberFormat getDefaultNumberFormat() { + return getDefaultNumberFormat(Locale.getDefault()); + } + + /** + * Formats a {@link Fraction} object to produce a string. The fraction is + * output in improper format. + * + * @param fraction the object to format. + * @param toAppendTo where the text is to be appended + * @param pos On input: an alignment field, if desired. On output: the + * offsets of the alignment field + * @return the value passed in as toAppendTo. + */ + public StringBuffer format(final Fraction fraction, + final StringBuffer toAppendTo, final FieldPosition pos) { + + pos.setBeginIndex(0); + pos.setEndIndex(0); + + getNumeratorFormat().format(fraction.getNumerator(), toAppendTo, pos); + toAppendTo.append(" / "); + getDenominatorFormat().format(fraction.getDenominator(), toAppendTo, + pos); + + return toAppendTo; + } + + /** + * Formats an object and appends the result to a StringBuffer.obj must be either a
+ * {@link Fraction} object or a {@link Number} object. Any other type of
+ * object will result in an {@link IllegalArgumentException} being thrown.
+ *
+ * @param obj the object to format.
+ * @param toAppendTo where the text is to be appended
+ * @param pos On input: an alignment field, if desired. On output: the
+ * offsets of the alignment field
+ * @return the value passed in as toAppendTo.
+ * @see java.text.Format#format(java.lang.Object, java.lang.StringBuffer, java.text.FieldPosition)
+ * @throws FractionConversionException if the number cannot be converted to a fraction
+ * @throws MathIllegalArgumentException if obj is not a valid type.
+ */
+ @Override
+ public StringBuffer format(final Object obj,
+ final StringBuffer toAppendTo, final FieldPosition pos)
+ throws FractionConversionException, MathIllegalArgumentException {
+ StringBuffer ret = null;
+
+ if (obj instanceof Fraction) {
+ ret = format((Fraction) obj, toAppendTo, pos);
+ } else if (obj instanceof Number) {
+ ret = format(new Fraction(((Number) obj).doubleValue()), toAppendTo, pos);
+ } else {
+ throw new MathIllegalArgumentException(LocalizedFormats.CANNOT_FORMAT_OBJECT_TO_FRACTION);
+ }
+
+ return ret;
+ }
+
+ /**
+ * Parses a string to produce a {@link Fraction} object.
+ * @param source the string to parse
+ * @return the parsed {@link Fraction} object.
+ * @exception MathParseException if the beginning of the specified string
+ * cannot be parsed.
+ */
+ @Override
+ public Fraction parse(final String source) throws MathParseException {
+ final ParsePosition parsePosition = new ParsePosition(0);
+ final Fraction result = parse(source, parsePosition);
+ if (parsePosition.getIndex() == 0) {
+ throw new MathParseException(source, parsePosition.getErrorIndex(), Fraction.class);
+ }
+ return result;
+ }
+
+ /**
+ * Parses a string to produce a {@link Fraction} object. This method
+ * expects the string to be formatted as an improper fraction.
+ * @param source the string to parse
+ * @param pos input/output parsing parameter.
+ * @return the parsed {@link Fraction} object.
+ */
+ @Override
+ public Fraction parse(final String source, final ParsePosition pos) {
+ final int initialIndex = pos.getIndex();
+
+ // parse whitespace
+ parseAndIgnoreWhitespace(source, pos);
+
+ // parse numerator
+ final Number num = getNumeratorFormat().parse(source, pos);
+ if (num == null) {
+ // invalid integer number
+ // set index back to initial, error index should already be set
+ // character examined.
+ pos.setIndex(initialIndex);
+ return null;
+ }
+
+ // parse '/'
+ final int startIndex = pos.getIndex();
+ final char c = parseNextCharacter(source, pos);
+ switch (c) {
+ case 0 :
+ // no '/'
+ // return num as a fraction
+ return new Fraction(num.intValue(), 1);
+ case '/' :
+ // found '/', continue parsing denominator
+ break;
+ default :
+ // invalid '/'
+ // set index back to initial, error index should be the last
+ // character examined.
+ pos.setIndex(initialIndex);
+ pos.setErrorIndex(startIndex);
+ return null;
+ }
+
+ // parse whitespace
+ parseAndIgnoreWhitespace(source, pos);
+
+ // parse denominator
+ final Number den = getDenominatorFormat().parse(source, pos);
+ if (den == null) {
+ // invalid integer number
+ // set index back to initial, error index should already be set
+ // character examined.
+ pos.setIndex(initialIndex);
+ return null;
+ }
+
+ return new Fraction(num.intValue(), den.intValue());
+ }
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/ProperBigFractionFormat.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/ProperBigFractionFormat.java
new file mode 100644
index 000000000..80ce28ef5
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/fraction/ProperBigFractionFormat.java
@@ -0,0 +1,238 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.fraction;
+
+import java.math.BigInteger;
+import java.text.FieldPosition;
+import java.text.NumberFormat;
+import java.text.ParsePosition;
+
+import com.fr.third.org.apache.commons.math3.exception.NullArgumentException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+
+/**
+ * Formats a BigFraction number in proper format. The number format for each of
+ * the whole number, numerator and, denominator can be configured.
+ *
+ * Minus signs are only allowed in the whole number part - i.e.,
+ * "-3 1/2" is legitimate and denotes -7/2, but "-3 -1/2" is invalid and
+ * will result in a ParseException.
+ * Minus signs are only allowed in the whole number part - i.e.,
+ * "-3 1/2" is legitimate and denotes -7/2, but "-3 -1/2" is invalid and
+ * will result in a ParseException.
+ * Minus signs are only allowed in the whole number part - i.e.,
+ * "-3 1/2" is legitimate and denotes -7/2, but "-3 -1/2" is invalid and
+ * will result in a ParseException.
+ * Minus signs are only allowed in the whole number part - i.e.,
+ * "-3 1/2" is legitimate and denotes -7/2, but "-3 -1/2" is invalid and
+ * will result in a ParseException.
representation can not represent a valid chromosome
+ */
+ public AbstractListChromosome(final Listrepresentation can not represent a valid chromosome
+ */
+ public AbstractListChromosome(final T[] representation) throws InvalidRepresentationException {
+ this(Arrays.asList(representation));
+ }
+
+ /**
+ * Constructor.
+ * @param representation inner representation of the chromosome
+ * @param copyList if {@code true}, the representation will be copied, otherwise it will be referenced.
+ * @since 3.3
+ */
+ public AbstractListChromosome(final Listrepresentation can represent a valid chromosome.
+ *
+ * @param chromosomeRepresentation representation of the chromosome
+ * @throws InvalidRepresentationException iff the representation can not represent a valid chromosome
+ */
+ protected abstract void checkValidity(Listthis is, with a given arrayRepresentation.
+ * This is needed in crossover and mutation operators, where we need a new instance of the same class, but with
+ * different array representation.
+ *
+ * Usually, this method just calls a constructor of the class.
+ *
+ * @param chromosomeRepresentation the inner array representation of the new chromosome.
+ * @return new instance extended from FixedLengthChromosome with the given arrayRepresentation
+ */
+ public abstract AbstractListChromosome
+ * The chromosomes are IMMUTABLE, and so their fitness is also immutable and
+ * therefore it can be cached.
+ *
+ * @since 2.0
+ */
+public abstract class Chromosome implements Comparable
+ * Computation of fitness is usually very time-consuming task, therefore the fitness is cached.
+ *
+ * @return the fitness
+ */
+ public double getFitness() {
+ if (this.fitness == NO_FITNESS) {
+ // no cache - compute the fitness
+ this.fitness = fitness();
+ }
+ return this.fitness;
+ }
+
+ /**
+ * Compares two chromosomes based on their fitness. The bigger the fitness, the better the chromosome.
+ *
+ * @param another another chromosome to compare
+ * @return
+ *
+ * To form a cycle the following procedure is applied:
+ *
+ * The first time {@link #isSatisfied(Population)} is invoked, the end time of the evolution is determined based on the
+ * provided
+ *
+ * Note: the chromosomes of the specified list are added to the population.
+ *
+ * @param chromosomes list of chromosomes to be added to the population
+ * @param populationLimit maximal size of the population
+ * @throws NullArgumentException if the list of chromosomes is {@code null}
+ * @throws NotPositiveException if the population limit is not a positive number (< 1)
+ * @throws NumberIsTooLargeException if the list of chromosomes exceeds the population limit
+ */
+ public ListPopulation(final List
+ * Note: this method removes all existing chromosomes in the population and adds all chromosomes
+ * of the specified list to the population.
+ *
+ * @param chromosomes the list of chromosomes
+ * @throws NullArgumentException if the list of chromosomes is {@code null}
+ * @throws NumberIsTooLargeException if the list of chromosomes exceeds the population limit
+ * @deprecated use {@link #addChromosomes(Collection)} instead
+ */
+ @Deprecated
+ public void setChromosomes(final List Any call to {@link Iterator#remove()} will result in a {@link UnsupportedOperationException}.
+ * Note: the number of crossover points must be <
+ * This policy works by applying the following rules:
+ *
+ * Example (random sublist from index 3 to 7, underlined):
+ *
+ * This policy works only on {@link AbstractListChromosome}, and therefore it
+ * is parameterized by T. Moreover, the chromosomes must have same lengths.
+ *
+ * @see
+ * Order 1 Crossover Operator
+ *
+ * @param representation can not represent a valid chromosome
+ */
+ public BinaryChromosome(Listrepresentation can not represent a valid chromosome
+ */
+ public BinaryChromosome(Integer[] representation) throws InvalidRepresentationException {
+ super(representation);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ protected void checkValidity(Listlength.
+ * @param length length of the array
+ * @return a random binary array of length length
+ */
+ public static List
+ *
+ */
+ public int compareTo(final Chromosome another) {
+ return Double.compare(getFitness(), another.getFitness());
+ }
+
+ /**
+ * Returns another is better than thisanother is worse than thistrue iff another has the same representation and therefore the same fitness. By
+ * default, it returns false -- override it in your implementation if you need it.
+ *
+ * @param another chromosome to compare
+ * @return true if another is equivalent to this chromosome
+ */
+ protected boolean isSame(final Chromosome another) {
+ return false;
+ }
+
+ /**
+ * Searches the population for another chromosome with the same representation. If such chromosome is
+ * found, it is returned, if no such chromosome exists, returns null.
+ *
+ * @param population Population to search
+ * @return Chromosome with the same representation, or null if no such chromosome exists.
+ */
+ protected Chromosome findSameChromosome(final Population population) {
+ for (Chromosome anotherChr : population) {
+ if (this.isSame(anotherChr)) {
+ return anotherChr;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Searches the population for a chromosome representing the same solution, and if it finds one,
+ * updates the fitness to its value.
+ *
+ * @param population Population to search
+ */
+ public void searchForFitnessUpdate(final Population population) {
+ Chromosome sameChromosome = findSameChromosome(population);
+ if (sameChromosome != null) {
+ fitness = sameChromosome.getFitness();
+ }
+ }
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/ChromosomePair.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/ChromosomePair.java
new file mode 100644
index 000000000..ec244bdba
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/ChromosomePair.java
@@ -0,0 +1,66 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.genetics;
+
+/**
+ * A pair of {@link Chromosome} objects.
+ * @since 2.0
+ *
+ */
+public class ChromosomePair {
+ /** the first chromosome in the pair. */
+ private final Chromosome first;
+
+ /** the second chromosome in the pair. */
+ private final Chromosome second;
+
+ /**
+ * Create a chromosome pair.
+ *
+ * @param c1 the first chromosome.
+ * @param c2 the second chromosome.
+ */
+ public ChromosomePair(final Chromosome c1, final Chromosome c2) {
+ super();
+ first = c1;
+ second = c2;
+ }
+
+ /**
+ * Access the first chromosome.
+ *
+ * @return the first chromosome.
+ */
+ public Chromosome getFirst() {
+ return first;
+ }
+
+ /**
+ * Access the second chromosome.
+ *
+ * @return the second chromosome.
+ */
+ public Chromosome getSecond() {
+ return second;
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ public String toString() {
+ return String.format("(%s,%s)", getFirst(), getSecond());
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/CrossoverPolicy.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/CrossoverPolicy.java
new file mode 100644
index 000000000..1bdddc4cd
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/CrossoverPolicy.java
@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.genetics;
+
+import com.fr.third.org.apache.commons.math3.exception.MathIllegalArgumentException;
+
+/**
+ * Policy used to create a pair of new chromosomes by performing a crossover
+ * operation on a source pair of chromosomes.
+ *
+ * @since 2.0
+ */
+public interface CrossoverPolicy {
+
+ /**
+ * Perform a crossover operation on the given chromosomes.
+ *
+ * @param first the first chromosome.
+ * @param second the second chromosome.
+ * @return the pair of new chromosomes that resulted from the crossover.
+ * @throws MathIllegalArgumentException if the given chromosomes are not compatible with this {@link CrossoverPolicy}
+ */
+ ChromosomePair crossover(Chromosome first, Chromosome second) throws MathIllegalArgumentException;
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/CycleCrossover.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/CycleCrossover.java
new file mode 100644
index 000000000..d2662bdf5
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/CycleCrossover.java
@@ -0,0 +1,182 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.genetics;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import com.fr.third.org.apache.commons.math3.exception.DimensionMismatchException;
+import com.fr.third.org.apache.commons.math3.exception.MathIllegalArgumentException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+
+/**
+ * Cycle Crossover [CX] builds offspring from ordered chromosomes by identifying cycles
+ * between two parent chromosomes. To form the children, the cycles are copied from the
+ * respective parents.
+ *
+ *
+ * The indices that form a cycle are then used to form the children in alternating order, i.e.
+ * in cycle 1, the genes of parent 1 are copied to child 1, while in cycle 2 the genes of parent 1
+ * are copied to child 2, and so forth ...
+ *
+ * p1 = (8 4 7 3 6 2 5 1 9 0) X c1 = (8 1 2 3 4 5 6 7 9 0)
+ * p2 = (0 1 2 3 4 5 6 7 8 9) X c2 = (0 4 7 3 6 2 5 1 8 9)
+ *
+ * cycle 1: 8 0 9
+ * cycle 2: 4 1 7 2 5 6
+ * cycle 3: 3
+ *
+ *
+ * This policy works only on {@link AbstractListChromosome}, and therefore it
+ * is parameterized by T. Moreover, the chromosomes must have same lengths.
+ *
+ * @see
+ * Cycle Crossover Operator
+ *
+ * @param {@link #elitismRate}
+ * percents of the best chromosomes are directly copied to the next generation.
+ *
+ * @return the beginnings of the next generation.
+ */
+ public Population nextGeneration() {
+ // initialize a new generation with the same parameters
+ ElitisticListPopulation nextGeneration =
+ new ElitisticListPopulation(getPopulationLimit(), getElitismRate());
+
+ final ListmaxTime value. Once the elapsed time reaches the configured maxTime value,
+ * {@link #isSatisfied(Population)} returns true.
+ *
+ * @since 3.1
+ */
+public class FixedElapsedTime implements StoppingCondition {
+ /** Maximum allowed time period (in nanoseconds). */
+ private final long maxTimePeriod;
+
+ /** The predetermined termination time (stopping condition). */
+ private long endTime = -1;
+
+ /**
+ * Create a new {@link FixedElapsedTime} instance.
+ *
+ * @param maxTime maximum number of seconds generations are allowed to evolve
+ * @throws NumberIsTooSmallException if the provided time is < 0
+ */
+ public FixedElapsedTime(final long maxTime) throws NumberIsTooSmallException {
+ this(maxTime, TimeUnit.SECONDS);
+ }
+
+ /**
+ * Create a new {@link FixedElapsedTime} instance.
+ *
+ * @param maxTime maximum time generations are allowed to evolve
+ * @param unit {@link TimeUnit} of the maxTime argument
+ * @throws NumberIsTooSmallException if the provided time is < 0
+ */
+ public FixedElapsedTime(final long maxTime, final TimeUnit unit) throws NumberIsTooSmallException {
+ if (maxTime < 0) {
+ throw new NumberIsTooSmallException(maxTime, 0, true);
+ }
+ maxTimePeriod = unit.toNanos(maxTime);
+ }
+
+ /**
+ * Determine whether or not the maximum allowed time has passed.
+ * The termination time is determined after the first generation.
+ *
+ * @param population ignored (no impact on result)
+ * @return true IFF the maximum allowed time period has elapsed
+ */
+ public boolean isSatisfied(final Population population) {
+ if (endTime < 0) {
+ endTime = System.nanoTime() + maxTimePeriod;
+ }
+
+ return System.nanoTime() >= endTime;
+ }
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/FixedGenerationCount.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/FixedGenerationCount.java
new file mode 100644
index 000000000..dddb44ffe
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/FixedGenerationCount.java
@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.genetics;
+
+import com.fr.third.org.apache.commons.math3.exception.NumberIsTooSmallException;
+
+/**
+ * Stops after a fixed number of generations. Each time {@link #isSatisfied(Population)} is invoked, a generation
+ * counter is incremented. Once the counter reaches the configured maxGenerations value,
+ * {@link #isSatisfied(Population)} returns true.
+ *
+ * @since 2.0
+ */
+public class FixedGenerationCount implements StoppingCondition {
+ /** Number of generations that have passed */
+ private int numGenerations = 0;
+
+ /** Maximum number of generations (stopping criteria) */
+ private final int maxGenerations;
+
+ /**
+ * Create a new FixedGenerationCount instance.
+ *
+ * @param maxGenerations number of generations to evolve
+ * @throws NumberIsTooSmallException if the number of generations is < 1
+ */
+ public FixedGenerationCount(final int maxGenerations) throws NumberIsTooSmallException {
+ if (maxGenerations <= 0) {
+ throw new NumberIsTooSmallException(maxGenerations, 1, true);
+ }
+ this.maxGenerations = maxGenerations;
+ }
+
+ /**
+ * Determine whether or not the given number of generations have passed. Increments the number of generations
+ * counter if the maximum has not been reached.
+ *
+ * @param population ignored (no impact on result)
+ * @return true IFF the maximum number of generations has been exceeded
+ */
+ public boolean isSatisfied(final Population population) {
+ if (this.numGenerations < this.maxGenerations) {
+ numGenerations++;
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Returns the number of generations that have already passed.
+ * @return the number of generations that have passed
+ */
+ public int getNumGenerations() {
+ return numGenerations;
+ }
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/GeneticAlgorithm.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/GeneticAlgorithm.java
new file mode 100644
index 000000000..f3e66fa48
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/GeneticAlgorithm.java
@@ -0,0 +1,233 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.genetics;
+
+import com.fr.third.org.apache.commons.math3.exception.OutOfRangeException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+import com.fr.third.org.apache.commons.math3.random.RandomGenerator;
+import com.fr.third.org.apache.commons.math3.random.JDKRandomGenerator;
+
+/**
+ * Implementation of a genetic algorithm. All factors that govern the operation
+ * of the algorithm can be configured for a specific problem.
+ *
+ * @since 2.0
+ */
+public class GeneticAlgorithm {
+
+ /**
+ * Static random number generator shared by GA implementation classes. Set the randomGenerator seed to get
+ * reproducible results. Use {@link #setRandomGenerator(RandomGenerator)} to supply an alternative to the default
+ * JDK-provided PRNG.
+ */
+ //@GuardedBy("this")
+ private static RandomGenerator randomGenerator = new JDKRandomGenerator();
+
+ /** the crossover policy used by the algorithm. */
+ private final CrossoverPolicy crossoverPolicy;
+
+ /** the rate of crossover for the algorithm. */
+ private final double crossoverRate;
+
+ /** the mutation policy used by the algorithm. */
+ private final MutationPolicy mutationPolicy;
+
+ /** the rate of mutation for the algorithm. */
+ private final double mutationRate;
+
+ /** the selection policy used by the algorithm. */
+ private final SelectionPolicy selectionPolicy;
+
+ /** the number of generations evolved to reach {@link StoppingCondition} in the last run. */
+ private int generationsEvolved = 0;
+
+ /**
+ * Create a new genetic algorithm.
+ * @param crossoverPolicy The {@link CrossoverPolicy}
+ * @param crossoverRate The crossover rate as a percentage (0-1 inclusive)
+ * @param mutationPolicy The {@link MutationPolicy}
+ * @param mutationRate The mutation rate as a percentage (0-1 inclusive)
+ * @param selectionPolicy The {@link SelectionPolicy}
+ * @throws OutOfRangeException if the crossover or mutation rate is outside the [0, 1] range
+ */
+ public GeneticAlgorithm(final CrossoverPolicy crossoverPolicy,
+ final double crossoverRate,
+ final MutationPolicy mutationPolicy,
+ final double mutationRate,
+ final SelectionPolicy selectionPolicy) throws OutOfRangeException {
+
+ if (crossoverRate < 0 || crossoverRate > 1) {
+ throw new OutOfRangeException(LocalizedFormats.CROSSOVER_RATE,
+ crossoverRate, 0, 1);
+ }
+ if (mutationRate < 0 || mutationRate > 1) {
+ throw new OutOfRangeException(LocalizedFormats.MUTATION_RATE,
+ mutationRate, 0, 1);
+ }
+ this.crossoverPolicy = crossoverPolicy;
+ this.crossoverRate = crossoverRate;
+ this.mutationPolicy = mutationPolicy;
+ this.mutationRate = mutationRate;
+ this.selectionPolicy = selectionPolicy;
+ }
+
+ /**
+ * Set the (static) random generator.
+ *
+ * @param random random generator
+ */
+ public static synchronized void setRandomGenerator(final RandomGenerator random) {
+ randomGenerator = random;
+ }
+
+ /**
+ * Returns the (static) random generator.
+ *
+ * @return the static random generator shared by GA implementation classes
+ */
+ public static synchronized RandomGenerator getRandomGenerator() {
+ return randomGenerator;
+ }
+
+ /**
+ * Evolve the given population. Evolution stops when the stopping condition
+ * is satisfied. Updates the {@link #getGenerationsEvolved() generationsEvolved}
+ * property with the number of generations evolved before the StoppingCondition
+ * is satisfied.
+ *
+ * @param initial the initial, seed population.
+ * @param condition the stopping condition used to stop evolution.
+ * @return the population that satisfies the stopping condition.
+ */
+ public Population evolve(final Population initial, final StoppingCondition condition) {
+ Population current = initial;
+ generationsEvolved = 0;
+ while (!condition.isSatisfied(current)) {
+ current = nextGeneration(current);
+ generationsEvolved++;
+ }
+ return current;
+ }
+
+ /**
+ * Evolve the given population into the next generation.
+ *
+ *
+ *
+ * @param current the current population.
+ * @return the population for the next generation.
+ */
+ public Population nextGeneration(final Population current) {
+ Population nextGeneration = current.nextGeneration();
+
+ RandomGenerator randGen = getRandomGenerator();
+
+ while (nextGeneration.getPopulationSize() < nextGeneration.getPopulationLimit()) {
+ // select parent chromosomes
+ ChromosomePair pair = getSelectionPolicy().select(current);
+
+ // crossover?
+ if (randGen.nextDouble() < getCrossoverRate()) {
+ // apply crossover policy to create two offspring
+ pair = getCrossoverPolicy().crossover(pair.getFirst(), pair.getSecond());
+ }
+
+ // mutation?
+ if (randGen.nextDouble() < getMutationRate()) {
+ // apply mutation policy to the chromosomes
+ pair = new ChromosomePair(
+ getMutationPolicy().mutate(pair.getFirst()),
+ getMutationPolicy().mutate(pair.getSecond()));
+ }
+
+ // add the first chromosome to the population
+ nextGeneration.addChromosome(pair.getFirst());
+ // is there still a place for the second chromosome?
+ if (nextGeneration.getPopulationSize() < nextGeneration.getPopulationLimit()) {
+ // add the second chromosome to the population
+ nextGeneration.addChromosome(pair.getSecond());
+ }
+ }
+
+ return nextGeneration;
+ }
+
+ /**
+ * Returns the crossover policy.
+ * @return crossover policy
+ */
+ public CrossoverPolicy getCrossoverPolicy() {
+ return crossoverPolicy;
+ }
+
+ /**
+ * Returns the crossover rate.
+ * @return crossover rate
+ */
+ public double getCrossoverRate() {
+ return crossoverRate;
+ }
+
+ /**
+ * Returns the mutation policy.
+ * @return mutation policy
+ */
+ public MutationPolicy getMutationPolicy() {
+ return mutationPolicy;
+ }
+
+ /**
+ * Returns the mutation rate.
+ * @return mutation rate
+ */
+ public double getMutationRate() {
+ return mutationRate;
+ }
+
+ /**
+ * Returns the selection policy.
+ * @return selection policy
+ */
+ public SelectionPolicy getSelectionPolicy() {
+ return selectionPolicy;
+ }
+
+ /**
+ * Returns the number of generations evolved to reach {@link StoppingCondition} in the last run.
+ *
+ * @return number of generations evolved
+ * @since 2.1
+ */
+ public int getGenerationsEvolved() {
+ return generationsEvolved;
+ }
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/InvalidRepresentationException.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/InvalidRepresentationException.java
new file mode 100644
index 000000000..25c752fbe
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/InvalidRepresentationException.java
@@ -0,0 +1,42 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.genetics;
+
+import com.fr.third.org.apache.commons.math3.exception.MathIllegalArgumentException;
+import com.fr.third.org.apache.commons.math3.exception.util.Localizable;
+
+/**
+ * Exception indicating that the representation of a chromosome is not valid.
+ *
+ * @since 2.0
+ */
+public class InvalidRepresentationException extends MathIllegalArgumentException {
+
+ /** Serialization version id */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ * Construct an InvalidRepresentationException with a specialized message.
+ *
+ * @param pattern Message pattern.
+ * @param args Arguments.
+ */
+ public InvalidRepresentationException(Localizable pattern, Object ... args) {
+ super(pattern, args);
+ }
+
+}
diff --git a/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/ListPopulation.java b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/ListPopulation.java
new file mode 100644
index 000000000..58ec37dee
--- /dev/null
+++ b/fine-commons-math3/src/com/fr/third/org/apache/commons/math3/genetics/ListPopulation.java
@@ -0,0 +1,222 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.fr.third.org.apache.commons.math3.genetics;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+import com.fr.third.org.apache.commons.math3.exception.NotPositiveException;
+import com.fr.third.org.apache.commons.math3.exception.NullArgumentException;
+import com.fr.third.org.apache.commons.math3.exception.NumberIsTooLargeException;
+import com.fr.third.org.apache.commons.math3.exception.NumberIsTooSmallException;
+import com.fr.third.org.apache.commons.math3.exception.util.LocalizedFormats;
+
+/**
+ * Population of chromosomes represented by a {@link List}.
+ *
+ * @since 2.0
+ */
+public abstract class ListPopulation implements Population {
+
+ /** List of chromosomes */
+ private Listcurrent
+ * generation, using its nextGeneration method
+ * current
+ * -C- denotes a crossover point
+ * -C- -C- -C- -C-
+ * p1 = (1 0 | 1 0 0 1 | 0 1 1) X p2 = (0 1 | 1 0 1 0 | 1 1 1)
+ * \----/ \-------/ \-----/ \----/ \--------/ \-----/
+ * || (*) || || (**) ||
+ * VV (**) VV VV (*) VV
+ * /----\ /--------\ /-----\ /----\ /--------\ /-----\
+ * c1 = (1 0 | 1 0 1 0 | 0 1 1) X c2 = (0 1 | 1 0 0 1 | 0 1 1)
+ *
+ *
+ * This policy works only on {@link AbstractListChromosome}, and therefore it
+ * is parameterized by T. Moreover, the chromosomes must have same lengths.
+ *
+ * @param chromosome length - 1.
+ * This condition can only be checked at runtime, as the chromosome length is not known in advance.
+ *
+ * @param crossoverPoints the number of crossover points
+ * @throws NotStrictlyPositiveException if the number of {@code crossoverPoints} is not strictly positive
+ */
+ public NPointCrossover(final int crossoverPoints) throws NotStrictlyPositiveException {
+ if (crossoverPoints <= 0) {
+ throw new NotStrictlyPositiveException(crossoverPoints);
+ }
+ this.crossoverPoints = crossoverPoints;
+ }
+
+ /**
+ * Returns the number of crossover points used by this {@link CrossoverPolicy}.
+ *
+ * @return the number of crossover points
+ */
+ public int getCrossoverPoints() {
+ return crossoverPoints;
+ }
+
+ /**
+ * Performs a N-point crossover. N random crossover points are selected and are used
+ * to divide the parent chromosomes into segments. The segments are copied in alternate
+ * order from the two parents to the corresponding child chromosomes.
+ *
+ * Example (2-point crossover):
+ *
+ * -C- denotes a crossover point
+ * -C- -C- -C- -C-
+ * p1 = (1 0 | 1 0 0 1 | 0 1 1) X p2 = (0 1 | 1 0 1 0 | 1 1 1)
+ * \----/ \-------/ \-----/ \----/ \--------/ \-----/
+ * || (*) || || (**) ||
+ * VV (**) VV VV (*) VV
+ * /----\ /--------\ /-----\ /----\ /--------\ /-----\
+ * c1 = (1 0 | 1 0 1 0 | 0 1 1) X c2 = (0 1 | 1 0 0 1 | 0 1 1)
+ *
+ *
+ * @param first first parent (p1)
+ * @param second second parent (p2)
+ * @return pair of two children (c1,c2)
+ * @throws MathIllegalArgumentException iff one of the chromosomes is
+ * not an instance of {@link AbstractListChromosome}
+ * @throws DimensionMismatchException if the length of the two chromosomes is different
+ */
+ @SuppressWarnings("unchecked") // OK because of instanceof checks
+ public ChromosomePair crossover(final Chromosome first, final Chromosome second)
+ throws DimensionMismatchException, MathIllegalArgumentException {
+
+ if (!(first instanceof AbstractListChromosome && second instanceof AbstractListChromosome)) {
+ throw new MathIllegalArgumentException(LocalizedFormats.INVALID_FIXED_LENGTH_CHROMOSOME);
+ }
+ return mate((AbstractListChromosome
+ * -C- denotes a crossover point
+ * -C- -C-
+ * p1 = (1 0 1 0 0 1 | 0 1 1) X p2 = (0 1 1 0 1 0 | 1 1 1)
+ * \------------/ \-----/ \------------/ \-----/
+ * || (*) || (**)
+ * VV (**) VV (*)
+ * /------------\ /-----\ /------------\ /-----\
+ * c1 = (1 0 1 0 0 1 | 1 1 1) X c2 = (0 1 1 0 1 0 | 0 1 1)
+ *
+ *
+ * This policy works only on {@link AbstractListChromosome}, and therefore it
+ * is parameterized by T. Moreover, the chromosomes must have same lengths.
+ *
+ * @param
+ * -C- denotes a crossover point
+ * -C- -C-
+ * p1 = (1 0 1 0 0 1 | 0 1 1) X p2 = (0 1 1 0 1 0 | 1 1 1)
+ * \------------/ \-----/ \------------/ \-----/
+ * || (*) || (**)
+ * VV (**) VV (*)
+ * /------------\ /-----\ /------------\ /-----\
+ * c1 = (1 0 1 0 0 1 | 1 1 1) X c2 = (0 1 1 0 1 0 | 0 1 1)
+ *
+ *
+ * @param first first parent (p1)
+ * @param second second parent (p2)
+ * @return pair of two children (c1,c2)
+ * @throws MathIllegalArgumentException iff one of the chromosomes is
+ * not an instance of {@link AbstractListChromosome}
+ * @throws DimensionMismatchException if the length of the two chromosomes is different
+ */
+ @SuppressWarnings("unchecked") // OK because of instanceof checks
+ public ChromosomePair crossover(final Chromosome first, final Chromosome second)
+ throws DimensionMismatchException, MathIllegalArgumentException {
+
+ if (! (first instanceof AbstractListChromosome && second instanceof AbstractListChromosome)) {
+ throw new MathIllegalArgumentException(LocalizedFormats.INVALID_FIXED_LENGTH_CHROMOSOME);
+ }
+ return crossover((AbstractListChromosome
+ *
+ *
+ * p1 = (8 4 7 3 6 2 5 1 9 0) X c1 = (0 4 7 3 6 2 5 1 8 9)
+ * --------- ---------
+ * p2 = (0 1 2 3 4 5 6 7 8 9) X c2 = (8 1 2 3 4 5 6 7 9 0)
+ *
+ *