Removed deprecated interfaces
authorJoris Mooij <joris.mooij@tuebingen.mpg.de>
Mon, 17 May 2010 18:02:54 +0000 (20:02 +0200)
committerJoris Mooij <joris.mooij@tuebingen.mpg.de>
Mon, 17 May 2010 18:02:54 +0000 (20:02 +0200)
ChangeLog
include/dai/clustergraph.h
include/dai/factor.h
include/dai/factorgraph.h
include/dai/prob.h
include/dai/properties.h
include/dai/regiongraph.h
include/dai/weightedgraph.h
src/weightedgraph.cpp
utils/uai2fg.cpp

index 5d8da46..611badb 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,6 @@
 git HEAD
 --------
+* Removed deprecated interfaces.
 * Added FactorGraph::isMaximal(size_t) and FactorGraph::maximalFactor(size_t).
 * Added optional reverse argument to Permute::Permute( const std::vector<Var>& )
   constructor.
index fb16303..a8c1596 100644 (file)
@@ -89,16 +89,6 @@ namespace dai {
                 return _clusters[I]; 
             }
 
-            /// Returns a constant reference to the clusters
-            /** \deprecated Please use dai::ClusterGraph::clusters() instead
-             */
-            const std::vector<VarSet>& toVector() const { return _clusters; }
-
-            /// Returns number of clusters
-            /** \deprecated Please use dai::ClusterGraph::nrClusters() instead
-             */
-            size_t size() const { return _G.nrNodes2(); }
-
             /// Returns the index of variable \a n
             /** \throw OBJECT_NOT_FOUND if the variable does not occur in the cluster graph
              */
index a313ba9..24b6d89 100644 (file)
@@ -132,10 +132,6 @@ class TFactor {
         /// Returns a copy of the \a i 'th entry of the value vector
         T operator[] (size_t i) const { return _p[i]; }
 
-        /// Returns a reference to the \a i 'th entry of the value vector
-        /// \deprecated Please use dai::TFactor::set() instead
-        T& operator[] (size_t i) { return _p[i]; }
-
         /// Returns constant reference to variable set (i.e., the variables on which the factor depends)
         const VarSet& vars() const { return _vs; }
 
@@ -147,12 +143,6 @@ class TFactor {
          */
         size_t nrStates() const { return _p.size(); }
 
-        /// Returns the number of possible joint states of the variables on which the factor depends, \f$\prod_{l\in L} S_l\f$
-        /** \note This is equal to the length of the value vector.
-         *  \deprecated Please use dai::TFactor::nrStates() instead.
-         */
-        size_t states() const { return _p.size(); }
-
         /// Returns the Shannon entropy of \c *this, \f$-\sum_i p_i \log p_i\f$
         T entropy() const { return _p.entropy(); }
 
index 66d1da1..e30a11f 100644 (file)
@@ -74,16 +74,6 @@ class FactorGraph {
         /// Shorthand for BipartiteGraph::Edge
         typedef BipartiteGraph::Edge      Edge;
 
-        /// Iterator over factors
-        /** \deprecated The FactorGraph iterator interface will be removed in future versions of libDAI
-         */
-        typedef std::vector<Factor>::iterator iterator;
-
-        /// Constant iterator over factors
-        /** \deprecated The FactorGraph iterator interface will be removed in future versions of libDAI
-         */
-        typedef std::vector<Factor>::const_iterator const_iterator;
-
     private:
         /// Stores the neighborhood structure
         BipartiteGraph           _G;
@@ -129,15 +119,6 @@ class FactorGraph {
         /// Returns constant reference to all variables
         const std::vector<Var>& vars() const { return _vars; }
 
-        /// Returns reference to \a I 'th factor
-        /** \deprecated Please use the const member dai::FactorGraph::factor( size_t ) instead,
-         *  or dai::FactorGraph::setFactor() for changing a factor.
-         */
-        Factor& factor( size_t I ) { 
-            DAI_DEBASSERT( I < nrFactors() );
-            return _factors[I]; 
-        }
-
         /// Returns constant reference to \a I 'th factor
         const Factor& factor( size_t I ) const { 
             DAI_DEBASSERT( I < nrFactors() );
@@ -156,26 +137,6 @@ class FactorGraph {
         const Neighbor& nbF( size_t I, size_t _i ) const { return _G.nb2(I)[_i]; }
     //@}
 
-    /// \name Iterator interface
-    //@{
-        /// Returns iterator pointing to first factor
-        /** \deprecated The FactorGraph iterator interface will be removed in future versions of libDAI
-         */
-        iterator begin() { return _factors.begin(); }
-        /// Returns constant iterator pointing to first factor
-        /** \deprecated The FactorGraph iterator interface will be removed in future versions of libDAI
-         */
-        const_iterator begin() const { return _factors.begin(); }
-        /// Returns iterator pointing beyond last factor
-        /** \deprecated The FactorGraph iterator interface will be removed in future versions of libDAI
-         */
-        iterator end() { return _factors.end(); }
-        /// Returns constant iterator pointing beyond last factor
-        /** \deprecated The FactorGraph iterator interface will be removed in future versions of libDAI
-         */
-        const_iterator end() const { return _factors.end(); }
-    //@}
-
     /// \name Queries
     //@{
         /// Returns neighborhood structure
@@ -276,13 +237,6 @@ class FactorGraph {
          *  strict subset of another factor domain.
          */
         std::vector<VarSet> maximalFactorDomains() const;
-
-        /// Returns the maximal factors domains in this factorgraph
-        /** \deprecated Please use dai::FactorGraph::maximalFactorDomains() instead
-         */
-        std::vector<VarSet> cliques() const {
-            return maximalFactorDomains();
-        }
     //@}
 
     /// \name Backup/restore mechanism for factors
index ca6850c..633cfa4 100644 (file)
@@ -207,24 +207,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 +224,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 +310,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
index d75f80d..289b7a3 100644 (file)
@@ -98,13 +98,6 @@ class PropertySet : private std::map<PropertyKey, PropertyValue> {
             return *this; 
         }
 
-        /// Sets a property (a key \a key with a corresponding value \a val)
-        /** \deprecated Please use dai::PropertySet::set(const PropertyKey&, const PropertyValue&) instead
-         */
-        PropertySet& Set( const PropertyKey& key, const PropertyValue& val ) { 
-            return set( key, val );
-        }
-
         /// Set properties according to \a newProps, overriding properties that already exist with new values
         PropertySet& set( const PropertySet& newProps ) {
             const std::map<PropertyKey, PropertyValue> *m = &newProps;
@@ -113,13 +106,6 @@ class PropertySet : private std::map<PropertyKey, PropertyValue> {
             return *this;
         }
 
-        /// Set properties according to \a newProps, overriding properties that already exist with new values
-        /** \deprecated Please use dai::PropertySet::set(const PropertySet&) instead
-         */
-        PropertySet& Set( const PropertySet& newProps ) {
-            return set( newProps );
-        }
-
         /// Shorthand for (temporarily) adding properties
         /** \par Example:
             \code
@@ -162,17 +148,6 @@ PropertySet p()("method","BP")("verbose",1)("tol",1e-9)
                 }
             }
         }
-
-        /// Converts the type of the property value corresponding with \a key from string to \a ValueType (if necessary)
-        /** The implementation makes use of boost::lexical_cast
-         *  \tparam ValueType Type to which the value should be cast
-         *  \throw IMPOSSIBLE_TYPECAST if the type cast cannot be done
-         *  \deprecated Please use dai::PropertySet::convertTo() instead
-         */
-        template<typename ValueType>
-        void ConvertTo( const PropertyKey& key ) { 
-            convertTo<ValueType>( key );
-        }
     //@}
 
     //@}
@@ -219,14 +194,6 @@ PropertySet p()("method","BP")("verbose",1)("tol",1e-9)
             return x->second;
         }
 
-        /// Gets the value corresponding to \a key
-        /** \throw OBJECT_NOT_FOUND if the key cannot be found in \c *this
-         *  \deprecated Please use dai::PropertySet::get() instead
-         */
-        const PropertyValue& Get( const PropertyKey& key ) const {
-            return get( key );
-        }
-
         /// Gets the value corresponding to \a key, cast to \a ValueType
         /** \tparam ValueType Type to which the value should be cast
          *  \throw OBJECT_NOT_FOUND if the key cannot be found in \c *this
@@ -242,17 +209,6 @@ PropertySet p()("method","BP")("verbose",1)("tol",1e-9)
             }
         }
 
-        /// Gets the value corresponding to \a key, cast to \a ValueType
-        /** \tparam ValueType Type to which the value should be cast
-         *  \throw OBJECT_NOT_FOUND if the key cannot be found in \c *this
-         *  \throw IMPOSSIBLE_TYPECAST if the type cast cannot be done
-         *  \deprecated Please use dai::PropertySet::getAs() instead
-         */
-        template<typename ValueType>
-        ValueType GetAs( const PropertyKey& key ) const {
-            return getAs<ValueType>( key );
-        }
-
         /// Gets the value corresponding to \a key, cast to \a ValueType, converting from a string if necessary
         /** If the type of the value is already equal to \a ValueType, no conversion is done.
          *  Otherwise, the type of the value should be a std::string, in which case boost::lexical_cast is
index 94e4448..d6b7870 100644 (file)
@@ -226,34 +226,6 @@ class RegionGraph : public FactorGraph {
                 ns |= fac->second.vars();
             recomputeORs( ns );
         }
-
-        /// Calculates counting numbers of inner regions based upon counting numbers of outer regions
-        /** The counting numbers of the inner regions are set using the Moebius inversion formula:
-         *    \f[ c_\beta := 1 - \sum_{\gamma \in \mathrm{an}(\beta)} c_\gamma \f]
-         *  where \f$\mathrm{an}(\beta)\f$ are the ancestors of inner region \f$\beta\f$ according to
-         *  the partial ordering induced by the subset relation (i.e., a region is a child of another
-         *  region if its variables are a subset of the variables of its parent region).
-         *  \deprecated This functionality has been protected.
-         */
-        void calcCountingNumbers() { calcCVMCountingNumbers(); }
-
-        /// Recompute all outer regions
-        /** The factor contents of each outer region is set to the product of the factors belonging to that region.
-         *  \deprecated This functionality has been protected.
-         */
-        void RecomputeORs() { recomputeORs(); }
-
-        /// Recompute all outer regions involving the variables in \a vs
-        /** The factor contents of each outer region involving at least one of the variables in \a vs is set to the product of the factors belonging to that region.
-         *  \deprecated This functionality has been protected.
-         */
-        void RecomputeORs( const VarSet& vs ) { recomputeORs( vs ); }
-
-        /// Recompute all outer regions involving factor \a I
-        /** The factor contents of each outer region involving the \a I 'th factor is set to the product of the factors belonging to that region.
-         *  \deprecated This functionality has been protected.
-         */
-        void RecomputeOR( size_t I ) { recomputeOR( I ); }
     //@}
 
     /// \name Input/output
index 6650ace..d186ea4 100644 (file)
@@ -41,18 +41,10 @@ namespace dai {
 class DEdge {
     public:
         /// First node index (source of edge)
-        union {
-            size_t first;
-            /// \deprecated Please use member dai::DEdge::first instead
-            size_t n1;
-        };
+        size_t first;
 
         /// Second node index (target of edge)
-        union {
-            size_t second;
-            /// \deprecated Please use member dai::DEdge::second instead
-            size_t n2;
-        };
+        size_t second;
 
         /// Default constructor
         DEdge() : first(0), second(0) {}
@@ -80,18 +72,10 @@ class DEdge {
 class UEdge {
     public:
         /// First node index
-        union {
-            size_t first;
-            /// \deprecated Please use member dai::UEdge::first instead
-            size_t n1;
-        };
+        size_t first;
 
         /// Second node index
-        union {
-            size_t second;
-            /// \deprecated Please use member dai::UEdge::second instead
-            size_t n2;
-        };
+        size_t second;
 
         /// Default constructor
         UEdge() : first(0), second(0) {}
@@ -260,39 +244,6 @@ template<typename T> RootedTree MaxSpanningTree( const WeightedGraph<T> &G, bool
 }
 
 
-/// Constructs a minimum spanning tree from the (non-negatively) weighted graph \a G using Prim's algorithm.
-/** \param G Weighted graph that should have non-negative weights.
- *  \note Uses implementation from Boost Graph Library.
- *  \note The vertices of \a G must be in the range [0,N) where N is the number of vertices of \a G.
- *  \deprecated Please use dai::MinSpanningTree(const WeightedGraph&, bool) instead
- */
-template<typename T> RootedTree MinSpanningTree( const WeightedGraph<T> &G ) {
-    return MinSpanningTree( G, true );
-}
-
-
-/// Constructs a minimum spanning tree from the (non-negatively) weighted graph \a G using Prim's algorithm.
-/** \param G Weighted graph that should have non-negative weights.
- *  \note Uses implementation from Boost Graph Library.
- *  \note The vertices of \a G must be in the range [0,N) where N is the number of vertices of \a G.
- *  \deprecated Please use dai::MinSpanningTree(const WeightedGraph&, bool) instead
- */
-template<typename T> RootedTree MaxSpanningTree( const WeightedGraph<T> &G ) {
-    return MaxSpanningTree( G, true );
-}
-
-
-/// Constructs a random undirected graph of \a N nodes, where each node has connectivity \a d
-/** Algorithm 1 in [\ref StW99].
- *  Draws a random graph of size \a N and uniform degree \a d
- *  from an almost uniform probability distribution over these graphs
- *  (which becomes uniform in the limit that \a d is small and \a N goes
- *  to infinity).
- *  \deprecated Please use dai::createGraphRegular(size_t, size_t) instead
- */
-GraphEL RandomDRegularGraph( size_t N, size_t d );
-
-
 } // end of namespace dai
 
 
index d69d6ad..3674f5a 100644 (file)
@@ -75,9 +75,4 @@ RootedTree::RootedTree( const GraphEL &T, size_t Root ) {
 }
 
 
-GraphEL RandomDRegularGraph( size_t N, size_t d ) {
-    return GraphEL( createGraphRegular( N, d ) );
-}
-
-
 } // end of namespace dai
index f447366..e58c2a7 100644 (file)
@@ -154,7 +154,7 @@ void ReadUAIFGFile( const char *filename, size_t verbose, vector<Var>& vars, vec
                 DAI_THROWE(INVALID_FACTORGRAPH_FILE,"Cannot read number of nonzero factor values for " + toString(I) + "'th factor");
             if( verbose >= 3 ) 
                 cout << "  number of nonzero values: " << nrNonZeros << endl;
-            DAI_ASSERT( nrNonZeros == factors[I].states() );
+            DAI_ASSERT( nrNonZeros == factors[I].nrStates() );
             for( size_t li = 0; li < nrNonZeros; li++ ) {
                 Real val;
                 is >> val;
@@ -163,7 +163,7 @@ void ReadUAIFGFile( const char *filename, size_t verbose, vector<Var>& vars, vec
                 // assign value after calculating its linear index corresponding to the permutation
                 if( verbose >= 4 )
                     cout << "  " << li << "'th value " << val << " corresponds with index " << permindex.convertLinearIndex(li) << endl;
-                factors[I][permindex.convertLinearIndex( li )] = val;
+                factors[I].set( permindex.convertLinearIndex( li ), val );
             }
         }
         if( verbose >= 3 )