/// <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));
}
