Merge branch 'master' of git@git.tuebingen.mpg.de:libdai
[libdai.git] / include / dai / factor.h
index 5f13988..6f2e5b0 100644 (file)
@@ -1,4 +1,5 @@
 /*  Copyright (C) 2006-2008  Joris Mooij  [j dot mooij at science dot ru dot nl]
+    Copyright (C) 2002  Martijn Leisink  [martijn@mbfys.kun.nl]
     Radboud University Nijmegen, The Netherlands
     
     This file is part of libDAI.
@@ -35,16 +36,15 @@ namespace dai {
 
 template<typename T> class      TFactor;
 typedef TFactor<Real>           Factor;
-typedef TFactor<Complex>        CFactor;
 
 
 // predefine friends
 template<typename T> Real           dist( const TFactor<T> & x, const TFactor<T> & y, Prob::DistType dt );
-template<typename T> Complex        KL_dist( const TFactor<T> & p, const TFactor<T> & q );
+template<typename T> Real           KL_dist( const TFactor<T> & p, const TFactor<T> & q );
 template<typename T> std::ostream&  operator<< (std::ostream& os, const TFactor<T>& P);
 
         
-// T should be castable from and to double and to complex
+// T should be castable from and to double
 template <typename T> class TFactor {
     protected:
         VarSet      _vs;
@@ -55,18 +55,18 @@ template <typename T> class TFactor {
         TFactor () : _vs(), _p(1,1.0) {}
         
         // Construct Factor from VarSet
-        TFactor( const VarSet& ns ) : _vs(ns), _p(_vs.stateSpace()) {}
+        TFactor( const VarSet& ns ) : _vs(ns), _p(_vs.states()) {}
         
         // Construct Factor from VarSet and initial value
-        TFactor( const VarSet& ns, Real p ) : _vs(ns), _p(_vs.stateSpace(),p) {}
+        TFactor( const VarSet& ns, Real p ) : _vs(ns), _p(_vs.states(),p) {}
         
         // Construct Factor from VarSet and initial array
-        TFactor( const VarSet& ns, const Real* p ) : _vs(ns), _p(_vs.stateSpace(),p) {}
+        TFactor( const VarSet& ns, const Real* p ) : _vs(ns), _p(_vs.states(),p) {}
 
         // Construct Factor from VarSet and TProb<T>
         TFactor( const VarSet& ns, const TProb<T> p ) : _vs(ns), _p(p) {
 #ifdef DAI_DEBUG
-            assert( _vs.stateSpace() == _p.size() );
+            assert( _vs.states() == _p.size() );
 #endif
         }
         
@@ -88,9 +88,9 @@ template <typename T> class TFactor {
         const TProb<T> & p() const { return _p; }
         TProb<T> & p() { return _p; }
         const VarSet & vars() const { return _vs; }
-        size_t stateSpace() const { 
+        size_t states() const { 
 #ifdef DAI_DEBUG
-            assert( _vs.stateSpace() == _p.size() );
+            assert( _vs.states() == _p.size() );
 #endif
             return _p.size();
         }
@@ -205,13 +205,6 @@ template <typename T> class TFactor {
             return l0; 
         }
 
-        CFactor clog0() const {
-            CFactor l0; 
-            l0._vs = _vs; 
-            l0._p = _p.clog0(); 
-            return l0; 
-        }
-
         T normalize( typename Prob::NormType norm ) { return _p.normalize( norm ); }
         TFactor<T> normalized( typename Prob::NormType norm ) const { 
             TFactor<T> result;
@@ -227,9 +220,9 @@ template <typename T> class TFactor {
             Factor result( nsrem, 0.0 );
             
             // OPTIMIZE ME
-            Index i_ns (ns, _vs);
-            Index i_nsrem (nsrem, _vs);
-            for( size_t i = 0; i < stateSpace(); i++, ++i_ns, ++i_nsrem )
+            IndexFor i_ns (ns, _vs);
+            IndexFor i_nsrem (nsrem, _vs);
+            for( size_t i = 0; i < states(); i++, ++i_ns, ++i_nsrem )
                 if( (size_t)i_ns == ns_state )
                     result._p[i_nsrem] = _p[i];
 
@@ -245,8 +238,8 @@ template <typename T> class TFactor {
         bool hasNegatives() const { return _p.hasNegatives(); }
         T totalSum() const { return _p.totalSum(); }
         T maxAbs() const { return _p.maxAbs(); }
-        T max() const { return _p.max(); }
-        Complex entropy() const { return _p.entropy(); }
+        T maxVal() const { return _p.maxVal(); }
+        Real entropy() const { return _p.entropy(); }
         T strength( const Var &i, const Var &j ) const;
 
         friend Real dist( const TFactor<T> & x, const TFactor<T> & y, Prob::DistType dt ) {
@@ -259,7 +252,7 @@ template <typename T> class TFactor {
                 return dist( x._p, y._p, dt );
             }
         }
-        friend Complex KL_dist <> (const TFactor<T> & p, const TFactor<T> & q);
+        friend Real KL_dist <> (const TFactor<T> & p, const TFactor<T> & q);
         template<class U> friend std::ostream& operator<< (std::ostream& os, const TFactor<U>& P);
 };
 
@@ -271,7 +264,7 @@ template<typename T> TFactor<T> TFactor<T>::part_sum(const VarSet & ns) const {
 
     TFactor<T> res( ns, 0.0 );
 
-    Index i_res( ns, _vs );
+    IndexFor i_res( ns, _vs );
     for( size_t i = 0; i < _p.size(); i++, ++i_res )
         res._p[i_res] += _p[i];
 
@@ -291,8 +284,8 @@ template<typename T> std::ostream& operator<< (std::ostream& os, const TFactor<T
 template<typename T> TFactor<T> TFactor<T>::operator* (const TFactor<T>& Q) const {
     TFactor<T> prod( _vs | Q._vs, 0.0 );
 
-    Index i1(_vs, prod._vs);
-    Index i2(Q._vs, prod._vs);
+    IndexFor i1(_vs, prod._vs);
+    IndexFor i2(Q._vs, prod._vs);
 
     for( size_t i = 0; i < prod._p.size(); i++, ++i1, ++i2 )
         prod._p[i] += _p[i1] * Q._p[i2];
@@ -301,7 +294,7 @@ template<typename T> TFactor<T> TFactor<T>::operator* (const TFactor<T>& Q) cons
 }
 
 
-template<typename T> Complex KL_dist(const TFactor<T> & P, const TFactor<T> & Q) {
+template<typename T> Real KL_dist(const TFactor<T> & P, const TFactor<T> & Q) {
     if( P._vs.empty() || Q._vs.empty() )
         return -1;
     else {
@@ -316,8 +309,8 @@ template<typename T> Complex KL_dist(const TFactor<T> & P, const TFactor<T> & Q)
 // calculate N(psi, i, j)
 template<typename T> T TFactor<T>::strength( const Var &i, const Var &j ) const {
 #ifdef DAI_DEBUG
-    assert( _vs && i );
-    assert( _vs && j );
+    assert( _vs.contains( i ) );
+    assert( _vs.contains( j ) );
     assert( i != j );
 #endif
     VarSet ij = i | j;
@@ -334,8 +327,8 @@ template<typename T> T TFactor<T>::strength( const Var &i, const Var &j ) const
                                 bs = i.states();
                             else
                                 as = j.states();
-                            T f1 = slice( ij, alpha1 * as + beta1 * bs ).p().divide( slice( ij, alpha2 * as + beta1 * bs ).p() ).max();
-                            T f2 = slice( ij, alpha2 * as + beta2 * bs ).p().divide( slice( ij, alpha1 * as + beta2 * bs ).p() ).max();
+                            T f1 = slice( ij, alpha1 * as + beta1 * bs ).p().divide( slice( ij, alpha2 * as + beta1 * bs ).p() ).maxVal();
+                            T f2 = slice( ij, alpha2 * as + beta2 * bs ).p().divide( slice( ij, alpha1 * as + beta2 * bs ).p() ).maxVal();
                             T f = f1 * f2;
                             if( f > max )
                                 max = f;