/// <summary>
/// Applies a perturbation to the specified underlying.
/// <para>
/// This should be invoked once for each of the underlying instances.
/// It is intended to be used to pass the result of each invocation to the
/// constructor of the combined instance.
///
/// </para>
/// </summary>
/// @param <R> the type of the underlying </param>
/// <param name="underlyingIndex"> the index of the underlying instance </param>
/// <param name="underlyingType"> the type of the parameterized data at the specified index </param>
/// <param name="perturbation"> the perturbation to apply </param>
/// <returns> a parameterized data instance based on this with the specified perturbation applied </returns>
public R underlyingWithPerturbation <R>(int underlyingIndex, Type <R> underlyingType, ParameterPerturbation perturbation) where R : ParameterizedData
{
ParameterizedData underlying = underlyings[underlyingIndex];
// perturb using a derived perturbation that adjusts the index
int adjustment = lookup[underlyingIndex];
ParameterizedData perturbed = underlying.withPerturbation((idx, value, meta) => perturbation(idx + adjustment, value, meta));
return(underlyingType.cast(perturbed));
}
//-------------------------------------------------------------------------
/// <summary>
/// Updates a parameter on the specified underlying.
/// <para>
/// This should be invoked once for each of the underlying instances.
/// It is intended to be used to pass the result of each invocation to the
/// constructor of the combined instance.
/// </para>
/// <para>
/// If the parameter index applies to the underlying, it is updated.
/// If the parameter index does not apply to the underlying, no error occurs.
///
/// </para>
/// </summary>
/// @param <R> the type of the underlying </param>
/// <param name="underlyingIndex"> the index of the underlying instance </param>
/// <param name="underlyingType"> the type of the parameterized data at the specified index </param>
/// <param name="parameterIndex"> the zero-based index of the parameter to change </param>
/// <param name="newValue"> the new value for the specified parameter </param>
/// <returns> a parameterized data instance based on this with the specified parameter altered </returns>
/// <exception cref="IndexOutOfBoundsException"> if the index is invalid </exception>
public R underlyingWithParameter <R>(int underlyingIndex, Type <R> underlyingType, int parameterIndex, double newValue) where R : ParameterizedData
{
ParameterizedData perturbed = underlyings[underlyingIndex];
if (findUnderlyingIndex(parameterIndex) == underlyingIndex)
{
int adjustment = lookup[underlyingIndex];
perturbed = perturbed.withParameter(parameterIndex - adjustment, newValue);
}
return(underlyingType.cast(perturbed));
}
//-------------------------------------------------------------------------
/// <summary>
/// Updates a parameter on the specified list of underlying instances.
/// <para>
/// The correct underlying is identified and updated, with the list returned.
///
/// </para>
/// </summary>
/// @param <R> the type of the underlying </param>
/// <param name="underlyingType"> the type of the parameterized data at the specified index </param>
/// <param name="parameterIndex"> the zero-based index of the parameter to change </param>
/// <param name="newValue"> the new value for the specified parameter </param>
/// <returns> a parameterized data instance based on this with the specified parameter altered </returns>
/// <exception cref="IndexOutOfBoundsException"> if the index is invalid </exception>
public IList <R> withParameter <R>(Type <R> underlyingType, int parameterIndex, double newValue) where R : ParameterizedData
{
int underlyingIndex = findUnderlyingIndex(parameterIndex);
ImmutableList.Builder <R> builder = ImmutableList.builder();
for (int i = 0; i < underlyings.Length; i++)
{
ParameterizedData underlying = underlyings[i];
if (i == underlyingIndex)
{
int adjustment = lookup[underlyingIndex];
ParameterizedData perturbed = underlying.withParameter(parameterIndex - adjustment, newValue);
builder.add(underlyingType.cast(perturbed));
}
else
{
builder.add(underlyingType.cast(underlying));
}
}
return(builder.build());
}
