/**
* Copyright (C) 2012 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.analytics.financial.provider.sensitivity.multicurve;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.apache.commons.lang.ObjectUtils;
import com.opengamma.analytics.financial.forex.method.FXMatrix;
import com.opengamma.analytics.math.matrix.DoubleMatrix1D;
import com.opengamma.analytics.math.matrix.MatrixAlgebra;
import com.opengamma.analytics.math.matrix.MatrixAlgebraFactory;
import com.opengamma.util.ArgumentChecker;
import com.opengamma.util.money.Currency;
import com.opengamma.util.tuple.ObjectsPair;
import com.opengamma.util.tuple.Pair;
/**
* Class containing the sensitivity of the present value to specific parameters or market quotes and methods for manipulating these data.
* The vector of sensitivities is stored with reference to a curve name and currency pair, with the sensitivity amounts assumed to be in the currency of the pair.
*/
public class MultipleCurrencyParameterSensitivity {
/**
* The map containing the sensitivity. The map links a pair of curve name and currency to a vector of sensitivities (sensitivities to parameters/inputs).
* The sensitivity is expressed in the currency of the pair.
*/
private final LinkedHashMap<Pair<String, Currency>, DoubleMatrix1D> _sensitivity;
/**
* Default constructor, creating an empty LinkedHashMap for the sensitivity.
*/
public MultipleCurrencyParameterSensitivity() {
_sensitivity = new LinkedHashMap<>();
}
/**
* Constructor taking a map. A new map is created.
* @param sensitivity The map with the sensitivities, not null. The map is copied.
*/
public MultipleCurrencyParameterSensitivity(final LinkedHashMap<Pair<String, Currency>, DoubleMatrix1D> sensitivity) {
ArgumentChecker.notNull(sensitivity, "sensitivity");
_sensitivity = new LinkedHashMap<>(sensitivity);
}
/**
* Static constructor from a map. A new map is created.
* @param sensitivity A map of name / currency pairs to vector of sensitivities, not null
* @return An new instance of ParameterSensitivity
*/
public static MultipleCurrencyParameterSensitivity of(final LinkedHashMap<Pair<String, Currency>, DoubleMatrix1D> sensitivity) {
ArgumentChecker.notNull(sensitivity, "sensitivity");
return new MultipleCurrencyParameterSensitivity(sensitivity);
}
/**
* Constructor from a simple sensitivity and a currency.
* @param single The Simple parameter sensitivity
* @param ccy The currency.
* @return The multiple currency sensitivity.
*/
public static MultipleCurrencyParameterSensitivity of(final SimpleParameterSensitivity single, final Currency ccy) {
final LinkedHashMap<Pair<String, Currency>, DoubleMatrix1D> sensi = new LinkedHashMap<>();
for (final String name : single.getAllNames()) {
sensi.put(new ObjectsPair<>(name, ccy), single.getSensitivity(name));
}
return MultipleCurrencyParameterSensitivity.of(sensi);
}
/**
* Create a copy of the sensitivity and add a given named sensitivity to it. If the name / currency pair is in the map, the two sensitivity matrices are added.
* Otherwise, a new entry is put into the map
* @param nameCcy The name and the currency, not null
* @param sensitivity The sensitivity to add, not null
* @return The total sensitivity.
*/
public MultipleCurrencyParameterSensitivity plus(final Pair<String, Currency> nameCcy, final DoubleMatrix1D sensitivity) {
ArgumentChecker.notNull(nameCcy, "Name/currency");
ArgumentChecker.notNull(sensitivity, "Matrix");
final MatrixAlgebra algebra = MatrixAlgebraFactory.COMMONS_ALGEBRA;
final LinkedHashMap<Pair<String, Currency>, DoubleMatrix1D> result = new LinkedHashMap<>();
result.putAll(_sensitivity);
if (result.containsKey(nameCcy)) {
result.put(nameCcy, (DoubleMatrix1D) algebra.add(result.get(nameCcy), sensitivity));
} else {
result.put(nameCcy, sensitivity);
}
return new MultipleCurrencyParameterSensitivity(result);
}
/**
* Create a copy of the sensitivity and add a given sensitivity to it.
* @param other The sensitivity to add.
* @return The total sensitivity.
*/
public MultipleCurrencyParameterSensitivity plus(final MultipleCurrencyParameterSensitivity other) {
ArgumentChecker.notNull(other, "Sensitivity to add");
final MatrixAlgebra algebra = MatrixAlgebraFactory.COMMONS_ALGEBRA;
final LinkedHashMap<Pair<String, Currency>, DoubleMatrix1D> result = new LinkedHashMap<>();
result.putAll(_sensitivity);
for (final Map.Entry<Pair<String, Currency>, DoubleMatrix1D> entry : other.getSensitivities().entrySet()) {
final Pair<String, Currency> nameCcy = entry.getKey();
if (result.containsKey(nameCcy)) {
result.put(nameCcy, (DoubleMatrix1D) algebra.add(result.get(nameCcy), entry.getValue()));
} else {
result.put(nameCcy, entry.getValue());
}
}
return new MultipleCurrencyParameterSensitivity(result);
}
/**
* Create a copy of the object with all the sensitivities multiplied by a common factor.
* @param factor The factor.
* @return The multiplied sensitivity.
*/
public MultipleCurrencyParameterSensitivity multipliedBy(final double factor) {
final MatrixAlgebra algebra = MatrixAlgebraFactory.COMMONS_ALGEBRA;
final LinkedHashMap<Pair<String, Currency>, DoubleMatrix1D> result = new LinkedHashMap<>();
for (final Pair<String, Currency> nameCcy : _sensitivity.keySet()) {
result.put(nameCcy, (DoubleMatrix1D) algebra.scale(_sensitivity.get(nameCcy), factor));
}
return new MultipleCurrencyParameterSensitivity(result);
}
/**
* Create a new parameter sensitivity with the new sensitivity with all the values in a common currency.
* @param fxMatrix The matrix with relevant exchange rates, not null
* @param ccy The currency in which the sensitivity is converted, not null
* @return The converted sensitivity.
*/
public MultipleCurrencyParameterSensitivity converted(final FXMatrix fxMatrix, final Currency ccy) {
ArgumentChecker.notNull(ccy, "Currency");
ArgumentChecker.notNull(fxMatrix, "FX Matrix");
MultipleCurrencyParameterSensitivity result = new MultipleCurrencyParameterSensitivity();
final MatrixAlgebra algebra = MatrixAlgebraFactory.COMMONS_ALGEBRA;
for (final Map.Entry<Pair<String, Currency>, DoubleMatrix1D> entry : _sensitivity.entrySet()) {
final Pair<String, Currency> nameCcy = entry.getKey();
final double fxRate = fxMatrix.getFxRate(nameCcy.getSecond(), ccy);
final Pair<String, Currency> nameCcyNew = Pair.of(nameCcy.getFirst(), ccy);
final DoubleMatrix1D sensitivityNew = (DoubleMatrix1D) algebra.scale(entry.getValue(), fxRate);
result = result.plus(nameCcyNew, sensitivityNew);
}
return result;
}
/**
* Returns the sensitivities wrapped in an unmodifiable map
* @return The sensitivities
*/
public Map<Pair<String, Currency>, DoubleMatrix1D> getSensitivities() {
return Collections.unmodifiableMap(_sensitivity);
}
/**
* Returns the sensitivity for a given name/currency pair.
* @param nameCcy The name and the currency, not null
* @return The sensitivity.
*/
public DoubleMatrix1D getSensitivity(final Pair<String, Currency> nameCcy) {
ArgumentChecker.notNull(nameCcy, "Name");
return _sensitivity.get(nameCcy);
}
/**
* Returns the sensitivity for a given name.
* @param name The name.
* @param ccy The currency.
* @return The sensitivity.
*/
public DoubleMatrix1D getSensitivity(final String name, final Currency ccy) {
ArgumentChecker.notNull(name, "Name");
ArgumentChecker.notNull(ccy, "Currency");
return _sensitivity.get(Pair.of(name, ccy));
}
/**
* Returns a map<Pair<String, Currency>, Double> with the total sensitivity with respect to each curve/currency.
* @return The map.
*/
public Map<Pair<String, Currency>, Double> totalSensitivityByCurveCurrency() {
final HashMap<Pair<String, Currency>, Double> s = new HashMap<>();
for (final Entry<Pair<String, Currency>, DoubleMatrix1D> entry : _sensitivity.entrySet()) {
double total = 0.0;
for (int loopi = 0; loopi < entry.getValue().getNumberOfElements(); loopi++) {
total += entry.getValue().getEntry(loopi);
}
s.put(entry.getKey(), total);
}
return s;
}
/**
* Returns the total sensitivity to all curves, in a given currency.
* @param fxMatrix The FX matrix will the exchange rates.
* @param ccy The currency for the conversion.
* @return The sensitivity.
*/
public double totalSensitivity(final FXMatrix fxMatrix, final Currency ccy) {
double total = 0.0;
for (final Entry<Pair<String, Currency>, DoubleMatrix1D> entry : _sensitivity.entrySet()) {
final double fx = fxMatrix.getFxRate(entry.getKey().getSecond(), ccy);
for (int loopi = 0; loopi < entry.getValue().getNumberOfElements(); loopi++) {
total += entry.getValue().getEntry(loopi) * fx;
}
}
return total;
}
/**
* Returns a set with all the curve names.
* @return The set of names.
*/
public Set<Pair<String, Currency>> getAllNamesCurrency() {
return _sensitivity.keySet();
}
@Override
public String toString() {
return _sensitivity.toString();
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + _sensitivity.hashCode();
return result;
}
@Override
public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof MultipleCurrencyParameterSensitivity)) {
return false;
}
final MultipleCurrencyParameterSensitivity other = (MultipleCurrencyParameterSensitivity) obj;
if (!ObjectUtils.equals(_sensitivity, other._sensitivity)) {
return false;
}
return true;
}
}