@Override
public Set<ComputedValue> execute(
final FunctionExecutionContext executionContext,
final FunctionInputs inputs,
final ComputationTarget target,
final Set<ValueRequirement> desiredValues) {
final Object positionOrNode = getTarget(target);
final ConventionBundleSource conventionSource =
OpenGammaExecutionContext.getConventionBundleSource(executionContext);
final ConventionBundle bundle =
conventionSource.getConventionBundle(
ExternalId.of(InMemoryConventionBundleMaster.SIMPLE_NAME_SCHEME, "USD_CAPM"));
final Clock snapshotClock = executionContext.getValuationClock();
final LocalDate now = snapshotClock.zonedDateTime().toLocalDate();
final ValueRequirement desiredValue = desiredValues.iterator().next();
final ValueProperties constraints = desiredValue.getConstraints();
final Period samplingPeriod =
getSamplingPeriod(constraints.getValues(ValuePropertyNames.SAMPLING_PERIOD));
final LocalDate startDate = now.minus(samplingPeriod);
final HistoricalTimeSeries riskFreeRateTSObject =
(HistoricalTimeSeries) inputs.getValue(ValueRequirementNames.HISTORICAL_TIME_SERIES);
final Object assetPnLObject =
inputs.getValue(
new ValueRequirement(
ValueRequirementNames.PNL_SERIES,
positionOrNode)); // TODO replace with return series when portfolio weights are in
if (assetPnLObject == null) {
throw new OpenGammaRuntimeException("Asset P&L was null");
}
final Object assetFairValueObject =
inputs.getValue(new ValueRequirement(ValueRequirementNames.FAIR_VALUE, positionOrNode));
if (assetFairValueObject == null) {
throw new OpenGammaRuntimeException("Asset fair value was null");
}
final Object betaObject =
inputs.getValue(new ValueRequirement(ValueRequirementNames.CAPM_BETA, positionOrNode));
if (betaObject == null) {
throw new OpenGammaRuntimeException("Beta was null");
}
final double beta = (Double) betaObject;
final double fairValue = (Double) assetFairValueObject;
DoubleTimeSeries<?> assetReturnTS = ((DoubleTimeSeries<?>) assetPnLObject).divide(fairValue);
DoubleTimeSeries<?> riskFreeReturnTS =
riskFreeRateTSObject.getTimeSeries().divide(100 * DAYS_PER_YEAR);
DoubleTimeSeries<?>[] series = TimeSeriesIntersector.intersect(riskFreeReturnTS, assetReturnTS);
riskFreeReturnTS = series[0];
assetReturnTS = series[1];
final TreynorRatioCalculator calculator =
getCalculator(constraints.getValues(ValuePropertyNames.EXCESS_RETURN_CALCULATOR));
final double ratio = calculator.evaluate(assetReturnTS, riskFreeReturnTS, beta);
final ValueProperties resultProperties = getResultProperties(desiredValues.iterator().next());
return Sets.newHashSet(
new ComputedValue(
new ValueSpecification(
new ValueRequirement(
ValueRequirementNames.TREYNOR_RATIO, positionOrNode, resultProperties),
getUniqueId()),
ratio));
}
@Override
public Set<ValueRequirement> getRequirements(
final FunctionCompilationContext context,
final ComputationTarget target,
final ValueRequirement desiredValue) {
final Set<String> curves = desiredValue.getConstraints().getValues(ValuePropertyNames.CURVE);
final Set<String> curveCalcConfigs =
desiredValue.getConstraints().getValues(ValuePropertyNames.CURVE_CALCULATION_CONFIG);
if ((curves == null) || (curves.size() != 1)) {
s_logger.warn("no curve specified");
// Can't support an unbound request; an injection function must be used (or declare all as
// optional and use [PLAT-1771])
return null;
}
if ((curveCalcConfigs == null) || (curveCalcConfigs.size() != 1)) {
s_logger.warn("no curve config specified");
return null;
}
final String curve = curves.iterator().next();
final String curveCalcConfig = curveCalcConfigs.iterator().next();
final Set<ValueRequirement> requirements = Sets.newHashSet();
requirements.add(getCurveRequirement(target, curve, curveCalcConfig));
requirements.add(getCurveSpecRequirement(target, curve));
requirements.addAll(
getSensitivityRequirements(
context.getSecuritySource(), (RawSecurity) target.getSecurity()));
return requirements;
}
@Override
public Set<ValueRequirement> getRequirements(
final FunctionCompilationContext context,
final ComputationTarget target,
final ValueRequirement desiredValue) {
Set<String> values =
desiredValue.getConstraints().getValues(HistoricalTimeSeriesFunctionUtils.ADJUST_PROPERTY);
if ((values == null) || values.isEmpty()) {
return Collections.singleton(
new ValueRequirement(
ValueRequirementNames.HISTORICAL_TIME_SERIES_LATEST,
target.toSpecification(),
desiredValue
.getConstraints()
.copy()
.withoutAny(HistoricalTimeSeriesFunctionUtils.ADJUST_PROPERTY)
.with(HistoricalTimeSeriesFunctionUtils.ADJUST_PROPERTY, "")
.get()));
} else if (values.size() > 1) {
return Collections.singleton(
new ValueRequirement(
ValueRequirementNames.HISTORICAL_TIME_SERIES_LATEST,
target.toSpecification(),
desiredValue
.getConstraints()
.copy()
.withoutAny(HistoricalTimeSeriesFunctionUtils.ADJUST_PROPERTY)
.with(HistoricalTimeSeriesFunctionUtils.ADJUST_PROPERTY, values.iterator().next())
.get()));
}
return Collections.emptySet();
}
@Override
public Set<ValueRequirement> getRequirements(
final FunctionCompilationContext context,
final ComputationTarget target,
final ValueRequirement desiredValue) {
final ValueProperties constraints = desiredValue.getConstraints();
final Set<String> forwardCurveCalculationMethods =
constraints.getValues(CURVE_CALCULATION_METHOD);
if (forwardCurveCalculationMethods == null || forwardCurveCalculationMethods.size() != 1) {
return null;
}
final Set<String> surfaceNames = constraints.getValues(SURFACE);
if (surfaceNames == null || surfaceNames.size() != 1) {
return null;
}
final String surfaceName = surfaceNames.iterator().next();
final ValueRequirement forwardCurveRequirement =
getForwardCurveRequirement(target, desiredValue);
final ValueRequirement volatilitySurfaceRequirement =
getVolatilityDataRequirement(
target,
surfaceName,
getInstrumentType(),
getSurfaceQuoteType(),
getSurfaceQuoteUnits());
final ValueRequirement interpolatorRequirement =
getInterpolatorRequirement(target, desiredValue);
return Sets.newHashSet(
interpolatorRequirement, forwardCurveRequirement, volatilitySurfaceRequirement);
}
@Override
public Set<ValueRequirement> getRequirements(
final FunctionCompilationContext context,
final ComputationTarget target,
final ValueRequirement desiredValue) {
final ValueProperties constraints = desiredValue.getConstraints();
final Set<String> curveNames = constraints.getValues(CURVE);
if (curveNames == null || curveNames.size() != 1) {
return null;
}
final Set<String> curveExposureConfigs = constraints.getValues(CURVE_EXPOSURES);
if (curveExposureConfigs == null) {
return null;
}
final Set<String> curveType = constraints.getValues(PROPERTY_CURVE_TYPE);
if (curveType == null) {
return null;
}
if (super.getRequirements(context, target, desiredValue) == null) {
return null;
}
final Set<ValueRequirement> requirements = new HashSet<>();
final ValueProperties curveProperties = ValueProperties.with(CURVE, curveNames).get();
final ValueProperties properties =
ValueProperties.with(PROPERTY_CURVE_TYPE, curveType)
.with(CURVE_EXPOSURES, curveExposureConfigs)
.get();
requirements.add(
new ValueRequirement(
CURVE_DEFINITION, ComputationTargetSpecification.NULL, curveProperties));
requirements.add(
new ValueRequirement(BLOCK_CURVE_SENSITIVITIES, target.toSpecification(), properties));
return requirements;
}
@SuppressWarnings("unchecked")
@Override
public Set<ComputedValue> execute(
final FunctionExecutionContext executionContext,
final FunctionInputs inputs,
final ComputationTarget target,
final Set<ValueRequirement> desiredValues) {
final HistoricalTimeSeriesSource timeSeriesSource =
OpenGammaExecutionContext.getHistoricalTimeSeriesSource(executionContext);
final ValueRequirement desiredValue = desiredValues.iterator().next();
Object value = timeSeriesSource.getLatestDataPoint(target.getUniqueId());
if (value == null) {
value = MissingMarketDataSentinel.getInstance();
} else {
final String adjusterString =
desiredValue.getConstraint(HistoricalTimeSeriesFunctionUtils.ADJUST_PROPERTY);
final HistoricalTimeSeriesAdjustment htsa =
HistoricalTimeSeriesAdjustment.parse(adjusterString);
value = htsa.adjust(((Pair<LocalDate, Double>) value).getValue());
}
return Collections.singleton(
new ComputedValue(
new ValueSpecification(
desiredValue.getValueName(),
desiredValue.getTargetSpecification(),
desiredValue.getConstraints()),
value));
}
private static List<RequirementBasedColumnKey> getRequirements(
ViewDefinition viewDefinition, EnumSet<ComputationTargetType> targetTypes) {
List<RequirementBasedColumnKey> result = new ArrayList<RequirementBasedColumnKey>();
for (ViewCalculationConfiguration calcConfig :
viewDefinition.getAllCalculationConfigurations()) {
String calcConfigName = calcConfig.getName();
if (targetTypes.contains(ComputationTargetType.POSITION)
|| targetTypes.contains(ComputationTargetType.PORTFOLIO_NODE)) {
for (Pair<String, ValueProperties> portfolioOutput :
calcConfig.getAllPortfolioRequirements()) {
String valueName = portfolioOutput.getFirst();
ValueProperties constraints = portfolioOutput.getSecond();
RequirementBasedColumnKey columnKey =
new RequirementBasedColumnKey(calcConfigName, valueName, constraints);
result.add(columnKey);
}
}
for (ValueRequirement specificRequirement : calcConfig.getSpecificRequirements()) {
if (!targetTypes.contains(specificRequirement.getTargetSpecification().getType())) {
continue;
}
String valueName = specificRequirement.getValueName();
ValueProperties constraints = specificRequirement.getConstraints();
RequirementBasedColumnKey columnKey =
new RequirementBasedColumnKey(calcConfigName, valueName, constraints);
result.add(columnKey);
}
}
return result;
}
@Override
public Set<ComputedValue> execute(
final FunctionExecutionContext executionContext,
final FunctionInputs inputs,
final ComputationTarget target,
final Set<ValueRequirement> desiredValues) {
double parentValue = 0;
double targetValue = 0;
final UniqueId targetIdentifier = target.getUniqueId();
for (final ComputedValue c : inputs.getAllValues()) {
if (targetIdentifier.equals(c.getSpecification().getTargetSpecification().getUniqueId())) {
targetValue = (Double) c.getValue();
} else {
parentValue = (Double) c.getValue();
}
}
final ValueRequirement desiredValue = desiredValues.iterator().next();
return Collections.singleton(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.WEIGHT,
target.toSpecification(),
desiredValue.getConstraints()),
targetValue / parentValue));
}
@Override
public Set<ValueRequirement> getRequirements(
final FunctionCompilationContext context,
final ComputationTarget target,
final ValueRequirement desiredValue) {
final ValueProperties constraints = desiredValue.getConstraints();
Set<String> values = constraints.getValues(VALUE_PROPERTY_NAME);
final String inputValue;
if ((values == null) || values.isEmpty()) {
inputValue = DEFAULT_VALUE_NAME;
} else if (values.size() == 1) {
inputValue = values.iterator().next();
} else {
return null;
}
// Propogate the desired value constraints onto the requirements, removing those specific to
// this function and adding a unit homogeneity clause
final ValueProperties.Builder requirementConstraintsBuilder =
constraints.copy().withoutAny(VALUE_PROPERTY_NAME);
for (String unit : UnitProperties.unitPropertyNames()) {
values = constraints.getValues(unit);
if (values == null) {
// Unit was not specified on the output, but we specify it on the inputs so we can check
// homogeneity to ensure the division is valid
requirementConstraintsBuilder.withOptional(unit);
}
}
// Request value on the value and parent
final ValueProperties requirementConstraints = requirementConstraintsBuilder.get();
return ImmutableSet.of(
new ValueRequirement(inputValue, getValueTarget(target), requirementConstraints),
new ValueRequirement(inputValue, getParentTarget(target), requirementConstraints));
}
@Override
public Set<ValueRequirement> getRequirements(
final FunctionCompilationContext context,
final ComputationTarget target,
final ValueRequirement desiredValue) {
final ValueProperties constraints = desiredValue.getConstraints();
final Set<String> payCurveNames = constraints.getValues(ValuePropertyNames.PAY_CURVE);
if (payCurveNames == null || payCurveNames.size() != 1) {
return null;
}
final Set<String> receiveCurveNames = constraints.getValues(ValuePropertyNames.RECEIVE_CURVE);
if (receiveCurveNames == null || receiveCurveNames.size() != 1) {
return null;
}
final Set<String> payCurveConfigNames =
constraints.getValues(ValuePropertyNames.PAY_CURVE_CALCULATION_CONFIG);
if (payCurveConfigNames == null || payCurveConfigNames.size() != 1) {
return null;
}
final Set<String> receiveCurveConfigNames =
constraints.getValues(ValuePropertyNames.RECEIVE_CURVE_CALCULATION_CONFIG);
if (receiveCurveConfigNames == null || receiveCurveConfigNames.size() != 1) {
return null;
}
final Set<String> daysForwardNames = constraints.getValues(PROPERTY_DAYS_TO_MOVE_FORWARD);
if (daysForwardNames == null || daysForwardNames.size() != 1) {
return null;
}
final String payCurveName = payCurveNames.iterator().next();
final String receiveCurveName = receiveCurveNames.iterator().next();
final String payCurveCalculationConfig = payCurveConfigNames.iterator().next();
final String receiveCurveCalculationConfig = receiveCurveConfigNames.iterator().next();
final FinancialSecurity security = (FinancialSecurity) target.getSecurity();
final Currency payCurrency = security.accept(ForexVisitors.getPayCurrencyVisitor());
final Currency receiveCurrency = security.accept(ForexVisitors.getReceiveCurrencyVisitor());
final ValueRequirement payFundingCurve =
YieldCurveFunctionUtils.getCurveRequirementForFXForward(
ComputationTargetSpecification.of(payCurrency),
payCurveName,
payCurveCalculationConfig,
true);
final ValueRequirement receiveFundingCurve =
YieldCurveFunctionUtils.getCurveRequirementForFXForward(
ComputationTargetSpecification.of(receiveCurrency),
receiveCurveName,
receiveCurveCalculationConfig,
false);
final ValueProperties optionalProperties =
ValueProperties.builder()
.with(PROPERTY_DAYS_TO_MOVE_FORWARD, daysForwardNames)
.withOptional(PROPERTY_DAYS_TO_MOVE_FORWARD)
.get();
final ValueRequirement pairQuoteRequirement =
new ValueRequirement(
ValueRequirementNames.CURRENCY_PAIRS,
ComputationTargetSpecification.NULL,
optionalProperties);
return Sets.newHashSet(payFundingCurve, receiveFundingCurve, pairQuoteRequirement);
}
public Set<ValueRequirement> getRequirements(
final FunctionCompilationContext context,
final ComputationTarget target,
final ValueRequirement desiredValue) {
Set<ValueRequirement> superReqs = super.getRequirements(context, target, desiredValue);
if (superReqs == null) {
return null;
}
// Test constraints are provided, else set to ""
final ValueProperties constraints = desiredValue.getConstraints();
ValueProperties.Builder scenarioDefaults = null;
final Set<String> priceShiftSet = constraints.getValues(s_priceShift);
if (priceShiftSet == null || priceShiftSet.isEmpty()) {
scenarioDefaults = constraints.copy().withoutAny(s_priceShift).with(s_priceShift, "");
}
final Set<String> priceShiftTypeSet = constraints.getValues(s_priceShiftType);
if (priceShiftTypeSet == null || priceShiftTypeSet.isEmpty()) {
if (scenarioDefaults == null) {
scenarioDefaults =
constraints
.copy()
.withoutAny(s_priceShiftType)
.with(s_priceShiftType, "Multiplicative");
} else {
scenarioDefaults =
scenarioDefaults.withoutAny(s_priceShiftType).with(s_priceShiftType, "Multiplicative");
}
}
final Set<String> volShiftSet = constraints.getValues(s_volShift);
if (volShiftSet == null || volShiftSet.isEmpty()) {
if (scenarioDefaults == null) {
scenarioDefaults = constraints.copy().withoutAny(s_volShift).with(s_volShift, "");
} else {
scenarioDefaults = scenarioDefaults.withoutAny(s_volShift).with(s_volShift, "");
}
}
final Set<String> volShiftSetType = constraints.getValues(s_volShiftType);
if (volShiftSetType == null || volShiftSetType.isEmpty()) {
if (scenarioDefaults == null) {
scenarioDefaults =
constraints.copy().withoutAny(s_volShiftType).with(s_volShiftType, "Multiplicative");
} else {
scenarioDefaults =
scenarioDefaults.withoutAny(s_volShiftType).with(s_volShiftType, "Multiplicative");
}
}
// If defaults have been added, this adds additional copy of the Function into dep graph with
// the adjusted constraints
if (scenarioDefaults != null) {
return Collections.singleton(
new ValueRequirement(
getValueRequirementName(), target.toSpecification(), scenarioDefaults.get()));
} else { // Scenarios are defined, so we're satisfied
return superReqs;
}
}
@Override
public Set<ComputedValue> execute(
final FunctionExecutionContext executionContext,
final FunctionInputs inputs,
final ComputationTarget target,
final Set<ValueRequirement> desiredValues) {
String curveName = null;
String curveCalculationConfig = null;
for (final ValueRequirement requirement : desiredValues) {
final ValueProperties constraints = requirement.getConstraints();
final Set<String> values = constraints.getValues(ValuePropertyNames.CURVE);
if (values != null) {
curveName = values.iterator().next();
}
final Set<String> curveConfigValues =
constraints.getValues(ValuePropertyNames.CURVE_CALCULATION_CONFIG);
if (curveConfigValues != null) {
curveCalculationConfig = curveConfigValues.iterator().next();
}
}
assert curveName != null;
assert curveCalculationConfig != null;
final RawSecurity security = (RawSecurity) target.getSecurity();
// final BigDecimal qty = target.getPosition().getQuantity();
final ValueRequirement curveRequirement =
getCurveRequirement(target, curveName, curveCalculationConfig);
final Object curveObject = inputs.getValue(curveRequirement);
if (curveObject == null) {
throw new OpenGammaRuntimeException("Could not get " + curveRequirement);
}
Object curveSpecObject = null;
final ValueRequirement curveSpecRequirement = getCurveSpecRequirement(target, curveName);
curveSpecObject = inputs.getValue(curveSpecRequirement);
if (curveSpecObject == null) {
throw new OpenGammaRuntimeException("Could not get " + curveSpecRequirement);
}
final YieldAndDiscountCurve curve = (YieldAndDiscountCurve) curveObject;
final InterpolatedYieldCurveSpecificationWithSecurities curveSpec =
(InterpolatedYieldCurveSpecificationWithSecurities) curveSpecObject;
final LinkedHashMap<String, YieldAndDiscountCurve> interpolatedCurves =
new LinkedHashMap<String, YieldAndDiscountCurve>();
interpolatedCurves.put(curveName, curve);
final YieldCurveBundle bundle = new YieldCurveBundle(interpolatedCurves);
final DoubleMatrix1D sensitivitiesForCurves =
getSensitivities(executionContext.getSecuritySource(), inputs, security, curveSpec, curve);
final ValueProperties.Builder properties =
createValueProperties(target)
.with(ValuePropertyNames.CURVE, curveName)
.with(ValuePropertyNames.CURVE_CALCULATION_CONFIG, curveCalculationConfig);
final ComputationTargetSpecification targetSpec = target.toSpecification();
final ValueSpecification resultSpec =
new ValueSpecification(YCNS_REQUIREMENT, targetSpec, properties.get());
final Set<ComputedValue> results =
YieldCurveNodeSensitivitiesHelper.getInstrumentLabelledSensitivitiesForCurve(
curveName, bundle, sensitivitiesForCurves, curveSpec, resultSpec);
// s_logger.debug("execute, returning " + results);
return results;
}
/**
* Respecifies the properties to match a tighter requirement.
*
* <p>This adds a new requirement to the specification. It requires {@code
* requirement.isSatisfiedBy(this) == true}.
*
* @param requirement additional requirement to reduce properties against
* @return the value specification based on this with the additional requirement added, not null
*/
public ValueSpecification compose(final ValueRequirement requirement) {
assert requirement.isSatisfiedBy(this);
final ValueProperties oldProperties = getProperties();
final ValueProperties newProperties = oldProperties.compose(requirement.getConstraints());
if (newProperties == oldProperties) {
return this;
} else {
return new ValueSpecification(getValueName(), getTargetSpecification(), newProperties);
}
}
@Override
public Set<ValueRequirement> getRequirements(
final FunctionCompilationContext context,
final ComputationTarget target,
final ValueRequirement desiredValue) {
final ValueProperties constraints = desiredValue.getConstraints();
final Set<String> surfaceNames = constraints.getValues(ValuePropertyNames.SURFACE);
if (surfaceNames == null || surfaceNames.size() != 1) {
return null;
}
final Set<String> curveCalculationConfigNames =
constraints.getValues(ValuePropertyNames.CURVE_CALCULATION_CONFIG);
if (curveCalculationConfigNames == null || curveCalculationConfigNames.size() != 1) {
return null;
}
final String curveCalculationConfigName = curveCalculationConfigNames.iterator().next();
final ConfigSource configSource = OpenGammaCompilationContext.getConfigSource(context);
final ConfigDBCurveCalculationConfigSource curveCalculationConfigSource =
new ConfigDBCurveCalculationConfigSource(configSource);
final MultiCurveCalculationConfig curveCalculationConfig =
curveCalculationConfigSource.getConfig(curveCalculationConfigName);
if (curveCalculationConfig == null) {
s_logger.error(
"Could not find curve calculation configuration named " + curveCalculationConfigName);
return null;
}
final Currency currency = FinancialSecurityUtils.getCurrency(target.getSecurity());
if (!ComputationTargetSpecification.of(currency).equals(curveCalculationConfig.getTarget())) {
s_logger.error(
"Security currency and curve calculation config id were not equal; have {} and {}",
currency,
curveCalculationConfig.getTarget());
return null;
}
final String surfaceName = surfaceNames.iterator().next();
final Set<ValueRequirement> requirements = new HashSet<>();
requirements.addAll(
YieldCurveFunctionUtils.getCurveRequirements(
curveCalculationConfig, curveCalculationConfigSource));
requirements.add(getVolatilityRequirement(surfaceName, currency));
final FinancialSecurity security = (FinancialSecurity) target.getSecurity();
try {
final Set<ValueRequirement> timeSeriesRequirements =
_definitionConverter.getConversionTimeSeriesRequirements(
security, security.accept(_visitor));
if (timeSeriesRequirements == null) {
return null;
}
requirements.addAll(timeSeriesRequirements);
return requirements;
} catch (final Exception e) {
s_logger.error(e.getMessage());
return null;
}
}
@Override
public Set<ValueSpecification> getResults(
final FunctionCompilationContext context,
final ComputationTarget target,
final Map<ValueSpecification, ValueRequirement> inputs) {
if (inputs.size() == 1) {
final ValueSpecification input = Iterables.getOnlyElement(inputs.keySet());
if (ValueRequirementNames.PNL_SERIES.equals(input.getValueName())) {
return Collections.singleton(input);
}
}
final FXForwardSecurity security = (FXForwardSecurity) target.getPosition().getSecurity();
final CurrencyPair currencyPair =
_currencyPairs.getCurrencyPair(security.getPayCurrency(), security.getReceiveCurrency());
if (currencyPair == null) {
return null;
}
final Currency currencyBase = currencyPair.getBase();
String resultCurrency = null;
final ValueProperties.Builder builder = createValueProperties();
for (final Map.Entry<ValueSpecification, ValueRequirement> entry : inputs.entrySet()) {
final ValueSpecification inputSpec = entry.getKey();
final ValueRequirement inputReq = entry.getValue();
if (inputReq.getValueName().equals(RETURN_SERIES)) {
final Set<String> resultCurrencies = inputReq.getConstraints().getValues(CURRENCY);
if (resultCurrencies != null && resultCurrencies.size() == 1) {
resultCurrency = inputReq.getConstraint(CURRENCY);
} else {
resultCurrency = currencyBase.getCode();
}
}
for (final String propertyName : inputSpec.getProperties().getProperties()) {
if (ValuePropertyNames.FUNCTION.equals(propertyName)) {
continue;
}
final Set<String> values = inputSpec.getProperties().getValues(propertyName);
if (values == null || values.isEmpty()) {
builder.withAny(propertyName);
} else {
builder.with(propertyName, values);
}
}
}
if (resultCurrency == null) {
return null;
}
builder
.with(ValuePropertyNames.CURRENCY, resultCurrency)
.with(
ValuePropertyNames.PROPERTY_PNL_CONTRIBUTIONS,
ValueRequirementNames.FX_CURRENCY_EXPOSURE);
return ImmutableSet.of(
new ValueSpecification(
ValueRequirementNames.PNL_SERIES, target.toSpecification(), builder.get()));
}
@Override
public Set<ValueRequirement> getRequirements(
final FunctionCompilationContext context,
final ComputationTarget target,
final ValueRequirement desiredValue) {
final Set<String> daysForwardNames =
desiredValue.getConstraints().getValues(PROPERTY_DAYS_TO_MOVE_FORWARD);
if (daysForwardNames == null || daysForwardNames.size() != 1) {
return null;
}
return super.getRequirements(context, target, desiredValue);
}
/**
* Creates a new specification to satisfy the given requirement.
*
* <p>The properties must include the function identifier and be able to satisfy the constraints
* of the original requirement.
*
* @param requirementSpecification a requirement, not null
* @param properties the value properties, not null and must include the function identifier
*/
public ValueSpecification(
final ValueRequirement requirementSpecification, final ValueProperties properties) {
ArgumentChecker.notNull(requirementSpecification, "requirementSpecification");
ArgumentChecker.notNull(properties, "properties");
ArgumentChecker.notNull(
properties.getValues(ValuePropertyNames.FUNCTION), "properties.FUNCTION");
assert requirementSpecification.getConstraints().isSatisfiedBy(properties);
// requirement specification interns its valueName
_valueName = requirementSpecification.getValueName();
_targetSpecification = requirementSpecification.getTargetSpecification();
_properties = properties;
}
@Override
public Set<ValueRequirement> getRequirements(
final FunctionCompilationContext context,
final ComputationTarget target,
final ValueRequirement desiredValue) {
final Set<ValueRequirement> requirements = new HashSet<>();
final ValueProperties constraints = desiredValue.getConstraints();
// curve
final String curveName = constraints.getStrictValue(ValuePropertyNames.CURVE);
if (curveName == null) {
return null;
}
// interpolator
final String interpolatorName =
constraints.getStrictValue(
ForwardCurveValuePropertyNames.PROPERTY_FORWARD_CURVE_INTERPOLATOR);
if (interpolatorName == null) {
return null;
}
// interpolator left extrapolator
final String leftExtrapolatorName =
constraints.getStrictValue(
ForwardCurveValuePropertyNames.PROPERTY_FORWARD_CURVE_LEFT_EXTRAPOLATOR);
if (leftExtrapolatorName == null) {
return null;
}
// interpolator right extrapolator
final String rightExtrapolatorName =
constraints.getStrictValue(
ForwardCurveValuePropertyNames.PROPERTY_FORWARD_CURVE_RIGHT_EXTRAPOLATOR);
if (rightExtrapolatorName == null) {
return null;
}
final ValueProperties futureCurveProperties =
ValueProperties.builder()
.with(
InstrumentTypeProperties.PROPERTY_SURFACE_INSTRUMENT_TYPE,
InstrumentTypeProperties.EQUITY_FUTURE_PRICE)
.with(ValuePropertyNames.CURVE, curveName)
.get();
requirements.add(
new ValueRequirement(
ValueRequirementNames.FUTURE_PRICE_CURVE_DATA,
target.toSpecification(),
futureCurveProperties));
return requirements;
}
/**
* Simplifies the type based on the associated {@link ComputationTargetResolver}.
*
* @param valueReq the requirement to process, not null
* @return the possibly simplified requirement, not null
*/
public ValueRequirement simplifyType(final ValueRequirement valueReq) {
final ComputationTargetReference oldTargetRef = valueReq.getTargetReference();
final ComputationTargetReference newTargetRef =
ComputationTargetResolverUtils.simplifyType(
oldTargetRef, getCompilationContext().getComputationTargetResolver());
if (newTargetRef == oldTargetRef) {
return valueReq;
} else {
return MemoryUtils.instance(
new ValueRequirement(valueReq.getValueName(), newTargetRef, valueReq.getConstraints()));
}
}
@Override
public Set<ValueRequirement> getRequirements(
final FunctionCompilationContext context,
final ComputationTarget target,
final ValueRequirement desiredValue) {
final Set<String> curveNames =
desiredValue.getConstraints().getValues(ValuePropertyNames.CURVE);
if (curveNames == null || curveNames.size() != 1) {
return null;
}
final String curveName = Iterables.getOnlyElement(curveNames);
final Set<String> curveCalculationConfigNames =
desiredValue.getConstraints().getValues(ValuePropertyNames.CURVE_CALCULATION_CONFIG);
if (curveCalculationConfigNames == null || curveCalculationConfigNames.size() != 1) {
return null;
}
final String curveCalculationConfigName = Iterables.getOnlyElement(curveCalculationConfigNames);
final EquityVarianceSwapSecurity security = (EquityVarianceSwapSecurity) target.getSecurity();
return Sets.newHashSet(
getSpotRequirement(security),
getDiscountRequirement(security, curveName, curveCalculationConfigName));
}
@Override
public Set<ValueRequirement> getRequirements(
final FunctionCompilationContext context,
final ComputationTarget target,
final ValueRequirement desiredValue) {
final Set<ValueRequirement> requirements = super.getRequirements(context, target, desiredValue);
if (requirements == null) {
return null;
}
requirements.add(
new ValueRequirement(
ValueRequirementNames.GAMMA, target.toSpecification(), desiredValue.getConstraints()));
return requirements;
}
/**
* Creates a new specification to satisfy the the given requirement.
*
* <p>The properties of the new specification are the constraints from the requirement with the
* function identifier added.
*
* @param requirementSpecification a value requirement, not null
* @param functionIdentifier the unique identifier of the function producing this value, not null
*/
public ValueSpecification(
final ValueRequirement requirementSpecification, final String functionIdentifier) {
ArgumentChecker.notNull(requirementSpecification, "requirementSpecification");
ArgumentChecker.notNull(functionIdentifier, "functionIdentifier");
// requirement specification interns its valueName
_valueName = requirementSpecification.getValueName();
_targetSpecification = requirementSpecification.getTargetSpecification();
_properties =
requirementSpecification
.getConstraints()
.copy()
.with(ValuePropertyNames.FUNCTION, functionIdentifier)
.get();
}
@Override
public Set<ValueRequirement> getRequirements(
final FunctionCompilationContext context,
final ComputationTarget target,
final ValueRequirement desiredValue) {
final ValueProperties constraints = desiredValue.getConstraints();
final Set<String> forwardCurveNames =
constraints.getValues(YieldCurveFunction.PROPERTY_FORWARD_CURVE);
if (forwardCurveNames == null || forwardCurveNames.size() != 1) {
return null;
}
final Set<String> fundingCurveNames =
constraints.getValues(YieldCurveFunction.PROPERTY_FUNDING_CURVE);
if (fundingCurveNames == null || fundingCurveNames.size() != 1) {
return null;
}
final Set<String> surfaceNames = constraints.getValues(ValuePropertyNames.SURFACE);
if (surfaceNames == null || surfaceNames.size() != 1) {
return null;
}
final Set<String> curveCalculationMethods =
constraints.getValues(ValuePropertyNames.CURVE_CALCULATION_METHOD);
if (curveCalculationMethods == null || curveCalculationMethods.size() != 1) {
return null;
}
final String forwardCurveName = forwardCurveNames.iterator().next();
final String fundingCurveName = fundingCurveNames.iterator().next();
final String surfaceName = surfaceNames.iterator().next();
final String curveCalculationMethod = curveCalculationMethods.iterator().next();
final Set<ValueRequirement> requirements = Sets.newHashSetWithExpectedSize(4);
final Currency currency = FinancialSecurityUtils.getCurrency(target.getSecurity());
requirements.add(
getCurveRequirement(
forwardCurveName,
forwardCurveName,
fundingCurveName,
curveCalculationMethod,
currency));
requirements.add(
getCurveRequirement(
fundingCurveName,
forwardCurveName,
fundingCurveName,
curveCalculationMethod,
currency));
requirements.add(getVolatilityRequirement(surfaceName, currency));
return requirements;
}
@Override
public ComputedValue getComputedValue(final ValueRequirement requirement) {
final Pair<String, Object> key =
Pair.of(
requirement.getValueName(),
targetSpecKey(_resolver.getTargetSpecification(requirement.getTargetReference())));
final ComputedValue[] values = _valuesByRequirement.get(key);
if (values != null) {
for (final ComputedValue value : values) {
// Shortcut to check the properties as we already know the name and target match
if (requirement.getConstraints().isSatisfiedBy(value.getSpecification().getProperties())) {
return value;
}
}
}
return null;
}
@Override
public Set<ValueRequirement> getRequirements(
final FunctionCompilationContext context,
final ComputationTarget target,
final ValueRequirement desiredValue) {
final ValueProperties constraints = desiredValue.getConstraints();
final Set<String> curveCalculationConfigNames =
constraints.getValues(ValuePropertyNames.CURVE_CALCULATION_CONFIG);
if (curveCalculationConfigNames == null || curveCalculationConfigNames.size() != 1) {
return null;
}
final String curveCalculationConfigName = curveCalculationConfigNames.iterator().next();
final ConfigSource configSource = OpenGammaCompilationContext.getConfigSource(context);
final ConfigDBCurveCalculationConfigSource curveCalculationConfigSource =
new ConfigDBCurveCalculationConfigSource(configSource);
final MultiCurveCalculationConfig curveCalculationConfig =
curveCalculationConfigSource.getConfig(curveCalculationConfigName);
if (curveCalculationConfig == null) {
s_logger.error(
"Could not find curve calculation configuration named " + curveCalculationConfigName);
return null;
}
final FinancialSecurity security = (FinancialSecurity) target.getSecurity();
final Currency currency = FinancialSecurityUtils.getCurrency(security);
if (!currency.equals(curveCalculationConfig.getUniqueId())) {
s_logger.error(
"Security currency and curve calculation config id were not equal; have {} and {}",
currency,
curveCalculationConfig.getUniqueId());
}
final Set<ValueRequirement> requirements = new HashSet<ValueRequirement>();
requirements.addAll(
YieldCurveFunctionUtils.getCurveRequirements(
curveCalculationConfig, curveCalculationConfigSource));
final Set<ValueRequirement> timeSeriesRequirements =
getDerivativeTimeSeriesRequirements(
security, security.accept(_visitor), _definitionConverter);
if (timeSeriesRequirements == null) {
return null;
}
requirements.addAll(timeSeriesRequirements);
return requirements;
}
@Override
public Set<ValueRequirement> getRequirements(
final FunctionCompilationContext compilationContext,
final ComputationTarget target,
final ValueRequirement desiredValue) {
final ValueProperties constraints = desiredValue.getConstraints();
final Set<String> rootFinderAbsoluteTolerance =
constraints.getValues(PROPERTY_ROOT_FINDER_ABSOLUTE_TOLERANCE);
if (rootFinderAbsoluteTolerance == null || rootFinderAbsoluteTolerance.size() != 1) {
return null;
}
final Set<String> rootFinderRelativeTolerance =
constraints.getValues(PROPERTY_ROOT_FINDER_RELATIVE_TOLERANCE);
if (rootFinderRelativeTolerance == null || rootFinderRelativeTolerance.size() != 1) {
return null;
}
final Set<String> maxIterations = constraints.getValues(PROPERTY_ROOT_FINDER_MAX_ITERATIONS);
if (maxIterations == null || maxIterations.size() != 1) {
return null;
}
final Set<String> decomposition = constraints.getValues(PROPERTY_DECOMPOSITION);
if (decomposition == null || decomposition.size() != 1) {
return null;
}
final Set<String> useFiniteDifference = constraints.getValues(PROPERTY_USE_FINITE_DIFFERENCE);
if (useFiniteDifference == null || useFiniteDifference.size() != 1) {
return null;
}
if (!_originalConfiguration.getTarget().equals(target.toSpecification())) {
s_logger.info(
"Invalid target, was {} - expected {}", target, _originalConfiguration.getTarget());
return null;
}
final ValueProperties properties =
ValueProperties.builder()
.with(CURVE_CALCULATION_METHOD, _originalConfiguration.getCalculationMethod())
.with(CURVE_CALCULATION_CONFIG, _originalConfiguration.getCalculationConfigName())
.with(CURVE, _originalCurveName)
.get();
return Collections.singleton(
new ValueRequirement(YIELD_CURVE, target.toSpecification(), properties));
}
@Override
public Set<ValueRequirement> getRequirements(
final FunctionCompilationContext context,
final ComputationTarget target,
final ValueRequirement desiredValue) {
final Set<ValueRequirement> requirements = super.getRequirements(context, target, desiredValue);
if (requirements == null) {
return null;
}
final ValueProperties constraints = desiredValue.getConstraints();
final Set<String> cutoffNames =
constraints.getValues(SABRRightExtrapolationFunction.PROPERTY_CUTOFF_STRIKE);
if (cutoffNames == null || cutoffNames.size() != 1) {
return null;
}
final Set<String> muNames =
constraints.getValues(SABRRightExtrapolationFunction.PROPERTY_TAIL_THICKNESS_PARAMETER);
if (muNames == null || muNames.size() != 1) {
return null;
}
return requirements;
}
@Override
public Set<ComputedValue> execute(
final FunctionExecutionContext context,
final FunctionInputs inputs,
final ComputationTarget target,
final Set<ValueRequirement> desiredValues)
throws AsynchronousExecution {
final MultipleCurrencyParameterSensitivity sensitivities =
(MultipleCurrencyParameterSensitivity) inputs.getValue(BLOCK_CURVE_SENSITIVITIES);
final ValueRequirement desiredValue = desiredValues.iterator().next();
final ValueProperties properties = desiredValue.getConstraints();
final String desiredCurveName = desiredValue.getConstraint(CURVE);
final Map<Pair<String, Currency>, DoubleMatrix1D> entries = sensitivities.getSensitivities();
final Set<ComputedValue> results = new HashSet<>();
for (final Map.Entry<Pair<String, Currency>, DoubleMatrix1D> entry : entries.entrySet()) {
final String curveName = entry.getKey().getFirst();
if (desiredCurveName.equals(curveName)) {
final ValueProperties curveSpecificProperties =
properties.copy().withoutAny(CURVE).with(CURVE, curveName).get();
final CurveDefinition curveDefinition =
(CurveDefinition)
inputs.getValue(
new ValueRequirement(
CURVE_DEFINITION,
ComputationTargetSpecification.NULL,
ValueProperties.builder().with(CURVE, curveName).get()));
final DoubleLabelledMatrix1D ycns =
MultiCurveUtils.getLabelledMatrix(entry.getValue(), curveDefinition);
final ValueSpecification spec =
new ValueSpecification(
YIELD_CURVE_NODE_SENSITIVITIES, target.toSpecification(), curveSpecificProperties);
results.add(new ComputedValue(spec, ycns));
return results;
}
}
s_logger.info(
"Could not get sensitivities to " + desiredCurveName + " for " + target.getName());
return Collections.emptySet();
}
@Override
public Set<ValueSpecification> getResults(
final FunctionCompilationContext context,
final ComputationTarget target,
final Map<ValueSpecification, ValueRequirement> inputs) {
String currencyPairConfigName = null;
String payCurveName = null;
String payCurveCalculationConfig = null;
String receiveCurveName = null;
String receiveCurveCalculationConfig = null;
String daysForward = null;
for (final Map.Entry<ValueSpecification, ValueRequirement> entry : inputs.entrySet()) {
final ValueSpecification specification = entry.getKey();
final ValueRequirement requirement = entry.getValue();
if (specification.getValueName().equals(ValueRequirementNames.CURRENCY_PAIRS)) {
currencyPairConfigName =
specification.getProperty(CurrencyPairsFunction.CURRENCY_PAIRS_NAME);
daysForward = requirement.getConstraint(PROPERTY_DAYS_TO_MOVE_FORWARD);
} else if (requirement.getValueName().equals(ValueRequirementNames.YIELD_CURVE)) {
final ValueProperties constraints = requirement.getConstraints();
if (constraints.getProperties().contains(ValuePropertyNames.PAY_CURVE)) {
payCurveName = Iterables.getOnlyElement(constraints.getValues(ValuePropertyNames.CURVE));
payCurveCalculationConfig =
Iterables.getOnlyElement(
constraints.getValues(ValuePropertyNames.CURVE_CALCULATION_CONFIG));
} else if (constraints.getProperties().contains(ValuePropertyNames.RECEIVE_CURVE)) {
receiveCurveName =
Iterables.getOnlyElement(constraints.getValues(ValuePropertyNames.CURVE));
receiveCurveCalculationConfig =
Iterables.getOnlyElement(
constraints.getValues(ValuePropertyNames.CURVE_CALCULATION_CONFIG));
}
}
}
assert currencyPairConfigName != null;
final CurrencyPairs baseQuotePairs =
OpenGammaCompilationContext.getCurrencyPairsSource(context)
.getCurrencyPairs(currencyPairConfigName);
final FinancialSecurity security = (FinancialSecurity) target.getSecurity();
final Currency payCurrency = security.accept(ForexVisitors.getPayCurrencyVisitor());
final Currency receiveCurrency = security.accept(ForexVisitors.getReceiveCurrencyVisitor());
final CurrencyPair baseQuotePair = baseQuotePairs.getCurrencyPair(payCurrency, receiveCurrency);
if (baseQuotePair == null) {
s_logger.error(
"Could not get base/quote pair for currency pair ("
+ payCurrency
+ ", "
+ receiveCurrency
+ ")");
return null;
}
final ValueSpecification resultSpec =
new ValueSpecification(
getValueRequirementName(),
target.toSpecification(),
getResultProperties(
target,
payCurveName,
receiveCurveName,
payCurveCalculationConfig,
receiveCurveCalculationConfig,
baseQuotePair,
daysForward)
.get());
return Collections.singleton(resultSpec);
}
@Override
public Set<ComputedValue> execute(
final FunctionExecutionContext executionContext,
final FunctionInputs inputs,
final ComputationTarget target,
final Set<ValueRequirement> desiredValues)
throws AsynchronousExecution {
final ZonedDateTime now = ZonedDateTime.now(executionContext.getValuationClock());
final ValueRequirement requirement = desiredValues.iterator().next();
final ValueProperties properties = requirement.getConstraints().copy().get();
final LegacyVanillaCDSSecurity security = (LegacyVanillaCDSSecurity) target.getSecurity();
// LegacyVanillaCreditDefaultSwapDefinition cds =
// _converter.visitLegacyVanillaCDSSecurity(security);
final ValueRequirement desiredValue = desiredValues.iterator().next(); // all same constraints
final String quoteConventionString =
desiredValue.getConstraint(ISDAFunctionConstants.CDS_QUOTE_CONVENTION);
final StandardCDSQuotingConvention quoteConvention =
StandardCDSQuotingConvention.parse(quoteConventionString);
final CdsRecoveryRateIdentifier recoveryRateIdentifier =
security.accept(
new CreditSecurityToRecoveryRateVisitor(executionContext.getSecuritySource()));
Object recoveryRateObject =
inputs.getValue(
new ValueRequirement(
"PX_LAST",
ComputationTargetType.PRIMITIVE,
recoveryRateIdentifier.getExternalId()));
if (recoveryRateObject == null) {
throw new OpenGammaRuntimeException("Could not get recovery rate");
// s_logger.warn("Could not get recovery rate, defaulting to 0.4: " + recoveryRateIdentifier);
// recoveryRateObject = 0.4;
}
final double recoveryRate = (Double) recoveryRateObject;
// get the isda curve
final Object isdaObject = inputs.getValue(ValueRequirementNames.YIELD_CURVE);
if (isdaObject == null) {
throw new OpenGammaRuntimeException("Couldn't get isda curve");
}
final ISDACompliantYieldCurve yieldCurve = (ISDACompliantYieldCurve) isdaObject;
// spreads
NodalTenorDoubleCurve spreadObject =
(NodalTenorDoubleCurve) inputs.getValue(ValueRequirementNames.BUCKETED_SPREADS);
if (spreadObject == null) {
throw new OpenGammaRuntimeException("Unable to get spreads");
}
final double[] spreads = ArrayUtils.toPrimitive(spreadObject.getYData());
// final String pillarString = IMMDateGenerator.isIMMDate(security.getMaturityDate()) ?
// requirement.getConstraint(ISDAFunctionConstants.ISDA_BUCKET_TENORS) :
// ISDACompliantCreditCurveFunction.NON_IMM_PILLAR_TENORS;
final ZonedDateTime[] bucketDates =
SpreadCurveFunctions.getPillarDates(now, spreadObject.getXData());
final CDSQuoteConvention[] quotes =
SpreadCurveFunctions.getQuotes(
security.getMaturityDate(), spreads, security.getParSpread(), quoteConvention, false);
// spreads
NodalTenorDoubleCurve pillarObject =
(NodalTenorDoubleCurve) inputs.getValue(ValueRequirementNames.PILLAR_SPREADS);
if (pillarObject == null) {
throw new OpenGammaRuntimeException("Unable to get pillars");
}
// CDS analytics for credit curve (possible performance improvement if earlier result obtained)
// final LegacyVanillaCreditDefaultSwapDefinition curveCDS = cds.withStartDate(now);
// security.setStartDate(now); // needed for curve instruments
final CDSAnalytic[] bucketCDSs = new CDSAnalytic[bucketDates.length];
for (int i = 0; i < bucketCDSs.length; i++) {
// security.setMaturityDate(bucketDates[i]);
final CDSAnalyticVisitor visitor =
new CDSAnalyticVisitor(
now.toLocalDate(),
_holidaySource,
_regionSource,
security.getStartDate().toLocalDate(),
bucketDates[i].toLocalDate(),
recoveryRate);
bucketCDSs[i] = security.accept(visitor);
}
final ZonedDateTime[] pillarDates =
SpreadCurveFunctions.getPillarDates(now, pillarObject.getXData());
final CDSAnalytic[] pillarCDSs = new CDSAnalytic[pillarDates.length];
for (int i = 0; i < pillarCDSs.length; i++) {
// security.setMaturityDate(bucketDates[i]);
final CDSAnalyticVisitor visitor =
new CDSAnalyticVisitor(
now.toLocalDate(),
_holidaySource,
_regionSource,
security.getStartDate().toLocalDate(),
pillarDates[i].toLocalDate(),
recoveryRate);
pillarCDSs[i] = security.accept(visitor);
}
final ISDACompliantCreditCurve creditCurve =
(ISDACompliantCreditCurve) inputs.getValue(ValueRequirementNames.HAZARD_RATE_CURVE);
if (creditCurve == null) {
throw new OpenGammaRuntimeException("Couldnt get credit curve");
}
// final CDSAnalytic analytic = CDSAnalyticConverter.create(cds, now.toLocalDate());
final CDSAnalyticVisitor visitor =
new CDSAnalyticVisitor(now.toLocalDate(), _holidaySource, _regionSource, recoveryRate);
final CDSAnalytic analytic = security.accept(visitor);
final BuySellProtection buySellProtection =
security.isBuy() ? BuySellProtection.BUY : BuySellProtection.SELL;
// final String term = new Tenor(Period.between(security.getStartDate().toLocalDate(),
// security.getMaturityDate().toLocalDate())).getPeriod().toString();
// final Double cdsQuoteDouble = (Double) inputs.getValue(new
// ValueRequirement(MarketDataRequirementNames.MARKET_VALUE,
// ComputationTargetType.PRIMITIVE, ExternalId.of("Tenor", term)));
final Double cdsQuoteDouble = (Double) inputs.getValue(MarketDataRequirementNames.MARKET_VALUE);
if (cdsQuoteDouble == null) {
throw new OpenGammaRuntimeException("Couldn't get spread for " + security);
}
final CDSQuoteConvention quote =
SpreadCurveFunctions.getQuotes(
security.getMaturityDate(),
new double[] {cdsQuoteDouble},
security.getParSpread(),
quoteConvention,
true)[0];
boolean isNonIMMFAndFromPUF =
!IMMDateLogic.isIMMDate(security.getMaturityDate().toLocalDate())
&& quote instanceof PointsUpFront;
boolean isNonIMMAndFromSpread =
!IMMDateLogic.isIMMDate(security.getMaturityDate().toLocalDate())
&& (quote instanceof QuotedSpread || quote instanceof ParSpread);
int buySellPremiumFactor = security.isBuy() ? -1 : 1;
final double notional = security.getNotional().getAmount();
final double coupon = security.getParSpread() * ONE_BPS;
final PointsUpFront puf =
getPointsUpfront(quote, buySellProtection, yieldCurve, analytic, creditCurve);
final double accruedPremiumPrim =
isNonIMMAndFromSpread || isNonIMMFAndFromPUF ? 0 : analytic.getAccruedPremium(coupon);
// final double accruedPremium = isNonIMMAndFromSpread || isNonIMMFAndFromPUF ? 0 :
// analytic.getAccruedPremium(coupon) * notional * buySellPremiumFactor;
final double accruedPremium =
isNonIMMAndFromSpread || isNonIMMFAndFromPUF
? 0
: accruedPremiumPrim * notional * buySellPremiumFactor;
final int accruedDays =
isNonIMMAndFromSpread || isNonIMMFAndFromPUF ? 0 : analytic.getAccuredDays();
final double quotedSpread =
getQuotedSpread(quote, puf, buySellProtection, yieldCurve, analytic).getQuotedSpread();
final double upfrontAmount =
isNonIMMAndFromSpread
? 0
: getUpfrontAmount(analytic, puf, notional, accruedPremiumPrim, buySellProtection);
final double cleanPV = puf.getPointsUpFront() * notional;
final double principal = isNonIMMAndFromSpread ? 0 : cleanPV;
final double cleanPrice = getCleanPrice(puf);
final TenorLabelledMatrix1D bucketedCS01 =
getBucketedCS01(
analytic,
bucketCDSs,
spreadObject.getXData(),
quote,
notional,
yieldCurve,
creditCurve);
final double parallelCS01 =
getParallelCS01(
quote,
analytic,
yieldCurve,
notional,
pillarCDSs,
ArrayUtils.toPrimitive(pillarObject.getYData()));
final Set<ComputedValue> results = Sets.newHashSetWithExpectedSize(_valueRequirements.length);
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.ACCRUED_PREMIUM, target.toSpecification(), properties),
accruedPremium));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.ACCRUED_DAYS, target.toSpecification(), properties),
accruedDays));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.QUOTED_SPREAD, target.toSpecification(), properties),
quotedSpread / ONE_BPS));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.UPFRONT_AMOUNT, target.toSpecification(), properties),
upfrontAmount));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.DIRTY_PRESENT_VALUE, target.toSpecification(), properties),
upfrontAmount));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.CLEAN_PRESENT_VALUE, target.toSpecification(), properties),
cleanPV));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.PRINCIPAL, target.toSpecification(), properties),
principal));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.CLEAN_PRICE, target.toSpecification(), properties),
cleanPrice));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.BUCKETED_CS01, target.toSpecification(), properties),
bucketedCS01));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.PARALLEL_CS01, target.toSpecification(), properties),
parallelCS01));
results.add(
new ComputedValue(
new ValueSpecification(
ValueRequirementNames.POINTS_UPFRONT, target.toSpecification(), properties),
puf.getPointsUpFront()));
return results;
}
