Removed obsolete/deprecated stuff
authorJoris Mooij <joris.mooij@tuebingen.mpg.de>
Mon, 16 Nov 2009 20:09:46 +0000 (21:09 +0100)
committerJoris Mooij <joris.mooij@tuebingen.mpg.de>
Mon, 16 Nov 2009 20:09:46 +0000 (21:09 +0100)
16 files changed:
ChangeLog
OBSOLETE [deleted file]
include/dai/bipgraph.h
include/dai/daialg.h
include/dai/factor.h
include/dai/factorgraph.h
include/dai/index.h
include/dai/jtree.h
include/dai/lc.h
include/dai/prob.h
include/dai/regiongraph.h
include/dai/util.h
include/dai/varset.h
include/dai/weightedgraph.h
src/lc.cpp
utils/fginfo.cpp

index 8cf1e6d..705c736 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,6 @@
+* Removed obsolete/deprecated stuff
+
+
 libDAI-0.2.3 (2009-11-16)
 -------------------------
 
 libDAI-0.2.3 (2009-11-16)
 -------------------------
 
diff --git a/OBSOLETE b/OBSOLETE
deleted file mode 100644 (file)
index 3f337f3..0000000
--- a/OBSOLETE
+++ /dev/null
@@ -1,50 +0,0 @@
-The following functions are obsolete and will be removed in the next major release (0.3.0):
-
-TFactor<T>& TFactor<T>::makeZero( T epsilon );
-TFactor<T>& TFactor<T>::makePositive( T epsilon );
-TProb<T>& TProb<T>::makePositive( T epsilon );
-TProb<T>& TProb<T>::makeZero( T epsilon );
-virtual void InfAlg::clamp( const Var &v, size_t x, bool backup = false ) = 0;
-void DAIAlg<GRM>::clamp( const Var &v, size_t x, bool backup = false );
-virtual void FactorGraph::clamp( const Var &v, size_t x, bool backup = false );
-FactorGraph clamped( const Var &v, size_t x ) const;
-size_t FactorGraph::VV2E(size_t n1, size_t n2) const;
-const Edge& FactorGraph::edge(size_t e) const;
-void FactorGraph::indexEdges();
-size_t FactorGraph::nr_edges() const;
-const std::vector<Edge>& FactorGraph::edges() const;
-bool BipartiteGraph::_edge_indexed;
-std::vector<Edge> BipartiteGraph::_edges;
-hash_map<Edge,size_t> BipartiteGraph::_vv2e;
-void BipartiteGraph::indexEdges();
-const Edge& BipartiteGraph::edge(size_t e) const;
-const std::vector<Edge>& BipartiteGraph::edges() const;
-size_t BipartiteGraph::VV2E(size_t n1, size_t n2) const;
-size_t BipartiteGraph::nr_edges() const;
-size_t Permute::convert_linear_index( size_t li ) const;
-TProb<T> TProb<T>::sgn() const;
-bool RegionGraph::Check_Counting_Numbers();
-void RegionGraph::Calc_Counting_Numbers();
-std::vector<Factor> calcPairBeliefsNew( const InfAlg& obj, const VarSet& vs, bool reInit );
-Factor calcMarginal2ndO( const InfAlg& obj, const VarSet& vs, bool reInit );
-class Diffs;
-std::pair<size_t,size_t> Treewidth( const FactorGraph & fg );
-typedef UEdgeVec;
-typedef DEdgeVec;
-DEdgeVec GrowRootedTree( const Graph &T, size_t Root );
-const Factor& LC::belief(size_t);
-size_t VarSet::calcState( const std::map<Var, size_t> &state ) const;
-std::map<Var, size_t> VarSet::calcStates( size_t linearState ) const;
-TProb<T> TProb<T>::log0() const;
-const TProb<T>& takeLog0();
-bool hasNonPositives() const;
-TFactor<T> log0() const;
-TFactor<T>& divide (const TFactor<T>& g);
-TFactor<T> divided_by (const TFactor<T>& g) const;
-TFactor<T> partSum(const VarSet &vars) const;
-T TProb<T>::minVal() const;
-T TProb<T>::maxVal() const;
-T TProb<T>::totalSum() const;
-T TFactor<T>::minVal() const;
-T TFactor<T>::maxVal() const;
-T TFactor<T>::totalSum() const;
index 25f20b2..dfb0c50 100644 (file)
@@ -139,28 +139,11 @@ class BipartiteGraph {
             std::vector<size_t> ind2;
         };
 
             std::vector<size_t> ind2;
         };
 
-    // OBSOLETE
-    /// \name Backwards compatibility layer (to be removed soon)
-        //@{
-        /// Enable backwards compatibility layer?
-        /** \deprecated Please use the BipartiteGraph::Neighbor interface instead
-         */
-        bool _edge_indexed;
-        /// Call indexEdges() first to initialize these members
-        /** \deprecated Please use the BipartiteGraph::Neighbor interface instead
-         */
-        std::vector<Edge> _edges;
-        /// Call indexEdges() first to initialize these members
-        /** \deprecated Please use the BipartiteGraph::Neighbor interface instead
-         */
-        hash_map<Edge,size_t> _vv2e;
-    //@}
-
     public:
     /// \name Constructors and destructors
     //@{
         /// Default constructor (creates an empty bipartite graph)
     public:
     /// \name Constructors and destructors
     //@{
         /// Default constructor (creates an empty bipartite graph)
-        BipartiteGraph() : _nb1(), _nb2(), _edge_indexed(false) {}
+        BipartiteGraph() : _nb1(), _nb2() {}
 
         /// Constructs BipartiteGraph from a range of edges.
         /** \tparam EdgeInputIterator Iterator that iterates over instances of BipartiteGraph::Edge.
 
         /// Constructs BipartiteGraph from a range of edges.
         /** \tparam EdgeInputIterator Iterator that iterates over instances of BipartiteGraph::Edge.
@@ -170,7 +153,7 @@ class BipartiteGraph {
          *  \param end Points just beyond the last edge.
          */
         template<typename EdgeInputIterator>
          *  \param end Points just beyond the last edge.
          */
         template<typename EdgeInputIterator>
-        BipartiteGraph( size_t nr1, size_t nr2, EdgeInputIterator begin, EdgeInputIterator end ) : _nb1( nr1 ), _nb2( nr2 ), _edge_indexed(false) {
+        BipartiteGraph( size_t nr1, size_t nr2, EdgeInputIterator begin, EdgeInputIterator end ) : _nb1( nr1 ), _nb2( nr2 ) {
             construct( nr1, nr2, begin, end );
         }
     //@}
             construct( nr1, nr2, begin, end );
         }
     //@}
@@ -350,69 +333,6 @@ class BipartiteGraph {
         /// Writes this BipartiteGraph to an output stream in GraphViz .dot syntax
         void printDot( std::ostream& os ) const;
     //@}
         /// Writes this BipartiteGraph to an output stream in GraphViz .dot syntax
         void printDot( std::ostream& os ) const;
     //@}
-
-        // OBSOLETE
-    /// \name Backwards compatibility layer (to be removed soon)
-    //@{
-        /// Prepare backwards compatibility layer for indexed edges
-        /** \deprecated Please use the BipartiteGraph::Neighbor interface instead
-         */
-        void indexEdges() {
-            std::cerr << "Warning: this BipartiteGraph edge interface is obsolete!" << std::endl;
-            _edges.clear();
-            _vv2e.clear();
-            size_t i=0;
-            foreach(const Neighbors &nb1s, _nb1) {
-                foreach(const Neighbor &n2, nb1s) {
-                    Edge e(i, n2.node);
-                    _edges.push_back(e);
-                }
-                i++;
-            }
-            sort(_edges.begin(), _edges.end()); // unnecessary?
-
-            i=0;
-            foreach(const Edge& e, _edges) {
-                _vv2e[e] = i++;
-            }
-
-            _edge_indexed = true;
-        }
-
-        /// Returns edge with index \a e
-        /** \deprecated Please use the BipartiteGraph::Neighbor interface instead
-         */
-        const Edge& edge(size_t e) const {
-            DAI_ASSERT(_edge_indexed);
-            return _edges[e];
-        }
-
-        /// Returns all edges
-        /** \deprecated Please use the BipartiteGraph::Neighbor interface instead
-         */
-        const std::vector<Edge>& edges() const {
-            return _edges;
-        }
-
-        /// Converts a pair of node indices to an edge index
-        /** \deprecated Please use the BipartiteGraph::Neighbor interface instead
-         */
-        size_t VV2E(size_t n1, size_t n2) const {
-            DAI_ASSERT(_edge_indexed);
-            Edge e(n1,n2);
-            hash_map<Edge,size_t>::const_iterator i = _vv2e.find(e);
-            DAI_ASSERT(i != _vv2e.end());
-            return i->second;
-        }
-
-        /// Returns number of edges
-        /** \deprecated Please use the BipartiteGraph::Neighbor interface instead
-         */
-        size_t nr_edges() const {
-            DAI_ASSERT(_edge_indexed);
-            return _edges.size();
-        }
-    //@}
 };
 
 
 };
 
 
index d3cf52b..9a128a8 100644 (file)
@@ -128,12 +128,6 @@ class InfAlg {
          */
         virtual void clamp( size_t i, size_t x, bool backup = false ) = 0;
 
          */
         virtual void clamp( size_t i, size_t x, bool backup = false ) = 0;
 
-        // OBSOLETE
-        /// Clamp variable \a v to value \a x (i.e. multiply with a Kronecker delta \f$\delta_{v, x}\f$)
-        /** \deprecated Please use dai::InfAlg::clamp(size_t,size_t,bool) instead
-         */
-        virtual void clamp( const Var &v, size_t x, bool backup = false ) = 0;
-
         /// Sets all factors interacting with variable with index \a i to one.
         /** If \a backup == \c true, make a backup of all factors that are changed.
          */
         /// Sets all factors interacting with variable with index \a i to one.
         /** If \a backup == \c true, make a backup of all factors that are changed.
          */
@@ -211,15 +205,6 @@ class DAIAlg : public InfAlg, public GRM {
          */
         void clamp( size_t i, size_t x, bool backup = false ) { GRM::clamp( i, x, backup ); }
 
          */
         void clamp( size_t i, size_t x, bool backup = false ) { GRM::clamp( i, x, backup ); }
 
-        // OBSOLETE
-        /// Clamp variable \a v to value \a x (i.e. multiply with a Kronecker delta \f$\delta_{v, x}\f$)
-        /** \deprecated Please use dai::DAIAlg<>::clamp(size_t,size_t,bool) instead
-         */
-        void clamp( const Var &v, size_t x, bool backup = false ) {
-            GRM::clamp( v, x, backup );
-            std::cerr << "Warning: this DAIAlg<...>::clamp(const Var&,...) interface is obsolete!" << std::endl;
-        }
-
         /// Sets all factors interacting with variable with index \a i to one.
         /** If \a backup == \c true, make a backup of all factors that are changed.
          */
         /// Sets all factors interacting with variable with index \a i to one.
         /** If \a backup == \c true, make a backup of all factors that are changed.
          */
@@ -271,18 +256,6 @@ Factor calcMarginal( const InfAlg& obj, const VarSet& vs, bool reInit );
  */
 std::vector<Factor> calcPairBeliefs( const InfAlg& obj, const VarSet& vs, bool reInit, bool accurate=false );
 
  */
 std::vector<Factor> calcPairBeliefs( const InfAlg& obj, const VarSet& vs, bool reInit, bool accurate=false );
 
-// OBSOLETE
-/// Calculates beliefs for all pairs of variables in \a vs using inference algorithm \a obj.
-/** \deprecated Please use dai::calcPairBeliefs() instead with \a accurate == \c true
- */
-std::vector<Factor> calcPairBeliefsNew( const InfAlg& obj, const VarSet& vs, bool reInit );
-
-// OBSOLETE
-/// Calculates marginal probability distribution for \a vs up to second order interactions using inference algorithm \a obj
-/** \deprecated Functionality is not widely used
- */
-Factor calcMarginal2ndO( const InfAlg& obj, const VarSet& vs, bool reInit );
-
 
 } // end of namespace dai
 
 
 } // end of namespace dai
 
index b92a366..d8132cc 100644 (file)
@@ -137,30 +137,12 @@ template <typename T> class TFactor {
         /// Returns maximum of all values
         T max() const { return _p.max(); }
 
         /// Returns maximum of all values
         T max() const { return _p.max(); }
 
-        // OBSOLETE
-        /// Returns maximum of all values
-        /** \deprecated Please use max() instead
-         */
-        T maxVal() const { return max(); }
-
         /// Returns minimum of all values
         T min() const { return _p.min(); }
 
         /// Returns minimum of all values
         T min() const { return _p.min(); }
 
-        // OBSOLETE
-        /// Returns minimum of all values
-        /** \deprecated Please use min() instead
-         */
-        T minVal() const { return min(); }
-
         /// Returns sum of all values
         T sum() const { return _p.sum(); }
 
         /// Returns sum of all values
         T sum() const { return _p.sum(); }
 
-        // OBSOLETE
-        /// Returns sum of all values
-        /** \deprecated Please use sum() instead
-         */
-        T totalSum() const { return sum(); }
-
         /// Returns maximum absolute value of all values
         T maxAbs() const { return _p.maxAbs(); }
 
         /// Returns maximum absolute value of all values
         T maxAbs() const { return _p.maxAbs(); }
 
@@ -205,12 +187,6 @@ template <typename T> class TFactor {
             return x;
         }
         
             return x;
         }
         
-        // OBSOLETE
-        /// Returns pointwise logarithm (or 0 if argument is 0)
-        /** \deprecated Please use log() instead with \a zero == \c true
-         */
-        TFactor<T> log0() const { return log(true); }
-
         /// Returns pointwise inverse
         /** If \a zero == \c true, uses <tt>1/0==0</tt>; otherwise, <tt>1/0==Inf</tt>.
          */
         /// Returns pointwise inverse
         /** If \a zero == \c true, uses <tt>1/0==0</tt>; otherwise, <tt>1/0==Inf</tt>.
          */
@@ -247,18 +223,6 @@ template <typename T> class TFactor {
         /// Sets all values to \a x
         TFactor<T> & fill (T x) { _p.fill( x ); return *this; }
 
         /// Sets all values to \a x
         TFactor<T> & fill (T x) { _p.fill( x ); return *this; }
 
-        // OBSOLETE
-        /// Sets values that are smaller (in absolute value) than \a epsilon to 0
-        /** \deprecated Functionality was not widely used
-         */
-        TFactor<T>& makeZero( T epsilon ) { _p.makeZero( epsilon ); return *this; }
-
-        // OBSOLETE
-        /// Sets values that are smaller than \a epsilon to \a epsilon
-        /** \deprecated Functionality was not widely used
-         */
-        TFactor<T>& makePositive( T epsilon ) { _p.makePositive( epsilon ); return *this; }
-
         /// Adds scalar \a x to each value
         TFactor<T>& operator+= (T x) { _p += x; return *this; }
 
         /// Adds scalar \a x to each value
         TFactor<T>& operator+= (T x) { _p += x; return *this; }
 
@@ -375,12 +339,6 @@ template <typename T> class TFactor {
          *  \f[\frac{f}{g} : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto \frac{f(x_L)}{g(x_M)}.\f]
          */
         TFactor<T>& operator/= (const TFactor<T>& g) { return binaryOp( g, fo_divides0<T>() ); }
          *  \f[\frac{f}{g} : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto \frac{f(x_L)}{g(x_M)}.\f]
          */
         TFactor<T>& operator/= (const TFactor<T>& g) { return binaryOp( g, fo_divides0<T>() ); }
-
-        // OBSOLETE
-        /// Divides \c *this by \a g (where division by zero yields zero)
-        /** \deprecated Please use operator/= instead
-          */
-        TFactor<T>& divide (const TFactor<T>& g) { return (*this /= g); }
     //@}
 
     /// \name Transformations with other factors
     //@}
 
     /// \name Transformations with other factors
@@ -447,12 +405,6 @@ template <typename T> class TFactor {
         TFactor<T> operator/ (const TFactor<T>& g) const {
             return binaryTr(g,fo_divides0<T>());
         }
         TFactor<T> operator/ (const TFactor<T>& g) const {
             return binaryTr(g,fo_divides0<T>());
         }
-
-        // OBSOLETE
-        /// Returns quotient of \c *this by \a f (where division by zero yields zero)
-        /** \deprecated Please use operator/ instead
-         */
-        TFactor<T> divided_by (const TFactor<T>& g) const { return (*this / g); }
     //@}
 
     /// \name Miscellaneous operations
     //@}
 
     /// \name Miscellaneous operations
@@ -488,12 +440,6 @@ template <typename T> class TFactor {
         /// Returns marginal on \a vars, obtained by summing out all variables except those in \a vars, and normalizing the result if \a normed == \c true
         TFactor<T> marginal(const VarSet &vars, bool normed=true) const;
 
         /// Returns marginal on \a vars, obtained by summing out all variables except those in \a vars, and normalizing the result if \a normed == \c true
         TFactor<T> marginal(const VarSet &vars, bool normed=true) const;
 
-        // OBSOLETE
-        /// Returns partial sum on \a vars, obtained by summing out all variables except those in \a vars
-        /** \deprecated Please use marginal() instead with \a normed == \c false
-         */
-        TFactor<T> partSum(const VarSet &vars) const { return marginal(vars,false); }
-
         /// Returns max-marginal on \a vars, obtained by maximizing all variables except those in \a vars, and normalizing the result if \a normed == \c true
         TFactor<T> maxMarginal(const VarSet &vars, bool normed=true) const;
     //@}
         /// Returns max-marginal on \a vars, obtained by maximizing all variables except those in \a vars, and normalizing the result if \a normed == \c true
         TFactor<T> maxMarginal(const VarSet &vars, bool normed=true) const;
     //@}
index b0a3e32..36bede3 100644 (file)
@@ -282,15 +282,6 @@ class FactorGraph {
          *  and keeps the current one constant, contrary to clamp()
          */
         FactorGraph clamped( size_t i, size_t x ) const;
          *  and keeps the current one constant, contrary to clamp()
          */
         FactorGraph clamped( size_t i, size_t x ) const;
-
-        // OBSOLETE
-        /// Clamp variable \a v to value \a x (i.e. multiply with a Kronecker delta \f$\delta_{v,x}\f$);
-        /** \deprecated Please use dai::FactorGraph::clamped(size_t,size_t) instead
-         */
-        FactorGraph clamped( const Var &v, size_t x ) const {
-            std::cerr << "Warning: this FactorGraph::clamped(const Var&,...) interface is obsolete!" << std::endl;
-            return clamped( findVar(v), x );
-        }
     //@}
 
     /// \name Operations
     //@}
 
     /// \name Operations
@@ -300,15 +291,6 @@ class FactorGraph {
          */
         virtual void clamp( size_t i, size_t x, bool backup = false );
 
          */
         virtual void clamp( size_t i, size_t x, bool backup = false );
 
-        // OBSOLETE
-        /// Clamp variable \a v to value \a x (i.e. multiply with a Kronecker delta \f$\delta_{v, x}\f$)
-        /** \deprecated Please use dai::FactorGraph::clamp(size_t,size_t,bool) instead
-         */
-        virtual void clamp( const Var &v, size_t x, bool backup = false ) {
-            std::cerr << "Warning: this FactorGraph::clamp(const Var&,...) interface is obsolete!" << std::endl;
-            clamp( findVar(v), x, backup );
-        }
-
         /// Clamp a variable in a factor graph to have one out of a list of values
         /** If \a backup == \c true, make a backup of all factors that are changed
          */
         /// Clamp a variable in a factor graph to have one out of a list of values
         /** If \a backup == \c true, make a backup of all factors that are changed
          */
@@ -355,31 +337,6 @@ class FactorGraph {
         void printDot( std::ostream& os ) const;
     //@}
 
         void printDot( std::ostream& os ) const;
     //@}
 
-        // OBSOLETE
-    /// \name Backwards compatibility layer (to be removed soon)
-    //@{
-        /// Prepare backwards compatibility layer for indexed edges
-        /** \deprecated Please use FactorGraph::Neighbor interface instead
-         */
-        void indexEdges() { G.indexEdges(); }
-        /// Returns edge with index \a e
-        /** \deprecated Please use FactorGraph::Neighbor interface instead
-         */
-        const Edge& edge(size_t e) const { return G.edge(e); }
-        /// Returns all edges
-        /** \deprecated Please use FactorGraph::Neighbor interface instead
-         */
-        const std::vector<Edge>& edges() const { return G.edges(); }
-        /// Converts a pair of node indices to an edge index
-        /** \deprecated Please use FactorGraph::Neighbor interface instead
-         */
-        size_t VV2E(size_t n1, size_t n2) const { return G.VV2E(n1,n2); }
-        /// Returns number of edges
-        /** \deprecated Please use FactorGraph::Neighbor interface instead
-         */
-        size_t nr_edges() const { return G.nr_edges(); }
-    //@}
-
     private:
         /// Part of constructors (creates edges, neighbors and adjacency matrix)
         void constructGraph( size_t nrEdges );
     private:
         /// Part of constructors (creates edges, neighbors and adjacency matrix)
         void constructGraph( size_t nrEdges );
index cf5d1c4..78a7678 100644 (file)
@@ -96,22 +96,11 @@ class IndexFor {
             return( *this );
         }
 
             return( *this );
         }
 
-        // OBSOLETE
-        /// Conversion to \c long: returns linear index of the current state of indexVars
-        /** \deprecated Will be replaced by an operator size_t()
-         */
-        operator long () const {
-            return( _index );
-        }
-
-        // NEW VERSION
-        /*
         /// Conversion to \c size_t: returns linear index of the current state of indexVars
         operator size_t() const {
             DAI_ASSERT( valid() );
             return( _index );
         }
         /// Conversion to \c size_t: returns linear index of the current state of indexVars
         operator size_t() const {
             DAI_ASSERT( valid() );
             return( _index );
         }
-        */
 
         /// Increments the current state of \a forVars (prefix)
         IndexFor& operator++ () {
 
         /// Increments the current state of \a forVars (prefix)
         IndexFor& operator++ () {
@@ -206,12 +195,6 @@ class Permute {
             return sigma_li;
         }
 
             return sigma_li;
         }
 
-        // OBSOLETE
-        /// Calculates a permuted linear index
-        /** \deprecated Renamed into dai::Permute::convertLinearIndex()
-         */
-        size_t convert_linear_index( size_t li ) const { return convertLinearIndex(li); }
-
         /// Returns const reference to the permutation
         const std::vector<size_t>& sigma() const { return _sigma; }
 
         /// Returns const reference to the permutation
         const std::vector<size_t>& sigma() const { return _sigma; }
 
index 6a0e55c..35bbab0 100644 (file)
@@ -183,12 +183,6 @@ class JTree : public DAIAlgRG {
 std::pair<size_t,size_t> boundTreewidth( const FactorGraph & fg );
 
 
 std::pair<size_t,size_t> boundTreewidth( const FactorGraph & fg );
 
 
-/// Calculates upper bound to the treewidth of a FactorGraph, using the MinFill heuristic
-/** \deprecated Renamed into boundTreewidth()
- */
-std::pair<size_t,size_t> treewidth( const FactorGraph & fg );
-
-
 } // end of namespace dai
 
 
 } // end of namespace dai
 
 
index 1c817c9..ec8842d 100644 (file)
@@ -135,10 +135,6 @@ class LC : public DAIAlgFG {
         Factor NewPancake (size_t i, size_t _I, bool & hasNaNs);
         /// Calculates the belief of variable \a i
         void CalcBelief (size_t i);
         Factor NewPancake (size_t i, size_t _I, bool & hasNaNs);
         /// Calculates the belief of variable \a i
         void CalcBelief (size_t i);
-        /// Returns the belief of variable \a i
-        /** \deprecated Please use dai::LC::beliefV() instead
-         */
-        const Factor &belief (size_t i) const { return _beliefs[i]; };
         /// Returns the belief of the Markov blanket of variable \a i (including the variable itself)
         const Factor &pancake (size_t i) const { return _pancakes[i]; };
         /// Returns the approximate cavity distribution for variable \a i
         /// Returns the belief of the Markov blanket of variable \a i (including the variable itself)
         const Factor &pancake (size_t i) const { return _pancakes[i]; };
         /// Returns the approximate cavity distribution for variable \a i
index afbca04..dd63308 100644 (file)
@@ -307,30 +307,12 @@ template <typename T> class TProb {
         /// Returns maximum value of all entries
         T max() const { return accumulate( (T)(-INFINITY), fo_max<T>(), fo_id<T>() ); }
 
         /// Returns maximum value of all entries
         T max() const { return accumulate( (T)(-INFINITY), fo_max<T>(), fo_id<T>() ); }
 
-        // OBSOLETE
-        /// Returns maximum value of all entries
-        /** \deprecated Please use max() instead
-         */
-        T maxVal() const { return max(); }
-
         /// Returns minimum value of all entries
         T min() const { return accumulate( (T)INFINITY, fo_min<T>(), fo_id<T>() ); }
 
         /// Returns minimum value of all entries
         T min() const { return accumulate( (T)INFINITY, fo_min<T>(), fo_id<T>() ); }
 
-        // OBSOLETE
-        /// Returns minimum value of all entries
-        /** \deprecated Please use min() instead
-         */
-        T minVal() const { return min(); }
-
         /// Returns sum of all entries
         T sum() const { return accumulate( (T)0, std::plus<T>(), fo_id<T>() ); }
 
         /// Returns sum of all entries
         T sum() const { return accumulate( (T)0, std::plus<T>(), fo_id<T>() ); }
 
-        // OBSOLETE
-        /// Returns sum of all entries
-        /** \deprecated Please use sum() instead
-         */
-        T totalSum() const { return sum(); }
-
         /// Return sum of absolute value of all entries
         T sumAbs() const { return accumulate( (T)0, std::plus<T>(), fo_abs<T>() ); }
 
         /// Return sum of absolute value of all entries
         T sumAbs() const { return accumulate( (T)0, std::plus<T>(), fo_abs<T>() ); }
 
@@ -353,20 +335,6 @@ template <typename T> class TProb {
             return (std::find_if( _p.begin(), _p.end(), std::bind2nd( std::less<T>(), (T)0 ) ) != _p.end());
         }
 
             return (std::find_if( _p.begin(), _p.end(), std::bind2nd( std::less<T>(), (T)0 ) ) != _p.end());
         }
 
-        // OBSOLETE
-        /// Returns \c true if one or more entries are non-positive
-        /** \deprecated Functionality was not widely used
-         */
-        bool hasNonPositives() const {
-            bool found = false;
-            for( typename std::vector<T>::const_iterator x = _p.begin(); x != _p.end(); x++ )
-                if( *x <= (T)0 ) {
-                    found = true;
-                    break;
-                }
-            return found;
-        }
-
         /// Returns a pair consisting of the index of the maximum value and the maximum value itself
         std::pair<size_t,T> argmax() const {
             T max = _p[0];
         /// Returns a pair consisting of the index of the maximum value and the maximum value itself
         std::pair<size_t,T> argmax() const {
             T max = _p[0];
@@ -411,24 +379,6 @@ template <typename T> class TProb {
             return r;
         }
 
             return r;
         }
 
-        // OBSOLETE
-        /// Returns pointwise signum
-        /** \deprecated Functionality was not widely used
-         */
-        TProb<T> sgn() const {
-            TProb<T> x;
-            x._p.reserve( size() );
-            for( size_t i = 0; i < size(); i++ ) {
-                T s = 0;
-                if( _p[i] > 0 )
-                    s = 1;
-                else if( _p[i] < 0 )
-                    s = -1;
-                x._p.push_back( s );
-            }
-            return x;
-        }
-
         /// Returns pointwise absolute value
         TProb<T> abs() const { return pwUnaryTr( fo_abs<T>() ); }
 
         /// Returns pointwise absolute value
         TProb<T> abs() const { return pwUnaryTr( fo_abs<T>() ); }
 
@@ -445,12 +395,6 @@ template <typename T> class TProb {
                 return pwUnaryTr( fo_log<T>() );
         }
         
                 return pwUnaryTr( fo_log<T>() );
         }
         
-        // OBSOLETE
-        /// Returns pointwise logarithm (or zero if argument is zero)
-        /** \deprecated Please use log() instead with \a zero == \c true
-         */
-        TProb<T> log0() const { return log(true); }
-
         /// Returns pointwise inverse
         /** If \a zero == \c true, uses <tt>1/0==0</tt>; otherwise, <tt>1/0==Inf</tt>.
          */
         /// Returns pointwise inverse
         /** If \a zero == \c true, uses <tt>1/0==0</tt>; otherwise, <tt>1/0==Inf</tt>.
          */
@@ -514,12 +458,6 @@ template <typename T> class TProb {
                 return pwUnaryOp( fo_log<T>() );
         }
 
                 return pwUnaryOp( fo_log<T>() );
         }
 
-        // OBSOLETE
-        /// Applies logarithm pointwise
-        /** \deprecated Please use takeLog() instead, with \a zero == \c true
-         */
-        const TProb<T>& takeLog0() { return takeLog(true); }
-
         /// Normalizes vector using the specified norm
         /** \throw NOT_NORMALIZABLE if the norm is zero
          */
         /// Normalizes vector using the specified norm
         /** \throw NOT_NORMALIZABLE if the norm is zero
          */
@@ -545,28 +483,6 @@ template <typename T> class TProb {
             return *this;
         }
 
             return *this;
         }
 
-        // OBSOLETE
-        /// Sets entries that are smaller (in absolute value) than \a epsilon to 0
-        /** \deprecated Functionality was not widely used
-         */
-        TProb<T>& makeZero( T epsilon ) {
-            for( size_t i = 0; i < size(); i++ )
-                if( (_p[i] < epsilon) && (_p[i] > -epsilon) )
-                    _p[i] = 0;
-            return *this;
-        }
-        
-        // OBSOLETE
-        /// Sets entries that are smaller than \a epsilon to \a epsilon
-        /** \deprecated Functionality was not widely used
-         */
-        TProb<T>& makePositive( T epsilon ) {
-            for( size_t i = 0; i < size(); i++ )
-                if( (0 < _p[i]) && (_p[i] < epsilon) )
-                    _p[i] = epsilon;
-            return *this;
-        }
-
         /// Adds scalar \a x to each entry
         TProb<T>& operator+= (T x) {
             if( x != 0 )
         /// Adds scalar \a x to each entry
         TProb<T>& operator+= (T x) {
             if( x != 0 )
index bb5224f..d1fd888 100644 (file)
@@ -160,12 +160,6 @@ class RegionGraph : public FactorGraph {
          *  that contain the variable equals one.
          */
         bool checkCountingNumbers() const;
          *  that contain the variable equals one.
          */
         bool checkCountingNumbers() const;
-
-        // OBSOLETE
-        /// Check whether the counting numbers are valid
-        /** \deprecated Renamed into dai::RegionGraph::checkCountingNumbers()
-         */
-        bool Check_Counting_Numbers() { return checkCountingNumbers(); }
     //@}
 
     /// \name Operations
     //@}
 
     /// \name Operations
@@ -208,12 +202,6 @@ class RegionGraph : public FactorGraph {
          *  region if its variables are a subset of the variables of its parent region).
          */
         void calcCountingNumbers();
          *  region if its variables are a subset of the variables of its parent region).
          */
         void calcCountingNumbers();
-
-        // OBSOLETE
-        /// Calculates counting numbers of inner regions based upon counting numbers of outer regions
-        /** \deprecated Renamed into dai::RegionGraph::calcCountingNumbers()
-         */
-        void Calc_Counting_Numbers() { calcCountingNumbers(); }
     //@}
 
     /// \name Input/output
     //@}
 
     /// \name Input/output
index a824e82..0fbaae6 100644 (file)
@@ -194,63 +194,6 @@ std::vector<T> concat( const std::vector<T>& u, const std::vector<T>& v ) {
 /// Split a string into tokens delimited by one of the characters in \a delim
 void tokenizeString( const std::string& s, std::vector<std::string>& outTokens, const std::string& delim="\t\n" );
 
 /// Split a string into tokens delimited by one of the characters in \a delim
 void tokenizeString( const std::string& s, std::vector<std::string>& outTokens, const std::string& delim="\t\n" );
 
-// OBSOLETE
-/// Used to keep track of the progress made by iterative algorithms.
-/** \deprecated Redundant, because a simple std::vector<Real> provides the same functionality
- */
-class Diffs : public std::vector<Real> {
-    private:
-        size_t _maxsize;
-        Real _def;
-        std::vector<Real>::iterator _pos;
-        std::vector<Real>::iterator _maxpos;
-    public:
-        /// Constructor
-        /** \param maxsize Maximum number of differences to store
-         *  \param def Default value
-         */
-        Diffs(long maxsize, Real def) : std::vector<Real>(), _maxsize(maxsize), _def(def) {
-            this->reserve(_maxsize);
-            _pos = begin();
-            _maxpos = begin();
-        }
-        /// Returns maximum difference encountered so far
-        Real maxDiff() {
-            if( size() < _maxsize )
-                return _def;
-            else
-                return( *_maxpos );
-        }
-        /// Register new difference \a x
-        void push(Real x) {
-            if( size() < _maxsize ) {
-                push_back(x);
-                _pos = end();
-                if( size() > 1 ) {
-                    if( *_maxpos < back() ) {
-                        _maxpos = end();
-                        _maxpos--;
-                    }
-                } else {
-                    _maxpos = begin();
-                }
-            } else {
-                if( _pos == end() )
-                    _pos = begin();
-                if( _maxpos == _pos ) {
-                    *_pos++ = x;
-                    _maxpos = max_element(begin(),end());
-                } else {
-                    if( x > *_maxpos )
-                        _maxpos = _pos;
-                    *_pos++ = x;
-                }
-            }
-        }
-        /// Return maximum number of differences that can be stored
-        size_t maxSize() { return _maxsize; }
-};
-
 
 } // end of namespace dai
 
 
 } // end of namespace dai
 
index 3f1a8d3..361ef7f 100644 (file)
@@ -137,16 +137,6 @@ class VarSet : public SmallSet<Var> {
                 states *= n->states();
             return states;
         }
                 states *= n->states();
             return states;
         }
-
-        /// Calculates the linear index in the Cartesian product of the variables in \c *this that corresponds to a particular joint assignment of the variables, specified by \a state.
-        /** \deprecated Please use dai::calcLinearState() instead
-         */
-        size_t calcState( const std::map<Var, size_t> &state ) const { return dai::calcLinearState( *this, state ); }
-
-        /// Calculates the joint assignment of the variables in \c *this corresponding to the linear index \a linearState.
-        /** \deprecated Please use dai::calcState() instead
-         */
-        std::map<Var, size_t> calcStates( size_t linearState ) const { return dai::calcState( *this, linearState ); }
     //@}
 
     /// \name Input and output
     //@}
 
     /// \name Input and output
index 36c98fe..cc723bc 100644 (file)
@@ -146,24 +146,6 @@ class RootedTree : public std::vector<DEdge> {
 };
 
 
 };
 
 
-// OBSOLETE
-/// Vector of UEdge
-/** \deprecated Please use Graph instead
- */
-typedef std::vector<UEdge>  UEdgeVec;
-// OBSOLETE
-/// Vector of DEdge
-/** \deprecated Please use RootedTree instead
- */
-typedef std::vector<DEdge>  DEdgeVec;
-
-// OBSOLETE
-/// Constructs a rooted tree from a tree and a root
-/** \pre T has no cycles and contains node \a Root
- *  \deprecated Please use RootedTree::RootedTree(const Graph &, size_t) instead
- */
-DEdgeVec GrowRootedTree( const Graph &T, size_t Root );
-
 /// Uses Prim's algorithm to construct a minimal spanning tree from the (positively) weighted graph \a G.
 /** Uses implementation in Boost Graph Library.
  */
 /// Uses Prim's algorithm to construct a minimal spanning tree from the (positively) weighted graph \a G.
 /** Uses implementation in Boost Graph Library.
  */
index 1cc0c1b..c192c28 100644 (file)
@@ -269,7 +269,7 @@ Real LC::run() {
 
     vector<Factor> old_beliefs;
     for(size_t i=0; i < nrVars(); i++ )
 
     vector<Factor> old_beliefs;
     for(size_t i=0; i < nrVars(); i++ )
-        old_beliefs.push_back(belief(i));
+        old_beliefs.push_back(beliefV(i));
 
     bool hasNaNs = false;
     for( size_t i=0; i < nrVars(); i++ )
 
     bool hasNaNs = false;
     for( size_t i=0; i < nrVars(); i++ )
@@ -307,8 +307,8 @@ Real LC::run() {
 
         // compare new beliefs with old ones
         for(size_t i=0; i < nrVars(); i++ ) {
 
         // compare new beliefs with old ones
         for(size_t i=0; i < nrVars(); i++ ) {
-            diffs[i] = dist( belief(i), old_beliefs[i], Prob::DISTLINF );
-            old_beliefs[i] = belief(i);
+            diffs[i] = dist( beliefV(i), old_beliefs[i], Prob::DISTLINF );
+            old_beliefs[i] = beliefV(i);
         }
         maxDiff = max( diffs );
 
         }
         maxDiff = max( diffs );
 
index 4605297..9b919af 100644 (file)
@@ -93,7 +93,7 @@ int main( int argc, char *argv[] ) {
         cout << "Binary variables?      " << fg.isBinary() << endl;
         cout << "Pairwise interactions? " << fg.isPairwise() << endl;
         if( calc_tw ) {
         cout << "Binary variables?      " << fg.isBinary() << endl;
         cout << "Pairwise interactions? " << fg.isPairwise() << endl;
         if( calc_tw ) {
-            std::pair<size_t,size_t> tw = treewidth(fg);
+            std::pair<size_t,size_t> tw = boundTreewidth(fg);
             cout << "Treewidth:           " << tw.first << endl;
             cout << "Largest cluster for JTree has " << tw.second << " states " << endl;
         }
             cout << "Treewidth:           " << tw.first << endl;
             cout << "Largest cluster for JTree has " << tw.second << " states " << endl;
         }