CurveShiftFunctionFactoryTest.java example

Explorer
OG-Platform-master
- projects
- sesame
/**
 * Copyright (C) 2009 - present by OpenGamma Inc. and the OpenGamma group of companies
 * 
 * Please see distribution for license.
 */
package com.opengamma.analytics.math.curve;

import static org.testng.AssertJUnit.assertEquals;
import static org.testng.internal.junit.ArrayAsserts.assertArrayEquals;

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

import com.opengamma.analytics.math.function.Function1D;
import com.opengamma.analytics.math.interpolation.LinearInterpolator1D;
import com.opengamma.util.test.TestGroup;

/**
 * Test.
 */
@Test(groups = TestGroup.UNIT)
public class CurveShiftFunctionFactoryTest {
  private static final Function1D<Double, Double> F = new Function1D<Double, Double>() {

    @Override
    public Double evaluate(final Double x) {
      return x;
    }

  };
  private static final ConstantDoublesCurve CONSTANT = ConstantDoublesCurve.from(3.4);
  private static final FunctionalDoublesCurve FUNCTIONAL = FunctionalDoublesCurve.from(F);
  private static final InterpolatedDoublesCurve INTERPOLATED = InterpolatedDoublesCurve.from(new double[] {1, 2 }, new double[] {1.2, 3.4 }, new LinearInterpolator1D());
  private static final SpreadDoublesCurve SPREAD = SpreadDoublesCurve.from(new AddCurveSpreadFunction(), new DoublesCurve[] {INTERPOLATED, CONSTANT });
  private static final DoublesCurve DUMMY = new DoublesCurve() {

    @Override
    public Double[] getXData() {
      return ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY;
    }

    @Override
    public Double[] getYData() {
      return ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY;
    }

    @Override
    public int size() {
      return 0;
    }

    @Override
    public Double getYValue(final Double x) {
      return 0.;
    }

    @Override
    public Double[] getYValueParameterSensitivity(final Double x) {
      return ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY;
    }

    @Override
    public double getDyDx(final double x) {
      return 0;
    }

  };

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void testWrongClass() {
    CurveShiftFunctionFactory.getFunction(String.class);
  }

  @Test
  public void testFunction() {
    assertEquals(ConstantCurveShiftFunction.class, CurveShiftFunctionFactory.getFunction(ConstantCurveShiftFunction.class).getClass());
    assertEquals(FunctionalCurveShiftFunction.class, CurveShiftFunctionFactory.getFunction(FunctionalCurveShiftFunction.class).getClass());
    assertEquals(InterpolatedCurveShiftFunction.class, CurveShiftFunctionFactory.getFunction(InterpolatedCurveShiftFunction.class).getClass());
    assertEquals(SpreadCurveShiftFunction.class, CurveShiftFunctionFactory.getFunction(SpreadCurveShiftFunction.class).getClass());
  }

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void testWrongCurveType1() {
    CurveShiftFunctionFactory.getShiftedCurve(DUMMY, 1);
  }

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void testWrongCurveType2() {
    CurveShiftFunctionFactory.getShiftedCurve(DUMMY, 1, "M");
  }

  @Test
  public void testGetShiftedCurve1() {
    final double shift = 2;
    Curve<Double, Double> shifted = CurveShiftFunctionFactory.getShiftedCurve(CONSTANT, shift);
    Curve<Double, Double> expected = new ConstantCurveShiftFunction().evaluate(CONSTANT, shift);
    assertEquals(shifted.getClass(), expected.getClass());
    assertEquals(shifted.getYValue(0.), expected.getYValue(0.));
    shifted = CurveShiftFunctionFactory.getShiftedCurve(INTERPOLATED, shift);
    expected = new InterpolatedCurveShiftFunction().evaluate(INTERPOLATED, shift);
    assertEquals(shifted.getClass(), expected.getClass());
    assertArrayEquals(shifted.getXData(), expected.getXData());
    assertArrayEquals(shifted.getYData(), expected.getYData());
    assertEquals(((InterpolatedDoublesCurve) shifted).getInterpolator(), ((InterpolatedDoublesCurve) expected).getInterpolator());
    assertArrayEquals(shifted.getXData(), expected.getXData());
    assertArrayEquals(shifted.getYData(), expected.getYData());
    shifted = CurveShiftFunctionFactory.getShiftedCurve(FUNCTIONAL, shift);
    expected = new FunctionalCurveShiftFunction().evaluate(FUNCTIONAL, shift);
    assertEquals(shifted.getClass(), expected.getClass());
    assertEquals(shifted.getYValue(0.), expected.getYValue(0.));
    shifted = CurveShiftFunctionFactory.getShiftedCurve(SPREAD, shift);
    expected = new SpreadCurveShiftFunction().evaluate(SPREAD, shift);
    assertEquals(shifted.getClass(), expected.getClass());
    assertEquals(shifted.getYValue(1.5), expected.getYValue(1.5));

    final String newName = "F";
    shifted = CurveShiftFunctionFactory.getShiftedCurve(CONSTANT, shift, newName);
    expected = new ConstantCurveShiftFunction().evaluate(CONSTANT, shift, newName);
    assertEquals(expected, shifted);
    shifted = CurveShiftFunctionFactory.getShiftedCurve(INTERPOLATED, shift, newName);
    expected = new InterpolatedCurveShiftFunction().evaluate(INTERPOLATED, shift, newName);
    assertEquals(expected, shifted);
    shifted = CurveShiftFunctionFactory.getShiftedCurve(FUNCTIONAL, shift, newName);
    expected = new FunctionalCurveShiftFunction().evaluate(FUNCTIONAL, shift, newName);
    assertEquals(shifted.getClass(), expected.getClass());
    assertEquals(shifted.getYValue(0.), expected.getYValue(0.));
    assertEquals(shifted.getName(), expected.getName());
    shifted = CurveShiftFunctionFactory.getShiftedCurve(SPREAD, shift, newName);
    expected = new SpreadCurveShiftFunction().evaluate(SPREAD, shift, newName);
    assertEquals(shifted.getClass(), expected.getClass());
    assertEquals(shifted.getYValue(1.5), expected.getYValue(1.5));
    assertEquals(shifted.getName(), expected.getName());
  }

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void testWrongCurveType3() {
    CurveShiftFunctionFactory.getShiftedCurve(DUMMY, 1, 1);
  }

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void testWrongCurveType4() {
    CurveShiftFunctionFactory.getShiftedCurve(DUMMY, 1, 1, "J");
  }

  @Test(expectedExceptions = UnsupportedOperationException.class)
  public void testUnsupportedShift1() {
    CurveShiftFunctionFactory.getShiftedCurve(CONSTANT, 1, 1);
  }

  @Test(expectedExceptions = UnsupportedOperationException.class)
  public void testUnsupportedShift2() {
    CurveShiftFunctionFactory.getShiftedCurve(FUNCTIONAL, 1, 1);
  }

  @Test(expectedExceptions = UnsupportedOperationException.class)
  public void testUnsupportedShift3() {
    CurveShiftFunctionFactory.getShiftedCurve(SPREAD, 1, 1);
  }

  @Test(expectedExceptions = UnsupportedOperationException.class)
  public void testUnsupportedShift4() {
    CurveShiftFunctionFactory.getShiftedCurve(CONSTANT, 1, 1, "L");
  }

  @Test(expectedExceptions = UnsupportedOperationException.class)
  public void testUnsupportedShift5() {
    CurveShiftFunctionFactory.getShiftedCurve(FUNCTIONAL, 1, 1, "P");
  }

  @Test(expectedExceptions = UnsupportedOperationException.class)
  public void testUnsupportedShift6() {
    CurveShiftFunctionFactory.getShiftedCurve(SPREAD, 1, 1, "O");
  }

  @Test
  public void testGetShiftedCurve2() {
    final double x = 1;
    final double shift = 2;
    Curve<Double, Double> shifted = CurveShiftFunctionFactory.getShiftedCurve(INTERPOLATED, x, shift);
    Curve<Double, Double> expected = new InterpolatedCurveShiftFunction().evaluate(INTERPOLATED, x, shift);
    assertEquals(shifted.getClass(), expected.getClass());
    assertArrayEquals(shifted.getXData(), expected.getXData());
    assertArrayEquals(shifted.getYData(), expected.getYData());
    assertEquals(((InterpolatedDoublesCurve) shifted).getInterpolator(), ((InterpolatedDoublesCurve) expected).getInterpolator());
    assertArrayEquals(shifted.getXData(), expected.getXData());
    assertArrayEquals(shifted.getYData(), expected.getYData());
    final String newName = "H";
    shifted = CurveShiftFunctionFactory.getShiftedCurve(INTERPOLATED, x, shift, newName);
    expected = new InterpolatedCurveShiftFunction().evaluate(INTERPOLATED, x, shift, newName);
    assertEquals(shifted, expected);
  }

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void testWrongCurveType5() {
    CurveShiftFunctionFactory.getShiftedCurve(DUMMY, new double[] {1 }, new double[] {1 });
  }

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void testWrongCurveType6() {
    CurveShiftFunctionFactory.getShiftedCurve(DUMMY, new double[] {1 }, new double[] {1 }, "N");
  }

  @Test(expectedExceptions = UnsupportedOperationException.class)
  public void testUnsupportedShift7() {
    CurveShiftFunctionFactory.getShiftedCurve(CONSTANT, new double[] {1 }, new double[] {1 });
  }

  @Test(expectedExceptions = UnsupportedOperationException.class)
  public void testUnsupportedShift8() {
    CurveShiftFunctionFactory.getShiftedCurve(FUNCTIONAL, new double[] {1 }, new double[] {1 });
  }

  @Test(expectedExceptions = UnsupportedOperationException.class)
  public void testUnsupportedShift9() {
    CurveShiftFunctionFactory.getShiftedCurve(SPREAD, new double[] {1 }, new double[] {1 });
  }

  @Test(expectedExceptions = UnsupportedOperationException.class)
  public void testUnsupportedShift10() {
    CurveShiftFunctionFactory.getShiftedCurve(CONSTANT, new double[] {1 }, new double[] {1 }, "L");
  }

  @Test(expectedExceptions = UnsupportedOperationException.class)
  public void testUnsupportedShift11() {
    CurveShiftFunctionFactory.getShiftedCurve(FUNCTIONAL, new double[] {1 }, new double[] {1 }, "K");
  }

  @Test(expectedExceptions = UnsupportedOperationException.class)
  public void testUnsupportedShift12() {
    CurveShiftFunctionFactory.getShiftedCurve(SPREAD, new double[] {1 }, new double[] {1 }, "J");
  }

  @Test
  public void testGetShiftedCurve3() {
    final double[] x = new double[] {1 };
    final double[] y = new double[] {2 };
    Curve<Double, Double> shifted = CurveShiftFunctionFactory.getShiftedCurve(INTERPOLATED, x, y);
    Curve<Double, Double> expected = new InterpolatedCurveShiftFunction().evaluate(INTERPOLATED, x, y);
    assertEquals(shifted.getClass(), expected.getClass());
    assertArrayEquals(shifted.getXData(), expected.getXData());
    assertArrayEquals(shifted.getYData(), expected.getYData());
    assertEquals(((InterpolatedDoublesCurve) shifted).getInterpolator(), ((InterpolatedDoublesCurve) expected).getInterpolator());
    assertArrayEquals(shifted.getXData(), expected.getXData());
    assertArrayEquals(shifted.getYData(), expected.getYData());
    final String newName = "M";
    shifted = CurveShiftFunctionFactory.getShiftedCurve(INTERPOLATED, x, y, newName);
    expected = new InterpolatedCurveShiftFunction().evaluate(INTERPOLATED, x, y, newName);
    assertEquals(shifted, expected);
    assertEquals(((InterpolatedDoublesCurve) shifted).getInterpolator(), ((InterpolatedDoublesCurve) expected).getInterpolator());
  }

}