scal_engine.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
 *
 *  scal_engine.h
 *  Apr 1, 2014
 *
 */
 
#ifndef TILEDARRAY_EXPRESSIONS_SCAL_ENGINE_H__INCLUDED
#define TILEDARRAY_EXPRESSIONS_SCAL_ENGINE_H__INCLUDED
 
#include <TiledArray/expressions/unary_engine.h>
#include <TiledArray/tile_op/scal.h>
#include <TiledArray/tile_op/unary_wrapper.h>
 
namespace TiledArray {
namespace expressions {
 
// Forward declarations
template <typename, typename>
class ScalExpr;
template <typename, typename, typename>
class ScalEngine;
 
template <typename Arg, typename Scalar, typename Result>
struct EngineTrait<ScalEngine<Arg, Scalar, Result>> {
  // Argument typedefs
  typedef Arg argument_type;  
 
  // Operational typedefs
  typedef Scalar scalar_type;  
  typedef TiledArray::detail::Scal<Result, typename EngineTrait<Arg>::eval_type,
                                   scalar_type,
                                   EngineTrait<Arg>::consumable>
      op_base_type;  
  typedef TiledArray::detail::UnaryWrapper<op_base_type>
      op_type;  
  typedef typename op_type::result_type value_type;  
  typedef typename eval_trait<value_type>::type
      eval_type;                                  
  typedef typename argument_type::policy policy;  
  typedef TiledArray::detail::DistEval<value_type, policy>
      dist_eval_type;  
 
  // Meta data typedefs
  typedef typename policy::ordinal_type size_type;   
  typedef typename policy::trange_type trange_type;  
  typedef typename policy::shape_type shape_type;    
  typedef typename policy::pmap_interface
      pmap_interface;  
 
  static constexpr bool consumable = true;
  static constexpr unsigned int leaves = EngineTrait<Arg>::leaves;
};
 
 
template <typename Arg, typename Scalar, typename Result>
class ScalEngine : public UnaryEngine<ScalEngine<Arg, Scalar, Result>> {
 public:
  // Class hierarchy typedefs
  typedef ScalEngine<Arg, Scalar, Result> ScalEngine_;  
  typedef UnaryEngine<ScalEngine_>
      UnaryEngine_;  
  typedef typename UnaryEngine_::ExprEngine_
      ExprEngine_;  
 
  // Argument typedefs
  typedef typename EngineTrait<ScalEngine_>::argument_type
      argument_type;  
 
  // Operational typedefs
  typedef typename EngineTrait<ScalEngine_>::value_type
      value_type;  
  typedef typename EngineTrait<ScalEngine_>::scalar_type
      scalar_type;  
  typedef typename EngineTrait<ScalEngine_>::op_type
      op_type;  
  typedef typename EngineTrait<ScalEngine_>::policy
      policy;  
  typedef typename EngineTrait<ScalEngine_>::dist_eval_type
      dist_eval_type;  
 
  // Meta data typedefs
  typedef
      typename EngineTrait<ScalEngine_>::size_type size_type;  
  typedef typename EngineTrait<ScalEngine_>::trange_type
      trange_type;  
  typedef
      typename EngineTrait<ScalEngine_>::shape_type shape_type;  
  typedef typename EngineTrait<ScalEngine_>::pmap_interface
      pmap_interface;  
 
 private:
  scalar_type factor_;  
 
 public:
 
  template <typename A, typename S>
  ScalEngine(const ScalExpr<A, S>& expr)
      : UnaryEngine_(expr), factor_(expr.factor()) {}
 
 
  shape_type make_shape() const {
    return UnaryEngine_::arg_.shape().scale(factor_);
  }
 
 
  shape_type make_shape(const Permutation& perm) const {
    return UnaryEngine_::arg_.shape().scale(factor_, perm);
  }
 
 
  op_type make_tile_op() const { return op_type(factor_); }
 
 
  template <typename Perm, typename = std::enable_if_t<
                               TiledArray::detail::is_permutation_v<Perm>>>
  op_type make_tile_op(const Perm& perm) const {
    return op_type(perm, factor_);
  }
 
 
  std::string make_tag() const {
    std::stringstream ss;
    ss << "[" << factor_ << "] ";
    return ss.str();
  }
 
};  // class ScalEngine
 
}  // namespace expressions
}  // namespace TiledArray
 
#endif  // TILEDARRAY_EXPRESSIONS_SCAL_ENGINE_H__INCLUDED