utilities.h

#ifndef UTILS_H
#define UTILS_H
 
#include <tuple>
#include <string>
#include <vector>
#include "eigen.h"
 
// returns the remainder of the division between two integers.
// Note: c++ defines the % operator such that: (a/b)*b + a%b == a    (for b!=0)
// this works as mod() in fortran or % in python when a and b are positive
// But the behavior is not the same for negative integers
// the function below can be used instead
int mod(const int &a, const int &b);
 
// returns -1 if val<0, 0 if val=0, and 1 if val>0
template<typename T> int sgn(T &val) {
    return (T(0) < val) - (val < T(0));
}
 
int compress3Indices(const int &i1, const int &i2, const int &i3,
        const int &size1, const int &size2, const int &size3);
 
std::tuple<int, int, int> decompress3Indices(const int &iTot,
        const int &size1, const int &size2, const int &size3);
 
int compress2Indices(const int &i1, const int &i2, const int &size1,
        const int &size2);
 
std::tuple<int, int> decompress2Indices(const int &iTot, const int &size1,
        const int &size2);
 
// helper to break up strings by commas and spaces
std::vector<std::string> tokenize(const std::string str);
 
// A function to allocate a dynamically sized array. It tricks the
// compiler into thinking the size is a constant via the const identifier
// on the argument. This resolves issues with VLAs -- see crystal.cpp
template <typename T> T* allocate(T *&array, const unsigned int size){
        array = new T [size];
        return array;
}
 
template<typename T, typename Parameter>
class NamedType {
public:
    explicit NamedType(T const &value) :
            value_(value) {
    }
    T& get() {
        return value_;
    }
    T const& get() const {
        return value_;
    }
private:
    T value_;
};
 
using CartIndex = NamedType<int, struct CartTag>;
 
using BteIndex = NamedType<int, struct BteTag>;
 
using TempIndex = NamedType<int, struct TempTag>;
using ChemPotIndex = NamedType<int, struct ChemPotTag>;
 
using WavevectorIndex = NamedType<int, struct WavevectorTag>;
 
using BandIndex = NamedType<int, struct BandTag>;
 
using StateIndex = NamedType<int, struct StateTag>;
 
std::tuple<double, double> memoryUsage();
 
template<typename Vector>
std::vector<Vector> splitVector(const Vector& v, unsigned chunkSize) {
  using Iterator = typename Vector::const_iterator;
  std::vector<Vector> vectorChunks;
  Iterator it = v.cbegin();
  const Iterator end = v.cend();
 
  while (it != end) {
    Vector v2;
    std::back_insert_iterator<Vector> inserter(v2);
    const auto num_to_copy = std::min(static_cast<unsigned>(
                                          std::distance(it, end)), chunkSize);
    std::copy(it, it + num_to_copy, inserter);
    vectorChunks.push_back(std::move(v2));
    std::advance(it, num_to_copy);
  }
 
  return vectorChunks;
}
 
double findMaxRelativeDifference(const Eigen::Tensor<double,3> &x,
                                 const Eigen::Tensor<double,3> &xRef);
 
std::vector<std::string> split(const std::string &s, char delimiter);
 
#endif