Avoid importing the std namespace

packages/CLPBN/horus/LiftedVe.cpp

@@ -8,21 +8,21 @@
 #include "Util.h"
 
 
-vector<LiftedOperator*>
+std::vector<LiftedOperator*>
 LiftedOperator::getValidOps (
     ParfactorList& pfList,
     const Grounds& query)
 {
-  vector<LiftedOperator*>  validOps;
-  vector<ProductOperator*> multOps;
+  std::vector<LiftedOperator*>  validOps;
+  std::vector<ProductOperator*> multOps;
 
   multOps = ProductOperator::getValidOps (pfList);
   validOps.insert (validOps.end(), multOps.begin(), multOps.end());
 
   if (Globals::verbosity > 1 || multOps.empty()) {
-    vector<SumOutOperator*>   sumOutOps;
-    vector<CountingOperator*> countOps;
-    vector<GroundOperator*>   groundOps;
+    std::vector<SumOutOperator*>   sumOutOps;
+    std::vector<CountingOperator*> countOps;
+    std::vector<GroundOperator*>   groundOps;
     sumOutOps = SumOutOperator::getValidOps (pfList, query);
     countOps  = CountingOperator::getValidOps (pfList);
     groundOps = GroundOperator::getValidOps (pfList);
@@ -41,21 +41,21 @@ LiftedOperator::printValidOps (
     ParfactorList& pfList,
     const Grounds& query)
 {
-  vector<LiftedOperator*> validOps;
+  std::vector<LiftedOperator*> validOps;
   validOps = LiftedOperator::getValidOps (pfList, query);
   for (size_t i = 0; i < validOps.size(); i++) {
-    cout << "-> " << validOps[i]->toString();
+    std::cout << "-> " << validOps[i]->toString();
     delete validOps[i];
   }
 }
 
 
 
-vector<ParfactorList::iterator>
+std::vector<ParfactorList::iterator>
 LiftedOperator::getParfactorsWithGroup (
     ParfactorList& pfList, PrvGroup group)
 {
-  vector<ParfactorList::iterator> iters;
+  std::vector<ParfactorList::iterator> iters;
   ParfactorList::iterator pflIt = pfList.begin();
   while (pflIt != pfList.end()) {
     if ((*pflIt)->containsGroup (group)) {
@@ -89,13 +89,13 @@ ProductOperator::apply (void)
 
 
 
-vector<ProductOperator*>
+std::vector<ProductOperator*>
 ProductOperator::getValidOps (ParfactorList& pfList)
 {
-  vector<ProductOperator*> validOps;
+  std::vector<ProductOperator*> validOps;
   ParfactorList::iterator it1 = pfList.begin();
   ParfactorList::iterator penultimate = -- pfList.end();
-  set<Parfactor*> pfs;
+  std::set<Parfactor*> pfs;
   while (it1 != penultimate) {
     if (Util::contains (pfs, *it1)) {
       ++ it1;
@@ -128,15 +128,15 @@ ProductOperator::getValidOps (ParfactorList& pfList)
 
 
 
-string
+std::string
 ProductOperator::toString (void)
 {
-  stringstream ss;
+  std::stringstream ss;
   ss << "just multiplicate " ;
   ss << (*g1_)->getAllGroups();
   ss << " x " ;
   ss << (*g2_)->getAllGroups();
-  ss << " [cost=" << std::exp (getLogCost()) << "]" << endl;
+  ss << " [cost=" << std::exp (getLogCost()) << "]" << std::endl;
   return ss.str();
 }
 
@@ -175,7 +175,7 @@ SumOutOperator::getLogCost (void)
   unsigned nrProdFactors = 0;
   while (pfIter != pfList_.end()) {
     if ((*pfIter)->containsGroup (group_)) {
-      vector<PrvGroup> groups = (*pfIter)->getAllGroups();
+      std::vector<PrvGroup> groups = (*pfIter)->getAllGroups();
       groupSet |= TinySet<PrvGroup> (groups);
       ++ nrProdFactors;
     }
@@ -205,7 +205,7 @@ SumOutOperator::getLogCost (void)
 void
 SumOutOperator::apply (void)
 {
-  vector<ParfactorList::iterator> iters;
+  std::vector<ParfactorList::iterator> iters;
   iters = getParfactorsWithGroup (pfList_, group_);
   Parfactor* product = *(iters[0]);
   pfList_.remove (iters[0]);
@@ -234,13 +234,13 @@ SumOutOperator::apply (void)
 
 
 
-vector<SumOutOperator*>
+std::vector<SumOutOperator*>
 SumOutOperator::getValidOps (
     ParfactorList& pfList,
     const Grounds& query)
 {
-  vector<SumOutOperator*> validOps;
-  set<PrvGroup> allGroups;
+  std::vector<SumOutOperator*> validOps;
+  std::set<PrvGroup> allGroups;
   ParfactorList::const_iterator it = pfList.begin();
   while (it != pfList.end()) {
     const ProbFormulas& formulas = (*it)->arguments();
@@ -249,7 +249,7 @@ SumOutOperator::getValidOps (
     }
     ++ it;
   }
-  set<PrvGroup>::const_iterator groupIt = allGroups.begin();
+  std::set<PrvGroup>::const_iterator groupIt = allGroups.begin();
   while (groupIt != allGroups.end()) {
     if (validOp (*groupIt, pfList, query)) {
       validOps.push_back (new SumOutOperator (*groupIt, pfList));
@@ -261,18 +261,18 @@ SumOutOperator::getValidOps (
 
 
 
-string
+std::string
 SumOutOperator::toString (void)
 {
-  stringstream ss;
-  vector<ParfactorList::iterator> pfIters;
+  std::stringstream ss;
+  std::vector<ParfactorList::iterator> pfIters;
   pfIters = getParfactorsWithGroup (pfList_, group_);
   size_t idx = (*pfIters[0])->indexOfGroup (group_);
   ProbFormula f = (*pfIters[0])->argument (idx);
   TupleSet tupleSet = (*pfIters[0])->constr()->tupleSet (f.logVars());
   ss << "sum out " << f.functor() << "/" << f.arity();
   ss << "|" << tupleSet << " (group " << group_ << ")";
-  ss << " [cost=" << std::exp (getLogCost()) << "]" << endl;
+  ss << " [cost=" << std::exp (getLogCost()) << "]" << std::endl;
   return ss.str();
 }
 
@@ -284,7 +284,7 @@ SumOutOperator::validOp (
     ParfactorList& pfList,
     const Grounds& query)
 {
-  vector<ParfactorList::iterator> pfIters;
+  std::vector<ParfactorList::iterator> pfIters;
   pfIters = getParfactorsWithGroup (pfList, group);
   if (isToEliminate (*pfIters[0], group, query) == false) {
     return false;
@@ -393,10 +393,10 @@ CountingOperator::apply (void)
 
 
 
-vector<CountingOperator*>
+std::vector<CountingOperator*>
 CountingOperator::getValidOps (ParfactorList& pfList)
 {
-  vector<CountingOperator*> validOps;
+  std::vector<CountingOperator*> validOps;
   ParfactorList::iterator it = pfList.begin();
   while (it != pfList.end()) {
     LogVarSet candidates = (*it)->uncountedLogVars();
@@ -414,17 +414,17 @@ CountingOperator::getValidOps (ParfactorList& pfList)
 
 
 
-string
+std::string
 CountingOperator::toString (void)
 {
-  stringstream ss;
+  std::stringstream ss;
   ss << "count convert " << X_ << " in " ;
   ss << (*pfIter_)->getLabel();
-  ss << " [cost=" << std::exp (getLogCost()) << "]" << endl;
+  ss << " [cost=" << std::exp (getLogCost()) << "]" << std::endl;
   Parfactors pfs = LiftedOperations::countNormalize (*pfIter_, X_);
   if ((*pfIter_)->constr()->isCountNormalized (X_) == false) {
     for (size_t i = 0; i < pfs.size(); i++) {
-      ss << "   º " << pfs[i]->getLabel() << endl;
+      ss << "   º " << pfs[i]->getLabel() << std::endl;
     }
   }
   for (size_t i = 0; i < pfs.size(); i++) {
@@ -457,14 +457,14 @@ CountingOperator::validOp (Parfactor* g, LogVar X)
 double
 GroundOperator::getLogCost (void)
 {
-  vector<pair<PrvGroup, unsigned>> affectedFormulas;
+  std::vector<std::pair<PrvGroup, unsigned>> affectedFormulas;
   affectedFormulas = getAffectedFormulas();
-  // cout << "affected formulas: " ;
+  // std::cout << "affected formulas: " ;
   // for (size_t i = 0; i < affectedFormulas.size(); i++) {
-  //  cout << affectedFormulas[i].first  << ":" ;
-  //  cout << affectedFormulas[i].second << " " ;
+  //  std::cout << affectedFormulas[i].first  << ":" ;
+  //  std::cout << affectedFormulas[i].second << " " ;
   // }
-  // cout << "cost =" ;
+  // std::cout << "cost =" ;
   double totalCost = std::log (0.0);
   ParfactorList::iterator pflIt = pfList_.begin();
   while (pflIt != pfList_.end()) {
@@ -495,13 +495,13 @@ GroundOperator::getLogCost (void)
       }
     }
     if (willBeAffected) {
-      // cout << " + " << std::exp (reps) << "x" << std::exp (pfSize);
+      // std::cout << " + " << std::exp (reps) << "x" << std::exp (pfSize);
       double pfCost = reps + pfSize;
       totalCost = Util::logSum (totalCost, pfCost);
     }
     ++ pflIt;
   }
-  // cout << endl;
+  // std::cout << std::endl;
   return totalCost + 3;
 }
 
@@ -537,11 +537,11 @@ GroundOperator::apply (void)
 
 
 
-vector<GroundOperator*>
+std::vector<GroundOperator*>
 GroundOperator::getValidOps (ParfactorList& pfList)
 {
-  vector<GroundOperator*> validOps;
-  set<PrvGroup> allGroups;
+  std::vector<GroundOperator*> validOps;
+  std::set<PrvGroup> allGroups;
   ParfactorList::const_iterator it = pfList.begin();
   while (it != pfList.end()) {
     const ProbFormulas& formulas = (*it)->arguments();
@@ -564,18 +564,18 @@ GroundOperator::getValidOps (ParfactorList& pfList)
 
 
 
-string
+std::string
 GroundOperator::toString (void)
 {
-  stringstream ss;
-  vector<ParfactorList::iterator> pfIters;
+  std::stringstream ss;
+  std::vector<ParfactorList::iterator> pfIters;
   pfIters = getParfactorsWithGroup (pfList_, group_);
   Parfactor* pf = *(getParfactorsWithGroup (pfList_, group_).front());
   size_t idx = pf->indexOfGroup (group_);
   ProbFormula f = pf->argument (idx);
   LogVar lv     = f.logVars()[lvIndex_];
   TupleSet tupleSet = pf->constr()->tupleSet ({lv});
-  string pos = "th";
+  std::string pos = "th";
   if (lvIndex_ == 0) {
     pos = "st" ;
   } else if (lvIndex_ == 1) {
@@ -586,21 +586,21 @@ GroundOperator::toString (void)
   ss << "grounding " << lvIndex_ + 1 << pos << " log var in " ;
   ss << f.functor() << "/" << f.arity();
   ss << "|" << tupleSet << " (group " << group_ << ")";
-  ss << " [cost=" << std::exp (getLogCost()) << "]" << endl;
+  ss << " [cost=" << std::exp (getLogCost()) << "]" << std::endl;
   return ss.str();
 }
 
 
 
-vector<pair<PrvGroup, unsigned>>
+std::vector<std::pair<PrvGroup, unsigned>>
 GroundOperator::getAffectedFormulas (void)
 {
-  vector<pair<PrvGroup, unsigned>> affectedFormulas;
-  affectedFormulas.push_back (make_pair (group_, lvIndex_));
-  queue<pair<PrvGroup, unsigned>> q;
-  q.push (make_pair (group_, lvIndex_));
+  std::vector<std::pair<PrvGroup, unsigned>> affectedFormulas;
+  affectedFormulas.push_back (std::make_pair (group_, lvIndex_));
+  std::queue<std::pair<PrvGroup, unsigned>> q;
+  q.push (std::make_pair (group_, lvIndex_));
   while (q.empty() == false) {
-    pair<PrvGroup, unsigned> front = q.front();
+    std::pair<PrvGroup, unsigned> front = q.front();
     ParfactorList::iterator pflIt = pfList_.begin();
     while (pflIt != pfList_.end()) {
       size_t idx = (*pflIt)->indexOfGroup (front.first);
@@ -610,7 +610,7 @@ GroundOperator::getAffectedFormulas (void)
         const ProbFormulas& fs = (*pflIt)->arguments();
         for (size_t i = 0; i < fs.size(); i++) {
           if (i != idx && fs[i].contains (X)) {
-            pair<PrvGroup, unsigned> pair = make_pair (
+            std::pair<PrvGroup, unsigned> pair = std::make_pair (
                 fs[i].group(), fs[i].indexOf (X));
             if (Util::contains (affectedFormulas, pair) == false) {
               q.push (pair);
@@ -647,11 +647,11 @@ LiftedVe::solveQuery (const Grounds& query)
 void
 LiftedVe::printSolverFlags (void) const
 {
-  stringstream ss;
+  std::stringstream ss;
   ss << "lve [" ;
   ss << "log_domain=" << Util::toString (Globals::logDomain);
   ss << "]" ;
-  cout << ss.str() << endl;
+  std::cout << ss.str() << std::endl;
 }
 
 
@@ -675,9 +675,9 @@ LiftedVe::runSolver (const Grounds& query)
       break;
     }
     if (Globals::verbosity > 1) {
-      cout << "best operation: " << op->toString();
+      std::cout << "best operation: " << op->toString();
       if (Globals::verbosity > 2) {
-        cout << endl;
+        std::cout << std::endl;
       }
     }
     op->apply();
@@ -693,8 +693,9 @@ LiftedVe::runSolver (const Grounds& query)
     }
   }
   if (Globals::verbosity > 0) {
-    cout << "largest cost = " << std::exp (largestCost_) << endl;
-    cout << endl;
+    std::cout << "largest cost = " << std::exp (largestCost_);
+    std::cout << std::endl;
+    std::cout << std::endl;
   }
   (*pfList_.begin())->simplifyGrounds();
   (*pfList_.begin())->reorderAccordingGrounds (query);
@@ -707,7 +708,7 @@ LiftedVe::getBestOperation (const Grounds& query)
 {
   double bestCost = 0.0;
   LiftedOperator* bestOp = 0;
-  vector<LiftedOperator*> validOps;
+  std::vector<LiftedOperator*> validOps;
   validOps = LiftedOperator::getValidOps (pfList_, query);
   for (size_t i = 0; i < validOps.size(); i++) {
     double cost = validOps[i]->getLogCost();