@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));
}
@SuppressWarnings("synthetic-access")
@Override
public InstrumentDerivative convert(
final FRASecurity security,
final ForwardRateAgreementDefinition definition,
final ZonedDateTime now,
final String[] curveNames,
final HistoricalTimeSeriesBundle timeSeries) {
final ExternalId indexId = security.getUnderlyingId();
final ConventionBundle indexConvention = _conventionSource.getConventionBundle(indexId);
if (indexConvention == null) {
throw new OpenGammaRuntimeException(
"No conventions found for floating reference rate " + indexId);
}
final ExternalIdBundle indexIdBundle = indexConvention.getIdentifiers();
final HistoricalTimeSeries ts =
timeSeries.get(MarketDataRequirementNames.MARKET_VALUE, indexIdBundle);
if (ts == null) {
throw new OpenGammaRuntimeException(
"Could not get price time series for " + indexIdBundle);
}
FastBackedDoubleTimeSeries<LocalDate> localDateTS = ts.getTimeSeries();
// TODO this normalization should not be done here
localDateTS = localDateTS.divide(100);
final FastLongDoubleTimeSeries convertedTS =
localDateTS.toFastLongDoubleTimeSeries(DateTimeNumericEncoding.TIME_EPOCH_MILLIS);
final LocalTime fixingTime = LocalTime.of(0, 0);
final DoubleTimeSeries<ZonedDateTime> indexTS =
new ArrayZonedDateTimeDoubleTimeSeries(
new ZonedDateTimeEpochMillisConverter(now.getZone(), fixingTime), convertedTS);
// TODO: remove the zone
return definition.toDerivative(now, indexTS, curveNames);
}
public static Set<ValueRequirement> buildRequirements(
final InterpolatedYieldCurveSpecification specification,
final FunctionCompilationContext context) {
final Set<ValueRequirement> result = new HashSet<ValueRequirement>();
for (final FixedIncomeStripWithIdentifier strip : specification.getStrips()) {
result.add(
new ValueRequirement(MarketDataRequirementNames.MARKET_VALUE, strip.getSecurity()));
}
final ConventionBundleSource conventionBundleSource =
OpenGammaCompilationContext.getConventionBundleSource(context);
final ConventionBundle conventionBundle =
conventionBundleSource.getConventionBundle(
Identifier.of(
InMemoryConventionBundleMaster.SIMPLE_NAME_SCHEME,
specification.getCurrency().getCode() + "_SWAP"));
final ConventionBundle referenceRateConvention =
conventionBundleSource.getConventionBundle(
IdentifierBundle.of(conventionBundle.getSwapFloatingLegInitialRate()));
final Identifier initialRefRateId =
SecurityUtils.bloombergTickerSecurityId(
referenceRateConvention.getIdentifiers().getIdentifier(SecurityUtils.BLOOMBERG_TICKER));
result.add(new ValueRequirement(MarketDataRequirementNames.MARKET_VALUE, initialRefRateId));
return Collections.unmodifiableSet(result);
}
@Override
public Set<ValueRequirement> getRequirements(
final FunctionCompilationContext context,
final ComputationTarget target,
final ValueRequirement desiredValue) {
final Object positionOrNode = getTarget(target);
final Set<ValueRequirement> result = new HashSet<ValueRequirement>();
final ValueProperties constraints = desiredValue.getConstraints();
final Set<String> samplingPeriodNames =
constraints.getValues(ValuePropertyNames.SAMPLING_PERIOD);
if (samplingPeriodNames == null || samplingPeriodNames.size() != 1) {
return null;
}
final Set<String> scheduleCalculatorNames =
constraints.getValues(ValuePropertyNames.SCHEDULE_CALCULATOR);
if (scheduleCalculatorNames == null || scheduleCalculatorNames.size() != 1) {
return null;
}
final Set<String> samplingFunctionNames =
constraints.getValues(ValuePropertyNames.SAMPLING_FUNCTION);
if (samplingFunctionNames == null || samplingFunctionNames.size() != 1) {
return null;
}
final Set<String> returnCalculatorNames =
constraints.getValues(ValuePropertyNames.RETURN_CALCULATOR);
if (returnCalculatorNames == null || returnCalculatorNames.size() != 1) {
return null;
}
final Set<String> stdDevCalculatorNames =
constraints.getValues(ValuePropertyNames.STD_DEV_CALCULATOR);
if (stdDevCalculatorNames == null || stdDevCalculatorNames.size() != 1) {
return null;
}
final Set<String> covarianceCalculatorNames =
constraints.getValues(ValuePropertyNames.COVARIANCE_CALCULATOR);
if (covarianceCalculatorNames == null || covarianceCalculatorNames.size() != 1) {
return null;
}
final Set<String> varianceCalculatorNames =
constraints.getValues(ValuePropertyNames.VARIANCE_CALCULATOR);
if (varianceCalculatorNames == null || varianceCalculatorNames.size() != 1) {
return null;
}
final String samplingPeriodName = samplingPeriodNames.iterator().next();
final String scheduleCalculatorName = scheduleCalculatorNames.iterator().next();
final String samplingFunctionName = samplingFunctionNames.iterator().next();
final String returnCalculatorName = returnCalculatorNames.iterator().next();
final ValueProperties pnlSeriesProperties =
ValueProperties.builder()
.withAny(ValuePropertyNames.CURRENCY)
.with(ValuePropertyNames.SAMPLING_PERIOD, samplingPeriodName)
.with(ValuePropertyNames.SCHEDULE_CALCULATOR, scheduleCalculatorName)
.with(ValuePropertyNames.SAMPLING_FUNCTION, samplingFunctionName)
.with(ValuePropertyNames.RETURN_CALCULATOR, returnCalculatorName)
.get();
final ValueProperties betaProperties =
ValueProperties.builder()
.with(ValuePropertyNames.SAMPLING_PERIOD, samplingPeriodName)
.with(ValuePropertyNames.SCHEDULE_CALCULATOR, scheduleCalculatorName)
.with(ValuePropertyNames.SAMPLING_FUNCTION, samplingFunctionName)
.with(ValuePropertyNames.RETURN_CALCULATOR, returnCalculatorName)
.with(
ValuePropertyNames.COVARIANCE_CALCULATOR,
covarianceCalculatorNames.iterator().next())
.with(ValuePropertyNames.VARIANCE_CALCULATOR, varianceCalculatorNames.iterator().next())
.get();
result.add(
new ValueRequirement(
ValueRequirementNames.PNL_SERIES, positionOrNode, pnlSeriesProperties));
result.add(new ValueRequirement(ValueRequirementNames.FAIR_VALUE, positionOrNode));
result.add(
new ValueRequirement(ValueRequirementNames.CAPM_BETA, positionOrNode, betaProperties));
final HistoricalTimeSeriesResolver resolver =
OpenGammaCompilationContext.getHistoricalTimeSeriesResolver(context);
final ConventionBundleSource conventionSource =
OpenGammaCompilationContext.getConventionBundleSource(context);
final ConventionBundle bundle =
conventionSource.getConventionBundle(
ExternalId.of(InMemoryConventionBundleMaster.SIMPLE_NAME_SCHEME, "USD_CAPM"));
final HistoricalTimeSeriesResolutionResult timeSeries =
resolver.resolve(
bundle.getCAPMMarket(),
null,
null,
null,
MarketDataRequirementNames.MARKET_VALUE,
_resolutionKey);
if (timeSeries == null) {
return null;
}
result.add(
HistoricalTimeSeriesFunctionUtils.createHTSRequirement(
timeSeries,
MarketDataRequirementNames.MARKET_VALUE,
DateConstraint.VALUATION_TIME.minus(samplingPeriodName),
true,
DateConstraint.VALUATION_TIME,
true));
return result;
}
