//-------------------------------------------------------------------------
public virtual void test_plus_sensitivity()
{
UnitParameterSensitivity base1 = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1);
UnitParameterSensitivity test = base1.plus(base1);
assertEquals(test, base1.multipliedBy(2));
}
//-------------------------------------------------------------------------
public virtual void test_toUnitParameterSensitivity()
{
CurrencyParameterSensitivity @base = CurrencyParameterSensitivity.of(NAME1, METADATA_USD1, USD, VECTOR_USD1);
UnitParameterSensitivity test = @base.toUnitParameterSensitivity();
assertEquals(test, UnitParameterSensitivity.of(NAME1, METADATA_USD1, VECTOR_USD1));
}
//-------------------------------------------------------------------------
/// <summary>
/// Combines two or more instances to form a single sensitivity instance.
/// <para>
/// The result will store information about the separate instances allowing it to be <seealso cref="#split()"/> later.
///
/// </para>
/// </summary>
/// <param name="marketDataName"> the combined name of the market data that the sensitivity refers to </param>
/// <param name="sensitivities"> the sensitivity instances to combine, two or more </param>
/// <returns> the combined sensitivity object </returns>
public static UnitParameterSensitivity combine <T1>(MarketDataName <T1> marketDataName, params UnitParameterSensitivity[] sensitivities)
{
ArgChecker.notEmpty(sensitivities, "sensitivities");
if (sensitivities.Length < 2)
{
throw new System.ArgumentException("At least two sensitivity instances must be specified");
}
int size = Stream.of(sensitivities).mapToInt(s => s.ParameterCount).sum();
double[] combinedSensitivities = new double[size];
ImmutableList.Builder <ParameterMetadata> combinedMeta = ImmutableList.builder();
ImmutableList.Builder <ParameterSize> split = ImmutableList.builder();
int count = 0;
for (int i = 0; i < sensitivities.Length; i++)
{
UnitParameterSensitivity sens = sensitivities[i];
Array.Copy(sens.Sensitivity.toArrayUnsafe(), 0, combinedSensitivities, count, sens.ParameterCount);
combinedMeta.addAll(sens.ParameterMetadata);
split.add(ParameterSize.of(sens.MarketDataName, sens.ParameterCount));
count += sens.ParameterCount;
}
return(new UnitParameterSensitivity(marketDataName, combinedMeta.build(), DoubleArray.ofUnsafe(combinedSensitivities), split.build()));
}
public virtual void test_plus_sensitivity_wrongName()
{
UnitParameterSensitivity base1 = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1);
UnitParameterSensitivity base2 = UnitParameterSensitivity.of(NAME2, METADATA1, VECTOR1);
assertThrowsIllegalArg(() => base1.plus(base2));
}
public virtual void test_multipliedBy()
{
UnitParameterSensitivity @base = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1);
UnitParameterSensitivity test = @base.multipliedBy(FACTOR1);
assertEquals(test, UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1_FACTOR));
}
//-------------------------------------------------------------------------
public virtual void test_plus_array()
{
UnitParameterSensitivity @base = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1);
UnitParameterSensitivity test = @base.plus(VECTOR1);
assertEquals(test, @base.multipliedBy(2));
}
public virtual void test_combine_duplicateNames()
{
UnitParameterSensitivity base1 = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1);
UnitParameterSensitivity base2 = UnitParameterSensitivity.of(NAME1, METADATA2, VECTOR2);
assertThrowsIllegalArg(() => UnitParameterSensitivity.combine(NAME_COMBINED, base1, base2));
}
//-------------------------------------------------------------------------
public virtual void test_total()
{
UnitParameterSensitivity @base = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1);
double test = @base.total();
assertEquals(test, VECTOR1.get(0) + VECTOR1.get(1) + VECTOR1.get(2) + VECTOR1.get(3));
}
//-------------------------------------------------------------------------
public virtual void test_split1()
{
UnitParameterSensitivity @base = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1);
ImmutableList <UnitParameterSensitivity> test = @base.split();
assertEquals(test.size(), 1);
assertEquals(test.get(0), @base);
}
//-------------------------------------------------------------------------
public virtual void test_withSensitivity()
{
UnitParameterSensitivity @base = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1);
UnitParameterSensitivity test = @base.withSensitivity(VECTOR1_FACTOR);
assertEquals(test, UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1_FACTOR));
assertThrowsIllegalArg(() => @base.withSensitivity(DoubleArray.of(1d)));
}
/// <summary>
/// Returns an instance with the specified sensitivity array added to the array in this instance.
/// <para>
/// The specified instance must have the same name, metadata and parameter split as this instance.
///
/// </para>
/// </summary>
/// <param name="otherSensitivty"> the other parameter sensitivity </param>
/// <returns> an instance based on this one, with the other instance added </returns>
/// <exception cref="IllegalArgumentException"> if the market data name, metadata or parameter split differs </exception>
public UnitParameterSensitivity plus(UnitParameterSensitivity otherSensitivty)
{
if (!marketDataName.Equals(otherSensitivty.marketDataName) || !parameterMetadata.Equals(otherSensitivty.parameterMetadata) || (parameterSplit != null && !parameterSplit.Equals(otherSensitivty.parameterSplit)))
{
throw new System.ArgumentException("Two sensitivity instances can only be added if name, metadata and split are equal");
}
return(plus(otherSensitivty.Sensitivity));
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
UnitParameterSensitivity test = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1);
coverImmutableBean(test);
UnitParameterSensitivity test2 = UnitParameterSensitivity.of(NAME2, METADATA2, VECTOR2);
coverBeanEquals(test, test2);
}
public virtual void test_split2()
{
UnitParameterSensitivity base1 = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1);
UnitParameterSensitivity base2 = UnitParameterSensitivity.of(NAME2, METADATA2, VECTOR2);
UnitParameterSensitivity combined = UnitParameterSensitivity.combine(NAME_COMBINED, base1, base2);
ImmutableList <UnitParameterSensitivity> test = combined.split();
assertEquals(test.size(), 2);
assertEquals(test.get(0), base1);
assertEquals(test.get(1), base2);
}
//-------------------------------------------------------------------------
public virtual void test_of_metadata()
{
UnitParameterSensitivity test = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1);
assertEquals(test.MarketDataName, NAME1);
assertEquals(test.ParameterCount, VECTOR1.size());
assertEquals(test.ParameterMetadata, METADATA1);
assertEquals(test.getParameterMetadata(0), METADATA1[0]);
assertEquals(test.Sensitivity, VECTOR1);
assertEquals(test.ParameterSplit, null);
}
public virtual void test_of_metadataParamSplit()
{
UnitParameterSensitivity test = UnitParameterSensitivity.of(NAME_COMBINED, METADATA_COMBINED, VECTOR_COMBINED, PARAM_SPLIT);
assertEquals(test.MarketDataName, NAME_COMBINED);
assertEquals(test.ParameterCount, VECTOR_COMBINED.size());
assertEquals(test.ParameterMetadata, METADATA_COMBINED);
assertEquals(test.getParameterMetadata(0), METADATA_COMBINED.get(0));
assertEquals(test.Sensitivity, VECTOR_COMBINED);
assertEquals(test.ParameterSplit, PARAM_SPLIT);
}
public virtual void test_combine()
{
UnitParameterSensitivity base1 = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1);
UnitParameterSensitivity base2 = UnitParameterSensitivity.of(NAME2, METADATA2, VECTOR2);
UnitParameterSensitivity test = UnitParameterSensitivity.combine(NAME_COMBINED, base1, base2);
assertEquals(test.MarketDataName, NAME_COMBINED);
assertEquals(test.ParameterCount, VECTOR_COMBINED.size());
assertEquals(test.ParameterMetadata, METADATA_COMBINED);
assertEquals(test.getParameterMetadata(0), METADATA_COMBINED.get(0));
assertEquals(test.Sensitivity, VECTOR_COMBINED);
assertEquals(test.ParameterSplit, PARAM_SPLIT);
}
//-------------------------------------------------------------------------
/// <summary>
/// Splits this sensitivity instance.
/// <para>
/// A single sensitivity instance may be based on more than one underlying <seealso cref="ParameterizedData"/>,
/// as represented by <seealso cref="#getParameterSplit()"/>. Calling this method returns a list
/// where the sensitivity of this instance has been split into multiple instances as per
/// the parameter split definition. In the common case where there is a single underlying
/// {@code ParameterizedData}, the list will be of size one containing this instance.
///
/// </para>
/// </summary>
/// <returns> this sensitivity split as per the defined parameter split, ordered as per this instance </returns>
public ImmutableList <UnitParameterSensitivity> split()
{
if (parameterSplit == null)
{
return(ImmutableList.of(this));
}
ImmutableList.Builder <UnitParameterSensitivity> builder = ImmutableList.builder();
int count = 0;
foreach (ParameterSize size in parameterSplit)
{
IList <ParameterMetadata> splitMetadata = parameterMetadata.subList(count, count + size.ParameterCount);
DoubleArray splitSensitivity = sensitivity.subArray(count, count + size.ParameterCount);
builder.add(UnitParameterSensitivity.of(size.Name, splitMetadata, splitSensitivity));
count += size.ParameterCount;
}
return(builder.build());
}
public virtual void test_of_metadataParamSplit_badSplit()
{
assertThrowsIllegalArg(() => UnitParameterSensitivity.of(NAME_COMBINED, METADATA1, VECTOR1, PARAM_SPLIT));
}
public virtual void test_combine_arraySize1()
{
UnitParameterSensitivity @base = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1);
assertThrowsIllegalArg(() => UnitParameterSensitivity.combine(NAME_COMBINED, @base));
}
public virtual void test_plus_array_wrongSize()
{
UnitParameterSensitivity @base = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1);
assertThrowsIllegalArg(() => @base.plus(VECTOR2));
}
public virtual void test_of_metadata_badMetadata()
{
assertThrowsIllegalArg(() => UnitParameterSensitivity.of(NAME1, METADATA_BAD, VECTOR1));
}
public virtual void test_combine_arraySize0()
{
assertThrowsIllegalArg(() => UnitParameterSensitivity.combine(NAME_COMBINED));
}
/// <summary>
/// Obtains an instance from a single sensitivity entry.
/// </summary>
/// <param name="sensitivity"> the sensitivity entry </param>
/// <returns> the sensitivities instance </returns>
public static UnitParameterSensitivities of(UnitParameterSensitivity sensitivity)
{
return(new UnitParameterSensitivities(ImmutableList.of(sensitivity)));
}
/// <summary>
/// Compares the key of two sensitivity objects, excluding the parameter sensitivity values.
/// </summary>
/// <param name="other"> the other sensitivity object </param>
/// <returns> positive if greater, zero if equal, negative if less </returns>
public int compareKey(UnitParameterSensitivity other)
{
return(ComparisonChain.start().compare(marketDataName, other.marketDataName).result());
}
