chromium/third_party/eigen3/src/Eigen/src/Core/functors/AssignmentFunctors.h

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008-2010 Gael Guennebaud <[email protected]>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef EIGEN_ASSIGNMENT_FUNCTORS_H
#define EIGEN_ASSIGNMENT_FUNCTORS_H

// IWYU pragma: private
#include "../InternalHeaderCheck.h"

namespace Eigen {

namespace internal {

/** \internal
 * \brief Template functor for scalar/packet assignment
 *
 */
template <typename DstScalar, typename SrcScalar>
struct assign_op { … };

// Empty overload for void type (used by PermutationMatrix)
assign_op<DstScalar, void>;

functor_traits<assign_op<DstScalar, SrcScalar>>;

/** \internal
 * \brief Template functor for scalar/packet assignment with addition
 *
 */
template <typename DstScalar, typename SrcScalar>
struct add_assign_op { … };
functor_traits<add_assign_op<DstScalar, SrcScalar>>;

/** \internal
 * \brief Template functor for scalar/packet assignment with subtraction
 *
 */
template <typename DstScalar, typename SrcScalar>
struct sub_assign_op { … };
functor_traits<sub_assign_op<DstScalar, SrcScalar>>;

/** \internal
 * \brief Template functor for scalar/packet assignment with multiplication
 *
 */
template <typename DstScalar, typename SrcScalar = DstScalar>
struct mul_assign_op { … };
functor_traits<mul_assign_op<DstScalar, SrcScalar>>;

/** \internal
 * \brief Template functor for scalar/packet assignment with diviving
 *
 */
template <typename DstScalar, typename SrcScalar = DstScalar>
struct div_assign_op { … };
functor_traits<div_assign_op<DstScalar, SrcScalar>>;

/** \internal
 * \brief Template functor for scalar/packet assignment with swapping
 *
 * It works as follow. For a non-vectorized evaluation loop, we have:
 *   for(i) func(A.coeffRef(i), B.coeff(i));
 * where B is a SwapWrapper expression. The trick is to make SwapWrapper::coeff behaves like a non-const coeffRef.
 * Actually, SwapWrapper might not even be needed since even if B is a plain expression, since it has to be writable
 * B.coeff already returns a const reference to the underlying scalar value.
 *
 * The case of a vectorized loop is more tricky:
 *   for(i,j) func.assignPacket<A_Align>(&A.coeffRef(i,j), B.packet<B_Align>(i,j));
 * Here, B must be a SwapWrapper whose packet function actually returns a proxy object holding a Scalar*,
 * the actual alignment and Packet type.
 *
 */
template <typename Scalar>
struct swap_assign_op { … };
functor_traits<swap_assign_op<Scalar>>;

}  // namespace internal

}  // namespace Eigen

#endif  // EIGEN_ASSIGNMENT_FUNCTORS_H