Extended SWIG python interface (inspired by Kyle Ellrott): inference is possible...
[libdai.git] / include / dai / prob.h
index 90b457b..51dfe47 100644 (file)
@@ -1,11 +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) 2006-2009  Joris Mooij  [joris dot mooij at libdai dot org]
- *  Copyright (C) 2006-2007  Radboud University Nijmegen, The Netherlands
+ *  Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
  */
 
 
@@ -207,24 +204,6 @@ class TProb {
         container_type _p;
 
     public:
-        /// Enumerates different ways of normalizing a probability measure.
-        /**
-         *  - NORMPROB means that the sum of all entries should be 1;
-         *  - NORMLINF means that the maximum absolute value of all entries should be 1.
-         *  \deprecated Please use dai::ProbNormType instead.
-         */
-        typedef enum { NORMPROB, NORMLINF } NormType;
-        /// Enumerates different distance measures between probability measures.
-        /**
-         *  - DISTL1 is the \f$\ell_1\f$ distance (sum of absolute values of pointwise difference);
-         *  - DISTLINF is the \f$\ell_\infty\f$ distance (maximum absolute value of pointwise difference);
-         *  - DISTTV is the total variation distance (half of the \f$\ell_1\f$ distance);
-         *  - DISTKL is the Kullback-Leibler distance (\f$\sum_i p_i (\log p_i - \log q_i)\f$).
-         *  - DISTHEL is the Hellinger distance (\f$\frac{1}{2}\sum_i (\sqrt{p_i}-\sqrt{q_i})^2\f$).
-         *  \deprecated Please use dai::ProbDistType instead.
-         */
-        typedef enum { DISTL1, DISTLINF, DISTTV, DISTKL, DISTHEL } DistType;
-
     /// \name Constructors and destructors
     //@{
         /// Default constructor (constructs empty vector)
@@ -242,10 +221,9 @@ class TProb {
          *  \param end Points just beyond last instance to be added.
          *  \param sizeHint For efficiency, the number of entries can be speficied by \a sizeHint;
          *    the value 0 can be given if the size is unknown, but this will result in a performance penalty.
-         *  \deprecated In future libDAI versions, the \a sizeHint argument will no longer default to 0.
          */
         template <typename TIterator>
-        TProb( TIterator begin, TIterator end, size_t sizeHint=0 ) : _p() {
+        TProb( TIterator begin, TIterator end, size_t sizeHint ) : _p() {
             _p.reserve( sizeHint );
             _p.insert( _p.begin(), begin, end );
         }
@@ -329,32 +307,9 @@ class TProb {
         /// Returns a copy of the \a i 'th entry
         T operator[]( size_t i ) const { return get(i); }
 
-        /// Returns reference to the \a i 'th entry
-        /** \deprecated Please use dai::TProb::set() instead
-         */
-        T& operator[]( size_t i ) { return _p[i]; }
-
         /// Returns length of the vector (i.e., the number of entries)
         size_t size() const { return _p.size(); }
 
-        /// Accumulate over all values, similar to std::accumulate
-        /** The following calculation is done:
-         *  \code
-         *  T t = op2(init);
-         *  for( const_iterator it = begin(); it != end(); it++ )
-         *      t = op1( t, op2(*it) );
-         *  return t;
-         *  \endcode
-         *  \deprecated Please use dai::TProb::accumulateSum or dai::TProb::accumulateMax instead
-         */
-        template<typename binOp, typename unOp> T accumulate( T init, binOp op1, unOp op2 ) const {
-            T t = op2(init);
-            for( const_iterator it = begin(); it != end(); it++ )
-                t = op1( t, op2(*it) );
-            return t;
-        }
-
-
         /// Accumulate all values (similar to std::accumulate) by summing
         /** The following calculation is done:
          *  \code
@@ -414,7 +369,7 @@ class TProb {
         bool hasNaNs() const {
             bool foundnan = false;
             for( const_iterator x = _p.begin(); x != _p.end(); x++ )
-                if( isnan( *x ) ) {
+                if( dai::isnan( *x ) ) {
                     foundnan = true;
                     break;
                 }
@@ -465,6 +420,13 @@ class TProb {
                 return false;
             return p() == q.p();
         }
+
+        /// Formats a TProb as a string
+        std::string toString() const {
+            std::stringstream ss;
+            ss << *this;
+            return ss.str();
+        }
     //@}
 
     /// \name Unary transformations