Java tutorial
/** * Copyright (C) 2016 - present by OpenGamma Inc. and the OpenGamma group of companies * * Please see distribution for license. */ package com.opengamma.strata.market.param; import java.util.List; import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableList; import com.opengamma.strata.collect.ArgChecker; /** * Helper that can be used to combine two or more underlying instances of {@code ParameterizedData}. * <p> * This is used by implementations of {@link ParameterizedData} that are based on more * than one underlying {@code ParameterizedData} instance. * <p> * This helper should be created in the constructor of the combined instance. * In each of the five {@code ParameterizedData} methods of the combined instance, * this helper should be invoked. See {@code DiscountFxForwardRates} for sample usage. */ public final class ParameterizedDataCombiner { /** * The underlying instances. */ private final ParameterizedData[] underlyings; /** * The lookup array. */ private final int[] lookup; /** * The count of parameters. */ private final int paramCount; //------------------------------------------------------------------------- /** * Obtains an instance that can combine the specified underlying instances. * * @param instances the underlying instances to combine * @return the combiner */ public static ParameterizedDataCombiner of(ParameterizedData... instances) { return new ParameterizedDataCombiner(instances); } /** * Obtains an instance that can combine the specified underlying instances. * * @param instances the underlying instances to combine * @return the combiner */ public static ParameterizedDataCombiner of(List<? extends ParameterizedData> instances) { return new ParameterizedDataCombiner((ParameterizedData[]) instances.toArray(new ParameterizedData[0])); } //------------------------------------------------------------------------- // creates an instance private ParameterizedDataCombiner(ParameterizedData[] underlyings) { ArgChecker.notEmpty(underlyings, "underlyings"); int size = underlyings.length; this.underlyings = underlyings; int[] lookup = new int[size]; for (int i = 1; i < size; i++) { lookup[i] = lookup[i - 1] + underlyings[i - 1].getParameterCount(); } this.lookup = lookup; this.paramCount = lookup[size - 1] + underlyings[size - 1].getParameterCount(); } //------------------------------------------------------------------------- /** * Gets the number of parameters. * <p> * This returns the total parameter count of all the instances. * * @return the number of parameters */ public int getParameterCount() { return paramCount; } /** * Gets the value of the parameter at the specified index. * <p> * This gets the parameter from the correct instance. * * @param parameterIndex the zero-based index of the parameter to get * @return the value of the parameter * @throws IndexOutOfBoundsException if the index is invalid */ public double getParameter(int parameterIndex) { int underlyingIndex = findUnderlyingIndex(parameterIndex); int adjustment = lookup[underlyingIndex]; return underlyings[underlyingIndex].getParameter(parameterIndex - adjustment); } /** * Gets the metadata of the parameter at the specified index. * <p> * This gets the parameter metadata from the correct instance. * * @param parameterIndex the zero-based index of the parameter to get * @return the metadata of the parameter * @throws IndexOutOfBoundsException if the index is invalid */ public ParameterMetadata getParameterMetadata(int parameterIndex) { int underlyingIndex = findUnderlyingIndex(parameterIndex); int adjustment = lookup[underlyingIndex]; return underlyings[underlyingIndex].getParameterMetadata(parameterIndex - adjustment); } //------------------------------------------------------------------------- /** * Updates a parameter on the specified underlying. * <p> * This should be invoked once for each of the underlying instances. * It is intended to be used to pass the result of each invocation to the * constructor of the combined instance. * <p> * If the parameter index applies to the underlying, it is updated. * If the parameter index does not apply to the underlying, no error occurs. * * @param <R> the type of the underlying * @param underlyingIndex the index of the underlying instance * @param underlyingType the type of the parameterized data at the specified index * @param parameterIndex the zero-based index of the parameter to change * @param newValue the new value for the specified parameter * @return a parameterized data instance based on this with the specified parameter altered * @throws IndexOutOfBoundsException if the index is invalid */ public <R extends ParameterizedData> R underlyingWithParameter(int underlyingIndex, Class<R> underlyingType, int parameterIndex, double newValue) { ParameterizedData perturbed = underlyings[underlyingIndex]; if (findUnderlyingIndex(parameterIndex) == underlyingIndex) { int adjustment = lookup[underlyingIndex]; perturbed = perturbed.withParameter(parameterIndex - adjustment, newValue); } return underlyingType.cast(perturbed); } /** * Applies a perturbation to the specified underlying. * <p> * This should be invoked once for each of the underlying instances. * It is intended to be used to pass the result of each invocation to the * constructor of the combined instance. * * @param <R> the type of the underlying * @param underlyingIndex the index of the underlying instance * @param underlyingType the type of the parameterized data at the specified index * @param perturbation the perturbation to apply * @return a parameterized data instance based on this with the specified perturbation applied */ public <R extends ParameterizedData> R underlyingWithPerturbation(int underlyingIndex, Class<R> underlyingType, ParameterPerturbation perturbation) { ParameterizedData underlying = underlyings[underlyingIndex]; // perturb using a derived perturbation that adjusts the index int adjustment = lookup[underlyingIndex]; ParameterizedData perturbed = underlying.withPerturbation( (idx, value, meta) -> perturbation.perturbParameter(idx + adjustment, value, meta)); return underlyingType.cast(perturbed); } //------------------------------------------------------------------------- /** * Updates a parameter on the specified list of underlying instances. * <p> * The correct underlying is identified and updated, with the list returned. * * @param <R> the type of the underlying * @param underlyingType the type of the parameterized data at the specified index * @param parameterIndex the zero-based index of the parameter to change * @param newValue the new value for the specified parameter * @return a parameterized data instance based on this with the specified parameter altered * @throws IndexOutOfBoundsException if the index is invalid */ public <R extends ParameterizedData> List<R> withParameter(Class<R> underlyingType, int parameterIndex, double newValue) { int underlyingIndex = findUnderlyingIndex(parameterIndex); ImmutableList.Builder<R> builder = ImmutableList.builder(); for (int i = 0; i < underlyings.length; i++) { ParameterizedData underlying = underlyings[i]; if (i == underlyingIndex) { int adjustment = lookup[underlyingIndex]; ParameterizedData perturbed = underlying.withParameter(parameterIndex - adjustment, newValue); builder.add(underlyingType.cast(perturbed)); } else { builder.add(underlyingType.cast(underlying)); } } return builder.build(); } /** * Applies a perturbation to each underlying. * <p> * The updated list of underlying instances is returned. * * @param <R> the type of the underlying * @param underlyingType the type of the parameterized data at the specified index * @param perturbation the perturbation to apply * @return a parameterized data instance based on this with the specified parameter altered * @throws IndexOutOfBoundsException if the index is invalid */ public <R extends ParameterizedData> List<R> withPerturbation(Class<R> underlyingType, ParameterPerturbation perturbation) { ImmutableList.Builder<R> builder = ImmutableList.builder(); for (int i = 0; i < underlyings.length; i++) { builder.add(underlyingWithPerturbation(i, underlyingType, perturbation)); } return builder.build(); } //------------------------------------------------------------------------- // convert parameter index to underlying index private int findUnderlyingIndex(int parameterIndex) { Preconditions.checkElementIndex(parameterIndex, paramCount); for (int i = 1; i < lookup.length; i++) { if (parameterIndex < lookup[i]) { return i - 1; } } return lookup.length - 1; } }