binary_wrapper.h

Go to the documentation of this file.

/*
 *  This file is a part of TiledArray.
 *  Copyright (C) 2013  Virginia Tech
 *
 *  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 should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  Justus Calvin
 *  Department of Chemistry, Virginia Tech
 *
 *  binary_interface.h
 *  Oct 6, 2013
 *
 */

#ifndef TILEDARRAY_TILE_OP_BINARY_WRAPPER_H__INCLUDED
#define TILEDARRAY_TILE_OP_BINARY_WRAPPER_H__INCLUDED

#include <TiledArray/tile_op/tile_interface.h>
#include <TiledArray/permutation.h>
#include <TiledArray/zero_tensor.h>

namespace TiledArray {
  namespace detail {


    template <typename Op>
    class BinaryWrapper {
    public:
      typedef BinaryWrapper<Op> BinaryWrapper_;
      typedef typename Op::left_type left_type; 
      typedef typename Op::right_type right_type; 
      typedef typename Op::result_type result_type; 


      static constexpr bool left_is_consumable = Op::left_is_consumable;
      static constexpr bool right_is_consumable = Op::right_is_consumable;

      template <typename T>
      static constexpr auto is_lazy_tile_v = is_lazy_tile<std::decay_t<T> >::value;

      template <typename T>
      static constexpr auto is_array_tile_v = is_array_tile<std::decay_t<T> >::value;

      template <typename T>
      static constexpr auto is_nonarray_lazy_tile_v = is_lazy_tile_v<T> && !is_array_tile_v<T>;

      template <typename T>
      using eval_t = typename eval_trait<std::decay_t<T> >::type;

    private:

      Op op_; 
      Permutation perm_; 

    public:

      // Compiler generated functions
      BinaryWrapper(const BinaryWrapper<Op>&) = default;
      BinaryWrapper(BinaryWrapper<Op>&&) = default;
      ~BinaryWrapper() = default;
      BinaryWrapper<Op>& operator=(const BinaryWrapper<Op>&) = default;
      BinaryWrapper<Op>& operator=(BinaryWrapper<Op>&&) = default;

      BinaryWrapper(const Op& op, const Permutation& perm) :
        op_(op), perm_(perm)
      { }

      BinaryWrapper(const Op& op) :
        op_(op), perm_()
      { }



      template <typename L, typename R,
                std::enable_if_t<!(is_lazy_tile_v<L> || is_lazy_tile_v<R>)>* =
                    nullptr>
      auto operator()(L&& left, R&& right) const {
        static_assert(std::is_same<std::decay_t<L>, left_type>::value,
                      "BinaryWrapper::operator()(L&&,R&&): invalid argument type L");
        static_assert(std::is_same<std::decay_t<R>, right_type>::value,
                      "BinaryWrapper::operator()(L&&,R&&): invalid argument type R");
        if (perm_)
          return op_(std::forward<L>(left), std::forward<R>(right), perm_);

        return op_(std::forward<L>(left), std::forward<R>(right));
      }


      template <typename R, std::enable_if_t<!is_lazy_tile_v<R> >* = nullptr>
      auto operator()(const ZeroTensor& left, R&& right) const {
        static_assert(std::is_same<std::decay_t<R>, right_type>::value,
                      "BinaryWrapper::operator()(zero,R&&): invalid argument type R");
        if(perm_)
          return op_(left, std::forward<R>(right), perm_);

        return op_(left, std::forward<R>(right));
      }


      template <typename L, std::enable_if_t<!is_lazy_tile_v<L> >* = nullptr>
      auto operator()(L&& left, const ZeroTensor& right) const {
        static_assert(std::is_same<std::decay_t<L>, left_type>::value,
                      "BinaryWrapper::operator()(L&&,zero): invalid argument type L");
        if(perm_)
          return op_(std::forward<L>(left), right, perm_);

        return op_(std::forward<L>(left), right);
      }

      // The following operators will evaluate lazy tile and use the base class
      // interface functions to call the correct evaluation kernel.


      template <typename L, typename R,
                std::enable_if_t<is_lazy_tile_v<L> && is_lazy_tile_v<R> &&
                                 (left_is_consumable || right_is_consumable)>* =
                    nullptr>
      auto operator()(L&& left, R&& right) const {
        auto eval_left = invoke_cast(std::forward<L>(left));
        auto eval_right = invoke_cast(std::forward<R>(right));
        auto continuation = [this](decltype(eval_left)& l, decltype(eval_right)& r) {
          return BinaryWrapper_::operator()(l, r);
        };
        using TiledArray::meta::invoke;
        return invoke(continuation, eval_left, eval_right);
      }


      template <typename L, typename R,
                std::enable_if_t<is_lazy_tile_v<L> &&
                                 (!is_lazy_tile_v<R>)&&(left_is_consumable ||
                                                        right_is_consumable)>* =
                    nullptr>
      auto operator()(L&& left, R&& right) const {
        auto eval_left = invoke_cast(std::forward<L>(left));
        auto continuation = [this](decltype(eval_left)& l, R&& r) {
          return BinaryWrapper_::operator()(l, std::forward<R>(r));
        };
        using TiledArray::meta::invoke;
        return invoke(continuation, eval_left, right);
      }


      template <typename L, typename R,
                std::enable_if_t<(!is_lazy_tile_v<L>)&&is_lazy_tile_v<R> &&
                                 (left_is_consumable || right_is_consumable)>* =
                    nullptr>
      auto operator()(L&& left, R&& right) const {
        auto eval_right = invoke_cast(std::forward<R>(right));
        return BinaryWrapper_::operator()(std::forward<L>(left), eval_right);
      }



      template <typename L, typename R,
                std::enable_if_t<is_array_tile_v<L> && is_array_tile_v<R> &&
                                 !(left_is_consumable ||
                                   right_is_consumable)>* = nullptr>
      auto operator()(L&& left, R&& right) const {
        auto eval_left = invoke_cast(std::forward<L>(left));
        auto eval_right = invoke_cast(std::forward<R>(right));

        using TiledArray::meta::invoke;

        if(perm_)
          return invoke(op_, eval_left, eval_right, perm_);

        auto op_left =[=](eval_t<L>&_left, eval_t<R>& _right) {
          return op_.consume_left(_left, _right);
        };
        auto op_right =[=](eval_t<L>&_left, eval_t<R>& _right) {
          return op_.consume_right(_left, _right);
        };
        // Override consumable
        if(is_consumable_tile<eval_t<L> >::value && left.is_consumable())
          return invoke(op_left, eval_left, eval_right);
        if(is_consumable_tile<eval_t<R> >::value && right.is_consumable())
          return invoke(op_right, eval_left, eval_right);

        return invoke(op_, eval_left, eval_right);
      }

      template <typename L, typename R,
                std::enable_if_t<
                    is_array_tile_v<L> &&
                    (!is_lazy_tile_v<R>)&&!(left_is_consumable ||
                                            right_is_consumable)>* = nullptr>
      auto operator()(L&& left, R&& right) const {
        auto eval_left = invoke_cast(std::forward<L>(left));

        if(perm_)
          return op_(eval_left, std::forward<R>(right), perm_);

        // Override consumable
        if(is_consumable_tile<eval_t<L> >::value && left.is_consumable())
          return op_.consume_left(eval_left, std::forward<R>(right));

        return op_(eval_left, std::forward<R>(right));
      }

      template <typename L, typename R,
                std::enable_if_t<
                    is_array_tile_v<L> && is_nonarray_lazy_tile_v<R> &&
                    !(left_is_consumable || right_is_consumable)>* = nullptr>
      auto operator()(L&& left, R&& right) const {
        auto eval_left = invoke_cast(std::forward<L>(left));
        auto eval_right = invoke_cast(std::forward<R>(right));

        if(perm_)
          return op_(eval_left, eval_right, perm_);

        // Override consumable
        if(is_consumable_tile<eval_t<L> >::value && left.is_consumable())
          return op_.consume_left(eval_left, eval_right);

        return op_(eval_left, eval_right);
      }

      template <typename L, typename R,
                std::enable_if_t<(!is_lazy_tile_v<L>)&&is_array_tile_v<R> &&
                                 !(left_is_consumable ||
                                   right_is_consumable)>* = nullptr>
      auto operator()(L&& left, R&& right) const {
        auto eval_right = invoke_cast(std::forward<R>(right));

        if(perm_)
          return op_(std::forward<L>(left), eval_right, perm_);

        // Override consumable
        if(is_consumable_tile<eval_t<R> >::value && right.is_consumable())
          return op_.consume_right(std::forward<L>(left), eval_right);

        return op_(std::forward<L>(left), eval_right);
      }

      template <typename L, typename R,
                std::enable_if_t<
                    is_nonarray_lazy_tile_v<L> && is_array_tile_v<R> &&
                    !(left_is_consumable || right_is_consumable)>* = nullptr>
      auto operator()(L&& left, R&& right) const {
        auto eval_left = invoke_cast(std::forward<L>(left));
        auto eval_right = invoke_cast(std::forward<R>(right));

        if(perm_)
          return op_(eval_left, eval_right, perm_);

        // Override consumable
        if(is_consumable_tile<eval_t<R> >::value && right.is_consumable())
          return op_.consume_right(eval_left, eval_right);

        return op_(eval_left, eval_right);
      }

    }; // class BinaryWrapper

  } // namespace detail
} // namespace TiledArray

#endif // TILEDARRAY_TILE_OP_BINARY_WRAPPER_H__INCLUDED