You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by tn...@apache.org on 2015/02/16 23:40:18 UTC
[48/82] [partial] [math] Update for next development iteration:
commons-math4
http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/analysis/differentiation/DerivativeStructure.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math3/analysis/differentiation/DerivativeStructure.java b/src/main/java/org/apache/commons/math3/analysis/differentiation/DerivativeStructure.java
deleted file mode 100644
index 7c45d18..0000000
--- a/src/main/java/org/apache/commons/math3/analysis/differentiation/DerivativeStructure.java
+++ /dev/null
@@ -1,1195 +0,0 @@
-/*
- * 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 org.apache.commons.math3.analysis.differentiation;
-
-import java.io.Serializable;
-
-import org.apache.commons.math3.RealFieldElement;
-import org.apache.commons.math3.Field;
-import org.apache.commons.math3.FieldElement;
-import org.apache.commons.math3.exception.DimensionMismatchException;
-import org.apache.commons.math3.exception.MathArithmeticException;
-import org.apache.commons.math3.exception.NumberIsTooLargeException;
-import org.apache.commons.math3.util.FastMath;
-import org.apache.commons.math3.util.MathArrays;
-import org.apache.commons.math3.util.MathUtils;
-
-/** Class representing both the value and the differentials of a function.
- * <p>This class is the workhorse of the differentiation package.</p>
- * <p>This class is an implementation of the extension to Rall's
- * numbers described in Dan Kalman's paper <a
- * href="http://www1.american.edu/cas/mathstat/People/kalman/pdffiles/mmgautodiff.pdf">Doubly
- * Recursive Multivariate Automatic Differentiation</a>, Mathematics Magazine, vol. 75,
- * no. 3, June 2002.</p>. 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.</p>
- * <p>{@link DerivativeStructure} instances can be used directly thanks to
- * the arithmetic operators to the mathematical functions provided as
- * methods by this class (+, -, *, /, %, sin, cos ...).</p>
- * <p>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}.</p>
- * <p>Instances of this class are guaranteed to be immutable.</p>
- * @see DSCompiler
- * @since 3.1
- */
-public class DerivativeStructure implements RealFieldElement<DerivativeStructure>, Serializable {
-
- /** Serializable UID. */
- private static final long serialVersionUID = 20120730L;
-
- /** Compiler for the current dimensions. */
- private transient DSCompiler compiler;
-
- /** Combined array holding all values. */
- private final double[] data;
-
- /** Build an instance with all values and derivatives set to 0.
- * @param compiler compiler to use for computation
- */
- private DerivativeStructure(final DSCompiler compiler) {
- this.compiler = compiler;
- this.data = new double[compiler.getSize()];
- }
-
- /** Build an instance with all values and derivatives set to 0.
- * @param parameters number of free parameters
- * @param order derivation order
- * @throws NumberIsTooLargeException if order is too large
- */
- public DerivativeStructure(final int parameters, final int order)
- throws NumberIsTooLargeException {
- this(DSCompiler.getCompiler(parameters, order));
- }
-
- /** Build an instance representing a constant value.
- * @param parameters number of free parameters
- * @param order derivation order
- * @param value value of the constant
- * @throws NumberIsTooLargeException if order is too large
- * @see #DerivativeStructure(int, int, int, double)
- */
- public DerivativeStructure(final int parameters, final int order, final double value)
- throws NumberIsTooLargeException {
- this(parameters, order);
- this.data[0] = value;
- }
-
- /** Build an instance representing a variable.
- * <p>Instances 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.</p>
- * @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.
- * <p>
- * This method is a convenience factory method, it simply calls
- * {@code new DerivativeStructure(getFreeParameters(), getOrder(), c)}
- * </p>
- * @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.
- * <p>
- * For double numbers of the form 2<sup>x</sup>, the unbiased
- * exponent is exactly x.
- * </p>
- * @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(<i>x</i><sup>2</sup> +<i>y</i><sup>2</sup>)<br/>
- * avoiding intermediate overflow or underflow.
- *
- * <ul>
- * <li> If either argument is infinite, then the result is positive infinity.</li>
- * <li> else, if either argument is NaN then the result is NaN.</li>
- * </ul>
- *
- * @param x a value
- * @param y a value
- * @return sqrt(<i>x</i><sup>2</sup> +<i>y</i><sup>2</sup>)
- * @exception DimensionMismatchException if number of free parameters
- * or orders do not match
- * @since 3.2
- */
- public static DerivativeStructure hypot(final DerivativeStructure x, final DerivativeStructure y)
- throws DimensionMismatchException {
- return x.hypot(y);
- }
-
- /** Compute composition of the instance by a univariate function.
- * @param f array of value and derivatives of the function at
- * the current point (i.e. [f({@link #getValue()}),
- * f'({@link #getValue()}), f''({@link #getValue()})...]).
- * @return f(this)
- * @exception DimensionMismatchException if the number of derivatives
- * in the array is not equal to {@link #getOrder() order} + 1
- */
- public DerivativeStructure compose(final double ... f)
- throws DimensionMismatchException {
- if (f.length != getOrder() + 1) {
- throw new DimensionMismatchException(f.length, getOrder() + 1);
- }
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.compose(data, 0, f, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc} */
- public DerivativeStructure reciprocal() {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.pow(data, 0, -1, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure sqrt() {
- return rootN(2);
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure cbrt() {
- return rootN(3);
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure rootN(final int n) {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.rootN(data, 0, n, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc} */
- public Field<DerivativeStructure> getField() {
- return new Field<DerivativeStructure>() {
-
- /** {@inheritDoc} */
- public DerivativeStructure getZero() {
- return new DerivativeStructure(compiler.getFreeParameters(), compiler.getOrder(), 0.0);
- }
-
- /** {@inheritDoc} */
- public DerivativeStructure getOne() {
- return new DerivativeStructure(compiler.getFreeParameters(), compiler.getOrder(), 1.0);
- }
-
- /** {@inheritDoc} */
- public Class<? extends FieldElement<DerivativeStructure>> getRuntimeClass() {
- return DerivativeStructure.class;
- }
-
- };
- }
-
- /** Compute a<sup>x</sup> where a is a double and x a {@link DerivativeStructure}
- * @param a number to exponentiate
- * @param x power to apply
- * @return a<sup>x</sup>
- * @since 3.3
- */
- public static DerivativeStructure pow(final double a, final DerivativeStructure x) {
- final DerivativeStructure result = new DerivativeStructure(x.compiler);
- x.compiler.pow(a, x.data, 0, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure pow(final double p) {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.pow(data, 0, p, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure pow(final int n) {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.pow(data, 0, n, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
- * or orders do not match
- * @since 3.2
- */
- public DerivativeStructure pow(final DerivativeStructure e)
- throws DimensionMismatchException {
- compiler.checkCompatibility(e.compiler);
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.pow(data, 0, e.data, 0, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure exp() {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.exp(data, 0, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure expm1() {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.expm1(data, 0, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure log() {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.log(data, 0, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure log1p() {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.log1p(data, 0, result.data, 0);
- return result;
- }
-
- /** Base 10 logarithm.
- * @return base 10 logarithm of the instance
- */
- public DerivativeStructure log10() {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.log10(data, 0, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure cos() {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.cos(data, 0, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure sin() {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.sin(data, 0, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure tan() {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.tan(data, 0, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure acos() {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.acos(data, 0, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure asin() {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.asin(data, 0, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure atan() {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.atan(data, 0, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure atan2(final DerivativeStructure x)
- throws DimensionMismatchException {
- compiler.checkCompatibility(x.compiler);
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.atan2(data, 0, x.data, 0, result.data, 0);
- return result;
- }
-
- /** Two arguments arc tangent operation.
- * @param y first argument of the arc tangent
- * @param x second argument of the arc tangent
- * @return atan2(y, x)
- * @exception DimensionMismatchException if number of free parameters
- * or orders do not match
- * @since 3.2
- */
- public static DerivativeStructure atan2(final DerivativeStructure y, final DerivativeStructure x)
- throws DimensionMismatchException {
- return y.atan2(x);
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure cosh() {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.cosh(data, 0, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure sinh() {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.sinh(data, 0, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure tanh() {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.tanh(data, 0, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure acosh() {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.acosh(data, 0, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure asinh() {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.asinh(data, 0, result.data, 0);
- return result;
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- public DerivativeStructure atanh() {
- final DerivativeStructure result = new DerivativeStructure(compiler);
- compiler.atanh(data, 0, result.data, 0);
- return result;
- }
-
- /** Convert radians to degrees, with error of less than 0.5 ULP
- * @return instance converted into degrees
- */
- public DerivativeStructure toDegrees() {
- final DerivativeStructure ds = new DerivativeStructure(compiler);
- for (int i = 0; i < ds.data.length; ++i) {
- ds.data[i] = FastMath.toDegrees(data[i]);
- }
- return ds;
- }
-
- /** Convert degrees to radians, with error of less than 0.5 ULP
- * @return instance converted into radians
- */
- public DerivativeStructure toRadians() {
- final DerivativeStructure ds = new DerivativeStructure(compiler);
- for (int i = 0; i < ds.data.length; ++i) {
- ds.data[i] = FastMath.toRadians(data[i]);
- }
- return ds;
- }
-
- /** Evaluate Taylor expansion a derivative structure.
- * @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 ... delta) throws MathArithmeticException {
- return compiler.taylor(data, 0, delta);
- }
-
- /** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
- * or orders do not match
- * @since 3.2
- */
- public DerivativeStructure linearCombination(final DerivativeStructure[] a, final DerivativeStructure[] b)
- throws DimensionMismatchException {
-
- // compute an accurate value, taking care of cancellations
- final double[] aDouble = new double[a.length];
- for (int i = 0; i < a.length; ++i) {
- aDouble[i] = a[i].getValue();
- }
- final double[] bDouble = new double[b.length];
- for (int i = 0; i < b.length; ++i) {
- bDouble[i] = b[i].getValue();
- }
- final double accurateValue = MathArrays.linearCombination(aDouble, bDouble);
-
- // compute a simple value, with all partial derivatives
- DerivativeStructure simpleValue = a[0].getField().getZero();
- for (int i = 0; i < a.length; ++i) {
- simpleValue = simpleValue.add(a[i].multiply(b[i]));
- }
-
- // create a result with accurate value and all derivatives (not necessarily as accurate as the value)
- final double[] all = simpleValue.getAllDerivatives();
- all[0] = accurateValue;
- return new DerivativeStructure(simpleValue.getFreeParameters(), simpleValue.getOrder(), all);
-
- }
-
- /** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
- * or orders do not match
- * @since 3.2
- */
- public DerivativeStructure linearCombination(final double[] a, final DerivativeStructure[] b)
- throws DimensionMismatchException {
-
- // compute an accurate value, taking care of cancellations
- final double[] bDouble = new double[b.length];
- for (int i = 0; i < b.length; ++i) {
- bDouble[i] = b[i].getValue();
- }
- final double accurateValue = MathArrays.linearCombination(a, bDouble);
-
- // compute a simple value, with all partial derivatives
- DerivativeStructure simpleValue = b[0].getField().getZero();
- for (int i = 0; i < a.length; ++i) {
- simpleValue = simpleValue.add(b[i].multiply(a[i]));
- }
-
- // create a result with accurate value and all derivatives (not necessarily as accurate as the value)
- final double[] all = simpleValue.getAllDerivatives();
- all[0] = accurateValue;
- return new DerivativeStructure(simpleValue.getFreeParameters(), simpleValue.getOrder(), all);
-
- }
-
- /** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
- * or orders do not match
- * @since 3.2
- */
- public DerivativeStructure linearCombination(final DerivativeStructure a1, final DerivativeStructure b1,
- final DerivativeStructure a2, final DerivativeStructure b2)
- throws DimensionMismatchException {
-
- // compute an accurate value, taking care of cancellations
- final double accurateValue = MathArrays.linearCombination(a1.getValue(), b1.getValue(),
- a2.getValue(), b2.getValue());
-
- // compute a simple value, with all partial derivatives
- final DerivativeStructure simpleValue = a1.multiply(b1).add(a2.multiply(b2));
-
- // create a result with accurate value and all derivatives (not necessarily as accurate as the value)
- final double[] all = simpleValue.getAllDerivatives();
- all[0] = accurateValue;
- return new DerivativeStructure(getFreeParameters(), getOrder(), all);
-
- }
-
- /** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
- * or orders do not match
- * @since 3.2
- */
- public DerivativeStructure linearCombination(final double a1, final DerivativeStructure b1,
- final double a2, final DerivativeStructure b2)
- throws DimensionMismatchException {
-
- // compute an accurate value, taking care of cancellations
- final double accurateValue = MathArrays.linearCombination(a1, b1.getValue(),
- a2, b2.getValue());
-
- // compute a simple value, with all partial derivatives
- final DerivativeStructure simpleValue = b1.multiply(a1).add(b2.multiply(a2));
-
- // create a result with accurate value and all derivatives (not necessarily as accurate as the value)
- final double[] all = simpleValue.getAllDerivatives();
- all[0] = accurateValue;
- return new DerivativeStructure(getFreeParameters(), getOrder(), all);
-
- }
-
- /** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
- * or orders do not match
- * @since 3.2
- */
- public DerivativeStructure linearCombination(final DerivativeStructure a1, final DerivativeStructure b1,
- final DerivativeStructure a2, final DerivativeStructure b2,
- final DerivativeStructure a3, final DerivativeStructure b3)
- throws DimensionMismatchException {
-
- // compute an accurate value, taking care of cancellations
- final double accurateValue = MathArrays.linearCombination(a1.getValue(), b1.getValue(),
- a2.getValue(), b2.getValue(),
- a3.getValue(), b3.getValue());
-
- // compute a simple value, with all partial derivatives
- final DerivativeStructure simpleValue = a1.multiply(b1).add(a2.multiply(b2)).add(a3.multiply(b3));
-
- // create a result with accurate value and all derivatives (not necessarily as accurate as the value)
- final double[] all = simpleValue.getAllDerivatives();
- all[0] = accurateValue;
- return new DerivativeStructure(getFreeParameters(), getOrder(), all);
-
- }
-
- /** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
- * or orders do not match
- * @since 3.2
- */
- public DerivativeStructure linearCombination(final double a1, final DerivativeStructure b1,
- final double a2, final DerivativeStructure b2,
- final double a3, final DerivativeStructure b3)
- throws DimensionMismatchException {
-
- // compute an accurate value, taking care of cancellations
- final double accurateValue = MathArrays.linearCombination(a1, b1.getValue(),
- a2, b2.getValue(),
- a3, b3.getValue());
-
- // compute a simple value, with all partial derivatives
- final DerivativeStructure simpleValue = b1.multiply(a1).add(b2.multiply(a2)).add(b3.multiply(a3));
-
- // create a result with accurate value and all derivatives (not necessarily as accurate as the value)
- final double[] all = simpleValue.getAllDerivatives();
- all[0] = accurateValue;
- return new DerivativeStructure(getFreeParameters(), getOrder(), all);
-
- }
-
- /** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
- * or orders do not match
- * @since 3.2
- */
- public DerivativeStructure linearCombination(final DerivativeStructure a1, final DerivativeStructure b1,
- final DerivativeStructure a2, final DerivativeStructure b2,
- final DerivativeStructure a3, final DerivativeStructure b3,
- final DerivativeStructure a4, final DerivativeStructure b4)
- throws DimensionMismatchException {
-
- // compute an accurate value, taking care of cancellations
- final double accurateValue = MathArrays.linearCombination(a1.getValue(), b1.getValue(),
- a2.getValue(), b2.getValue(),
- a3.getValue(), b3.getValue(),
- a4.getValue(), b4.getValue());
-
- // compute a simple value, with all partial derivatives
- final DerivativeStructure simpleValue = a1.multiply(b1).add(a2.multiply(b2)).add(a3.multiply(b3)).add(a4.multiply(b4));
-
- // create a result with accurate value and all derivatives (not necessarily as accurate as the value)
- final double[] all = simpleValue.getAllDerivatives();
- all[0] = accurateValue;
- return new DerivativeStructure(getFreeParameters(), getOrder(), all);
-
- }
-
- /** {@inheritDoc}
- * @exception DimensionMismatchException if number of free parameters
- * or orders do not match
- * @since 3.2
- */
- public DerivativeStructure linearCombination(final double a1, final DerivativeStructure b1,
- final double a2, final DerivativeStructure b2,
- final double a3, final DerivativeStructure b3,
- final double a4, final DerivativeStructure b4)
- throws DimensionMismatchException {
-
- // compute an accurate value, taking care of cancellations
- final double accurateValue = MathArrays.linearCombination(a1, b1.getValue(),
- a2, b2.getValue(),
- a3, b3.getValue(),
- a4, b4.getValue());
-
- // compute a simple value, with all partial derivatives
- final DerivativeStructure simpleValue = b1.multiply(a1).add(b2.multiply(a2)).add(b3.multiply(a3)).add(b4.multiply(a4));
-
- // create a result with accurate value and all derivatives (not necessarily as accurate as the value)
- final double[] all = simpleValue.getAllDerivatives();
- all[0] = accurateValue;
- return new DerivativeStructure(getFreeParameters(), getOrder(), all);
-
- }
-
- /**
- * Test for the equality of two derivative structures.
- * <p>
- * Derivative structures are considered equal if they have the same number
- * of free parameters, the same derivation order, and the same derivatives.
- * </p>
- * @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
- */
- public 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);
- }
-
- }
-
-}
http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/analysis/differentiation/FiniteDifferencesDifferentiator.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math3/analysis/differentiation/FiniteDifferencesDifferentiator.java b/src/main/java/org/apache/commons/math3/analysis/differentiation/FiniteDifferencesDifferentiator.java
deleted file mode 100644
index ea92809..0000000
--- a/src/main/java/org/apache/commons/math3/analysis/differentiation/FiniteDifferencesDifferentiator.java
+++ /dev/null
@@ -1,383 +0,0 @@
-/*
- * 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 org.apache.commons.math3.analysis.differentiation;
-
-import java.io.Serializable;
-
-import org.apache.commons.math3.analysis.UnivariateFunction;
-import org.apache.commons.math3.analysis.UnivariateMatrixFunction;
-import org.apache.commons.math3.analysis.UnivariateVectorFunction;
-import org.apache.commons.math3.exception.MathIllegalArgumentException;
-import org.apache.commons.math3.exception.NotPositiveException;
-import org.apache.commons.math3.exception.NumberIsTooLargeException;
-import org.apache.commons.math3.exception.NumberIsTooSmallException;
-import org.apache.commons.math3.util.FastMath;
-
-/** Univariate functions differentiator using finite differences.
- * <p>
- * 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
- * value.
- * </p>
- * <p>
- * 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.
- * </p>
- * <p>
- * 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:
- * <ul>
- * <li>step size = 0.25, second order derivative error about 9.97e-10</li>
- * <li>step size = 0.25, fourth order derivative error about 5.43e-8</li>
- * <li>step size = 1.0e-6, second order derivative error about 148</li>
- * <li>step size = 1.0e-6, fourth order derivative error about 6.35e+14</li>
- * </ul>
- * This example shows that the small step size is really bad, even simply
- * for second order derivative!
- * </p>
- * @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.
- * <p>
- * 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
- * <em>bad</em> idea.
- * </p>
- * @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.
- * <p>
- * 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.
- * </p>
- * <p>
- * Note that the boundaries are considered to be excluded for function evaluation.
- * </p>
- * <p>
- * 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
- * <em>bad</em> idea.
- * </p>
- * @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.
- * <p>
- * Evaluation is done using divided differences.
- * </p>
- * @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}
- * <p>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.
- * </p>
- */
- 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}
- * <p>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.
- * </p>
- */
- 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}
- * <p>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.
- * </p>
- */
- 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;
-
- }
-
- };
- }
-
-}
http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/analysis/differentiation/GradientFunction.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math3/analysis/differentiation/GradientFunction.java b/src/main/java/org/apache/commons/math3/analysis/differentiation/GradientFunction.java
deleted file mode 100644
index 25aa7c7..0000000
--- a/src/main/java/org/apache/commons/math3/analysis/differentiation/GradientFunction.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * 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 org.apache.commons.math3.analysis.differentiation;
-
-import org.apache.commons.math3.analysis.MultivariateVectorFunction;
-
-/** Class representing the gradient of a multivariate function.
- * <p>
- * The vectorial components of the function represent the derivatives
- * with respect to each function parameters.
- * </p>
- * @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;
-
- }
-
-}
http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/analysis/differentiation/JacobianFunction.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math3/analysis/differentiation/JacobianFunction.java b/src/main/java/org/apache/commons/math3/analysis/differentiation/JacobianFunction.java
deleted file mode 100644
index 0de47db..0000000
--- a/src/main/java/org/apache/commons/math3/analysis/differentiation/JacobianFunction.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * 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 org.apache.commons.math3.analysis.differentiation;
-
-import org.apache.commons.math3.analysis.MultivariateMatrixFunction;
-
-/** Class representing the Jacobian of a multivariate vector function.
- * <p>
- * 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.
- * </p>
- * @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;
-
- }
-
-}
http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/analysis/differentiation/MultivariateDifferentiableFunction.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math3/analysis/differentiation/MultivariateDifferentiableFunction.java b/src/main/java/org/apache/commons/math3/analysis/differentiation/MultivariateDifferentiableFunction.java
deleted file mode 100644
index 443671e..0000000
--- a/src/main/java/org/apache/commons/math3/analysis/differentiation/MultivariateDifferentiableFunction.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * 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 org.apache.commons.math3.analysis.differentiation;
-
-import org.apache.commons.math3.analysis.MultivariateFunction;
-import org.apache.commons.math3.exception.MathIllegalArgumentException;
-
-/**
- * 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;
-
-}
http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/analysis/differentiation/MultivariateDifferentiableVectorFunction.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math3/analysis/differentiation/MultivariateDifferentiableVectorFunction.java b/src/main/java/org/apache/commons/math3/analysis/differentiation/MultivariateDifferentiableVectorFunction.java
deleted file mode 100644
index a5987ae..0000000
--- a/src/main/java/org/apache/commons/math3/analysis/differentiation/MultivariateDifferentiableVectorFunction.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * 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 org.apache.commons.math3.analysis.differentiation;
-
-import org.apache.commons.math3.analysis.MultivariateVectorFunction;
-import org.apache.commons.math3.exception.MathIllegalArgumentException;
-
-
-/**
- * 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;
-
-}