utility.h

Go to the documentation of this file.

// Copyright (C) 2020  Philipp Basler, Margarete Mühlleitner and Jonas Müller
// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas
// Müller
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
#include <BSMPT/config.h>
#include <algorithm>
#include <functional>
#include <gsl/gsl_integration.h>
#include <iostream>
#include <numeric>
#include <random>
#include <string>
#include <unordered_map>
#include <vector>
 
#ifdef Boost_FOUND
#include <boost/version.hpp>
#if BOOST_VERSION >= 107200
#include <boost/math/interpolators/cardinal_cubic_b_spline.hpp>
#else
#include <boost/math/interpolators/cubic_b_spline.hpp>
#endif
#endif
 
namespace BSMPT
{
 
template <typename key, typename value>
std::unordered_map<value, key>
InvertMap(const std::unordered_map<key, value> &originalMap,
          const std::string &errorOnDuplicateValue)
{
  std::unordered_map<value, key> result;
  for (const auto &[orig_key, orig_value] : originalMap)
  {
    auto success = result.emplace(orig_value, orig_key);
    if (not success.second)
    {
      throw std::runtime_error(errorOnDuplicateValue);
    }
  }
 
  return result;
}
 
bool StringStartsWith(const std::string &str, const std::string &prefix);
 
bool StringEndsWith(const std::string &str, const std::string &suffix);
 
const std::string sep = "\t";
 
int factorial(const int &a);
 
template <typename T>
std::vector<T> push_back(std::vector<T> &a, const std::vector<T> &b)
{
  return a.insert(a.end(), b.begin(), b.end());
}
 
template <typename T> std::string vec_to_string(const std::vector<T> &vec)
{
  std::string res;
  bool first = true;
  for (const auto &el : vec)
  {
    if (not first)
    {
      res += sep + std::to_string(el);
    }
    else
    {
      res   = std::to_string(el);
      first = false;
    }
  }
  return res;
}
 
std::vector<std::string> split(const std::string &str, char delimiter);
 
template <typename T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &vec)
{
  bool first = true;
  for (const auto &el : vec)
  {
    if (not first)
    {
      os << sep;
    }
    else
    {
      first = false;
    }
    os << el;
  }
  return os;
}
 
template <typename T>
std::vector<T> operator+(const std::vector<T> &a, const std::vector<T> &b)
{
  if (a.size() != b.size())
    throw std::runtime_error(
        "Vector cannot be added. Must have the same size.");
  std::vector<T> result;
  result.reserve(a.size());
 
  std::transform(a.begin(),
                 a.end(),
                 b.begin(),
                 std::back_inserter(result),
                 std::plus<T>());
  return result;
}
 
template <typename T>
std::vector<T> operator-(const std::vector<T> &a, const std::vector<T> &b)
{
  if (a.size() != b.size())
    throw("Vector cannot be subtracted. Must have the same size.");
 
  std::vector<T> result;
  result.reserve(a.size());
 
  std::transform(a.begin(),
                 a.end(),
                 b.begin(),
                 std::back_inserter(result),
                 std::minus<T>());
  return result;
}
 
template <typename T, typename T2>
std::vector<T> operator*(const T2 &a, const std::vector<T> &b)
{
  std::vector<T> result;
  result.reserve(b.size());
 
  std::transform(b.begin(),
                 b.end(),
                 std::back_inserter(result),
                 [&a](T i) { return a * i; });
  return result;
}
 
template <typename T, typename T2>
std::vector<T> operator/(const std::vector<T> &a, const T2 &b)
{
  std::vector<T> result;
  result.reserve(a.size());
 
  std::transform(a.begin(),
                 a.end(),
                 std::back_inserter(result),
                 [&b](T i) { return i / b; });
  return result;
}
 
template <typename T>
T operator*(const std::vector<T> &a, const std::vector<T> &b)
{
  if (a.size() != b.size())
    throw(
        "Dot product between vectors cannot be done. Must have the same size.");
 
  std::vector<T> result;
  result.reserve(a.size());
 
  std::transform(a.begin(),
                 a.end(),
                 b.begin(),
                 std::back_inserter(result),
                 [](T i, T j) { return (i * j); });
 
  T result1 = std::accumulate(result.begin(), result.end(), 0.0);
 
  return result1;
}
 
template <typename T>
std::vector<T> operator*(const std::vector<std::vector<T>> &a,
                         const std::vector<T> &b)
{
  if (a.size() != b.size())
    throw("Multiplication of matrix with vector cannot be done. Must have the "
          "same size.");
 
  std::vector<T> result;
  result.reserve(a.size());
 
  std::transform(a.begin(),
                 a.end(),
                 std::back_inserter(result),
                 [&](std::vector<T> i) { return (i * b); });
 
  return result;
}
 
template <typename T>
std::vector<T> flatten(std::vector<std::vector<T>> const &vec)
{
  std::vector<T> flattened;
  for (auto const &v : vec)
  {
    flattened.insert(flattened.end(), v.begin(), v.end());
  }
  return flattened;
}
 
double L2NormVector(const std::vector<double> &vec);
 
std::vector<std::vector<double>>
Transpose(const std::vector<std::vector<double>> &A);
 
double Li2(const double &x);
 
double EllipIntSecond(const double &x);
 
#ifdef Boost_FOUND
#if BOOST_VERSION >= 107200
template <typename T>
using boost_cubic_b_spline =
    boost::math::interpolators::cardinal_cubic_b_spline<T>;
#else
template <typename T>
using boost_cubic_b_spline = boost::math::cubic_b_spline<T>;
#endif
#endif
 
} // namespace BSMPT