CommonUtilities.hpp

Go to the documentation of this file.

// _LICENSE_HEADER_
//
// Copyright (C) 2019 - 2025.
// Terms register on the GPL-3.0 license.
//
// This file can be redistributed and/or modified under the license terms.
//
// See top level LICENSE file for more details.
//
// This file can be used citing references in CITATION.cff file.
 
#ifndef __GEDIM_UTILITIES_H
#define __GEDIM_UTILITIES_H
 
#include "IOUtilities.hpp"
#include <algorithm>
#include <numeric>
#include <random>
 
namespace Gedim
{
class Utilities
{
  public:
    template <class T> static void Unused(const T &)
    {
    }
 
    static unsigned int RandomSeed()
    {
        return static_cast<unsigned int>(time(nullptr));
    }
 
    static std::list<std::vector<int>> CombinationWithRepetition(int n, int k);
 
    template <class container> static void Shuffle(container &array, const unsigned int &seed = time(nullptr))
    {
        std::shuffle(array.begin(), array.end(), std::default_random_engine(seed));
    }
 
    static std::vector<unsigned int> RandomArrayNoRepetition(const unsigned int &n,
                                                             const unsigned int &maxNumber = RAND_MAX,
                                                             const unsigned int &seed = time(nullptr));
 
    template <typename T> static std::vector<unsigned int> SortArrayIndices(const std::vector<T> &array)
    {
        std::vector<unsigned int> indices(array.size());
        std::iota(begin(indices), end(indices), 0);
 
        std::sort(indices.begin(), indices.end(), [&array](int a, int b) { return (array.at(a) < array.at(b)); });
 
        return indices;
    }
 
    template <typename _InputIterator>
    static double Slope(_InputIterator x_begin, _InputIterator y_begin, const unsigned int &n)
    {
        const auto s_x = std::accumulate(x_begin, x_begin + n, 0.0);
        const auto s_y = std::accumulate(y_begin, y_begin + n, 0.0);
        const auto s_xx = std::inner_product(x_begin, x_begin + n, x_begin, 0.0);
        const auto s_xy = std::inner_product(x_begin, x_begin + n, y_begin, 0.0);
        return (n * s_xy - s_x * s_y) / (n * s_xx - s_x * s_x);
    }
 
    static double BinomialCoefficient(const unsigned int &n, const unsigned int &k)
    {
        // Base Case
        if (k > n)
            return 0;
 
        if (k == 0 || k == n)
            return 1;
 
        return BinomialCoefficient(n - 1, k - 1) + BinomialCoefficient(n - 1, k);
    }
 
    template <typename T> static T Union(const std::initializer_list<T> &arrays)
    {
        std::unordered_set<typename T::value_type> s;
 
        for (const auto &array : arrays)
            s.insert(array.begin(), array.end());
 
        return T(s.begin(), s.end());
    }
};
} // namespace Gedim
 
#endif // __GEDIM_UTILITIES_H