Miscellaneous.h

Go to the documentation of this file.

#pragma once

#include <memory>
#include <chrono>
#include <array> 

#include "Numerics.h"


// From https://stackoverflow.com/questions/478898/how-to-execute-a-command-and-get-output-of-command-within-c-using-posix
std::string system_exec(const char* cmd) {
    std::array<char, 1024> buffer;
    std::string result;
    std::unique_ptr<FILE, decltype(&pclose)> pipe(popen(cmd, "r"), pclose);
    if (!pipe) {
        throw std::runtime_error("popen() failed!");
    }
    while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
        result += buffer.data();
    }
    return result;
}


// Python-like pass statements

#define pass ((void)0)

template <typename T>
void UNUSED(const T& x) {}


// Hash combination from https://stackoverflow.com/questions/2590677/how-do-i-combine-hash-values-in-c0x
inline void hash_combine(std::size_t& seed) { }

template <typename T, typename... Rest>
inline void hash_combine(std::size_t& seed, const T& v, Rest... rest) {
    
    std::hash<T> hasher;
    seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);
    hash_combine(seed, rest...);
}


template<typename M>
typename M::mapped_type get(const M& m, const typename M::key_type& key, const typename M::mapped_type& def) {
    if(m.contains(key)) return m.at(key);
    else                return def;
}



//https://stackoverflow.com/questions/13830158/check-if-a-variable-is-iterable
template <typename T, typename = void>
struct is_iterable : std::false_type {};

// this gets used only when we can call std::begin() and std::end() on that type
template <typename T>
struct is_iterable<T, std::void_t<decltype(std::begin(std::declval<T>())),
                                  decltype(std::end(std::declval<T>()))
                                 >
                  > : std::true_type {};

// Here is a helper:
template <typename T>
constexpr bool is_iterable_v = is_iterable<T>::value;



// from https://stackoverflow.com/questions/42258608/c-constexpr-values-for-types
template <class T, class Tuple> 
struct TypeIndex;

template <class T, class... Types>
struct TypeIndex<T, std::tuple<T, Types...>> {
    static const size_t value = 0;
};

template <class T, class U, class... Types>
struct TypeIndex<T, std::tuple<U, Types...>> {
    static const size_t value = 1 + TypeIndex<T, std::tuple<Types...>>::value;
};


// * @brief Check if a type is contained in parameter pack
// * @return 
// */
template<typename X, typename... Ts>
constexpr bool contains_type() {
    return std::disjunction<std::is_same<X, Ts>...>::value;
}



//https://stackoverflow.com/questions/16337610/how-to-know-if-a-type-is-a-specialization-of-stdvector
template<typename Test, template<typename...> class Ref>
struct is_specialization : std::false_type {};

template<template<typename...> class Ref, typename... Args>
struct is_specialization<Ref<Args...>, Ref>: std::true_type {};



template<typename T> 
T mymin(T a) {
    return a; // if std::isnan(a) then we also return that
}

template<typename T, typename... Args> 
T mymin(T a, Args... args) {
    // if we are a nan, then remove
    if(std::isnan(a)) {
        return mymin(args...);
    }
    else {
        return std::min(a, mymin(args...));
    }
}