auxiliary.h

Go to the documentation of this file.

#pragma once
#include "average.h"
#include <nlohmann/json.hpp>
#include <ranges>
#include <functional>
#include <iterator>
#include <fstream>
#include <vector>
#include <string>
#include <sstream>
#include <concepts>

namespace Faunus {

template <std::integral TOut, std::floating_point TIn> inline TOut numeric_cast(const TIn number)
{
    if (std::isfinite(number)) {
        // The number is finite ...
        if (number < std::nextafter(static_cast<TIn>(std::numeric_limits<TOut>::max()), 0) &&
            number > std::nextafter(static_cast<TIn>(std::numeric_limits<TOut>::min()), 0)) {
            // ... and fits into the integral type range.
            // The nextafter function is used to mitigate possible rounding up or down.
            return static_cast<TOut>(number >= 0 ? number + TIn(0.5)
                                                 : number - TIn(0.5)); // round before cast
        }
    }
    // not-a-number, infinite, or outside the representable range
    throw std::overflow_error("numeric cast overflow");
}

template <std::forward_iterator Titer, typename Tfunction, typename T = double,
          typename Taggregate_function>
T for_each_unique_pair(Titer begin, Titer end, Tfunction f,
                       Taggregate_function aggregator = std::plus<T>())
{
    T x = T();
    for (auto i = begin; i != end; ++i) {
        for (auto j = i; ++j != end;) {
            x = aggregator(x, f(*i, *j));
        }
    }
    return x;
}

template <std::ranges::range T> T erase_range(T target, const T& values)
{
    target.erase(std::remove_if(target.begin(), target.end(),
                                [&](auto i) {
                                    return std::find(values.begin(), values.end(), i) !=
                                           values.end();
                                }),
                 target.end());
    return target;
}

template <class T> struct ordered_pair : public std::pair<T, T>
{
    using base = std::pair<T, T>;
    ordered_pair() = default;

    ordered_pair(const T& a, const T& b)
        : base(std::minmax(a, b))
    {
    }

    bool contains(const T& value) const { return value == base::first || value == base::second; }
};

template <std::floating_point T, std::integral Tint = int> Tint to_bin(T x, T dx = 1)
{
    return (x < 0) ? Tint(x / dx - 0.5) : Tint(x / dx + 0.5);
}

template <std::floating_point Tfloat = double> class Quantize
{
  private:
    Tfloat xmin, dx, x;

  public:
    Quantize(Tfloat dx, Tfloat xmin = 0)
        : xmin(xmin)
        , dx(dx)
    {
    }

    Quantize& operator=(Tfloat val)
    {
        assert(val >= xmin);
        if (val >= 0) {
            x = int(val / dx + 0.5) * dx;
        }
        else {
            x = int(val / dx - 0.5) * dx;
        }
        assert(x >= xmin);
        return *this;
    }

    Quantize& frombin(unsigned int i)
    {
        x = i * dx + xmin;
        return *this;
    }

    Quantize& operator()(Tfloat val)
    {
        *this = val;
        return *this;
    }

    template <typename T> operator T()
    {
        if (std::is_integral<T>::value) {
            return T((x - xmin) / dx + 0.5);
        }
        return x;
    }
};

template <class T>
concept StringStreamable = requires(T a) {
    { std::istringstream() >> a };
    { std::ostringstream() << a };
};

template <StringStreamable T> auto splitConvert(const std::string& words)
{
    auto stream = std::istringstream(words);
    return std::vector<T>(std::istream_iterator<T>(stream), std::istream_iterator<T>());
} // space separated string to vector of values

template <std::ranges::range Range>
std::string joinToString(const Range& values)
    requires StringStreamable<std::ranges::range_value_t<Range>>
{
    std::ostringstream o;
    if (!values.empty()) {
        o << *values.begin();
        std::for_each(std::next(values.begin()), values.end(), [&](auto& val) { o << " " << val; });
    }
    return o.str();
}

template <typename T> struct BasePointerVector
{
    using value_type = std::shared_ptr<T>;
    std::vector<value_type> vec; 

    auto begin() noexcept { return vec.begin(); }

    auto begin() const noexcept { return vec.begin(); }

    auto end() noexcept { return vec.end(); }

    auto end() const noexcept { return vec.end(); }

    auto empty() const noexcept { return vec.empty(); }

    auto size() const noexcept { return vec.size(); }

    auto& back() noexcept { return vec.back(); }

    auto& back() const noexcept { return vec.back(); }

    auto& front() noexcept { return vec.front(); }

    auto& front() const noexcept { return vec.front(); }

    auto& at(size_t n) { return vec.at(n); }

    auto& at(size_t n) const { return vec.at(n); }

    template <typename Tderived, class... Args,
              class = std::enable_if_t<std::is_base_of<T, Tderived>::value>>
    void emplace_back(Args&... args)
    {
        vec.push_back(std::make_shared<Tderived>(args...));
    } 

    template <typename Tderived, class... Args,
              class = std::enable_if_t<std::is_base_of<T, Tderived>::value>>
    void emplace_back(const Args&... args)
    {
        vec.push_back(std::make_shared<Tderived>(args...));
    } 

    //    template <typename Tderived, class Arg, class = std::enable_if_t<std::is_base_of<T,
    //    Tderived>::value>> auto& push_back(std::shared_ptr<Arg> arg) {
    //        vec.push_back(arg);
    //        return vec.back(); // reference to element just added
    //    }                      //!< Append a pointer to a (derived) instance to the vector

    auto& push_back(value_type arg)
    {
        vec.push_back(arg);
        return vec.back(); // reference to element just added
    } 

    template <typename Tderived, class = std::enable_if_t<std::is_base_of<T, Tderived>::value>>
    auto& operator=(const BasePointerVector<Tderived>& d)
    {
        vec.assign(d.vec.begin(), d.vec.end());
        return *this;
    } 

    template <typename Tderived, class = std::enable_if_t<std::is_base_of<T, Tderived>::value>>
    auto find() const
    {
        BasePointerVector<Tderived> _v;
        for (auto& base : vec) {
            if (auto derived = std::dynamic_pointer_cast<Tderived>(base); derived) {
                _v.push_back(derived);
            }
        }
        return _v;
    } 

    template <typename Tderived, class = std::enable_if_t<std::is_base_of<T, Tderived>::value>>
    std::shared_ptr<Tderived> findFirstOf() const
    {
        for (auto& base : vec) {
            if (auto derived = std::dynamic_pointer_cast<Tderived>(base); derived) {
                return derived;
            }
        }
        return nullptr;
    }

    template <typename U>
    friend void to_json(nlohmann::json&,
                        const BasePointerVector<U>&); 
}; 

template <typename T> void to_json(nlohmann::json& j, const BasePointerVector<T>& b)
{
    using namespace std::string_literals;
    try {
        for (auto& shared_ptr : b.vec) {
            j.push_back(*shared_ptr);
        }
    }
    catch (const std::exception& e) {
        throw std::runtime_error("error converting to json: "s + e.what());
    }
}

template <typename T> void from_json(const nlohmann::json& j, BasePointerVector<T>& b)
{
    using namespace std::string_literals;
    try {
        for (const auto& it : j) {
            std::shared_ptr<T> ptr = it;
            b.push_back(ptr);
        }
    }
    catch (const std::exception& e) {
        throw std::runtime_error("error converting from json: "s + e.what());
    }
}
} // namespace Faunus