src/experimental/org/apache/commons/math/linear/CholeskySolverTest.java - commons-math - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package org.apache.commons.math.linear;

 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
 import junit.textui.TestRunner;

 /**
  * Test cases for the {@link CholeskySolver} class.
  * <p>
  * @author Stefan Koeberle, 11/2003
  */
 public class CholeskySolverTest
 extends TestCase {

         private double[][] m1 = {{1}};
         private double m1Det = 1.0d;

         private double[][] m2 = {{1, 0} ,
                                  {0, 2}};
         private double m2Det = 2.0d;

         private double[][] m3 = {{1, 0, 0},
                                  {0, 2, 0},
                                  {0, 0, 3}};
         private double m3Det = 6.0d;

         private double[][] m4 = {{1, 0, 0},
                                  {2, 3, 0},
                                  {4, 5, 6}};
         private double m4Det = 18.0d;

         private double[][] m5 = {{ 1,  0,  0,  0,  0},
                                  {-2,  3,  0,  0,  0},
                                  { 4, -5,  6,  0,  0},
                                  { 7,  8, -9, 10,  0},
                                  {11, 12, 13, 14, 15}};
         private double m5Det = 2700.0d;


         private double[][] m6 = {{1, 0,  0},
                                  {2, 0,  0},
                                  {4, 5,  6}};

         private double[][] m7 = {{1, 2, 3},
                                  {4, 5, 6}};

     /**
      * Creates a new instance of CholeskySolverTest
      */
     public CholeskySolverTest(String nameOfTest) {
         super(nameOfTest);
     }//constructor CholeskySolverTest

     public void setUp()
     throws java.lang.Exception {
        super.setUp();
     }//setUp


     public void tearDown()
     throws java.lang.Exception {
         super.tearDown();
     }//tearDown

     public static Test suite() {
         TestSuite suite = new TestSuite(CholeskySolverTest.class);
         suite.setName("CholeskySolver Tests");
         return suite;
     }//suite


     /**
      * tests CholeskySolver.setNumericalZero()
      */
     public void testNumericalZero() {
         CholeskySolver solver = new CholeskySolver();
         double numericalZero = 77.77d;
         solver.setNumericalZero(numericalZero);
         assertEquals(solver.getNumericalZero(), numericalZero, 0.0d);

         try {
             solver.decompose(
                 new Array2DRowRealMatrix(new double[][]{{numericalZero/2, 0},
                                                   {0, numericalZero/2}}));
             fail("testing numericalZero");
         } catch (IllegalArgumentException e) {}

     }//testNumericalZero


     /**
      * tests CholeskySolver.decompose(...)
      */
     public void testDecompose() {

         //The following decompositions should succeed.
         testDecompose(m1, "Decomposing matrix m1");
         testDecompose(m2, "Decomposing matrix m2");
         testDecompose(m3, "Decomposing matrix m3");
         testDecompose(m4, "Decomposing matrix m4");
         testDecompose(m5, "Decomposing matrix m5");

         //The following decompositions will fail. An IllegalArgumentException
         //should be thrown.
         try {
             testDecompose(m6, "Decomposing matrix m6");
             fail("Decomposing matrix m6");
         } catch (IllegalArgumentException e) {}

          try {
              CholeskySolver solver = new CholeskySolver();
              solver.decompose(new Array2DRowRealMatrix(m7));
              fail("Decomposing matrix m7");
         } catch (IllegalArgumentException e) {}

     }//testDecomposition


     /**
      * tests CholeskySolver.solve(...)
      */
     public void testSolve() {

         //If there's no matrix, there's no linear euqitation to solve ...
         try {
              CholeskySolver solver = new CholeskySolver();
              solver.solve(new double[] {1,2,3});
              fail("solving a liniar equitation with a missing matrix should fail");
         } catch (IllegalStateException e) {}

         //The following operations should succeed.
         testSolve(m1, "Solving matrix m1");
         testSolve(m2, "Solving matrix m2");
         testSolve(m3, "Solving matrix m3");
         testSolve(m4, "Solving matrix m4");
         testSolve(m5, "Solving matrix m5");

         //The following operations will fail. An IllegalArgumentException
         //should be thrown.
         try {
           testSolve(m6, "Solving matrix m6");
           fail("Solving matrix m6");
         } catch (IllegalArgumentException e) {}

          try {
              CholeskySolver solver = new CholeskySolver();
              solver.solve(new Array2DRowRealMatrix(m3), new double[] {1, 2, 3, 4});
              fail("Solving matrix m3[3x3], v[4]");
         } catch (IllegalArgumentException e) {}

     }//testDecomposition


     /**
      * tests CholeskySolver.getDeterminant(...)
      */
     public void testGetDeterminant() {

         //Since no matrix was decomposed, there's no determinant.
         try {
              CholeskySolver solver = new CholeskySolver();
              solver.getDeterminant();
              fail("Calculating determinant of missing matrix should fail");
         } catch (IllegalStateException e) {}

         //These test will suceed.
         testGetDeterminant(m1, m1Det, "Calculating determinant of m1");
         testGetDeterminant(m2, m2Det, "Calculating determinant of m2");
         testGetDeterminant(m3, m3Det, "Calculating determinant of m3");
         testGetDeterminant(m4, m4Det, "Calculating determinant of m4");
         testGetDeterminant(m5, m5Det, "Calculating determinant of m5");
     }//test


     /**
      * Generates the matrix
      * <code>m = lowerTriangularMatrix * lowerTriangularMatrix^T</code>.
      * If alle diagonalelements of <code>lowerTriangularMatrix</code> are
      * positiv, <code>m</code> will be positiv definit.
      * Decomposing <code>m</code> should result in
      * <code>lowerTriangularMatrix</code> again. So there's a simple test ...
      */
     private void testDecompose(double[][] lowerTriangularMatrix, String message)
     throws IllegalArgumentException {

         RealMatrix triangularMatrix = new Array2DRowRealMatrix(lowerTriangularMatrix);
         RealMatrix pdMatrix =
             triangularMatrix.multiply(triangularMatrix.transpose());

         CholeskySolver solver = new CholeskySolver();
         solver.decompose(pdMatrix);

         assertTrue(message,
             areEqual(triangularMatrix, solver.getDecomposition(), 1.0E-10));

     }//testDecompose


     /**
      * Similar to <code> private testDecompose(...)</code>.
      */
     private void testSolve(double[][] lowerTriangularMatrix, String message)  {

         RealMatrix triangularMatrix =
             new Array2DRowRealMatrix(lowerTriangularMatrix);
         Array2DRowRealMatrix pdMatrix =
             (Array2DRowRealMatrix) triangularMatrix.multiply(triangularMatrix.transpose());
         CholeskySolver solver =
             new CholeskySolver();

         double[] c = new double[lowerTriangularMatrix.length];
         for (int i=0; i<c.length; i++)
             for (int j=0; j<lowerTriangularMatrix[0].length; j++)
                 c[i] += lowerTriangularMatrix[i][j];

         solver.decompose(pdMatrix);
         RealMatrix x = new Array2DRowRealMatrix(solver.solve(c));

         assertTrue(message,
             areEqual(pdMatrix.multiply(x),  new Array2DRowRealMatrix(c), 1.0E-10));
     }//testSolve


     /**
      * Similar to <code> private testDecompose(...)</code>.
      */
     private void testGetDeterminant(double[][] lowerTriangularMatrix,
                                     double determinant,
                                     String message)
     throws IllegalArgumentException {

         RealMatrix triangularMatrix = new Array2DRowRealMatrix(lowerTriangularMatrix);
         RealMatrix pdMatrix =
             triangularMatrix.multiply(triangularMatrix.transpose());
         double pdDeterminant = determinant * determinant;

         CholeskySolver solver = new CholeskySolver();
         solver.decompose(pdMatrix);
         assertEquals(message, solver.getDeterminant(), pdDeterminant, 1.0E-10);
     }//testGetDeterminant


     /**
      * Are <code>m1</code> and <code>m2</code> equal?
      */
     private static boolean areEqual(RealMatrix m1, RealMatrix m2, double delta) {

         double[][] mv1 = m1.getData();
         double[][] mv2 = m2.getData();

         if (mv1.length != mv1.length  ||
             mv1[0].length != mv2[0].length)
             return false;

         for (int i=0; i<mv1.length; i++)
             for (int j=0; j<mv1[0].length; j++)
                 if (Math.abs(mv1[i][j] -mv2[i][j]) > delta)
                     return false;

         return true;
     }//isEqual


     /**
      * Executes all tests of this class
      */
     public static void main(String[] args) {
         System.out.println("Start");
         TestRunner runner = new TestRunner();
         runner.doRun(CholeskySolverTest.suite());
         System.out.println("End");
     }//main

 }//class CholeskySolverTest
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package org.apache.commons.math.linear;

	import junit.framework.Test;
	import junit.framework.TestCase;
	import junit.framework.TestSuite;
	import junit.textui.TestRunner;

	/**
	* Test cases for the {@link CholeskySolver} class.
	* <p>
	* @author Stefan Koeberle, 11/2003
	*/
	public class CholeskySolverTest
	extends TestCase {

	private double[][] m1 = {{1}};
	private double m1Det = 1.0d;

	private double[][] m2 = {{1, 0} ,
	{0, 2}};
	private double m2Det = 2.0d;

	private double[][] m3 = {{1, 0, 0},
	{0, 2, 0},
	{0, 0, 3}};
	private double m3Det = 6.0d;

	private double[][] m4 = {{1, 0, 0},
	{2, 3, 0},
	{4, 5, 6}};
	private double m4Det = 18.0d;

	private double[][] m5 = {{ 1, 0, 0, 0, 0},
	{-2, 3, 0, 0, 0},
	{ 4, -5, 6, 0, 0},
	{ 7, 8, -9, 10, 0},
	{11, 12, 13, 14, 15}};
	private double m5Det = 2700.0d;


	private double[][] m6 = {{1, 0, 0},
	{2, 0, 0},
	{4, 5, 6}};

	private double[][] m7 = {{1, 2, 3},
	{4, 5, 6}};

	/**
	* Creates a new instance of CholeskySolverTest
	*/
	public CholeskySolverTest(String nameOfTest) {
	super(nameOfTest);
	}//constructor CholeskySolverTest

	public void setUp()
	throws java.lang.Exception {
	super.setUp();
	}//setUp


	public void tearDown()
	throws java.lang.Exception {
	super.tearDown();
	}//tearDown

	public static Test suite() {
	TestSuite suite = new TestSuite(CholeskySolverTest.class);
	suite.setName("CholeskySolver Tests");
	return suite;
	}//suite


	/**
	* tests CholeskySolver.setNumericalZero()
	*/
	public void testNumericalZero() {
	CholeskySolver solver = new CholeskySolver();
	double numericalZero = 77.77d;
	solver.setNumericalZero(numericalZero);
	assertEquals(solver.getNumericalZero(), numericalZero, 0.0d);

	try {
	solver.decompose(
	new Array2DRowRealMatrix(new double[][]{{numericalZero/2, 0},
	{0, numericalZero/2}}));
	fail("testing numericalZero");
	} catch (IllegalArgumentException e) {}

	}//testNumericalZero


	/**
	* tests CholeskySolver.decompose(...)
	*/
	public void testDecompose() {

	//The following decompositions should succeed.
	testDecompose(m1, "Decomposing matrix m1");
	testDecompose(m2, "Decomposing matrix m2");
	testDecompose(m3, "Decomposing matrix m3");
	testDecompose(m4, "Decomposing matrix m4");
	testDecompose(m5, "Decomposing matrix m5");

	//The following decompositions will fail. An IllegalArgumentException
	//should be thrown.
	try {
	testDecompose(m6, "Decomposing matrix m6");
	fail("Decomposing matrix m6");
	} catch (IllegalArgumentException e) {}

	try {
	CholeskySolver solver = new CholeskySolver();
	solver.decompose(new Array2DRowRealMatrix(m7));
	fail("Decomposing matrix m7");
	} catch (IllegalArgumentException e) {}

	}//testDecomposition


	/**
	* tests CholeskySolver.solve(...)
	*/
	public void testSolve() {

	//If there's no matrix, there's no linear euqitation to solve ...
	try {
	CholeskySolver solver = new CholeskySolver();
	solver.solve(new double[] {1,2,3});
	fail("solving a liniar equitation with a missing matrix should fail");
	} catch (IllegalStateException e) {}

	//The following operations should succeed.
	testSolve(m1, "Solving matrix m1");
	testSolve(m2, "Solving matrix m2");
	testSolve(m3, "Solving matrix m3");
	testSolve(m4, "Solving matrix m4");
	testSolve(m5, "Solving matrix m5");

	//The following operations will fail. An IllegalArgumentException
	//should be thrown.
	try {
	testSolve(m6, "Solving matrix m6");
	fail("Solving matrix m6");
	} catch (IllegalArgumentException e) {}

	try {
	CholeskySolver solver = new CholeskySolver();
	solver.solve(new Array2DRowRealMatrix(m3), new double[] {1, 2, 3, 4});
	fail("Solving matrix m3[3x3], v[4]");
	} catch (IllegalArgumentException e) {}

	}//testDecomposition


	/**
	* tests CholeskySolver.getDeterminant(...)
	*/
	public void testGetDeterminant() {

	//Since no matrix was decomposed, there's no determinant.
	try {
	CholeskySolver solver = new CholeskySolver();
	solver.getDeterminant();
	fail("Calculating determinant of missing matrix should fail");
	} catch (IllegalStateException e) {}

	//These test will suceed.
	testGetDeterminant(m1, m1Det, "Calculating determinant of m1");
	testGetDeterminant(m2, m2Det, "Calculating determinant of m2");
	testGetDeterminant(m3, m3Det, "Calculating determinant of m3");
	testGetDeterminant(m4, m4Det, "Calculating determinant of m4");
	testGetDeterminant(m5, m5Det, "Calculating determinant of m5");
	}//test


	/**
	* Generates the matrix
	* <code>m = lowerTriangularMatrix * lowerTriangularMatrix^T</code>.
	* If alle diagonalelements of <code>lowerTriangularMatrix</code> are
	* positiv, <code>m</code> will be positiv definit.
	* Decomposing <code>m</code> should result in
	* <code>lowerTriangularMatrix</code> again. So there's a simple test ...
	*/
	private void testDecompose(double[][] lowerTriangularMatrix, String message)
	throws IllegalArgumentException {

	RealMatrix triangularMatrix = new Array2DRowRealMatrix(lowerTriangularMatrix);
	RealMatrix pdMatrix =
	triangularMatrix.multiply(triangularMatrix.transpose());

	CholeskySolver solver = new CholeskySolver();
	solver.decompose(pdMatrix);

	assertTrue(message,
	areEqual(triangularMatrix, solver.getDecomposition(), 1.0E-10));

	}//testDecompose


	/**
	* Similar to <code> private testDecompose(...)</code>.
	*/
	private void testSolve(double[][] lowerTriangularMatrix, String message) {

	RealMatrix triangularMatrix =
	new Array2DRowRealMatrix(lowerTriangularMatrix);
	Array2DRowRealMatrix pdMatrix =
	(Array2DRowRealMatrix) triangularMatrix.multiply(triangularMatrix.transpose());
	CholeskySolver solver =
	new CholeskySolver();

	double[] c = new double[lowerTriangularMatrix.length];
	for (int i=0; i<c.length; i++)
	for (int j=0; j<lowerTriangularMatrix[0].length; j++)
	c[i] += lowerTriangularMatrix[i][j];

	solver.decompose(pdMatrix);
	RealMatrix x = new Array2DRowRealMatrix(solver.solve(c));

	assertTrue(message,
	areEqual(pdMatrix.multiply(x), new Array2DRowRealMatrix(c), 1.0E-10));
	}//testSolve


	/**
	* Similar to <code> private testDecompose(...)</code>.
	*/
	private void testGetDeterminant(double[][] lowerTriangularMatrix,
	double determinant,
	String message)
	throws IllegalArgumentException {

	RealMatrix triangularMatrix = new Array2DRowRealMatrix(lowerTriangularMatrix);
	RealMatrix pdMatrix =
	triangularMatrix.multiply(triangularMatrix.transpose());
	double pdDeterminant = determinant * determinant;

	CholeskySolver solver = new CholeskySolver();
	solver.decompose(pdMatrix);
	assertEquals(message, solver.getDeterminant(), pdDeterminant, 1.0E-10);
	}//testGetDeterminant


	/**
	* Are <code>m1</code> and <code>m2</code> equal?
	*/
	private static boolean areEqual(RealMatrix m1, RealMatrix m2, double delta) {

	double[][] mv1 = m1.getData();
	double[][] mv2 = m2.getData();

	if (mv1.length != mv1.length \|\|
	mv1[0].length != mv2[0].length)
	return false;

	for (int i=0; i<mv1.length; i++)
	for (int j=0; j<mv1[0].length; j++)
	if (Math.abs(mv1[i][j] -mv2[i][j]) > delta)
	return false;

	return true;
	}//isEqual


	/**
	* Executes all tests of this class
	*/
	public static void main(String[] args) {
	System.out.println("Start");
	TestRunner runner = new TestRunner();
	runner.doRun(CholeskySolverTest.suite());
	System.out.println("End");
	}//main

	}//class CholeskySolverTest