commonUtils.hpp

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
 *
 *  bitpit
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of bitpit.
 *
 *  bitpit is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  bitpit is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
 *  License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with bitpit. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
#ifndef __BITPIT_COMMON_UTILS_HPP__
#define __BITPIT_COMMON_UTILS_HPP__
 
#include <array>
#include <algorithm>
#include <cfloat>
#include <cmath>
#include <functional>
#include <limits>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <map>
 
// Stringification macro
#define BITPIT_STR2(X) #X
#define BITPIT_STR(X) BITPIT_STR2(X)
 
// Macros to allow using oveload in preprocessing macro
#define BITPIT_CAT(A, B) A ## B
 
#define BITPIT_COUNT_ARGS_MAX6(_1, _2, _3, _4, _5, _6 /* ad nauseam */, COUNT, ...) COUNT
#define BITPIT_EXPAND_ARGS_FOR_COUNT(x) x
#define BITPIT_ARGS_SIZE(...) BITPIT_EXPAND_ARGS_FOR_COUNT(BITPIT_COUNT_ARGS_MAX6(__VA_ARGS__, 6, 5, 4, 3, 2, 1, 0))
 
#define BITPIT_SELECT_OVERLOAD(NAME, NUM) BITPIT_CAT(NAME ## _, NUM)
#define BITPIT_OVERLOAD_CALL(NAME, ...) BITPIT_SELECT_OVERLOAD(NAME, BITPIT_ARGS_SIZE(__VA_ARGS__))(__VA_ARGS__)
 
#define BITPIT_CREATE_WORKSPACE(workspace, item_type, size, stack_size) \
item_type *workspace;                                            \
std::array<item_type, stack_size> workspace##_stack;             \
std::unique_ptr<std::vector<item_type>> workspace##_heap;        \
if (size <= stack_size) {                                        \
    workspace = workspace##_stack.data();                        \
} else {                                                         \
    workspace##_heap = std::unique_ptr<std::vector<item_type>>(new std::vector<item_type>(size)); \
    workspace = workspace##_heap->data();                        \
}
 
namespace bitpit {
 
namespace utils {
 
template <typename T, typename Comparator = std::less<T> >
bool addToOrderedVector(const T &value, std::vector<T> &list, Comparator comparator = Comparator());
 
template <typename T, typename Comparator = std::less<T> >
typename std::vector<T>::const_iterator findInOrderedVector(const T &value, const std::vector<T> &list, Comparator comparator = Comparator());
 
template<typename T>
void reorderVector(std::vector<size_t>& order, std::vector<T>& v, std::size_t size);
 
template<typename OrderContainer, typename DataContainer>
void reorderContainer(OrderContainer &order, DataContainer &v, std::size_t size);
 
template<typename Container, typename Index>
void swapValue(Container &v, Index i, Index j);
 
template<>
void swapValue(std::vector<bool> &v, std::size_t i, std::size_t j);
 
template <class T>
void eraseValue(std::vector<T> &, const T&);
 
template <class T>
std::vector<T> intersectionVector(const std::vector<T>&, const std::vector<T>&);
 
#ifndef __BITPIT_COMMON_UTILS_SRC__
extern template bool addToOrderedVector<>(const long&, std::vector<long>&, std::less<long>);
extern template bool addToOrderedVector<>(const unsigned long&, std::vector<unsigned long>&, std::less<unsigned long>);
 
extern template std::vector<long>::const_iterator findInOrderedVector<>(const long&, const std::vector<long>&, std::less<long>);
extern template std::vector<unsigned long>::const_iterator findInOrderedVector<>(const unsigned long&, const std::vector<unsigned long>&, std::less<unsigned long>);
#endif
 
void extractWithoutReplacement(                                               // Extract integers without replacement
    int                         ,                                             // (input) number of integers to be extracted
    int                         ,                                             // (input) upper bound of extraction interval
    std::vector<int>           &                                              // (input/output) list of extracted value
);
 
std::size_t countDigits(int n);
 
unsigned long factorial(unsigned long n);
 
struct DoubleFloatingComparison
{
 
public:
    virtual ~DoubleFloatingComparison() = default;
 
protected:
    constexpr static const double DEFAULT_ABS_TOL = 10 * std::numeric_limits<double>::epsilon();
    constexpr static const double DEFAULT_REL_TOL = 10 * std::numeric_limits<double>::epsilon();
 
    DoubleFloatingComparison() = default;
 
};
 
struct DoubleFloatingEqual : public DoubleFloatingComparison
{
    bool operator()(double x, double y, double relativeTolerance = DEFAULT_REL_TOL, double absoluteTolerance = DEFAULT_ABS_TOL) const
    {
        // Check if the numbers are really close (needed when comparing
        // numbers near zero).
        double absoluteDifference = std::abs(x - y);
        if (absoluteDifference <= absoluteTolerance) {
            return true;
        }
 
        // Compare using a relative difference
        //
        // The check that is performed is:
        //
        //  abs(x - y) <= abs(x) * epsilon OR abs(x - y) <= abs(y) * epsilon
        //
        // The multiplication in the right side of inequalities may cause an
        // unwanted underflow condition. To prevent this, the difference is
        // scaled rather than epsilon.
        double relativeDifference = absoluteDifference / std::max(std::abs(x), std::abs(y));
 
        return (relativeDifference <= relativeTolerance);
    }
 
};
 
struct DoubleFloatingLess : public DoubleFloatingComparison
{
    bool operator()(double x, double y, double relativeTolerance = DEFAULT_REL_TOL, double absoluteTolerance = DEFAULT_ABS_TOL) const
    {
        if (x > y) {
            return false;
        }
 
        if (DoubleFloatingEqual()(x, y, relativeTolerance, absoluteTolerance)) {
            return false;
        }
 
        return true;
    }
 
};
 
struct DoubleFloatingLessEqual : public DoubleFloatingComparison
{
    bool operator()(double x, double y, double relativeTolerance = DEFAULT_REL_TOL, double absoluteTolerance = DEFAULT_ABS_TOL) const
    {
        if (x < y) {
            return true;
        }
 
        if (DoubleFloatingEqual()(x, y, relativeTolerance, absoluteTolerance)) {
            return true;
        }
 
        return false;
    }
 
};
 
struct DoubleFloatingGreater : public DoubleFloatingComparison
{
    bool operator()(double x, double y, double relativeTolerance = DEFAULT_REL_TOL, double absoluteTolerance = DEFAULT_ABS_TOL) const
    {
        if (x < y) {
            return false;
        }
 
        if (DoubleFloatingEqual()(x, y, relativeTolerance, absoluteTolerance)) {
            return false;
        }
 
        return true;
    }
 
};
 
struct DoubleFloatingGreaterEqual : public DoubleFloatingComparison
{
    bool operator()(double x, double y, double relativeTolerance = DEFAULT_REL_TOL, double absoluteTolerance = DEFAULT_ABS_TOL) const
    {
        if (x > y) {
            return true;
        }
 
        if (DoubleFloatingEqual()(x, y, relativeTolerance, absoluteTolerance)) {
            return true;
        }
 
        return false;
    }
 
};
 
}
 
}
 
// Template implementation
#include "commonUtils.tpp"
 
#endif