com.opengamma.strata.market.param

Class CurrencyParameterSensitivity

java.lang.Object

com.opengamma.strata.market.param.CurrencyParameterSensitivity

All Implemented Interfaces:

FxConvertible<CurrencyParameterSensitivity>, Serializable, org.joda.beans.Bean, org.joda.beans.ImmutableBean

public final class CurrencyParameterSensitivity
extends Object
implements FxConvertible<CurrencyParameterSensitivity>, org.joda.beans.ImmutableBean, Serializable

Currency-based parameter sensitivity for parameterized market data, such as a curve.

Parameter sensitivity is the sensitivity of a value to the parameters of a parameterized market data object that is used to determine the value. Common ParameterizedData implementations include Curve and Surface.

The sensitivity is expressed as an array, with one entry for each parameter in the ParameterizedData. The sensitivity represents a monetary value in the specified currency.

A single CurrencyParameterSensitivity represents the sensitivity to a single ParameterizedData instance. However, a ParameterizedData instance can itself be backed by more than one underlying instance. For example, a curve formed from two underlying curves. Information about the split between these underlying instances can optionally be stored.

See Also:

Serialized Form

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	CurrencyParameterSensitivity.Builder The bean-builder for CurrencyParameterSensitivity.
static class	CurrencyParameterSensitivity.Meta The meta-bean for CurrencyParameterSensitivity.

Method Summary

Modifier and Type	Method and Description
static CurrencyParameterSensitivity.Builder	builder() Returns a builder used to create an instance of the bean.
static CurrencyParameterSensitivity	combine(MarketDataName<?> marketDataName, CurrencyParameterSensitivity... sensitivities) Combines two or more instances to form a single sensitivity instance.
int	compareKey(CurrencyParameterSensitivity other) Compares the key of two sensitivity objects, excluding the parameter sensitivity values.
CurrencyParameterSensitivity	convertedTo(Currency resultCurrency, FxRateProvider rateProvider) Converts this sensitivity to an equivalent in the specified currency.
boolean	equals(Object obj)
Currency	getCurrency() Gets the currency of the sensitivity.
MarketDataName<?>	getMarketDataName() Gets the market data name.
int	getParameterCount() Gets the number of parameters.
ImmutableList<ParameterMetadata>	getParameterMetadata() Gets the list of parameter metadata.
ParameterMetadata	getParameterMetadata(int parameterIndex) Gets the parameter metadata at the specified index.
Optional<List<ParameterSize>>	getParameterSplit() Gets the split of parameters between the underlying parameterized data.
DoubleArray	getSensitivity() Gets the parameter sensitivity values.
int	hashCode()
CurrencyParameterSensitivity	mapSensitivity(DoubleUnaryOperator operator) Returns an instance with the specified operation applied to the sensitivity values.
CurrencyParameterSensitivity	mapSensitivityWithIndex(IntDoubleToDoubleFunction function) Returns an instance with an operation applied to each indexed value in the sensitivity values.
static CurrencyParameterSensitivity.Meta	meta() The meta-bean for CurrencyParameterSensitivity.
CurrencyParameterSensitivity.Meta	metaBean()
CurrencyParameterSensitivity	multipliedBy(double factor) Returns an instance with the sensitivity values multiplied by the specified factor.
static CurrencyParameterSensitivity	of(MarketDataName<?> marketDataName, Currency currency, DoubleArray sensitivity) Obtains an instance from the market data name, currency and sensitivity.
static CurrencyParameterSensitivity	of(MarketDataName<?> marketDataName, Currency currency, Map<? extends ParameterMetadata,Double> sensitivityMetadataMap) Obtains an instance from the market data name, currency and a map of metadata to sensitivity.
static CurrencyParameterSensitivity	of(MarketDataName<?> marketDataName, List<? extends ParameterMetadata> parameterMetadata, Currency currency, DoubleArray sensitivity) Obtains an instance from the market data name, metadata, currency and sensitivity.
static CurrencyParameterSensitivity	of(MarketDataName<?> marketDataName, List<? extends ParameterMetadata> parameterMetadata, Currency currency, DoubleArray sensitivity, List<ParameterSize> parameterSplit) Obtains an instance from the market data name, metadata, currency, sensitivity and parameter split.
CurrencyParameterSensitivity	plus(CurrencyParameterSensitivity otherSensitivty) Returns an instance with the specified sensitivity array added to the array in this instance.
CurrencyParameterSensitivity	plus(DoubleArray otherSensitivty) Returns an instance with the specified sensitivity array added to the array in this instance.
MapStream<ParameterMetadata,Double>	sensitivities() Converts this instance to a stream of sensitivity, keyed by the parameter metadata.
ImmutableList<CurrencyParameterSensitivity>	split() Splits this sensitivity instance.
CurrencyParameterSensitivity.Builder	toBuilder() Returns a builder that allows this bean to be mutated.
<T> ImmutableMap<T,Double>	toSensitivityMap(Class<T> identifierType) Converts this instance to a map of sensitivities, keyed by the identifier.
String	toString()
CurrencyAmount	total() Returns the total of the sensitivity values.
UnitParameterSensitivity	toUnitParameterSensitivity() Converts this instance to the equivalent unit sensitivity.
CurrencyParameterSensitivity	withSensitivity(DoubleArray sensitivity) Returns an instance with new parameter sensitivity values.

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.joda.beans.Bean

property, propertyNames

Method Detail

of

public static CurrencyParameterSensitivity of(MarketDataName<?> marketDataName,
                                              List<? extends ParameterMetadata> parameterMetadata,
                                              Currency currency,
                                              DoubleArray sensitivity)

Obtains an instance from the market data name, metadata, currency and sensitivity.

The market data name identifies the ParameterizedData instance that was queried. The parameter metadata provides information on each parameter. The size of the parameter metadata list must match the size of the sensitivity array.

Parameters:

marketDataName - the name of the market data that the sensitivity refers to

parameterMetadata - the parameter metadata

currency - the currency of the sensitivity

sensitivity - the sensitivity values, one for each parameter

Returns:

the sensitivity object

of

public static CurrencyParameterSensitivity of(MarketDataName<?> marketDataName,
                                              Currency currency,
                                              DoubleArray sensitivity)

Obtains an instance from the market data name, currency and sensitivity.

The market data name identifies the ParameterizedData instance that was queried. The parameter metadata will be empty. The size of the parameter metadata list must match the size of the sensitivity array.

Parameters:

marketDataName - the name of the market data that the sensitivity refers to

currency - the currency of the sensitivity

sensitivity - the sensitivity values, one for each parameter

Returns:

the sensitivity object

of

public static CurrencyParameterSensitivity of(MarketDataName<?> marketDataName,
                                              List<? extends ParameterMetadata> parameterMetadata,
                                              Currency currency,
                                              DoubleArray sensitivity,
                                              List<ParameterSize> parameterSplit)

Obtains an instance from the market data name, metadata, currency, sensitivity and parameter split.

The market data name identifies the ParameterizedData instance that was queried. The parameter metadata provides information on each parameter. The size of the parameter metadata list must match the size of the sensitivity array.

The parameter split allows the sensitivity to represent the split between two or more underlying ParameterizedData instances. The sum of the parameters in the split must equal the size of the sensitivity array, and each name must be unique.

Parameters:

marketDataName - the name of the market data that the sensitivity refers to

parameterMetadata - the parameter metadata

currency - the currency of the sensitivity

sensitivity - the sensitivity values, one for each parameter

parameterSplit - the split between the underlying ParameterizedData instances

Returns:

the sensitivity object

of

public static CurrencyParameterSensitivity of(MarketDataName<?> marketDataName,
                                              Currency currency,
                                              Map<? extends ParameterMetadata,Double> sensitivityMetadataMap)

Obtains an instance from the market data name, currency and a map of metadata to sensitivity.

The market data name identifies the ParameterizedData instance that was queried. The parameter metadata provides information on each parameter. One use of this method is to provide tenor-based sensitivity via TenorParameterMetadata.

Parameters:

marketDataName - the name of the market data that the sensitivity refers to

currency - the currency of the sensitivity

sensitivityMetadataMap - the map of parameter metadata to sensitivity

Returns:

the sensitivity object

combine

public static CurrencyParameterSensitivity combine(MarketDataName<?> marketDataName,
                                                   CurrencyParameterSensitivity... sensitivities)

Combines two or more instances to form a single sensitivity instance.

The result will store information about the separate instances allowing it to be split() later.

If a single sensitivity is supplied and refers to the same market data then it will be returned unmodified. Otherwise a new instance will be returned with a single parameter split (the original sensitivity).

Parameters:

marketDataName - the combined name of the market data that the sensitivity refers to

sensitivities - the sensitivity instances to combine, two or more

Returns:

the combined sensitivity object

getParameterCount

public int getParameterCount()

Gets the number of parameters.

This returns the number of parameters in the ParameterizedData instance which is the same size as the sensitivity array.

Returns:

the number of parameters

getParameterMetadata

public ParameterMetadata getParameterMetadata(int parameterIndex)

Gets the parameter metadata at the specified index.

If there is no specific parameter metadata, an empty instance will be returned.

Parameters:

parameterIndex - the zero-based index of the parameter to get

Returns:

the metadata of the parameter

Throws:

IndexOutOfBoundsException - if the index is invalid

compareKey

public int compareKey(CurrencyParameterSensitivity other)

Compares the key of two sensitivity objects, excluding the parameter sensitivity values.

Parameters:

other - the other sensitivity object

Returns:

positive if greater, zero if equal, negative if less

convertedTo

public CurrencyParameterSensitivity convertedTo(Currency resultCurrency,
                                                FxRateProvider rateProvider)

Converts this sensitivity to an equivalent in the specified currency.

Any FX conversion that is required will use rates from the provider.

Specified by:

convertedTo in interface FxConvertible<CurrencyParameterSensitivity>

Parameters:

resultCurrency - the currency of the result

rateProvider - the provider of FX rates

Returns:

the sensitivity object expressed in terms of the result currency

Throws:

RuntimeException - if no FX rate could be found

multipliedBy

public CurrencyParameterSensitivity multipliedBy(double factor)

Returns an instance with the sensitivity values multiplied by the specified factor.

Each value in the sensitivity array will be multiplied by the factor.

Parameters:

factor - the multiplicative factor

Returns:

an instance based on this one, with each sensitivity multiplied by the factor

mapSensitivity

public CurrencyParameterSensitivity mapSensitivity(DoubleUnaryOperator operator)

Returns an instance with the specified operation applied to the sensitivity values.

Each value in the sensitivity array will be operated on. For example, the operator could multiply the sensitivities by a constant, or take the inverse.

   inverse = base.mapSensitivity(value -> 1 / value);
 

Parameters:

operator - the operator to be applied to the sensitivities

Returns:

an instance based on this one, with the operator applied to the sensitivity values

mapSensitivityWithIndex

public CurrencyParameterSensitivity mapSensitivityWithIndex(IntDoubleToDoubleFunction function)

Returns an instance with an operation applied to each indexed value in the sensitivity values.

Each value in the sensitivity array will be operated on. The function receives both the index and the value. For example, the operator could multiply the sensitivities by the index.

   result = base.mapSensitivityWithIndex((index, value) -> index * value);
 

This instance is immutable and unaffected by this method.

Parameters:

function - the function to be applied to the sensitivities

Returns:

an instance based on this one, with the operator applied to the sensitivity values

withSensitivity

public CurrencyParameterSensitivity withSensitivity(DoubleArray sensitivity)

Returns an instance with new parameter sensitivity values.

Parameters:

sensitivity - the new sensitivity values

Returns:

an instance based on this one, with the specified sensitivity values

plus

public CurrencyParameterSensitivity plus(DoubleArray otherSensitivty)

Returns an instance with the specified sensitivity array added to the array in this instance.

The specified array must match the size of the array in this instance.

Parameters:

otherSensitivty - the other parameter sensitivity

Returns:

an instance based on this one, with the other instance added

Throws:

IllegalArgumentException - if the market data name, metadata or parameter split differs

plus

public CurrencyParameterSensitivity plus(CurrencyParameterSensitivity otherSensitivty)

Returns an instance with the specified sensitivity array added to the array in this instance.

The specified instance must have the same name, metadata, currency and parameter split as this instance.

Parameters:

otherSensitivty - the other parameter sensitivity

Returns:

an instance based on this one, with the other instance added

Throws:

IllegalArgumentException - if the market data name, metadata or parameter split differs

split

public ImmutableList<CurrencyParameterSensitivity> split()

Splits this sensitivity instance.

A single sensitivity instance may be based on more than one underlying ParameterizedData, as represented by 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 ParameterizedData, the list will be of size one containing this instance.

Returns:

this sensitivity split as per the defined parameter split, ordered as per this instance

total

public CurrencyAmount total()

Returns the total of the sensitivity values.

Returns:

the total sensitivity values

sensitivities

public MapStream<ParameterMetadata,Double> sensitivities()

Converts this instance to a stream of sensitivity, keyed by the parameter metadata.

This returns a MapStream keyed by the parameter metadata.

Returns:

a map stream containing the parameter metadata and the sensitivity value

toSensitivityMap

public <T> ImmutableMap<T,Double> toSensitivityMap(Class<T> identifierType)

Converts this instance to a map of sensitivities, keyed by the identifier.

This returns a Map keyed by the identifier of the metadata. For example, this could be used to extract a Map<Tenor, Double>.

Type Parameters:

T - the type of the identifier

Parameters:

identifierType - the type of the parameter metadata identifier

Returns:

a map containing the parameter metadata identifier and the sensitivity value

Throws:

ClassCastException - if the identifier of the parameter metadata does not match the specified type

toUnitParameterSensitivity

public UnitParameterSensitivity toUnitParameterSensitivity()

Converts this instance to the equivalent unit sensitivity.

The result has the same sensitivity values, but no longer records the currency.

Returns:

an instance based on this one, with the currency removed

meta

public static CurrencyParameterSensitivity.Meta meta()

The meta-bean for CurrencyParameterSensitivity.

Returns:

the meta-bean, not null

builder

public static CurrencyParameterSensitivity.Builder builder()

Returns a builder used to create an instance of the bean.

Returns:

the builder, not null

metaBean

public CurrencyParameterSensitivity.Meta metaBean()

Specified by:

metaBean in interface org.joda.beans.Bean

getMarketDataName

public MarketDataName<?> getMarketDataName()

Gets the market data name.

This name is used in the market data system to identify the data that the sensitivities refer to.

Returns:

the value of the property, not null

getParameterMetadata

public ImmutableList<ParameterMetadata> getParameterMetadata()

Gets the list of parameter metadata.

There is one entry for each parameter.

Returns:

the value of the property, not null

getCurrency

public Currency getCurrency()

Gets the currency of the sensitivity.

Returns:

the value of the property, not null

getSensitivity

public DoubleArray getSensitivity()

Gets the parameter sensitivity values.

There is one sensitivity value for each parameter.

Returns:

the value of the property, not null

getParameterSplit

public Optional<List<ParameterSize>> getParameterSplit()

Gets the split of parameters between the underlying parameterized data.

A single CurrencyParameterSensitivity represents the sensitivity to a single ParameterizedData instance. However, a ParameterizedData instance can itself be backed by more than one underlying instance. For example, a curve formed from two underlying curves. If this list is present, it represents how to split this sensitivity between the underlying instances.

Returns:

the optional value of the property, not null

toBuilder

public CurrencyParameterSensitivity.Builder toBuilder()

Returns a builder that allows this bean to be mutated.

Returns:

the mutable builder, not null

equals

public boolean equals(Object obj)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

toString

public String toString()

Overrides:

toString in class Object