New git HEAD version
[libdai.git] / tests / unit / factorgraph_test.cpp
index 3268792..b182391 100644 (file)
@@ -1,10 +1,8 @@
 /*  This file is part of libDAI - http://www.libdai.org/
  *
- *  libDAI is licensed under the terms of the GNU General Public License version
- *  2, or (at your option) any later version. libDAI is distributed without any
- *  warranty. See the file COPYING for more details.
+ *  Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
  *
- *  Copyright (C) 2010  Joris Mooij      [joris dot mooij at libdai dot org]
+ *  Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
  */
 
 
@@ -139,6 +137,7 @@ BOOST_AUTO_TEST_CASE( QueriesTest ) {
     BOOST_CHECK( G0.MarkovGraph() == GraphAL() );
     BOOST_CHECK( G0.bipGraph() == BipartiteGraph() );
     BOOST_CHECK_EQUAL( G0.maximalFactorDomains().size(), 1 );
+    BOOST_CHECK_CLOSE( G0.logScore( std::vector<size_t>() ), (Real)0.0, tol );
 
     std::vector<Factor> facs;
     facs.push_back( Factor( v01 ) );
@@ -198,9 +197,16 @@ BOOST_AUTO_TEST_CASE( QueriesTest ) {
     BOOST_CHECK( G1.isPairwise() );
     BOOST_CHECK( G1.MarkovGraph() == H );
     BOOST_CHECK( G1.bipGraph() == K );
+    BOOST_CHECK(  G1.isMaximal( 0 ) );
+    BOOST_CHECK(  G1.isMaximal( 1 ) );
+    BOOST_CHECK( !G1.isMaximal( 2 ) );
+    BOOST_CHECK_EQUAL( G1.maximalFactor( 0 ), 0 );
+    BOOST_CHECK_EQUAL( G1.maximalFactor( 1 ), 1 );
+    BOOST_CHECK_EQUAL( G1.maximalFactor( 2 ), 0 );
     BOOST_CHECK_EQUAL( G1.maximalFactorDomains().size(), 2 );
     BOOST_CHECK_EQUAL( G1.maximalFactorDomains()[0], v01 );
     BOOST_CHECK_EQUAL( G1.maximalFactorDomains()[1], v12 );
+    BOOST_CHECK_CLOSE( G1.logScore( std::vector<size_t>(3,0) ), -dai::log((Real)32.0), tol ); 
 
     facs.push_back( Factor( v02 ) );
     H.addEdge( 0, 2 );
@@ -233,10 +239,19 @@ BOOST_AUTO_TEST_CASE( QueriesTest ) {
     BOOST_CHECK( G2.isPairwise() );
     BOOST_CHECK( G2.MarkovGraph() == H );
     BOOST_CHECK( G2.bipGraph() == K );
+    BOOST_CHECK(  G2.isMaximal( 0 ) );
+    BOOST_CHECK(  G2.isMaximal( 1 ) );
+    BOOST_CHECK( !G2.isMaximal( 2 ) );
+    BOOST_CHECK(  G2.isMaximal( 3 ) );
+    BOOST_CHECK_EQUAL( G2.maximalFactor( 0 ), 0 );
+    BOOST_CHECK_EQUAL( G2.maximalFactor( 1 ), 1 );
+    BOOST_CHECK_EQUAL( G2.maximalFactor( 2 ), 0 );
+    BOOST_CHECK_EQUAL( G2.maximalFactor( 3 ), 3 );
     BOOST_CHECK_EQUAL( G2.maximalFactorDomains().size(), 3 );
     BOOST_CHECK_EQUAL( G2.maximalFactorDomains()[0], v01 );
     BOOST_CHECK_EQUAL( G2.maximalFactorDomains()[1], v12 );
     BOOST_CHECK_EQUAL( G2.maximalFactorDomains()[2], v02 );
+    BOOST_CHECK_CLOSE( G2.logScore( std::vector<size_t>(3,0) ), -dai::log((Real)128.0), tol );
 
     Var v3( 3, 3 );
     VarSet v03( v0, v3 );
@@ -283,11 +298,22 @@ BOOST_AUTO_TEST_CASE( QueriesTest ) {
     BOOST_CHECK( G3.isPairwise() );
     BOOST_CHECK( G3.MarkovGraph() == H );
     BOOST_CHECK( G3.bipGraph() == K );
+    BOOST_CHECK(  G3.isMaximal( 0 ) );
+    BOOST_CHECK(  G3.isMaximal( 1 ) );
+    BOOST_CHECK( !G3.isMaximal( 2 ) );
+    BOOST_CHECK(  G3.isMaximal( 3 ) );
+    BOOST_CHECK(  G3.isMaximal( 4 ) );
+    BOOST_CHECK_EQUAL( G3.maximalFactor( 0 ), 0 );
+    BOOST_CHECK_EQUAL( G3.maximalFactor( 1 ), 1 );
+    BOOST_CHECK_EQUAL( G3.maximalFactor( 2 ), 0 );
+    BOOST_CHECK_EQUAL( G3.maximalFactor( 3 ), 3 );
+    BOOST_CHECK_EQUAL( G3.maximalFactor( 4 ), 4 );
     BOOST_CHECK_EQUAL( G3.maximalFactorDomains().size(), 4 );
     BOOST_CHECK_EQUAL( G3.maximalFactorDomains()[0], v01 );
     BOOST_CHECK_EQUAL( G3.maximalFactorDomains()[1], v12 );
     BOOST_CHECK_EQUAL( G3.maximalFactorDomains()[2], v02 );
     BOOST_CHECK_EQUAL( G3.maximalFactorDomains()[3], v3 );
+    BOOST_CHECK_CLOSE( G3.logScore( std::vector<size_t>(4,0) ), -dai::log((Real)384.0), tol );
 
     facs.push_back( Factor( v123 ) );
     H.addEdge( 1, 3 );
@@ -328,10 +354,23 @@ BOOST_AUTO_TEST_CASE( QueriesTest ) {
     BOOST_CHECK( !G4.isPairwise() );
     BOOST_CHECK( G4.MarkovGraph() == H );
     BOOST_CHECK( G4.bipGraph() == K );
+    BOOST_CHECK(  G4.isMaximal( 0 ) );
+    BOOST_CHECK( !G4.isMaximal( 1 ) );
+    BOOST_CHECK( !G4.isMaximal( 2 ) );
+    BOOST_CHECK(  G4.isMaximal( 3 ) );
+    BOOST_CHECK( !G4.isMaximal( 4 ) );
+    BOOST_CHECK(  G4.isMaximal( 5 ) );
+    BOOST_CHECK_EQUAL( G4.maximalFactor( 0 ), 0 );
+    BOOST_CHECK_EQUAL( G4.maximalFactor( 1 ), 5 );
+    BOOST_CHECK_EQUAL( G4.maximalFactor( 2 ), 0 );
+    BOOST_CHECK_EQUAL( G4.maximalFactor( 3 ), 3 );
+    BOOST_CHECK_EQUAL( G4.maximalFactor( 4 ), 5 );
+    BOOST_CHECK_EQUAL( G4.maximalFactor( 5 ), 5 );
     BOOST_CHECK_EQUAL( G4.maximalFactorDomains().size(), 3 );
     BOOST_CHECK_EQUAL( G4.maximalFactorDomains()[0], v01 );
     BOOST_CHECK_EQUAL( G4.maximalFactorDomains()[1], v02 );
     BOOST_CHECK_EQUAL( G4.maximalFactorDomains()[2], v123 );
+    BOOST_CHECK_CLOSE( G4.logScore( std::vector<size_t>(4,0) ), -dai::log((Real)4608.0), tol );
 }
 
 
@@ -709,6 +748,8 @@ BOOST_AUTO_TEST_CASE( IOTest ) {
     std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "0          3" );
     std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "1          3" );
 
+    BOOST_CHECK_EQUAL( G.toString(), "3\n\n2\n0 1 \n2 2 \n4\n0          1\n1          1\n2          1\n3          1\n\n2\n1 2 \n2 2 \n4\n0          2\n1          2\n2          2\n3          2\n\n1\n1 \n2 \n2\n0          3\n1          3\n" );
+
     ss << G;
     FactorGraph G3;
     ss >> G3;
@@ -720,4 +761,15 @@ BOOST_AUTO_TEST_CASE( IOTest ) {
         for( size_t s = 0; s < G.factor(I).nrStates(); s++ )
             BOOST_CHECK_CLOSE( G.factor(I)[s], G3.factor(I)[s], tol );
     }
+
+    FactorGraph G4;
+    G4.fromString( G.toString() );
+    BOOST_CHECK( G.vars() == G4.vars() );
+    BOOST_CHECK( G.bipGraph() == G4.bipGraph() );
+    BOOST_CHECK_EQUAL( G.nrFactors(), G4.nrFactors() );
+    for( size_t I = 0; I < G.nrFactors(); I++ ) {
+        BOOST_CHECK( G.factor(I).vars() == G4.factor(I).vars() );
+        for( size_t s = 0; s < G.factor(I).nrStates(); s++ )
+            BOOST_CHECK_CLOSE( G.factor(I)[s], G4.factor(I)[s], tol );
+    }
 }