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