utils.hpp

Go to the documentation of this file.

// Copyright (c) 2013-2018 Commissariat à l'énergie atomique et aux énergies alternatives (CEA)
// Copyright (c) 2013-2018 Centre national de la recherche scientifique (CNRS)
// Copyright (c) 2018-2023 Simons Foundation
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You may obtain a copy of the License at
//     https://www.gnu.org/licenses/gpl-3.0.txt
//
// Authors: Philipp Dumitrescu, Olivier Parcollet, Nils Wentzell

 
#pragma once
 
#include "./concepts.hpp"
#include "../utility/macros.hpp"
 
#include <nda/nda.hpp>
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <ranges>
#include <span>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace triqs::mesh {
 
  // Aliases and type definitions.
  using dcomplex = std::complex<double>;
  using all_t    = nda::range::all_t;
  using nda::array;
  using nda::array_view;
  using nda::ellipsis;
  using nda::eye;
  using nda::matrix;
  using nda::matrix_const_view;
  using nda::matrix_view;
  using nda::range;


  template <typename... Ts> [[nodiscard]] uint64_t hash(Ts &&...ts) { return (std::hash<std::decay_t<Ts>>()(std::forward<Ts>(ts)) + ...); }

  [[nodiscard]] C2PY_IGNORE inline std::size_t hash_bytes(std::span<std::byte const> bytes) {
    return std::hash<std::string_view>{}(std::string_view{reinterpret_cast<char const *>(bytes.data()), bytes.size()});
  }

  template <nda::MemoryArray R> [[nodiscard]] std::size_t hash_bytes(R const &r) {
    EXPECTS(r.is_contiguous());
    return hash_bytes(std::as_bytes(std::span{r.data(), static_cast<std::size_t>(r.size())}));
  }

  [[nodiscard]] C2PY_IGNORE inline long positive_modulo(long x, long y) {
    EXPECTS(y >= 0);
    long res = x % y;
    return (res >= 0 ? res : res + y);
  }

  template <MeshWithValues M> [[nodiscard]] auto values(M const &m) {
    auto res = nda::vector<typename M::value_t>(m.size());
    for (auto i : nda::range(m.size())) res(i) = m[i].value();
    return res;
  }

  template <Mesh M> [[nodiscard]] M copy(M const &m) { return m; }

  template <Mesh M> void copy_from(M &m1, M const &m2) { m1 = m2; }

  template <Mesh M> static constexpr bool is_product = false;

  template <Mesh M> static constexpr int n_variables = 1;

  enum statistic_enum { Boson = 0, Fermion = 1 };

  [[nodiscard]] C2PY_IGNORE inline int sign(statistic_enum s) { return (s == Boson ? 1 : -1); }

  [[nodiscard]] C2PY_IGNORE inline auto operator*(statistic_enum s1, statistic_enum s2) { return (s1 == s2 ? Boson : Fermion); }

  template <typename T> struct closest_mesh_point_t {
    T value;
  };

  template <typename... Ts> [[nodiscard]] auto closest_mesh_pt(Ts &&...ts) {
    if constexpr (sizeof...(Ts) == 1)
      return closest_mesh_point_t<std::decay_t<Ts>...>{std::forward<Ts>(ts)...};
    else
      return std::tuple{closest_mesh_point_t<std::decay_t<Ts>>{std::forward<Ts>(ts)}...};
  }

 
  namespace detail {
 
    // Apply a function to each element of a range and sum the results into a regular type.
    [[nodiscard]] auto sum_to_regular(std::ranges::forward_range auto &&rg, auto f) {
      auto it  = std::ranges::begin(rg);
      auto e   = std::ranges::end(rg);
      auto res = nda::make_regular(f(*it));
      for (++it; it != e; ++it) res += f(*it);
      return res;
    }
 
  } // namespace detail
 
} // namespace triqs::mesh