operation.hpp

Go to the documentation of this file.

// Copyright (c) 2024--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 "./expression.hpp"
#include "./utils.hpp"
#include "../macros.hpp"
 
#include <functional>
#include <type_traits>
#include <utility>
 
namespace nda::clef {


  template <typename F>
  constexpr bool supports_partial_eval_of_calls = false;

  template <typename T>
  constexpr bool supports_partial_eval_of_subscript = false;
 
  namespace detail {
 
    // Get the value from a std::reference_wrapper or simply forward the argument of any other type.
    template <typename U>
    FORCEINLINE U &&fget(U &&x) {
      return std::forward<U>(x);
    }
 
    // Specialization of fget for std::reference_wrapper.
    template <typename U>
    FORCEINLINE decltype(auto) fget(std::reference_wrapper<U> x) {
      return x.get();
    }
 
  } // namespace detail

  template <typename Tag>
  struct operation;

  template <>
  struct operation<tags::terminal> {
    template <typename L>
    FORCEINLINE L operator()(L &&l) const {
      return std::forward<L>(l);
    }
  };

  template <>
  struct operation<tags::function> {
    template <typename F, typename... Args>
    FORCEINLINE decltype(auto) operator()(F &&f, Args &&...args) const {
      return detail::fget(std::forward<F>(f))(detail::fget(std::forward<Args>(args))...);
    }
  };

  template <>
  struct operation<tags::subscript> {
    template <typename F, typename... Args>
    FORCEINLINE decltype(auto) operator()(F &&f, Args &&...args) const {
      return detail::fget(std::forward<F>(f)).operator[](detail::fget(std::forward<Args>(args))...);
    }
  };
 
  // Define and implement all lazy binary operations.
#define CLEF_OPERATION(TAG, OP)                                                                                                                      \
  namespace tags {                                                                                                                                   \
                                                                                                   \
    struct TAG : binary_op {                                                                                                                         \
                                                                                          \
      static const char *name() { return AS_STRING(OP); }                                                                                            \
    };                                                                                                                                               \
  }                                                                                                                                                  \
                                                                                    \
  template <typename L, typename R>                                                                                                                  \
  FORCEINLINE auto operator OP(L &&l, R &&r)                                                                                                         \
    requires(is_any_lazy<L, R>)                                                                                                                      \
  {                                                                                                                                                  \
    return expr<tags::TAG, expr_storage_t<L>, expr_storage_t<R>>{tags::TAG(), std::forward<L>(l), std::forward<R>(r)};                               \
  }                                                                                                                                                  \
                                                                     \
  template <>                                                                                                                                        \
  struct operation<tags::TAG> {                                                                                                                      \
                                                                \
    template <typename L, typename R>                                                                                                                \
    FORCEINLINE decltype(auto) operator()(L &&l, R &&r) const {                                                                                      \
      return detail::fget(std::forward<L>(l)) OP detail::fget(std::forward<R>(r));                                                                   \
    }                                                                                                                                                \
  }
 
  // clang-format off
  CLEF_OPERATION(plus, +);
  CLEF_OPERATION(minus, -);
  CLEF_OPERATION(multiplies, *);
  CLEF_OPERATION(divides, /);
  CLEF_OPERATION(greater, >);
  CLEF_OPERATION(less, <);
  CLEF_OPERATION(leq, <=);
  CLEF_OPERATION(geq, >=);
  CLEF_OPERATION(eq, ==);
  // clang-format on
#undef CLEF_OPERATION
 
  // Define and implement all lazy unary operations.
#define CLEF_OPERATION(TAG, OP)                                                                                                                      \
  namespace tags {                                                                                                                                   \
                                                                                                    \
    struct TAG : unary_op {                                                                                                                          \
                                                                                          \
      static const char *name() { return AS_STRING(OP); }                                                                                            \
    };                                                                                                                                               \
  }                                                                                                                                                  \
                                                                                     \
  template <typename L>                                                                                                                              \
  FORCEINLINE auto operator OP(L &&l)                                                                                                                \
    requires(is_any_lazy<L>)                                                                                                                         \
  {                                                                                                                                                  \
    return expr<tags::TAG, expr_storage_t<L>>{tags::TAG(), std::forward<L>(l)};                                                                      \
  }                                                                                                                                                  \
                                                                     \
  template <>                                                                                                                                        \
  struct operation<tags::TAG> {                                                                                                                      \
                                                                 \
    template <typename L>                                                                                                                            \
    FORCEINLINE decltype(auto) operator()(L &&l) const {                                                                                             \
      return OP detail::fget(std::forward<L>(l));                                                                                                    \
    }                                                                                                                                                \
  }
 
  CLEF_OPERATION(unaryplus, +);
  CLEF_OPERATION(negate, -);
  CLEF_OPERATION(loginot, !);
#undef CLEF_OPERATION

  template <>
  struct operation<tags::if_else> {
    template <typename C, typename A, typename B>
    FORCEINLINE A operator()(C const &c, A const &a, B const &b) const {
      return detail::fget(c) ? detail::fget(a) : detail::fget(b);
    }
  };

  template <typename C, typename A, typename B>
  FORCEINLINE auto if_else(C &&c, A &&a, B &&b) {
    return expr<tags::if_else, expr_storage_t<C>, expr_storage_t<A>, expr_storage_t<B>>{tags::if_else(), std::forward<C>(c), std::forward<A>(a),
                                                                                        std::forward<B>(b)};
  }

 
  template <typename Tag, typename... Args>
  FORCEINLINE auto op_dispatch(std::true_type, Args &&...args) {
    using Arg0 = std::decay_t<std::tuple_element_t<0, std::tuple<Args...>>>;
    if constexpr ((std::is_same_v<Tag, tags::function> and not supports_partial_eval_of_calls<Arg0>) or  //
                  (std::is_same_v<Tag, tags::subscript> and not supports_partial_eval_of_subscript<Arg0>) //
    )
      return expr<Tag, expr_storage_t<Args>...>{Tag(), std::forward<Args>(args)...};
     else
      return operation<Tag>()(std::forward<Args>(args)...);
  }

  template <typename Tag, typename... Args>
  FORCEINLINE decltype(auto) op_dispatch(std::false_type, Args &&...args) {
    return operation<Tag>()(std::forward<Args>(args)...);
  }

 
} // namespace nda::clef