commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From t.@apache.org
Subject [48/82] [partial] [math] Update for next development iteration: commons-math4
Date Mon, 16 Feb 2015 22:40:18 GMT
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>&nbsp;+<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>&nbsp;+<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 (&Delta;x, &Delta;y, ...)
-     * @return value of the Taylor expansion at x + &Delta;x, y + &Delta;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 &lt; t &lt; 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;
-
-}


Mime
View raw message