/** {@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); }
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) { return abs(); } else if (expY > expX + 27) { return y.abs(); } else { final DerivativeStructure scaledX = scalb(-middleExp); final DerivativeStructure scaledY = y.scalb(-middleExp); scaledX.multiply(scaledX).add(scaledY.multiply(scaledY)).sqrt(); return scaledH.scalb(middleExp);
/** {@inheritDoc} * @since 3.1 */ public DerivativeStructure value(final DerivativeStructure t) { return t.acos(); }
/** {@inheritDoc} * @since 3.1 */ public DerivativeStructure value(final DerivativeStructure t) { return new DerivativeStructure(t.getFreeParameters(), t.getOrder(), c); }
/** * {@inheritDoc} * @since 3.1 */ public DerivativeStructure value(final DerivativeStructure t) { verifyInputArray(a, c); final int n = c.length; DerivativeStructure value = new DerivativeStructure(t.getFreeParameters(), t.getOrder(), a[n]); for (int i = n - 1; i >= 0; i--) { value = t.subtract(c[i]).multiply(value).add(a[i]); } return value; }
/** {@inheritDoc} * @exception NumberIsTooLargeException if derivation order is greater than 1 */ public DerivativeStructure value(final DerivativeStructure t) throws NumberIsTooLargeException { switch (t.getOrder()) { case 0 : return new DerivativeStructure(t.getFreeParameters(), 0, f.value(t.getValue())); case 1 : { final int parameters = t.getFreeParameters(); final double[] derivatives = new double[parameters + 1]; derivatives[0] = f.value(t.getValue()); final double fPrime = f.derivative().value(t.getValue()); int[] orders = new int[parameters]; for (int i = 0; i < parameters; ++i) { orders[i] = 1; derivatives[i + 1] = fPrime * t.getPartialDerivative(orders); orders[i] = 0; } return new DerivativeStructure(parameters, 1, derivatives); } default : throw new NumberIsTooLargeException(t.getOrder(), 1, true); } }
/** {@inheritDoc} * @since 3.1 */ public DerivativeStructure value(final DerivativeStructure t) throws DimensionMismatchException { final double x = t.getValue(); double[] f = new double[t.getOrder() + 1]; final double alpha = omega * x + phase; f[0] = amplitude * FastMath.cos(alpha); if (f.length > 1) { f[1] = -amplitude * omega * FastMath.sin(alpha); final double mo2 = - omega * omega; for (int i = 2; i < f.length; ++i) { f[i] = mo2 * f[i - 2]; } } return t.compose(f); }
/** Replace the deserialized data transfer object with a {@link DerivativeStructure}. * @return replacement {@link DerivativeStructure} */ private Object readResolve() { return new DerivativeStructure(variables, order, data); }
/** {@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); }
/** Interpolate value at a specified abscissa. * <p> * Calling this method is equivalent to call the {@link * PolynomialFunction#value(DerivativeStructure) value} methods of all polynomials * returned by {@link #getPolynomials() getPolynomials}, except it does not build the * intermediate polynomials, so this method is faster and numerically more stable. * </p> * @param x interpolation abscissa * @return interpolated value * @exception NoDataException if sample is empty */ public DerivativeStructure[] value(final DerivativeStructure x) throws NoDataException { // safety check checkInterpolation(); final DerivativeStructure[] value = new DerivativeStructure[topDiagonal.get(0).length]; Arrays.fill(value, x.getField().getZero()); DerivativeStructure valueCoeff = x.getField().getOne(); for (int i = 0; i < topDiagonal.size(); ++i) { double[] dividedDifference = topDiagonal.get(i); for (int k = 0; k < value.length; ++k) { value[k] = value[k].add(valueCoeff.multiply(dividedDifference[k])); } final DerivativeStructure deltaX = x.subtract(abscissae.get(i)); valueCoeff = valueCoeff.multiply(deltaX); } return value; }
/** * Returns value of loglikelihood using DerivativeStructure per interface requirements * @param t * @return */ public DerivativeStructure value(DerivativeStructure t){ return new DerivativeStructure(1, 0, 0, logLikelihood(t.getValue())); }
/** {@inheritDoc} * @since 3.1 */ public DerivativeStructure value(final DerivativeStructure t) { final double t0 = t.getValue(); if (t0 < knots[0] || t0 > knots[n]) { throw new OutOfRangeException(t0, knots[0], knots[n]); } int i = Arrays.binarySearch(knots, t0); if (i < 0) { i = -i - 2; } // This will handle the case where t is the last knot value // There are only n-1 polynomials, so if t is the last knot // then we will use the last polynomial to calculate the value. if ( i >= polynomials.length ) { i--; } return polynomials[i].value(t.subtract(knots[i])); }
/** * {@inheritDoc} */ @Override protected double doSolve() throws TooManyEvaluationsException { final double startValue = getStartValue(); final double absoluteAccuracy = getAbsoluteAccuracy(); double x0 = startValue; double x1; while (true) { final DerivativeStructure y0 = computeObjectiveValueAndDerivative(x0); x1 = x0 - (y0.getValue() / y0.getPartialDerivative(1)); if (FastMath.abs(x1 - x0) <= absoluteAccuracy) { return x1; } x0 = x1; } } }
/** {@inheritDoc} * @since 3.2 */ public DerivativeStructure subtract(final double a) { return add(-a); }
/** {@inheritDoc} * @since 3.1 */ public DerivativeStructure value(final DerivativeStructure t) { return t.asinh(); }
/** {@inheritDoc} * @since 3.1 */ public DerivativeStructure value(final DerivativeStructure t) { return t.atan(); }
/** 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.1 */ public DerivativeStructure value(final DerivativeStructure t) { return t.acosh(); }
/** {@inheritDoc} * @since 3.1 */ public DerivativeStructure value(final DerivativeStructure t) { return t.asin(); }