ahUtils.H

Go to the documentation of this file.

 
/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
#ifndef AHUTILS_H
#define AHUTILS_H
 
#include <sys/stat.h>
#include <cstdlib>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <memory>
#include <limits>
#ifndef _MSC_VER
#include <cxxabi.h>  // Itanium ABI demangling (GCC/Clang); absent on MSVC
#endif
#include <string>
#include <sstream>
#include <iostream>
#include <fstream>
#include <typeinfo>
#include <algorithm>
 
#include <ahFunction.H>
 
// build a string with the file name and line number
#define POSITION_TRACE (std::string(__FILE__) + ":" + std::to_string(__LINE__))
 
namespace Aleph {
template <class T, class Compare = Aleph::less<T>>
inline const T *median(const T &a, const T &b, const T &c, const Compare &cmp = Compare())
{
  if (cmp(a, b))
    {
      if (cmp(b, c))
        return &b;  // a < b < c
      if (cmp(a, c))
        return &c;  // a < c <= b
      return &a;    // c <= a < b
    }
  if (cmp(a, c))
    return &a;  // b <= a < c
  if (cmp(b, c))
    return &c;  // b < c <= a
  return &b;    // c <= b <= a
}
 
inline bool is_even(const long n)
{
  return n % 2 == 0;
}
 
inline bool is_odd(const long n)
{
  return not is_even(n);
}
 
inline char nibble_to_char(const int i)
{
  assert(i >= 0 and i <= 15);
 
  const char ret = i < 10 ? i + '0' : i - 10 + 'A';
 
  assert((ret >= '0' and ret <= '9') or (ret >= 'A' and ret <= 'F'));
 
  return ret;
}
 
inline int char_to_nibble(const char c)
{
  assert((c >= '0' and c <= '9') or (c >= 'A' and c <= 'F'));
 
  const int ret = c < 'A' ? c - '0' : c - 'A' + 10;
 
  assert(ret >= 0 and ret <= 15);
 
  return ret;
}
 
#define DERIVATE_ITERATOR(container_name, base_it_name, it_name)                                   \
  struct it_name : public base_it_name                                                             \
  {                                                                                                \
    it_name()                                                                                      \
    { /* empty */                                                                                  \
    }                                                                                              \
                                                                                                   \
    it_name(container_name &c) : base_it_name(c)                                                   \
    {                                                                                              \
      /* empty */                                                                                  \
    }                                                                                              \
                                                                                                   \
    it_name(const it_name &it) : base_it_name(it)                                                  \
    {                                                                                              \
      /* empty */                                                                                  \
    }                                                                                              \
                                                                                                   \
    it_name &operator = (const it_name &it)                                                        \
    {                                                                                              \
      return base_it_name::operator = (it);                                                        \
    }                                                                                              \
  };
 
extern bool resize_process_stack(size_t new_size);
 
inline size_t u_index(const size_t &i)
{
  return i >> 1;  // divide i entre 2
}
 
inline size_t l_index(const size_t i)
{
  return i << 1;
}
 
inline bool is_power_of_2(unsigned long x)
{
  return x && !(x & (x - 1UL));
}
 
inline unsigned long next_power_of_2(unsigned long x)
{
  if (is_power_of_2(x))
    return x;
 
  unsigned long ret = 1;
  while (ret < x)
    ret <<= 1;
 
  return ret;
}
 
inline std::string demangle(const char *name)
{
#ifdef _MSC_VER
  // MSVC's typeid().name() already returns a human-readable name
  // (e.g. "class Foo"); there is no cxxabi.h to demangle with.
  return name;
#else
  int status = -4;  // some arbitrary value to eliminate the compiler warning
  // enable c++11 by passing the flag -std=c++11 to g++
  std::unique_ptr<char, void (*)(void *)> res{abi::__cxa_demangle(name, nullptr, nullptr, &status),
                                              std::free};
  return (status == 0) ? res.get() : name;
#endif
}
 
#define CLASSNAME_TO_STRING(class_ptr) ::Aleph::demangle(typeid(*class_ptr).name())
 
inline void error_msg(const std::string &msg)
{
  std::cerr << msg << '\n';
  abort();
}
 
inline bool exists_file(const std::string &name)
{
  struct stat buffer;
  return (stat(name.c_str(), &buffer) == 0);
}
 
template <class C>
inline std::string Rvector(const std::string &name, const C &c)
{
  std::ostringstream s;
  s << name << " <- c(";
  auto last_ptr = &c.get_last();
  for (auto it = c.get_it(); it.has_curr(); it.next())
    {
      auto &v = it.get_curr();
      s << v;
      if (&v != last_ptr)
        s << ", ";
    }
  s << ")";
 
  return s.str();
}
 
template <class C>
inline std::string Rvector(const C &c)
{
  std::ostringstream s;
  s << c.get_first() << " <- c(";
  auto last_ptr = &c.get_last();
  for (auto it = c.get_it(1); it.has_curr(); it.next())
    {
      auto &v = it.get_curr();
      s << v;
      if (&v != last_ptr)
        s << ", ";
    }
  s << ")";
 
  return s.str();
}
 
inline double interpolate(const double x1,
                          const double x2,
                          const double y1,
                          const double y2,
                          const double x)
{
  assert(x2 > x1 and x <= x2 and x >= x1);
  return y1 + (y2 - y1) * (x - x1) / (x2 - x1);
}
 
inline double extrapolate_left(const double x1,
                               const double x2,
                               const double y1,
                               const double y2,
                               const double x)
{
  assert(x2 > x1 and x < x1);
  return y1 - (y2 - y1) * (x1 - x) / (x2 - x1);
}
 
inline double pow2(const double x)
{
  return x * x;
}
 
inline double pow3(const double x)
{
  return x * pow2(x);
}
 
inline double extrapolate_right(const double x1,
                                const double x2,
                                const double y1,
                                const double y2,
                                const double x)
{
  assert(x2 > x1 and x > x2);
  return y2 + (y2 - y1) * (x - x2) / (x2 - x1);
}
 
inline double next_value(const double val)
{
  // Store limit in a local to avoid preprocessor misparse of <double>
  // inside a macro argument (clang-cl on Windows treats < as arg separator).
  constexpr double lim = std::numeric_limits<double>::max();
  return std::nextafter(val, lim);
}
 
inline double prev_value(const double val)
{
  constexpr double lim = std::numeric_limits<double>::min();
  return std::nextafter(val, lim);
}
 
[[nodiscard]] constexpr bool are_near(const double v1, const double v2, const double e) noexcept
{
  // std::fabs is not constexpr in MSVC's STL under C++20 (it only became
  // constexpr in C++23), so compute the absolute difference by hand to keep
  // this function usable in constant expressions across all compilers.
  const double d = v1 - v2;
  return (d < 0.0 ? -d : d) <= e;
}
 
inline void execute_R_script(const std::string &scr, const std::string &file_name = "tmp.R")
{
  std::ofstream tmp(file_name);
  tmp << "#!/usr/bin/Rscript" << '\n'
      << '\n'
      << "X11()" << '\n'
      << scr << '\n'
      << "message(\"Press Return To Continue\")" << '\n'
      << "invisible(readLines(\"stdin\", n=1))" << '\n';
  const std::string cmd = "Rscript " + file_name;
  system(cmd.c_str());
}
 
inline bool is_normal_number(const double n)
{
  if constexpr (std::numeric_limits<double>::is_iec559 && sizeof(double) == sizeof(std::uint64_t))
    {
      // IEEE-754 bit inspection avoids fast-math assuming finiteness.
      std::uint64_t bits = 0;
      std::memcpy(&bits, &n, sizeof(bits));
 
      constexpr std::uint64_t exp_mask = 0x7ff0000000000000ULL;
      constexpr std::uint64_t frac_mask = 0x000fffffffffffffULL;
 
      const std::uint64_t exp = bits & exp_mask;
      const std::uint64_t frac = bits & frac_mask;
 
      if (exp == exp_mask)
        return false;
 
      if (exp == 0)
        return frac == 0;
 
      return true;
    }
 
  if (not std::isfinite(n))
    return false;
 
  const int status = std::fpclassify(n);
  return (status == FP_NORMAL or status == FP_ZERO);
}
}  // namespace Aleph
 
#endif  // AHUTILS_H