100 lines
2.4 KiB
C++
100 lines
2.4 KiB
C++
#ifndef EXTENDED_ALGORITHMS_H
|
|
#define EXTENDED_ALGORITHMS_H
|
|
|
|
#include <algorithm>
|
|
#include <functional>
|
|
#include <utility>
|
|
#include <type_traits>
|
|
#include <array>
|
|
#include <vector>
|
|
#include <numeric>
|
|
#include <cstring>
|
|
|
|
#if defined(FASTOR_UNIX_OS)
|
|
#include <sys/resource.h>
|
|
#endif
|
|
|
|
namespace Fastor {
|
|
|
|
// Implementation of STL iota to work on other types such as
|
|
// std::complex. For std::complex iota_impl increments the real
|
|
// part only
|
|
template<class ForwardIt, class T>
|
|
inline void iota_impl(ForwardIt first, ForwardIt last, T value)
|
|
{
|
|
while(first != last) {
|
|
*first++ = value;
|
|
value += T(1);
|
|
}
|
|
}
|
|
|
|
template <typename T, size_t N>
|
|
inline std::array<int,N> argsort(const std::array<T,N> &v) {
|
|
std::array<int,N> idx;
|
|
std::iota(idx.begin(),idx.end(),0);
|
|
std::sort(idx.begin(), idx.end(), [&v](int i1, int i2) {return v[i1] < v[i2];});
|
|
return idx;
|
|
}
|
|
|
|
|
|
template<typename T, size_t N, typename std::enable_if<std::is_arithmetic<T>::value,bool>::type = 0>
|
|
inline std::string itoa(const std::array<T,N>& arr) {
|
|
std::string out = std::to_string(arr[0]);
|
|
for (size_t i=1; i<N; ++i)
|
|
out += ","+std::to_string(arr[i]);
|
|
return out;
|
|
}
|
|
|
|
|
|
#if defined(FASTOR_UNIX_OS)
|
|
inline size_t set_stack_size(size_t size) {
|
|
// If the function does not work, copy-paste it within
|
|
// the body of the main
|
|
|
|
// size is stack size in MB (for instance provide 80 for 80MB)
|
|
// returns old stack size in MB
|
|
const rlim_t stacksize = size*1024*1024;
|
|
struct rlimit rl;
|
|
int result;
|
|
result = getrlimit(RLIMIT_STACK, &rl);
|
|
rlim_t old = rl.rlim_cur = stacksize;
|
|
if (result==0) {
|
|
if (rl.rlim_cur < stacksize) {
|
|
rl.rlim_cur = stacksize;
|
|
result = setrlimit(RLIMIT_STACK,&rl);
|
|
FASTOR_ASSERT(result !=0, "CHANGING STACK SIZE FAILED");
|
|
}
|
|
}
|
|
|
|
return old;
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
// Get sign of a number
|
|
template <typename T>
|
|
inline constexpr int signum(T x, [[gnu::unused]] std::false_type is_signed) {
|
|
return T(0) < x;
|
|
}
|
|
template <typename T>
|
|
inline constexpr int signum(T x, [[gnu::unused]] std::true_type is_signed) {
|
|
return (T(0) < x) - (x < T(0));
|
|
}
|
|
template <typename T>
|
|
inline constexpr int signum(T x) {
|
|
return signum(x, std::is_signed<T>());
|
|
}
|
|
|
|
// Get a string +/- based on sign
|
|
template <typename T> std::string signum_string(T val) {
|
|
return signum(val) == 1 ? "+" : "-";
|
|
}
|
|
|
|
|
|
} // end of namespace Fastor
|
|
|
|
|
|
#endif // EXTENDED_ALGORITHMS_H
|
|
|