Class UnitParameterSensitivity

  • All Implemented Interfaces:
    java.io.Serializable, Bean, ImmutableBean

    public final class UnitParameterSensitivity
    extends java.lang.Object
    implements ImmutableBean, java.io.Serializable
    Unit 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 has no associated currency.

    A single UnitParameterSensitivity 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 UnitParameterSensitivity of​(MarketDataName<?> marketDataName,
                                                  java.util.List<? extends ParameterMetadata> parameterMetadata,
                                                  DoubleArray sensitivity)
        Obtains an instance from the market data name, metadata 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
        sensitivity - the sensitivity values, one for each parameter
        Returns:
        the sensitivity object
      • of

        public static UnitParameterSensitivity of​(MarketDataName<?> marketDataName,
                                                  DoubleArray sensitivity)
        Obtains an instance from the market data name 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
        sensitivity - the sensitivity values, one for each parameter
        Returns:
        the sensitivity object
      • of

        public static UnitParameterSensitivity of​(MarketDataName<?> marketDataName,
                                                  java.util.List<? extends ParameterMetadata> parameterMetadata,
                                                  DoubleArray sensitivity,
                                                  java.util.List<ParameterSize> parameterSplit)
        Obtains an instance from the market data name, metadata, 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
        sensitivity - the sensitivity values, one for each parameter
        parameterSplit - the split between the underlying ParameterizedData instances
        Returns:
        the sensitivity object
      • combine

        public static UnitParameterSensitivity combine​(MarketDataName<?> marketDataName,
                                                       UnitParameterSensitivity... 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.

        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:
        java.lang.IndexOutOfBoundsException - if the index is invalid
      • compareKey

        public int compareKey​(UnitParameterSensitivity 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​(Currency currency,
                                                         double amount)
        Returns an instance converted this sensitivity to a monetary value, multiplying by the specified factor.

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

        Parameters:
        currency - the currency of the amount
        amount - the amount to multiply by
        Returns:
        the resulting sensitivity object
      • multipliedBy

        public UnitParameterSensitivity 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 UnitParameterSensitivity mapSensitivity​(java.util.function.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 UnitParameterSensitivity 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 UnitParameterSensitivity 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:
        java.lang.IllegalArgumentException - if the market data name, metadata or parameter split differs
      • plus

        public UnitParameterSensitivity plus​(UnitParameterSensitivity 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 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:
        java.lang.IllegalArgumentException - if the market data name, metadata or parameter split differs
      • split

        public com.google.common.collect.ImmutableList<UnitParameterSensitivity> 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 double total()
        Returns the total of the sensitivity values.
        Returns:
        the total sensitivity values
      • 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 com.google.common.collect.ImmutableList<ParameterMetadata> getParameterMetadata()
        Gets the list of parameter metadata.

        There is one entry for each parameter.

        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 java.util.Optional<java.util.List<ParameterSize>> getParameterSplit()
        Gets the split of parameters between the underlying parameterized data.

        A single UnitParameterSensitivity 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. This list is present, it represents how to split this sensitivity between the underlying instances.

        Returns:
        the optional value of the property, not null
      • equals

        public boolean equals​(java.lang.Object obj)
        Overrides:
        equals in class java.lang.Object
      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class java.lang.Object
      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object