com.opengamma.analytics.financial.model.interestrate.curve.PriceIndexCurve.java Source code

Introduction

Here is the source code for com.opengamma.analytics.financial.model.interestrate.curve.PriceIndexCurve.java

Source

/**
 * Copyright (C) 2011 - present by OpenGamma Inc. and the OpenGamma group of companies
 *
 * Please see distribution for license.
 */
package com.opengamma.analytics.financial.model.interestrate.curve;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang.Validate;

import com.opengamma.analytics.math.curve.DoublesCurve;
import com.opengamma.analytics.math.curve.InterpolatedDoublesCurve;
import com.opengamma.analytics.math.interpolation.LinearInterpolator1D;
import com.opengamma.util.ArgumentChecker;

/**
 * A curve containing the (estimated) price index at different maturities. The maturities can be (slightly) negative as the price index are known only with a certain lag.
 * The price index for a given month is on the first of the month point.
 */
// TODO: Improve the object to have something similar to the YieldAndDiscountCurve.
public class PriceIndexCurve {

    /**
     * The price index curve.
     */
    private final DoublesCurve _curve;

    /**
     * A small amount of time
     */
    private static final double SMALL_TIME = 1.0E-6;

    /**
     * Constructor from a curve object.
     * @param curve The curve.
     */
    public PriceIndexCurve(final DoublesCurve curve) {
        Validate.notNull(curve, "curve");
        _curve = curve;
    }

    /**
     * Build a simple price index curve from known index and annual zero-coupon swap rates. The inflation coupon reference are exact month are not interpolated.
     * No seasonality is used. The price index are interpolated linearly.
     * @param nodeTimeKnown The time to the known price index. Those time will typically be negative (the price index are published after month end).
     * @param indexKnown The value of the known index. The first one in the list is the one used in the swaps used for curve construction.
     * @param nodeTimeOther The time to the price index reference for the swaps.
     * @param rate The zero-coupon swaps rates.
     * @return The price index curve.
     */
    public static PriceIndexCurve fromStartOfMonth(final double[] nodeTimeKnown, final double[] indexKnown,
            final double[] nodeTimeOther, final double[] rate) {
        final int nbNode = nodeTimeKnown.length + nodeTimeOther.length;
        final double[] nodeTime = new double[nbNode];
        System.arraycopy(nodeTimeKnown, 0, nodeTime, 0, nodeTimeKnown.length);
        System.arraycopy(nodeTimeOther, 0, nodeTime, nodeTimeKnown.length, nodeTimeOther.length);
        final double[] indexValue = new double[nbNode];
        System.arraycopy(indexKnown, 0, indexValue, 0, nodeTimeKnown.length);
        final double[] nbYear = new double[nodeTimeOther.length];
        for (int loopperiod = 0; loopperiod < nodeTimeOther.length; loopperiod++) {
            nbYear[loopperiod] = Math.round(nodeTimeOther[loopperiod] - nodeTimeKnown[0]);
            indexValue[nodeTimeKnown.length + loopperiod] = indexKnown[0]
                    * Math.pow(1 + rate[loopperiod], nbYear[loopperiod]);
        }
        final InterpolatedDoublesCurve curve = InterpolatedDoublesCurve.from(nodeTime, indexValue,
                new LinearInterpolator1D());
        return new PriceIndexCurve(curve);
    }

    /**
     * Gets the underlying curve object.
     * @return The curve.
     */
    public DoublesCurve getCurve() {
        return _curve;
    }

    /**
     * Returns the curve name.
     * @return The name.
     */
    public String getName() {
        return _curve.getName();
    }

    /**
     * Returns the estimated price index for a given time to index.
     * @param timeToIndex The time
     * @return The price index.
     */
    public double getPriceIndex(final Double timeToIndex) {
        return _curve.getYValue(timeToIndex);
    }

    /**
     * Returns the estimated inflation rate between two given time .
     * @param firstTime The time
     * @param secondTime The time
     * @return The price index.
     */
    public double getInflationRate(final Double firstTime, final Double secondTime) {
        ArgumentChecker.isTrue(firstTime < secondTime, "firstTime should be before secondTime");
        return _curve.getYValue(secondTime) / _curve.getYValue(firstTime) - 1.0;
    }

    /**
     * Gets the number of parameters in a curve.
     * @return The number of parameters
     */
    public int getNumberOfParameters() {
        return _curve.size();
    }

    /**
     * The list of underlying curves (up to one level).
     * @return The list.
     */
    public List<String> getUnderlyingCurvesNames() {
        return new ArrayList<>();
    }

    /**
     * Gets the sensitivities of the price index to the curve parameters for a time.
     * @param time The time
     * @return The sensitivities. If the time is less than 1e<sup>-6</sup>, the rate is
     * ill-defined and zero is returned.
     */
    public double[] getPriceIndexParameterSensitivity(final double time) {
        final Double[] curveSensitivity = _curve.getYValueParameterSensitivity(time);
        final double[] priceIndexZeroSensitivity = new double[curveSensitivity.length];
        // Implementation note: if time = 0, the rate is ill-defined: return 0 sensitivity
        if (Math.abs(time) < SMALL_TIME) {
            return priceIndexZeroSensitivity;
        }
        for (int loopp = 0; loopp < curveSensitivity.length; loopp++) {
            priceIndexZeroSensitivity[loopp] = curveSensitivity[loopp];
        }
        return priceIndexZeroSensitivity;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + _curve.hashCode();
        return result;
    }

    @Override
    public boolean equals(final Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final PriceIndexCurve other = (PriceIndexCurve) obj;
        return ObjectUtils.equals(_curve, other._curve);
    }

}