mapped_functions.hpp

Go to the documentation of this file.

// Copyright (c) 2019--present, The Simons Foundation
// This file is part of TRIQS/nda and is licensed under the Apache License, Version 2.0.
// SPDX-License-Identifier: Apache-2.0
// See LICENSE in the root of this distribution for details.

 
#pragma once
 
#include "./concepts.hpp"
#include "./macros.hpp"
#include "./map.hpp"
#include "./traits.hpp"
 
#include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <type_traits>
#include <utility>
 
namespace nda {

 
  namespace detail {
 
    // Get the real part of a scalar.
    template <nda::Scalar S>
    auto real(S x) {
      if constexpr (is_complex_v<S>) {
        return std::real(x);
      } else {
        return x;
      }
    }
 
    // Get the complex conjugate of a scalar.
    template <nda::Scalar S>
    auto conj(S x) {
      if constexpr (is_complex_v<S>) {
        return std::conj(x);
      } else {
        return x;
      }
    }
 
    // Get the squared absolute value with the return type of std::norm.
    FORCEINLINE auto abs2(auto x) { return std::norm(x); }
 
    // Check if a scalar or either component of a complex scalar is NaN.
    template <Scalar S>
    bool isnan(S const &x) {
      if constexpr (is_complex_v<S>) {
        return std::isnan(x.real()) or std::isnan(x.imag());
      } else {
        return std::isnan(x);
      }
    }
 
    // Functor for nda::detail::conj.
    struct conj_f {
      auto operator()(auto const &x) const { return conj(x); };
    };
 
  } // namespace detail
 
  // The scalar overloads of the <cmath> family are the std ones, brought in by using-declarations rather than
  // nda function templates: libc++ declares generic templates like pow(A1, A2) in the global namespace, which would
  // tie with such templates for unqualified calls under `using namespace nda`. The using-declarations must follow the
  // <cmath>, <complex> and <cstdlib> includes, since they only capture overloads declared before them.
#ifdef NDA_DOXYGEN
  template <Scalar S, Scalar P>
  auto pow(S s, P p);
#endif
  using std::pow;

  template <Array A, Scalar S>
  auto pow(A &&a, S p) {
    return nda::map([p](auto const &x) { return pow(x, p); })(std::forward<A>(a));
  }

  template <ArrayOrScalar A>
  decltype(auto) conj(A &&a) {
    if constexpr (is_complex_v<get_value_t<A>>)
      return nda::map(detail::conj_f{})(std::forward<A>(a));
    else
      return std::forward<A>(a);
  }

  template <ArrayOrScalar A>
  auto reciprocal(A &&a) {
    return nda::map([]<typename T>(T const &x) {
      if constexpr (Scalar<T>) {
        using real_t = remove_complex_t<T>;
        if constexpr (std::is_floating_point_v<real_t>) {
          return real_t{1} / x;
        } else {
          return 1.0 / x;
        }
      } else {
        return nda::reciprocal(x);
      }
    })(std::forward<A>(a));
  }

  template <ArrayOrScalar A, ArrayOrScalar B>
    requires(((Scalar<A> && Scalar<B>) || (Array<A> && Array<B> && get_rank<A> == get_rank<B>))
             && !is_complex_v<get_value_t<A>> && !is_complex_v<get_value_t<B>>)
  [[nodiscard]] auto max(A &&a, B &&b) {
    return nda::map([](auto const &x, auto const &y) {
      using std::max;
      return max(x, y);
    })(std::forward<A>(a), std::forward<B>(b));
  }

  template <ArrayOrScalar A, ArrayOrScalar B>
    requires(((Scalar<A> && Scalar<B>) || (Array<A> && Array<B> && get_rank<A> == get_rank<B>))
             && !is_complex_v<get_value_t<A>> && !is_complex_v<get_value_t<B>>)
  [[nodiscard]] auto min(A &&a, B &&b) {
    return nda::map([](auto const &x, auto const &y) {
      using std::min;
      return min(x, y);
    })(std::forward<A>(a), std::forward<B>(b));
  }
 
#ifdef NDA_DOXYGEN
  template <Scalar S>
  auto abs(S s);
#endif
  using std::abs;

  template <Array A>
  auto abs(A &&a) {
    return nda::map([](auto const &x) { return abs(x); })(std::forward<A>(a));
  }

  template <ArrayOrScalar A>
  auto imag(A &&a) {
    return nda::map([](auto const &x) {
      using std::imag;
      return imag(x);
    })(std::forward<A>(a));
  }
 
#ifdef NDA_DOXYGEN
  template <Scalar S>
  auto floor(S s);
#endif
  using std::floor;

  template <Array A>
  auto floor(A &&a) {
    return nda::map([](auto const &x) { return floor(x); })(std::forward<A>(a));
  }

  template <ArrayOrScalar A>
  auto real(A &&a) {
    return nda::map([](auto const &x) { return detail::real(x); })(std::forward<A>(a));
  }

  template <ArrayOrScalar A>
  auto abs2(A &&a) {
    return nda::map([](auto const &x) { return detail::abs2(x); })(std::forward<A>(a));
  }
 
#ifdef NDA_DOXYGEN
  template <Scalar S>
    requires(not is_complex_v<S>)
  auto isnan(S s);
#endif
  using std::isnan;

  template <typename A>
    requires(Array<A> || is_complex_v<A>)
  auto isnan(A &&a) {
    return nda::map([](auto const &x) { return detail::isnan(x); })(std::forward<A>(a));
  }
 
#ifdef NDA_DOXYGEN
  template <Scalar S>
  auto exp(S s);
#endif
  using std::exp;

  template <Array A>
  auto exp(A &&a)
    requires(get_algebra<A> != 'M')
  {
    return nda::map([](auto const &x) { return exp(x); })(std::forward<A>(a));
  }
 
#ifdef NDA_DOXYGEN
  template <Scalar S>
  auto cos(S s);
#endif
  using std::cos;

  template <Array A>
  auto cos(A &&a)
    requires(get_algebra<A> != 'M')
  {
    return nda::map([](auto const &x) { return cos(x); })(std::forward<A>(a));
  }
 
#ifdef NDA_DOXYGEN
  template <Scalar S>
  auto sin(S s);
#endif
  using std::sin;

  template <Array A>
  auto sin(A &&a)
    requires(get_algebra<A> != 'M')
  {
    return nda::map([](auto const &x) { return sin(x); })(std::forward<A>(a));
  }
 
#ifdef NDA_DOXYGEN
  template <Scalar S>
  auto tan(S s);
#endif
  using std::tan;

  template <Array A>
  auto tan(A &&a)
    requires(get_algebra<A> != 'M')
  {
    return nda::map([](auto const &x) { return tan(x); })(std::forward<A>(a));
  }
 
#ifdef NDA_DOXYGEN
  template <Scalar S>
  auto cosh(S s);
#endif
  using std::cosh;

  template <Array A>
  auto cosh(A &&a)
    requires(get_algebra<A> != 'M')
  {
    return nda::map([](auto const &x) { return cosh(x); })(std::forward<A>(a));
  }
 
#ifdef NDA_DOXYGEN
  template <Scalar S>
  auto sinh(S s);
#endif
  using std::sinh;

  template <Array A>
  auto sinh(A &&a)
    requires(get_algebra<A> != 'M')
  {
    return nda::map([](auto const &x) { return sinh(x); })(std::forward<A>(a));
  }
 
#ifdef NDA_DOXYGEN
  template <Scalar S>
  auto tanh(S s);
#endif
  using std::tanh;

  template <Array A>
  auto tanh(A &&a)
    requires(get_algebra<A> != 'M')
  {
    return nda::map([](auto const &x) { return tanh(x); })(std::forward<A>(a));
  }
 
#ifdef NDA_DOXYGEN
  template <Scalar S>
  auto acos(S s);
#endif
  using std::acos;

  template <Array A>
  auto acos(A &&a)
    requires(get_algebra<A> != 'M')
  {
    return nda::map([](auto const &x) { return acos(x); })(std::forward<A>(a));
  }
 
#ifdef NDA_DOXYGEN
  template <Scalar S>
  auto asin(S s);
#endif
  using std::asin;

  template <Array A>
  auto asin(A &&a)
    requires(get_algebra<A> != 'M')
  {
    return nda::map([](auto const &x) { return asin(x); })(std::forward<A>(a));
  }
 
#ifdef NDA_DOXYGEN
  template <Scalar S>
  auto atan(S s);
#endif
  using std::atan;

  template <Array A>
  auto atan(A &&a)
    requires(get_algebra<A> != 'M')
  {
    return nda::map([](auto const &x) { return atan(x); })(std::forward<A>(a));
  }
 
#ifdef NDA_DOXYGEN
  template <Scalar S>
  auto log(S s);
#endif
  using std::log;

  template <Array A>
  auto log(A &&a)
    requires(get_algebra<A> != 'M')
  {
    return nda::map([](auto const &x) { return log(x); })(std::forward<A>(a));
  }
 
#ifdef NDA_DOXYGEN
  template <Scalar S>
  auto sqrt(S s);
#endif
  using std::sqrt;

  template <Array A>
  auto sqrt(A &&a)
    requires(get_algebra<A> != 'M')
  {
    return nda::map([](auto const &x) { return sqrt(x); })(std::forward<A>(a));
  }

 
} // namespace nda