Compressed Makefile and added unit tests for SmallSet
authorJoris Mooij <joris.mooij@tuebingen.mpg.de>
Fri, 19 Mar 2010 16:39:43 +0000 (17:39 +0100)
committerJoris Mooij <joris.mooij@tuebingen.mpg.de>
Fri, 19 Mar 2010 16:39:43 +0000 (17:39 +0100)
ChangeLog
Makefile
include/dai/smallset.h
tests/unit/smallset.cpp [new file with mode: 0644]
tests/unit/var.cpp

index 108f23f..cf02e77 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,7 +1,8 @@
 git HEAD
 --------
 
-* Added unit tests for Var
+* Compressed Makefile
+* Added unit tests for Var, SmallSet
 * Added unit testing framework
 * Added initialization of TRWBP weights by sampling spanning trees
 * Cleaned up MR code:
index 2363898..ded18d7 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -122,9 +122,10 @@ examples : examples/example$(EE) examples/example_bipgraph$(EE) examples/example
 
 matlabs : matlab/dai$(ME) matlab/dai_readfg$(ME) matlab/dai_writefg$(ME) matlab/dai_potstrength$(ME)
 
-unittests : tests/unit/var$(EE)
+unittests : tests/unit/var$(EE) tests/unit/smallset$(EE)
        echo Running unit tests...
        tests/unit/var
+       tests/unit/smallset
 
 tests : tests/testdai$(EE) tests/testem/testem$(EE) tests/testbbp$(EE) $(unittests)
 
@@ -136,168 +137,104 @@ lib: $(LIB)/libdai$(LE)
 # OBJECTS
 ##########
 
-bipgraph$(OE) : $(SRC)/bipgraph.cpp $(HEADERS)
-       $(CC) -c $(SRC)/bipgraph.cpp
-
-graph$(OE) : $(SRC)/graph.cpp $(HEADERS)
-       $(CC) -c $(SRC)/graph.cpp
-
-varset$(OE) : $(SRC/varset.cpp $(HEADERS)
-       $(CC) -c $(SRC)/varset.cpp
-
-daialg$(OE) : $(SRC)/daialg.cpp $(HEADERS)
-       $(CC) -c $(SRC)/daialg.cpp
-
-exactinf$(OE) : $(SRC)/exactinf.cpp $(INC)/exactinf.h $(HEADERS)
-       $(CC) -c $(SRC)/exactinf.cpp
-
-bp$(OE) : $(SRC)/bp.cpp $(INC)/bp.h $(HEADERS)
-       $(CC) -c $(SRC)/bp.cpp
-
-fbp$(OE) : $(SRC)/fbp.cpp $(INC)/fbp.h $(HEADERS)
-       $(CC) -c $(SRC)/fbp.cpp
-
-trwbp$(OE) : $(SRC)/trwbp.cpp $(INC)/trwbp.h $(HEADERS)
-       $(CC) -c $(SRC)/trwbp.cpp
-
-bp_dual$(OE) : $(SRC)/bp_dual.cpp $(INC)/bp_dual.h $(HEADERS)
-       $(CC) -c $(SRC)/bp_dual.cpp
+%$(OE) : $(SRC)/%.cpp $(INC)/%.h $(HEADERS)
+       $(CC) -c $< -o $@
 
 bbp$(OE) : $(SRC)/bbp.cpp $(INC)/bbp.h $(INC)/bp_dual.h $(HEADERS)
-       $(CC) -c $(SRC)/bbp.cpp
+       $(CC) -c $<
 
 cbp$(OE) : $(SRC)/cbp.cpp $(INC)/cbp.h $(INC)/bbp.h $(INC)/bp_dual.h $(HEADERS)
-       $(CC) -c $(SRC)/cbp.cpp
-
-lc$(OE) : $(SRC)/lc.cpp $(INC)/lc.h $(HEADERS)
-       $(CC) -c $(SRC)/lc.cpp
-
-mf$(OE) : $(SRC)/mf.cpp $(INC)/mf.h $(HEADERS)
-       $(CC) -c $(SRC)/mf.cpp
-
-factor$(OE) : $(SRC)/factor.cpp $(INC)/factor.h $(HEADERS)
-       $(CC) -c $(SRC)/factor.cpp
-
-factorgraph$(OE) : $(SRC)/factorgraph.cpp $(INC)/factorgraph.h $(HEADERS)
-       $(CC) -c $(SRC)/factorgraph.cpp
-
-util$(OE) : $(SRC)/util.cpp $(INC)/util.h $(HEADERS)
-       $(CC) -c $(SRC)/util.cpp
-
-regiongraph$(OE) : $(SRC)/regiongraph.cpp $(INC)/regiongraph.h $(HEADERS)
-       $(CC) -c $(SRC)/regiongraph.cpp
+       $(CC) -c $<
 
 hak$(OE) : $(SRC)/hak.cpp $(INC)/hak.h $(HEADERS) $(INC)/regiongraph.h
-       $(CC) -c $(SRC)/hak.cpp
-
-clustergraph$(OE) : $(SRC)/clustergraph.cpp $(INC)/clustergraph.h $(HEADERS)
-       $(CC) -c $(SRC)/clustergraph.cpp
+       $(CC) -c $<
 
 jtree$(OE) : $(SRC)/jtree.cpp $(INC)/jtree.h $(HEADERS) $(INC)/weightedgraph.h $(INC)/clustergraph.h $(INC)/regiongraph.h
-       $(CC) -c $(SRC)/jtree.cpp
+       $(CC) -c $<
 
 treeep$(OE) : $(SRC)/treeep.cpp $(INC)/treeep.h $(HEADERS) $(INC)/weightedgraph.h $(INC)/clustergraph.h $(INC)/regiongraph.h $(INC)/jtree.h
-       $(CC) -c $(SRC)/treeep.cpp
-
-weightedgraph$(OE) : $(SRC)/weightedgraph.cpp $(INC)/weightedgraph.h $(HEADERS)
-       $(CC) -c $(SRC)/weightedgraph.cpp
-
-mr$(OE) : $(SRC)/mr.cpp $(INC)/mr.h $(HEADERS)
-       $(CC) -c $(SRC)/mr.cpp
-
-gibbs$(OE) : $(SRC)/gibbs.cpp $(INC)/gibbs.h $(HEADERS)
-       $(CC) -c $(SRC)/gibbs.cpp
-
-evidence$(OE) : $(SRC)/evidence.cpp $(INC)/evidence.h $(HEADERS)
-       $(CC) -c $(SRC)/evidence.cpp
+       $(CC) -c $<
 
 emalg$(OE) : $(SRC)/emalg.cpp $(INC)/emalg.h $(INC)/evidence.h $(HEADERS)
-       $(CC) -c $(SRC)/emalg.cpp
-
-properties$(OE) : $(SRC)/properties.cpp $(HEADERS)
-       $(CC) -c $(SRC)/properties.cpp
-
-exceptions$(OE) : $(SRC)/exceptions.cpp $(HEADERS)
-       $(CC) -c $(SRC)/exceptions.cpp
-
-alldai$(OE) : $(SRC)/alldai.cpp $(HEADERS)
-       $(CC) -c $(SRC)/alldai.cpp
+       $(CC) -c $<
 
 
 # EXAMPLES
 ###########
 
 examples/example$(EE) : examples/example.cpp $(HEADERS) $(LIB)/libdai$(LE)
-       $(CC) $(CCO)examples/example$(EE) examples/example.cpp $(LIBS)
+       $(CC) $(CCO)$@ $< $(LIBS)
 
 examples/example_bipgraph$(EE) : examples/example_bipgraph.cpp $(HEADERS) $(LIB)/libdai$(LE)
-       $(CC) $(CCO)examples/example_bipgraph$(EE) examples/example_bipgraph.cpp $(LIBS)
+       $(CC) $(CCO)$@ $< $(LIBS)
 
 examples/example_varset$(EE) : examples/example_varset.cpp $(HEADERS) $(LIB)/libdai$(LE)
-       $(CC) $(CCO)examples/example_varset$(EE) examples/example_varset.cpp $(LIBS)
+       $(CC) $(CCO)$@ $< $(LIBS)
 
 examples/example_permute$(EE) : examples/example_permute.cpp $(HEADERS) $(LIB)/libdai$(LE)
-       $(CC) $(CCO)examples/example_permute$(EE) examples/example_permute.cpp $(LIBS)
+       $(CC) $(CCO)$@ $< $(LIBS)
 
 examples/example_sprinkler$(EE) : examples/example_sprinkler.cpp $(HEADERS) $(LIB)/libdai$(LE)
-       $(CC) $(CCO)examples/example_sprinkler$(EE) examples/example_sprinkler.cpp $(LIBS)
+       $(CC) $(CCO)$@ $< $(LIBS)
 
 examples/example_sprinkler_gibbs$(EE) : examples/example_sprinkler_gibbs.cpp $(HEADERS) $(LIB)/libdai$(LE)
-       $(CC) $(CCO)examples/example_sprinkler_gibbs$(EE) examples/example_sprinkler_gibbs.cpp $(LIBS)
+       $(CC) $(CCO)$@ $< $(LIBS)
 
 examples/example_sprinkler_em$(EE) : examples/example_sprinkler_em.cpp $(HEADERS) $(LIB)/libdai$(LE)
-       $(CC) $(CCO)examples/example_sprinkler_em$(EE) examples/example_sprinkler_em.cpp $(LIBS)
+       $(CC) $(CCO)$@ $< $(LIBS)
 
 
 # UNIT TESTS
 #############
 
 tests/unit/var$(EE) : tests/unit/var.cpp $(HEADERS) $(LIB)/libdai$(LE)
-       $(CC) $(CCO)tests/unit/var$(EE) tests/unit/var.cpp $(LIBS) $(BOOSTLIBS_UTF)
+       $(CC) $(CCO)$@ $< $(LIBS) $(BOOSTLIBS_UTF)
+tests/unit/smallset$(EE) : tests/unit/smallset.cpp $(HEADERS) $(LIB)/libdai$(LE)
+       $(CC) $(CCO)$@ $< $(LIBS) $(BOOSTLIBS_UTF)
 
 
 # TESTS
 ########
 
 tests/testdai$(EE) : tests/testdai.cpp $(HEADERS) $(LIB)/libdai$(LE)
-       $(CC) $(CCO)tests/testdai$(EE) tests/testdai.cpp $(LIBS) $(BOOSTLIBS_PO)
+       $(CC) $(CCO)$@ $< $(LIBS) $(BOOSTLIBS_PO)
 tests/testem/testem$(EE) : tests/testem/testem.cpp $(HEADERS) $(LIB)/libdai$(LE)
        $(CC) $(CCO)$@ $< $(LIBS) $(BOOSTLIBS_PO)
 
 tests/testbbp$(EE) : tests/testbbp.cpp $(HEADERS) $(LIB)/libdai$(LE)
-       $(CC) $(CCO)tests/testbbp$(EE) tests/testbbp.cpp $(LIBS)
+       $(CC) $(CCO)$@ $< $(LIBS)
 
 
 # MATLAB INTERFACE
 ###################
 
 matlab/dai$(ME) : $(SRC)/matlab/dai.cpp $(HEADERS) matlab$(OE) $(LIB)/libdai$(LE)
-       $(MEX) -o matlab/dai $(SRC)/matlab/dai.cpp matlab$(OE) $(LIB)/libdai$(LE)
+       $(MEX) -o$@ $< matlab$(OE) $(LIB)/libdai$(LE)
 
 matlab/dai_readfg$(ME) : $(SRC)/matlab/dai_readfg.cpp $(HEADERS) factorgraph$(OE) matlab$(OE) exceptions$(OE) bipgraph$(OE)
-       $(MEX) -o matlab/dai_readfg $(SRC)/matlab/dai_readfg.cpp factorgraph$(OE) matlab$(OE) exceptions$(OE) bipgraph$(OE)
+       $(MEX) -o$@ $< factorgraph$(OE) matlab$(OE) exceptions$(OE) bipgraph$(OE)
 
 matlab/dai_writefg$(ME) : $(SRC)/matlab/dai_writefg.cpp $(HEADERS) factorgraph$(OE) matlab$(OE) exceptions$(OE) bipgraph$(OE)
-       $(MEX) -o matlab/dai_writefg $(SRC)/matlab/dai_writefg.cpp factorgraph$(OE) matlab$(OE) exceptions$(OE) bipgraph$(OE)
+       $(MEX) -o$@ $< factorgraph$(OE) matlab$(OE) exceptions$(OE) bipgraph$(OE)
 
 matlab/dai_potstrength$(ME) : $(SRC)/matlab/dai_potstrength.cpp $(HEADERS) matlab$(OE) exceptions$(OE)
-       $(MEX) -o matlab/dai_potstrength $(SRC)/matlab/dai_potstrength.cpp matlab$(OE) exceptions$(OE)
+       $(MEX) -o$@ $< matlab$(OE) exceptions$(OE)
 
 matlab$(OE) : $(SRC)/matlab/matlab.cpp $(INC)/matlab/matlab.h $(HEADERS)
-       $(MEX) -c $(SRC)/matlab/matlab.cpp
+       $(MEX) -c $<
 
 
 # UTILS
 ########
 
 utils/createfg$(EE) : utils/createfg.cpp $(HEADERS) $(LIB)/libdai$(LE)
-       $(CC) $(CCO)utils/createfg$(EE) utils/createfg.cpp $(LIBS) $(BOOSTLIBS_PO)
+       $(CC) $(CCO)$@ $< $(LIBS) $(BOOSTLIBS_PO)
 
 utils/fg2dot$(EE) : utils/fg2dot.cpp $(HEADERS) $(LIB)/libdai$(LE)
-       $(CC) $(CCO)utils/fg2dot$(EE) utils/fg2dot.cpp $(LIBS)
+       $(CC) $(CCO)$@ $< $(LIBS)
 
 utils/fginfo$(EE) : utils/fginfo.cpp $(HEADERS) $(LIB)/libdai$(LE)
-       $(CC) $(CCO)utils/fginfo$(EE) utils/fginfo.cpp $(LIBS)
+       $(CC) $(CCO)$@ $< $(LIBS)
 
 
 # LIBRARY
index dd2c4c4..ae8cdd0 100644 (file)
@@ -20,6 +20,7 @@
 
 #include <vector>
 #include <algorithm>
+#include <iostream>
 
 
 namespace dai {
@@ -198,9 +199,14 @@ class SmallSet {
         const_reverse_iterator rend() const { return _elements.rend(); }
 
         /// Returns reference to first element
-        T& front() { return _elements.at(0); }
+        T& front() { return _elements.front(); }
         /// Returns constant reference to first element
-        const T& front() const { return _elements.at(0); }
+        const T& front() const { return _elements.front(); }
+
+        /// Returns reference to last element
+        T& back() { return _elements.back(); }
+        /// Returns constant reference to last element
+        const T& back() const { return _elements.back(); }
     //@}
 
     /// \name Comparison operators
@@ -220,6 +226,18 @@ class SmallSet {
             return a._elements < b._elements;
         }
     //@}
+
+    /// \name Streaming input/output
+    //@{
+        /// Writes a SmallSet to an output stream
+        friend std::ostream& operator << ( std::ostream& os, const SmallSet& x ) {
+            os << "{";
+            for( typename std::vector<T>::const_iterator it = x.begin(); it != x.end(); it++ )
+                os << (it != x.begin() ? ", " : "") << *it;
+            os << "}";
+            return os;
+        }
+    //@}
 };
 
 
diff --git a/tests/unit/smallset.cpp b/tests/unit/smallset.cpp
new file mode 100644 (file)
index 0000000..d863480
--- /dev/null
@@ -0,0 +1,772 @@
+/*  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) 2010  Joris Mooij      [joris dot mooij at libdai dot org]
+ */
+
+
+#define BOOST_TEST_DYN_LINK
+
+
+#include <dai/smallset.h>
+#include <vector>
+
+
+using namespace dai;
+
+
+#define BOOST_TEST_MODULE SmallSetTest
+
+
+#include <boost/test/unit_test.hpp>
+
+
+BOOST_AUTO_TEST_CASE( ConstructorsTest ) {
+    // check constructors
+    SmallSet<int> x;
+    BOOST_CHECK( x.empty() );
+    BOOST_CHECK_EQUAL( x.size(), 0 );
+    BOOST_CHECK( !x.contains( 5 ) );
+
+    SmallSet<int> y( 1 );
+    BOOST_CHECK( !y.empty() );
+    BOOST_CHECK_EQUAL( y.size(), 1 );
+    BOOST_CHECK( !y.contains( 5 ) );
+    BOOST_CHECK( y.contains( 1 ) );
+
+    SmallSet<double> z( 1.0, 2.0 );
+    BOOST_CHECK_EQUAL( z.size(), 2 );
+    BOOST_CHECK( !z.contains( 5.0 ) );
+    BOOST_CHECK( z.contains( 1.0 ) );
+    BOOST_CHECK( z.contains( 2.0 ) );
+
+    SmallSet<char> v( 'a', 'a' );
+    BOOST_CHECK_EQUAL( v.size(), 1 );
+    BOOST_CHECK( v.contains( 'a' ) );
+    BOOST_CHECK( !v.contains( 'b' ) );
+
+    std::vector<int> a;
+    a.push_back( 1 );
+    a.push_back( 3 );
+    a.push_back( 4 );
+    a.push_back( 3 );
+    a.push_back( 2 );
+    SmallSet<double> w( a.begin(), a.end() );
+    BOOST_CHECK_EQUAL( w.size(), 4 );
+    BOOST_CHECK( w.contains( 1 ) );
+    BOOST_CHECK( w.contains( 2 ) );
+    BOOST_CHECK( w.contains( 3 ) );
+    BOOST_CHECK( w.contains( 4 ) );
+    BOOST_CHECK( !w.contains( 0 ) );
+
+    x = y;
+    BOOST_CHECK( x == y );
+}
+
+
+BOOST_AUTO_TEST_CASE( ComparisonTest ) {
+    // check comparison operators
+    SmallSet<int> x, y;
+    BOOST_CHECK( x == y );
+    BOOST_CHECK( !(x != y) );
+
+    SmallSet<int> z( 1 );
+    BOOST_CHECK( x != z );
+    BOOST_CHECK( !(x == z) );
+
+    BOOST_CHECK( x < z );
+
+    SmallSet<int> u( 2 );
+    BOOST_CHECK( x < u );
+    BOOST_CHECK( z < u );
+    BOOST_CHECK( !(u < z) );
+
+    SmallSet<int> v( 2, 1 );
+    BOOST_CHECK( x < v );
+    BOOST_CHECK( z < v );
+    BOOST_CHECK( !(v < z) );
+    BOOST_CHECK( v < u );
+    BOOST_CHECK( !(u < v) );
+
+    SmallSet<int> w( 1, 3 );
+    BOOST_CHECK( x < w );
+    BOOST_CHECK( v < w );
+    BOOST_CHECK( z < w );
+    BOOST_CHECK( w < u );
+    BOOST_CHECK( !(w < x) );
+    BOOST_CHECK( !(w < v) );
+    BOOST_CHECK( !(w < z) );
+    BOOST_CHECK( !(u < w) );
+}
+
+
+BOOST_AUTO_TEST_CASE( IteratorTest ) {
+    // check iterator interface
+    std::vector<int> v;
+    v.push_back( 3 );
+    v.push_back( 2 );
+    v.push_back( 2 );
+    v.push_back( 1 );
+    v.push_back( 3 );
+    SmallSet<int> x( v.begin(), v.end(), v.size() );
+
+    BOOST_CHECK( x.begin() != x.end() );
+    BOOST_CHECK( x.rbegin() != x.rend() );
+
+    BOOST_CHECK_EQUAL( x.front(), 1 );
+    BOOST_CHECK_EQUAL( x.back(), 3 );
+
+    SmallSet<int>::const_iterator j = x.begin();
+    SmallSet<int>::iterator k = x.begin();
+    for( size_t i = 1; i < 4; i++, j++, k++ ) {
+        BOOST_CHECK_EQUAL( i, *j );
+        BOOST_CHECK_EQUAL( i, *k );
+    }
+    BOOST_CHECK( j == x.end() );
+    BOOST_CHECK( k == x.end() );
+
+    SmallSet<int>::const_reverse_iterator rj = x.rbegin();
+    SmallSet<int>::reverse_iterator rk = x.rbegin();
+    for( size_t i = 3; i > 0; i--, rj++, rk++ ) {
+        BOOST_CHECK_EQUAL( i, *rj );
+        BOOST_CHECK_EQUAL( i, *rk );
+    }
+    BOOST_CHECK( rj == x.rend() );
+    BOOST_CHECK( rk == x.rend() );
+}
+
+
+BOOST_AUTO_TEST_CASE( QueriesTest ) {
+    // check queries
+    SmallSet<int> x( 2, 1 );
+    SmallSet<int> y( 2, 3 );
+    SmallSet<int> z( 4, 3 );
+
+    BOOST_CHECK( x.intersects( y ) );
+    BOOST_CHECK( !x.intersects( z ) );
+    BOOST_CHECK( y.intersects( x ) );
+    BOOST_CHECK( y.intersects( z ) );
+    BOOST_CHECK( !z.intersects( x ) );
+    BOOST_CHECK( z.intersects( y ) );
+
+    BOOST_CHECK( x.contains( 1 ) );
+    BOOST_CHECK( x.contains( 2 ) );
+    BOOST_CHECK( !x.contains( 3 ) );
+    BOOST_CHECK( !x.contains( 4 ) );
+    BOOST_CHECK( !y.contains( 1 ) );
+    BOOST_CHECK( y.contains( 2 ) );
+    BOOST_CHECK( y.contains( 3 ) );
+    BOOST_CHECK( !y.contains( 4 ) );
+    BOOST_CHECK( !z.contains( 1 ) );
+    BOOST_CHECK( !z.contains( 2 ) );
+    BOOST_CHECK( z.contains( 3 ) );
+    BOOST_CHECK( z.contains( 4 ) );
+
+    BOOST_CHECK_EQUAL( x.size(), 2 );
+
+    BOOST_CHECK( !x.empty() );
+    
+    x.elements()[0] = 3;
+    x.elements()[1] = 4;
+    std::vector<int> v;
+    v.push_back( 3 );
+    v.push_back( 4 );
+    BOOST_CHECK( x.elements() == v );
+}
+
+
+BOOST_AUTO_TEST_CASE( OperatorTest ) {
+    // check operators
+    SmallSet<int> x;
+    SmallSet<int> x1( 1 );
+    SmallSet<int> x2( 2 );
+    SmallSet<int> x3( 3 );
+    SmallSet<int> x12( 2, 1 );
+    SmallSet<int> x23( 2, 3 );
+    SmallSet<int> x13( 1, 3 );
+    SmallSet<int> x123 = x12 | 3;
+    SmallSet<int> y;
+
+    // check operator/
+    BOOST_CHECK_EQUAL( x    / x,    x    );
+    BOOST_CHECK_EQUAL( x    / x1,   x    );
+    BOOST_CHECK_EQUAL( x    / x2,   x    );
+    BOOST_CHECK_EQUAL( x    / x3,   x    );
+    BOOST_CHECK_EQUAL( x    / x12,  x    );
+    BOOST_CHECK_EQUAL( x    / x23,  x    );
+    BOOST_CHECK_EQUAL( x    / x13,  x    );
+    BOOST_CHECK_EQUAL( x    / x123, x    );
+    BOOST_CHECK_EQUAL( x1   / x,    x1   );
+    BOOST_CHECK_EQUAL( x1   / x1,   x    );
+    BOOST_CHECK_EQUAL( x1   / x2,   x1   );
+    BOOST_CHECK_EQUAL( x1   / x3,   x1   );
+    BOOST_CHECK_EQUAL( x1   / x12,  x    );
+    BOOST_CHECK_EQUAL( x1   / x23,  x1   );
+    BOOST_CHECK_EQUAL( x1   / x13,  x    );
+    BOOST_CHECK_EQUAL( x1   / x123, x    );
+    BOOST_CHECK_EQUAL( x2   / x,    x2   );
+    BOOST_CHECK_EQUAL( x2   / x1,   x2   );
+    BOOST_CHECK_EQUAL( x2   / x2,   x    );
+    BOOST_CHECK_EQUAL( x2   / x3,   x2   );
+    BOOST_CHECK_EQUAL( x2   / x12,  x    );
+    BOOST_CHECK_EQUAL( x2   / x23,  x    );
+    BOOST_CHECK_EQUAL( x2   / x13,  x2   );
+    BOOST_CHECK_EQUAL( x2   / x123, x    );
+    BOOST_CHECK_EQUAL( x3   / x,    x3   );
+    BOOST_CHECK_EQUAL( x3   / x1,   x3   );
+    BOOST_CHECK_EQUAL( x3   / x2,   x3   );
+    BOOST_CHECK_EQUAL( x3   / x3,   x    );
+    BOOST_CHECK_EQUAL( x3   / x12,  x3   );
+    BOOST_CHECK_EQUAL( x3   / x23,  x    );
+    BOOST_CHECK_EQUAL( x3   / x13,  x    );
+    BOOST_CHECK_EQUAL( x3   / x123, x    );
+    BOOST_CHECK_EQUAL( x12  / x,    x12  );
+    BOOST_CHECK_EQUAL( x12  / x1,   x2   );
+    BOOST_CHECK_EQUAL( x12  / x2,   x1   );
+    BOOST_CHECK_EQUAL( x12  / x3,   x12  );
+    BOOST_CHECK_EQUAL( x12  / x12,  x    );
+    BOOST_CHECK_EQUAL( x12  / x23,  x1   );
+    BOOST_CHECK_EQUAL( x12  / x13,  x2   );
+    BOOST_CHECK_EQUAL( x12  / x123, x    );
+    BOOST_CHECK_EQUAL( x23  / x,    x23  );
+    BOOST_CHECK_EQUAL( x23  / x1,   x23  );
+    BOOST_CHECK_EQUAL( x23  / x2,   x3   );
+    BOOST_CHECK_EQUAL( x23  / x3,   x2   );
+    BOOST_CHECK_EQUAL( x23  / x12,  x3   );
+    BOOST_CHECK_EQUAL( x23  / x23,  x    );
+    BOOST_CHECK_EQUAL( x23  / x13,  x2   );
+    BOOST_CHECK_EQUAL( x23  / x123, x    );
+    BOOST_CHECK_EQUAL( x13  / x,    x13  );
+    BOOST_CHECK_EQUAL( x13  / x1,   x3   );
+    BOOST_CHECK_EQUAL( x13  / x2,   x13  );
+    BOOST_CHECK_EQUAL( x13  / x3,   x1   );
+    BOOST_CHECK_EQUAL( x13  / x12,  x3   );
+    BOOST_CHECK_EQUAL( x13  / x23,  x1   );
+    BOOST_CHECK_EQUAL( x13  / x13,  x    );
+    BOOST_CHECK_EQUAL( x13  / x123, x    );
+    BOOST_CHECK_EQUAL( x123 / x,    x123 );
+    BOOST_CHECK_EQUAL( x123 / x1,   x23  );
+    BOOST_CHECK_EQUAL( x123 / x2,   x13  );
+    BOOST_CHECK_EQUAL( x123 / x3,   x12  );
+    BOOST_CHECK_EQUAL( x123 / x12,  x3   );
+    BOOST_CHECK_EQUAL( x123 / x23,  x1   );
+    BOOST_CHECK_EQUAL( x123 / x13,  x2   );
+    BOOST_CHECK_EQUAL( x123 / x123, x    );
+
+    // check operator|
+    BOOST_CHECK_EQUAL( x    | x,    x    );
+    BOOST_CHECK_EQUAL( x    | x1,   x1   );
+    BOOST_CHECK_EQUAL( x    | x2,   x2   );
+    BOOST_CHECK_EQUAL( x    | x3,   x3   );
+    BOOST_CHECK_EQUAL( x    | x12,  x12  );
+    BOOST_CHECK_EQUAL( x    | x23,  x23  );
+    BOOST_CHECK_EQUAL( x    | x13,  x13  );
+    BOOST_CHECK_EQUAL( x    | x123, x123 );
+    BOOST_CHECK_EQUAL( x1   | x,    x1   );
+    BOOST_CHECK_EQUAL( x1   | x1,   x1   );
+    BOOST_CHECK_EQUAL( x1   | x2,   x12  );
+    BOOST_CHECK_EQUAL( x1   | x3,   x13  );
+    BOOST_CHECK_EQUAL( x1   | x12,  x12  );
+    BOOST_CHECK_EQUAL( x1   | x23,  x123 );
+    BOOST_CHECK_EQUAL( x1   | x13,  x13  );
+    BOOST_CHECK_EQUAL( x1   | x123, x123 );
+    BOOST_CHECK_EQUAL( x2   | x,    x2   );
+    BOOST_CHECK_EQUAL( x2   | x1,   x12  );
+    BOOST_CHECK_EQUAL( x2   | x2,   x2   );
+    BOOST_CHECK_EQUAL( x2   | x3,   x23  );
+    BOOST_CHECK_EQUAL( x2   | x12,  x12  );
+    BOOST_CHECK_EQUAL( x2   | x23,  x23  );
+    BOOST_CHECK_EQUAL( x2   | x13,  x123 );
+    BOOST_CHECK_EQUAL( x2   | x123, x123 );
+    BOOST_CHECK_EQUAL( x3   | x,    x3   );
+    BOOST_CHECK_EQUAL( x3   | x1,   x13  );
+    BOOST_CHECK_EQUAL( x3   | x2,   x23  );
+    BOOST_CHECK_EQUAL( x3   | x3,   x3   );
+    BOOST_CHECK_EQUAL( x3   | x12,  x123 );
+    BOOST_CHECK_EQUAL( x3   | x23,  x23  );
+    BOOST_CHECK_EQUAL( x3   | x13,  x13  );
+    BOOST_CHECK_EQUAL( x3   | x123, x123 );
+    BOOST_CHECK_EQUAL( x12  | x,    x12  );
+    BOOST_CHECK_EQUAL( x12  | x1,   x12  );
+    BOOST_CHECK_EQUAL( x12  | x2,   x12  );
+    BOOST_CHECK_EQUAL( x12  | x3,   x123 );
+    BOOST_CHECK_EQUAL( x12  | x12,  x12  );
+    BOOST_CHECK_EQUAL( x12  | x23,  x123 );
+    BOOST_CHECK_EQUAL( x12  | x13,  x123 );
+    BOOST_CHECK_EQUAL( x12  | x123, x123 );
+    BOOST_CHECK_EQUAL( x23  | x,    x23  );
+    BOOST_CHECK_EQUAL( x23  | x1,   x123 );
+    BOOST_CHECK_EQUAL( x23  | x2,   x23  );
+    BOOST_CHECK_EQUAL( x23  | x3,   x23  );
+    BOOST_CHECK_EQUAL( x23  | x12,  x123 );
+    BOOST_CHECK_EQUAL( x23  | x23,  x23  );
+    BOOST_CHECK_EQUAL( x23  | x13,  x123 );
+    BOOST_CHECK_EQUAL( x23  | x123, x123 );
+    BOOST_CHECK_EQUAL( x13  | x,    x13  );
+    BOOST_CHECK_EQUAL( x13  | x1,   x13  );
+    BOOST_CHECK_EQUAL( x13  | x2,   x123 );
+    BOOST_CHECK_EQUAL( x13  | x3,   x13  );
+    BOOST_CHECK_EQUAL( x13  | x12,  x123 );
+    BOOST_CHECK_EQUAL( x13  | x23,  x123 );
+    BOOST_CHECK_EQUAL( x13  | x13,  x13  );
+    BOOST_CHECK_EQUAL( x13  | x123, x123 );
+    BOOST_CHECK_EQUAL( x123 | x,    x123 );
+    BOOST_CHECK_EQUAL( x123 | x1,   x123 );
+    BOOST_CHECK_EQUAL( x123 | x2,   x123 );
+    BOOST_CHECK_EQUAL( x123 | x3,   x123 );
+    BOOST_CHECK_EQUAL( x123 | x12,  x123 );
+    BOOST_CHECK_EQUAL( x123 | x23,  x123 );
+    BOOST_CHECK_EQUAL( x123 | x13,  x123 );
+    BOOST_CHECK_EQUAL( x123 | x123, x123 );
+
+    // check operator&
+    BOOST_CHECK_EQUAL( x    & x,    x    );
+    BOOST_CHECK_EQUAL( x    & x1,   x    );
+    BOOST_CHECK_EQUAL( x    & x2,   x    );
+    BOOST_CHECK_EQUAL( x    & x3,   x    );
+    BOOST_CHECK_EQUAL( x    & x12,  x    );
+    BOOST_CHECK_EQUAL( x    & x23,  x    );
+    BOOST_CHECK_EQUAL( x    & x13,  x    );
+    BOOST_CHECK_EQUAL( x    & x123, x    );
+    BOOST_CHECK_EQUAL( x1   & x,    x    );
+    BOOST_CHECK_EQUAL( x1   & x1,   x1   );
+    BOOST_CHECK_EQUAL( x1   & x2,   x    );
+    BOOST_CHECK_EQUAL( x1   & x3,   x    );
+    BOOST_CHECK_EQUAL( x1   & x12,  x1   );
+    BOOST_CHECK_EQUAL( x1   & x23,  x    );
+    BOOST_CHECK_EQUAL( x1   & x13,  x1   );
+    BOOST_CHECK_EQUAL( x1   & x123, x1   );
+    BOOST_CHECK_EQUAL( x2   & x,    x    );
+    BOOST_CHECK_EQUAL( x2   & x1,   x    );
+    BOOST_CHECK_EQUAL( x2   & x2,   x2   );
+    BOOST_CHECK_EQUAL( x2   & x3,   x    );
+    BOOST_CHECK_EQUAL( x2   & x12,  x2   );
+    BOOST_CHECK_EQUAL( x2   & x23,  x2   );
+    BOOST_CHECK_EQUAL( x2   & x13,  x    );
+    BOOST_CHECK_EQUAL( x2   & x123, x2   );
+    BOOST_CHECK_EQUAL( x3   & x,    x    );
+    BOOST_CHECK_EQUAL( x3   & x1,   x    );
+    BOOST_CHECK_EQUAL( x3   & x2,   x    );
+    BOOST_CHECK_EQUAL( x3   & x3,   x3   );
+    BOOST_CHECK_EQUAL( x3   & x12,  x    );
+    BOOST_CHECK_EQUAL( x3   & x23,  x3   );
+    BOOST_CHECK_EQUAL( x3   & x13,  x3   );
+    BOOST_CHECK_EQUAL( x3   & x123, x3   );
+    BOOST_CHECK_EQUAL( x12  & x,    x    );
+    BOOST_CHECK_EQUAL( x12  & x1,   x1   );
+    BOOST_CHECK_EQUAL( x12  & x2,   x2   );
+    BOOST_CHECK_EQUAL( x12  & x3,   x    );
+    BOOST_CHECK_EQUAL( x12  & x12,  x12  );
+    BOOST_CHECK_EQUAL( x12  & x23,  x2   );
+    BOOST_CHECK_EQUAL( x12  & x13,  x1   );
+    BOOST_CHECK_EQUAL( x12  & x123, x12  );
+    BOOST_CHECK_EQUAL( x23  & x,    x    );
+    BOOST_CHECK_EQUAL( x23  & x1,   x    );
+    BOOST_CHECK_EQUAL( x23  & x2,   x2   );
+    BOOST_CHECK_EQUAL( x23  & x3,   x3   );
+    BOOST_CHECK_EQUAL( x23  & x12,  x2   );
+    BOOST_CHECK_EQUAL( x23  & x23,  x23  );
+    BOOST_CHECK_EQUAL( x23  & x13,  x3   );
+    BOOST_CHECK_EQUAL( x23  & x123, x23  );
+    BOOST_CHECK_EQUAL( x13  & x,    x    );
+    BOOST_CHECK_EQUAL( x13  & x1,   x1   );
+    BOOST_CHECK_EQUAL( x13  & x2,   x    );
+    BOOST_CHECK_EQUAL( x13  & x3,   x3   );
+    BOOST_CHECK_EQUAL( x13  & x12,  x1   );
+    BOOST_CHECK_EQUAL( x13  & x23,  x3   );
+    BOOST_CHECK_EQUAL( x13  & x13,  x13  );
+    BOOST_CHECK_EQUAL( x13  & x123, x13  );
+    BOOST_CHECK_EQUAL( x123 & x,    x    );
+    BOOST_CHECK_EQUAL( x123 & x1,   x1   );
+    BOOST_CHECK_EQUAL( x123 & x2,   x2   );
+    BOOST_CHECK_EQUAL( x123 & x3,   x3   );
+    BOOST_CHECK_EQUAL( x123 & x12,  x12  );
+    BOOST_CHECK_EQUAL( x123 & x23,  x23  );
+    BOOST_CHECK_EQUAL( x123 & x13,  x13  );
+    BOOST_CHECK_EQUAL( x123 & x123, x123 );
+
+    // check operator/=
+    y = x   ; y /= x;    BOOST_CHECK_EQUAL( y, x    );
+    y = x   ; y /= x1;   BOOST_CHECK_EQUAL( y, x    );
+    y = x   ; y /= x2;   BOOST_CHECK_EQUAL( y, x    );
+    y = x   ; y /= x3;   BOOST_CHECK_EQUAL( y, x    );
+    y = x   ; y /= x12;  BOOST_CHECK_EQUAL( y, x    );
+    y = x   ; y /= x23;  BOOST_CHECK_EQUAL( y, x    );
+    y = x   ; y /= x13;  BOOST_CHECK_EQUAL( y, x    );
+    y = x   ; y /= x123; BOOST_CHECK_EQUAL( y, x    );
+    y = x1  ; y /= x;    BOOST_CHECK_EQUAL( y, x1   );
+    y = x1  ; y /= x1;   BOOST_CHECK_EQUAL( y, x    );
+    y = x1  ; y /= x2;   BOOST_CHECK_EQUAL( y, x1   );
+    y = x1  ; y /= x3;   BOOST_CHECK_EQUAL( y, x1   );
+    y = x1  ; y /= x12;  BOOST_CHECK_EQUAL( y, x    );
+    y = x1  ; y /= x23;  BOOST_CHECK_EQUAL( y, x1   );
+    y = x1  ; y /= x13;  BOOST_CHECK_EQUAL( y, x    );
+    y = x1  ; y /= x123; BOOST_CHECK_EQUAL( y, x    );
+    y = x2  ; y /= x;    BOOST_CHECK_EQUAL( y, x2   );
+    y = x2  ; y /= x1;   BOOST_CHECK_EQUAL( y, x2   );
+    y = x2  ; y /= x2;   BOOST_CHECK_EQUAL( y, x    );
+    y = x2  ; y /= x3;   BOOST_CHECK_EQUAL( y, x2   );
+    y = x2  ; y /= x12;  BOOST_CHECK_EQUAL( y, x    );
+    y = x2  ; y /= x23;  BOOST_CHECK_EQUAL( y, x    );
+    y = x2  ; y /= x13;  BOOST_CHECK_EQUAL( y, x2   );
+    y = x2  ; y /= x123; BOOST_CHECK_EQUAL( y, x    );
+    y = x3  ; y /= x;    BOOST_CHECK_EQUAL( y, x3   );
+    y = x3  ; y /= x1;   BOOST_CHECK_EQUAL( y, x3   );
+    y = x3  ; y /= x2;   BOOST_CHECK_EQUAL( y, x3   );
+    y = x3  ; y /= x3;   BOOST_CHECK_EQUAL( y, x    );
+    y = x3  ; y /= x12;  BOOST_CHECK_EQUAL( y, x3   );
+    y = x3  ; y /= x23;  BOOST_CHECK_EQUAL( y, x    );
+    y = x3  ; y /= x13;  BOOST_CHECK_EQUAL( y, x    );
+    y = x3  ; y /= x123; BOOST_CHECK_EQUAL( y, x    );
+    y = x12 ; y /= x;    BOOST_CHECK_EQUAL( y, x12  );
+    y = x12 ; y /= x1;   BOOST_CHECK_EQUAL( y, x2   );
+    y = x12 ; y /= x2;   BOOST_CHECK_EQUAL( y, x1   );
+    y = x12 ; y /= x3;   BOOST_CHECK_EQUAL( y, x12  );
+    y = x12 ; y /= x12;  BOOST_CHECK_EQUAL( y, x    );
+    y = x12 ; y /= x23;  BOOST_CHECK_EQUAL( y, x1   );
+    y = x12 ; y /= x13;  BOOST_CHECK_EQUAL( y, x2   );
+    y = x12 ; y /= x123; BOOST_CHECK_EQUAL( y, x    );
+    y = x23 ; y /= x;    BOOST_CHECK_EQUAL( y, x23  );
+    y = x23 ; y /= x1;   BOOST_CHECK_EQUAL( y, x23  );
+    y = x23 ; y /= x2;   BOOST_CHECK_EQUAL( y, x3   );
+    y = x23 ; y /= x3;   BOOST_CHECK_EQUAL( y, x2   );
+    y = x23 ; y /= x12;  BOOST_CHECK_EQUAL( y, x3   );
+    y = x23 ; y /= x23;  BOOST_CHECK_EQUAL( y, x    );
+    y = x23 ; y /= x13;  BOOST_CHECK_EQUAL( y, x2   );
+    y = x23 ; y /= x123; BOOST_CHECK_EQUAL( y, x    );
+    y = x13 ; y /= x;    BOOST_CHECK_EQUAL( y, x13  );
+    y = x13 ; y /= x1;   BOOST_CHECK_EQUAL( y, x3   );
+    y = x13 ; y /= x2;   BOOST_CHECK_EQUAL( y, x13  );
+    y = x13 ; y /= x3;   BOOST_CHECK_EQUAL( y, x1   );
+    y = x13 ; y /= x12;  BOOST_CHECK_EQUAL( y, x3   );
+    y = x13 ; y /= x23;  BOOST_CHECK_EQUAL( y, x1   );
+    y = x13 ; y /= x13;  BOOST_CHECK_EQUAL( y, x    );
+    y = x13 ; y /= x123; BOOST_CHECK_EQUAL( y, x    );
+    y = x123; y /= x;    BOOST_CHECK_EQUAL( y, x123 );
+    y = x123; y /= x1;   BOOST_CHECK_EQUAL( y, x23  );
+    y = x123; y /= x2;   BOOST_CHECK_EQUAL( y, x13  );
+    y = x123; y /= x3;   BOOST_CHECK_EQUAL( y, x12  );
+    y = x123; y /= x12;  BOOST_CHECK_EQUAL( y, x3   );
+    y = x123; y /= x23;  BOOST_CHECK_EQUAL( y, x1   );
+    y = x123; y /= x13;  BOOST_CHECK_EQUAL( y, x2   );
+    y = x123; y /= x123; BOOST_CHECK_EQUAL( y, x    );
+
+    // check operator|=
+    y = x   ; y |= x;    BOOST_CHECK_EQUAL( y, x    );
+    y = x   ; y |= x1;   BOOST_CHECK_EQUAL( y, x1   );
+    y = x   ; y |= x2;   BOOST_CHECK_EQUAL( y, x2   );
+    y = x   ; y |= x3;   BOOST_CHECK_EQUAL( y, x3   );
+    y = x   ; y |= x12;  BOOST_CHECK_EQUAL( y, x12  );
+    y = x   ; y |= x23;  BOOST_CHECK_EQUAL( y, x23  );
+    y = x   ; y |= x13;  BOOST_CHECK_EQUAL( y, x13  );
+    y = x   ; y |= x123; BOOST_CHECK_EQUAL( y, x123 );
+    y = x1  ; y |= x;    BOOST_CHECK_EQUAL( y, x1   );
+    y = x1  ; y |= x1;   BOOST_CHECK_EQUAL( y, x1   );
+    y = x1  ; y |= x2;   BOOST_CHECK_EQUAL( y, x12  );
+    y = x1  ; y |= x3;   BOOST_CHECK_EQUAL( y, x13  );
+    y = x1  ; y |= x12;  BOOST_CHECK_EQUAL( y, x12  );
+    y = x1  ; y |= x23;  BOOST_CHECK_EQUAL( y, x123 );
+    y = x1  ; y |= x13;  BOOST_CHECK_EQUAL( y, x13  );
+    y = x1  ; y |= x123; BOOST_CHECK_EQUAL( y, x123 );
+    y = x2  ; y |= x;    BOOST_CHECK_EQUAL( y, x2   );
+    y = x2  ; y |= x1;   BOOST_CHECK_EQUAL( y, x12  );
+    y = x2  ; y |= x2;   BOOST_CHECK_EQUAL( y, x2   );
+    y = x2  ; y |= x3;   BOOST_CHECK_EQUAL( y, x23  );
+    y = x2  ; y |= x12;  BOOST_CHECK_EQUAL( y, x12  );
+    y = x2  ; y |= x23;  BOOST_CHECK_EQUAL( y, x23  );
+    y = x2  ; y |= x13;  BOOST_CHECK_EQUAL( y, x123 );
+    y = x2  ; y |= x123; BOOST_CHECK_EQUAL( y, x123 );
+    y = x3  ; y |= x;    BOOST_CHECK_EQUAL( y, x3   );
+    y = x3  ; y |= x1;   BOOST_CHECK_EQUAL( y, x13  );
+    y = x3  ; y |= x2;   BOOST_CHECK_EQUAL( y, x23  );
+    y = x3  ; y |= x3;   BOOST_CHECK_EQUAL( y, x3   );
+    y = x3  ; y |= x12;  BOOST_CHECK_EQUAL( y, x123 );
+    y = x3  ; y |= x23;  BOOST_CHECK_EQUAL( y, x23  );
+    y = x3  ; y |= x13;  BOOST_CHECK_EQUAL( y, x13  );
+    y = x3  ; y |= x123; BOOST_CHECK_EQUAL( y, x123 );
+    y = x12 ; y |= x;    BOOST_CHECK_EQUAL( y, x12  );
+    y = x12 ; y |= x1;   BOOST_CHECK_EQUAL( y, x12  );
+    y = x12 ; y |= x2;   BOOST_CHECK_EQUAL( y, x12  );
+    y = x12 ; y |= x3;   BOOST_CHECK_EQUAL( y, x123 );
+    y = x12 ; y |= x12;  BOOST_CHECK_EQUAL( y, x12  );
+    y = x12 ; y |= x23;  BOOST_CHECK_EQUAL( y, x123 );
+    y = x12 ; y |= x13;  BOOST_CHECK_EQUAL( y, x123 );
+    y = x12 ; y |= x123; BOOST_CHECK_EQUAL( y, x123 );
+    y = x23 ; y |= x;    BOOST_CHECK_EQUAL( y, x23  );
+    y = x23 ; y |= x1;   BOOST_CHECK_EQUAL( y, x123 );
+    y = x23 ; y |= x2;   BOOST_CHECK_EQUAL( y, x23  );
+    y = x23 ; y |= x3;   BOOST_CHECK_EQUAL( y, x23  );
+    y = x23 ; y |= x12;  BOOST_CHECK_EQUAL( y, x123 );
+    y = x23 ; y |= x23;  BOOST_CHECK_EQUAL( y, x23  );
+    y = x23 ; y |= x13;  BOOST_CHECK_EQUAL( y, x123 );
+    y = x23 ; y |= x123; BOOST_CHECK_EQUAL( y, x123 );
+    y = x13 ; y |= x;    BOOST_CHECK_EQUAL( y, x13  );
+    y = x13 ; y |= x1;   BOOST_CHECK_EQUAL( y, x13  );
+    y = x13 ; y |= x2;   BOOST_CHECK_EQUAL( y, x123 );
+    y = x13 ; y |= x3;   BOOST_CHECK_EQUAL( y, x13  );
+    y = x13 ; y |= x12;  BOOST_CHECK_EQUAL( y, x123 );
+    y = x13 ; y |= x23;  BOOST_CHECK_EQUAL( y, x123 );
+    y = x13 ; y |= x13;  BOOST_CHECK_EQUAL( y, x13  );
+    y = x13 ; y |= x123; BOOST_CHECK_EQUAL( y, x123 );
+    y = x123; y |= x;    BOOST_CHECK_EQUAL( y, x123 );
+    y = x123; y |= x1;   BOOST_CHECK_EQUAL( y, x123 );
+    y = x123; y |= x2;   BOOST_CHECK_EQUAL( y, x123 );
+    y = x123; y |= x3;   BOOST_CHECK_EQUAL( y, x123 );
+    y = x123; y |= x12;  BOOST_CHECK_EQUAL( y, x123 );
+    y = x123; y |= x23;  BOOST_CHECK_EQUAL( y, x123 );
+    y = x123; y |= x13;  BOOST_CHECK_EQUAL( y, x123 );
+    y = x123; y |= x123; BOOST_CHECK_EQUAL( y, x123 );
+
+    // check operator&=
+    y = x   ; y &= x;    BOOST_CHECK_EQUAL( y, x    );
+    y = x   ; y &= x1;   BOOST_CHECK_EQUAL( y, x    );
+    y = x   ; y &= x2;   BOOST_CHECK_EQUAL( y, x    );
+    y = x   ; y &= x3;   BOOST_CHECK_EQUAL( y, x    );
+    y = x   ; y &= x12;  BOOST_CHECK_EQUAL( y, x    );
+    y = x   ; y &= x23;  BOOST_CHECK_EQUAL( y, x    );
+    y = x   ; y &= x13;  BOOST_CHECK_EQUAL( y, x    );
+    y = x   ; y &= x123; BOOST_CHECK_EQUAL( y, x    );
+    y = x1  ; y &= x;    BOOST_CHECK_EQUAL( y, x    );
+    y = x1  ; y &= x1;   BOOST_CHECK_EQUAL( y, x1   );
+    y = x1  ; y &= x2;   BOOST_CHECK_EQUAL( y, x    );
+    y = x1  ; y &= x3;   BOOST_CHECK_EQUAL( y, x    );
+    y = x1  ; y &= x12;  BOOST_CHECK_EQUAL( y, x1   );
+    y = x1  ; y &= x23;  BOOST_CHECK_EQUAL( y, x    );
+    y = x1  ; y &= x13;  BOOST_CHECK_EQUAL( y, x1   );
+    y = x1  ; y &= x123; BOOST_CHECK_EQUAL( y, x1   );
+    y = x2  ; y &= x;    BOOST_CHECK_EQUAL( y, x    );
+    y = x2  ; y &= x1;   BOOST_CHECK_EQUAL( y, x    );
+    y = x2  ; y &= x2;   BOOST_CHECK_EQUAL( y, x2   );
+    y = x2  ; y &= x3;   BOOST_CHECK_EQUAL( y, x    );
+    y = x2  ; y &= x12;  BOOST_CHECK_EQUAL( y, x2   );
+    y = x2  ; y &= x23;  BOOST_CHECK_EQUAL( y, x2   );
+    y = x2  ; y &= x13;  BOOST_CHECK_EQUAL( y, x    );
+    y = x2  ; y &= x123; BOOST_CHECK_EQUAL( y, x2   );
+    y = x3  ; y &= x;    BOOST_CHECK_EQUAL( y, x    );
+    y = x3  ; y &= x1;   BOOST_CHECK_EQUAL( y, x    );
+    y = x3  ; y &= x2;   BOOST_CHECK_EQUAL( y, x    );
+    y = x3  ; y &= x3;   BOOST_CHECK_EQUAL( y, x3   );
+    y = x3  ; y &= x12;  BOOST_CHECK_EQUAL( y, x    );
+    y = x3  ; y &= x23;  BOOST_CHECK_EQUAL( y, x3   );
+    y = x3  ; y &= x13;  BOOST_CHECK_EQUAL( y, x3   );
+    y = x3  ; y &= x123; BOOST_CHECK_EQUAL( y, x3   );
+    y = x12 ; y &= x;    BOOST_CHECK_EQUAL( y, x    );
+    y = x12 ; y &= x1;   BOOST_CHECK_EQUAL( y, x1   );
+    y = x12 ; y &= x2;   BOOST_CHECK_EQUAL( y, x2   );
+    y = x12 ; y &= x3;   BOOST_CHECK_EQUAL( y, x    );
+    y = x12 ; y &= x12;  BOOST_CHECK_EQUAL( y, x12  );
+    y = x12 ; y &= x23;  BOOST_CHECK_EQUAL( y, x2   );
+    y = x12 ; y &= x13;  BOOST_CHECK_EQUAL( y, x1   );
+    y = x12 ; y &= x123; BOOST_CHECK_EQUAL( y, x12  );
+    y = x23 ; y &= x;    BOOST_CHECK_EQUAL( y, x    );
+    y = x23 ; y &= x1;   BOOST_CHECK_EQUAL( y, x    );
+    y = x23 ; y &= x2;   BOOST_CHECK_EQUAL( y, x2   );
+    y = x23 ; y &= x3;   BOOST_CHECK_EQUAL( y, x3   );
+    y = x23 ; y &= x12;  BOOST_CHECK_EQUAL( y, x2   );
+    y = x23 ; y &= x23;  BOOST_CHECK_EQUAL( y, x23  );
+    y = x23 ; y &= x13;  BOOST_CHECK_EQUAL( y, x3   );
+    y = x23 ; y &= x123; BOOST_CHECK_EQUAL( y, x23  );
+    y = x13 ; y &= x;    BOOST_CHECK_EQUAL( y, x    );
+    y = x13 ; y &= x1;   BOOST_CHECK_EQUAL( y, x1   );
+    y = x13 ; y &= x2;   BOOST_CHECK_EQUAL( y, x    );
+    y = x13 ; y &= x3;   BOOST_CHECK_EQUAL( y, x3   );
+    y = x13 ; y &= x12;  BOOST_CHECK_EQUAL( y, x1   );
+    y = x13 ; y &= x23;  BOOST_CHECK_EQUAL( y, x3   );
+    y = x13 ; y &= x13;  BOOST_CHECK_EQUAL( y, x13  );
+    y = x13 ; y &= x123; BOOST_CHECK_EQUAL( y, x13  );
+    y = x123; y &= x;    BOOST_CHECK_EQUAL( y, x    );
+    y = x123; y &= x1;   BOOST_CHECK_EQUAL( y, x1   );
+    y = x123; y &= x2;   BOOST_CHECK_EQUAL( y, x2   );
+    y = x123; y &= x3;   BOOST_CHECK_EQUAL( y, x3   );
+    y = x123; y &= x12;  BOOST_CHECK_EQUAL( y, x12  );
+    y = x123; y &= x23;  BOOST_CHECK_EQUAL( y, x23  );
+    y = x123; y &= x13;  BOOST_CHECK_EQUAL( y, x13  );
+    y = x123; y &= x123; BOOST_CHECK_EQUAL( y, x123 );
+
+    // check operator/=
+    y = x   ; y /= 1;    BOOST_CHECK_EQUAL( y, x    );
+    y = x   ; y /= 2;    BOOST_CHECK_EQUAL( y, x    );
+    y = x   ; y /= 3;    BOOST_CHECK_EQUAL( y, x    );
+    y = x1  ; y /= 1;    BOOST_CHECK_EQUAL( y, x    );
+    y = x1  ; y /= 2;    BOOST_CHECK_EQUAL( y, x1   );
+    y = x1  ; y /= 3;    BOOST_CHECK_EQUAL( y, x1   );
+    y = x2  ; y /= 1;    BOOST_CHECK_EQUAL( y, x2   );
+    y = x2  ; y /= 2;    BOOST_CHECK_EQUAL( y, x    );
+    y = x2  ; y /= 3;    BOOST_CHECK_EQUAL( y, x2   );
+    y = x3  ; y /= 1;    BOOST_CHECK_EQUAL( y, x3   );
+    y = x3  ; y /= 2;    BOOST_CHECK_EQUAL( y, x3   );
+    y = x3  ; y /= 3;    BOOST_CHECK_EQUAL( y, x    );
+    y = x12 ; y /= 1;    BOOST_CHECK_EQUAL( y, x2   );
+    y = x12 ; y /= 2;    BOOST_CHECK_EQUAL( y, x1   );
+    y = x12 ; y /= 3;    BOOST_CHECK_EQUAL( y, x12  );
+    y = x13 ; y /= 1;    BOOST_CHECK_EQUAL( y, x3   );
+    y = x13 ; y /= 2;    BOOST_CHECK_EQUAL( y, x13  );
+    y = x13 ; y /= 3;    BOOST_CHECK_EQUAL( y, x1   );
+    y = x23 ; y /= 1;    BOOST_CHECK_EQUAL( y, x23  );
+    y = x23 ; y /= 2;    BOOST_CHECK_EQUAL( y, x3   );
+    y = x23 ; y /= 3;    BOOST_CHECK_EQUAL( y, x2   );
+    y = x123; y /= 1;    BOOST_CHECK_EQUAL( y, x23  );
+    y = x123; y /= 2;    BOOST_CHECK_EQUAL( y, x13  );
+    y = x123; y /= 3;    BOOST_CHECK_EQUAL( y, x12  );
+
+    // check operator|=
+    y = x   ; y |= 1;    BOOST_CHECK_EQUAL( y, x1   );
+    y = x   ; y |= 2;    BOOST_CHECK_EQUAL( y, x2   );
+    y = x   ; y |= 3;    BOOST_CHECK_EQUAL( y, x3   );
+    y = x1  ; y |= 1;    BOOST_CHECK_EQUAL( y, x1   );
+    y = x1  ; y |= 2;    BOOST_CHECK_EQUAL( y, x12  );
+    y = x1  ; y |= 3;    BOOST_CHECK_EQUAL( y, x13  );
+    y = x2  ; y |= 1;    BOOST_CHECK_EQUAL( y, x12  );
+    y = x2  ; y |= 2;    BOOST_CHECK_EQUAL( y, x2   );
+    y = x2  ; y |= 3;    BOOST_CHECK_EQUAL( y, x23  );
+    y = x3  ; y |= 1;    BOOST_CHECK_EQUAL( y, x13  );
+    y = x3  ; y |= 2;    BOOST_CHECK_EQUAL( y, x23  );
+    y = x3  ; y |= 3;    BOOST_CHECK_EQUAL( y, x3   );
+    y = x12 ; y |= 1;    BOOST_CHECK_EQUAL( y, x12  );
+    y = x12 ; y |= 2;    BOOST_CHECK_EQUAL( y, x12  );
+    y = x12 ; y |= 3;    BOOST_CHECK_EQUAL( y, x123 );
+    y = x13 ; y |= 1;    BOOST_CHECK_EQUAL( y, x13  );
+    y = x13 ; y |= 2;    BOOST_CHECK_EQUAL( y, x123 );
+    y = x13 ; y |= 3;    BOOST_CHECK_EQUAL( y, x13  );
+    y = x23 ; y |= 1;    BOOST_CHECK_EQUAL( y, x123 );
+    y = x23 ; y |= 2;    BOOST_CHECK_EQUAL( y, x23  );
+    y = x23 ; y |= 3;    BOOST_CHECK_EQUAL( y, x23  );
+    y = x123; y |= 1;    BOOST_CHECK_EQUAL( y, x123 );
+    y = x123; y |= 2;    BOOST_CHECK_EQUAL( y, x123 );
+    y = x123; y |= 3;    BOOST_CHECK_EQUAL( y, x123 );
+
+    // check operator<<
+    BOOST_CHECK(  (x    << x   ) );
+    BOOST_CHECK(  (x    << x1  ) );
+    BOOST_CHECK(  (x    << x2  ) );
+    BOOST_CHECK(  (x    << x3  ) );
+    BOOST_CHECK(  (x    << x12 ) );
+    BOOST_CHECK(  (x    << x13 ) );
+    BOOST_CHECK(  (x    << x23 ) );
+    BOOST_CHECK(  (x    << x123) );
+    BOOST_CHECK( !(x1   << x   ) );
+    BOOST_CHECK(  (x1   << x1  ) );
+    BOOST_CHECK( !(x1   << x2  ) );
+    BOOST_CHECK( !(x1   << x3  ) );
+    BOOST_CHECK(  (x1   << x12 ) );
+    BOOST_CHECK(  (x1   << x13 ) );
+    BOOST_CHECK( !(x1   << x23 ) );
+    BOOST_CHECK(  (x1   << x123) );
+    BOOST_CHECK( !(x2   << x   ) );
+    BOOST_CHECK( !(x2   << x1  ) );
+    BOOST_CHECK(  (x2   << x2  ) );
+    BOOST_CHECK( !(x2   << x3  ) );
+    BOOST_CHECK(  (x2   << x12 ) );
+    BOOST_CHECK( !(x2   << x13 ) );
+    BOOST_CHECK(  (x2   << x23 ) );
+    BOOST_CHECK(  (x2   << x123) );
+    BOOST_CHECK( !(x3   << x   ) );
+    BOOST_CHECK( !(x3   << x1  ) );
+    BOOST_CHECK( !(x3   << x2  ) );
+    BOOST_CHECK(  (x3   << x3  ) );
+    BOOST_CHECK( !(x3   << x12 ) );
+    BOOST_CHECK(  (x3   << x13 ) );
+    BOOST_CHECK(  (x3   << x23 ) );
+    BOOST_CHECK(  (x3   << x123) );
+    BOOST_CHECK( !(x12  << x   ) );
+    BOOST_CHECK( !(x12  << x1  ) );
+    BOOST_CHECK( !(x12  << x2  ) );
+    BOOST_CHECK( !(x12  << x3  ) );
+    BOOST_CHECK(  (x12  << x12 ) );
+    BOOST_CHECK( !(x12  << x13 ) );
+    BOOST_CHECK( !(x12  << x23 ) );
+    BOOST_CHECK(  (x12  << x123) );
+    BOOST_CHECK( !(x13  << x   ) );
+    BOOST_CHECK( !(x13  << x1  ) );
+    BOOST_CHECK( !(x13  << x2  ) );
+    BOOST_CHECK( !(x13  << x3  ) );
+    BOOST_CHECK( !(x13  << x12 ) );
+    BOOST_CHECK(  (x13  << x13 ) );
+    BOOST_CHECK( !(x13  << x23 ) );
+    BOOST_CHECK(  (x13  << x123) );
+    BOOST_CHECK( !(x23  << x   ) );
+    BOOST_CHECK( !(x23  << x1  ) );
+    BOOST_CHECK( !(x23  << x2  ) );
+    BOOST_CHECK( !(x23  << x3  ) );
+    BOOST_CHECK( !(x23  << x12 ) );
+    BOOST_CHECK( !(x23  << x13 ) );
+    BOOST_CHECK(  (x23  << x23 ) );
+    BOOST_CHECK(  (x23  << x123) );
+    BOOST_CHECK( !(x123 << x   ) );
+    BOOST_CHECK( !(x123 << x1  ) );
+    BOOST_CHECK( !(x123 << x2  ) );
+    BOOST_CHECK( !(x123 << x3  ) );
+    BOOST_CHECK( !(x123 << x12 ) );
+    BOOST_CHECK( !(x123 << x13 ) );
+    BOOST_CHECK( !(x123 << x23 ) );
+    BOOST_CHECK(  (x123 << x123) );
+
+    // check operator>>
+    BOOST_CHECK(  (x    >> x   ) );
+    BOOST_CHECK( !(x    >> x1  ) );
+    BOOST_CHECK( !(x    >> x2  ) );
+    BOOST_CHECK( !(x    >> x3  ) );
+    BOOST_CHECK( !(x    >> x12 ) );
+    BOOST_CHECK( !(x    >> x13 ) );
+    BOOST_CHECK( !(x    >> x23 ) );
+    BOOST_CHECK( !(x    >> x123) );
+    BOOST_CHECK(  (x1   >> x   ) );
+    BOOST_CHECK(  (x1   >> x1  ) );
+    BOOST_CHECK( !(x1   >> x2  ) );
+    BOOST_CHECK( !(x1   >> x3  ) );
+    BOOST_CHECK( !(x1   >> x12 ) );
+    BOOST_CHECK( !(x1   >> x13 ) );
+    BOOST_CHECK( !(x1   >> x23 ) );
+    BOOST_CHECK( !(x1   >> x123) );
+    BOOST_CHECK(  (x2   >> x   ) );
+    BOOST_CHECK( !(x2   >> x1  ) );
+    BOOST_CHECK(  (x2   >> x2  ) );
+    BOOST_CHECK( !(x2   >> x3  ) );
+    BOOST_CHECK( !(x2   >> x12 ) );
+    BOOST_CHECK( !(x2   >> x13 ) );
+    BOOST_CHECK( !(x2   >> x23 ) );
+    BOOST_CHECK( !(x2   >> x123) );
+    BOOST_CHECK(  (x3   >> x   ) );
+    BOOST_CHECK( !(x3   >> x1  ) );
+    BOOST_CHECK( !(x3   >> x2  ) );
+    BOOST_CHECK(  (x3   >> x3  ) );
+    BOOST_CHECK( !(x3   >> x12 ) );
+    BOOST_CHECK( !(x3   >> x13 ) );
+    BOOST_CHECK( !(x3   >> x23 ) );
+    BOOST_CHECK( !(x3   >> x123) );
+    BOOST_CHECK(  (x12  >> x   ) );
+    BOOST_CHECK(  (x12  >> x1  ) );
+    BOOST_CHECK(  (x12  >> x2  ) );
+    BOOST_CHECK( !(x12  >> x3  ) );
+    BOOST_CHECK(  (x12  >> x12 ) );
+    BOOST_CHECK( !(x12  >> x13 ) );
+    BOOST_CHECK( !(x12  >> x23 ) );
+    BOOST_CHECK( !(x12  >> x123) );
+    BOOST_CHECK(  (x13  >> x   ) );
+    BOOST_CHECK(  (x13  >> x1  ) );
+    BOOST_CHECK( !(x13  >> x2  ) );
+    BOOST_CHECK(  (x13  >> x3  ) );
+    BOOST_CHECK( !(x13  >> x12 ) );
+    BOOST_CHECK(  (x13  >> x13 ) );
+    BOOST_CHECK( !(x13  >> x23 ) );
+    BOOST_CHECK( !(x13  >> x123) );
+    BOOST_CHECK(  (x23  >> x   ) );
+    BOOST_CHECK( !(x23  >> x1  ) );
+    BOOST_CHECK(  (x23  >> x2  ) );
+    BOOST_CHECK(  (x23  >> x3  ) );
+    BOOST_CHECK( !(x23  >> x12 ) );
+    BOOST_CHECK( !(x23  >> x13 ) );
+    BOOST_CHECK(  (x23  >> x23 ) );
+    BOOST_CHECK( !(x23  >> x123) );
+    BOOST_CHECK(  (x123 >> x   ) );
+    BOOST_CHECK(  (x123 >> x1  ) );
+    BOOST_CHECK(  (x123 >> x2  ) );
+    BOOST_CHECK(  (x123 >> x3  ) );
+    BOOST_CHECK(  (x123 >> x12 ) );
+    BOOST_CHECK(  (x123 >> x13 ) );
+    BOOST_CHECK(  (x123 >> x23 ) );
+    BOOST_CHECK(  (x123 >> x123) );
+}
index d8c226c..6e362f8 100644 (file)
@@ -25,7 +25,7 @@ using namespace dai;
 
 
 BOOST_AUTO_TEST_CASE( ConstructorsTest ) {
-    // check constructors and states and labels accessors
+    // check constructors
     Var x;
     BOOST_CHECK_EQUAL( x.label(), 0 );
     BOOST_CHECK_EQUAL( x.states(), 0 );