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_toUnitParameterSensitivity()
{
CurrencyParameterSensitivity @base = CurrencyParameterSensitivity.of(NAME1, METADATA_USD1, USD, VECTOR_USD1);
UnitParameterSensitivity test = @base.toUnitParameterSensitivity();
assertEquals(test, UnitParameterSensitivity.of(NAME1, METADATA_USD1, VECTOR_USD1));
}
//-------------------------------------------------------------------------
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_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_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_plus_sensitivity()
{
UnitParameterSensitivity base1 = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1);
UnitParameterSensitivity test = base1.plus(base1);
assertEquals(test, base1.multipliedBy(2));
}
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_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)));
}
//-------------------------------------------------------------------------
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 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_combine_arraySize1()
{
UnitParameterSensitivity @base = UnitParameterSensitivity.of(NAME1, METADATA1, VECTOR1);
assertThrowsIllegalArg(() => UnitParameterSensitivity.combine(NAME_COMBINED, @base));
}
public virtual void test_of_metadataParamSplit_badSplit()
{
assertThrowsIllegalArg(() => UnitParameterSensitivity.of(NAME_COMBINED, METADATA1, VECTOR1, PARAM_SPLIT));
}
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));
}
