// This file is part of Eigen, a lightweight C++ template library // for linear algebra. // // Copyright (C) 2008 Gael Guennebaud <[email protected]> // Copyright (C) 2006-2008 Benoit Jacob <[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_XPRHELPER_H #define EIGEN_XPRHELPER_H // IWYU pragma: private #include "../InternalHeaderCheck.h" namespace Eigen { namespace internal { // useful for unsigned / signed integer comparisons when idx is intended to be non-negative template <typename IndexType> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename make_unsigned<IndexType>::type returnUnsignedIndexValue( const IndexType& idx) { … } template <typename IndexDest, typename IndexSrc, bool IndexDestIsInteger = NumTraits<IndexDest>::IsInteger, bool IndexDestIsSigned = NumTraits<IndexDest>::IsSigned, bool IndexSrcIsInteger = NumTraits<IndexSrc>::IsInteger, bool IndexSrcIsSigned = NumTraits<IndexSrc>::IsSigned> struct convert_index_impl { … }; convert_index_impl<IndexDest, IndexSrc, true, true, true, false>; convert_index_impl<IndexDest, IndexSrc, true, false, true, true>; template <typename IndexDest, typename IndexSrc> EIGEN_DEVICE_FUNC inline IndexDest convert_index(const IndexSrc& idx) { … } // true if T can be considered as an integral index (i.e., and integral type or enum) template <typename T> struct is_valid_index_type { … }; // true if both types are not valid index types template <typename RowIndices, typename ColIndices> struct valid_indexed_view_overload { … }; // promote_scalar_arg is an helper used in operation between an expression and a scalar, like: // expression * scalar // Its role is to determine how the type T of the scalar operand should be promoted given the scalar type ExprScalar of // the given expression. The IsSupported template parameter must be provided by the caller as: // internal::has_ReturnType<ScalarBinaryOpTraits<ExprScalar,T,op> >::value using the proper order for ExprScalar and T. // Then the logic is as follows: // - if the operation is natively supported as defined by IsSupported, then the scalar type is not promoted, and T is // returned. // - otherwise, NumTraits<ExprScalar>::Literal is returned if T is implicitly convertible to // NumTraits<ExprScalar>::Literal AND that this does not imply a float to integer conversion. // - otherwise, ExprScalar is returned if T is implicitly convertible to ExprScalar AND that this does not imply a // float to integer conversion. // - In all other cases, the promoted type is not defined, and the respective operation is thus invalid and not // available (SFINAE). template <typename ExprScalar, typename T, bool IsSupported> struct promote_scalar_arg; promote_scalar_arg<S, T, true>; // Recursively check safe conversion to PromotedType, and then ExprScalar if they are different. template <typename ExprScalar, typename T, typename PromotedType, bool ConvertibleToLiteral = internal::is_convertible<T, PromotedType>::value, bool IsSafe = NumTraits<T>::IsInteger || !NumTraits<PromotedType>::IsInteger> struct promote_scalar_arg_unsupported; // Start recursion with NumTraits<ExprScalar>::Literal promote_scalar_arg<S, T, false>; // We found a match! promote_scalar_arg_unsupported<S, T, PromotedType, true, true>; // No match, but no real-to-integer issues, and ExprScalar and current PromotedType are different, // so let's try to promote to ExprScalar promote_scalar_arg_unsupported<ExprScalar, T, PromotedType, false, true>; // Unsafe real-to-integer, let's stop. promote_scalar_arg_unsupported<S, T, PromotedType, ConvertibleToLiteral, false>; // T is not even convertible to ExprScalar, let's stop. promote_scalar_arg_unsupported<S, T, S, false, true>; // classes inheriting no_assignment_operator don't generate a default operator=. class no_assignment_operator { … }; /** \internal return the index type with the largest number of bits */ template <typename I1, typename I2> struct promote_index_type { … }; /** \internal If the template parameter Value is Dynamic, this class is just a wrapper around a T variable that * can be accessed using value() and setValue(). * Otherwise, this class is an empty structure and value() just returns the template parameter Value. */ template <typename T, int Value> class variable_if_dynamic { … }; variable_if_dynamic<T, Dynamic>; /** \internal like variable_if_dynamic but for DynamicIndex */ template <typename T, int Value> class variable_if_dynamicindex { … }; variable_if_dynamicindex<T, DynamicIndex>; template <typename T> struct functor_traits { … }; // estimates the cost of lazily evaluating a generic functor by unwinding the expression template <typename Xpr> struct nested_functor_cost { … }; nested_functor_cost<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols>>; nested_functor_cost<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols>>; // TODO: assign a cost to the stride type? nested_functor_cost<Map<PlainObjectType, MapOptions, StrideType>>; nested_functor_cost<CwiseUnaryOp<Func, Xpr>>; nested_functor_cost<CwiseNullaryOp<Func, Xpr>>; nested_functor_cost<CwiseBinaryOp<Func, LhsXpr, RhsXpr>>; nested_functor_cost<CwiseTernaryOp<Func, LhsXpr, MidXpr, RhsXpr>>; template <typename Xpr> struct functor_cost { … }; template <typename T> struct packet_traits; template <typename T> struct unpacket_traits; template <int Size, typename PacketType, bool Stop = Size == Dynamic || (Size % unpacket_traits<PacketType>::size) == 0 || is_same<PacketType, typename unpacket_traits<PacketType>::half>::value> struct find_best_packet_helper; find_best_packet_helper<Size, PacketType, true>; find_best_packet_helper<Size, PacketType, false>; template <typename T, int Size> struct find_best_packet { … }; template <int Size, typename PacketType, bool Stop = (Size == unpacket_traits<PacketType>::size) || is_same<PacketType, typename unpacket_traits<PacketType>::half>::value> struct find_packet_by_size_helper; find_packet_by_size_helper<Size, PacketType, true>; find_packet_by_size_helper<Size, PacketType, false>; template <typename T, int Size> struct find_packet_by_size { … }; find_packet_by_size<T, 1>; #if EIGEN_MAX_STATIC_ALIGN_BYTES > 0 constexpr inline int compute_default_alignment_helper(int ArrayBytes, int AlignmentBytes) { … } #else // If static alignment is disabled, no need to bother. // This also avoids a division by zero constexpr inline int compute_default_alignment_helper(int ArrayBytes, int AlignmentBytes) { EIGEN_UNUSED_VARIABLE(ArrayBytes); EIGEN_UNUSED_VARIABLE(AlignmentBytes); return 0; } #endif template <typename T, int Size> struct compute_default_alignment { … }; compute_default_alignment<T, Dynamic>; template <typename Scalar_, int Rows_, int Cols_, int Options_ = AutoAlign | ((Rows_ == 1 && Cols_ != 1) ? RowMajor : (Cols_ == 1 && Rows_ != 1) ? ColMajor : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION), int MaxRows_ = Rows_, int MaxCols_ = Cols_> class make_proper_matrix_type { … }; constexpr inline unsigned compute_matrix_flags(int Options) { … } constexpr inline int size_at_compile_time(int rows, int cols) { … } template <typename XprType> struct size_of_xpr_at_compile_time { … }; /* plain_matrix_type : the difference from eval is that plain_matrix_type is always a plain matrix type, * whereas eval is a const reference in the case of a matrix */ template <typename T, typename StorageKind = typename traits<T>::StorageKind> struct plain_matrix_type; template <typename T, typename BaseClassType, int Flags> struct plain_matrix_type_dense; plain_matrix_type<T, Dense>; plain_matrix_type<T, DiagonalShape>; plain_matrix_type<T, SkewSymmetricShape>; plain_matrix_type_dense<T, MatrixXpr, Flags>; plain_matrix_type_dense<T, ArrayXpr, Flags>; /* eval : the return type of eval(). For matrices, this is just a const reference * in order to avoid a useless copy */ template <typename T, typename StorageKind = typename traits<T>::StorageKind> struct eval; eval<T, Dense>; eval<T, DiagonalShape>; eval<T, SkewSymmetricShape>; // for matrices, no need to evaluate, just use a const reference to avoid a useless copy eval<Matrix<Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_>, Dense>; eval<Array<Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_>, Dense>; /* similar to plain_matrix_type, but using the evaluator's Flags */ template <typename T, typename StorageKind = typename traits<T>::StorageKind> struct plain_object_eval; plain_object_eval<T, Dense>; /* plain_matrix_type_column_major : same as plain_matrix_type but guaranteed to be column-major */ template <typename T> struct plain_matrix_type_column_major { … }; /* plain_matrix_type_row_major : same as plain_matrix_type but guaranteed to be row-major */ template <typename T> struct plain_matrix_type_row_major { … }; /** \internal The reference selector for template expressions. The idea is that we don't * need to use references for expressions since they are light weight proxy * objects which should generate no copying overhead. */ template <typename T> struct ref_selector { … }; /** \internal Adds the const qualifier on the value-type of T2 if and only if T1 is a const type */ template <typename T1, typename T2> struct transfer_constness { … }; // However, we still need a mechanism to detect whether an expression which is evaluated multiple time // has to be evaluated into a temporary. // That's the purpose of this new nested_eval helper: /** \internal Determines how a given expression should be nested when evaluated multiple times. * For example, when you do a * (b+c), Eigen will determine how the expression b+c should be * evaluated into the bigger product expression. The choice is between nesting the expression b+c as-is, or * evaluating that expression b+c into a temporary variable d, and nest d so that the resulting expression is * a*d. Evaluating can be beneficial for example if every coefficient access in the resulting expression causes * many coefficient accesses in the nested expressions -- as is the case with matrix product for example. * * \tparam T the type of the expression being nested. * \tparam n the number of coefficient accesses in the nested expression for each coefficient access in the bigger * expression. \tparam PlainObject the type of the temporary if needed. */ template <typename T, int n, typename PlainObject = typename plain_object_eval<T>::type> struct nested_eval { … }; template <typename T> EIGEN_DEVICE_FUNC inline T* const_cast_ptr(const T* ptr) { … } template <typename Derived, typename XprKind = typename traits<Derived>::XprKind> struct dense_xpr_base { … }; dense_xpr_base<Derived, MatrixXpr>; dense_xpr_base<Derived, ArrayXpr>; template <typename Derived, typename XprKind = typename traits<Derived>::XprKind, typename StorageKind = typename traits<Derived>::StorageKind> struct generic_xpr_base; generic_xpr_base<Derived, XprKind, Dense>; template <typename XprType, typename CastType> struct cast_return_type { … }; template <typename A, typename B> struct promote_storage_type; promote_storage_type<A, A>; promote_storage_type<A, const A>; promote_storage_type<const A, A>; /** \internal Specify the "storage kind" of applying a coefficient-wise * binary operations between two expressions of kinds A and B respectively. * The template parameter Functor permits to specialize the resulting storage kind wrt to * the functor. * The default rules are as follows: * \code * A op A -> A * A op dense -> dense * dense op B -> dense * sparse op dense -> sparse * dense op sparse -> sparse * \endcode */ template <typename A, typename B, typename Functor> struct cwise_promote_storage_type; cwise_promote_storage_type<A, A, Functor>; cwise_promote_storage_type<Dense, Dense, Functor>; cwise_promote_storage_type<A, Dense, Functor>; cwise_promote_storage_type<Dense, B, Functor>; cwise_promote_storage_type<Sparse, Dense, Functor>; cwise_promote_storage_type<Dense, Sparse, Functor>; template <typename LhsKind, typename RhsKind, int LhsOrder, int RhsOrder> struct cwise_promote_storage_order { … }; cwise_promote_storage_order<LhsKind, Sparse, LhsOrder, RhsOrder>; cwise_promote_storage_order<Sparse, RhsKind, LhsOrder, RhsOrder>; cwise_promote_storage_order<Sparse, Sparse, Order, Order>; /** \internal Specify the "storage kind" of multiplying an expression of kind A with kind B. * The template parameter ProductTag permits to specialize the resulting storage kind wrt to * some compile-time properties of the product: GemmProduct, GemvProduct, OuterProduct, InnerProduct. * The default rules are as follows: * \code * K * K -> K * dense * K -> dense * K * dense -> dense * diag * K -> K * K * diag -> K * Perm * K -> K * K * Perm -> K * \endcode */ template <typename A, typename B, int ProductTag> struct product_promote_storage_type; product_promote_storage_type<A, A, ProductTag>; product_promote_storage_type<Dense, Dense, ProductTag>; product_promote_storage_type<A, Dense, ProductTag>; product_promote_storage_type<Dense, B, ProductTag>; product_promote_storage_type<A, DiagonalShape, ProductTag>; product_promote_storage_type<DiagonalShape, B, ProductTag>; product_promote_storage_type<Dense, DiagonalShape, ProductTag>; product_promote_storage_type<DiagonalShape, Dense, ProductTag>; product_promote_storage_type<A, SkewSymmetricShape, ProductTag>; product_promote_storage_type<SkewSymmetricShape, B, ProductTag>; product_promote_storage_type<Dense, SkewSymmetricShape, ProductTag>; product_promote_storage_type<SkewSymmetricShape, Dense, ProductTag>; product_promote_storage_type<SkewSymmetricShape, SkewSymmetricShape, ProductTag>; product_promote_storage_type<A, PermutationStorage, ProductTag>; product_promote_storage_type<PermutationStorage, B, ProductTag>; product_promote_storage_type<Dense, PermutationStorage, ProductTag>; product_promote_storage_type<PermutationStorage, Dense, ProductTag>; /** \internal gives the plain matrix or array type to store a row/column/diagonal of a matrix type. * \tparam Scalar optional parameter allowing to pass a different scalar type than the one of the MatrixType. */ template <typename ExpressionType, typename Scalar = typename ExpressionType::Scalar> struct plain_row_type { … }; template <typename ExpressionType, typename Scalar = typename ExpressionType::Scalar> struct plain_col_type { … }; template <typename ExpressionType, typename Scalar = typename ExpressionType::Scalar> struct plain_diag_type { … }; template <typename Expr, typename Scalar = typename Expr::Scalar> struct plain_constant_type { … }; template <typename ExpressionType> struct is_lvalue { … }; template <typename T> struct is_diagonal { … }; is_diagonal<DiagonalBase<T>>; is_diagonal<DiagonalWrapper<T>>; is_diagonal<DiagonalMatrix<T, S>>; template <typename T> struct is_identity { … }; is_identity<CwiseNullaryOp<internal::scalar_identity_op<typename T::Scalar>, T>>; template <typename S1, typename S2> struct glue_shapes; template <> struct glue_shapes<DenseShape, TriangularShape> { … }; template <typename T1, typename T2> struct possibly_same_dense { … }; template <typename T1, typename T2> EIGEN_DEVICE_FUNC bool is_same_dense(const T1& mat1, const T2& mat2, std::enable_if_t<possibly_same_dense<T1, T2>::value>* = 0) { … } template <typename T1, typename T2> EIGEN_DEVICE_FUNC bool is_same_dense(const T1&, const T2&, std::enable_if_t<!possibly_same_dense<T1, T2>::value>* = 0) { … } // Internal helper defining the cost of a scalar division for the type T. // The default heuristic can be specialized for each scalar type and architecture. template <typename T, bool Vectorized = false, typename EnableIf = void> struct scalar_div_cost { … }; scalar_div_cost<std::complex<T>, Vectorized>; scalar_div_cost<long, Vectorized, std::conditional_t<sizeof(long) == 8, void, false_type>>; scalar_div_cost<unsigned long, Vectorized, std::conditional_t<sizeof(long) == 8, void, false_type>>; #ifdef EIGEN_DEBUG_ASSIGN std::string demangle_traversal(int t) { if (t == DefaultTraversal) return "DefaultTraversal"; if (t == LinearTraversal) return "LinearTraversal"; if (t == InnerVectorizedTraversal) return "InnerVectorizedTraversal"; if (t == LinearVectorizedTraversal) return "LinearVectorizedTraversal"; if (t == SliceVectorizedTraversal) return "SliceVectorizedTraversal"; return "?"; } std::string demangle_unrolling(int t) { if (t == NoUnrolling) return "NoUnrolling"; if (t == InnerUnrolling) return "InnerUnrolling"; if (t == CompleteUnrolling) return "CompleteUnrolling"; return "?"; } std::string demangle_flags(int f) { std::string res; if (f & RowMajorBit) res += " | RowMajor"; if (f & PacketAccessBit) res += " | Packet"; if (f & LinearAccessBit) res += " | Linear"; if (f & LvalueBit) res += " | Lvalue"; if (f & DirectAccessBit) res += " | Direct"; if (f & NestByRefBit) res += " | NestByRef"; if (f & NoPreferredStorageOrderBit) res += " | NoPreferredStorageOrderBit"; return res; } #endif template <typename XprType> struct is_block_xpr : std::false_type { … }; is_block_xpr<Block<XprType, BlockRows, BlockCols, InnerPanel>>; is_block_xpr<const Block<XprType, BlockRows, BlockCols, InnerPanel>>; // Helper utility for constructing non-recursive block expressions. template <typename XprType> struct block_xpr_helper { … }; block_xpr_helper<Block<XprType, BlockRows, BlockCols, InnerPanel>>; block_xpr_helper<const Block<XprType, BlockRows, BlockCols, InnerPanel>>; template <typename XprType> struct is_matrix_base_xpr : std::is_base_of<MatrixBase<remove_all_t<XprType>>, remove_all_t<XprType>> { … }; template <typename XprType> struct is_permutation_base_xpr : std::is_base_of<PermutationBase<remove_all_t<XprType>>, remove_all_t<XprType>> { … }; } // end namespace internal /** \class ScalarBinaryOpTraits * \ingroup Core_Module * * \brief Determines whether the given binary operation of two numeric types is allowed and what the scalar return type is. * * This class permits to control the scalar return type of any binary operation performed on two different scalar types through (partial) template specializations. * * For instance, let \c U1, \c U2 and \c U3 be three user defined scalar types for which most operations between instances of \c U1 and \c U2 returns an \c U3. * You can let %Eigen knows that by defining: \code template<typename BinaryOp> struct ScalarBinaryOpTraits<U1,U2,BinaryOp> { typedef U3 ReturnType; }; template<typename BinaryOp> struct ScalarBinaryOpTraits<U2,U1,BinaryOp> { typedef U3 ReturnType; }; \endcode * You can then explicitly disable some particular operations to get more explicit error messages: \code template<> struct ScalarBinaryOpTraits<U1,U2,internal::scalar_max_op<U1,U2> > {}; \endcode * Or customize the return type for individual operation: \code template<> struct ScalarBinaryOpTraits<U1,U2,internal::scalar_sum_op<U1,U2> > { typedef U1 ReturnType; }; \endcode * * By default, the following generic combinations are supported: <table class="manual"> <tr><th>ScalarA</th><th>ScalarB</th><th>BinaryOp</th><th>ReturnType</th><th>Note</th></tr> <tr ><td>\c T </td><td>\c T </td><td>\c * </td><td>\c T </td><td></td></tr> <tr class="alt"><td>\c NumTraits<T>::Real </td><td>\c T </td><td>\c * </td><td>\c T </td><td>Only if \c NumTraits<T>::IsComplex </td></tr> <tr ><td>\c T </td><td>\c NumTraits<T>::Real </td><td>\c * </td><td>\c T </td><td>Only if \c NumTraits<T>::IsComplex </td></tr> </table> * * \sa CwiseBinaryOp */ template <typename ScalarA, typename ScalarB, typename BinaryOp = internal::scalar_product_op<ScalarA, ScalarB>> struct ScalarBinaryOpTraits #ifndef EIGEN_PARSED_BY_DOXYGEN // for backward compatibility, use the hints given by the (deprecated) internal::scalar_product_traits class. : internal::scalar_product_traits<ScalarA, ScalarB> #endif // EIGEN_PARSED_BY_DOXYGEN { }; ScalarBinaryOpTraits<T, T, BinaryOp>; ScalarBinaryOpTraits<T, typename NumTraits<std::enable_if_t<NumTraits<T>::IsComplex, T>>::Real, BinaryOp>; ScalarBinaryOpTraits<typename NumTraits<std::enable_if_t<NumTraits<T>::IsComplex, T>>::Real, T, BinaryOp>; // For Matrix * Permutation ScalarBinaryOpTraits<T, void, BinaryOp>; // For Permutation * Matrix ScalarBinaryOpTraits<void, T, BinaryOp>; // for Permutation*Permutation ScalarBinaryOpTraits<void, void, BinaryOp>; // We require Lhs and Rhs to have "compatible" scalar types. // It is tempting to always allow mixing different types but remember that this is often impossible in the vectorized // paths. So allowing mixing different types gives very unexpected errors when enabling vectorization, when the user // tries to add together a float matrix and a double matrix. #define EIGEN_CHECK_BINARY_COMPATIBILIY(BINOP, LHS, RHS) … } // end namespace Eigen #endif // EIGEN_XPRHELPER_H
Codebase Browser
chromium