aux.hh

#ifndef LOCARNA_AUX_HH
#define LOCARNA_AUX_HH
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
 
#include <iostream>
#include <exception>
#include <string>
#include <vector>
#include <cassert>
 
 
#if __cplusplus < 201100L
#    define nullptr NULL
#endif
 
namespace std
{
    template <class T1, class T2>
    struct hash<std::pair<T1, T2>>
    {
        size_t
        operator()(const std::pair<T1, T2> &p) const
            noexcept(noexcept(hash<T1>()(p.first)) &&
                     noexcept(hash<T2>()(p.second))) {
            return hash<T1>()(p.first) ^ (hash<T2>()(p.second) << 1);
        }
    };
}
 
#include "quadmath.hh"
 
namespace LocARNA {
 
    using standard_pf_score_t = double;
    using extended_pf_score_t = long double;
 
#if defined(_GLIBCXX_USE_FLOAT128) && ! defined(__clang__)
    using quad_pf_score_t = __float128;
#else
    using quad_pf_score_t = long double;
#endif
 
    template <typename T>
    struct check_score_t {
        template<class CLP>
        check_score_t(const CLP &clp) {}
    };
 
    template <>
    struct check_score_t<extended_pf_score_t> {
        template <class CLP>
        check_score_t(const CLP &clp) {
            if (clp.verbose) {
                std::cout << "Use extended precision for partition functions ("
                          << sizeof(extended_pf_score_t) << " bytes; usually 80bit precision)."
                          <<std::endl;
            }
            if (!(sizeof(extended_pf_score_t) > sizeof(standard_pf_score_t))) {
                std::cerr << "WARNING: the extended precision type (long double) "
                          << "is not larger than the standard precision "
                          << "( double, "<<sizeof(standard_pf_score_t)<<" bytes )."
                          <<std::endl
                          << "This issue is system and compiler dependent."
                          <<std::endl;
            }
        }
    };
 
 
    // template <typename T, class CLP>
    // void
    // check_score_t(const CLP &clp) {}
 
    // template <class CLP>
    // void
    // check_score_t<extended_pf_score_t,CLP>(const CLP &clp) {
    //     if (clp.verbose) {
    //         std::cout << "Use extended precision for partition functions ("
    //                   << sizeof(extended_pf_score_t) << " bytes; usually 80bit precision)."
    //                   <<std::endl;
    //     }
    //     if (!(sizeof(extended_pf_score_t) > sizeof(standard_pf_score_t))) {
    //         std::cerr << "WARNING: the extended precision type (long double) "
    //                   << "is not larger than the standard precision "
    //                   << "( double, "<<sizeof(standard_pf_score_t)<<" bytes )."
    //                   <<std::endl
    //                   << "This issue is system and compiler dependent."
    //                   <<std::endl;
    //     }
    // }
 
#if defined( _GLIBCXX_USE_FLOAT128 ) && ! defined( __clang__ )
    template <>
    struct check_score_t<quad_pf_score_t> {
        template <class CLP>
        check_score_t(const CLP &clp) {
            if (clp.verbose) {
                std::cout << "Use quad precision for partition functions ("
                          << sizeof(quad_pf_score_t) << " bytes; 128bit precision)."
                          <<std::endl;
            }
            if (!(sizeof(quad_pf_score_t) > sizeof(standard_pf_score_t))) {
                std::cerr << "WARNING: the quad precision type (__float128) "
                          << "is not larger than the standard precision "
                          << "( double, "<<sizeof(standard_pf_score_t)<<" bytes )."
                          <<std::endl;
            }
        }
    };
#endif
 
 
    class string1;
 
    typedef size_t size_type;
 
    typedef size_type pos_type;
 
    // ------------------------------------------------------------
    // define gap codes and symbols
 
    enum class Gap {
        regular,
        loop,
        locality,
        other
    };
 
    bool
    is_gap_symbol(char c);
 
    char
    gap_symbol(Gap gap);
 
    char
    special_gap_symbol(Gap gap);
 
    Gap
    gap_code(char symbol);
    // ------------------------------------------------------------
 
    class failure : public std::exception {
        std::string msg_;
 
    public:
        explicit failure(const std::string &msg)
            : std::exception(), msg_(msg){};
 
        explicit failure() : std::exception(), msg_(){};
 
        virtual ~failure();
 
        virtual const char *
        what() const noexcept;
    };
 
    struct wrong_format_failure : public failure {
        wrong_format_failure() : failure("Wrong format") {}
    };
 
    struct syntax_error_failure : public failure {
        syntax_error_failure() : failure("Syntax error") {}
 
        explicit syntax_error_failure(const std::string &msg)
            : failure("Syntax error: " + msg) {}
    };
 
    constexpr
    inline double
    prob_exp_f(int seqlen) {
        return 1.0 / (2.0 * seqlen);
    }
 
    // ------------------------------------------------------------
    // transformation of strings
 
    void
    transform_toupper(std::string &s);
 
    void
    normalize_rna_sequence(std::string &seq);
 
    void
    split_at_separator(const std::string &s,
                       char sep,
                       std::vector<std::string> &v);
 
    std::vector<std::string>
    split_at_separator(const std::string &s, char sep);
 
    std::string
    concat_with_separator(const std::vector<std::string> &v, char sep);
 
    typedef double FLT_OR_DBL;
 
    constexpr
    inline bool
    frag_len_geq(size_t i, size_t j, size_t minlen) {
        return i + minlen <= j + 1;
    }
 
    constexpr
    inline size_t
    frag_len(size_t i, size_t j) {
        return j + 1 - i;
    }
 
    constexpr
    inline size_t
    bp_span(size_t i, size_t j) {
        return frag_len(i, j);
    }
 
    bool
    has_prefix(const std::string &s, const std::string &p, size_t start = 0);
 
    bool
    get_nonempty_line(std::istream &in, std::string &line);
 
    double
    sequence_identity(const string1 &seqA, const string1 &seqB);
 
    template <class Iterable, typename KeyFun>
    auto
    maximum(const Iterable&x, const KeyFun &key) {
        auto maxelem_it = max_element(x.begin(), x.end(),
                                      [&key](const auto &x, const auto &y) {
                                          return key(x) < key(y);
                                      });
        return key(*maxelem_it);
    }
 
    template <class Iterable, typename KeyFun>
    auto
    minimum(const Iterable&x, const KeyFun &key) {
        auto minelem_it = min_element(x.begin(), x.end(),
                                      [&key](const auto &x, const auto &y) {
                                          return key(x) < key(y);
                                      });
        return key(*minelem_it);
    }
 
    // @brief delay the evaluation of a function
    template <class Value, class Function>
    class Delay {
    public:
        Delay(Function fun)
            : fun_(fun), evaluated_(false)
        {};
 
        const Value &
        get() {
            if (!evaluated_) {
                val_ = fun_();
            }
            evaluated_ = true;
            return val_;
        }
 
    private:
        Value val_;
        Function fun_;
        bool evaluated_;
    };
 
    // @brief make object of Delay
    // @note work around partial specialization of functions
    template <class Value>
    class make_delay {
    public:
        template <class Function>
        static auto
        fun(Function fun_) {
            return Delay<Value, Function>(fun_);
        }
    };
 
 
}
 
#endif