tile_interface.h

Go to the documentation of this file.

/*
 *  This file is a part of TiledArray.
 *  Copyright (C) 2014  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
 *
 *  tile_interface.h
 *  Sep 29, 2014
 *
 */
 
#ifndef TILEDARRAY_NONINTRUSIVE_API_TENSOR_H__INCLUDED
#define TILEDARRAY_NONINTRUSIVE_API_TENSOR_H__INCLUDED
 
#include <TiledArray/tensor/type_traits.h>
#include <TiledArray/type_traits.h>
#include <iterator>
#include <vector>
 
namespace TiledArray {
 
// Forward declaration
namespace math {
class GemmHelper;
}  // namespace math
namespace detail {
template <typename, typename>
class LazyArrayTile;
}  // namespace detail
 
// Empty operations ----------------------------------------------------------
 
// to check that `arg` is empty (no data) just use std::empty
 
using std::empty;
 
// Subtraction ---------------------------------------------------------------
 
 
template <typename Left, typename Right>
inline auto subt(const Left& left, const Right& right) {
  return left.subt(right);
}
 
 
template <
    typename Left, typename Right, typename Scalar,
    typename std::enable_if<detail::is_numeric_v<Scalar>>::type* = nullptr>
inline auto subt(const Left& left, const Right& right, const Scalar factor) {
  return left.subt(right, factor);
}
 
 
template <typename Left, typename Right, typename Perm,
          typename = std::enable_if_t<detail::is_permutation_v<Perm>>>
inline auto subt(const Left& left, const Right& right, const Perm& perm) {
  return left.subt(right, perm);
}
 
 
template <
    typename Left, typename Right, typename Scalar, typename Perm,
    typename std::enable_if<detail::is_numeric_v<Scalar> &&
                            detail::is_permutation_v<Perm>>::type* = nullptr>
inline auto subt(const Left& left, const Right& right, const Scalar factor,
                 const Perm& perm) {
  return left.subt(right, factor, perm);
}
 
 
template <
    typename Arg, typename Scalar,
    typename std::enable_if<detail::is_numeric_v<Scalar>>::type* = nullptr>
inline auto subt(const Arg& arg, const Scalar value) {
  return arg.subt(value);
}
 
 
template <
    typename Arg, typename Scalar, typename Perm,
    typename std::enable_if<detail::is_numeric_v<Scalar> &&
                            detail::is_permutation_v<Perm>>::type* = nullptr>
inline auto subt(const Arg& arg, const Scalar value, const Perm& perm) {
  return arg.subt(value, perm);
}
 
 
template <typename Result, typename Arg>
inline Result& subt_to(Result& result, const Arg& arg) {
  return result.subt_to(arg);
}
 
 
template <
    typename Result, typename Arg, typename Scalar,
    typename std::enable_if<detail::is_numeric_v<Scalar>>::type* = nullptr>
inline Result& subt_to(Result& result, const Arg& arg, const Scalar factor) {
  return result.subt_to(arg, factor);
}
 
 
template <
    typename Result, typename Scalar,
    typename std::enable_if<detail::is_numeric_v<Scalar>>::type* = nullptr>
inline Result& subt_to(Result& result, const Scalar value) {
  return result.subt_to(value);
}
 
template <typename... T>
using result_of_subt_t = decltype(subt(std::declval<T>()...));
 
template <typename... T>
using result_of_subt_to_t = decltype(subt_to(std::declval<T>()...));
 
// Multiplication operations -------------------------------------------------
 
 
template <typename Left, typename Right>
inline auto mult(const Left& left, const Right& right) {
  return left.mult(right);
}
 
 
template <typename Left, typename Right, typename Scalar,
          std::enable_if_t<TiledArray::detail::is_numeric_v<Scalar>>* = nullptr>
inline auto mult(const Left& left, const Right& right, const Scalar factor) {
  return left.mult(right, factor);
}
 
 
template <
    typename Left, typename Right, typename Perm,
    typename = std::enable_if_t<detail::is_permutation_v<Perm> &&
                                detail::has_member_function_mult_anyreturn_v<
                                    const Left, const Right&, const Perm&>>>
inline auto mult(const Left& left, const Right& right, const Perm& perm) {
  return left.mult(right, perm);
}
 
 
template <typename Left, typename Right, typename Scalar, typename Perm,
          std::enable_if_t<TiledArray::detail::is_numeric_v<Scalar> &&
                           detail::is_permutation_v<Perm>>* = nullptr>
inline auto mult(const Left& left, const Right& right, const Scalar factor,
                 const Perm& perm) {
  return left.mult(right, factor, perm);
}
 
 
template <typename Result, typename Arg>
inline Result& mult_to(Result& result, const Arg& arg) {
  return result.mult_to(arg);
}
 
 
template <typename Result, typename Arg, typename Scalar,
          std::enable_if_t<TiledArray::detail::is_numeric_v<Scalar>>* = nullptr>
inline Result& mult_to(Result& result, const Arg& arg, const Scalar factor) {
  return result.mult_to(arg, factor);
}
 
template <typename... T>
using result_of_mult_t = decltype(mult(std::declval<T>()...));
 
template <typename... T>
using result_of_mult_to_t = decltype(mult_to(std::declval<T>()...));
 
// Generic element-wise binary operations
// ---------------------------------------------
 
// clang-format off
 
// clang-format on
template <typename Left, typename Right, typename Op>
inline decltype(auto) binary(const Left& left, const Right& right, Op&& op) {
  return left.binary(right, std::forward<Op>(op));
}
 
// clang-format off
 
// clang-format on
template <typename Left, typename Right, typename Op, typename Perm,
          typename = std::enable_if_t<detail::is_permutation_v<Perm>>>
inline decltype(auto) binary(const Left& left, const Right& right, Op&& op,
                             const Perm& perm) {
  return left.binary(right, std::forward<Op>(op), perm);
}
 
// clang-format off
 
// clang-format on
template <typename Left, typename Right, typename Op>
inline Left& inplace_binary(Left& left, const Right& right, Op&& op) {
  return left.inplace_binary(right, std::forward<Op>(op));
}
 
template <typename... T>
using result_of_binary_t = decltype(binary(std::declval<T>()...));
 
template <typename... T>
using result_of_inplace_binary_t =
    decltype(inplace_binary(std::declval<T>()...));
 
// Scaling operations --------------------------------------------------------
 
// see tile_interface/scale.h
 
// Negation operations -------------------------------------------------------
 
 
template <typename Arg>
inline auto neg(const Arg& arg) {
  return arg.neg();
}
 
 
template <typename Arg, typename Perm,
          typename = std::enable_if_t<detail::is_permutation_v<Perm>>>
inline auto neg(const Arg& arg, const Perm& perm) {
  return arg.neg(perm);
}
 
 
template <typename Result>
inline Result& neg_to(Result& result) {
  return result.neg_to();
}
 
template <typename... T>
using result_of_neg_t = decltype(neg(std::declval<T>()...));
 
template <typename... T>
using result_of_neg_to_t = decltype(neg_to(std::declval<T>()...));
 
// Complex conjugate operations ---------------------------------------------
 
 
template <typename Arg>
inline auto conj(const Arg& arg) {
  return arg.conj();
}
 
 
template <typename Arg, typename Scalar,
          typename std::enable_if<
              TiledArray::detail::is_numeric_v<Scalar>>::type* = nullptr>
inline auto conj(const Arg& arg, const Scalar factor) {
  return arg.conj(factor);
}
 
 
template <typename Arg, typename Perm,
          typename = std::enable_if_t<detail::is_permutation_v<Perm>>>
inline auto conj(const Arg& arg, const Perm& perm) {
  return arg.conj(perm);
}
 
 
template <
    typename Arg, typename Scalar, typename Perm,
    typename std::enable_if<TiledArray::detail::is_numeric_v<Scalar> &&
                            detail::is_permutation_v<Perm>>::type* = nullptr>
inline auto conj(const Arg& arg, const Scalar factor, const Perm& perm) {
  return arg.conj(factor, perm);
}
 
 
template <typename Result>
inline Result& conj_to(Result& result) {
  return result.conj_to();
}
 
 
template <typename Result, typename Scalar,
          typename std::enable_if<
              TiledArray::detail::is_numeric_v<Scalar>>::type* = nullptr>
inline Result& conj_to(Result& result, const Scalar factor) {
  return result.conj_to(factor);
}
 
template <typename... T>
using result_of_conj_t = decltype(conj(std::declval<T>()...));
 
template <typename... T>
using result_of_conj_to_t = decltype(conj_to(std::declval<T>()...));
 
// Generic element-wise unary operations
// ---------------------------------------------
 
// clang-format off
 
// clang-format on
template <typename Arg, typename Op>
inline decltype(auto) unary(const Arg& arg, Op&& op) {
  return arg.unary(std::forward<Op>(op));
}
 
// clang-format off
 
// clang-format on
template <typename Arg, typename Op, typename Perm,
          typename = std::enable_if_t<detail::is_permutation_v<Perm>>>
inline decltype(auto) unary(const Arg& arg, Op&& op, const Perm& perm) {
  return arg.unary(std::forward<Op>(op), perm);
}
 
// clang-format off
 
// clang-format on
template <typename Result, typename Op>
inline Result& inplace_unary(Result& arg, Op&& op) {
  return arg.inplace_unary(std::forward<Op>(op));
}
 
template <typename... T>
using result_of_unary_t = decltype(unary(std::declval<T>()...));
 
template <typename... T>
using result_of_inplace_unary_t = decltype(inplace_unary(std::declval<T>()...));
 
// Contraction operations ----------------------------------------------------
 
 
template <typename Left, typename Right, typename Scalar,
          std::enable_if_t<TiledArray::detail::is_numeric_v<Scalar>>* = nullptr>
inline auto gemm(const Left& left, const Right& right, const Scalar factor,
                 const math::GemmHelper& gemm_config) {
  return left.gemm(right, factor, gemm_config);
}
 
 
template <typename Result, typename Left, typename Right, typename Scalar,
          std::enable_if_t<TiledArray::detail::is_numeric_v<Scalar>>* = nullptr>
inline Result& gemm(Result& result, const Left& left, const Right& right,
                    const Scalar factor, const math::GemmHelper& gemm_config) {
  return result.gemm(left, right, factor, gemm_config);
}
 
 
template <typename Result, typename Left, typename Right,
          typename ElementMultiplyAddOp,
          std::enable_if_t<std::is_invocable_r_v<
              void, std::remove_reference_t<ElementMultiplyAddOp>,
              typename Result::value_type&, const typename Left::value_type&,
              const typename Right::value_type&>>* = nullptr>
inline Result& gemm(Result& result, const Left& left, const Right& right,
                    const math::GemmHelper& gemm_config,
                    ElementMultiplyAddOp&& element_multiplyadd_op) {
  return result.gemm(
      left, right, gemm_config,
      std::forward<ElementMultiplyAddOp>(element_multiplyadd_op));
}
 
template <typename... T>
using result_of_gemm_t = decltype(gemm(std::declval<T>()...));
 
// Reduction operations ------------------------------------------------------
 
 
// template <typename Arg>
// inline auto trace(const Arg& arg) {
//  return arg.trace();
//}
 
 
template <typename Arg>
inline auto sum(const Arg& arg) {
  return arg.sum();
}
 
 
template <typename Arg>
inline auto product(const Arg& arg) {
  return arg.product();
}
 
 
template <typename Arg>
inline auto squared_norm(const Arg& arg) {
  return arg.squared_norm();
}
 
 
template <typename Arg>
inline auto norm(const Arg& arg) {
  return arg.norm();
}
 
 
template <typename Arg, typename ResultType>
inline void norm(const Arg& arg, ResultType& result) {
  result = arg.template norm<ResultType>();
}
 
 
template <typename Arg>
inline auto max(const Arg& arg) {
  return arg.max();
}
 
 
template <typename Arg>
inline auto min(const Arg& arg) {
  return arg.min();
}
 
 
template <typename Arg>
inline auto abs_max(const Arg& arg) {
  return arg.abs_max();
}
 
 
template <typename Arg>
inline auto abs_min(const Arg& arg) {
  return arg.abs_min();
}
 
 
template <typename Left, typename Right>
inline auto dot(const Left& left, const Right& right) {
  return left.dot(right);
}
 
 
template <typename Left, typename Right>
inline auto inner_product(const Left& left, const Right& right) {
  return left.inner_product(right);
}
 
// template <typename T>
// using result_of_trace_t = decltype(mult(std::declval<T>()));
 
template <typename T>
using result_of_sum_t = decltype(sum(std::declval<T>()));
 
template <typename T>
using result_of_product_t = decltype(product(std::declval<T>()));
 
template <typename T>
using result_of_squared_norm_t = decltype(squared_norm(std::declval<T>()));
 
template <typename T, typename ResultType = T>
using result_of_norm_t =
    decltype(norm(std::declval<T>(), std::declval<ResultType&>()));
 
template <typename T>
using result_of_max_t = decltype(max(std::declval<T>()));
 
template <typename T>
using result_of_min_t = decltype(min(std::declval<T>()));
 
template <typename T>
using result_of_abs_max_t = decltype(abs_max(std::declval<T>()));
 
template <typename T>
using result_of_abs_min_t = decltype(abs_min(std::declval<T>()));
 
template <typename L, typename R>
using result_of_dot_t = decltype(dot(std::declval<L>(), std::declval<R>()));
 
}  // namespace TiledArray
 
#endif /* TILEDARRAY_NONINTRUSIVE_API_TENSOR_H__INCLUDED */