Interpolator1DDataBundleTestCase.java

/**
 * Copyright (C) 2009 - present by OpenGamma Inc. and the OpenGamma group of companies
 *
 * Please see distribution for license.
 */
package com.opengamma.analytics.math.interpolation.data;

import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertNull;
import static org.testng.AssertJUnit.assertTrue;

import java.util.Arrays;

import org.testng.annotations.Test;

import com.opengamma.util.test.TestGroup;

/**
 * Abstract test.
 */
@Test(groups = TestGroup.UNIT)
public abstract class Interpolator1DDataBundleTestCase {
  private static final double EPS = 1e-16;
  private static final double[] KEYS1 = new double[] {5., 1., 4., 2., 3.};
  private static final double[] VALUES1 = new double[] {50., 10., 40., 20., 30.};
  private final Interpolator1DDataBundle DATA = createDataBundle(KEYS1, VALUES1);

  protected abstract Interpolator1DDataBundle createDataBundle(double[] keys, double[] values);

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void testLowLowerBoundKey() {
    DATA.getLowerBoundKey(0.5);
  }

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void testHighLowerBoundKey() {
    DATA.getLowerBoundKey(10.);
  }

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void testLowLowerBoundIndex() {
    DATA.getLowerBoundIndex(0.5);
  }

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void testHighLowerBoundIndex() {
    DATA.getLowerBoundIndex(10.);
  }

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void testLowHigherKey() {
    DATA.higherKey(0.5);
  }

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void testHighHigherKey() {
    DATA.higherKey(10.);
  }

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void testSetNegativeIndex() {
    DATA.setYValueAtIndex(-2, 3);
  }

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void testSetHighIndex() {
    DATA.setYValueAtIndex(100, 4);
  }

  @Test
  public void size() {
    assertEquals(5, DATA.size());
  }

  @Test
  public void lowerBounds() {
    assertEquals(1., DATA.getLowerBoundKey(1.5), EPS);
    assertEquals(1., DATA.getLowerBoundKey(1.), EPS);
    assertEquals(4, DATA.getLowerBoundKey(4.), EPS);
    assertEquals(5, DATA.getLowerBoundKey(5.), EPS);
  }

  @Test
  public void lowerBoundIndices() {
    assertEquals(0, DATA.getLowerBoundIndex(1.5));
    assertEquals(0, DATA.getLowerBoundIndex(1.));
    assertEquals(3, DATA.getLowerBoundIndex(4.));
    assertEquals(4, DATA.getLowerBoundIndex(5.));
  }

  @Test
  public void lowerBoundValues() {
    assertEquals(10, DATA.get(DATA.getLowerBoundKey(1.5)), EPS);
    assertEquals(10, DATA.get(DATA.getLowerBoundKey(1.)), EPS);
    assertEquals(40, DATA.get(DATA.getLowerBoundKey(4.)), EPS);
    assertEquals(50, DATA.get(DATA.getLowerBoundKey(5.)), EPS);
  }

  @Test
  public void firstKeyValue() {
    assertEquals(1., DATA.firstKey(), EPS);
    assertEquals(10., DATA.firstValue(), EPS);
  }

  @Test
  public void lastKeyValue() {
    assertEquals(5., DATA.lastKey(), EPS);
    assertEquals(50., DATA.lastValue(), EPS);
  }

  @Test
  public void higherKeyValue() {
    assertEquals(5., DATA.higherKey(4.5), EPS);
    assertEquals(50., DATA.higherValue(4.5), EPS);
    assertEquals(5., DATA.higherKey(4.), EPS);
    assertEquals(50., DATA.higherValue(4.), EPS);
    assertEquals(2., DATA.higherKey(1.), EPS);
    assertEquals(20., DATA.higherValue(1.), EPS);
    assertNull(DATA.higherKey(5.));
    assertNull(DATA.higherValue(5.));
  }

  @Test
  public void pointLookup() {
    assertEquals(10., DATA.get(1.), EPS);
    assertEquals(20., DATA.get(2.), EPS);
    assertEquals(30., DATA.get(3.), EPS);
    assertEquals(40., DATA.get(4.), EPS);
    assertEquals(50., DATA.get(5.), EPS);
    assertNull(DATA.get(4.5));
    assertNull(DATA.get(6.));
  }

  @Test
  public void containsKey() {
    assertTrue(DATA.containsKey(1.));
    assertTrue(DATA.containsKey(2.));
    assertTrue(DATA.containsKey(3.));
    assertTrue(DATA.containsKey(4.));
    assertTrue(DATA.containsKey(5.));
    assertFalse(DATA.containsKey(1.5));
  }

  @Test
  public void keys() {
    final double[] keys = DATA.getKeys();
    assertEquals(1., keys[0], EPS);
    assertEquals(2., keys[1], EPS);
    assertEquals(3., keys[2], EPS);
    assertEquals(4., keys[3], EPS);
    assertEquals(5., keys[4], EPS);
    assertEquals(5, keys.length);
  }

  @Test
  public void values() {
    final double[] values = DATA.getValues();
    assertEquals(10., values[0], EPS);
    assertEquals(20., values[1], EPS);
    assertEquals(30., values[2], EPS);
    assertEquals(40., values[3], EPS);
    assertEquals(50., values[4], EPS);
    assertEquals(5, values.length);
  }

  @Test
  public void testBoundedValues() {
    final InterpolationBoundedValues boundedValues = DATA.getBoundedValues(1.5);
    assertEquals(boundedValues.getLowerBoundKey(), 1., 0);
    assertEquals(boundedValues.getLowerBoundValue(), 10., 0);
    assertEquals(boundedValues.getHigherBoundKey(), 2., 0);
    assertEquals(boundedValues.getHigherBoundValue(), 20., 0);
  }

  @Test
  public void testEqualsAndHashCode() {
    Interpolator1DDataBundle other = createDataBundle(KEYS1, VALUES1);
    assertEquals(DATA, other);
    assertEquals(DATA.hashCode(), other.hashCode());
    final double[] x = new double[] {KEYS1[0] + 1.456, KEYS1[1] + 1.456, KEYS1[2] + 1.456, KEYS1[3] + 1.456, KEYS1[4] + 1.456};
    other = createDataBundle(x, VALUES1);
    assertFalse(DATA.equals(other));
    other = createDataBundle(KEYS1, x);
    assertFalse(DATA.equals(other));
  }

  @Test
  public void testSetYValue() {
    final int n = KEYS1.length;
    final double[] x = Arrays.copyOf(KEYS1, n);
    final double[] y = Arrays.copyOf(VALUES1, n);
    Arrays.sort(x);
    Arrays.sort(y);
    Interpolator1DDataBundle data1 = createDataBundle(x, y);
    final double newY = 120;
    final double[] yData = Arrays.copyOf(y, n);
    for (int i = 0; i < n; i++) {
      yData[i] = newY;
      data1.setYValueAtIndex(i, newY);
      assertEquals(data1, createDataBundle(x, yData));
      yData[i] = y[i];
      data1 = createDataBundle(x, y);
    }
  }
}