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 "./map.hpp"
#include "./traits.hpp"
 
#include <algorithm>
#include <cmath>
#include <complex>
#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 of a double.
    inline double abs2(double x) { return x * x; }
 
    // Get the squared absolute value of a std::complex<double>.
    inline double abs2(std::complex<double> z) { return (conj(z) * z).real(); }
 
    // Check if a std::complex<double> is NaN.
    inline bool isnan(std::complex<double> const &z) { return std::isnan(z.real()) or std::isnan(z.imag()); }
 
    // Functor for nda::detail::conj.
    struct conj_f {
      auto operator()(auto const &x) const { return conj(x); };
    };
 
  } // namespace detail

  template <ArrayOrScalar A>
  auto pow(A &&a, double p) {
    return nda::map([p](auto const &x) {
      using std::pow;
      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([](auto const &x) {
      if constexpr (Scalar<decltype(x)>) {
        return 1.0 / x;
      } else {
        return 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));
  }

 
} // namespace nda