tensor_interface.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/>.
 *
 *  Justus Calvin
 *  Department of Chemistry, Virginia Tech
 *
 *  tensor_interface.h
 *  May 29, 2015
 *
 */
 
#ifndef TILEDARRAY_TENSOR_TENSOR_VIEW_H__INCLUDED
#define TILEDARRAY_TENSOR_TENSOR_VIEW_H__INCLUDED
 
#include <TiledArray/tensor/complex.h>
#include <TiledArray/tensor/kernels.h>
#include <TiledArray/tile_interface/permute.h>
#include <TiledArray/type_traits.h>
 
namespace TiledArray {
 
// Forward declarations
template <typename T, typename A>
class Tensor;
class Range;
namespace detail {
template <typename T, typename Range, typename OpResult>
class TensorInterface;
}
 
template <typename T, typename Range_, typename OpResult, typename Index1,
          typename Index2>
void remap(detail::TensorInterface<T, Range_, OpResult>&, T* const,
           const Index1&, const Index2&);
template <typename T, typename Range_, typename OpResult, typename Index1,
          typename Index2>
void remap(detail::TensorInterface<const T, Range_, OpResult>&, T* const,
           const Index1&, const Index2&);
template <typename T, typename Range_, typename OpResult, typename Index1,
          typename Index2>
void remap(detail::TensorInterface<T, Range_, OpResult>&, T* const,
           const std::initializer_list<Index1>&,
           const std::initializer_list<Index2>&);
template <typename T, typename Range_, typename OpResult, typename Index1,
          typename Index2>
void remap(detail::TensorInterface<const T, Range_, OpResult>&, T* const,
           const std::initializer_list<Index1>&,
           const std::initializer_list<Index2>&);
 
namespace detail {
 
 
template <typename T, typename R, typename OpResult>
class TensorInterface {
 public:
  typedef TensorInterface<T, R, OpResult>
      TensorInterface_;                                  
  typedef R range_type;                                  
  typedef typename range_type::index1_type index1_type;  
  typedef typename range_type::ordinal_type ordinal_type;  
  using size_type = ordinal_type;
  typedef
      typename std::remove_const<T>::type value_type;  
  typedef typename std::add_lvalue_reference<T>::type
      reference;  
  typedef
      typename std::add_lvalue_reference<typename std::add_const<T>::type>::type
          const_reference;  
  typedef typename std::add_pointer<T>::type pointer;  
  typedef typename std::add_pointer<typename std::add_const<T>::type>::type
      const_pointer;                                
  typedef typename std::ptrdiff_t difference_type;  
  typedef typename detail::numeric_type<value_type>::type
      numeric_type;  
  typedef typename detail::scalar_type<value_type>::type
      scalar_type;  
 
  typedef OpResult result_tensor;
 
 private:
  template <typename X>
  using numeric_t = typename TiledArray::detail::numeric_type<X>::type;
 
  template <typename, typename, typename>
  friend class TensorInterface;
 
  template <typename U, typename Range_, typename OpResult_, typename Index1,
            typename Index2>
  friend void TiledArray::remap(detail::TensorInterface<U, Range_, OpResult_>&,
                                U* const, const Index1&, const Index2&);
  template <typename U, typename Range_, typename OpResult_, typename Index1,
            typename Index2>
  friend void TiledArray::remap(
      detail::TensorInterface<const U, Range_, OpResult_>&, U* const,
      const Index1&, const Index2&);
  template <typename U, typename Range_, typename OpResult_, typename Index1,
            typename Index2>
  friend void TiledArray::remap(detail::TensorInterface<U, Range_, OpResult_>&,
                                U* const, const std::initializer_list<Index1>&,
                                const std::initializer_list<Index2>&);
  template <typename U, typename Range_, typename OpResult_, typename Index1,
            typename Index2>
  friend void TiledArray::remap(
      detail::TensorInterface<const U, Range_, OpResult_>&, U* const,
      const std::initializer_list<Index1>&,
      const std::initializer_list<Index2>&);
 
  range_type range_;  
  pointer data_;      
 
 public:
  TensorInterface() = delete;
  ~TensorInterface() = default;
  TensorInterface(const TensorInterface_&) = default;
  TensorInterface(TensorInterface_&&) = default;
  TensorInterface_& operator=(const TensorInterface_&) = delete;
  TensorInterface_& operator=(TensorInterface_&&) = delete;
 
 
  template <typename U, typename UOpResult,
            typename std::enable_if<std::is_convertible<
                typename TensorInterface<U, R, UOpResult>::pointer,
                pointer>::value>::type* = nullptr>
  TensorInterface(const TensorInterface<U, R, UOpResult>& other)
      : range_(other.range_), data_(other.data_) {}
 
 
  template <typename U, typename UOpResult,
            typename std::enable_if<std::is_convertible<
                typename TensorInterface<U, R, UOpResult>::pointer,
                pointer>::value>::type* = nullptr>
  TensorInterface(TensorInterface<U, R, UOpResult>&& other)
      : range_(std::move(other.range_)), data_(other.data_) {
    other.data_ = nullptr;
  }
 
 
  TensorInterface(const range_type& range, pointer data)
      : range_(range), data_(data) {
    TA_ASSERT(data);
  }
 
 
  TensorInterface(range_type&& range, pointer data)
      : range_(std::move(range)), data_(data) {
    TA_ASSERT(data);
  }
 
  template <typename T1, typename std::enable_if<
                             detail::is_tensor<T1>::value>::type* = nullptr>
  TensorInterface_& operator=(const T1& other) {
    TA_ASSERT(data_ != other.data());
 
    detail::inplace_tensor_op([](numeric_type& MADNESS_RESTRICT result,
                                 const numeric_t<T1> arg) { result = arg; },
                              *this, other);
 
    return *this;
  }
 
 
  const range_type& range() const { return range_; }
 
 
  ordinal_type size() const { return range_.volume(); }
 
 
  pointer data() const { return data_; }
 
 
  const_reference operator[](const ordinal_type index) const {
    TA_ASSERT(range_.includes(index));
    return data_[range_.ordinal(index)];
  }
 
 
  reference operator[](const ordinal_type index) {
    TA_ASSERT(range_.includes(index));
    return data_[range_.ordinal(index)];
  }
 
 
  template <typename... Index>
  reference operator()(const Index&... idx) {
    TA_ASSERT(range_.includes(idx...));
    return data_[range_.ordinal(idx...)];
  }
 
 
  template <typename... Index>
  const_reference operator()(const Index&... idx) const {
    TA_ASSERT(range_.includes(idx...));
    return data_[range_.ordinal(idx...)];
  }
 
 
  constexpr bool empty() const { return false; }
 
 
  void swap(TensorInterface_& other) {
    range_.swap(other.range_);
    std::swap(data_, other.data_);
  }
 
 
  template <typename Index,
            typename = std::enable_if_t<detail::is_integral_range_v<Index>>>
  TensorInterface_& shift_to(const Index& bound_shift) {
    range_.inplace_shift(bound_shift);
    return *this;
  }
 
 
  template <typename Index,
            typename = std::enable_if_t<std::is_integral_v<Index>>>
  TensorInterface_& shift_to(const std::initializer_list<Index>& bound_shift) {
    range_.inplace_shift(bound_shift);
    return *this;
  }
 
 
  template <typename Index,
            typename = std::enable_if_t<detail::is_integral_range_v<Index>>>
  result_tensor shift(const Index& bound_shift) const {
    return result_tensor(range_.shift(bound_shift), data_);
  }
 
 
  template <typename Index,
            typename = std::enable_if_t<std::is_integral_v<Index>>>
  result_tensor shift(const std::initializer_list<Index>& bound_shift) const {
    return result_tensor(range_.shift(bound_shift), data_);
  }
 
  // Generic vector operations
 
 
  template <typename Right, typename Op,
            typename std::enable_if<is_tensor<Right>::value>::type* = nullptr>
  result_tensor binary(const Right& right, Op&& op) const {
    //        return result_tensor(*this, right, op);
    result_tensor new_tensor(detail::clone_range(*this));
    detail::tensor_init(std::forward<Op>(op), new_tensor, *this, right);
    return new_tensor;
  }
 
 
  template <
      typename Right, typename Op, typename Perm,
      typename std::enable_if<is_tensor<Right>::value &&
                              detail::is_permutation_v<Perm>>::type* = nullptr>
  result_tensor binary(const Right& right, Op&& op, const Perm& perm) const {
    //        return result_tensor(*this, right, op, perm);
    result_tensor new_tensor(outer(perm) * this->range());
    detail::tensor_init(std::forward<Op>(op), outer(perm), new_tensor, *this,
                        right);
 
    // If we actually have a ToT the inner permutation was not applied above so
    // we do that now
    constexpr bool is_tot = detail::is_tensor_of_tensor_v<TensorInterface>;
    constexpr bool is_bperm = detail::is_bipartite_permutation_v<Perm>;
    if constexpr (is_tot && is_bperm) {
      if (inner_size(perm) != 0) {
        auto inner_perm = inner(perm);
        Permute<T, T> p;
        for (auto& x : new_tensor) x = p(x, inner_perm);
      }
    }
 
    return new_tensor;
  }
 
 
  template <typename Right, typename Op,
            typename std::enable_if<is_tensor<Right>::value>::type* = nullptr>
  TensorInterface_& inplace_binary(const Right& right, Op&& op) {
    detail::inplace_tensor_op(std::forward<Op>(op), *this, right);
    return *this;
  }
 
 
  template <typename Op>
  result_tensor unary(Op&& op) const {
    //        return result_tensor(*this, op);
    result_tensor new_tensor(detail::clone_range(*this));
    detail::tensor_init(std::forward<Op>(op), new_tensor, *this);
    return new_tensor;
  }
 
 
  template <typename Op, typename Perm,
            typename = std::enable_if_t<detail::is_permutation_v<Perm>>>
  result_tensor unary(Op&& op, const Perm& perm) const {
    result_tensor new_tensor(outer(perm) * this->range());
    detail::tensor_init(std::forward<Op>(op), outer(perm), new_tensor, *this);
 
    // If we actually have a ToT the inner permutation was not applied above so
    // we do that now
    constexpr bool is_tot = detail::is_tensor_of_tensor_v<TensorInterface>;
    constexpr bool is_bperm = detail::is_bipartite_permutation_v<Perm>;
    if constexpr (is_tot && is_bperm) {
      if (inner_size(perm) != 0) {
        auto inner_perm = inner(perm);
        Permute<T, T> p;
        for (auto& x : new_tensor) x = p(x, inner_perm);
      }
    }
 
    return new_tensor;
  }
 
 
  template <typename Op>
  TensorInterface_& inplace_unary(Op&& op) {
    detail::inplace_tensor_op(std::forward<Op>(op), *this);
    return *this;
  }
 
  // permute operation
  // construct a permuted copy of this tensor
  template <typename Perm,
            typename = std::enable_if_t<detail::is_permutation_v<Perm>>>
  result_tensor permute(const Perm& perm) const {
    auto op = [](const T& arg) { return arg; };
    result_tensor new_tensor(outer(perm) * this->range());
    TiledArray::detail::tensor_init(op, outer(perm), new_tensor, *this);
 
    // If we actually have a ToT the inner permutation was not applied above so
    // we do that now
    constexpr bool is_tot = detail::is_tensor_of_tensor_v<TensorInterface>;
    constexpr bool is_bperm = detail::is_bipartite_permutation_v<Perm>;
    if constexpr (is_tot && is_bperm) {
      if (inner_size(perm) != 0) {
        auto inner_perm = inner(perm);
        Permute<T, T> p;
        for (auto& x : new_tensor) x = p(x, inner_perm);
      }
    }
 
    return new_tensor;
  }
 
  // Scale operation
 
 
  template <typename Scalar, typename std::enable_if<
                                 detail::is_numeric_v<Scalar>>::type* = nullptr>
  result_tensor scale(const Scalar factor) const {
    return unary(
        [factor](const numeric_type a) -> numeric_type { return a * factor; });
  }
 
 
  template <
      typename Scalar, typename Perm,
      typename std::enable_if<detail::is_numeric_v<Scalar> &&
                              detail::is_permutation_v<Perm>>::type* = nullptr>
  result_tensor scale(const Scalar factor, const Perm& perm) const {
    return unary(
        [factor](const numeric_type a) -> numeric_type { return a * factor; },
        perm);
  }
 
 
  template <typename Scalar, typename std::enable_if<
                                 detail::is_numeric_v<Scalar>>::type* = nullptr>
  TensorInterface_& scale_to(const Scalar factor) {
    return inplace_unary(
        [factor](numeric_type& MADNESS_RESTRICT res) { res *= factor; });
  }
 
  // Addition operations
 
 
  template <typename Right,
            typename std::enable_if<is_tensor<Right>::value>::type* = nullptr>
  result_tensor add(const Right& right) const {
    return binary(
        right,
        [](const numeric_type l, const numeric_t<Right> r) -> numeric_type {
          return l + r;
        });
  }
 
 
  template <
      typename Right, typename Perm,
      typename std::enable_if<is_tensor<Right>::value &&
                              detail::is_permutation_v<Perm>>::type* = nullptr>
  result_tensor add(const Right& right, const Perm& perm) const {
    return binary(
        right,
        [](const numeric_type l, const numeric_t<Right> r) -> numeric_type {
          return l + r;
        },
        perm);
  }
 
 
  template <
      typename Right, typename Scalar,
      typename std::enable_if<is_tensor<Right>::value &&
                              detail::is_numeric_v<Scalar>>::type* = nullptr>
  result_tensor add(const Right& right, const Scalar factor) const {
    return binary(right,
                  [factor](const numeric_type l, const numeric_t<Right> r)
                      -> numeric_type { return (l + r) * factor; });
  }
 
 
  template <typename Right, typename Scalar, typename Perm,
            typename std::enable_if<
                is_tensor<Right>::value && detail::is_numeric_v<Scalar> &&
                detail::is_permutation_v<Perm>>::type* = nullptr>
  result_tensor add(const Right& right, const Scalar factor,
                    const Perm& perm) const {
    return binary(
        right,
        [factor](const numeric_type l, const numeric_t<Right> r)
            -> numeric_type { return (l + r) * factor; },
        perm);
  }
 
 
  result_tensor add(const numeric_type value) const {
    return unary(
        [value](const numeric_type a) -> numeric_type { return a + value; });
  }
 
 
  template <typename Perm,
            typename = std::enable_if_t<detail::is_permutation_v<Perm>>>
  result_tensor add(const numeric_type value, const Perm& perm) const {
    return unary(
        [value](const numeric_type a) -> numeric_type { return a + value; },
        perm);
  }
 
 
  template <typename Right,
            typename std::enable_if<is_tensor<Right>::value>::type* = nullptr>
  TensorInterface_& add_to(const Right& right) {
    return inplace_binary(right, [](numeric_type& MADNESS_RESTRICT l,
                                    const numeric_t<Right> r) { l += r; });
  }
 
 
  template <
      typename Right, typename Scalar,
      typename std::enable_if<is_tensor<Right>::value &&
                              detail::is_numeric_v<Scalar>>::type* = nullptr>
  TensorInterface_& add_to(const Right& right, const Scalar factor) {
    return inplace_binary(
        right, [factor](numeric_type& MADNESS_RESTRICT l,
                        const numeric_t<Right> r) { (l += r) *= factor; });
  }
 
 
  TensorInterface_& add_to(const numeric_type value) {
    return inplace_unary(
        [value](numeric_type& MADNESS_RESTRICT res) { res += value; });
  }
 
  // Subtraction operations
 
 
  template <typename Right,
            typename std::enable_if<is_tensor<Right>::value>::type* = nullptr>
  result_tensor subt(const Right& right) const {
    return binary(
        right,
        [](const numeric_type l, const numeric_t<Right> r) -> numeric_type {
          return l - r;
        });
  }
 
 
  template <
      typename Right, typename Perm,
      typename std::enable_if<is_tensor<Right>::value &&
                              detail::is_permutation_v<Perm>>::type* = nullptr>
  result_tensor subt(const Right& right, const Perm& perm) const {
    return binary(
        right,
        [](const numeric_type l, const numeric_t<Right> r) -> numeric_type {
          return l - r;
        },
        perm);
  }
 
 
  template <
      typename Right, typename Scalar,
      typename std::enable_if<is_tensor<Right>::value &&
                              detail::is_numeric_v<Scalar>>::type* = nullptr>
  result_tensor subt(const Right& right, const Scalar factor) const {
    return binary(right,
                  [factor](const numeric_type l, const numeric_t<Right> r)
                      -> numeric_type { return (l - r) * factor; });
  }
 
 
  template <typename Right, typename Scalar, typename Perm,
            typename std::enable_if<
                is_tensor<Right>::value && detail::is_numeric_v<Scalar> &&
                detail::is_permutation_v<Perm>>::type* = nullptr>
  result_tensor subt(const Right& right, const Scalar factor,
                     const Perm& perm) const {
    return binary(
        right,
        [factor](const numeric_type l, const numeric_t<Right> r)
            -> numeric_type { return (l - r) * factor; },
        perm);
  }
 
 
  result_tensor subt(const numeric_type value) const { return add(-value); }
 
 
  template <typename Perm,
            typename = std::enable_if_t<detail::is_permutation_v<Perm>>>
  result_tensor subt(const numeric_type value, const Perm& perm) const {
    return add(-value, perm);
  }
 
 
  template <typename Right,
            typename std::enable_if<is_tensor<Right>::value>::type* = nullptr>
  TensorInterface_& subt_to(const Right& right) {
    return inplace_binary(right, [](numeric_type& MADNESS_RESTRICT l,
                                    const numeric_t<Right> r) { l -= r; });
  }
 
 
  template <
      typename Right, typename Scalar,
      typename std::enable_if<is_tensor<Right>::value &&
                              detail::is_numeric_v<Scalar>>::type* = nullptr>
  TensorInterface_& subt_to(const Right& right, const Scalar factor) {
    return inplace_binary(
        right, [factor](numeric_type& MADNESS_RESTRICT l,
                        const numeric_t<Right> r) { (l -= r) *= factor; });
  }
 
 
  TensorInterface_& subt_to(const numeric_type value) { return add_to(-value); }
 
  // Multiplication operations
 
 
  template <typename Right,
            typename std::enable_if<is_tensor<Right>::value>::type* = nullptr>
  result_tensor mult(const Right& right) const {
    return binary(
        right,
        [](const numeric_type l, const numeric_t<Right> r) -> numeric_type {
          return l * r;
        });
  }
 
 
  template <
      typename Right, typename Perm,
      typename std::enable_if<is_tensor<Right>::value &&
                              detail::is_permutation_v<Perm>>::type* = nullptr>
  result_tensor mult(const Right& right, const Perm& perm) const {
    return binary(
        right,
        [](const numeric_type l, const numeric_t<Right> r) -> numeric_type {
          return l * r;
        },
        perm);
  }
 
 
  template <
      typename Right, typename Scalar,
      typename std::enable_if<is_tensor<Right>::value &&
                              detail::is_numeric_v<Scalar>>::type* = nullptr>
  result_tensor mult(const Right& right, const Scalar factor) const {
    return binary(right,
                  [factor](const numeric_type l, const numeric_t<Right> r)
                      -> numeric_type { return (l * r) * factor; });
  }
 
 
  template <typename Right, typename Scalar, typename Perm,
            typename std::enable_if<
                is_tensor<Right>::value && detail::is_numeric_v<Scalar> &&
                detail::is_permutation_v<Perm>>::type* = nullptr>
  result_tensor mult(const Right& right, const Scalar factor,
                     const Perm& perm) const {
    return binary(
        right,
        [factor](const numeric_type l, const numeric_t<Right> r)
            -> numeric_type { return (l * r) * factor; },
        perm);
  }
 
 
  template <typename Right,
            typename std::enable_if<is_tensor<Right>::value>::type* = nullptr>
  TensorInterface_& mult_to(const Right& right) {
    return inplace_binary(right, [](numeric_type& MADNESS_RESTRICT l,
                                    const numeric_t<Right> r) { l *= r; });
  }
 
 
  template <
      typename Right, typename Scalar,
      typename std::enable_if<is_tensor<Right>::value &&
                              detail::is_numeric_v<Scalar>>::type* = nullptr>
  TensorInterface_& mult_to(const Right& right, const Scalar factor) {
    return inplace_binary(
        right, [factor](numeric_type& MADNESS_RESTRICT l,
                        const numeric_t<Right> r) { (l *= r) *= factor; });
  }
 
  // Negation operations
 
 
  result_tensor neg() const {
    return unary([](const numeric_type r) -> numeric_type { return -r; });
  }
 
 
  template <typename Perm,
            typename = std::enable_if_t<detail::is_permutation_v<Perm>>>
  result_tensor neg(const Perm& perm) const {
    return unary([](const numeric_type l) -> numeric_type { return -l; }, perm);
  }
 
 
  TensorInterface_& neg_to() {
    return inplace_unary([](numeric_type& MADNESS_RESTRICT l) { l = -l; });
  }
 
 
  result_tensor conj() const { return scale(conj_op()); }
 
 
  template <typename Scalar, typename std::enable_if<
                                 detail::is_numeric_v<Scalar>>::type* = nullptr>
  result_tensor conj(const Scalar factor) const {
    return scale(conj_op(factor));
  }
 
 
  template <typename Perm,
            typename = std::enable_if_t<detail::is_permutation_v<Perm>>>
  result_tensor conj(const Perm& perm) const {
    return scale(conj_op(), perm);
  }
 
 
  template <
      typename Scalar, typename Perm,
      typename std::enable_if<detail::is_numeric_v<Scalar> &&
                              detail::is_permutation_v<Perm>>::type* = nullptr>
  result_tensor conj(const Scalar factor, const Perm& perm) const {
    return scale(conj_op(factor), perm);
  }
 
 
  TensorInterface_& conj_to() { return scale_to(conj_op()); }
 
 
  template <typename Scalar, typename std::enable_if<
                                 detail::is_numeric_v<Scalar>>::type* = nullptr>
  TensorInterface_& conj_to(const Scalar factor) {
    return scale_to(conj_op(factor));
  }
 
 
  template <typename ReduceOp, typename JoinOp>
  numeric_type reduce(ReduceOp&& reduce_op, JoinOp&& join_op,
                      const numeric_type identity) const {
    return detail::tensor_reduce(std::forward<ReduceOp>(reduce_op),
                                 std::forward<JoinOp>(join_op), identity,
                                 *this);
  }
 
 
  template <typename Right, typename ReduceOp, typename JoinOp,
            typename std::enable_if<is_tensor<Right>::value>::type* = nullptr>
  numeric_type reduce(const Right& other, ReduceOp&& reduce_op,
                      JoinOp&& join_op, const numeric_type identity) const {
    return detail::tensor_reduce(std::forward<ReduceOp>(reduce_op),
                                 std::forward<JoinOp>(join_op), identity, *this,
                                 other);
  }
 
 
  numeric_type sum() const {
    auto sum_op = [](numeric_type& MADNESS_RESTRICT res,
                     const numeric_type arg) { res += arg; };
    return reduce(sum_op, sum_op, numeric_type(0));
  }
 
 
  numeric_type product() const {
    auto mult_op = [](numeric_type& MADNESS_RESTRICT res,
                      const numeric_type arg) { res *= arg; };
    return reduce(mult_op, mult_op, numeric_type(1));
  }
 
 
  scalar_type squared_norm() const {
    auto square_op = [](scalar_type& MADNESS_RESTRICT res,
                        const numeric_type arg) {
      res += TiledArray::detail::norm(arg);
    };
    auto sum_op = [](scalar_type& MADNESS_RESTRICT res, const scalar_type arg) {
      res += arg;
    };
    return reduce(square_op, sum_op, numeric_type(0));
  }
 
 
  template <typename ResultType = numeric_type>
  ResultType norm() const {
    return std::sqrt(static_cast<ResultType>(squared_norm()));
  }
 
 
  numeric_type min() const {
    auto min_op = [](numeric_type& MADNESS_RESTRICT res,
                     const numeric_type arg) { res = std::min(res, arg); };
    return reduce(min_op, min_op, std::numeric_limits<numeric_type>::max());
  }
 
 
  numeric_type max() const {
    auto max_op = [](numeric_type& MADNESS_RESTRICT res,
                     const numeric_type arg) { res = std::max(res, arg); };
    return reduce(max_op, max_op, std::numeric_limits<numeric_type>::min());
  }
 
 
  numeric_type abs_min() const {
    auto abs_min_op = [](numeric_type& MADNESS_RESTRICT res,
                         const numeric_type arg) {
      res = std::min(res, std::abs(arg));
    };
    auto min_op = [](numeric_type& MADNESS_RESTRICT res,
                     const numeric_type arg) { res = std::min(res, arg); };
    return reduce(abs_min_op, min_op, std::numeric_limits<numeric_type>::max());
  }
 
 
  numeric_type abs_max() const {
    auto abs_max_op = [](numeric_type& MADNESS_RESTRICT res,
                         const numeric_type arg) {
      res = std::max(res, std::abs(arg));
    };
    auto max_op = [](numeric_type& MADNESS_RESTRICT res,
                     const numeric_type arg) { res = std::max(res, arg); };
    return reduce(abs_max_op, max_op, numeric_type(0));
  }
 
 
  template <typename Right,
            typename std::enable_if<is_tensor<Right>::value>::type* = nullptr>
  numeric_type dot(const Right& other) const {
    auto mult_add_op = [](numeric_type& res, const numeric_type l,
                          const numeric_t<Right> r) { res += l * r; };
    auto add_op = [](numeric_type& MADNESS_RESTRICT res,
                     const numeric_type value) { res += value; };
    return reduce(other, mult_add_op, add_op, numeric_type(0));
  }
 
  template <typename Right,
            typename std::enable_if<is_tensor<Right>::value>::type* = nullptr>
  numeric_type inner_product(const Right& other) const {
    auto mult_add_op = [](numeric_type& res, const numeric_type l,
                          const numeric_t<Right> r) {
      res += TiledArray::detail::inner_product(l, r);
    };
    auto add_op = [](numeric_type& MADNESS_RESTRICT res,
                     const numeric_type value) { res += value; };
    return reduce(other, mult_add_op, add_op, numeric_type(0));
  }
 
};  // class TensorInterface
 
 
template <typename T, typename Range, typename OpResult>
bool operator==(const TensorInterface<T, Range, OpResult>& first,
                const TensorInterface<T, Range, OpResult>& second) {
  return first.data() == second.data() && first.range() == second.range();
}
 
}  // namespace detail
}  // namespace TiledArray
 
#endif  // TILEDARRAY_TENSOR_TENSOR_VIEW_H__INCLUDED