/usr/include/TiledArray/tile_op/scal.h is in libtiledarray-dev 0.6.0-5.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 | /*
* This file is a part of TiledArray.
* Copyright (C) 2013 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.h
* June 20, 2013
*
*/
#ifndef TILEDARRAY_TILE_OP_SCAL_H__INCLUDED
#define TILEDARRAY_TILE_OP_SCAL_H__INCLUDED
#include <type_traits>
#include <TiledArray/tile_op/tile_interface.h>
namespace TiledArray {
/// Tile scaling operation
/// This scaling operation will scale the content a tile and apply a
/// permutation to the result tensor. If no permutation is given or the
/// permutation is null, then the result is not permuted.
/// \tparam Result The result type
/// \tparam Arg The argument type
/// \tparam Consumable Flag that is \c true when Arg is consumable
template <typename Arg, typename Scalar, bool Consumable>
class Scal {
public:
typedef Scal<Arg, Scalar, Consumable> Scal_; ///< This object type
typedef Arg argument_type; ///< The argument type
typedef Scalar scalar_type; ///< The scaling factor type
typedef decltype(scale(std::declval<argument_type>(),
std::declval<scalar_type>())) result_type; ///< The result tile type
static constexpr bool is_consumable =
Consumable && std::is_same<result_type, argument_type>::value;
private:
scalar_type factor_; ///< Scaling factor
// Permuting tile evaluation function
// These operations cannot consume the argument tile since this operation
// requires temporary storage space.
result_type eval(const Arg& arg, const Permutation& perm) const {
using TiledArray::scale;
return scale(arg, factor_, perm);
}
// Non-permuting tile evaluation functions
// The compiler will select the correct functions based on the consumability
// of the arguments.
template <bool C, typename std::enable_if<!C>::type* = nullptr>
result_type eval(const argument_type& arg) const {
using TiledArray::scale;
return scale(arg, factor_);
}
template <bool C, typename std::enable_if<C>::type* = nullptr>
result_type eval(argument_type& arg) const {
using TiledArray::scale_to;
return scale_to(arg, factor_);
}
public:
// Compiler generated functions
Scal(const Scal_&) = default;
Scal(Scal_&&) = default;
~Scal() = default;
Scal_& operator=(const Scal_&) = default;
Scal_& operator=(Scal_&&) = default;
/// Constructor
/// Construct a scaling operation that scales the result tensor
/// \param factor The scaling factor for the operation
explicit Scal(const scalar_type factor) : factor_(factor) { }
/// Scale and permute operator
/// \param arg The tile argument
/// \param perm The permutation applied to the result tile
/// \return A permuted and scaled copy of `arg`
result_type
operator()(const argument_type& arg, const Permutation& perm) const {
return eval(arg, perm);
}
/// Consuming scale operation
/// \tparam A The tile argument type
/// \param arg The tile argument
/// \return A scaled copy of `arg`
template <typename A>
result_type operator()(A&& arg) const {
return Scal_::template eval<is_consumable &&
! std::is_const<typename std::remove_reference<A>::type>::value>(
std::forward<A>(arg));
}
/// Explicit consuming scale operation
/// \param arg The tile argument
/// \return In-place scaled `arg`
result_type consume(argument_type& arg) const {
return Scal_::template eval<is_consumable_tile<Arg>::value>(arg);
}
}; // class Scal
} // namespace TiledArray
#endif // TILEDARRAY_TILE_OP_SCAL_H__INCLUDED
|