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/>.
 *
 *  Justusu 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/type_traits.h>
#include <vector>

namespace TiledArray {

  // Forward declaration
  class Permutation;
  namespace math {
    class GemmHelper;
  }  // namespace math
  namespace detail {
    template <typename, typename> class LazyArrayTile;
  }  // namespace detail

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


  template <typename Arg>
  inline bool empty(const Arg& arg) {
    return arg.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<Scalar>::value>::type* = nullptr>
  inline auto subt(const Left& left, const Right& right, const Scalar factor)
  { return left.subt(right, factor); }


  template <typename Left, typename Right>
  inline auto
  subt(const Left& left, const Right& right, const Permutation& perm)
  { return left.subt(right, perm); }


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


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


  template <typename Arg, typename Scalar,
      typename std::enable_if<detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline auto
  subt(const Arg& arg, const Scalar value, const Permutation& 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<Scalar>::value>::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<Scalar>::value>::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,
      typename std::enable_if<TiledArray::detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline auto mult(const Left& left, const Right& right, const Scalar factor)
  { return left.mult(right, factor); }


  template <typename Left, typename Right>
  inline auto
  mult(const Left& left, const Right& right, const Permutation& perm)
  { return left.mult(right, perm); }


  template <typename Left, typename Right, typename Scalar,
      typename std::enable_if<TiledArray::detail::is_numeric<Scalar>::value>::type* = nullptr>
  inline auto mult(const Left& left, const Right& right, const Scalar factor,
      const Permutation& 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,
      typename std::enable_if<TiledArray::detail::is_numeric<Scalar>::value>::type* = 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>()...));

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

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


  template <typename Arg>
  inline auto neg(const Arg& arg)
  { return arg.neg(); }


  template <typename Arg>
  inline auto neg(const Arg& arg, const Permutation& 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<Scalar>::value
      >::type* = nullptr>
  inline auto conj(const Arg& arg, const Scalar factor)
  { return arg.conj(factor); }


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


  template <typename Arg, typename Scalar,
      typename std::enable_if<
          TiledArray::detail::is_numeric<Scalar>::value
      >::type* = nullptr>
  inline auto conj(const Arg& arg, const Scalar factor, const Permutation& 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<Scalar>::value
      >::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>()...));

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



  template <typename Left, typename Right, typename Scalar,
      typename std::enable_if<TiledArray::detail::is_numeric<Scalar>::value>::type* = 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,
      typename std::enable_if<TiledArray::detail::is_numeric<Scalar>::value>::type* = 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... 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>
  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>
  using result_of_norm_t = decltype(norm(std::declval<T>()));

  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 */