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

Introduction

Here is the source code for com.opengamma.analytics.math.linearalgebra.SVDecompositionCommonsResultTest.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 static org.testng.internal.junit.ArrayAsserts.assertArrayEquals;

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.RealMatrix;
import org.apache.commons.math.linear.RealVector;
import org.apache.commons.math.linear.SingularValueDecomposition;
import org.testng.annotations.Test;

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

/**
 * 
 */
public class SVDecompositionCommonsResultTest {
    static final double CONDITION = 0.5;
    static final double NORM = 0.2;
    static final int RANK = 6;
    static final RealMatrix S = new Array2DRowRealMatrix(
            new double[][] { new double[] { 0.1, 0.2 }, new double[] { 0.3, 0.4 } });
    static final RealMatrix U = new Array2DRowRealMatrix(
            new double[][] { new double[] { 1.1, 1.2 }, new double[] { 1.3, 1.4 } });
    static final RealMatrix UT = new Array2DRowRealMatrix(
            new double[][] { new double[] { 1.1, 1.3 }, new double[] { 1.2, 1.4 } });
    static final RealMatrix V = new Array2DRowRealMatrix(
            new double[][] { new double[] { 2.1, 2.2 }, new double[] { 2.3, 2.4 } });
    static final RealMatrix VT = new Array2DRowRealMatrix(
            new double[][] { new double[] { 2.1, 2.3 }, new double[] { 2.2, 2.4 } });
    static final RealMatrix M = new Array2DRowRealMatrix(
            new double[][] { new double[] { 3.1, 3.2 }, new double[] { 3.3, 3.4 } });
    static final double[] SINGULAR_VALUES = new double[] { 6, 7 };
    static final RealMatrix RESULT_2D = new Array2DRowRealMatrix(
            new double[][] { new double[] { 3.5, 4.5 }, new double[] { 5.5, 6.5 } });
    static final RealVector RESULT_1D = new ArrayRealVector(new double[] { 7.5, 8.5 });
    static final DecompositionSolver SOLVER = new MyDecompositionSolver();
    private static final SVDecompositionResult SVD = new SVDecompositionCommonsResult(
            new MySingularValueDecomposition());
    private static final double EPS = 1e-15;

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

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

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

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

    @Test
    public void testGetters() {
        assertEquals(CONDITION, SVD.getConditionNumber(), 0);
        assertEquals(RANK, SVD.getRank());
        assertEquals(NORM, SVD.getNorm(), 0);
        assertRealMatrixEquals(S, SVD.getS());
        assertRealMatrixEquals(U, SVD.getU());
        assertRealMatrixEquals(UT, SVD.getUT());
        assertRealMatrixEquals(V, SVD.getV());
        assertRealMatrixEquals(VT, SVD.getVT());
        assertArrayEquals(SINGULAR_VALUES, SVD.getSingularValues(), 1e-12);
    }

    @Test
    public void testSolvers() {
        assertTrue(Arrays.equals(RESULT_1D.getData(), SVD.solve(new double[] { 0.1, 0.2 })));
        assertRealVectorEquals(RESULT_1D, SVD.solve(new DoubleMatrix1D(new double[] { 0.1, 0.2 })));
        assertRealMatrixEquals(RESULT_2D, SVD.solve(
                new DoubleMatrix2D(new double[][] { new double[] { 0.1, 0.2 }, new double[] { 0.1, 0.2 } })));
    }

    private void assertRealVectorEquals(final RealVector v1, final DoubleMatrix1D v2) {
        final int n = v1.getDimension();
        assertEquals(n, v2.getNumberOfElements());
        for (int i = 0; i < n; i++) {
            assertEquals(v1.getEntry(i), v2.getEntry(i), EPS);
        }
    }

    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), EPS);
            }
        }
    }

    protected static class MySingularValueDecomposition implements SingularValueDecomposition {

        @Override
        public double getConditionNumber() {
            return CONDITION;
        }

        @Override
        public RealMatrix getCovariance(final double minSingularValue) throws IllegalArgumentException {
            return null;
        }

        @Override
        public double getNorm() {
            return NORM;
        }

        @Override
        public int getRank() {
            return RANK;
        }

        @Override
        public RealMatrix getS() {
            return S;
        }

        @Override
        public double[] getSingularValues() {
            return SINGULAR_VALUES;
        }

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

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

        @Override
        public RealMatrix getUT() {
            return UT;
        }

        @Override
        public RealMatrix getV() {
            return V;
        }

        @Override
        public RealMatrix getVT() {
            return VT;
        }
    }

    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;
        }

    }
}