12345qiupeng
/
gtsam
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replaced BOOSE_FOREACH with for in gtsam folder.

release/4.3a0
Yao Chen 2016-05-20 23:41:22 -04:00
parent d1ea1015a9
commit ce2cd71112
42 changed files with 150 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
gtsam/base/DSFVector.cpp
View File

@ -79,7 +79,7 @@ DSFVector::DSFVector(const boost::shared_ptr<V>& v_in,
/* ************************************************************************* */ /* ************************************************************************* */
bool DSFVector::isSingleton(const size_t& label) const { bool DSFVector::isSingleton(const size_t& label) const {
bool result = false; bool result = false;
BOOST_FOREACH(size_t key,keys_) { for(size_t key: keys_) {
if (find(key) == label) { if (find(key) == label) {
if (!result) // find the first occurrence if (!result) // find the first occurrence
result = true; result = true;
@ -93,7 +93,7 @@ bool DSFVector::isSingleton(const size_t& label) const {
/* ************************************************************************* */ /* ************************************************************************* */
std::set<size_t> DSFVector::set(const size_t& label) const { std::set<size_t> DSFVector::set(const size_t& label) const {
std::set < size_t > set; std::set < size_t > set;
BOOST_FOREACH(size_t key,keys_) for(size_t key: keys_)
if (find(key) == label) if (find(key) == label)
set.insert(key); set.insert(key);
return set; return set;
@ -102,7 +102,7 @@ std::set<size_t> DSFVector::set(const size_t& label) const {
/* ************************************************************************* */ /* ************************************************************************* */
std::map<size_t, std::set<size_t> > DSFVector::sets() const { std::map<size_t, std::set<size_t> > DSFVector::sets() const {
std::map<size_t, std::set<size_t> > sets; std::map<size_t, std::set<size_t> > sets;
BOOST_FOREACH(size_t key,keys_) for(size_t key: keys_)
sets[find(key)].insert(key); sets[find(key)].insert(key);
return sets; return sets;
} }
@ -110,7 +110,7 @@ std::map<size_t, std::set<size_t> > DSFVector::sets() const {
/* ************************************************************************* */ /* ************************************************************************* */
std::map<size_t, std::vector<size_t> > DSFVector::arrays() const { std::map<size_t, std::vector<size_t> > DSFVector::arrays() const {
std::map<size_t, std::vector<size_t> > arrays; std::map<size_t, std::vector<size_t> > arrays;
BOOST_FOREACH(size_t key,keys_) for(size_t key: keys_)
arrays[find(key)].push_back(key); arrays[find(key)].push_back(key);
return arrays; return arrays;
} }

12
gtsam/base/Matrix.cpp
View File

@ -190,7 +190,7 @@ istream& operator>>(istream& inputStream, Matrix& destinationMatrix) {
// Copy coefficients to matrix // Copy coefficients to matrix
destinationMatrix.resize(height, width); destinationMatrix.resize(height, width);
int row = 0; int row = 0;
BOOST_FOREACH(const vector<double>& rowVec, coeffs) { for(const vector<double>& rowVec: coeffs) {
destinationMatrix.row(row) = Eigen::Map<const Eigen::RowVectorXd>(&rowVec[0], width); destinationMatrix.row(row) = Eigen::Map<const Eigen::RowVectorXd>(&rowVec[0], width);
++ row; ++ row;
} }
@ -419,7 +419,7 @@ Matrix stack(size_t nrMatrices, ...)
Matrix stack(const std::vector<Matrix>& blocks) { Matrix stack(const std::vector<Matrix>& blocks) {
if (blocks.size() == 1) return blocks.at(0); if (blocks.size() == 1) return blocks.at(0);
DenseIndex nrows = 0, ncols = blocks.at(0).cols(); DenseIndex nrows = 0, ncols = blocks.at(0).cols();
BOOST_FOREACH(const Matrix& mat, blocks) { for(const Matrix& mat: blocks) {
nrows += mat.rows(); nrows += mat.rows();
if (ncols != mat.cols()) if (ncols != mat.cols())
throw invalid_argument("Matrix::stack(): column size mismatch!"); throw invalid_argument("Matrix::stack(): column size mismatch!");
@ -427,7 +427,7 @@ Matrix stack(const std::vector<Matrix>& blocks) {
Matrix result(nrows, ncols); Matrix result(nrows, ncols);
DenseIndex cur_row = 0; DenseIndex cur_row = 0;
BOOST_FOREACH(const Matrix& mat, blocks) { for(const Matrix& mat: blocks) {
result.middleRows(cur_row, mat.rows()) = mat; result.middleRows(cur_row, mat.rows()) = mat;
cur_row += mat.rows(); cur_row += mat.rows();
} }
@ -441,7 +441,7 @@ Matrix collect(const std::vector<const Matrix *>& matrices, size_t m, size_t n)
size_t dimA1 = m; size_t dimA1 = m;
size_t dimA2 = n*matrices.size(); size_t dimA2 = n*matrices.size();
if (!m && !n) { if (!m && !n) {
BOOST_FOREACH(const Matrix* M, matrices) { for(const Matrix* M: matrices) {
dimA1 = M->rows(); // TODO: should check if all the same ! dimA1 = M->rows(); // TODO: should check if all the same !
dimA2 += M->cols(); dimA2 += M->cols();
} }
@ -450,7 +450,7 @@ Matrix collect(const std::vector<const Matrix *>& matrices, size_t m, size_t n)
// stl::copy version // stl::copy version
Matrix A(dimA1, dimA2); Matrix A(dimA1, dimA2);
size_t hindex = 0; size_t hindex = 0;
BOOST_FOREACH(const Matrix* M, matrices) { for(const Matrix* M: matrices) {
size_t row_len = M->cols(); size_t row_len = M->cols();
A.block(0, hindex, dimA1, row_len) = *M; A.block(0, hindex, dimA1, row_len) = *M;
hindex += row_len; hindex += row_len;
@ -611,7 +611,7 @@ std::string formatMatrixIndented(const std::string& label, const Matrix& matrix,
boost::tokenizer<boost::char_separator<char> > tok(matrixStr, boost::char_separator<char>("\n")); boost::tokenizer<boost::char_separator<char> > tok(matrixStr, boost::char_separator<char>("\n"));
DenseIndex row = 0; DenseIndex row = 0;
BOOST_FOREACH(const std::string& line, tok) for(const std::string& line: tok)
{ {
assert(row < effectiveRows); assert(row < effectiveRows);
if(row > 0) if(row > 0)

31
gtsam/base/TestableAssertions.h
View File

@ -20,7 +20,6 @@
#include <gtsam/base/Testable.h> #include <gtsam/base/Testable.h>
#include <gtsam/global_includes.h> #include <gtsam/global_includes.h>
#include <boost/foreach.hpp>
#include <boost/optional.hpp> #include <boost/optional.hpp>
#include <map> #include <map>
#include <iostream> #include <iostream>
@ -91,7 +90,7 @@ bool assert_equal(const std::vector<V>& expected, const std::vector<V>& actual,
match = false; match = false;
if(match) { if(match) {
size_t i = 0; size_t i = 0;
BOOST_FOREACH(const V& a, expected) { for(const V& a: expected) {
if (!assert_equal(a, actual[i++], tol)) { if (!assert_equal(a, actual[i++], tol)) {
match = false; match = false;
break; break;
@ -100,9 +99,9 @@ bool assert_equal(const std::vector<V>& expected, const std::vector<V>& actual,
} }
if(!match) { if(!match) {
std::cout << "expected: " << std::endl; std::cout << "expected: " << std::endl;
BOOST_FOREACH(const V& a, expected) { std::cout << a << " "; } for(const V& a: expected) { std::cout << a << " "; }
std::cout << "\nactual: " << std::endl; std::cout << "\nactual: " << std::endl;
BOOST_FOREACH(const V& a, actual) { std::cout << a << " "; } for(const V& a: actual) { std::cout << a << " "; }
std::cout << std::endl; std::cout << std::endl;
return false; return false;
} }
@ -133,12 +132,12 @@ bool assert_container_equal(const std::map<V1,V2>& expected, const std::map<V1,V
} }
if(!match) { if(!match) {
std::cout << "expected: " << std::endl; std::cout << "expected: " << std::endl;
BOOST_FOREACH(const typename Map::value_type& a, expected) { for(const typename Map::value_type& a: expected) {
a.first.print("key"); a.first.print("key");
a.second.print(" value"); a.second.print(" value");
} }
std::cout << "\nactual: " << std::endl; std::cout << "\nactual: " << std::endl;
BOOST_FOREACH(const typename Map::value_type& a, actual) { for(const typename Map::value_type& a: actual) {
a.first.print("key"); a.first.print("key");
a.second.print(" value"); a.second.print(" value");
} }
@ -171,12 +170,12 @@ bool assert_container_equal(const std::map<size_t,V2>& expected, const std::map<
} }
if(!match) { if(!match) {
std::cout << "expected: " << std::endl; std::cout << "expected: " << std::endl;
BOOST_FOREACH(const typename Map::value_type& a, expected) { for(const typename Map::value_type& a: expected) {
std::cout << "Key: " << a.first << std::endl; std::cout << "Key: " << a.first << std::endl;
a.second.print(" value"); a.second.print(" value");
} }
std::cout << "\nactual: " << std::endl; std::cout << "\nactual: " << std::endl;
BOOST_FOREACH(const typename Map::value_type& a, actual) { for(const typename Map::value_type& a: actual) {
std::cout << "Key: " << a.first << std::endl; std::cout << "Key: " << a.first << std::endl;
a.second.print(" value"); a.second.print(" value");
} }
@ -210,12 +209,12 @@ bool assert_container_equal(const std::vector<std::pair<V1,V2> >& expected,
} }
if(!match) { if(!match) {
std::cout << "expected: " << std::endl; std::cout << "expected: " << std::endl;
BOOST_FOREACH(const typename VectorPair::value_type& a, expected) { for(const typename VectorPair::value_type& a: expected) {
a.first.print( " first "); a.first.print( " first ");
a.second.print(" second"); a.second.print(" second");
} }
std::cout << "\nactual: " << std::endl; std::cout << "\nactual: " << std::endl;
BOOST_FOREACH(const typename VectorPair::value_type& a, actual) { for(const typename VectorPair::value_type& a: actual) {
a.first.print( " first "); a.first.print( " first ");
a.second.print(" second"); a.second.print(" second");
} }
@ -247,9 +246,9 @@ bool assert_container_equal(const V& expected, const V& actual, double tol = 1e-
} }
if(!match) { if(!match) {
std::cout << "expected: " << std::endl; std::cout << "expected: " << std::endl;
BOOST_FOREACH(const typename V::value_type& a, expected) { a.print(" "); } for(const typename V::value_type& a: expected) { a.print(" "); }
std::cout << "\nactual: " << std::endl; std::cout << "\nactual: " << std::endl;
BOOST_FOREACH(const typename V::value_type& a, actual) { a.print(" "); } for(const typename V::value_type& a: actual) { a.print(" "); }
std::cout << std::endl; std::cout << std::endl;
return false; return false;
} }
@ -279,12 +278,12 @@ bool assert_container_equality(const std::map<size_t,V2>& expected, const std::m
} }
if(!match) { if(!match) {
std::cout << "expected: " << std::endl; std::cout << "expected: " << std::endl;
BOOST_FOREACH(const typename Map::value_type& a, expected) { for(const typename Map::value_type& a: expected) {
std::cout << "Key: " << a.first << std::endl; std::cout << "Key: " << a.first << std::endl;
std::cout << "Value: " << a.second << std::endl; std::cout << "Value: " << a.second << std::endl;
} }
std::cout << "\nactual: " << std::endl; std::cout << "\nactual: " << std::endl;
BOOST_FOREACH(const typename Map::value_type& a, actual) { for(const typename Map::value_type& a: actual) {
std::cout << "Key: " << a.first << std::endl; std::cout << "Key: " << a.first << std::endl;
std::cout << "Value: " << a.second << std::endl; std::cout << "Value: " << a.second << std::endl;
} }
@ -316,9 +315,9 @@ bool assert_container_equality(const V& expected, const V& actual) {
} }
if(!match) { if(!match) {
std::cout << "expected: " << std::endl; std::cout << "expected: " << std::endl;
BOOST_FOREACH(const typename V::value_type& a, expected) { std::cout << a << " "; } for(const typename V::value_type& a: expected) { std::cout << a << " "; }
std::cout << "\nactual: " << std::endl; std::cout << "\nactual: " << std::endl;
BOOST_FOREACH(const typename V::value_type& a, actual) { std::cout << a << " "; } for(const typename V::value_type& a: actual) { std::cout << a << " "; }
std::cout << std::endl; std::cout << std::endl;
return false; return false;
} }

5
gtsam/base/Vector.cpp
View File

@ -17,7 +17,6 @@
*/ */
#include <gtsam/base/Vector.h> #include <gtsam/base/Vector.h>
#include <boost/foreach.hpp>
#include <boost/optional.hpp> #include <boost/optional.hpp>
#include <stdexcept> #include <stdexcept>
#include <cstdarg> #include <cstdarg>
@ -264,12 +263,12 @@ weightedPseudoinverse(const Vector& a, const Vector& weights) {
Vector concatVectors(const std::list<Vector>& vs) Vector concatVectors(const std::list<Vector>& vs)
{ {
size_t dim = 0; size_t dim = 0;
BOOST_FOREACH(Vector v, vs) for(Vector v: vs)
dim += v.size(); dim += v.size();
Vector A(dim); Vector A(dim);
size_t index = 0; size_t index = 0;
BOOST_FOREACH(Vector v, vs) { for(Vector v: vs) {
for(int d = 0; d < v.size(); d++) for(int d = 0; d < v.size(); d++)
A(d+index) = v(d); A(d+index) = v(d);
index += v.size(); index += v.size();

4
gtsam/base/tests/testDSFVector.cpp
View File

@ -70,7 +70,7 @@ TEST(DSFBase, mergePairwiseMatches) {
// Merge matches // Merge matches
DSFBase dsf(7); // We allow for keys 0..6 DSFBase dsf(7); // We allow for keys 0..6
BOOST_FOREACH(const Match& m, matches) for(const Match& m: matches)
dsf.merge(m.first,m.second); dsf.merge(m.first,m.second);
// Each point is now associated with a set, represented by one of its members // Each point is now associated with a set, represented by one of its members
@ -206,7 +206,7 @@ TEST(DSFVector, mergePairwiseMatches) {
// Merge matches // Merge matches
DSFVector dsf(keys); DSFVector dsf(keys);
BOOST_FOREACH(const Match& m, matches) for(const Match& m: matches)
dsf.merge(m.first,m.second); dsf.merge(m.first,m.second);
// Check that we have two connected components, 1,2,3 and 4,5,6 // Check that we have two connected components, 1,2,3 and 4,5,6

2
gtsam/base/tests/testMatrix.cpp
View File

@ -919,7 +919,7 @@ TEST(Matrix, weighted_elimination )
// unpack and verify // unpack and verify
i = 0; i = 0;
BOOST_FOREACH(boost::tie(r, di, sigma), solution){ for(boost::tie(r, di, sigma): solution){
EXPECT(assert_equal(r, expectedR.row(i))); // verify r EXPECT(assert_equal(r, expectedR.row(i))); // verify r
DOUBLES_EQUAL(d(i), di, 1e-8); // verify d DOUBLES_EQUAL(d(i), di, 1e-8); // verify d
DOUBLES_EQUAL(newSigmas(i), sigma, 1e-5); // verify sigma DOUBLES_EQUAL(newSigmas(i), sigma, 1e-5); // verify sigma

11
gtsam/base/timing.cpp
View File

@ -20,7 +20,6 @@
#include <gtsam/base/timing.h> #include <gtsam/base/timing.h>
#include <boost/algorithm/string/replace.hpp> #include <boost/algorithm/string/replace.hpp>
#include <boost/foreach.hpp>
#include <boost/format.hpp> #include <boost/format.hpp>
#include <cmath> #include <cmath>
@ -66,7 +65,7 @@ TimingOutline::TimingOutline(const std::string& label, size_t id) :
size_t TimingOutline::time() const { size_t TimingOutline::time() const {
size_t time = 0; size_t time = 0;
bool hasChildren = false; bool hasChildren = false;
BOOST_FOREACH(const ChildMap::value_type& child, children_) { for(const ChildMap::value_type& child: children_) {
time += child.second->time(); time += child.second->time();
hasChildren = true; hasChildren = true;
} }
@ -86,11 +85,11 @@ void TimingOutline::print(const std::string& outline) const {
// Order children // Order children
typedef FastMap<size_t, boost::shared_ptr<TimingOutline> > ChildOrder; typedef FastMap<size_t, boost::shared_ptr<TimingOutline> > ChildOrder;
ChildOrder childOrder; ChildOrder childOrder;
BOOST_FOREACH(const ChildMap::value_type& child, children_) { for(const ChildMap::value_type& child: children_) {
childOrder[child.second->myOrder_] = child.second; childOrder[child.second->myOrder_] = child.second;
} }
// Print children // Print children
BOOST_FOREACH(const ChildOrder::value_type order_child, childOrder) { for(const ChildOrder::value_type order_child: childOrder) {
std::string childOutline(outline); std::string childOutline(outline);
childOutline += "| "; childOutline += "| ";
order_child.second->print(childOutline); order_child.second->print(childOutline);
@ -130,7 +129,7 @@ void TimingOutline::print2(const std::string& outline,
std::cout << std::endl; std::cout << std::endl;
} }
BOOST_FOREACH(const ChildMap::value_type& child, children_) { for(const ChildMap::value_type& child: children_) {
std::string childOutline(outline); std::string childOutline(outline);
if (n_ == 0) { if (n_ == 0) {
child.second->print2(childOutline, childTotal); child.second->print2(childOutline, childTotal);
@ -210,7 +209,7 @@ void TimingOutline::finishedIteration() {
if (tMin_ == 0 || tIt_ < tMin_) if (tMin_ == 0 || tIt_ < tMin_)
tMin_ = tIt_; tMin_ = tIt_;
tIt_ = 0; tIt_ = 0;
BOOST_FOREACH(ChildMap::value_type& child, children_) { for(ChildMap::value_type& child: children_) {
child.second->finishedIteration(); child.second->finishedIteration();
} }
} }

5
gtsam/base/treeTraversal-inst.h
View File

@ -29,7 +29,6 @@
#include <string> #include <string>
#include <boost/shared_ptr.hpp> #include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp> #include <boost/make_shared.hpp>
#include <boost/foreach.hpp>
#include <boost/bind.hpp> #include <boost/bind.hpp>
namespace gtsam { namespace gtsam {
@ -91,7 +90,7 @@ void DepthFirstForest(FOREST& forest, DATA& rootData, VISITOR_PRE& visitorPre,
// Add roots to stack (insert such that they are visited and processed in order // Add roots to stack (insert such that they are visited and processed in order
{ {
typename Stack::iterator insertLocation = stack.begin(); typename Stack::iterator insertLocation = stack.begin();
BOOST_FOREACH(const sharedNode& root, forest.roots()) for(const sharedNode& root: forest.roots())
stack.insert(insertLocation, TraversalNode(root, rootData)); stack.insert(insertLocation, TraversalNode(root, rootData));
} }
@ -112,7 +111,7 @@ void DepthFirstForest(FOREST& forest, DATA& rootData, VISITOR_PRE& visitorPre,
node.dataPointer = dataList.insert(dataList.end(), node.dataPointer = dataList.insert(dataList.end(),
visitorPre(node.treeNode, node.parentData)); visitorPre(node.treeNode, node.parentData));
typename Stack::iterator insertLocation = stack.begin(); typename Stack::iterator insertLocation = stack.begin();
BOOST_FOREACH(const sharedNode& child, node.treeNode->children) for(const sharedNode& child: node.treeNode->children)
stack.insert(insertLocation, TraversalNode(child, *node.dataPointer)); stack.insert(insertLocation, TraversalNode(child, *node.dataPointer));
node.expanded = true; node.expanded = true;
} }

6
gtsam/base/treeTraversal/parallelTraversalTasks.h
View File

@ -101,7 +101,7 @@ namespace gtsam {
tbb::task* firstChild = 0; tbb::task* firstChild = 0;
tbb::task_list childTasks; tbb::task_list childTasks;
BOOST_FOREACH(const boost::shared_ptr<NODE>& child, treeNode->children) for(const boost::shared_ptr<NODE>& child: treeNode->children)
{ {
// Process child in a subtask. Important: Run visitorPre before calling // Process child in a subtask. Important: Run visitorPre before calling
// allocate_child so that if visitorPre throws an exception, we will not have // allocate_child so that if visitorPre throws an exception, we will not have
@ -143,7 +143,7 @@ namespace gtsam {
void processNodeRecursively(const boost::shared_ptr<NODE>& node, DATA& myData) void processNodeRecursively(const boost::shared_ptr<NODE>& node, DATA& myData)
{ {
BOOST_FOREACH(const boost::shared_ptr<NODE>& child, node->children) for(const boost::shared_ptr<NODE>& child: node->children)
{ {
DATA childData = visitorPre(child, myData); DATA childData = visitorPre(child, myData);
processNodeRecursively(child, childData); processNodeRecursively(child, childData);
@ -174,7 +174,7 @@ namespace gtsam {
typedef PreOrderTask<NODE, DATA, VISITOR_PRE, VISITOR_POST> PreOrderTask; typedef PreOrderTask<NODE, DATA, VISITOR_PRE, VISITOR_POST> PreOrderTask;
// Create data and tasks for our children // Create data and tasks for our children
tbb::task_list tasks; tbb::task_list tasks;
BOOST_FOREACH(const boost::shared_ptr<NODE>& root, roots) for(const boost::shared_ptr<NODE>& root: roots)
{ {
boost::shared_ptr<DATA> rootData = boost::allocate_shared<DATA>(tbb::scalable_allocator<DATA>(), visitorPre(root, myData)); boost::shared_ptr<DATA> rootData = boost::allocate_shared<DATA>(tbb::scalable_allocator<DATA>(), visitorPre(root, myData));
tasks.push_back(*new(allocate_child()) tasks.push_back(*new(allocate_child())

2
gtsam/base/treeTraversal/statistics.h
View File

@ -63,7 +63,7 @@ namespace gtsam {
{ {
int largestProblemSize = 0; int largestProblemSize = 0;
int secondLargestProblemSize = 0; int secondLargestProblemSize = 0;
BOOST_FOREACH(const boost::shared_ptr<NODE>& child, node->children) for(const boost::shared_ptr<NODE>& child: node->children)
{ {
if (child->problemSize() > largestProblemSize) if (child->problemSize() > largestProblemSize)
{ {

5
gtsam/discrete/Assignment.h
View File

@ -18,7 +18,6 @@
#pragma once #pragma once
#include <boost/foreach.hpp>
#include <iostream> #include <iostream>
#include <vector> #include <vector>
#include <map> #include <map>
@ -36,7 +35,7 @@ namespace gtsam {
public: public:
void print(const std::string& s = "Assignment: ") const { void print(const std::string& s = "Assignment: ") const {
std::cout << s << ": "; std::cout << s << ": ";
BOOST_FOREACH(const typename Assignment::value_type& keyValue, *this) for(const typename Assignment::value_type& keyValue: *this)
std::cout << "(" << keyValue.first << ", " << keyValue.second << ")"; std::cout << "(" << keyValue.first << ", " << keyValue.second << ")";
std::cout << std::endl; std::cout << std::endl;
} }
@ -65,7 +64,7 @@ namespace gtsam {
std::vector<Assignment<L> > allPossValues; std::vector<Assignment<L> > allPossValues;
Assignment<L> values; Assignment<L> values;
typedef std::pair<L, size_t> DiscreteKey; typedef std::pair<L, size_t> DiscreteKey;
BOOST_FOREACH(const DiscreteKey& key, keys) for(const DiscreteKey& key: keys)
values[key.first] = 0; //Initialize from 0 values[key.first] = 0; //Initialize from 0
while (1) { while (1) {
allPossValues.push_back(values); allPossValues.push_back(values);

11
gtsam/discrete/DecisionTree-inl.h
View File

@ -24,7 +24,6 @@
#include <boost/format.hpp> #include <boost/format.hpp>
#include <boost/optional.hpp> #include <boost/optional.hpp>
#include <boost/foreach.hpp>
#include <boost/tuple/tuple.hpp> #include <boost/tuple/tuple.hpp>
#include <boost/assign/std/vector.hpp> #include <boost/assign/std/vector.hpp>
using boost::assign::operator+=; using boost::assign::operator+=;
@ -310,7 +309,7 @@ namespace gtsam {
label_(label), allSame_(true) { label_(label), allSame_(true) {
branches_.reserve(f.branches_.size()); // reserve space branches_.reserve(f.branches_.size()); // reserve space
BOOST_FOREACH (const NodePtr& branch, f.branches_) for (const NodePtr& branch: f.branches_)
push_back(branch->apply(op)); push_back(branch->apply(op));
} }
@ -332,7 +331,7 @@ namespace gtsam {
// If second argument of binary op is Leaf node, recurse on branches // If second argument of binary op is Leaf node, recurse on branches
NodePtr apply_g_op_fL(const Leaf& fL, const Binary& op) const { NodePtr apply_g_op_fL(const Leaf& fL, const Binary& op) const {
boost::shared_ptr<Choice> h(new Choice(label(), nrChoices())); boost::shared_ptr<Choice> h(new Choice(label(), nrChoices()));
BOOST_FOREACH(NodePtr branch, branches_) for(NodePtr branch: branches_)
h->push_back(fL.apply_f_op_g(*branch, op)); h->push_back(fL.apply_f_op_g(*branch, op));
return Unique(h); return Unique(h);
} }
@ -347,7 +346,7 @@ namespace gtsam {
template<typename OP> template<typename OP>
NodePtr apply_fC_op_gL(const Leaf& gL, OP op) const { NodePtr apply_fC_op_gL(const Leaf& gL, OP op) const {
boost::shared_ptr<Choice> h(new Choice(label(), nrChoices())); boost::shared_ptr<Choice> h(new Choice(label(), nrChoices()));
BOOST_FOREACH(const NodePtr& branch, branches_) for(const NodePtr& branch: branches_)
h->push_back(branch->apply_f_op_g(gL, op)); h->push_back(branch->apply_f_op_g(gL, op));
return Unique(h); return Unique(h);
} }
@ -359,7 +358,7 @@ namespace gtsam {
// second case, not label of interest, just recurse // second case, not label of interest, just recurse
boost::shared_ptr<Choice> r(new Choice(label_, branches_.size())); boost::shared_ptr<Choice> r(new Choice(label_, branches_.size()));
BOOST_FOREACH(const NodePtr& branch, branches_) for(const NodePtr& branch: branches_)
r->push_back(branch->choose(label, index)); r->push_back(branch->choose(label, index));
return Unique(r); return Unique(r);
} }
@ -593,7 +592,7 @@ namespace gtsam {
// put together via Shannon expansion otherwise not sorted. // put together via Shannon expansion otherwise not sorted.
std::vector<LY> functions; std::vector<LY> functions;
BOOST_FOREACH(const MXNodePtr& branch, choice->branches()) { for(const MXNodePtr& branch: choice->branches()) {
LY converted(convert<M, X>(branch, map, op)); LY converted(convert<M, X>(branch, map, op));
functions += converted; functions += converted;
} }

6
gtsam/discrete/DecisionTreeFactor.cpp
View File

@ -66,11 +66,11 @@ namespace gtsam {
ADT::Binary op) const { ADT::Binary op) const {
map<Key,size_t> cs; // new cardinalities map<Key,size_t> cs; // new cardinalities
// make unique key-cardinality map // make unique key-cardinality map
BOOST_FOREACH(Key j, keys()) cs[j] = cardinality(j); for(Key j: keys()) cs[j] = cardinality(j);
BOOST_FOREACH(Key j, f.keys()) cs[j] = f.cardinality(j); for(Key j: f.keys()) cs[j] = f.cardinality(j);
// Convert map into keys // Convert map into keys
DiscreteKeys keys; DiscreteKeys keys;
BOOST_FOREACH(const DiscreteKey& key, cs) for(const DiscreteKey& key: cs)
keys.push_back(key); keys.push_back(key);
// apply operand // apply operand
ADT result = ADT::apply(f, op); ADT result = ADT::apply(f, op);

2
gtsam/discrete/DiscreteBayesNet.cpp
View File

@ -46,7 +46,7 @@ namespace gtsam {
double DiscreteBayesNet::evaluate(const DiscreteConditional::Values & values) const { double DiscreteBayesNet::evaluate(const DiscreteConditional::Values & values) const {
// evaluate all conditionals and multiply // evaluate all conditionals and multiply
double result = 1.0; double result = 1.0;
BOOST_FOREACH(DiscreteConditional::shared_ptr conditional, *this) for(DiscreteConditional::shared_ptr conditional: *this)
result *= (*conditional)(values); result *= (*conditional)(values);
return result; return result;
} }

8
gtsam/discrete/DiscreteConditional.cpp
View File

@ -87,7 +87,7 @@ bool DiscreteConditional::equals(const DiscreteFactor& other,
Potentials::ADT DiscreteConditional::choose(const Values& parentsValues) const { Potentials::ADT DiscreteConditional::choose(const Values& parentsValues) const {
ADT pFS(*this); ADT pFS(*this);
Key j; size_t value; Key j; size_t value;
BOOST_FOREACH(Key key, parents()) for(Key key: parents())
try { try {
j = (key); j = (key);
value = parentsValues.at(j); value = parentsValues.at(j);
@ -111,7 +111,7 @@ void DiscreteConditional::solveInPlace(Values& values) const {
double maxP = 0; double maxP = 0;
DiscreteKeys keys; DiscreteKeys keys;
BOOST_FOREACH(Key idx, frontals()) { for(Key idx: frontals()) {
DiscreteKey dk(idx, cardinality(idx)); DiscreteKey dk(idx, cardinality(idx));
keys & dk; keys & dk;
} }
@ -119,7 +119,7 @@ void DiscreteConditional::solveInPlace(Values& values) const {
vector<Values> allPosbValues = cartesianProduct(keys); vector<Values> allPosbValues = cartesianProduct(keys);
// Find the MPE // Find the MPE
BOOST_FOREACH(Values& frontalVals, allPosbValues) { for(Values& frontalVals: allPosbValues) {
double pValueS = pFS(frontalVals); // P(F=value|S=parentsValues) double pValueS = pFS(frontalVals); // P(F=value|S=parentsValues)
// Update MPE solution if better // Update MPE solution if better
if (pValueS > maxP) { if (pValueS > maxP) {
@ -129,7 +129,7 @@ void DiscreteConditional::solveInPlace(Values& values) const {
} }
//set values (inPlace) to mpe //set values (inPlace) to mpe
BOOST_FOREACH(Key j, frontals()) { for(Key j: frontals()) {
values[j] = mpe[j]; values[j] = mpe[j];
} }
} }

12
gtsam/discrete/DiscreteFactorGraph.cpp
View File

@ -41,7 +41,7 @@ namespace gtsam {
/* ************************************************************************* */ /* ************************************************************************* */
KeySet DiscreteFactorGraph::keys() const { KeySet DiscreteFactorGraph::keys() const {
KeySet keys; KeySet keys;
BOOST_FOREACH(const sharedFactor& factor, *this) for(const sharedFactor& factor: *this)
if (factor) keys.insert(factor->begin(), factor->end()); if (factor) keys.insert(factor->begin(), factor->end());
return keys; return keys;
} }
@ -49,7 +49,7 @@ namespace gtsam {
/* ************************************************************************* */ /* ************************************************************************* */
DecisionTreeFactor DiscreteFactorGraph::product() const { DecisionTreeFactor DiscreteFactorGraph::product() const {
DecisionTreeFactor result; DecisionTreeFactor result;
BOOST_FOREACH(const sharedFactor& factor, *this) for(const sharedFactor& factor: *this)
if (factor) result = (*factor) * result; if (factor) result = (*factor) * result;
return result; return result;
} }
@ -58,7 +58,7 @@ namespace gtsam {
double DiscreteFactorGraph::operator()( double DiscreteFactorGraph::operator()(
const DiscreteFactor::Values &values) const { const DiscreteFactor::Values &values) const {
double product = 1.0; double product = 1.0;
BOOST_FOREACH( const sharedFactor& factor, factors_ ) for( const sharedFactor& factor: factors_ )
product *= (*factor)(values); product *= (*factor)(values);
return product; return product;
} }
@ -78,7 +78,7 @@ namespace gtsam {
// /* ************************************************************************* */ // /* ************************************************************************* */
// void DiscreteFactorGraph::permuteWithInverse( // void DiscreteFactorGraph::permuteWithInverse(
// const Permutation& inversePermutation) { // const Permutation& inversePermutation) {
// BOOST_FOREACH(const sharedFactor& factor, factors_) { // for(const sharedFactor& factor: factors_) {
// if(factor) // if(factor)
// factor->permuteWithInverse(inversePermutation); // factor->permuteWithInverse(inversePermutation);
// } // }
@ -87,7 +87,7 @@ namespace gtsam {
// /* ************************************************************************* */ // /* ************************************************************************* */
// void DiscreteFactorGraph::reduceWithInverse( // void DiscreteFactorGraph::reduceWithInverse(
// const internal::Reduction& inverseReduction) { // const internal::Reduction& inverseReduction) {
// BOOST_FOREACH(const sharedFactor& factor, factors_) { // for(const sharedFactor& factor: factors_) {
// if(factor) // if(factor)
// factor->reduceWithInverse(inverseReduction); // factor->reduceWithInverse(inverseReduction);
// } // }
@ -107,7 +107,7 @@ namespace gtsam {
// PRODUCT: multiply all factors // PRODUCT: multiply all factors
gttic(product); gttic(product);
DecisionTreeFactor product; DecisionTreeFactor product;
BOOST_FOREACH(const DiscreteFactor::shared_ptr& factor, factors) for(const DiscreteFactor::shared_ptr& factor: factors)
product = (*factor) * product; product = (*factor) * product;
gttoc(product); gttoc(product);

5
gtsam/discrete/DiscreteKey.cpp
View File

@ -18,7 +18,6 @@
#include <iostream> #include <iostream>
#include <boost/format.hpp> // for key names #include <boost/format.hpp> // for key names
#include <boost/foreach.hpp> // FOREACH
#include "DiscreteKey.h" #include "DiscreteKey.h"
namespace gtsam { namespace gtsam {
@ -34,7 +33,7 @@ namespace gtsam {
vector<Key> DiscreteKeys::indices() const { vector<Key> DiscreteKeys::indices() const {
vector < Key > js; vector < Key > js;
BOOST_FOREACH(const DiscreteKey& key, *this) for(const DiscreteKey& key: *this)
js.push_back(key.first); js.push_back(key.first);
return js; return js;
} }
@ -42,7 +41,7 @@ namespace gtsam {
map<Key,size_t> DiscreteKeys::cardinalities() const { map<Key,size_t> DiscreteKeys::cardinalities() const {
map<Key,size_t> cs; map<Key,size_t> cs;
cs.insert(begin(),end()); cs.insert(begin(),end());
// BOOST_FOREACH(const DiscreteKey& key, *this) // for(const DiscreteKey& key: *this)
// cs.insert(key); // cs.insert(key);
return cs; return cs;
} }

6
gtsam/discrete/Potentials.cpp
View File

@ -54,7 +54,7 @@ namespace gtsam {
void Potentials::print(const string& s, void Potentials::print(const string& s,
const KeyFormatter& formatter) const { const KeyFormatter& formatter) const {
cout << s << "\n Cardinalities: "; cout << s << "\n Cardinalities: ";
BOOST_FOREACH(const DiscreteKey& key, cardinalities_) for(const DiscreteKey& key: cardinalities_)
cout << formatter(key.first) << "=" << formatter(key.second) << " "; cout << formatter(key.first) << "=" << formatter(key.second) << " ";
cout << endl; cout << endl;
ADT::print(" "); ADT::print(" ");
@ -68,11 +68,11 @@ namespace gtsam {
// map<Key, Key> ordering; // map<Key, Key> ordering;
// //
// // Get the original keys from cardinalities_ // // Get the original keys from cardinalities_
// BOOST_FOREACH(const DiscreteKey& key, cardinalities_) // for(const DiscreteKey& key: cardinalities_)
// keys & key; // keys & key;
// //
// // Perform Permutation // // Perform Permutation
// BOOST_FOREACH(DiscreteKey& key, keys) { // for(DiscreteKey& key: keys) {
// ordering[key.first] = remapping[key.first]; // ordering[key.first] = remapping[key.first];
// key.first = ordering[key.first]; // key.first = ordering[key.first];
// } // }

13
gtsam/discrete/Signature.cpp
View File

@ -17,7 +17,6 @@
*/ */
#include <sstream> #include <sstream>
#include <boost/foreach.hpp>
#include "Signature.h" #include "Signature.h"
@ -125,7 +124,7 @@ namespace gtsam {
DiscreteKeys Signature::discreteKeysParentsFirst() const { DiscreteKeys Signature::discreteKeysParentsFirst() const {
DiscreteKeys keys; DiscreteKeys keys;
BOOST_FOREACH(const DiscreteKey& key, parents_) for(const DiscreteKey& key: parents_)
keys.push_back(key); keys.push_back(key);
keys.push_back(key_); keys.push_back(key_);
return keys; return keys;
@ -134,7 +133,7 @@ namespace gtsam {
vector<Key> Signature::indices() const { vector<Key> Signature::indices() const {
vector<Key> js; vector<Key> js;
js.push_back(key_.first); js.push_back(key_.first);
BOOST_FOREACH(const DiscreteKey& key, parents_) for(const DiscreteKey& key: parents_)
js.push_back(key.first); js.push_back(key.first);
return js; return js;
} }
@ -142,8 +141,8 @@ namespace gtsam {
vector<double> Signature::cpt() const { vector<double> Signature::cpt() const {
vector<double> cpt; vector<double> cpt;
if (table_) { if (table_) {
BOOST_FOREACH(const Row& row, *table_) for(const Row& row: *table_)
BOOST_FOREACH(const double& x, row) for(const double& x: row)
cpt.push_back(x); cpt.push_back(x);
} }
return cpt; return cpt;
@ -171,7 +170,7 @@ namespace gtsam {
// qi::phrase_parse(f, l, parser::grammar.table, qi::space, table); // using full grammar // qi::phrase_parse(f, l, parser::grammar.table, qi::space, table); // using full grammar
parser::parse_table(spec, table); parser::parse_table(spec, table);
if (success) { if (success) {
BOOST_FOREACH(Row& row, table) for(Row& row: table)
normalize(row); normalize(row);
table_.reset(table); table_.reset(table);
} }
@ -180,7 +179,7 @@ namespace gtsam {
Signature& Signature::operator=(const Table& t) { Signature& Signature::operator=(const Table& t) {
Table table = t; Table table = t;
BOOST_FOREACH(Row& row, table) for(Row& row: table)
normalize(row); normalize(row);
table_.reset(table); table_.reset(table);
return *this; return *this;

5
gtsam/discrete/tests/testAlgebraicDecisionTree.cpp
View File

@ -25,7 +25,6 @@
#define DISABLE_TIMING #define DISABLE_TIMING
#include <boost/timer.hpp> #include <boost/timer.hpp>
#include <boost/foreach.hpp>
#include <boost/tokenizer.hpp> #include <boost/tokenizer.hpp>
#include <boost/assign/std/map.hpp> #include <boost/assign/std/map.hpp>
#include <boost/assign/std/vector.hpp> #include <boost/assign/std/vector.hpp>
@ -66,7 +65,7 @@ void dot(const T&f, const string& filename) {
typename DecisionTree<L, double>::Node::Ptr DecisionTree<L, double>::Choice::apply_fC_op_gL( typename DecisionTree<L, double>::Node::Ptr DecisionTree<L, double>::Choice::apply_fC_op_gL(
Cache& cache, const Leaf& gL, Mul op) const { Cache& cache, const Leaf& gL, Mul op) const {
Ptr h(new Choice(label(), cardinality())); Ptr h(new Choice(label(), cardinality()));
BOOST_FOREACH(const NodePtr& branch, branches_) for(const NodePtr& branch: branches_)
h->push_back(branch->apply_f_op_g(cache, gL, op)); h->push_back(branch->apply_f_op_g(cache, gL, op));
return Unique(cache, h); return Unique(cache, h);
} }
@ -401,7 +400,7 @@ TEST(ADT, constructor)
DiscreteKey z0(0,5), z1(1,4), z2(2,3), z3(3,2); DiscreteKey z0(0,5), z1(1,4), z2(2,3), z3(3,2);
vector<double> table(5 * 4 * 3 * 2); vector<double> table(5 * 4 * 3 * 2);
double x = 0; double x = 0;
BOOST_FOREACH(double& t, table) for(double& t: table)
t = x++; t = x++;
ADT f3(z0 & z1 & z2 & z3, table); ADT f3(z0 & z1 & z2 & z3, table);
Assignment<Key> assignment; Assignment<Key> assignment;

4
gtsam/discrete/tests/testDiscreteBayesTree.cpp
View File

@ -63,7 +63,7 @@
//// double evaluate(const DiscreteConditional::Values & values) { //// double evaluate(const DiscreteConditional::Values & values) {
//// double result = (*(this->conditional_))(values); //// double result = (*(this->conditional_))(values);
//// // evaluate all children and multiply into result //// // evaluate all children and multiply into result
//// BOOST_FOREACH(boost::shared_ptr<Clique> c, children_) //// for(boost::shared_ptr<Clique> c: children_)
//// result *= c->evaluate(values); //// result *= c->evaluate(values);
//// return result; //// return result;
//// } //// }
@ -213,7 +213,7 @@
// //
// // calculate all shortcuts to root // // calculate all shortcuts to root
// DiscreteBayesTree::Nodes cliques = bayesTree.nodes(); // DiscreteBayesTree::Nodes cliques = bayesTree.nodes();
// BOOST_FOREACH(Clique::shared_ptr c, cliques) { // for(Clique::shared_ptr c: cliques) {
// DiscreteBayesNet shortcut = c->shortcut(R, EliminateDiscrete); // DiscreteBayesNet shortcut = c->shortcut(R, EliminateDiscrete);
// if (debug) { // if (debug) {
// c->printSignature(); // c->printSignature();

4
gtsam/discrete/tests/testDiscreteFactorGraph.cpp
View File

@ -321,7 +321,7 @@ struct Graph2: public std::list<Factor2> {
/** Add a factor graph*/ /** Add a factor graph*/
// void operator +=(const Graph2& graph) { // void operator +=(const Graph2& graph) {
// BOOST_FOREACH(const Factor2& f, graph) // for(const Factor2& f: graph)
// push_back(f); // push_back(f);
// } // }
friend std::ostream& operator <<(std::ostream &os, const Graph2& graph); friend std::ostream& operator <<(std::ostream &os, const Graph2& graph);
@ -334,7 +334,7 @@ friend std::ostream& operator <<(std::ostream &os, const Graph2& graph);
// return graph; // return graph;
//} //}
std::ostream& operator <<(std::ostream &os, const Graph2& graph) { std::ostream& operator <<(std::ostream &os, const Graph2& graph) {
BOOST_FOREACH(const Factor2& f, graph) for(const Factor2& f: graph)
os << f << endl; os << f << endl;
return os; return os;
} }

6
gtsam/geometry/Pose2.cpp
View File

@ -19,8 +19,6 @@
#include <gtsam/base/Testable.h> #include <gtsam/base/Testable.h>
#include <gtsam/base/concepts.h> #include <gtsam/base/concepts.h>
#include <boost/foreach.hpp>
#include <cmath> #include <cmath>
#include <iostream> #include <iostream>
#include <iomanip> #include <iomanip>
@ -314,7 +312,7 @@ boost::optional<Pose2> align(const vector<Point2Pair>& pairs) {
// calculate centroids // calculate centroids
Point2 cp,cq; Point2 cp,cq;
BOOST_FOREACH(const Point2Pair& pair, pairs) { for(const Point2Pair& pair: pairs) {
cp += pair.first; cp += pair.first;
cq += pair.second; cq += pair.second;
} }
@ -323,7 +321,7 @@ boost::optional<Pose2> align(const vector<Point2Pair>& pairs) {
// calculate cos and sin // calculate cos and sin
double c=0,s=0; double c=0,s=0;
BOOST_FOREACH(const Point2Pair& pair, pairs) { for(const Point2Pair& pair: pairs) {
Point2 dq = pair.first - cp; Point2 dq = pair.first - cp;
Point2 dp = pair.second - cq; Point2 dp = pair.second - cq;
c += dp.x() * dq.x() + dp.y() * dq.y(); c += dp.x() * dq.x() + dp.y() * dq.y();

3
gtsam/geometry/Pose3.cpp
View File

@ -19,7 +19,6 @@
#include <gtsam/geometry/concepts.h> #include <gtsam/geometry/concepts.h>
#include <gtsam/base/concepts.h> #include <gtsam/base/concepts.h>
#include <boost/foreach.hpp>
#include <iostream> #include <iostream>
#include <cmath> #include <cmath>
@ -424,7 +423,7 @@ boost::optional<Pose3> Pose3::Align(const std::vector<Point3Pair>& abPointPairs)
boost::optional<Pose3> align(const vector<Point3Pair>& baPointPairs) { boost::optional<Pose3> align(const vector<Point3Pair>& baPointPairs) {
vector<Point3Pair> abPointPairs; vector<Point3Pair> abPointPairs;
BOOST_FOREACH (const Point3Pair& baPair, baPointPairs) { for (const Point3Pair& baPair: baPointPairs) {
abPointPairs.push_back(make_pair(baPair.second, baPair.first)); abPointPairs.push_back(make_pair(baPair.second, baPair.first));
} }
return Pose3::Align(abPointPairs); return Pose3::Align(abPointPairs);

3
gtsam/geometry/tests/testUnit3.cpp
View File

@ -33,7 +33,6 @@
#include <CppUnitLite/TestHarness.h> #include <CppUnitLite/TestHarness.h>
#include <boost/bind.hpp> #include <boost/bind.hpp>
#include <boost/foreach.hpp>
#include <boost/random.hpp> #include <boost/random.hpp>
#include <boost/assign/std/vector.hpp> #include <boost/assign/std/vector.hpp>
#include <cmath> #include <cmath>
@ -56,7 +55,7 @@ TEST(Unit3, point3) {
ps += Point3(1, 0, 0), Point3(0, 1, 0), Point3(0, 0, 1), Point3(1, 1, 0) ps += Point3(1, 0, 0), Point3(0, 1, 0), Point3(0, 0, 1), Point3(1, 1, 0)
/ sqrt(2.0); / sqrt(2.0);
Matrix actualH, expectedH; Matrix actualH, expectedH;
BOOST_FOREACH(Point3 p,ps) { for(Point3 p: ps) {
Unit3 s(p); Unit3 s(p);
expectedH = numericalDerivative11<Point3, Unit3>(point3_, s); expectedH = numericalDerivative11<Point3, Unit3>(point3_, s);
EXPECT(assert_equal(p, s.point3(actualH), 1e-8)); EXPECT(assert_equal(p, s.point3(actualH), 1e-8));

10
gtsam/geometry/triangulation.h
View File

@ -237,7 +237,7 @@ Point3 triangulatePoint3(const std::vector<Pose3>& poses,
// construct projection matrices from poses & calibration // construct projection matrices from poses & calibration
std::vector<Matrix34> projection_matrices; std::vector<Matrix34> projection_matrices;
CameraProjectionMatrix<CALIBRATION> createP(*sharedCal); // partially apply CameraProjectionMatrix<CALIBRATION> createP(*sharedCal); // partially apply
BOOST_FOREACH(const Pose3& pose, poses) for(const Pose3& pose: poses)
projection_matrices.push_back(createP(pose)); projection_matrices.push_back(createP(pose));
// Triangulate linearly // Triangulate linearly
@ -250,7 +250,7 @@ Point3 triangulatePoint3(const std::vector<Pose3>& poses,
#ifdef GTSAM_THROW_CHEIRALITY_EXCEPTION #ifdef GTSAM_THROW_CHEIRALITY_EXCEPTION
// verify that the triangulated point lies in front of all cameras // verify that the triangulated point lies in front of all cameras
BOOST_FOREACH(const Pose3& pose, poses) { for(const Pose3& pose: poses) {
const Point3& p_local = pose.transform_to(point); const Point3& p_local = pose.transform_to(point);
if (p_local.z() <= 0) if (p_local.z() <= 0)
throw(TriangulationCheiralityException()); throw(TriangulationCheiralityException());
@ -286,7 +286,7 @@ Point3 triangulatePoint3(
// construct projection matrices from poses & calibration // construct projection matrices from poses & calibration
std::vector<Matrix34> projection_matrices; std::vector<Matrix34> projection_matrices;
BOOST_FOREACH(const CAMERA& camera, cameras) for(const CAMERA& camera: cameras)
projection_matrices.push_back( projection_matrices.push_back(
CameraProjectionMatrix<typename CAMERA::CalibrationType>(camera.calibration())( CameraProjectionMatrix<typename CAMERA::CalibrationType>(camera.calibration())(
camera.pose())); camera.pose()));
@ -298,7 +298,7 @@ Point3 triangulatePoint3(
#ifdef GTSAM_THROW_CHEIRALITY_EXCEPTION #ifdef GTSAM_THROW_CHEIRALITY_EXCEPTION
// verify that the triangulated point lies in front of all cameras // verify that the triangulated point lies in front of all cameras
BOOST_FOREACH(const CAMERA& camera, cameras) { for(const CAMERA& camera: cameras) {
const Point3& p_local = camera.pose().transform_to(point); const Point3& p_local = camera.pose().transform_to(point);
if (p_local.z() <= 0) if (p_local.z() <= 0)
throw(TriangulationCheiralityException()); throw(TriangulationCheiralityException());
@ -454,7 +454,7 @@ TriangulationResult triangulateSafe(const std::vector<CAMERA>& cameras,
// Check landmark distance and re-projection errors to avoid outliers // Check landmark distance and re-projection errors to avoid outliers
size_t i = 0; size_t i = 0;
double totalReprojError = 0.0; double totalReprojError = 0.0;
BOOST_FOREACH(const CAMERA& camera, cameras) { for(const CAMERA& camera: cameras) {
const Pose3& pose = camera.pose(); const Pose3& pose = camera.pose();
if (params.landmarkDistanceThreshold > 0 if (params.landmarkDistanceThreshold > 0
&& distance(pose.translation(), point) && distance(pose.translation(), point)

2
gtsam/inference/BayesNet-inst.h
View File

@ -44,7 +44,7 @@ namespace gtsam {
typename CONDITIONAL::Frontals frontals = conditional->frontals(); typename CONDITIONAL::Frontals frontals = conditional->frontals();
Key me = frontals.front(); Key me = frontals.front();
typename CONDITIONAL::Parents parents = conditional->parents(); typename CONDITIONAL::Parents parents = conditional->parents();
BOOST_FOREACH(Key p, parents) for(Key p: parents)
of << keyFormatter(p) << "->" << keyFormatter(me) << std::endl; of << keyFormatter(p) << "->" << keyFormatter(me) << std::endl;
} }

43
gtsam/inference/BayesTree-inst.h
View File

@ -26,7 +26,6 @@
#include <gtsam/base/timing.h> #include <gtsam/base/timing.h>
#include <boost/optional.hpp> #include <boost/optional.hpp>
#include <boost/foreach.hpp>
#include <boost/assign/list_of.hpp> #include <boost/assign/list_of.hpp>
#include <fstream> #include <fstream>
@ -38,7 +37,7 @@ namespace gtsam {
template<class CLIQUE> template<class CLIQUE>
BayesTreeCliqueData BayesTree<CLIQUE>::getCliqueData() const { BayesTreeCliqueData BayesTree<CLIQUE>::getCliqueData() const {
BayesTreeCliqueData data; BayesTreeCliqueData data;
BOOST_FOREACH(const sharedClique& root, roots_) for(const sharedClique& root: roots_)
getCliqueData(data, root); getCliqueData(data, root);
return data; return data;
} }
@ -48,7 +47,7 @@ namespace gtsam {
void BayesTree<CLIQUE>::getCliqueData(BayesTreeCliqueData& data, sharedClique clique) const { void BayesTree<CLIQUE>::getCliqueData(BayesTreeCliqueData& data, sharedClique clique) const {
data.conditionalSizes.push_back(clique->conditional()->nrFrontals()); data.conditionalSizes.push_back(clique->conditional()->nrFrontals());
data.separatorSizes.push_back(clique->conditional()->nrParents()); data.separatorSizes.push_back(clique->conditional()->nrParents());
BOOST_FOREACH(sharedClique c, clique->children) { for(sharedClique c: clique->children) {
getCliqueData(data, c); getCliqueData(data, c);
} }
} }
@ -57,7 +56,7 @@ namespace gtsam {
template<class CLIQUE> template<class CLIQUE>
size_t BayesTree<CLIQUE>::numCachedSeparatorMarginals() const { size_t BayesTree<CLIQUE>::numCachedSeparatorMarginals() const {
size_t count = 0; size_t count = 0;
BOOST_FOREACH(const sharedClique& root, roots_) for(const sharedClique& root: roots_)
count += root->numCachedSeparatorMarginals(); count += root->numCachedSeparatorMarginals();
return count; return count;
} }
@ -68,7 +67,7 @@ namespace gtsam {
if (roots_.empty()) throw std::invalid_argument("the root of Bayes tree has not been initialized!"); if (roots_.empty()) throw std::invalid_argument("the root of Bayes tree has not been initialized!");
std::ofstream of(s.c_str()); std::ofstream of(s.c_str());
of<< "digraph G{\n"; of<< "digraph G{\n";
BOOST_FOREACH(const sharedClique& root, roots_) for(const sharedClique& root: roots_)
saveGraph(of, root, keyFormatter); saveGraph(of, root, keyFormatter);
of<<"}"; of<<"}";
of.close(); of.close();
@ -84,7 +83,7 @@ namespace gtsam {
std::string parent = out.str(); std::string parent = out.str();
parent += "[label=\""; parent += "[label=\"";
BOOST_FOREACH(Key index, clique->conditional_->frontals()) { for(Key index: clique->conditional_->frontals()) {
if(!first) parent += ","; first = false; if(!first) parent += ","; first = false;
parent += indexFormatter(index); parent += indexFormatter(index);
} }
@ -95,7 +94,7 @@ namespace gtsam {
} }
first = true; first = true;
BOOST_FOREACH(Key sep, clique->conditional_->parents()) { for(Key sep: clique->conditional_->parents()) {
if(!first) parent += ","; first = false; if(!first) parent += ","; first = false;
parent += indexFormatter(sep); parent += indexFormatter(sep);
} }
@ -103,7 +102,7 @@ namespace gtsam {
s << parent; s << parent;
parentnum = num; parentnum = num;
BOOST_FOREACH(sharedClique c, clique->children) { for(sharedClique c: clique->children) {
num++; num++;
saveGraph(s, c, indexFormatter, parentnum); saveGraph(s, c, indexFormatter, parentnum);
} }
@ -113,7 +112,7 @@ namespace gtsam {
template<class CLIQUE> template<class CLIQUE>
size_t BayesTree<CLIQUE>::size() const { size_t BayesTree<CLIQUE>::size() const {
size_t size = 0; size_t size = 0;
BOOST_FOREACH(const sharedClique& clique, roots_) for(const sharedClique& clique: roots_)
size += clique->treeSize(); size += clique->treeSize();
return size; return size;
} }
@ -121,7 +120,7 @@ namespace gtsam {
/* ************************************************************************* */ /* ************************************************************************* */
template<class CLIQUE> template<class CLIQUE>
void BayesTree<CLIQUE>::addClique(const sharedClique& clique, const sharedClique& parent_clique) { void BayesTree<CLIQUE>::addClique(const sharedClique& clique, const sharedClique& parent_clique) {
BOOST_FOREACH(Key j, clique->conditional()->frontals()) for(Key j: clique->conditional()->frontals())
nodes_[j] = clique; nodes_[j] = clique;
if (parent_clique != NULL) { if (parent_clique != NULL) {
clique->parent_ = parent_clique; clique->parent_ = parent_clique;
@ -189,7 +188,7 @@ namespace gtsam {
this->clear(); this->clear();
boost::shared_ptr<Clique> rootContainer = boost::make_shared<Clique>(); boost::shared_ptr<Clique> rootContainer = boost::make_shared<Clique>();
treeTraversal::DepthFirstForest(other, rootContainer, BayesTreeCloneForestVisitorPre<Clique>); treeTraversal::DepthFirstForest(other, rootContainer, BayesTreeCloneForestVisitorPre<Clique>);
BOOST_FOREACH(const sharedClique& root, rootContainer->children) { for(const sharedClique& root: rootContainer->children) {
root->parent_ = typename Clique::weak_ptr(); // Reset the parent since it's set to the dummy clique root->parent_ = typename Clique::weak_ptr(); // Reset the parent since it's set to the dummy clique
insertRoot(root); insertRoot(root);
} }
@ -234,13 +233,13 @@ namespace gtsam {
template<class CLIQUE> template<class CLIQUE>
void BayesTree<CLIQUE>::fillNodesIndex(const sharedClique& subtree) { void BayesTree<CLIQUE>::fillNodesIndex(const sharedClique& subtree) {
// Add each frontal variable of this root node // Add each frontal variable of this root node
BOOST_FOREACH(const Key& j, subtree->conditional()->frontals()) { for(const Key& j: subtree->conditional()->frontals()) {
bool inserted = nodes_.insert(std::make_pair(j, subtree)).second; bool inserted = nodes_.insert(std::make_pair(j, subtree)).second;
assert(inserted); (void)inserted; assert(inserted); (void)inserted;
} }
// Fill index for each child // Fill index for each child
typedef typename BayesTree<CLIQUE>::sharedClique sharedClique; typedef typename BayesTree<CLIQUE>::sharedClique sharedClique;
BOOST_FOREACH(const sharedClique& child, subtree->children) { for(const sharedClique& child: subtree->children) {
fillNodesIndex(child); } fillNodesIndex(child); }
} }
@ -345,7 +344,7 @@ namespace gtsam {
boost::shared_ptr<typename EliminationTraitsType::BayesTreeType> p_C1_B; { boost::shared_ptr<typename EliminationTraitsType::BayesTreeType> p_C1_B; {
FastVector<Key> C1_minus_B; { FastVector<Key> C1_minus_B; {
KeySet C1_minus_B_set(C1->conditional()->beginParents(), C1->conditional()->endParents()); KeySet C1_minus_B_set(C1->conditional()->beginParents(), C1->conditional()->endParents());
BOOST_FOREACH(const Key j, *B->conditional()) { for(const Key j: *B->conditional()) {
C1_minus_B_set.erase(j); } C1_minus_B_set.erase(j); }
C1_minus_B.assign(C1_minus_B_set.begin(), C1_minus_B_set.end()); C1_minus_B.assign(C1_minus_B_set.begin(), C1_minus_B_set.end());
} }
@ -357,7 +356,7 @@ namespace gtsam {
boost::shared_ptr<typename EliminationTraitsType::BayesTreeType> p_C2_B; { boost::shared_ptr<typename EliminationTraitsType::BayesTreeType> p_C2_B; {
FastVector<Key> C2_minus_B; { FastVector<Key> C2_minus_B; {
KeySet C2_minus_B_set(C2->conditional()->beginParents(), C2->conditional()->endParents()); KeySet C2_minus_B_set(C2->conditional()->beginParents(), C2->conditional()->endParents());
BOOST_FOREACH(const Key j, *B->conditional()) { for(const Key j: *B->conditional()) {
C2_minus_B_set.erase(j); } C2_minus_B_set.erase(j); }
C2_minus_B.assign(C2_minus_B_set.begin(), C2_minus_B_set.end()); C2_minus_B.assign(C2_minus_B_set.begin(), C2_minus_B_set.end());
} }
@ -403,7 +402,7 @@ namespace gtsam {
/* ************************************************************************* */ /* ************************************************************************* */
template<class CLIQUE> template<class CLIQUE>
void BayesTree<CLIQUE>::deleteCachedShortcuts() { void BayesTree<CLIQUE>::deleteCachedShortcuts() {
BOOST_FOREACH(const sharedClique& root, roots_) { for(const sharedClique& root: roots_) {
root->deleteCachedShortcuts(); root->deleteCachedShortcuts();
} }
} }
@ -424,10 +423,10 @@ namespace gtsam {
} }
// orphan my children // orphan my children
BOOST_FOREACH(sharedClique child, clique->children) for(sharedClique child: clique->children)
child->parent_ = typename Clique::weak_ptr(); child->parent_ = typename Clique::weak_ptr();
BOOST_FOREACH(Key j, clique->conditional()->frontals()) { for(Key j: clique->conditional()->frontals()) {
nodes_.unsafe_erase(j); nodes_.unsafe_erase(j);
} }
} }
@ -462,7 +461,7 @@ namespace gtsam {
void BayesTree<CLIQUE>::removeTop(const FastVector<Key>& keys, BayesNetType& bn, Cliques& orphans) void BayesTree<CLIQUE>::removeTop(const FastVector<Key>& keys, BayesNetType& bn, Cliques& orphans)
{ {
// process each key of the new factor // process each key of the new factor
BOOST_FOREACH(const Key& j, keys) for(const Key& j: keys)
{ {
// get the clique // get the clique
// TODO: Nodes will be searched again in removeClique // TODO: Nodes will be searched again in removeClique
@ -475,7 +474,7 @@ namespace gtsam {
// Delete cachedShortcuts for each orphan subtree // Delete cachedShortcuts for each orphan subtree
//TODO: Consider Improving //TODO: Consider Improving
BOOST_FOREACH(sharedClique& orphan, orphans) for(sharedClique& orphan: orphans)
orphan->deleteCachedShortcuts(); orphan->deleteCachedShortcuts();
} }
@ -499,14 +498,14 @@ namespace gtsam {
for(typename Cliques::iterator clique = cliques.begin(); clique != cliques.end(); ++clique) for(typename Cliques::iterator clique = cliques.begin(); clique != cliques.end(); ++clique)
{ {
// Add children // Add children
BOOST_FOREACH(const sharedClique& child, (*clique)->children) { for(const sharedClique& child: (*clique)->children) {
cliques.push_back(child); } cliques.push_back(child); }
// Delete cached shortcuts // Delete cached shortcuts
(*clique)->deleteCachedShortcutsNonRecursive(); (*clique)->deleteCachedShortcutsNonRecursive();
// Remove this node from the nodes index // Remove this node from the nodes index
BOOST_FOREACH(Key j, (*clique)->conditional()->frontals()) { for(Key j: (*clique)->conditional()->frontals()) {
nodes_.unsafe_erase(j); } nodes_.unsafe_erase(j); }
// Erase the parent and children pointers // Erase the parent and children pointers

5
gtsam/inference/BayesTree.cpp
View File

@ -20,7 +20,6 @@
#include <gtsam/inference/BayesTree.h> #include <gtsam/inference/BayesTree.h>
#include <boost/foreach.hpp>
#include <iostream> #include <iostream>
namespace gtsam { namespace gtsam {
@ -41,7 +40,7 @@ BayesTreeCliqueStats BayesTreeCliqueData::getStats() const
double sum = 0.0; double sum = 0.0;
size_t max = 0; size_t max = 0;
BOOST_FOREACH(size_t s, conditionalSizes) { for(size_t s: conditionalSizes) {
sum += (double)s; sum += (double)s;
if(s > max) max = s; if(s > max) max = s;
} }
@ -50,7 +49,7 @@ BayesTreeCliqueStats BayesTreeCliqueData::getStats() const
sum = 0.0; sum = 0.0;
max = 1; max = 1;
BOOST_FOREACH(size_t s, separatorSizes) { for(size_t s: separatorSizes) {
sum += (double)s; sum += (double)s;
if(s > max) max = s; if(s > max) max = s;
} }

7
gtsam/inference/BayesTreeCliqueBase-inst.h
View File

@ -18,7 +18,6 @@
#include <gtsam/inference/BayesTreeCliqueBase.h> #include <gtsam/inference/BayesTreeCliqueBase.h>
#include <gtsam/base/timing.h> #include <gtsam/base/timing.h>
#include <boost/foreach.hpp>
namespace gtsam { namespace gtsam {
@ -83,7 +82,7 @@ namespace gtsam {
template<class DERIVED, class FACTORGRAPH> template<class DERIVED, class FACTORGRAPH>
size_t BayesTreeCliqueBase<DERIVED, FACTORGRAPH>::treeSize() const { size_t BayesTreeCliqueBase<DERIVED, FACTORGRAPH>::treeSize() const {
size_t size = 1; size_t size = 1;
BOOST_FOREACH(const derived_ptr& child, children) for(const derived_ptr& child: children)
size += child->treeSize(); size += child->treeSize();
return size; return size;
} }
@ -96,7 +95,7 @@ namespace gtsam {
return 0; return 0;
size_t subtree_count = 1; size_t subtree_count = 1;
BOOST_FOREACH(const derived_ptr& child, children) for(const derived_ptr& child: children)
subtree_count += child->numCachedSeparatorMarginals(); subtree_count += child->numCachedSeparatorMarginals();
return subtree_count; return subtree_count;
@ -204,7 +203,7 @@ namespace gtsam {
// root are also generated. So, if this clique's cached shortcut is set, // root are also generated. So, if this clique's cached shortcut is set,
// recursively call over all child cliques. Otherwise, it is unnecessary. // recursively call over all child cliques. Otherwise, it is unnecessary.
if (cachedSeparatorMarginal_) { if (cachedSeparatorMarginal_) {
BOOST_FOREACH(derived_ptr& child, children) { for(derived_ptr& child: children) {
child->deleteCachedShortcuts(); child->deleteCachedShortcuts();
} }

11
gtsam/inference/ClusterTree-inst.h
View File

@ -13,7 +13,6 @@
#include <gtsam/base/timing.h> #include <gtsam/base/timing.h>
#include <gtsam/base/treeTraversal-inst.h> #include <gtsam/base/treeTraversal-inst.h>
#include <boost/foreach.hpp>
#include <boost/bind.hpp> #include <boost/bind.hpp>
namespace gtsam { namespace gtsam {
@ -87,7 +86,7 @@ struct EliminationData {
gatheredFactors += myData.childFactors; gatheredFactors += myData.childFactors;
// Check for Bayes tree orphan subtrees, and add them to our children // Check for Bayes tree orphan subtrees, and add them to our children
BOOST_FOREACH(const sharedFactor& f, node->factors) { for(const sharedFactor& f: node->factors) {
if (const BayesTreeOrphanWrapper<BTNode>* asSubtree = if (const BayesTreeOrphanWrapper<BTNode>* asSubtree =
dynamic_cast<const BayesTreeOrphanWrapper<BTNode>*>(f.get())) { dynamic_cast<const BayesTreeOrphanWrapper<BTNode>*>(f.get())) {
myData.bayesTreeNode->children.push_back(asSubtree->clique); myData.bayesTreeNode->children.push_back(asSubtree->clique);
@ -107,7 +106,7 @@ struct EliminationData {
// Fill nodes index - we do this here instead of calling insertRoot at the end to avoid // Fill nodes index - we do this here instead of calling insertRoot at the end to avoid
// putting orphan subtrees in the index - they'll already be in the index of the ISAM2 // putting orphan subtrees in the index - they'll already be in the index of the ISAM2
// object they're added to. // object they're added to.
BOOST_FOREACH(const Key& j, myData.bayesTreeNode->conditional()->frontals()) for(const Key& j: myData.bayesTreeNode->conditional()->frontals())
nodesIndex_.insert(std::make_pair(j, myData.bayesTreeNode)); nodesIndex_.insert(std::make_pair(j, myData.bayesTreeNode));
// Store remaining factor in parent's gathered factors // Store remaining factor in parent's gathered factors
@ -138,7 +137,7 @@ void ClusterTree<BAYESTREE, GRAPH>::Cluster::mergeChildren(
size_t nrNewChildren = 0; size_t nrNewChildren = 0;
// Loop over children // Loop over children
size_t i = 0; size_t i = 0;
BOOST_FOREACH(const sharedNode& child, children) { for(const sharedNode& child: children) {
if (merge[i]) { if (merge[i]) {
nrKeys += child->orderedFrontalKeys.size(); nrKeys += child->orderedFrontalKeys.size();
nrFactors += child->factors.size(); nrFactors += child->factors.size();
@ -155,7 +154,7 @@ void ClusterTree<BAYESTREE, GRAPH>::Cluster::mergeChildren(
typename Node::Children newChildren; typename Node::Children newChildren;
newChildren.reserve(nrNewChildren); newChildren.reserve(nrNewChildren);
i = 0; i = 0;
BOOST_FOREACH(const sharedNode& child, children) { for(const sharedNode& child: children) {
if (merge[i]) { if (merge[i]) {
// Merge keys. For efficiency, we add keys in reverse order at end, calling reverse after.. // Merge keys. For efficiency, we add keys in reverse order at end, calling reverse after..
orderedFrontalKeys.insert(orderedFrontalKeys.end(), orderedFrontalKeys.insert(orderedFrontalKeys.end(),
@ -228,7 +227,7 @@ std::pair<boost::shared_ptr<BAYESTREE>, boost::shared_ptr<GRAPH> > ClusterTree<
remaining->reserve( remaining->reserve(
remainingFactors_.size() + rootsContainer.childFactors.size()); remainingFactors_.size() + rootsContainer.childFactors.size());
remaining->push_back(remainingFactors_.begin(), remainingFactors_.end()); remaining->push_back(remainingFactors_.begin(), remainingFactors_.end());
BOOST_FOREACH(const sharedFactor& factor, rootsContainer.childFactors) { for(const sharedFactor& factor: rootsContainer.childFactors) {
if (factor) if (factor)
remaining->push_back(factor); remaining->push_back(factor);
} }

5
gtsam/inference/Conditional-inst.h
View File

@ -18,7 +18,6 @@
// \callgraph // \callgraph
#pragma once #pragma once
#include <boost/foreach.hpp>
#include <iostream> #include <iostream>
#include <gtsam/inference/Conditional.h> #include <gtsam/inference/Conditional.h>
@ -29,11 +28,11 @@ namespace gtsam {
template<class FACTOR, class DERIVEDFACTOR> template<class FACTOR, class DERIVEDFACTOR>
void Conditional<FACTOR,DERIVEDFACTOR>::print(const std::string& s, const KeyFormatter& formatter) const { void Conditional<FACTOR,DERIVEDFACTOR>::print(const std::string& s, const KeyFormatter& formatter) const {
std::cout << s << " P("; std::cout << s << " P(";
BOOST_FOREACH(Key key, frontals()) for(Key key: frontals())
std::cout << " " << formatter(key); std::cout << " " << formatter(key);
if (nrParents() > 0) if (nrParents() > 0)
std::cout << " |"; std::cout << " |";
BOOST_FOREACH(Key parent, parents()) for(Key parent: parents())
std::cout << " " << formatter(parent); std::cout << " " << formatter(parent);
std::cout << ")" << std::endl; std::cout << ")" << std::endl;
} }

21
gtsam/inference/EliminationTree-inst.h
View File

@ -17,7 +17,6 @@
*/ */
#pragma once #pragma once
#include <boost/foreach.hpp>
#include <boost/make_shared.hpp> #include <boost/make_shared.hpp>
#include <boost/bind.hpp> #include <boost/bind.hpp>
#include <stack> #include <stack>
@ -66,7 +65,7 @@ namespace gtsam {
const std::string& str, const KeyFormatter& keyFormatter) const const std::string& str, const KeyFormatter& keyFormatter) const
{ {
std::cout << str << "(" << keyFormatter(key) << ")\n"; std::cout << str << "(" << keyFormatter(key) << ")\n";
BOOST_FOREACH(const sharedFactor& factor, factors) { for(const sharedFactor& factor: factors) {
if(factor) if(factor)
factor->print(str); factor->print(str);
else else
@ -107,7 +106,7 @@ namespace gtsam {
// for row i \in Struct[A*j] do // for row i \in Struct[A*j] do
node->children.reserve(factors.size()); node->children.reserve(factors.size());
node->factors.reserve(factors.size()); node->factors.reserve(factors.size());
BOOST_FOREACH(const size_t i, factors) { for(const size_t i: factors) {
// If we already hit a variable in this factor, make the subtree containing the previous // If we already hit a variable in this factor, make the subtree containing the previous
// variable in this factor a child of the current node. This means that the variables // variable in this factor a child of the current node. This means that the variables
// eliminated earlier in the factor depend on the later variables in the factor. If we // eliminated earlier in the factor depend on the later variables in the factor. If we
@ -222,15 +221,15 @@ namespace gtsam {
// Add roots in sorted order // Add roots in sorted order
{ {
FastMap<Key,sharedNode> keys; FastMap<Key,sharedNode> keys;
BOOST_FOREACH(const sharedNode& root, this->roots_) { keys.insert(std::make_pair(root->key, root)); } for(const sharedNode& root: this->roots_) { keys.insert(std::make_pair(root->key, root)); }
typedef typename FastMap<Key,sharedNode>::value_type Key_Node; typedef typename FastMap<Key,sharedNode>::value_type Key_Node;
BOOST_FOREACH(const Key_Node& key_node, keys) { stack1.push(key_node.second); } for(const Key_Node& key_node: keys) { stack1.push(key_node.second); }
} }
{ {
FastMap<Key,sharedNode> keys; FastMap<Key,sharedNode> keys;
BOOST_FOREACH(const sharedNode& root, expected.roots_) { keys.insert(std::make_pair(root->key, root)); } for(const sharedNode& root: expected.roots_) { keys.insert(std::make_pair(root->key, root)); }
typedef typename FastMap<Key,sharedNode>::value_type Key_Node; typedef typename FastMap<Key,sharedNode>::value_type Key_Node;
BOOST_FOREACH(const Key_Node& key_node, keys) { stack2.push(key_node.second); } for(const Key_Node& key_node: keys) { stack2.push(key_node.second); }
} }
// Traverse, adding children in sorted order // Traverse, adding children in sorted order
@ -262,15 +261,15 @@ namespace gtsam {
// Add children in sorted order // Add children in sorted order
{ {
FastMap<Key,sharedNode> keys; FastMap<Key,sharedNode> keys;
BOOST_FOREACH(const sharedNode& node, node1->children) { keys.insert(std::make_pair(node->key, node)); } for(const sharedNode& node: node1->children) { keys.insert(std::make_pair(node->key, node)); }
typedef typename FastMap<Key,sharedNode>::value_type Key_Node; typedef typename FastMap<Key,sharedNode>::value_type Key_Node;
BOOST_FOREACH(const Key_Node& key_node, keys) { stack1.push(key_node.second); } for(const Key_Node& key_node: keys) { stack1.push(key_node.second); }
} }
{ {
FastMap<Key,sharedNode> keys; FastMap<Key,sharedNode> keys;
BOOST_FOREACH(const sharedNode& node, node2->children) { keys.insert(std::make_pair(node->key, node)); } for(const sharedNode& node: node2->children) { keys.insert(std::make_pair(node->key, node)); }
typedef typename FastMap<Key,sharedNode>::value_type Key_Node; typedef typename FastMap<Key,sharedNode>::value_type Key_Node;
BOOST_FOREACH(const Key_Node& key_node, keys) { stack2.push(key_node.second); } for(const Key_Node& key_node: keys) { stack2.push(key_node.second); }
} }
} }

5
gtsam/inference/Factor.cpp
View File

@ -19,7 +19,6 @@
// \callgraph // \callgraph
#include <boost/foreach.hpp>
#include <iostream> #include <iostream>
#include <gtsam/inference/Factor.h> #include <gtsam/inference/Factor.h>
@ -35,7 +34,7 @@ namespace gtsam {
/* ************************************************************************* */ /* ************************************************************************* */
void Factor::printKeys(const std::string& s, const KeyFormatter& formatter) const { void Factor::printKeys(const std::string& s, const KeyFormatter& formatter) const {
std::cout << s << " "; std::cout << s << " ";
BOOST_FOREACH(Key key, keys_) std::cout << " " << formatter(key); for(Key key: keys_) std::cout << " " << formatter(key);
std::cout << std::endl; std::cout << std::endl;
} }
@ -44,4 +43,4 @@ namespace gtsam {
return keys_ == other.keys_; return keys_ == other.keys_;
} }
} }

2
gtsam/inference/ISAM-inst.h
View File

@ -39,7 +39,7 @@ namespace gtsam {
factors += newFactors; factors += newFactors;
// Add the orphaned subtrees // Add the orphaned subtrees
BOOST_FOREACH(const sharedClique& orphan, orphans) for(const sharedClique& orphan: orphans)
factors += boost::make_shared<BayesTreeOrphanWrapper<Clique> >(orphan); factors += boost::make_shared<BayesTreeOrphanWrapper<Clique> >(orphan);
// eliminate into a Bayes net // eliminate into a Bayes net

2
gtsam/inference/JunctionTree-inst.h
View File

@ -105,7 +105,7 @@ struct ConstructorTraversalData {
// decide which children to merge, as index into children // decide which children to merge, as index into children
std::vector<bool> merge(nrChildren, false); std::vector<bool> merge(nrChildren, false);
size_t myNrFrontals = 1, i = 0; size_t myNrFrontals = 1, i = 0;
BOOST_FOREACH(const sharedNode& child, node->children) { for(const sharedNode& child: node->children) {
// Check if we should merge the i^th child // Check if we should merge the i^th child
if (myNrParents + myNrFrontals == childConditionals[i]->nrParents()) { if (myNrParents + myNrFrontals == childConditionals[i]->nrParents()) {
// Increment number of frontal variables // Increment number of frontal variables

3
gtsam/inference/Key.cpp
View File

@ -20,7 +20,6 @@
#include <gtsam/inference/Key.h> #include <gtsam/inference/Key.h>
#include <gtsam/inference/LabeledSymbol.h> #include <gtsam/inference/LabeledSymbol.h>
#include <boost/foreach.hpp>
#include <boost/lexical_cast.hpp> #include <boost/lexical_cast.hpp>
#include <iostream> #include <iostream>
@ -63,7 +62,7 @@ static void Print(const CONTAINER& keys, const string& s,
if (keys.empty()) if (keys.empty())
cout << "(none)" << endl; cout << "(none)" << endl;
else { else {
BOOST_FOREACH(const Key& key, keys) for(const Key& key: keys)
cout << keyFormatter(key) << " "; cout << keyFormatter(key) << " ";
cout << endl; cout << endl;
} }

7
gtsam/inference/MetisIndex-inl.h
View File

@ -17,7 +17,6 @@
#pragma once #pragma once
#include <boost/foreach.hpp>
#include <map> #include <map>
#include <vector> #include <vector>
@ -42,7 +41,7 @@ void MetisIndex::augment(const FactorGraph<FACTOR>& factors) {
// key to integer mapping. This is referenced during the adjaceny step // key to integer mapping. This is referenced during the adjaceny step
for (size_t i = 0; i < factors.size(); i++) { for (size_t i = 0; i < factors.size(); i++) {
if (factors[i]) { if (factors[i]) {
BOOST_FOREACH(const Key& key, *factors[i]) { for(const Key& key: *factors[i]) {
keySet.insert(keySet.end(), key); // Keep a track of all unique keys keySet.insert(keySet.end(), key); // Keep a track of all unique keys
if (intKeyBMap_.left.find(key) == intKeyBMap_.left.end()) { if (intKeyBMap_.left.find(key) == intKeyBMap_.left.end()) {
intKeyBMap_.insert(bm_type::value_type(key, keyCounter)); intKeyBMap_.insert(bm_type::value_type(key, keyCounter));
@ -55,8 +54,8 @@ void MetisIndex::augment(const FactorGraph<FACTOR>& factors) {
// Create an adjacency mapping that stores the set of all adjacent keys for every key // Create an adjacency mapping that stores the set of all adjacent keys for every key
for (size_t i = 0; i < factors.size(); i++) { for (size_t i = 0; i < factors.size(); i++) {
if (factors[i]) { if (factors[i]) {
BOOST_FOREACH(const Key& k1, *factors[i]) for(const Key& k1: *factors[i])
BOOST_FOREACH(const Key& k2, *factors[i]) for(const Key& k2: *factors[i])
if (k1 != k2) { if (k1 != k2) {
// Store both in Key and int32_t format // Store both in Key and int32_t format
int i = intKeyBMap_.left.at(k1); int i = intKeyBMap_.left.at(k1);

4
gtsam/inference/VariableIndex-inl.h
View File

@ -34,7 +34,7 @@ void VariableIndex::augment(const FG& factors,
if (factors[i]) { if (factors[i]) {
const size_t globalI = const size_t globalI =
newFactorIndices ? (*newFactorIndices)[i] : nFactors_; newFactorIndices ? (*newFactorIndices)[i] : nFactors_;
BOOST_FOREACH(const Key key, *factors[i]) { for(const Key key: *factors[i]) {
index_[key].push_back(globalI); index_[key].push_back(globalI);
++nEntries_; ++nEntries_;
} }
@ -67,7 +67,7 @@ void VariableIndex::remove(ITERATOR firstFactor, ITERATOR lastFactor,
throw std::invalid_argument( throw std::invalid_argument(
"Internal error, requested inconsistent number of factor indices and factors in VariableIndex::remove"); "Internal error, requested inconsistent number of factor indices and factors in VariableIndex::remove");
if (factors[i]) { if (factors[i]) {
BOOST_FOREACH(Key j, *factors[i]) { for(Key j: *factors[i]) {
Factors& factorEntries = internalAt(j); Factors& factorEntries = internalAt(j);
Factors::iterator entry = std::find(factorEntries.begin(), Factors::iterator entry = std::find(factorEntries.begin(),
factorEntries.end(), *factorIndex); factorEntries.end(), *factorIndex);

8
gtsam/inference/VariableIndex.cpp
View File

@ -33,9 +33,9 @@ bool VariableIndex::equals(const VariableIndex& other, double tol) const {
void VariableIndex::print(const string& str, const KeyFormatter& keyFormatter) const { void VariableIndex::print(const string& str, const KeyFormatter& keyFormatter) const {
cout << str; cout << str;
cout << "nEntries = " << nEntries() << ", nFactors = " << nFactors() << "\n"; cout << "nEntries = " << nEntries() << ", nFactors = " << nFactors() << "\n";
BOOST_FOREACH(KeyMap::value_type key_factors, index_) { for(KeyMap::value_type key_factors: index_) {
cout << "var " << keyFormatter(key_factors.first) << ":"; cout << "var " << keyFormatter(key_factors.first) << ":";
BOOST_FOREACH(const size_t factor, key_factors.second) for(const size_t factor: key_factors.second)
cout << " " << factor; cout << " " << factor;
cout << "\n"; cout << "\n";
} }
@ -46,9 +46,9 @@ void VariableIndex::print(const string& str, const KeyFormatter& keyFormatter) c
void VariableIndex::outputMetisFormat(ostream& os) const { void VariableIndex::outputMetisFormat(ostream& os) const {
os << size() << " " << nFactors() << "\n"; os << size() << " " << nFactors() << "\n";
// run over variables, which will be hyper-edges. // run over variables, which will be hyper-edges.
BOOST_FOREACH(KeyMap::value_type key_factors, index_) { for(KeyMap::value_type key_factors: index_) {
// every variable is a hyper-edge covering its factors // every variable is a hyper-edge covering its factors
BOOST_FOREACH(const size_t factor, key_factors.second) for(const size_t factor: key_factors.second)
os << (factor+1) << " "; // base 1 os << (factor+1) << " "; // base 1
os << "\n"; os << "\n";
} }

5
gtsam/inference/VariableSlots.cpp
View File

@ -18,7 +18,6 @@
#include <gtsam/inference/VariableSlots.h> #include <gtsam/inference/VariableSlots.h>
#include <iostream> #include <iostream>
#include <boost/foreach.hpp>
using namespace std; using namespace std;
@ -33,12 +32,12 @@ void VariableSlots::print(const std::string& str) const {
else { else {
cout << str << "\n"; cout << str << "\n";
cout << "Var:\t"; cout << "Var:\t";
BOOST_FOREACH(const value_type& slot, *this) { cout << slot.first << "\t"; } for(const value_type& slot: *this) { cout << slot.first << "\t"; }
cout << "\n"; cout << "\n";
for(size_t i=0; i<this->begin()->second.size(); ++i) { for(size_t i=0; i<this->begin()->second.size(); ++i) {
cout << " \t"; cout << " \t";
BOOST_FOREACH(const value_type& slot, *this) { for(const value_type& slot: *this) {
if(slot.second[i] == Empty) if(slot.second[i] == Empty)
cout << "x" << "\t"; cout << "x" << "\t";
else else

5
gtsam/inference/VariableSlots.h
View File

@ -24,7 +24,6 @@
#include <gtsam/base/timing.h> #include <gtsam/base/timing.h>
#include <gtsam/base/Testable.h> #include <gtsam/base/Testable.h>
#include <boost/foreach.hpp>
#include <boost/tuple/tuple.hpp> #include <boost/tuple/tuple.hpp>
#include <iostream> #include <iostream>
@ -99,10 +98,10 @@ VariableSlots::VariableSlots(const FG& factorGraph)
// removed factors. The slot number is the max integer value if the // removed factors. The slot number is the max integer value if the
// factor does not involve that variable. // factor does not involve that variable.
size_t jointFactorPos = 0; size_t jointFactorPos = 0;
BOOST_FOREACH(const typename FG::sharedFactor& factor, factorGraph) { for(const typename FG::sharedFactor& factor: factorGraph) {
assert(factor); assert(factor);
size_t factorVarSlot = 0; size_t factorVarSlot = 0;
BOOST_FOREACH(const Key involvedVariable, *factor) { for(const Key involvedVariable: *factor) {
// Set the slot in this factor for this variable. If the // Set the slot in this factor for this variable. If the
// variable was not already discovered, create an array for it // variable was not already discovered, create an array for it
// that we'll fill with the slot indices for each factor that // that we'll fill with the slot indices for each factor that