Class 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
    • 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
      • 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
      • 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
      • 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
      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class Object