/// <inheritdoc/> public double[][] value(double[] x) { int n = x.Length; // delegate computation to underlying function DerivativeStructure[] dsX = new DerivativeStructure[n]; for (int i = 0; i < n; ++i) { dsX[i] = new DerivativeStructure(n, 1, i, x[i]); } DerivativeStructure[] y = f.value(dsX); // extract Jacobian double[][] jacobian = new double[y.Length][]; int[] orders = new int[n]; for (int i = 0; i < y.Length; ++i) { for (int j = 0; j < n; ++j) { orders[j] = 1; jacobian[i][j] = y[i].getPartialDerivative(orders); orders[j] = 0; } } return(jacobian); }
/// <inheritdoc/> /// <exception cref="NumberIsTooLargeException"> if derivation order is greater /// than 1</exception> public DerivativeStructure value(DerivativeStructure t) { switch (t.getOrder()) { case 0: return(new DerivativeStructure(t.getFreeParameters(), 0, f.value(t.getValue()))); case 1: { int parameters = t.getFreeParameters(); double[] derivatives = new double[parameters + 1]; derivatives[0] = f.value(t.getValue()); 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 <Int32, Int32>(t.getOrder(), 1, true); } }
/// <inheritdoc/> /// <exception cref="NumberIsTooLargeException"> if derivation order is higher /// than 1</exception> /// <exception cref="DimensionMismatchException"> if numbers of free parameters /// are inconsistent</exception> public DerivativeStructure[] value(DerivativeStructure[] t) { // check parameters and orders limits int parameters = t[0].getFreeParameters(); int order = t[0].getOrder(); int n = t.Length; if (order > 1) { throw new NumberIsTooLargeException <Int32, Int32>(order, 1, true); } // check all elements in the array are consistent for (int i = 0; i < n; ++i) { if (t[i].getFreeParameters() != parameters) { throw new DimensionMismatchException(t[i].getFreeParameters(), parameters); } if (t[i].getOrder() != order) { throw new DimensionMismatchException(t[i].getOrder(), order); } } // delegate computation to underlying function double[] point = new double[n]; for (int i = 0; i < n; ++i) { point[i] = t[i].getValue(); } double[] value = f.value(point); double[][] jacobian = f.jacobian().value(point); // merge value and Jacobian into a DerivativeStructure array DerivativeStructure[] merged = new DerivativeStructure[value.Length]; for (int k = 0; k < merged.Length; ++k) { double[] derivatives = new double[parameters + 1]; derivatives[0] = value[k]; int[] orders = new int[parameters]; for (int i = 0; i < parameters; ++i) { orders[i] = 1; for (int j = 0; j < n; ++j) { derivatives[i + 1] += jacobian[k][j] * t[j].getPartialDerivative(orders); } orders[i] = 0; } merged[k] = new DerivativeStructure(parameters, order, derivatives); } return(merged); }
/// <inheritdoc/> public DerivativeStructure value(DerivativeStructure t) { DerivativeStructure r = f[0].value(t); for (int i = 1; i < f.Length; i++) { r = r.multiply(f[i].value(t)); } return(r); }
/// <inheritdoc/> public DerivativeStructure value(DerivativeStructure t) { DerivativeStructure r = t; for (int i = f.Length - 1; i >= 0; i--) { r = f[i].value(r); } return(r); }
/// <inheritdoc/> public double value(double[] x) { int n = x.Length; // delegate computation to underlying function DerivativeStructure[] dsX = new DerivativeStructure[n]; for (int i = 0; i < n; ++i) { if (i == k) { dsX[i] = new DerivativeStructure(1, 1, 0, x[i]); } else { dsX[i] = new DerivativeStructure(1, 1, x[i]); } } DerivativeStructure y = f.value(dsX); // extract partial derivative return(y.getPartialDerivative(1)); }
/// <inheritdoc/> public double[] value(double[] x) { int n = x.Length; // delegate computation to underlying function DerivativeStructure[] dsX = new DerivativeStructure[n]; for (int i = 0; i < n; ++i) { dsX[i] = new DerivativeStructure(n, 1, i, x[i]); } DerivativeStructure y = f.value(dsX); // extract gradient double[] gradient = new double[n]; int[] orders = new int[n]; for (int i = 0; i < n; ++i) { orders[i] = 1; gradient[i] = y.getPartialDerivative(orders); orders[i] = 0; } return(gradient); }
/// <inheritdoc/> public DerivativeStructure value(DerivativeStructure t) { return(t); }
/// <inheritdoc/> public DerivativeStructure value(DerivativeStructure t) { return(new DerivativeStructure(t.getFreeParameters(), t.getOrder(), c)); }