Java tutorial
/** * Copyright (C) 2015 - present by OpenGamma Inc. and the OpenGamma group of companies * * Please see distribution for license. */ package com.opengamma.strata.market.sensitivity; import java.io.Serializable; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Map; import java.util.NoSuchElementException; import java.util.Set; import java.util.function.DoubleUnaryOperator; import java.util.stream.Collectors; import org.joda.beans.Bean; import org.joda.beans.BeanBuilder; import org.joda.beans.BeanDefinition; import org.joda.beans.ImmutableBean; import org.joda.beans.JodaBeanUtils; import org.joda.beans.MetaProperty; import org.joda.beans.Property; import org.joda.beans.PropertyDefinition; import org.joda.beans.impl.direct.DirectFieldsBeanBuilder; import org.joda.beans.impl.direct.DirectMetaBean; import org.joda.beans.impl.direct.DirectMetaProperty; import org.joda.beans.impl.direct.DirectMetaPropertyMap; import com.google.common.collect.ImmutableList; import com.opengamma.strata.basics.currency.Currency; import com.opengamma.strata.basics.currency.FxConvertible; import com.opengamma.strata.basics.currency.FxRateProvider; import com.opengamma.strata.collect.Guavate; /** * A collection of point sensitivities. * <p> * Contains a list of {@linkplain PointSensitivity point sensitivity} objects, * each referring to a specific point on a curve that was queried. * The order of the list has no specific meaning, but does allow duplicates. * <p> * For example, the point sensitivity for present value on a FRA might contain * two entries, one for the Ibor forward curve and one for the discount curve. * Each entry identifies the date that the curve was queried and the resulting multiplier. * <p> * When creating an instance, consider using {@link MutablePointSensitivities}. * <p> * One way of viewing this class is as a {@code Map} from a specific sensitivity * key to a {@code double} sensitivity value. However, instead or being structured * as a {@code Map}, the data is structured as a {@code List}, with the key and * value in each entry. */ @BeanDefinition(builderScope = "private") public final class PointSensitivities implements FxConvertible<PointSensitivities>, ImmutableBean, Serializable { /** * An empty instance. */ private static final PointSensitivities EMPTY = new PointSensitivities(ImmutableList.of()); /** * The point sensitivities. * <p> * Each entry includes details of the market data query it relates to. */ @PropertyDefinition(validate = "notNull") private final ImmutableList<PointSensitivity> sensitivities; //------------------------------------------------------------------------- /** * An empty sensitivity instance. * * @return the empty instance */ public static PointSensitivities empty() { return EMPTY; } /** * Obtains an instance from an array of sensitivity entries. * * @param sensitivity the sensitivity entry * @return the sensitivities instance */ public static PointSensitivities of(PointSensitivity... sensitivity) { return PointSensitivities.of(ImmutableList.copyOf(sensitivity)); } /** * Obtains an instance from a list of sensitivity entries. * * @param sensitivities the list of sensitivity entries * @return the sensitivities instance */ @SuppressWarnings("unchecked") public static PointSensitivities of(List<? extends PointSensitivity> sensitivities) { return new PointSensitivities((List<PointSensitivity>) sensitivities); } //----------------------------------------------------------------------- /** * Gets the number of sensitivity entries. * * @return the size of the internal list of point sensitivities */ public int size() { return sensitivities.size(); } //------------------------------------------------------------------------- /** * Combines this point sensitivities with another instance. * <p> * This returns a new sensitivity instance with a combined list of point sensitivities. * This instance is immutable and unaffected by this method. * The result may contain duplicate point sensitivities. * * @param other the other point sensitivities * @return a {@code PointSensitivities} based on this one, with the other instance added */ public PointSensitivities combinedWith(PointSensitivities other) { return new PointSensitivities(ImmutableList.<PointSensitivity>builder().addAll(sensitivities) .addAll(other.sensitivities).build()); } //------------------------------------------------------------------------- /** * Multiplies the sensitivities in this instance by the specified factor. * <p> * The result will consist of the same entries, but with each sensitivity value multiplied. * This instance is immutable and unaffected by this method. * * @param factor the multiplicative factor * @return a {@code PointSensitivities} based on this one, with each sensitivity multiplied by the factor */ public PointSensitivities multipliedBy(double factor) { return mapSensitivities(s -> s * factor); } /** * Applies an operation to the sensitivities in this instance. * <p> * The result will consist of the same entries, but with the operator applied to each sensitivity value. * This instance is immutable and unaffected by this method. * <p> * This is used to apply a mathematical operation to the sensitivity values. * For example, the operator could multiply the sensitivities by a constant, or take the inverse. * <pre> * inverse = base.mapSensitivities(value -> 1 / value); * </pre> * * @param operator the operator to be applied to the sensitivities * @return a {@code PointSensitivities} based on this one, with the operator applied to the sensitivity values */ public PointSensitivities mapSensitivities(DoubleUnaryOperator operator) { return sensitivities.stream().map(s -> s.withSensitivity(operator.applyAsDouble(s.getSensitivity()))) .collect(Collectors.collectingAndThen(Guavate.toImmutableList(), PointSensitivities::new)); } /** * Normalizes the point sensitivities by sorting and merging. * <p> * The list of sensitivities is sorted and then merged. * Any two entries that represent the same curve query are merged. * For example, if there are two point sensitivities that were created based on the same curve, * currency and fixing date, then the entries are combined, summing the sensitivity value. * <p> * The intention is that normalization occurs after gathering all the point sensitivities. * <p> * This instance is immutable and unaffected by this method. * * @return a {@code PointSensitivities} based on this one, with the sensitivities normalized */ public PointSensitivities normalized() { if (sensitivities.isEmpty()) { return this; } List<PointSensitivity> mutable = new ArrayList<>(); for (PointSensitivity sensi : sensitivities) { insert(mutable, sensi); } return new PointSensitivities(mutable); } //----------------------------------------------------------------------- /** * Returns a mutable version of this object. * <p> * The result is an instance of the mutable {@link MutablePointSensitivities}. * It will contain the same individual sensitivity entries. * * @return the mutable sensitivity instance, not null */ public MutablePointSensitivities toMutable() { return new MutablePointSensitivities(sensitivities); } //------------------------------------------------------------------------- /** * Checks if this sensitivity equals another within the specified tolerance. * <p> * This returns true if the two instances have the list of {@code PointSensitivity}, * where the sensitivity {@code double} values are compared within the specified tolerance. * It is expected that this comparator will be used on the normalized version of the sensitivity. * * @param other the other sensitivity * @param tolerance the tolerance * @return true if equal up to the tolerance */ public boolean equalWithTolerance(PointSensitivities other, double tolerance) { ImmutableList<PointSensitivity> list1 = this.getSensitivities(); ImmutableList<PointSensitivity> list2 = other.getSensitivities(); int nbList1 = list1.size(); int nbList2 = list2.size(); if (nbList1 != nbList2) { return false; } for (int i1 = 0; i1 < nbList1; i1++) { if (list1.get(i1).compareKey(list2.get(i1)) == 0) { if (Math.abs(list1.get(i1).getSensitivity() - list2.get(i1).getSensitivity()) > tolerance) { return false; } } else { return false; } } return true; } //------------------------------------------------------------------------- @Override public PointSensitivities convertedTo(Currency resultCurrency, FxRateProvider rateProvider) { List<PointSensitivity> mutable = new ArrayList<>(); for (PointSensitivity sensi : sensitivities) { insert(mutable, sensi.convertedTo(resultCurrency, rateProvider)); } return new PointSensitivities(mutable); } // inserts a sensitivity into the mutable list in the right location // merges the entry with an existing entry if the key matches private static void insert(List<PointSensitivity> mutable, PointSensitivity addition) { int index = Collections.binarySearch(mutable, addition, PointSensitivity::compareKey); if (index >= 0) { PointSensitivity base = mutable.get(index); double combined = base.getSensitivity() + addition.getSensitivity(); mutable.set(index, base.withSensitivity(combined)); } else { int insertionPoint = -(index + 1); mutable.add(insertionPoint, addition); } } //------------------------- AUTOGENERATED START ------------------------- ///CLOVER:OFF /** * The meta-bean for {@code PointSensitivities}. * @return the meta-bean, not null */ public static PointSensitivities.Meta meta() { return PointSensitivities.Meta.INSTANCE; } static { JodaBeanUtils.registerMetaBean(PointSensitivities.Meta.INSTANCE); } /** * The serialization version id. */ private static final long serialVersionUID = 1L; private PointSensitivities(List<PointSensitivity> sensitivities) { JodaBeanUtils.notNull(sensitivities, "sensitivities"); this.sensitivities = ImmutableList.copyOf(sensitivities); } @Override public PointSensitivities.Meta metaBean() { return PointSensitivities.Meta.INSTANCE; } @Override public <R> Property<R> property(String propertyName) { return metaBean().<R>metaProperty(propertyName).createProperty(this); } @Override public Set<String> propertyNames() { return metaBean().metaPropertyMap().keySet(); } //----------------------------------------------------------------------- /** * Gets the point sensitivities. * <p> * Each entry includes details of the market data query it relates to. * @return the value of the property, not null */ public ImmutableList<PointSensitivity> getSensitivities() { return sensitivities; } //----------------------------------------------------------------------- @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (obj != null && obj.getClass() == this.getClass()) { PointSensitivities other = (PointSensitivities) obj; return JodaBeanUtils.equal(sensitivities, other.sensitivities); } return false; } @Override public int hashCode() { int hash = getClass().hashCode(); hash = hash * 31 + JodaBeanUtils.hashCode(sensitivities); return hash; } @Override public String toString() { StringBuilder buf = new StringBuilder(64); buf.append("PointSensitivities{"); buf.append("sensitivities").append('=').append(JodaBeanUtils.toString(sensitivities)); buf.append('}'); return buf.toString(); } //----------------------------------------------------------------------- /** * The meta-bean for {@code PointSensitivities}. */ public static final class Meta extends DirectMetaBean { /** * The singleton instance of the meta-bean. */ static final Meta INSTANCE = new Meta(); /** * The meta-property for the {@code sensitivities} property. */ @SuppressWarnings({ "unchecked", "rawtypes" }) private final MetaProperty<ImmutableList<PointSensitivity>> sensitivities = DirectMetaProperty .ofImmutable(this, "sensitivities", PointSensitivities.class, (Class) ImmutableList.class); /** * The meta-properties. */ private final Map<String, MetaProperty<?>> metaPropertyMap$ = new DirectMetaPropertyMap(this, null, "sensitivities"); /** * Restricted constructor. */ private Meta() { } @Override protected MetaProperty<?> metaPropertyGet(String propertyName) { switch (propertyName.hashCode()) { case 1226228605: // sensitivities return sensitivities; } return super.metaPropertyGet(propertyName); } @Override public BeanBuilder<? extends PointSensitivities> builder() { return new PointSensitivities.Builder(); } @Override public Class<? extends PointSensitivities> beanType() { return PointSensitivities.class; } @Override public Map<String, MetaProperty<?>> metaPropertyMap() { return metaPropertyMap$; } //----------------------------------------------------------------------- /** * The meta-property for the {@code sensitivities} property. * @return the meta-property, not null */ public MetaProperty<ImmutableList<PointSensitivity>> sensitivities() { return sensitivities; } //----------------------------------------------------------------------- @Override protected Object propertyGet(Bean bean, String propertyName, boolean quiet) { switch (propertyName.hashCode()) { case 1226228605: // sensitivities return ((PointSensitivities) bean).getSensitivities(); } return super.propertyGet(bean, propertyName, quiet); } @Override protected void propertySet(Bean bean, String propertyName, Object newValue, boolean quiet) { metaProperty(propertyName); if (quiet) { return; } throw new UnsupportedOperationException("Property cannot be written: " + propertyName); } } //----------------------------------------------------------------------- /** * The bean-builder for {@code PointSensitivities}. */ private static final class Builder extends DirectFieldsBeanBuilder<PointSensitivities> { private List<PointSensitivity> sensitivities = ImmutableList.of(); /** * Restricted constructor. */ private Builder() { } //----------------------------------------------------------------------- @Override public Object get(String propertyName) { switch (propertyName.hashCode()) { case 1226228605: // sensitivities return sensitivities; default: throw new NoSuchElementException("Unknown property: " + propertyName); } } @SuppressWarnings("unchecked") @Override public Builder set(String propertyName, Object newValue) { switch (propertyName.hashCode()) { case 1226228605: // sensitivities this.sensitivities = (List<PointSensitivity>) newValue; break; default: throw new NoSuchElementException("Unknown property: " + propertyName); } return this; } @Override public Builder set(MetaProperty<?> property, Object value) { super.set(property, value); return this; } @Override public Builder setString(String propertyName, String value) { setString(meta().metaProperty(propertyName), value); return this; } @Override public Builder setString(MetaProperty<?> property, String value) { super.setString(property, value); return this; } @Override public Builder setAll(Map<String, ? extends Object> propertyValueMap) { super.setAll(propertyValueMap); return this; } @Override public PointSensitivities build() { return new PointSensitivities(sensitivities); } //----------------------------------------------------------------------- @Override public String toString() { StringBuilder buf = new StringBuilder(64); buf.append("PointSensitivities.Builder{"); buf.append("sensitivities").append('=').append(JodaBeanUtils.toString(sensitivities)); buf.append('}'); return buf.toString(); } } ///CLOVER:ON //-------------------------- AUTOGENERATED END -------------------------- }