operation.hpp

Go to the documentation of this file.

// Copyright (c) 2019-2023 Simons Foundation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0.txt
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Authors: Olivier Parcollet, Nils Wentzell
 
#pragma once
 
#include "./expression.hpp"
#include "./utils.hpp"
#include "../macros.hpp"
 
#include <functional>
#include <type_traits>
#include <utility>
 
namespace nda::clef {
 
  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 {
      // directly calling [args...] breaks clang
      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) {
    return expr<Tag, expr_storage_t<Args>...>{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