com.opengamma.analytics.financial.curve.CurveConstructionXCcyTest.java Source code

Java tutorial

Introduction

Here is the source code for com.opengamma.analytics.financial.curve.CurveConstructionXCcyTest.java

Source

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

import static org.testng.AssertJUnit.assertEquals;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;

import javax.time.calendar.Period;
import javax.time.calendar.ZonedDateTime;

import org.apache.commons.lang.ArrayUtils;
import org.testng.annotations.BeforeSuite;
import org.testng.annotations.Test;

import com.opengamma.analytics.financial.calculator.MarketQuoteSensitivityBlockCalculator;
import com.opengamma.analytics.financial.calculator.PresentValueConvertedCalculator;
import com.opengamma.analytics.financial.calculator.PresentValueCurveSensitivityConvertedCalculator;
import com.opengamma.analytics.financial.calculator.PresentValueCurveSensitivityMCSCalculator;
import com.opengamma.analytics.financial.calculator.PresentValueMCACalculator;
import com.opengamma.analytics.financial.curve.building.CurveBuildingBlock;
import com.opengamma.analytics.financial.curve.building.CurveBuildingBlockBundle;
import com.opengamma.analytics.financial.curve.building.MultipleYieldCurveFinderGeneratorDataBundle;
import com.opengamma.analytics.financial.curve.building.MultipleYieldCurveFinderGeneratorFunction;
import com.opengamma.analytics.financial.curve.building.MultipleYieldCurveFinderGeneratorJacobian;
import com.opengamma.analytics.financial.curve.generator.GeneratorCurveYieldInterpolated;
import com.opengamma.analytics.financial.curve.generator.GeneratorYDCurve;
import com.opengamma.analytics.financial.curve.sensitivity.ParameterSensitivity;
import com.opengamma.analytics.financial.curve.sensitivity.ParameterSensitivityBlockCalculator;
import com.opengamma.analytics.financial.curve.sensitivity.ParameterSensitivityCalculator;
import com.opengamma.analytics.financial.forex.definition.ForexSwapDefinition;
import com.opengamma.analytics.financial.forex.method.FXMatrix;
import com.opengamma.analytics.financial.instrument.InstrumentDefinition;
import com.opengamma.analytics.financial.instrument.cash.CashDefinition;
import com.opengamma.analytics.financial.instrument.fra.ForwardRateAgreementDefinition;
import com.opengamma.analytics.financial.instrument.index.GeneratorDeposit;
import com.opengamma.analytics.financial.instrument.index.GeneratorDepositON;
import com.opengamma.analytics.financial.instrument.index.GeneratorForexSwap;
import com.opengamma.analytics.financial.instrument.index.GeneratorInstrument;
import com.opengamma.analytics.financial.instrument.index.GeneratorSwapFixedIbor;
import com.opengamma.analytics.financial.instrument.index.GeneratorSwapFixedIborMaster;
import com.opengamma.analytics.financial.instrument.index.GeneratorSwapFixedON;
import com.opengamma.analytics.financial.instrument.index.GeneratorSwapIborIbor;
import com.opengamma.analytics.financial.instrument.index.GeneratorSwapXCcyIborIbor;
import com.opengamma.analytics.financial.instrument.index.IborIndex;
import com.opengamma.analytics.financial.instrument.index.IndexIborMaster;
import com.opengamma.analytics.financial.instrument.index.IndexON;
import com.opengamma.analytics.financial.instrument.swap.SwapFixedIborDefinition;
import com.opengamma.analytics.financial.instrument.swap.SwapFixedONDefinition;
import com.opengamma.analytics.financial.instrument.swap.SwapIborIborDefinition;
import com.opengamma.analytics.financial.instrument.swap.SwapXCcyIborIborDefinition;
import com.opengamma.analytics.financial.interestrate.AbstractInstrumentDerivativeVisitor;
import com.opengamma.analytics.financial.interestrate.InstrumentDerivative;
import com.opengamma.analytics.financial.interestrate.InterestRateCurveSensitivity;
import com.opengamma.analytics.financial.interestrate.LastTimeCalculator;
import com.opengamma.analytics.financial.interestrate.ParSpreadMarketQuoteCalculator;
import com.opengamma.analytics.financial.interestrate.ParSpreadMarketQuoteCurveSensitivityCalculator;
import com.opengamma.analytics.financial.interestrate.YieldCurveBundle;
import com.opengamma.analytics.financial.interestrate.payments.derivative.Payment;
import com.opengamma.analytics.financial.interestrate.swap.derivative.Swap;
import com.opengamma.analytics.financial.schedule.ScheduleCalculator;
import com.opengamma.analytics.math.function.Function1D;
import com.opengamma.analytics.math.interpolation.CombinedInterpolatorExtrapolatorFactory;
import com.opengamma.analytics.math.interpolation.Interpolator1D;
import com.opengamma.analytics.math.interpolation.Interpolator1DFactory;
import com.opengamma.analytics.math.linearalgebra.DecompositionFactory;
import com.opengamma.analytics.math.matrix.CommonsMatrixAlgebra;
import com.opengamma.analytics.math.matrix.DoubleMatrix1D;
import com.opengamma.analytics.math.matrix.DoubleMatrix2D;
import com.opengamma.analytics.math.matrix.MatrixAlgebra;
import com.opengamma.analytics.math.rootfinding.newton.BroydenVectorRootFinder;
import com.opengamma.financial.convention.businessday.BusinessDayConvention;
import com.opengamma.financial.convention.businessday.BusinessDayConventionFactory;
import com.opengamma.financial.convention.calendar.Calendar;
import com.opengamma.financial.convention.calendar.MondayToFridayCalendar;
import com.opengamma.financial.convention.daycount.DayCount;
import com.opengamma.financial.convention.daycount.DayCountFactory;
import com.opengamma.util.money.Currency;
import com.opengamma.util.time.DateUtils;
import com.opengamma.util.timeseries.DoubleTimeSeries;
import com.opengamma.util.timeseries.zoneddatetime.ArrayZonedDateTimeDoubleTimeSeries;
import com.opengamma.util.tuple.ObjectsPair;
import com.opengamma.util.tuple.Pair;

/**
 * Build of curve in several currencies in several blocks with relevant Jacobian matrices.
 * Currencies: USD (2 curves), EUR (2 curves), JPY (3 curves)
 */
public class CurveConstructionXCcyTest {

    //  private static final Interpolator1D INTERPOLATOR = CombinedInterpolatorExtrapolatorFactory.getInterpolator(Interpolator1DFactory.DOUBLE_QUADRATIC,
    //      Interpolator1DFactory.LINEAR_EXTRAPOLATOR, Interpolator1DFactory.FLAT_EXTRAPOLATOR);
    private static final Interpolator1D INTERPOLATOR = CombinedInterpolatorExtrapolatorFactory.getInterpolator(
            Interpolator1DFactory.LINEAR, Interpolator1DFactory.LINEAR_EXTRAPOLATOR,
            Interpolator1DFactory.FLAT_EXTRAPOLATOR);
    private static final MatrixAlgebra MATRIX_ALGEBRA = new CommonsMatrixAlgebra();

    private static final LastTimeCalculator MATURITY_CALCULATOR = LastTimeCalculator.getInstance();
    private static final double TOLERANCE_ROOT = 1.0E-10;
    private static final BroydenVectorRootFinder ROOT_FINDER = new BroydenVectorRootFinder(TOLERANCE_ROOT,
            TOLERANCE_ROOT, 10000, DecompositionFactory.getDecomposition(DecompositionFactory.SV_COLT_NAME));
    private static final Currency CCY_USD = Currency.USD;
    private static final Currency CCY_EUR = Currency.EUR;
    private static final Currency CCY_JPY = Currency.JPY;
    private static final double FX_EURUSD = 1.40;
    private static final double FX_USDJPY = 80.0;
    private static final FXMatrix FX_MATRIX = new FXMatrix(CCY_USD);
    private static final Calendar CALENDAR = new MondayToFridayCalendar("CAL");
    private static final int SPOT_LAG = 2;
    private static final DayCount DAY_COUNT_CASH = DayCountFactory.INSTANCE.getDayCount("Actual/360");
    private static final DayCount DAY_COUNT_CASH_3 = DayCountFactory.INSTANCE.getDayCount("Actual/365");
    private static final double NOTIONAL = 1.0;
    private static final BusinessDayConvention BDC = BusinessDayConventionFactory.INSTANCE
            .getBusinessDayConvention("Modified Following");
    private static final IndexON INDEX_ON_1 = new IndexON("Fed Fund", CCY_USD, DAY_COUNT_CASH, 1, CALENDAR);
    private static final GeneratorDepositON GENERATOR_DEPOSIT_ON_1 = new GeneratorDepositON("USD Deposit ON",
            CCY_USD, CALENDAR, DAY_COUNT_CASH);
    private static final GeneratorDepositON GENERATOR_DEPOSIT_ON_2 = new GeneratorDepositON("EUR Deposit ON",
            CCY_EUR, CALENDAR, DAY_COUNT_CASH);
    private static final GeneratorDepositON GENERATOR_DEPOSIT_ON_3 = new GeneratorDepositON("JPY Deposit ON",
            CCY_JPY, CALENDAR, DAY_COUNT_CASH_3);
    private static final GeneratorSwapFixedON GENERATOR_OIS_1 = new GeneratorSwapFixedON("USD1YFEDFUND", INDEX_ON_1,
            Period.ofMonths(12), DAY_COUNT_CASH, BDC, true, SPOT_LAG, SPOT_LAG);
    private static final GeneratorForexSwap GENERATOR_FX_EURUSD = new GeneratorForexSwap("EURUSD", CCY_EUR, CCY_USD,
            CALENDAR, SPOT_LAG, BDC, true);
    private static final GeneratorForexSwap GENERATOR_FX_USDJPY = new GeneratorForexSwap("USDJPY", CCY_USD, CCY_JPY,
            CALENDAR, SPOT_LAG, BDC, true);
    private static final GeneratorDeposit GENERATOR_DEPOSIT_USD = new GeneratorDeposit("USD Deposit", CCY_USD,
            CALENDAR, SPOT_LAG, DAY_COUNT_CASH, BDC, true);
    private static final GeneratorDeposit GENERATOR_DEPOSIT_EUR = new GeneratorDeposit("EUR Deposit", CCY_EUR,
            CALENDAR, SPOT_LAG, DAY_COUNT_CASH, BDC, true);
    private static final GeneratorDeposit GENERATOR_DEPOSIT_JPY = new GeneratorDeposit("JPY Deposit", CCY_JPY,
            CALENDAR, SPOT_LAG, DAY_COUNT_CASH, BDC, true);
    private static final GeneratorSwapFixedIborMaster GENERATOR_SWAP_MASTER = GeneratorSwapFixedIborMaster
            .getInstance();
    private static final GeneratorSwapFixedIbor USD6MLIBOR3M = GENERATOR_SWAP_MASTER.getGenerator("USD6MLIBOR3M",
            CALENDAR);
    private static final GeneratorSwapFixedIbor EUR1YEURIBOR3M = GENERATOR_SWAP_MASTER
            .getGenerator("EUR1YEURIBOR3M", CALENDAR);
    private static final GeneratorSwapFixedIbor JPY6MLIBOR6M = GENERATOR_SWAP_MASTER.getGenerator("JPY6MLIBOR6M",
            CALENDAR);
    private static final IborIndex USDLIBOR3M = USD6MLIBOR3M.getIborIndex();
    private static final IborIndex EURIBOR3M = EUR1YEURIBOR3M.getIborIndex();
    private static final IborIndex JPYLIBOR6M = JPY6MLIBOR6M.getIborIndex();
    private static final IborIndex JPYLIBOR3M = IndexIborMaster.getInstance().getIndex("JPYLIBOR3M", CALENDAR);
    private static final GeneratorSwapXCcyIborIbor EURIBOR3MUSDLIBOR3M = new GeneratorSwapXCcyIborIbor(
            "EURIBOR3MUSDLIBOR3M", EURIBOR3M, USDLIBOR3M); // Spread on EUR leg
    private static final GeneratorSwapXCcyIborIbor JPYLIBOR3MUSDLIBOR3M = new GeneratorSwapXCcyIborIbor(
            "JPYLIBOR3MUSDLIBOR3M", JPYLIBOR3M, USDLIBOR3M); // Spread on JPY leg
    private static final GeneratorSwapXCcyIborIbor JPYLIBOR3MEURIBOR3M = new GeneratorSwapXCcyIborIbor(
            "JPYLIBOR3MEURIBOR3M", JPYLIBOR3M, EURIBOR3M); // Spread on JPY leg
    private static final GeneratorSwapIborIbor JPYLIBOR6MLIBOR3M = new GeneratorSwapIborIbor("JPYLIBOR6MLIBOR3M",
            JPYLIBOR3M, JPYLIBOR6M);

    private static final ZonedDateTime NOW = DateUtils.getUTCDate(2011, 9, 28);

    private static final ArrayZonedDateTimeDoubleTimeSeries TS_EMPTY = new ArrayZonedDateTimeDoubleTimeSeries();
    private static final ArrayZonedDateTimeDoubleTimeSeries TS_ON_USD_WITH_TODAY = new ArrayZonedDateTimeDoubleTimeSeries(
            new ZonedDateTime[] { DateUtils.getUTCDate(2011, 9, 27), DateUtils.getUTCDate(2011, 9, 28) },
            new double[] { 0.07, 0.08 });
    private static final ArrayZonedDateTimeDoubleTimeSeries TS_ON_USD_WITHOUT_TODAY = new ArrayZonedDateTimeDoubleTimeSeries(
            new ZonedDateTime[] { DateUtils.getUTCDate(2011, 9, 27), DateUtils.getUTCDate(2011, 9, 28) },
            new double[] { 0.07, 0.08 });
    @SuppressWarnings("rawtypes")
    private static final DoubleTimeSeries[] TS_FIXED_OIS_USD_WITH_TODAY = new DoubleTimeSeries[] { TS_EMPTY,
            TS_ON_USD_WITH_TODAY };
    @SuppressWarnings("rawtypes")
    private static final DoubleTimeSeries[] TS_FIXED_OIS_USD_WITHOUT_TODAY = new DoubleTimeSeries[] { TS_EMPTY,
            TS_ON_USD_WITHOUT_TODAY };

    private static final ArrayZonedDateTimeDoubleTimeSeries TS_IBOR_USD3M_WITH_TODAY = new ArrayZonedDateTimeDoubleTimeSeries(
            new ZonedDateTime[] { DateUtils.getUTCDate(2011, 9, 27), DateUtils.getUTCDate(2011, 9, 28) },
            new double[] { 0.0035, 0.0036 });
    private static final ArrayZonedDateTimeDoubleTimeSeries TS_IBOR_USD3M_WITHOUT_TODAY = new ArrayZonedDateTimeDoubleTimeSeries(
            new ZonedDateTime[] { DateUtils.getUTCDate(2011, 9, 27) }, new double[] { 0.0035 });

    private static final ArrayZonedDateTimeDoubleTimeSeries TS_IBOR_EUR3M_WITH_TODAY = new ArrayZonedDateTimeDoubleTimeSeries(
            new ZonedDateTime[] { DateUtils.getUTCDate(2011, 9, 27), DateUtils.getUTCDate(2011, 9, 28) },
            new double[] { 0.0060, 0.0061 });
    private static final ArrayZonedDateTimeDoubleTimeSeries TS_IBOR_EUR3M_WITHOUT_TODAY = new ArrayZonedDateTimeDoubleTimeSeries(
            new ZonedDateTime[] { DateUtils.getUTCDate(2011, 9, 27) }, new double[] { 0.0060 });

    private static final ArrayZonedDateTimeDoubleTimeSeries TS_IBOR_JPY3M_WITH_TODAY = new ArrayZonedDateTimeDoubleTimeSeries(
            new ZonedDateTime[] { DateUtils.getUTCDate(2011, 9, 27), DateUtils.getUTCDate(2011, 9, 28) },
            new double[] { 0.0060, 0.0061 });
    private static final ArrayZonedDateTimeDoubleTimeSeries TS_IBOR_JPY3M_WITHOUT_TODAY = new ArrayZonedDateTimeDoubleTimeSeries(
            new ZonedDateTime[] { DateUtils.getUTCDate(2011, 9, 27) }, new double[] { 0.0060 });
    private static final ArrayZonedDateTimeDoubleTimeSeries TS_IBOR_JPY6M_WITH_TODAY = new ArrayZonedDateTimeDoubleTimeSeries(
            new ZonedDateTime[] { DateUtils.getUTCDate(2011, 9, 27), DateUtils.getUTCDate(2011, 9, 28) },
            new double[] { 0.0060, 0.0061 });
    private static final ArrayZonedDateTimeDoubleTimeSeries TS_IBOR_JPY6M_WITHOUT_TODAY = new ArrayZonedDateTimeDoubleTimeSeries(
            new ZonedDateTime[] { DateUtils.getUTCDate(2011, 9, 27) }, new double[] { 0.0060 });
    @SuppressWarnings("rawtypes")
    private static final DoubleTimeSeries[] TS_FIXED_IBOR_USD3M_WITH_TODAY = new DoubleTimeSeries[] {
            TS_IBOR_USD3M_WITH_TODAY };
    @SuppressWarnings("rawtypes")
    private static final DoubleTimeSeries[] TS_FIXED_IBOR_USD3M_WITHOUT_TODAY = new DoubleTimeSeries[] {
            TS_IBOR_USD3M_WITHOUT_TODAY };
    @SuppressWarnings("rawtypes")
    private static final DoubleTimeSeries[] TS_FIXED_IBOR_EUR3M_WITH_TODAY = new DoubleTimeSeries[] {
            TS_IBOR_EUR3M_WITH_TODAY };
    @SuppressWarnings("rawtypes")
    private static final DoubleTimeSeries[] TS_FIXED_IBOR_EUR3M_WITHOUT_TODAY = new DoubleTimeSeries[] {
            TS_IBOR_EUR3M_WITHOUT_TODAY };
    @SuppressWarnings("rawtypes")
    private static final DoubleTimeSeries[] TS_FIXED_IBOR_EURUSD3M_WITH_TODAY = new DoubleTimeSeries[] {
            TS_IBOR_EUR3M_WITH_TODAY, TS_IBOR_USD3M_WITH_TODAY };
    @SuppressWarnings("rawtypes")
    private static final DoubleTimeSeries[] TS_FIXED_IBOR_EURUSD3M_WITHOUT_TODAY = new DoubleTimeSeries[] {
            TS_IBOR_EUR3M_WITHOUT_TODAY, TS_IBOR_USD3M_WITHOUT_TODAY };
    @SuppressWarnings("rawtypes")
    private static final DoubleTimeSeries[] TS_FIXED_IBOR_JPY3MJPY6M_WITH_TODAY = new DoubleTimeSeries[] {
            TS_IBOR_JPY3M_WITH_TODAY, TS_IBOR_JPY6M_WITH_TODAY };
    @SuppressWarnings("rawtypes")
    private static final DoubleTimeSeries[] TS_FIXED_IBOR_JPY3MJPY6M_WITHOUT_TODAY = new DoubleTimeSeries[] {
            TS_IBOR_JPY3M_WITHOUT_TODAY, TS_IBOR_JPY6M_WITHOUT_TODAY };

    private static final String CURVE_NAME_DSC_USD = "USD Dsc";
    private static final String CURVE_NAME_FWD3_USD = "USD Fwd 3M";
    private static final String CURVE_NAME_DSC_EUR = "EUR Dsc";
    private static final String CURVE_NAME_FWD3_EUR = "EUR Fwd 3M";
    private static final String CURVE_NAME_DSC_JPY = "JPY Dsc";
    private static final String CURVE_NAME_FWD3_JPY = "JPY Fwd 3M";
    private static final String CURVE_NAME_FWD6_JPY = "JPY Fwd 6M";
    private static final HashMap<String, Currency> CCY_MAP = new HashMap<String, Currency>();
    static {
        CCY_MAP.put(CURVE_NAME_DSC_USD, CCY_USD);
        CCY_MAP.put(CURVE_NAME_FWD3_USD, CCY_USD);
        CCY_MAP.put(CURVE_NAME_DSC_EUR, CCY_EUR);
        CCY_MAP.put(CURVE_NAME_FWD3_EUR, CCY_EUR);
        CCY_MAP.put(CURVE_NAME_DSC_JPY, CCY_JPY);
        CCY_MAP.put(CURVE_NAME_FWD3_JPY, CCY_JPY);
        CCY_MAP.put(CURVE_NAME_FWD6_JPY, CCY_JPY);
        FX_MATRIX.addCurrency(CCY_EUR, CCY_USD, FX_EURUSD);
        FX_MATRIX.addCurrency(CCY_JPY, CCY_USD, 1 / FX_USDJPY);
    }

    /** Market values for the dsc USD curve */
    public static final double[] DSC_1_MARKET_QUOTES = new double[] { 0.0010, 0.0010, 0.0010, 0.0010, 0.0010,
            0.0010, 0.0010, 0.0010, 0.0015, 0.0020, 0.0035, 0.0050, 0.0130 };
    /** Generators for the dsc USD curve */
    public static final GeneratorInstrument[] DSC_1_GENERATORS = new GeneratorInstrument[] { GENERATOR_DEPOSIT_ON_1,
            GENERATOR_DEPOSIT_ON_1, GENERATOR_OIS_1, GENERATOR_OIS_1, GENERATOR_OIS_1, GENERATOR_OIS_1,
            GENERATOR_OIS_1, GENERATOR_OIS_1, GENERATOR_OIS_1, GENERATOR_OIS_1, GENERATOR_OIS_1, GENERATOR_OIS_1,
            GENERATOR_OIS_1 };
    /** Tenors for the dsc USD curve */
    public static final Period[] DSC_1_TENOR = new Period[] { Period.ofDays(0), Period.ofDays(1),
            Period.ofMonths(1), Period.ofMonths(2), Period.ofMonths(3), Period.ofMonths(6), Period.ofMonths(9),
            Period.ofYears(1), Period.ofYears(2), Period.ofYears(3), Period.ofYears(4), Period.ofYears(5),
            Period.ofYears(10) };

    /** Market values for the Fwd 3M USD curve */
    public static final double[] FWD_1_MARKET_QUOTES = new double[] { 0.0045, 0.0045, 0.0045, 0.0045, 0.0060,
            0.0070, 0.0080, 0.0160 };
    /** Generators for the Fwd 3M USD curve */
    public static final GeneratorInstrument[] FWD_1_GENERATORS = new GeneratorInstrument[] { GENERATOR_DEPOSIT_USD,
            USD6MLIBOR3M, USD6MLIBOR3M, USD6MLIBOR3M, USD6MLIBOR3M, USD6MLIBOR3M, USD6MLIBOR3M, USD6MLIBOR3M };
    /** Tenors for the Fwd 3M USD curve */
    public static final Period[] FWD_1_TENOR = new Period[] { Period.ofMonths(3), Period.ofMonths(6),
            Period.ofYears(1), Period.ofYears(2), Period.ofYears(3), Period.ofYears(4), Period.ofYears(5),
            Period.ofYears(10) };

    /** Market values for the dsc EUR curve */
    public static final double[] DSC_EUR_MARKET_QUOTES = new double[] { 0.0010, 0.0010, 0.0004, 0.0009, 0.0015,
            0.0035, 0.0050, 0.0060, -0.0050, -0.0050, -0.0050, -0.0045, -0.0040 };
    //  public static final double[] DSC_EUR_MARKET_QUOTES = new double[] {0.0010, 0.0010, 0.0004 * FX_EURUSD, 0.0009 * FX_EURUSD, 0.0015 * FX_EURUSD, 0.0035 * FX_EURUSD, 0.0050 * FX_EURUSD,
    //    0.0060 * FX_EURUSD, -0.0050, -0.0050, -0.0050, -0.0045, -0.0040};
    /** Generators for the dsc EUR curve */
    public static final GeneratorInstrument[] DSC_EUR_GENERATORS = new GeneratorInstrument[] {
            GENERATOR_DEPOSIT_ON_2, GENERATOR_DEPOSIT_ON_2, GENERATOR_FX_EURUSD, GENERATOR_FX_EURUSD,
            GENERATOR_FX_EURUSD, GENERATOR_FX_EURUSD, GENERATOR_FX_EURUSD, GENERATOR_FX_EURUSD, EURIBOR3MUSDLIBOR3M,
            EURIBOR3MUSDLIBOR3M, EURIBOR3MUSDLIBOR3M, EURIBOR3MUSDLIBOR3M, EURIBOR3MUSDLIBOR3M };
    /** Tenors for the dsc EUR curve */
    public static final Period[] DSC_EUR_TENOR = new Period[] { Period.ofDays(0), Period.ofDays(1),
            Period.ofMonths(1), Period.ofMonths(2), Period.ofMonths(3), Period.ofMonths(6), Period.ofMonths(9),
            Period.ofYears(1), Period.ofYears(2), Period.ofYears(3), Period.ofYears(4), Period.ofYears(5),
            Period.ofYears(10) };
    //  /** FX rqtes for the dsc EUR curve */
    //  public static final Double[] DSC_EUR_FX_RATE = new Double[] {FX_EURUSD, FX_EURUSD, FX_EURUSD, FX_EURUSD, FX_EURUSD, FX_EURUSD, FX_EURUSD, FX_EURUSD, FX_EURUSD, FX_EURUSD, FX_EURUSD, FX_EURUSD,
    //      FX_EURUSD};

    /** Market values for the Fwd 3M EUR curve */
    public static final double[] FWD_EUR_MARKET_QUOTES = new double[] { 0.0045, 0.0045, 0.0045, 0.0045, 0.0050,
            0.0060, 0.0085, 0.0160 };
    /** Generators for the Fwd 3M USD curve */
    public static final GeneratorInstrument[] FWD_EUR_GENERATORS = new GeneratorInstrument[] {
            GENERATOR_DEPOSIT_EUR, EUR1YEURIBOR3M, EUR1YEURIBOR3M, EUR1YEURIBOR3M, EUR1YEURIBOR3M, EUR1YEURIBOR3M,
            EUR1YEURIBOR3M, EUR1YEURIBOR3M };
    /** Tenors for the Fwd 3M USD curve */
    public static final Period[] FWD_EUR_TENOR = new Period[] { Period.ofMonths(3), Period.ofMonths(6),
            Period.ofYears(1), Period.ofYears(2), Period.ofYears(3), Period.ofYears(4), Period.ofYears(5),
            Period.ofYears(10) };

    /** Market values for the dsc JPY curve */
    public static final double[] DSC_JPY_MARKET_QUOTES = new double[] { 0.0005, 0.0005, -0.0004, -0.0008, -0.0012,
            -0.0024, -0.0036, -0.0048, -0.0030, -0.0040, -0.0040, -0.0045, -0.0050 };
    /** Generators for the dsc EUR curve */
    public static final GeneratorInstrument[] DSC_JPY_GENERATORS = new GeneratorInstrument[] {
            GENERATOR_DEPOSIT_ON_3, GENERATOR_DEPOSIT_ON_3, GENERATOR_FX_USDJPY, GENERATOR_FX_USDJPY,
            GENERATOR_FX_USDJPY, GENERATOR_FX_USDJPY, GENERATOR_FX_USDJPY, GENERATOR_FX_USDJPY,
            JPYLIBOR3MUSDLIBOR3M, JPYLIBOR3MUSDLIBOR3M, JPYLIBOR3MUSDLIBOR3M, JPYLIBOR3MUSDLIBOR3M,
            JPYLIBOR3MUSDLIBOR3M };
    /** Tenors for the dsc EUR curve */
    public static final Period[] DSC_JPY_TENOR = new Period[] { Period.ofDays(0), Period.ofDays(1),
            Period.ofMonths(1), Period.ofMonths(2), Period.ofMonths(3), Period.ofMonths(6), Period.ofMonths(9),
            Period.ofYears(1), Period.ofYears(2), Period.ofYears(3), Period.ofYears(4), Period.ofYears(5),
            Period.ofYears(10) };
    //  /** FX rqtes for the dsc EUR curve */
    //  public static final Double[] DSC_JPY_FX_RATE = new Double[] {FX_USDJPY, FX_USDJPY, FX_USDJPY, FX_USDJPY, FX_USDJPY, FX_USDJPY, FX_USDJPY, FX_USDJPY, FX_USDJPY, FX_USDJPY, FX_USDJPY, FX_USDJPY,
    //      FX_USDJPY};

    /** Market values for the Fwd 3M JPY curve */
    public static final double[] FWD3_JPY_MARKET_QUOTES = new double[] { 0.0020, 0.0010, 0.0010, 0.0010, 0.0010,
            0.0015, 0.0015, 0.0015 };
    /** Generators for the Fwd 3M JPY curve */
    public static final GeneratorInstrument[] FWD3_JPY_GENERATORS = new GeneratorInstrument[] {
            GENERATOR_DEPOSIT_JPY, JPYLIBOR6MLIBOR3M, JPYLIBOR6MLIBOR3M, JPYLIBOR6MLIBOR3M, JPYLIBOR6MLIBOR3M,
            JPYLIBOR6MLIBOR3M, JPYLIBOR6MLIBOR3M, JPYLIBOR6MLIBOR3M };
    /** Tenors for the Fwd 3M JPY curve */
    public static final Period[] FWD3_JPY_TENOR = new Period[] { Period.ofMonths(3), Period.ofMonths(6),
            Period.ofYears(1), Period.ofYears(2), Period.ofYears(3), Period.ofYears(4), Period.ofYears(5),
            Period.ofYears(10) };

    /** Market values for the Fwd 6M JPY curve */
    public static final double[] FWD6_JPY_MARKET_QUOTES = new double[] { 0.0035, 0.0035, 0.0035, 0.0040, 0.0040,
            0.0040, 0.0075 };
    /** Generators for the Fwd 6M JPY curve */
    public static final GeneratorInstrument[] FWD6_JPY_GENERATORS = new GeneratorInstrument[] {
            GENERATOR_DEPOSIT_JPY, JPY6MLIBOR6M, JPY6MLIBOR6M, JPY6MLIBOR6M, JPY6MLIBOR6M, JPY6MLIBOR6M,
            JPY6MLIBOR6M };
    /** Tenors for the Fwd 6M JPY curve */
    public static final Period[] FWD6_JPY_TENOR = new Period[] { Period.ofMonths(6), Period.ofYears(1),
            Period.ofYears(2), Period.ofYears(3), Period.ofYears(4), Period.ofYears(5), Period.ofYears(10) };

    /** Standard USD discounting curve instrument definitions */
    public static final InstrumentDefinition<?>[] DEFINITIONS_DSC_USD;
    /** Standard USD Forward 3M curve instrument definitions */
    public static final InstrumentDefinition<?>[] DEFINITIONS_FWD3_USD;
    /** Standard EUR discounting curve instrument definitions */
    public static final InstrumentDefinition<?>[] DEFINITIONS_DSC_EUR;
    /** Standard EUR Forward 3M curve instrument definitions */
    public static final InstrumentDefinition<?>[] DEFINITIONS_FWD3_EUR;
    /** Standard JPY discounting curve instrument definitions */
    public static final InstrumentDefinition<?>[] DEFINITIONS_DSC_JPY;
    /** Standard JPY Forward 3M curve instrument definitions */
    public static final InstrumentDefinition<?>[] DEFINITIONS_FWD3_JPY;
    /** Standard JPY Forward 6M curve instrument definitions */
    public static final InstrumentDefinition<?>[] DEFINITIONS_FWD6_JPY;
    /** Units of curves */
    public static final int[] NB_UNITS = new int[] { 3, 3, 1 };
    public static final int NB_BLOCKS = NB_UNITS.length;
    public static final InstrumentDefinition<?>[][][][] DEFINITIONS_UNITS = new InstrumentDefinition<?>[NB_BLOCKS][][][];
    public static final GeneratorYDCurve[][][] GENERATORS_UNITS = new GeneratorYDCurve[NB_BLOCKS][][];
    public static final String[][][] NAMES_UNITS = new String[NB_BLOCKS][][];
    public static final YieldCurveBundle KNOWN_DATA = new YieldCurveBundle(FX_MATRIX, CCY_MAP);

    static {
        DEFINITIONS_DSC_USD = getDefinitions(DSC_1_MARKET_QUOTES, DSC_1_GENERATORS, DSC_1_TENOR);
        DEFINITIONS_FWD3_USD = getDefinitions(FWD_1_MARKET_QUOTES, FWD_1_GENERATORS, FWD_1_TENOR);
        DEFINITIONS_DSC_EUR = getDefinitions(DSC_EUR_MARKET_QUOTES, DSC_EUR_GENERATORS, DSC_EUR_TENOR);
        DEFINITIONS_FWD3_EUR = getDefinitions(FWD_EUR_MARKET_QUOTES, FWD_EUR_GENERATORS, FWD_EUR_TENOR);
        DEFINITIONS_DSC_JPY = getDefinitions(DSC_JPY_MARKET_QUOTES, DSC_JPY_GENERATORS, DSC_JPY_TENOR);
        DEFINITIONS_FWD3_JPY = getDefinitions(FWD3_JPY_MARKET_QUOTES, FWD3_JPY_GENERATORS, FWD3_JPY_TENOR);
        DEFINITIONS_FWD6_JPY = getDefinitions(FWD6_JPY_MARKET_QUOTES, FWD6_JPY_GENERATORS, FWD6_JPY_TENOR);
        DEFINITIONS_UNITS[0] = new InstrumentDefinition<?>[NB_UNITS[0]][][];
        DEFINITIONS_UNITS[1] = new InstrumentDefinition<?>[NB_UNITS[1]][][];
        DEFINITIONS_UNITS[2] = new InstrumentDefinition<?>[NB_UNITS[2]][][];
        DEFINITIONS_UNITS[0][0] = new InstrumentDefinition<?>[][] { DEFINITIONS_DSC_USD };
        DEFINITIONS_UNITS[0][1] = new InstrumentDefinition<?>[][] { DEFINITIONS_FWD3_USD };
        DEFINITIONS_UNITS[0][2] = new InstrumentDefinition<?>[][] { DEFINITIONS_DSC_EUR, DEFINITIONS_FWD3_EUR };
        DEFINITIONS_UNITS[1][0] = new InstrumentDefinition<?>[][] { DEFINITIONS_DSC_USD };
        DEFINITIONS_UNITS[1][1] = new InstrumentDefinition<?>[][] { DEFINITIONS_FWD3_USD };
        DEFINITIONS_UNITS[1][2] = new InstrumentDefinition<?>[][] { DEFINITIONS_DSC_JPY, DEFINITIONS_FWD3_JPY,
                DEFINITIONS_FWD6_JPY };
        DEFINITIONS_UNITS[2][0] = new InstrumentDefinition<?>[][] { DEFINITIONS_DSC_USD, DEFINITIONS_FWD3_USD,
                DEFINITIONS_DSC_JPY, DEFINITIONS_FWD3_JPY, DEFINITIONS_FWD6_JPY };
        GeneratorYDCurve genInt = new GeneratorCurveYieldInterpolated(MATURITY_CALCULATOR, INTERPOLATOR);
        GENERATORS_UNITS[0] = new GeneratorYDCurve[NB_UNITS[0]][];
        GENERATORS_UNITS[1] = new GeneratorYDCurve[NB_UNITS[1]][];
        GENERATORS_UNITS[2] = new GeneratorYDCurve[NB_UNITS[2]][];
        GENERATORS_UNITS[0][0] = new GeneratorYDCurve[] { genInt };
        GENERATORS_UNITS[0][1] = new GeneratorYDCurve[] { genInt };
        GENERATORS_UNITS[0][2] = new GeneratorYDCurve[] { genInt, genInt };
        GENERATORS_UNITS[1][0] = new GeneratorYDCurve[] { genInt };
        GENERATORS_UNITS[1][1] = new GeneratorYDCurve[] { genInt };
        GENERATORS_UNITS[1][2] = new GeneratorYDCurve[] { genInt, genInt, genInt };
        GENERATORS_UNITS[2][0] = new GeneratorYDCurve[] { genInt, genInt, genInt, genInt, genInt };
        NAMES_UNITS[0] = new String[NB_UNITS[0]][];
        NAMES_UNITS[1] = new String[NB_UNITS[1]][];
        NAMES_UNITS[2] = new String[NB_UNITS[2]][];
        NAMES_UNITS[0][0] = new String[] { CURVE_NAME_DSC_USD };
        NAMES_UNITS[0][1] = new String[] { CURVE_NAME_FWD3_USD };
        NAMES_UNITS[0][2] = new String[] { CURVE_NAME_DSC_EUR, CURVE_NAME_FWD3_EUR };
        NAMES_UNITS[1][0] = new String[] { CURVE_NAME_DSC_USD };
        NAMES_UNITS[1][1] = new String[] { CURVE_NAME_FWD3_USD };
        NAMES_UNITS[1][2] = new String[] { CURVE_NAME_DSC_JPY, CURVE_NAME_FWD3_JPY, CURVE_NAME_FWD6_JPY };
        NAMES_UNITS[2][0] = new String[] { CURVE_NAME_DSC_USD, CURVE_NAME_FWD3_USD, CURVE_NAME_DSC_JPY,
                CURVE_NAME_FWD3_JPY, CURVE_NAME_FWD6_JPY };
    }

    // Present Value
    private static final PresentValueMCACalculator PV_CALCULATOR = PresentValueMCACalculator.getInstance();
    private static final PresentValueCurveSensitivityMCSCalculator PVCS_CALCULATOR = PresentValueCurveSensitivityMCSCalculator
            .getInstance();
    private static final Currency CCY_PV = CCY_USD;
    private static final PresentValueConvertedCalculator PV_CONVERTED_CALCULATOR = new PresentValueConvertedCalculator(
            CCY_PV, PV_CALCULATOR);
    private static final PresentValueCurveSensitivityConvertedCalculator PVCS_CONVERTED_CALCULATOR = new PresentValueCurveSensitivityConvertedCalculator(
            CCY_PV, PVCS_CALCULATOR);
    // Par spread market quote
    private static final ParSpreadMarketQuoteCalculator PSMQ_CALCULATOR = ParSpreadMarketQuoteCalculator
            .getInstance();
    private static final ParSpreadMarketQuoteCurveSensitivityCalculator PSMQCS_CALCULATOR = ParSpreadMarketQuoteCurveSensitivityCalculator
            .getInstance();

    private static Pair<YieldCurveBundle, CurveBuildingBlockBundle> CURVES_PRESENT_VALUE_WITH_TODAY_BLOCK0;
    private static Pair<YieldCurveBundle, CurveBuildingBlockBundle> CURVES_PAR_SPREAD_MQ_WITH_TODAY_BLOCK0;
    private static Pair<YieldCurveBundle, CurveBuildingBlockBundle> CURVES_PRESENT_VALUE_WITHOUT_TODAY_BLOCK0;
    private static Pair<YieldCurveBundle, CurveBuildingBlockBundle> CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_BLOCK0;
    private static Pair<YieldCurveBundle, CurveBuildingBlockBundle> CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_BLOCK1;
    private static Pair<YieldCurveBundle, CurveBuildingBlockBundle> CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_BLOCK2;
    private static Pair<YieldCurveBundle, CurveBuildingBlockBundle> CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_TOTAL;

    private static final double TOLERANCE_PV = 1.0E-10;

    @BeforeSuite
    static void initClass() {
        CURVES_PRESENT_VALUE_WITH_TODAY_BLOCK0 = makeCurves(DEFINITIONS_UNITS[0], GENERATORS_UNITS[0],
                NAMES_UNITS[0], KNOWN_DATA, PV_CONVERTED_CALCULATOR, PVCS_CONVERTED_CALCULATOR, true, 0);
        CURVES_PAR_SPREAD_MQ_WITH_TODAY_BLOCK0 = makeCurves(DEFINITIONS_UNITS[0], GENERATORS_UNITS[0],
                NAMES_UNITS[0], KNOWN_DATA, PSMQ_CALCULATOR, PSMQCS_CALCULATOR, true, 0);
        CURVES_PRESENT_VALUE_WITHOUT_TODAY_BLOCK0 = makeCurves(DEFINITIONS_UNITS[0], GENERATORS_UNITS[0],
                NAMES_UNITS[0], KNOWN_DATA, PV_CONVERTED_CALCULATOR, PVCS_CONVERTED_CALCULATOR, false, 0);
        CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_BLOCK0 = makeCurves(DEFINITIONS_UNITS[0], GENERATORS_UNITS[0],
                NAMES_UNITS[0], KNOWN_DATA, PSMQ_CALCULATOR, PSMQCS_CALCULATOR, false, 0);
        CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_BLOCK1 = makeCurves(DEFINITIONS_UNITS[1], GENERATORS_UNITS[1],
                NAMES_UNITS[1], KNOWN_DATA, PSMQ_CALCULATOR, PSMQCS_CALCULATOR, false, 1);
        CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_BLOCK2 = makeCurves(DEFINITIONS_UNITS[2], GENERATORS_UNITS[2],
                NAMES_UNITS[2], KNOWN_DATA, PSMQ_CALCULATOR, PSMQCS_CALCULATOR, false, 2);
        YieldCurveBundle ycbTotal = CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_BLOCK0.getFirst().copy();
        ycbTotal.addAll(CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_BLOCK1.getFirst());
        CurveBuildingBlockBundle cubTotal = new CurveBuildingBlockBundle();
        cubTotal.addAll(CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_BLOCK0.getSecond());
        cubTotal.addAll(CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_BLOCK1.getSecond());
        CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_TOTAL = new ObjectsPair<YieldCurveBundle, CurveBuildingBlockBundle>(
                ycbTotal, cubTotal);
    }

    @Test
    public void curveConstructionGeneratorBlock0() {
        // Curve constructed with present value and today fixing
        curveConstructionTest(NAMES_UNITS[0], DEFINITIONS_UNITS[0],
                CURVES_PRESENT_VALUE_WITH_TODAY_BLOCK0.getFirst(), true, 0);
        // Curve constructed with par spread (market quote) and  today fixing
        curveConstructionTest(NAMES_UNITS[0], DEFINITIONS_UNITS[0],
                CURVES_PAR_SPREAD_MQ_WITH_TODAY_BLOCK0.getFirst(), true, 0);
        // Curve constructed with present value and no today fixing
        curveConstructionTest(NAMES_UNITS[0], DEFINITIONS_UNITS[0],
                CURVES_PRESENT_VALUE_WITHOUT_TODAY_BLOCK0.getFirst(), false, 0);
        // Curve constructed with par spread (market quote) and no today fixing
        curveConstructionTest(NAMES_UNITS[0], DEFINITIONS_UNITS[0],
                CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_BLOCK0.getFirst(), false, 0);
    }

    @Test
    public void curveConstructionGeneratorAllBlocks() {
        // Curve constructed with par spread (market quote) and  today fixing
        curveConstructionTest(NAMES_UNITS[0], DEFINITIONS_UNITS[0],
                CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_TOTAL.getFirst(), false, 0);
        curveConstructionTest(NAMES_UNITS[1], DEFINITIONS_UNITS[1],
                CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_TOTAL.getFirst(), false, 1);
        curveConstructionTest(NAMES_UNITS[2], DEFINITIONS_UNITS[2],
                CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_BLOCK2.getFirst(), false, 2);
    }

    @Test(enabled = true)
    public void curveSensitivity() {
        ZonedDateTime settleDate = ScheduleCalculator.getAdjustedDate(NOW, Period.ofMonths(6),
                GENERATOR_DEPOSIT_JPY);
        SwapXCcyIborIborDefinition swapJpyEurDefinition = SwapXCcyIborIborDefinition.from(settleDate,
                Period.ofYears(5), JPYLIBOR3MEURIBOR3M, 1000000000, 10000000, -0.0020, true);
        Swap<Payment, Payment> swapJpyEur = swapJpyEurDefinition.toDerivative(NOW,
                new String[] { CURVE_NAME_DSC_JPY, CURVE_NAME_FWD3_JPY, CURVE_NAME_DSC_EUR, CURVE_NAME_FWD3_EUR });
        ParameterSensitivityBlockCalculator psc = new ParameterSensitivityBlockCalculator(PVCS_CALCULATOR);
        @SuppressWarnings("unused")
        ParameterSensitivity ps = psc.calculateSensitivity(swapJpyEur, new HashSet<String>(),
                CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_TOTAL.getFirst());
        MarketQuoteSensitivityBlockCalculator mqsc = new MarketQuoteSensitivityBlockCalculator(psc);
        @SuppressWarnings("unused")
        ParameterSensitivity mqs = mqsc.fromInstrument(swapJpyEur, new HashSet<String>(),
                CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_TOTAL.getFirst(),
                CURVES_PAR_SPREAD_MQ_WITHOUT_TODAY_TOTAL.getSecond());
        int t = 0;
        t++;
    }

    public void curveConstructionTest(String[][] curveNames, final InstrumentDefinition<?>[][][] definitions,
            final YieldCurveBundle curves, final boolean withToday, int block) {
        int nbBlocks = definitions.length;
        for (int loopblock = 0; loopblock < nbBlocks; loopblock++) {
            InstrumentDerivative[] instruments = convert(curveNames, definitions[loopblock], loopblock, withToday,
                    block);
            double[] pv = new double[instruments.length];
            for (int loopins = 0; loopins < instruments.length; loopins++) {
                pv[loopins] = curves.getFxRates()
                        .convert(PV_CALCULATOR.visit(instruments[loopins], curves), CCY_USD).getAmount();
                assertEquals("Curve construction: node block " + loopblock + " - instrument " + loopins, 0,
                        pv[loopins], TOLERANCE_PV);
            }
        }
    }

    @Test(enabled = false)
    public void performance() {
        long startTime, endTime;
        final int nbTest = 10;
        @SuppressWarnings("unused")
        Pair<YieldCurveBundle, CurveBuildingBlockBundle> curvePresentValue;
        Pair<YieldCurveBundle, CurveBuildingBlockBundle> curveParSpreadMQ0;
        Pair<YieldCurveBundle, CurveBuildingBlockBundle> curveParSpreadMQ1;
        @SuppressWarnings("unused")
        Pair<YieldCurveBundle, CurveBuildingBlockBundle> curveParSpreadMQ2;
        @SuppressWarnings("unused")
        Pair<YieldCurveBundle, CurveBuildingBlockBundle> curveParSpreadMQT;
        int nbIns0 = DEFINITIONS_DSC_USD.length + DEFINITIONS_FWD3_USD.length + DEFINITIONS_DSC_EUR.length
                + DEFINITIONS_FWD3_EUR.length;
        int nbIns1 = DEFINITIONS_DSC_USD.length + DEFINITIONS_FWD3_USD.length + DEFINITIONS_DSC_JPY.length
                + DEFINITIONS_FWD3_JPY.length + DEFINITIONS_FWD6_JPY.length;
        int nbInsT = DEFINITIONS_DSC_USD.length + DEFINITIONS_FWD3_USD.length + DEFINITIONS_DSC_EUR.length
                + DEFINITIONS_FWD3_EUR.length + DEFINITIONS_DSC_JPY.length + DEFINITIONS_FWD3_JPY.length
                + DEFINITIONS_FWD6_JPY.length;

        startTime = System.currentTimeMillis();
        for (int looptest = 0; looptest < nbTest; looptest++) {
            curvePresentValue = makeCurves(DEFINITIONS_UNITS[0], GENERATORS_UNITS[0], NAMES_UNITS[0], KNOWN_DATA,
                    PV_CONVERTED_CALCULATOR, PVCS_CONVERTED_CALCULATOR, true, 0);
        }
        endTime = System.currentTimeMillis();
        System.out.println(nbTest + " curve construction Full (4 curves, 2 ccy and " + nbIns0
                + " instruments in 3 units) - with present value: " + (endTime - startTime) + " ms");
        // Performance note: curve construction (with present value, 4 curves - 2 ccy and 42 instruments by units): 23-Jul-2012: On Mac Pro 3.2 GHz Quad-Core Intel Xeon: xx ms for 100 bundles.

        startTime = System.currentTimeMillis();
        for (int looptest = 0; looptest < nbTest; looptest++) {
            curveParSpreadMQ0 = makeCurves(DEFINITIONS_UNITS[0], GENERATORS_UNITS[0], NAMES_UNITS[0], KNOWN_DATA,
                    PSMQ_CALCULATOR, PSMQCS_CALCULATOR, true, 0);
        }
        endTime = System.currentTimeMillis();
        System.out.println(nbTest + " curve construction Full (4 curves, 2 ccy and " + nbIns0
                + " instruments in 3 units)- with par spread-market quote: " + (endTime - startTime) + " ms");
        // Performance note: curve construction (with par spread/market quote), 4 curves - 2 ccy and 49 instruments by units): 23-Jul-2012: On Mac Pro 3.2 GHz Quad-Core Intel Xeon: x ms for 100 bundles.

        startTime = System.currentTimeMillis();
        for (int looptest = 0; looptest < nbTest; looptest++) {
            curveParSpreadMQ1 = makeCurves(DEFINITIONS_UNITS[1], GENERATORS_UNITS[1], NAMES_UNITS[1], KNOWN_DATA,
                    PSMQ_CALCULATOR, PSMQCS_CALCULATOR, true, 1);
        }
        endTime = System.currentTimeMillis();
        System.out.println(nbTest + " curve construction Full (5 curves, 2 ccy and " + nbIns1
                + " instruments in 3 units) - with par spread-market quote: " + (endTime - startTime) + " ms");
        // Performance note: curve construction (with par spread/market quote), 4 curves - 2 ccy and 49 instruments by units): 23-Jul-2012: On Mac Pro 3.2 GHz Quad-Core Intel Xeon: x ms for 100 bundles.

        startTime = System.currentTimeMillis();
        for (int looptest = 0; looptest < nbTest; looptest++) {
            curveParSpreadMQ2 = makeCurves(DEFINITIONS_UNITS[2], GENERATORS_UNITS[2], NAMES_UNITS[2], KNOWN_DATA,
                    PSMQ_CALCULATOR, PSMQCS_CALCULATOR, true, 2);
        }
        endTime = System.currentTimeMillis();
        System.out.println(nbTest + " curve construction Full (5 curves, 2 ccy and " + nbIns1
                + " instruments in 1 units) - with par spread-market quote: " + (endTime - startTime) + " ms");
        // Performance note: curve construction (with par spread/market quote), 4 curves - 2 ccy and 49 instruments by units): 23-Jul-2012: On Mac Pro 3.2 GHz Quad-Core Intel Xeon: x ms for 100 bundles.

        startTime = System.currentTimeMillis();
        for (int looptest = 0; looptest < nbTest; looptest++) {
            curveParSpreadMQ0 = makeCurves(DEFINITIONS_UNITS[0], GENERATORS_UNITS[0], NAMES_UNITS[0], KNOWN_DATA,
                    PSMQ_CALCULATOR, PSMQCS_CALCULATOR, true, 0);
            curveParSpreadMQ1 = makeCurves(DEFINITIONS_UNITS[1], GENERATORS_UNITS[1], NAMES_UNITS[1], KNOWN_DATA,
                    PSMQ_CALCULATOR, PSMQCS_CALCULATOR, true, 1);
            YieldCurveBundle ycbTotal = curveParSpreadMQ0.getFirst().copy();
            ycbTotal.addAll(curveParSpreadMQ0.getFirst());
            CurveBuildingBlockBundle cubTotal = new CurveBuildingBlockBundle();
            cubTotal.addAll(curveParSpreadMQ1.getSecond());
            cubTotal.addAll(curveParSpreadMQ1.getSecond());
            curveParSpreadMQT = new ObjectsPair<YieldCurveBundle, CurveBuildingBlockBundle>(ycbTotal, cubTotal);
        }
        endTime = System.currentTimeMillis();
        System.out.println(nbTest + " curve construction Full (7 curves, 3 ccy and " + nbInsT
                + " instruments in 4 units) - with par spread-market quote: " + (endTime - startTime) + " ms");
        // Performance note: curve construction (with par spread/market quote), 7 curves - 3 ccy and 70 instruments by units): 23-Jul-2012: On Mac Pro 3.2 GHz Quad-Core Intel Xeon: x ms for 100 bundles.

        startTime = System.currentTimeMillis();
        for (int looptest = 0; looptest < nbTest; looptest++) {
            curvePresentValue = makeCurves(DEFINITIONS_UNITS[0], GENERATORS_UNITS[0], NAMES_UNITS[0], KNOWN_DATA,
                    PV_CONVERTED_CALCULATOR, PVCS_CONVERTED_CALCULATOR, true, 0);
        }
        endTime = System.currentTimeMillis();
        System.out.println(nbTest + " curve construction Full (4 curves, 2 ccy and " + nbIns0
                + " instruments in 3 units) - with present value: " + (endTime - startTime) + " ms");
        // Performance note: curve construction (with present value, 4 curves - 2 ccy and 42 instruments by units): 23-Jul-2012: On Mac Pro 3.2 GHz Quad-Core Intel Xeon: xx ms for 100 bundles.

        startTime = System.currentTimeMillis();
        for (int looptest = 0; looptest < nbTest; looptest++) {
            curveParSpreadMQ0 = makeCurves(DEFINITIONS_UNITS[0], GENERATORS_UNITS[0], NAMES_UNITS[0], KNOWN_DATA,
                    PSMQ_CALCULATOR, PSMQCS_CALCULATOR, true, 0);
        }
        endTime = System.currentTimeMillis();
        System.out.println(nbTest + " curve construction Full (4 curves, 2 ccy and " + nbIns0
                + " instruments in 3 units)- with par spread-market quote: " + (endTime - startTime) + " ms");
        // Performance note: curve construction (with par spread/market quote), 4 curves - 2 ccy and 49 instruments by units): 23-Jul-2012: On Mac Pro 3.2 GHz Quad-Core Intel Xeon: x ms for 100 bundles.

        startTime = System.currentTimeMillis();
        for (int looptest = 0; looptest < nbTest; looptest++) {
            curveParSpreadMQ1 = makeCurves(DEFINITIONS_UNITS[1], GENERATORS_UNITS[1], NAMES_UNITS[1], KNOWN_DATA,
                    PSMQ_CALCULATOR, PSMQCS_CALCULATOR, true, 1);
        }
        endTime = System.currentTimeMillis();
        System.out.println(nbTest + " curve construction Full (5 curves, 2 ccy and " + nbIns1
                + " instruments in 3 units) - with par spread-market quote: " + (endTime - startTime) + " ms");
        // Performance note: curve construction (with par spread/market quote), 4 curves - 2 ccy and 49 instruments by units): 23-Jul-2012: On Mac Pro 3.2 GHz Quad-Core Intel Xeon: x ms for 100 bundles.

        startTime = System.currentTimeMillis();
        for (int looptest = 0; looptest < nbTest; looptest++) {
            curveParSpreadMQ2 = makeCurves(DEFINITIONS_UNITS[2], GENERATORS_UNITS[2], NAMES_UNITS[2], KNOWN_DATA,
                    PSMQ_CALCULATOR, PSMQCS_CALCULATOR, true, 2);
        }
        endTime = System.currentTimeMillis();
        System.out.println(nbTest + " curve construction Full (5 curves, 2 ccy and " + nbIns1
                + " instruments in 1 units) - with par spread-market quote: " + (endTime - startTime) + " ms");
        // Performance note: curve construction (with par spread/market quote), 4 curves - 2 ccy and 49 instruments by units): 23-Jul-2012: On Mac Pro 3.2 GHz Quad-Core Intel Xeon: x ms for 100 bundles.

        startTime = System.currentTimeMillis();
        for (int looptest = 0; looptest < nbTest; looptest++) {
            curveParSpreadMQ0 = makeCurves(DEFINITIONS_UNITS[0], GENERATORS_UNITS[0], NAMES_UNITS[0], KNOWN_DATA,
                    PSMQ_CALCULATOR, PSMQCS_CALCULATOR, true, 0);
            curveParSpreadMQ1 = makeCurves(DEFINITIONS_UNITS[1], GENERATORS_UNITS[1], NAMES_UNITS[1], KNOWN_DATA,
                    PSMQ_CALCULATOR, PSMQCS_CALCULATOR, true, 1);
            YieldCurveBundle ycbTotal = curveParSpreadMQ0.getFirst().copy();
            ycbTotal.addAll(curveParSpreadMQ0.getFirst());
            CurveBuildingBlockBundle cubTotal = new CurveBuildingBlockBundle();
            cubTotal.addAll(curveParSpreadMQ1.getSecond());
            cubTotal.addAll(curveParSpreadMQ1.getSecond());
            curveParSpreadMQT = new ObjectsPair<YieldCurveBundle, CurveBuildingBlockBundle>(ycbTotal, cubTotal);
        }
        endTime = System.currentTimeMillis();
        System.out.println(nbTest + " curve construction Full (7 curves, 3 ccy and " + nbIns1
                + " instruments in 4 units) - with par spread-market quote: " + (endTime - startTime) + " ms");
        // Performance note: curve construction (with par spread/market quote), 7 curves - 3 ccy and 70 instruments by units): 23-Jul-2012: On Mac Pro 3.2 GHz Quad-Core Intel Xeon: x ms for 100 bundles.

    }

    public static InstrumentDefinition<?>[] getDefinitions(final double[] marketQuotes,
            final GeneratorInstrument[] generators, final Period[] tenors) {
        final InstrumentDefinition<?>[] definitions = new InstrumentDefinition<?>[marketQuotes.length];
        for (int loopmv = 0; loopmv < marketQuotes.length; loopmv++) {
            definitions[loopmv] = generators[loopmv].generateInstrument(NOW, tenors[loopmv], marketQuotes[loopmv],
                    NOTIONAL, FX_MATRIX);
        }
        return definitions;
    }

    private static Pair<YieldCurveBundle, Double[]> makeUnit(InstrumentDerivative[] instruments, double[] initGuess,
            LinkedHashMap<String, GeneratorYDCurve> curveGenerators, YieldCurveBundle knownData,
            final AbstractInstrumentDerivativeVisitor<YieldCurveBundle, Double> calculator,
            final AbstractInstrumentDerivativeVisitor<YieldCurveBundle, InterestRateCurveSensitivity> sensitivityCalculator) {
        final MultipleYieldCurveFinderGeneratorDataBundle data = new MultipleYieldCurveFinderGeneratorDataBundle(
                instruments, knownData, curveGenerators);
        final Function1D<DoubleMatrix1D, DoubleMatrix1D> curveCalculator = new MultipleYieldCurveFinderGeneratorFunction(
                calculator, data);
        final Function1D<DoubleMatrix1D, DoubleMatrix2D> jacobianCalculator = new MultipleYieldCurveFinderGeneratorJacobian(
                new ParameterSensitivityCalculator(sensitivityCalculator), data);
        final double[] parameters = ROOT_FINDER
                .getRoot(curveCalculator, jacobianCalculator, new DoubleMatrix1D(initGuess)).getData();
        final YieldCurveBundle newCurves = data.getBuildingFunction().evaluate(new DoubleMatrix1D(parameters));
        return new ObjectsPair<YieldCurveBundle, Double[]>(newCurves, ArrayUtils.toObject(parameters));
    }

    private static DoubleMatrix2D[] makeCurveMatrix(InstrumentDerivative[] instrumentsTotal,
            LinkedHashMap<String, GeneratorYDCurve> curveGeneratorsTotal, int startBlock, int[] nbParameters,
            Double[] parametersTotal, YieldCurveBundle knownData,
            final AbstractInstrumentDerivativeVisitor<YieldCurveBundle, InterestRateCurveSensitivity> sensitivityCalculator) {
        final MultipleYieldCurveFinderGeneratorDataBundle data = new MultipleYieldCurveFinderGeneratorDataBundle(
                instrumentsTotal, knownData, curveGeneratorsTotal);
        final Function1D<DoubleMatrix1D, DoubleMatrix2D> jacobianCalculator = new MultipleYieldCurveFinderGeneratorJacobian(
                new ParameterSensitivityCalculator(sensitivityCalculator), data);
        final DoubleMatrix2D jacobian = jacobianCalculator.evaluate(new DoubleMatrix1D(parametersTotal));
        final DoubleMatrix2D inverseJacobian = MATRIX_ALGEBRA.getInverse(jacobian);
        double[][] matrixTotal = inverseJacobian.getData();
        DoubleMatrix2D[] result = new DoubleMatrix2D[nbParameters.length];
        int startCurve = 0;
        for (int loopmat = 0; loopmat < nbParameters.length; loopmat++) {
            double[][] matrixCurve = new double[nbParameters[loopmat]][matrixTotal.length];
            for (int loopparam = 0; loopparam < nbParameters[loopmat]; loopparam++) {
                matrixCurve[loopparam] = matrixTotal[startBlock + startCurve + loopparam].clone();
            }
            result[loopmat] = new DoubleMatrix2D(matrixCurve);
            startCurve += nbParameters[loopmat];
        }
        return result;
    }

    private static Pair<YieldCurveBundle, CurveBuildingBlockBundle> makeCurves(
            final InstrumentDefinition<?>[][][] definitions, GeneratorYDCurve[][] curveGenerators,
            String[][] curveNames, YieldCurveBundle knownData,
            final AbstractInstrumentDerivativeVisitor<YieldCurveBundle, Double> calculator,
            final AbstractInstrumentDerivativeVisitor<YieldCurveBundle, InterestRateCurveSensitivity> sensitivityCalculator,
            boolean withToday, int block) {
        int nbBlocks = curveGenerators.length;
        YieldCurveBundle knownSoFarData = knownData.copy();
        List<InstrumentDerivative> instrumentsSoFar = new ArrayList<InstrumentDerivative>();
        LinkedHashMap<String, GeneratorYDCurve> generatorsSoFar = new LinkedHashMap<String, GeneratorYDCurve>();
        LinkedHashMap<String, Pair<CurveBuildingBlock, DoubleMatrix2D>> unitBundleSoFar = new LinkedHashMap<String, Pair<CurveBuildingBlock, DoubleMatrix2D>>();
        List<Double> parametersSoFar = new ArrayList<Double>();
        LinkedHashMap<String, Pair<Integer, Integer>> unitMap = new LinkedHashMap<String, Pair<Integer, Integer>>();
        int start = 0;
        for (int loopunit = 0; loopunit < nbBlocks; loopunit++) {
            int startBlock = 0;
            InstrumentDerivative[] instruments = convert(curveNames, definitions[loopunit], loopunit, withToday,
                    block);
            instrumentsSoFar.addAll(Arrays.asList(instruments));
            InstrumentDerivative[] instrumentsSoFarArray = instrumentsSoFar.toArray(new InstrumentDerivative[0]);
            double[] initGuess = initialGuess(definitions[loopunit]);
            LinkedHashMap<String, GeneratorYDCurve> gen = new LinkedHashMap<String, GeneratorYDCurve>();
            int[] nbIns = new int[curveGenerators[loopunit].length];
            for (int loopcurve = 0; loopcurve < curveGenerators[loopunit].length; loopcurve++) {
                nbIns[loopcurve] = definitions[loopunit][loopcurve].length;
                InstrumentDerivative[] insCurve = new InstrumentDerivative[nbIns[loopcurve]];
                System.arraycopy(instruments, startBlock, insCurve, 0, nbIns[loopcurve]);
                GeneratorYDCurve tmp = curveGenerators[loopunit][loopcurve].finalGenerator(insCurve);
                gen.put(curveNames[loopunit][loopcurve], tmp);
                generatorsSoFar.put(curveNames[loopunit][loopcurve], tmp);
                unitMap.put(curveNames[loopunit][loopcurve],
                        new ObjectsPair<Integer, Integer>(start + startBlock, nbIns[loopcurve]));
                startBlock += nbIns[loopcurve];
            }
            Pair<YieldCurveBundle, Double[]> unitCal = makeUnit(instruments, initGuess, gen, knownSoFarData,
                    calculator, sensitivityCalculator);
            parametersSoFar.addAll(Arrays.asList(unitCal.getSecond()));
            DoubleMatrix2D[] mat = makeCurveMatrix(instrumentsSoFarArray, generatorsSoFar, start, nbIns,
                    parametersSoFar.toArray(new Double[0]), knownData, sensitivityCalculator);
            for (int loopcurve = 0; loopcurve < curveGenerators[loopunit].length; loopcurve++) {
                unitBundleSoFar.put(curveNames[loopunit][loopcurve],
                        new ObjectsPair<CurveBuildingBlock, DoubleMatrix2D>(new CurveBuildingBlock(unitMap),
                                mat[loopcurve]));
            }
            knownSoFarData.addAll(unitCal.getFirst());
            start = start + startBlock;
        }
        return new ObjectsPair<YieldCurveBundle, CurveBuildingBlockBundle>(knownSoFarData,
                new CurveBuildingBlockBundle(unitBundleSoFar));
    }

    @SuppressWarnings("unchecked")
    private static InstrumentDerivative[] convert(String[][] curveNames, InstrumentDefinition<?>[][] definitions,
            int unit, boolean withToday, int block) {
        int nbDef = 0;
        for (int loopdef1 = 0; loopdef1 < definitions.length; loopdef1++) {
            nbDef += definitions[loopdef1].length;
        }
        final InstrumentDerivative[] instruments = new InstrumentDerivative[nbDef];
        int loopins = 0;
        for (int loopcurve = 0; loopcurve < definitions.length; loopcurve++) {
            for (final InstrumentDefinition<?> instrument : definitions[loopcurve]) {
                InstrumentDerivative ird;
                if (instrument instanceof SwapFixedONDefinition) {
                    final String[] names = getCurvesNameSwapFixedON(curveNames, unit);
                    ird = ((SwapFixedONDefinition) instrument).toDerivative(NOW, getTSSwapFixedON(withToday, unit),
                            names);
                } else {
                    if (instrument instanceof SwapFixedIborDefinition) {
                        final String[] names = getCurvesNameSwapFixedIbor(curveNames, unit, loopcurve, block);
                        ird = ((SwapFixedIborDefinition) instrument).toDerivative(NOW,
                                getTSSwapFixedIbor(withToday, unit), names);
                    } else {
                        if (instrument instanceof SwapXCcyIborIborDefinition) {
                            final String[] names = getCurvesNameSwapXCcyIborIbor(curveNames, block);
                            ird = ((SwapXCcyIborIborDefinition) instrument).toDerivative(NOW,
                                    getTSSwapXCcyIborIbor(withToday, unit), names);
                        } else {
                            if (instrument instanceof SwapIborIborDefinition) {
                                final String[] names = getCurvesNameSwapIborIbor(curveNames, unit, block);
                                ird = ((SwapIborIborDefinition) instrument).toDerivative(NOW,
                                        getTSSwapIborIbor(withToday, unit), names);
                            } else {
                                final String[] names;
                                if (instrument instanceof ForexSwapDefinition) {
                                    names = getCurvesNameFXSwap(curveNames, block);
                                } else {
                                    // Cash
                                    names = getCurvesNameCash(curveNames, unit, loopcurve, block);
                                }
                                ird = instrument.toDerivative(NOW, names);
                            }
                        }
                    }
                }
                instruments[loopins++] = ird;
            }
        }
        return instruments;
    }

    private static double initialGuess(InstrumentDefinition<?> instrument) {
        if (instrument instanceof SwapFixedONDefinition) {
            return ((SwapFixedONDefinition) instrument).getFixedLeg().getNthPayment(0).getRate();
        }
        if (instrument instanceof SwapFixedIborDefinition) {
            return ((SwapFixedIborDefinition) instrument).getFixedLeg().getNthPayment(0).getRate();
        }
        if (instrument instanceof ForwardRateAgreementDefinition) {
            return ((ForwardRateAgreementDefinition) instrument).getRate();
        }
        if (instrument instanceof CashDefinition) {
            return ((CashDefinition) instrument).getRate();
        }
        return 0.01;
    }

    private static double[] initialGuess(InstrumentDefinition<?>[][] definitions) {
        int nbDef = 0;
        for (int loopdef1 = 0; loopdef1 < definitions.length; loopdef1++) {
            nbDef += definitions[loopdef1].length;
        }
        double[] result = new double[nbDef];
        int loopr = 0;
        for (int loopcurve = 0; loopcurve < definitions.length; loopcurve++) {
            for (int loopins = 0; loopins < definitions[loopcurve].length; loopins++) {
                result[loopr++] = initialGuess(definitions[loopcurve][loopins]);
            }
        }
        return result;
    }

    private static String[] getCurvesNameSwapFixedON(String[][] curveNames, Integer unit) {
        switch (unit) {
        case 0:
            return new String[] { curveNames[0][0], curveNames[0][0] };
        case 2:
            return new String[] { curveNames[2][0], curveNames[2][0] };
        default:
            throw new IllegalArgumentException(unit.toString());
        }
    }

    private static String[] getCurvesNameSwapFixedIbor(String[][] curveNames, Integer unit, Integer curve,
            int block) {
        if (block != 2) {
            switch (unit) {
            case 1:
                return new String[] { curveNames[0][0], curveNames[1][0] };
            case 2:
                return new String[] { curveNames[2][0], curveNames[2][1] };
            default:
                throw new IllegalArgumentException(unit.toString());
            }
        }
        switch (curve) {
        case 1:
            return new String[] { curveNames[0][0], curveNames[0][1] };
        case 4:
            return new String[] { curveNames[0][2], curveNames[0][4] };
        default:
            throw new IllegalArgumentException(unit.toString());
        }
    }

    private static String[] getCurvesNameSwapXCcyIborIbor(String[][] curveNames, int block) {
        switch (block) {
        case 2:
            return new String[] { curveNames[0][2], curveNames[0][3], curveNames[0][0], curveNames[0][1] };
        default:
            return new String[] { curveNames[2][0], curveNames[2][1], curveNames[0][0], curveNames[1][0] };
        }
    }

    private static String[] getCurvesNameSwapIborIbor(String[][] curveNames, Integer unit, int block) {
        if (block != 2) {
            switch (unit) {
            case 2:
                return new String[] { curveNames[2][0], curveNames[2][1], curveNames[2][2] };
            default:
                throw new IllegalArgumentException(unit.toString());
            }
        }
        return new String[] { curveNames[0][2], curveNames[0][3], curveNames[0][4] };
    }

    private static String[] getCurvesNameCash(String[][] curveNames, Integer unit, Integer curve, int block) {
        if (block != 2) {
            switch (unit) {
            case 0:
                return new String[] { curveNames[0][0] };
            case 1:
                return new String[] { curveNames[1][0] };
            case 2:
                return new String[] { curveNames[2][curve] };
            default:
                throw new IllegalArgumentException(unit.toString());
            }
        }
        return new String[] { curveNames[0][curve] };

    }

    private static String[] getCurvesNameFXSwap(String[][] curveNames, int block) {
        switch (block) {
        case 2:
            return new String[] { curveNames[0][2], curveNames[0][0] };
        default:
            return new String[] { curveNames[2][0], curveNames[0][0] };
        }
    }

    @SuppressWarnings("rawtypes")
    private static DoubleTimeSeries[] getTSSwapFixedON(Boolean withToday, Integer unit) {
        switch (unit) {
        case 0:
            return withToday ? TS_FIXED_OIS_USD_WITH_TODAY : TS_FIXED_OIS_USD_WITHOUT_TODAY;
        default:
            throw new IllegalArgumentException(unit.toString());
        }
    }

    @SuppressWarnings("rawtypes")
    private static DoubleTimeSeries[] getTSSwapFixedIbor(Boolean withToday, Integer unit) {
        switch (unit) {
        case 0:
            return TS_FIXED_IBOR_USD3M_WITHOUT_TODAY;
        case 1:
            return withToday ? TS_FIXED_IBOR_USD3M_WITH_TODAY : TS_FIXED_IBOR_USD3M_WITHOUT_TODAY;
        case 2:
            return withToday ? TS_FIXED_IBOR_EUR3M_WITH_TODAY : TS_FIXED_IBOR_EUR3M_WITHOUT_TODAY;
        default:
            throw new IllegalArgumentException(unit.toString());
        }
    }

    @SuppressWarnings("rawtypes")
    private static DoubleTimeSeries[] getTSSwapXCcyIborIbor(Boolean withToday, Integer unit) {
        switch (unit) {
        case 0:
            return TS_FIXED_IBOR_EURUSD3M_WITHOUT_TODAY;
        case 2:
            return withToday ? TS_FIXED_IBOR_EURUSD3M_WITH_TODAY : TS_FIXED_IBOR_EURUSD3M_WITHOUT_TODAY;
        default:
            throw new IllegalArgumentException(unit.toString());
        }
    }

    @SuppressWarnings("rawtypes")
    private static DoubleTimeSeries[] getTSSwapIborIbor(Boolean withToday, Integer unit) {
        switch (unit) {
        case 0:
            return TS_FIXED_IBOR_JPY3MJPY6M_WITHOUT_TODAY;
        case 2:
            return withToday ? TS_FIXED_IBOR_JPY3MJPY6M_WITH_TODAY : TS_FIXED_IBOR_JPY3MJPY6M_WITHOUT_TODAY;
        default:
            throw new IllegalArgumentException(unit.toString());
        }
    }

}