Replace boost with std library functionality (part 1)

src/Boundary/ConstantBoundary.cc

@@ -15,8 +15,6 @@
 #include "Boundary/ConstantBoundary.hh"
 #include "Boundary/ConstantBoundaryUtilities.hh"
 
-#include "boost/algorithm/string.hpp"
-
 using std::vector;
 using std::map;
 using std::string;

src/Boundary/InflowOutflowBoundary.cc

@@ -18,8 +18,7 @@
 #include "Boundary/InflowOutflowBoundary.hh"
 #include "Boundary/ConstantBoundaryUtilities.hh"
 
-#include "boost/lexical_cast.hpp"
-#include "boost/algorithm/string.hpp"
+#include <string>
 
 using std::vector;
 using std::map;
@@ -516,7 +515,7 @@ InflowOutflowBoundary<Dimension>::clearStoredValues() {
 template<typename Dimension>
 std::string
 InflowOutflowBoundary<Dimension>::label() const {
-  return "InflowOutflowBoundary" + boost::lexical_cast<std::string>(mBoundaryCount);
+  return "InflowOutflowBoundary" + std::to_string(mBoundaryCount);
 }
 
 //------------------------------------------------------------------------------

src/Boundary/ReflectingBoundary.hh

@@ -11,7 +11,6 @@
 #include "Boundary/Boundary.hh"
 #include "Boundary/PlanarBoundary.hh"
 #include "RK/RKCorrectionParams.hh"
-#include "boost/unordered_map.hpp"
 
 #include "Eigen/Sparse"
 
@@ -99,7 +98,7 @@ public:
 private:
   //--------------------------- Private Interface ---------------------------//
   Tensor mReflectOperator;
-  boost::unordered_map<RKOrder, std::pair<TransformationMatrix, TransformationMatrix>> mrkReflectOperators;
+  std::unordered_map<RKOrder, std::pair<TransformationMatrix, TransformationMatrix>> mrkReflectOperators;
 };
 
 }

src/Damage/IvanoviSALEDamageModel.cc

@@ -40,8 +40,6 @@
 #include "Utilities/allReduce.hh"
 #include "Utilities/uniform_random.hh"
 
-#include <boost/functional/hash.hpp>  // hash_combine
-
 #include <string>
 #include <vector>
 #include <algorithm>

src/DataBase/StateBase.cc

@@ -30,11 +30,11 @@ namespace Spheral {
 // //------------------------------------------------------------------------------
 // template<typename T>
 // T*
-// extractType(boost::any& anyT) {
+// extractType(std::any& anyT) {
 //   try {
-//     T* result = boost::any_cast<T*>(anyT);
+//     T* result = std::any_cast<T*>(anyT);
 //     return result;
-//   } catch (boost::any_cast_error) {
+//   } catch (std::any_cast_error) {
 //     return NULL;
 //   }
 // }
@@ -125,21 +125,21 @@ operator==(const StateBase<Dimension>& rhs) const {
        rhsItr != rhs.mStorage.end();
        ++rhsItr, ++lhsItr) {
     try {
-      auto lhsPtr = boost::any_cast<FieldBase<Dimension>*>(lhsItr->second);
-      auto rhsPtr = boost::any_cast<FieldBase<Dimension>*>(rhsItr->second);
+      auto lhsPtr = std::any_cast<FieldBase<Dimension>*>(lhsItr->second);
+      auto rhsPtr = std::any_cast<FieldBase<Dimension>*>(rhsItr->second);
       if (*lhsPtr != *rhsPtr) {
         cerr << "Fields for " << lhsItr->first <<  " don't match." << endl;
         result = false;
       }
-    } catch (const boost::bad_any_cast&) {
+    } catch (const std::bad_any_cast&) {
       try {
-        auto lhsPtr = boost::any_cast<vector<Vector>*>(lhsItr->second);
-        auto rhsPtr = boost::any_cast<vector<Vector>*>(rhsItr->second);
+        auto lhsPtr = std::any_cast<vector<Vector>*>(lhsItr->second);
+        auto rhsPtr = std::any_cast<vector<Vector>*>(rhsItr->second);
         if (*lhsPtr != *rhsPtr) {
           cerr << "vector<Vector> for " << lhsItr->first <<  " don't match." << endl;
           result = false;
         }
-      } catch (const boost::bad_any_cast&) {
+      } catch (const std::bad_any_cast&) {
         std::cerr << "StateBase::operator== WARNING: unable to compare values for " << lhsItr->first << "\n";
       }
     }
@@ -205,7 +205,7 @@ void
 StateBase<Dimension>::
 enroll(FieldBase<Dimension>& field) {
   const KeyType key = this->key(field);
-  boost::any fieldptr;
+  std::any fieldptr;
   fieldptr = &field;
   mStorage[key] = fieldptr;
   mNodeListPtrs.insert(field.nodeListPtr());
@@ -382,15 +382,15 @@ assign(const StateBase<Dimension>& rhs) {
     auto& anylhs = mStorage[itr->first];
     const auto& anyrhs = itr->second;
     try {
-      auto lhsptr = boost::any_cast<FieldBase<Dimension>*>(anylhs);
-      const auto rhsptr = boost::any_cast<FieldBase<Dimension>*>(anyrhs);
+      auto lhsptr = std::any_cast<FieldBase<Dimension>*>(anylhs);
+      const auto rhsptr = std::any_cast<FieldBase<Dimension>*>(anyrhs);
       *lhsptr = *rhsptr;
-    } catch(const boost::bad_any_cast&) {
+    } catch(const std::bad_any_cast&) {
       try {
-        auto lhsptr = boost::any_cast<vector<Vector>*>(anylhs);
-        const auto rhsptr = boost::any_cast<vector<Vector>*>(anyrhs);
+        auto lhsptr = std::any_cast<vector<Vector>*>(anylhs);
+        const auto rhsptr = std::any_cast<vector<Vector>*>(anyrhs);
         *lhsptr = *rhsptr;
-      } catch(const boost::bad_any_cast&) {
+      } catch(const std::bad_any_cast&) {
         // We'll assume other things don't need to be assigned...
         // VERIFY2(false, "StateBase::assign ERROR: unknown type for key " << itr->first << "\n");
       }
@@ -430,22 +430,22 @@ copyState() {
   for (auto itr = mStorage.begin();
        itr != mStorage.end();
        ++itr) {
-    boost::any anythingPtr = itr->second;
+    std::any anythingPtr = itr->second;
 
     // Is this a Field?
     try {
-      auto ptr = boost::any_cast<FieldBase<Dimension>*>(anythingPtr);
+      auto ptr = std::any_cast<FieldBase<Dimension>*>(anythingPtr);
       mFieldCache.push_back(ptr->clone());
       itr->second = mFieldCache.back().get();
 
-    } catch (const boost::bad_any_cast&) {
+    } catch (const std::bad_any_cast&) {
       try {
-        auto ptr = boost::any_cast<vector<Vector>*>(anythingPtr);
+        auto ptr = std::any_cast<vector<Vector>*>(anythingPtr);
         auto clone = std::shared_ptr<vector<Vector>>(new vector<Vector>(*ptr));
         mCache.push_back(clone);
         itr->second = clone.get();
 
-      } catch (const boost::bad_any_cast&) {
+      } catch (const std::bad_any_cast&) {
         // We'll assume other things don't need to be copied...
         // VERIFY2(false, "StateBase::copyState ERROR: unrecognized type for " << itr->first << "\n");
       }

src/DataBase/StateBase.hh

@@ -18,8 +18,7 @@
 
 #include "Field/FieldBase.hh"
 
-#include "boost/any.hpp"
-
+#include <any>
 #include <string>
 #include <utility>
 #include <memory>
@@ -162,9 +161,9 @@ public:
 
 protected:
   //--------------------------- Protected Interface ---------------------------//
-  typedef std::map<KeyType, boost::any> StorageType;
+  typedef std::map<KeyType, std::any> StorageType;
   typedef std::list<std::shared_ptr<FieldBase<Dimension>>> FieldCacheType;
-  typedef std::list<boost::any> CacheType;
+  typedef std::list<std::any> CacheType;
 
   // Protected data.
   StorageType mStorage;

src/DataBase/StateBaseInline.hh

@@ -36,7 +36,7 @@ allFields(const Value&) const {
        itr != mStorage.end();
        ++itr) {
     try {
-      Field<Dimension, Value>* ptr = dynamic_cast<Field<Dimension, Value>*>(boost::any_cast<FieldBase<Dimension>*>(itr->second));
+      Field<Dimension, Value>* ptr = dynamic_cast<Field<Dimension, Value>*>(std::any_cast<FieldBase<Dimension>*>(itr->second));
       if (ptr != 0) result.push_back(ptr);
     } catch (...) {
       // The field must have been the wrong type.
@@ -88,9 +88,9 @@ Value&
 StateBase<Dimension>::
 getAny(const typename StateBase<Dimension>::KeyType& key) const {
   try {
-    Value& result = *boost::any_cast<Value*>(mStorage.find(key)->second);
+    Value& result = *std::any_cast<Value*>(mStorage.find(key)->second);
     return result;
-  } catch (const boost::bad_any_cast&) {
+  } catch (const std::bad_any_cast&) {
     VERIFY2(false, "StateBase::getAny ERROR: unable to extract Value for " << key << "\n");
   }
 }

src/DataBase/StateDerivatives.cc

@@ -164,20 +164,20 @@ Zero() {
        ++itr) {
 
     try {
-      auto ptr = boost::any_cast<FieldBase<Dimension>*>(itr->second);
+      auto ptr = std::any_cast<FieldBase<Dimension>*>(itr->second);
       ptr->Zero();
 
-    } catch (const boost::bad_any_cast&) {
+    } catch (const std::bad_any_cast&) {
       try {
-        auto ptr = boost::any_cast<vector<Vector>*>(itr->second);
+        auto ptr = std::any_cast<vector<Vector>*>(itr->second);
         ptr->clear();
 
-      } catch (const boost::bad_any_cast&) {
+      } catch (const std::bad_any_cast&) {
         try {
-          auto ptr = boost::any_cast<vector<Scalar>*>(itr->second);
+          auto ptr = std::any_cast<vector<Scalar>*>(itr->second);
           ptr->clear();
 
-        } catch (const boost::bad_any_cast&) {
+        } catch (const std::bad_any_cast&) {
           VERIFY2(false, "StateDerivatives::Zero ERROR: unknown type for key " << itr->first << "\n");
         }
       }

src/Distributed/VoronoiRedistributeNodes.cc

@@ -47,8 +47,6 @@ using std::min;
 using std::max;
 using std::abs;
 
-#include <boost/assign.hpp>
-
 namespace Spheral {
 
 

src/FractalStruct/libs.hh

@@ -18,7 +18,6 @@
 #include <array>
 #include <utility>
 #include <sys/stat.h>
-#include <boost/random.hpp>
 #include "fftw3-mpi.h"
 #include "_hypre_utilities.h"
 #include "HYPRE_krylov.h"

src/Geometry/RankNTensorInline.hh

@@ -1,7 +1,6 @@
 #include <algorithm>
 #include <limits.h>
 #include <string>
-#include "boost/static_assert.hpp"
 
 #include "Utilities/SpheralFunctions.hh"
 #include "Utilities/DBC.hh"

src/Geometry/invertRankNTensor.cc

@@ -7,7 +7,6 @@
 
 #include <iostream>
 #include <algorithm>
-#include "boost/static_assert.hpp"
 #include <assert.h>
 #include "Eigen/Dense"
 

src/Gravity/Tree.hh

@@ -15,7 +15,7 @@
 
 #include <stdint.h>
 #include "boost/unordered_map.hpp"
-#include "boost/unordered_set.hpp"
+#include <unordered_set>
 
 namespace Spheral {
 
@@ -59,7 +59,7 @@ public:
   // Data types we use to build the internal tree structure.
   typedef uint32_t LevelKey;
   typedef std::pair<size_t, size_t> NodeID;
-  typedef boost::unordered_map<NodeID, std::vector<boost::unordered_set<CellKey> > > CompletedCellSet;
+  typedef boost::unordered_map<NodeID, std::vector<std::unordered_set<CellKey> > > CompletedCellSet;
   typedef boost::unordered_map<CellKey, Cell> TreeLevel;
 
   static unsigned num1dbits;                   // The number of bits we quantize 1D coordinates to.  We have to fit three of these in 64 bits.

src/Gravity/TreeGravity.cc

@@ -178,7 +178,7 @@ evaluateDerivatives(const typename Dimension::Scalar /*time*/,
   CompletedCellSet cellsCompleted;
   for (unsigned nodeListi = 0; nodeListi != mass.numFields(); ++nodeListi) {
     for (unsigned i = 0; i != mass[nodeListi]->numInternalElements(); ++i) {
-      cellsCompleted[NodeID(nodeListi, i)] = vector<boost::unordered_set<CellKey> >(num1dbits);
+      cellsCompleted[NodeID(nodeListi, i)] = vector<std::unordered_set<CellKey> >(num1dbits);
     }
   }
 

src/Gravity/TreeGravity.hh

@@ -13,7 +13,7 @@
 
 #include <stdint.h>
 #include "boost/unordered_map.hpp"
-#include "boost/unordered_set.hpp"
+#include <unordered_set>
 
 namespace Spheral {
 
@@ -132,7 +132,7 @@ private:
   typedef uint32_t LevelKey;
   typedef uint64_t CellKey;
   typedef std::pair<size_t, size_t> NodeID;
-  typedef boost::unordered_map<NodeID, std::vector<boost::unordered_set<CellKey> > > CompletedCellSet;
+  typedef boost::unordered_map<NodeID, std::vector<std::unordered_set<CellKey> > > CompletedCellSet;
 
   static unsigned num1dbits;                   // The number of bits we quantize 1D coordinates to.  We have to fit three of these in 64 bits.
   static CellKey max1dKey;                     // The maximum number of cells this corresponds to in a direction.

src/KernelIntegrator/BilinearIndex.hh

@@ -8,7 +8,6 @@
 
 #include <vector>
 #include <unordered_map>
-// #include <boost/functional/hash.hpp>
 #include "DataBase/DataBase.hh"
 #include "Field/FieldList.hh"
 
@@ -30,15 +29,13 @@ public:
   // Typedefs for bilinear indexing
   typedef typename std::pair<int, int> Pair;
   typedef typename std::unordered_map<Pair, int, BilinearHash<Pair>> MapPair;
-  // typedef typename std::unordered_map<Pair, int, boost::hash<Pair>> MapPair;
   typedef typename std::vector<Pair> VectorPair;
   typedef FieldList<Dimension, MapPair> PairToFlat;
   typedef FieldList<Dimension, VectorPair> FlatToPair;
 
   // Typedefs for surface indexing
   typedef typename std::array<int, Dimension::nDim> ArrayDim;
   typedef typename std::unordered_map<ArrayDim, int, BilinearHash<ArrayDim>> MapNormal;
-  // typedef typename std::unordered_map<ArrayDim, int, boost::hash<ArrayDim>> MapNormal;
   typedef typename std::vector<Vector> NormalType;
   typedef FieldList<Dimension, MapNormal> NormalToFlat;
   typedef FieldList<Dimension, NormalType> FlatToNormal;

src/Mesh/MeshConstructionUtilities.hh

@@ -235,7 +235,6 @@ collapseDegenerateVertices(const std::vector<Vector>& vertices,
                            const Vector& xmax,
                            const Vector& boxInv,
                            const Uint tol) {
-  using namespace boost;
   typedef std::tuple<Uint, Uint, Uint> Key;
   using std::vector;
   using std::set;
@@ -330,7 +329,6 @@ exchangeTuples(const std::vector<std::tuple<T, T, T> >& localKeys,
   CONTRACT_VAR(neighborDomains);
   CONTRACT_VAR(neighborKeys);
 #ifdef USE_MPI
-  using namespace boost;
   typedef std::tuple<T, T, T> Key;
   using std::vector;
 
@@ -395,7 +393,6 @@ exchangeTuples(const std::vector<std::tuple<T, T, T> >& localKeys,
   CONTRACT_VAR(sendIndices);
   CONTRACT_VAR(neighborKeys);
 #ifdef USE_MPI
-  using namespace boost;
   typedef std::tuple<T, T, T> Key;
 
   const unsigned numNeighborDomains = neighborDomains.size();
@@ -781,7 +778,6 @@ inline
 std::tuple<T, T, T, T, T, T>
 hashEdge(const std::tuple<T, T, T>& hashi,
          const std::tuple<T, T, T>& hashj) {
-  using namespace boost;
   return (hashi < hashj ? 
           std::make_tuple(std::get<0>(hashi), std::get<1>(hashi), std::get<2>(hashi),
                           std::get<0>(hashj), std::get<1>(hashj), std::get<2>(hashj)) :

src/Neighbor/NodePairList.hh

@@ -9,7 +9,6 @@
 #include <tuple>
 #include <functional>
 #include <iostream>
-// #include <boost/container_hash/hash.hpp>
 
 // These are based on what we get from size_t_bits
 #define MAX_NODE_INDEX (size_t(1u) << ((SIZE_T_BITS - 10)/2))
@@ -103,8 +102,6 @@ namespace std {
   struct hash<Spheral::NodePairIdxType> {
     size_t operator()(const Spheral::NodePairIdxType& x) const {
       return x.hash();
-      // boost::hash<std::tuple<int, int, int, int>> hasher;
-      // return hasher(std::make_tuple(x.i_node, x.i_list, x.j_node, x.j_list));
     }
   };
 } // namespace std

src/PYB11/Gravity/Tree.py

@@ -16,7 +16,7 @@ class Tree:
   typedef uint64_t CellKey;
   typedef uint32_t LevelKey;
   typedef std::pair<size_t, size_t> NodeID;
-  typedef boost::unordered_map<NodeID, std::vector<boost::unordered_set<CellKey> > > CompletedCellSet;
+  typedef boost::unordered_map<NodeID, std::vector<std::unordered_set<CellKey> > > CompletedCellSet;
 //  typedef boost::unordered_map<CellKey, Tree::Cell> TreeLevel;
 """
 

src/SolidMaterial/ANEOS.cc

@@ -14,7 +14,6 @@
 #include "Utilities/bisectRoot.hh"
 #include "Utilities/DBC.hh"
 
-#include "boost/multi_array.hpp"
 #include <iostream>
 #include <ctime>
 using std::vector;