tile.h

Go to the documentation of this file.

/*
 *  This file is a part of TiledArray.
 *  Copyright (C) 2015  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/>.
 *
 */

#ifndef TILEDARRAY_TILE_H__INCLUDED
#define TILEDARRAY_TILE_H__INCLUDED

#include <TiledArray/tile_op/tile_interface.h>
#include <TiledArray/tile_interface/cast.h>
#include <memory>

// Forward declaration of MADNESS archive type traits
namespace madness {
  namespace archive {

    template <typename> struct is_output_archive;
    template <typename> struct is_input_archive;

  }  // namespace archive
}  // namespace madness

namespace TiledArray {



  template <typename T>
  class Tile {
  public:
    typedef Tile<T> Tile_;
    typedef T tensor_type;

  private:

    std::shared_ptr<tensor_type> pimpl_;

  public:

    // Constructors and destructor ---------------------------------------------

    Tile() = default;
    Tile(const Tile_&) = default;
    Tile(Tile_&&) = default;


    template <typename Arg,
      typename = typename std::enable_if<
        not detail::is_same_or_derived<Tile_,Arg>::value &&
        not std::is_convertible<Arg,Tile_>::value &&
        not TiledArray::detail::is_explicitly_convertible<Arg,Tile_>::value
      >::type
    >
    explicit Tile(Arg&& arg) :
      pimpl_(std::make_shared<tensor_type>(std::forward<Arg>(arg)))
    { }

    template <typename Arg1, typename Arg2, typename ... Args>
    Tile(Arg1&& arg1, Arg2&& arg2, Args&&... args) :
      pimpl_(std::make_shared<tensor_type>(std::forward<Arg1>(arg1),
                                           std::forward<Arg2>(arg2),
                                           std::forward<Args>(args)...))
    { }

    ~Tile() = default;

    // Assignment operators ----------------------------------------------------

    Tile_& operator=(Tile_&&) = default;
    Tile_& operator=(const Tile_&) = default;

    Tile_& operator=(const tensor_type& tensor) {
      *pimpl_ = tensor;
      return *this;
    }

    Tile_& operator=(tensor_type&& tensor) {
      *pimpl_ = std::move(tensor);
      return *this;
    }


    // State accessor ----------------------------------------------------------

    bool empty() const {
      return not bool(pimpl_);
    }

    // Tile accessor -----------------------------------------------------------

    tensor_type& tensor() { return *pimpl_; }

    const tensor_type& tensor() const { return *pimpl_; }


    // Iterator accessor -------------------------------------------------------


    decltype(auto) begin()
    { return std::begin(tensor()); }


    decltype(auto) begin() const
    { return std::begin(tensor()); }


    decltype(auto) end()
    { return std::end(tensor()); }


    decltype(auto) end() const
    { return std::end(tensor()); }


    // Dimension information accessors -----------------------------------------


    decltype(auto) size() const
    { return tensor().size(); }


    decltype(auto) range() const
    { return tensor().range(); }


    // Element accessors -------------------------------------------------------


    decltype(auto) operator[](std::size_t i) const
    { return tensor()[i]; }


    decltype(auto) operator[](std::size_t i)
    { return tensor()[i]; }


    template <typename... I>
    decltype(auto) operator()(const I... i) const
    { return tensor()(i...); }


    template <typename... I>
    decltype(auto) operator()(const I... i)
    { return tensor()(i...); }


    // Serialization -----------------------------------------------------------

    template <typename Archive,
        typename std::enable_if<madness::archive::is_output_archive<Archive>::value>::type* = nullptr>
    void serialize(Archive &ar) const {
      // Serialize data for empty tile check
      bool empty = !static_cast<bool>(pimpl_);
      ar & empty;
      if (!empty) {
        // Serialize tile data
        ar & *pimpl_;
      }
    }

    template <typename Archive,
        typename std::enable_if<madness::archive::is_input_archive<Archive>::value>::type* = nullptr>
    void serialize(Archive &ar) {
      // Check for empty tile
      bool empty = false;
      ar & empty;

      if (!empty) {
        // Deserialize tile data
        tensor_type tensor;
        ar & tensor;

        // construct a new pimpl
        pimpl_ = std::make_shared<T>(std::move(tensor));
      } else {
        // Set pimpl to an empty tile
        pimpl_.reset();
      }
    }

  }; // class Tile

  // The following functions define the non-intrusive interface used to apply
  // math operations to Tiles. These functions in turn use the non-intrusive
  // interface functions to evaluate tiles.

  namespace detail {


    template <typename T>
    Tile<T> make_tile(T&& t) { return Tile<T>(std::forward<T>(t)); }

  }  // namespace detail


  // Clone operations ----------------------------------------------------------


  template <typename Arg>
  inline Tile<Arg> clone(const Tile<Arg>& arg) {
    return Tile<Arg>(clone(arg.tensor()));
  }


  // Empty operations ----------------------------------------------------------


  template <typename Arg>
  inline bool empty(const Tile<Arg>& arg) {
    return arg.empty() || empty(arg.tensor());
  }


  // Permutation operations ----------------------------------------------------


  template <typename Arg>
  inline decltype(auto) permute(const Tile<Arg>& arg, const Permutation& perm)
  {
    return Tile<Arg>(permute(arg.tensor(), perm));
  }


  // Shift operations ----------------------------------------------------------


  template <typename Arg, typename Index>
  inline decltype(auto) shift(const Tile<Arg>& arg, const Index& range_shift)
  { return detail::make_tile(shift(arg.tensor(), range_shift)); }


  template <typename Arg, typename Index>
  inline Tile<Arg>& shift_to(Tile<Arg>& arg, const Index& range_shift) {
    shift_to(arg.tensor(), range_shift);
    return arg;
  }


  // Addition operations -------------------------------------------------------


  template <typename Left, typename Right>
  inline decltype(auto) add(const Tile<Left>& left, const Tile<Right>& right)
  { return detail::make_tile(add(left.tensor(), right.tensor())); }


  template <typename Left, typename Right, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline decltype(auto) add(const Tile<Left>& left, const Tile<Right>& right, const Scalar factor)
  { return detail::make_tile(add(left.tensor(), right.tensor(), factor)); }


  template <typename Left, typename Right>
  inline decltype(auto) add(const Tile<Left>& left, const Tile<Right>& right, const Permutation& perm)
  { return detail::make_tile(add(left.tensor(), right.tensor(), perm)); }


  template <typename Left, typename Right, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline decltype(auto) add(const Tile<Left>& left, const Tile<Right>& right,
      const Scalar factor, const Permutation& perm)
  { return detail::make_tile(add(left.tensor(), right.tensor(), factor, perm)); }


  template <typename Arg, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline decltype(auto) add(const Tile<Arg>& arg, const Scalar value)
  { return detail::make_tile(add(arg.tensor(), value)); }


  template <typename Arg, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline decltype(auto)
  add(const Tile<Arg>& arg, const Scalar value, const Permutation& perm)
  { return detail::make_tile(add(arg.tensor(), value, perm)); }


  template <typename Result, typename Arg>
  inline Tile<Result>& add_to(Tile<Result>& result, const Tile<Arg>& arg) {
    add_to(result.tensor(), arg.tensor());
    return result;
  }


  template <typename Result, typename Arg, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline Tile<Result>&
  add_to(Tile<Result>& result, const Tile<Arg>& arg, const Scalar factor) {
    add_to(result.tensor(), arg.tensor(), factor);
    return result;
  }


  template <typename Result, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline Tile<Result>& add_to(Tile<Result>& result, const Scalar value) {
    add_to(result.tensor(), value);
    return result;
  }


  // Subtraction ---------------------------------------------------------------


  template <typename Left, typename Right>
  inline decltype(auto)
  subt(const Tile<Left>& left, const Tile<Right>& right)
  { return detail::make_tile(subt(left.tensor(), right.tensor())); }


  template <typename Left, typename Right, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline decltype(auto)
  subt(const Tile<Left>& left, const Tile<Right>& right, const Scalar factor)
  { return detail::make_tile(subt(left.tensor(), right.tensor(), factor)); }


  template <typename Left, typename Right>
  inline decltype(auto)
  subt(const Tile<Left>& left, const Tile<Right>& right, const Permutation& perm)
  { return detail::make_tile(subt(left.tensor(), right.tensor(), perm)); }


  template <typename Left, typename Right, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline decltype(auto)
  subt(const Tile<Left>& left, const Tile<Right>& right, const Scalar factor,
      const Permutation& perm)
  { return detail::make_tile(subt(left.tensor(), right.tensor(), factor, perm)); }


  template <typename Arg, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline decltype(auto)
  subt(const Tile<Arg>& arg, const Scalar value)
  { return detail::make_tile(subt(arg.tensor(), value)); }


  template <typename Arg, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline decltype(auto)
  subt(const Tile<Arg>& arg, const Scalar value, const Permutation& perm)
  { return detail::make_tile(subt(arg.tensor(), value, perm)); }


  template <typename Result, typename Arg>
  inline Tile<Result>& subt_to(Tile<Result>& result, const Tile<Arg>& arg) {
    subt_to(result.tensor(), arg.tensor());
    return result;
  }


  template <typename Result, typename Arg, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline Tile<Result>&
  subt_to(Tile<Result>& result, const Tile<Arg>& arg, const Scalar factor) {
    subt_to(result.tensor(), arg.tensor(), factor);
    return result;
  }


  template <typename Result, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline Tile<Result>& subt_to(Tile<Result>& result, const Scalar value) {
    subt_to(result.tensor(), value);
    return result;
  }


  // Multiplication operations -------------------------------------------------



  template <typename Left, typename Right>
  inline decltype(auto) mult(const Tile<Left>& left, const Tile<Right>& right)
  { return detail::make_tile(mult(left.tensor(), right.tensor())); }


  template <typename Left, typename Right, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline decltype(auto)
  mult(const Tile<Left>& left, const Tile<Right>& right,  const Scalar factor)
  { return detail::make_tile(mult(left.tensor(), right.tensor(), factor)); }


  template <typename Left, typename Right>
  inline decltype(auto)
  mult(const Tile<Left>& left, const Tile<Right>& right, const Permutation& perm)
  { return detail::make_tile(mult(left.tensor(), right.tensor(), perm)); }


  template <typename Left, typename Right, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline decltype(auto)
  mult(const Tile<Left>& left, const Tile<Right>& right, const Scalar factor,
      const Permutation& perm)
  { return detail::make_tile(mult(left.tensor(), right.tensor(), factor, perm)); }


  template <typename Result, typename Arg>
  inline Tile<Result>& mult_to(Tile<Result>& result, const Tile<Arg>& arg) {
    mult_to(result.tensor(), arg.tensor());
    return result;
  }


  template <typename Result, typename Arg, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline Tile<Result>& mult_to(Tile<Result>& result, const Tile<Arg>& arg,
      const Scalar factor)
  {
    mult_to(result.tensor(), arg.tensor(), factor);
    return result;
  }


  // Scaling operations --------------------------------------------------------


  template <typename Arg, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline decltype(auto) scale(const Tile<Arg>& arg, const Scalar factor)
  { return detail::make_tile(scale(arg.tensor(), factor)); }


  template <typename Arg, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline decltype(auto)
  scale(const Tile<Arg>& arg, const Scalar factor, const Permutation& perm)
  { return detail::make_tile(scale(arg.tensor(), factor, perm)); }


  template <typename Result, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline Tile<Result>& scale_to(Tile<Result>& result, const Scalar factor) {
    scale_to(result.tensor(), factor);
    return result;
  }


  // Negation operations -------------------------------------------------------


  template <typename Arg>
  inline decltype(auto) neg(const Tile<Arg>& arg)
  { return detail::make_tile(neg(arg.tensor())); }


  template <typename Arg>
  inline decltype(auto) neg(const Tile<Arg>& arg, const Permutation& perm)
  { return detail::make_tile(neg(arg.tensor(), perm)); }


  template <typename Result>
  inline Tile<Result>& neg_to(Tile<Result>& result) {
    neg_to(result.tensor());
    return result;
  }


  // Complex conjugate operations ---------------------------------------------


  template <typename Arg>
  inline decltype(auto) conj(const Tile<Arg>& arg)
  { return detail::make_tile(conj(arg.tensor())); }


  template <typename Arg, typename Scalar,
      typename std::enable_if<
          TiledArray::detail::is_numeric<Scalar>::value
      >::type* = nullptr>
  inline decltype(auto) conj(const Tile<Arg>& arg, const Scalar factor)
  { return detail::make_tile(conj(arg.tensor(), factor)); }


  template <typename Arg>
  inline decltype(auto) conj(const Tile<Arg>& arg, const Permutation& perm)
  { return detail::make_tile(conj(arg.tensor(), perm)); }


  template <typename Arg, typename Scalar,
      typename std::enable_if<
          TiledArray::detail::is_numeric<Scalar>::value
      >::type* = nullptr>
  inline decltype(auto) conj(const Tile<Arg>& arg, const Scalar factor, const Permutation& perm)
  { return detail::make_tile(conj(arg.tensor(), factor, perm)); }


  template <typename Result>
  inline Result& conj_to(Tile<Result>& result) {
    conj_to(result.tensor());
    return result;
  }


  template <typename Result, typename Scalar,
      typename std::enable_if<
          TiledArray::detail::is_numeric<Scalar>::value
      >::type* = nullptr>
  inline Result& conj_to(Tile<Result>& result, const Scalar factor) {
    conj_to(result.tensor(), factor);
    return result;
  }

  // Contraction operations ----------------------------------------------------



  template <typename Left, typename Right, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline decltype(auto) gemm(const Tile<Left>& left, const Tile<Right>& right,
      const Scalar factor, const math::GemmHelper& gemm_config)
  { return detail::make_tile(gemm(left.tensor(), right.tensor(), factor, gemm_config)); }


  template <typename Result, typename Left, typename Right, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline Tile<Result>& gemm(Tile<Result>& result, const Tile<Left>& left,
      const Tile<Right>& right, const Scalar factor,
      const math::GemmHelper& gemm_config)
  {
    gemm(result.tensor(), left.tensor(), right.tensor(), factor, gemm_config);
    return result;
  }


  // Reduction operations ------------------------------------------------------


  template <typename Arg>
  inline decltype(auto) trace(const Tile<Arg>& arg)
  { return trace(arg.tensor()); }


  template <typename Arg>
  inline decltype(auto) sum(const Tile<Arg>& arg)
  { return sum(arg.tensor()); }


  template <typename Arg>
  inline decltype(auto) product(const Tile<Arg>& arg)
  { return product(arg.tensor()); }


  template <typename Arg>
  inline decltype(auto) squared_norm(const Tile<Arg>& arg)
  { return squared_norm(arg.tensor()); }


  template <typename Arg>
  inline decltype(auto) norm(const Tile<Arg>& arg)
  { return norm(arg.tensor()); }


  template <typename Arg>
  inline decltype(auto) max(const Tile<Arg>& arg)
  { return max(arg.tensor()); }


  template <typename Arg>
  inline decltype(auto) min(const Tile<Arg>& arg)
  { return min(arg.tensor()); }


  template <typename Arg>
  inline decltype(auto) abs_max(const Tile<Arg>& arg)
  { return abs_max(arg.tensor()); }


  template <typename Arg>
  inline decltype(auto) abs_min(const Tile<Arg>& arg)
  { return abs_min(arg.tensor()); }


  template <typename Left, typename Right>
  inline decltype(auto) dot(const Tile<Left>& left, const Tile<Right>& right)
  { return dot(left.tensor(), right.tensor()); }

  // Tile arithmetic operators -------------------------------------------------



  template <typename Left, typename Right>
  inline decltype(auto) operator+(const Tile<Left>& left, const Tile<Right>& right)
  { return add(left, right); }


  template <typename Left, typename Right>
  inline Tile<Left>& operator+=(Tile<Left>& left, const Tile<Right>& right)
  { return add_to(left, right); }


  template <typename Left, typename Right>
  inline decltype(auto) operator-(const Tile<Left>& left, const Tile<Right>& right)
  { return subt(left, right); }


  template <typename Left, typename Right>
  inline Tile<Left>& operator-=(Tile<Left>& left, const Tile<Right>& right)
  { return subt_to(left, right); }


  template <typename Left, typename Right>
  inline decltype(auto) operator*(const Tile<Left>& left, const Tile<Right>& right)
  { return mult(left, right); }


  template <typename Left, typename Right,
      typename std::enable_if<detail::is_numeric<Right>::value>::type* = nullptr>
  inline decltype(auto) operator*(const Tile<Left>& left, const Right right)
  { return scale(left, right); }


  template <typename Left, typename Right,
      typename std::enable_if<TiledArray::detail::is_numeric<Left>::value>::type* = nullptr>
  inline decltype(auto) operator*(const Left left, const Tile<Right>& right)
  { return scale(right, left); }


  template <typename Left, typename Right>
  inline Tile<Left>& operator*=(Tile<Left>& left, const Tile<Right>& right)
  { return mult_to(left, right); }


  template <typename Arg>
  inline decltype(auto) operator-(const Tile<Arg>& arg)
  { return neg(arg); }


  template <typename Arg>
  inline decltype(auto) operator*(const Permutation& perm, Tile<Arg> const arg)
  { return permute(arg, perm); }


  template <typename T>
  inline std::ostream &operator<<(std::ostream &os, const Tile<T>& tile) {
    os << tile.tensor();
    return os;
  }

template<typename Allocator, typename T>
struct Cast<TiledArray::Tensor<typename T::value_type, Allocator>,
            Tile<T>,
            detail::void_t<decltype(std::declval<TiledArray::Cast<TiledArray::Tensor<typename T::value_type, Allocator>,
                                                                  T>>()(std::declval<const T &>()))>> {
  auto operator()(const Tile<T> &arg) const {
    return TiledArray::Cast<TiledArray::Tensor<typename T::value_type, Allocator>,
                            T>{}(arg.tensor());
  }
};

}  // namespace TiledArray

#endif  // TILEDARRAY_TILE_H__INCLUDED