com.opengamma.analytics.math.linearalgebra.LUDecompositionCommonsResultTest.java Source code

Introduction

Here is the source code for com.opengamma.analytics.math.linearalgebra.LUDecompositionCommonsResultTest.java

Source

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

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

import java.util.Arrays;

import org.apache.commons.math.linear.Array2DRowRealMatrix;
import org.apache.commons.math.linear.ArrayRealVector;
import org.apache.commons.math.linear.DecompositionSolver;
import org.apache.commons.math.linear.InvalidMatrixException;
import org.apache.commons.math.linear.LUDecomposition;
import org.apache.commons.math.linear.RealMatrix;
import org.apache.commons.math.linear.RealVector;
import org.testng.annotations.Test;

import com.opengamma.analytics.math.matrix.DoubleMatrix1D;
import com.opengamma.analytics.math.matrix.DoubleMatrix2D;

/**
 * 
 */
public class LUDecompositionCommonsResultTest {
    static final double DETERMINANT = 3;
    static final int[] PIVOT = new int[] { 1, 2, 3 };
    static final RealMatrix L = new Array2DRowRealMatrix(
            new double[][] { new double[] { 1, 2, 3 }, new double[] { 4, 5, 6 }, new double[] { 7, 8, 9 } });
    static final RealMatrix U = new Array2DRowRealMatrix(new double[][] { new double[] { 10, 11, 12 },
            new double[] { 13, 14, 15 }, new double[] { 16, 17, 18 } });
    static final RealMatrix P = new Array2DRowRealMatrix(new double[][] { new double[] { 19, 20, 21 },
            new double[] { 22, 23, 24 }, new double[] { 25, 26, 27 } });
    static final RealMatrix RESULT_2D = new Array2DRowRealMatrix(
            new double[][] { new double[] { 1, 2 }, new double[] { 3, 4 } });
    static final RealVector RESULT_1D = new ArrayRealVector(new double[] { 1, 2 });
    static final DecompositionSolver SOLVER = new MyDecompositionSolver();
    private static final LUDecompositionResult LU = new LUDecompositionCommonsResult(new MyLUDecomposition());

    @Test(expectedExceptions = IllegalArgumentException.class)
    public void testNullQR() {
        new QRDecompositionCommonsResult(null);
    }

    @Test(expectedExceptions = IllegalArgumentException.class)
    public void testNullArray() {
        LU.solve((double[]) null);
    }

    @Test(expectedExceptions = IllegalArgumentException.class)
    public void testNullVector() {
        LU.solve((DoubleMatrix1D) null);
    }

    @Test(expectedExceptions = IllegalArgumentException.class)
    public void testNullMatrix() {
        LU.solve((DoubleMatrix2D) null);
    }

    @Test
    public void testGetters() {
        assertRealMatrixEquals(L, LU.getL());
        assertRealMatrixEquals(U, LU.getU());
        assertRealMatrixEquals(P, LU.getP());
        assertEquals(DETERMINANT, LU.getDeterminant(), 0);
        assertTrue(Arrays.equals(PIVOT, LU.getPivot()));
    }

    @Test
    public void testSolvers() {
        assertTrue(Arrays.equals(RESULT_1D.getData(), LU.solve(RESULT_1D.getData())));
        assertTrue(Arrays.equals(RESULT_1D.getData(), LU.solve(new DoubleMatrix1D(RESULT_1D.getData())).getData()));
        assertRealMatrixEquals(RESULT_2D, LU.solve(new DoubleMatrix2D(RESULT_2D.getData())));
    }

    private void assertRealMatrixEquals(final RealMatrix m1, final DoubleMatrix2D m2) {
        final int m = m1.getRowDimension();
        final int n = m1.getColumnDimension();
        assertEquals(m, m2.getNumberOfRows());
        assertEquals(n, m2.getNumberOfColumns());
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                assertEquals(m1.getEntry(i, j), m2.getEntry(i, j), 0);
            }
        }
    }

    protected static class MyLUDecomposition implements LUDecomposition {

        @Override
        public double getDeterminant() {
            return DETERMINANT;
        }

        @Override
        public RealMatrix getL() {
            return L;
        }

        @Override
        public RealMatrix getP() {
            return P;
        }

        @Override
        public int[] getPivot() {
            return PIVOT;
        }

        @Override
        public DecompositionSolver getSolver() {
            return SOLVER;
        }

        @Override
        public RealMatrix getU() {
            return U;
        }

    }

    protected static class MyDecompositionSolver implements DecompositionSolver {
        @Override
        public RealMatrix getInverse() throws InvalidMatrixException {
            return null;
        }

        @Override
        public boolean isNonSingular() {
            return false;
        }

        @Override
        public double[] solve(final double[] b) throws IllegalArgumentException, InvalidMatrixException {
            return RESULT_1D.toArray();
        }

        @Override
        public RealVector solve(final RealVector b) throws IllegalArgumentException, InvalidMatrixException {
            return RESULT_1D;
        }

        @Override
        public RealMatrix solve(final RealMatrix b) throws IllegalArgumentException, InvalidMatrixException {
            return RESULT_2D;
        }
    }
}