Update Eigen to: https://gitlab.com/libeigen/eigen/-/commit/e939c06b0e54fd7c4bfa173d01b47d2554bf7a85 PiperOrigin-RevId: 419652492 Change-Id: I01a8bd6bf8feea498fd1827cacc133eb4b971d75
diff --git a/Eigen/Cholesky b/Eigen/Cholesky index a318ceb..2c686f1 100644 --- a/Eigen/Cholesky +++ b/Eigen/Cholesky
@@ -32,11 +32,7 @@ #include "src/Cholesky/LLT.h" #include "src/Cholesky/LDLT.h" #ifdef EIGEN_USE_LAPACKE -#ifdef EIGEN_USE_MKL -#include "mkl_lapacke.h" -#else -#include "src/misc/lapacke.h" -#endif +#include "src/misc/lapacke_helpers.h" #include "src/Cholesky/LLT_LAPACKE.h" #endif
diff --git a/Eigen/Core b/Eigen/Core index 5cc8344..1074332 100644 --- a/Eigen/Core +++ b/Eigen/Core
@@ -36,7 +36,7 @@ // Disable the ipa-cp-clone optimization flag with MinGW 6.x or newer (enabled by default with -O3) // See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=556 for details. -#if EIGEN_COMP_MINGW && EIGEN_GNUC_AT_LEAST(4,6) && EIGEN_GNUC_AT_MOST(5,5) +#if EIGEN_COMP_MINGW && EIGEN_GNUC_AT_MOST(5,5) #pragma GCC optimize ("-fno-ipa-cp-clone") #endif @@ -98,9 +98,7 @@ #include <array> // for std::is_nothrow_move_assignable -#ifdef EIGEN_INCLUDE_TYPE_TRAITS #include <type_traits> -#endif // for outputting debug info #ifdef EIGEN_DEBUG_ASSIGN
diff --git a/Eigen/LU b/Eigen/LU index 1236ceb..b7f9a8a 100644 --- a/Eigen/LU +++ b/Eigen/LU
@@ -28,11 +28,7 @@ #include "src/LU/FullPivLU.h" #include "src/LU/PartialPivLU.h" #ifdef EIGEN_USE_LAPACKE -#ifdef EIGEN_USE_MKL -#include "mkl_lapacke.h" -#else -#include "src/misc/lapacke.h" -#endif +#include "src/misc/lapacke_helpers.h" #include "src/LU/PartialPivLU_LAPACKE.h" #endif #include "src/LU/Determinant.h"
diff --git a/Eigen/QR b/Eigen/QR index 8465b62..1f6c22e 100644 --- a/Eigen/QR +++ b/Eigen/QR
@@ -36,11 +36,7 @@ #include "src/QR/ColPivHouseholderQR.h" #include "src/QR/CompleteOrthogonalDecomposition.h" #ifdef EIGEN_USE_LAPACKE -#ifdef EIGEN_USE_MKL -#include "mkl_lapacke.h" -#else -#include "src/misc/lapacke.h" -#endif +#include "src/misc/lapacke_helpers.h" #include "src/QR/HouseholderQR_LAPACKE.h" #include "src/QR/ColPivHouseholderQR_LAPACKE.h" #endif
diff --git a/Eigen/SPQRSupport b/Eigen/SPQRSupport index f70390c..33c3370 100644 --- a/Eigen/SPQRSupport +++ b/Eigen/SPQRSupport
@@ -28,7 +28,7 @@ * */ -#include "src/CholmodSupport/CholmodSupport.h" +#include "Eigen/CholmodSupport" #include "src/SPQRSupport/SuiteSparseQRSupport.h" #endif
diff --git a/Eigen/src/Cholesky/LLT_LAPACKE.h b/Eigen/src/Cholesky/LLT_LAPACKE.h index bde9bcd..62bc679 100644 --- a/Eigen/src/Cholesky/LLT_LAPACKE.h +++ b/Eigen/src/Cholesky/LLT_LAPACKE.h
@@ -39,44 +39,12 @@ namespace internal { -namespace lapacke_llt_helpers { - - // ------------------------------------------------------------------------------------------------------------------- - // Translation from Eigen to Lapacke types - // ------------------------------------------------------------------------------------------------------------------- - - // For complex numbers, the types in Eigen and Lapacke are different, but layout compatible. - template<typename Scalar> struct translate_type; - template<> struct translate_type<float> { using type = float; }; - template<> struct translate_type<double> { using type = double; }; - template<> struct translate_type<dcomplex> { using type = lapack_complex_double; }; - template<> struct translate_type<scomplex> { using type = lapack_complex_float; }; - - // ------------------------------------------------------------------------------------------------------------------- - // Dispatch for potrf handling double, float, complex double, complex float types - // ------------------------------------------------------------------------------------------------------------------- - - inline lapack_int potrf(lapack_int matrix_order, char uplo, lapack_int size, double* a, lapack_int lda) { - return LAPACKE_dpotrf( matrix_order, uplo, size, a, lda ); - } - - inline lapack_int potrf(lapack_int matrix_order, char uplo, lapack_int size, float* a, lapack_int lda) { - return LAPACKE_spotrf( matrix_order, uplo, size, a, lda ); - } - - inline lapack_int potrf(lapack_int matrix_order, char uplo, lapack_int size, lapack_complex_double* a, lapack_int lda) { - return LAPACKE_zpotrf( matrix_order, uplo, size, a, lda ); - } - - inline lapack_int potrf(lapack_int matrix_order, char uplo, lapack_int size, lapack_complex_float* a, lapack_int lda) { - return LAPACKE_cpotrf( matrix_order, uplo, size, a, lda ); - } - +namespace lapacke_helpers { // ------------------------------------------------------------------------------------------------------------------- // Dispatch for rank update handling upper and lower parts // ------------------------------------------------------------------------------------------------------------------- - template<unsigned Mode> + template<UpLoType Mode> struct rank_update {}; template<> @@ -100,9 +68,8 @@ // Generic lapacke llt implementation that hands of to the dispatches // ------------------------------------------------------------------------------------------------------------------- - template<typename Scalar, unsigned Mode> + template<typename Scalar, UpLoType Mode> struct lapacke_llt { - using BlasType = typename translate_type<Scalar>::type; template<typename MatrixType> static Index blocked(MatrixType& m) { @@ -110,15 +77,13 @@ if(m.rows() == 0) { return -1; } - /* Set up parameters for ?potrf */ - lapack_int size = convert_index<lapack_int>(m.rows()); - lapack_int StorageOrder = MatrixType::Flags&RowMajorBit?RowMajor:ColMajor; - lapack_int matrix_order = StorageOrder==RowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; + lapack_int size = to_lapack(m.rows()); + lapack_int matrix_order = lapack_storage_of(m); Scalar* a = &(m.coeffRef(0,0)); - lapack_int lda = convert_index<lapack_int>(m.outerStride()); + lapack_int lda = to_lapack(m.outerStride()); - lapack_int info = potrf( matrix_order, Mode == Lower ? 'L' : 'U', size, (BlasType*)a, lda ); + lapack_int info = potrf(matrix_order, translate_mode<Mode>, size, to_lapack(a), lda ); info = (info==0) ? -1 : info>0 ? info-1 : size; return info; } @@ -130,7 +95,7 @@ } }; } -// end namespace lapacke_llt_helpers +// end namespace lapacke_helpers /* * Here, we just put the generic implementation from lapacke_llt into a full specialization of the llt_inplace @@ -139,13 +104,13 @@ */ #define EIGEN_LAPACKE_LLT(EIGTYPE) \ -template<> struct llt_inplace<EIGTYPE, Lower> : public lapacke_llt_helpers::lapacke_llt<EIGTYPE, Lower> {}; \ -template<> struct llt_inplace<EIGTYPE, Upper> : public lapacke_llt_helpers::lapacke_llt<EIGTYPE, Upper> {}; +template<> struct llt_inplace<EIGTYPE, Lower> : public lapacke_helpers::lapacke_llt<EIGTYPE, Lower> {}; \ +template<> struct llt_inplace<EIGTYPE, Upper> : public lapacke_helpers::lapacke_llt<EIGTYPE, Upper> {}; EIGEN_LAPACKE_LLT(double) EIGEN_LAPACKE_LLT(float) -EIGEN_LAPACKE_LLT(dcomplex) -EIGEN_LAPACKE_LLT(scomplex) +EIGEN_LAPACKE_LLT(std::complex<double>) +EIGEN_LAPACKE_LLT(std::complex<float>) #undef EIGEN_LAPACKE_LLT
diff --git a/Eigen/src/Core/ArithmeticSequence.h b/Eigen/src/Core/ArithmeticSequence.h index 1c8b670..112ca98 100644 --- a/Eigen/src/Core/ArithmeticSequence.h +++ b/Eigen/src/Core/ArithmeticSequence.h
@@ -16,59 +16,6 @@ namespace internal { -#if !((!EIGEN_COMP_GNUC) || EIGEN_COMP_GNUC>=48) -template<typename T> struct aseq_negate {}; - -template<> struct aseq_negate<Index> { - typedef Index type; -}; - -template<int N> struct aseq_negate<FixedInt<N> > { - typedef FixedInt<-N> type; -}; - -// Compilation error in the following case: -template<> struct aseq_negate<FixedInt<DynamicIndex> > {}; - -template<typename FirstType,typename SizeType,typename IncrType, - bool FirstIsSymbolic=symbolic::is_symbolic<FirstType>::value, - bool SizeIsSymbolic =symbolic::is_symbolic<SizeType>::value> -struct aseq_reverse_first_type { - typedef Index type; -}; - -template<typename FirstType,typename SizeType,typename IncrType> -struct aseq_reverse_first_type<FirstType,SizeType,IncrType,true,true> { - typedef symbolic::AddExpr<FirstType, - symbolic::ProductExpr<symbolic::AddExpr<SizeType,symbolic::ValueExpr<FixedInt<-1> > >, - symbolic::ValueExpr<IncrType> > - > type; -}; - -template<typename SizeType,typename IncrType,typename EnableIf = void> -struct aseq_reverse_first_type_aux { - typedef Index type; -}; - -template<typename SizeType,typename IncrType> -struct aseq_reverse_first_type_aux<SizeType,IncrType,typename internal::enable_if<bool((SizeType::value+IncrType::value)|0x1)>::type> { - typedef FixedInt<(SizeType::value-1)*IncrType::value> type; -}; - -template<typename FirstType,typename SizeType,typename IncrType> -struct aseq_reverse_first_type<FirstType,SizeType,IncrType,true,false> { - typedef typename aseq_reverse_first_type_aux<SizeType,IncrType>::type Aux; - typedef symbolic::AddExpr<FirstType,symbolic::ValueExpr<Aux> > type; -}; - -template<typename FirstType,typename SizeType,typename IncrType> -struct aseq_reverse_first_type<FirstType,SizeType,IncrType,false,true> { - typedef symbolic::AddExpr<symbolic::ProductExpr<symbolic::AddExpr<SizeType,symbolic::ValueExpr<FixedInt<-1> > >, - symbolic::ValueExpr<IncrType> >, - symbolic::ValueExpr<> > type; -}; -#endif - // Helper to cleanup the type of the increment: template<typename T> struct cleanup_seq_incr { typedef typename cleanup_index_type<T,DynamicIndex>::type type; @@ -139,21 +86,9 @@ IncrType m_incr; public: - -#if (!EIGEN_COMP_GNUC) || EIGEN_COMP_GNUC>=48 auto reverse() const -> decltype(Eigen::seqN(m_first+(m_size+fix<-1>())*m_incr,m_size,-m_incr)) { return seqN(m_first+(m_size+fix<-1>())*m_incr,m_size,-m_incr); } -#else -protected: - typedef typename internal::aseq_negate<IncrType>::type ReverseIncrType; - typedef typename internal::aseq_reverse_first_type<FirstType,SizeType,IncrType>::type ReverseFirstType; -public: - ArithmeticSequence<ReverseFirstType,SizeType,ReverseIncrType> - reverse() const { - return seqN(m_first+(m_size+fix<-1>())*m_incr,m_size,-m_incr); - } -#endif }; /** \returns an ArithmeticSequence starting at \a first, of length \a size, and increment \a incr
diff --git a/Eigen/src/Core/AssignEvaluator.h b/Eigen/src/Core/AssignEvaluator.h index 5056328..2c00387 100644 --- a/Eigen/src/Core/AssignEvaluator.h +++ b/Eigen/src/Core/AssignEvaluator.h
@@ -42,7 +42,7 @@ DstAlignment = DstEvaluator::Alignment, SrcAlignment = SrcEvaluator::Alignment, DstHasDirectAccess = (DstFlags & DirectAccessBit) == DirectAccessBit, - JointAlignment = EIGEN_PLAIN_ENUM_MIN(DstAlignment,SrcAlignment) + JointAlignment = plain_enum_min(DstAlignment, SrcAlignment) }; private: @@ -53,8 +53,8 @@ InnerMaxSize = int(Dst::IsVectorAtCompileTime) ? int(Dst::MaxSizeAtCompileTime) : int(DstFlags)&RowMajorBit ? int(Dst::MaxColsAtCompileTime) : int(Dst::MaxRowsAtCompileTime), - RestrictedInnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(InnerSize,MaxPacketSize), - RestrictedLinearSize = EIGEN_SIZE_MIN_PREFER_FIXED(Dst::SizeAtCompileTime,MaxPacketSize), + RestrictedInnerSize = min_size_prefer_fixed(InnerSize, MaxPacketSize), + RestrictedLinearSize = min_size_prefer_fixed(Dst::SizeAtCompileTime, MaxPacketSize), OuterStride = int(outer_stride_at_compile_time<Dst>::ret), MaxSizeAtCompileTime = Dst::SizeAtCompileTime };
diff --git a/Eigen/src/Core/BandMatrix.h b/Eigen/src/Core/BandMatrix.h index 69b7681..a8d8b19 100644 --- a/Eigen/src/Core/BandMatrix.h +++ b/Eigen/src/Core/BandMatrix.h
@@ -43,7 +43,7 @@ DataRowsAtCompileTime = ((Supers!=Dynamic) && (Subs!=Dynamic)) ? 1 + Supers + Subs : Dynamic, - SizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime,ColsAtCompileTime) + SizeAtCompileTime = min_size_prefer_dynamic(RowsAtCompileTime,ColsAtCompileTime) }; public: @@ -98,8 +98,8 @@ DiagonalSize = (RowsAtCompileTime==Dynamic || ColsAtCompileTime==Dynamic) ? Dynamic : (ActualIndex<0 - ? EIGEN_SIZE_MIN_PREFER_DYNAMIC(ColsAtCompileTime, RowsAtCompileTime + ActualIndex) - : EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime, ColsAtCompileTime - ActualIndex)) + ? min_size_prefer_dynamic(ColsAtCompileTime, RowsAtCompileTime + ActualIndex) + : min_size_prefer_dynamic(RowsAtCompileTime, ColsAtCompileTime - ActualIndex)) }; typedef Block<CoefficientsType,1, DiagonalSize> BuildType; typedef typename internal::conditional<Conjugate,
diff --git a/Eigen/src/Core/CoreEvaluators.h b/Eigen/src/Core/CoreEvaluators.h index 1dcd2f8..4a20312 100644 --- a/Eigen/src/Core/CoreEvaluators.h +++ b/Eigen/src/Core/CoreEvaluators.h
@@ -657,9 +657,9 @@ ) ), Flags = (Flags0 & ~RowMajorBit) | (Arg1Flags & RowMajorBit), - Alignment = EIGEN_PLAIN_ENUM_MIN( - EIGEN_PLAIN_ENUM_MIN(evaluator<Arg1>::Alignment, evaluator<Arg2>::Alignment), - evaluator<Arg3>::Alignment) + Alignment = plain_enum_min( + plain_enum_min(evaluator<Arg1>::Alignment, evaluator<Arg2>::Alignment), + evaluator<Arg3>::Alignment) }; EIGEN_DEVICE_FUNC explicit ternary_evaluator(const XprType& xpr) : m_d(xpr) @@ -753,7 +753,7 @@ ) ), Flags = (Flags0 & ~RowMajorBit) | (LhsFlags & RowMajorBit), - Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<Lhs>::Alignment,evaluator<Rhs>::Alignment) + Alignment = plain_enum_min(evaluator<Lhs>::Alignment, evaluator<Rhs>::Alignment) }; EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE @@ -902,7 +902,7 @@ m_innerStride(map.innerStride()), m_outerStride(map.outerStride()) { - EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(evaluator<Derived>::Flags&PacketAccessBit, internal::inner_stride_at_compile_time<Derived>::ret==1), + EIGEN_STATIC_ASSERT(check_implication(evaluator<Derived>::Flags&PacketAccessBit, internal::inner_stride_at_compile_time<Derived>::ret==1), PACKET_ACCESS_REQUIRES_TO_HAVE_INNER_STRIDE_FIXED_TO_1); EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost); } @@ -1074,7 +1074,7 @@ Alignment0 = (InnerPanel && (OuterStrideAtCompileTime!=Dynamic) && (OuterStrideAtCompileTime!=0) && (((OuterStrideAtCompileTime * int(sizeof(Scalar))) % int(PacketAlignment)) == 0)) ? int(PacketAlignment) : 0, - Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<ArgType>::Alignment, Alignment0) + Alignment = plain_enum_min(evaluator<ArgType>::Alignment, Alignment0) }; typedef block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel> block_evaluator_type; EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE @@ -1225,7 +1225,7 @@ : mapbase_evaluator<XprType, typename XprType::PlainObject>(block) { // TODO: for the 3.3 release, this should be turned to an internal assertion, but let's keep it as is for the beta lifetime - eigen_assert(((internal::UIntPtr(block.data()) % EIGEN_PLAIN_ENUM_MAX(1,evaluator<XprType>::Alignment)) == 0) && "data is not aligned"); + eigen_assert(((internal::UIntPtr(block.data()) % plain_enum_max(1,evaluator<XprType>::Alignment)) == 0) && "data is not aligned"); } }; @@ -1241,12 +1241,12 @@ typedef Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> XprType; enum { CoeffReadCost = evaluator<ConditionMatrixType>::CoeffReadCost - + EIGEN_PLAIN_ENUM_MAX(evaluator<ThenMatrixType>::CoeffReadCost, - evaluator<ElseMatrixType>::CoeffReadCost), + + plain_enum_max(evaluator<ThenMatrixType>::CoeffReadCost, + evaluator<ElseMatrixType>::CoeffReadCost), Flags = (unsigned int)evaluator<ThenMatrixType>::Flags & evaluator<ElseMatrixType>::Flags & HereditaryBits, - Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<ThenMatrixType>::Alignment, evaluator<ElseMatrixType>::Alignment) + Alignment = plain_enum_min(evaluator<ThenMatrixType>::Alignment, evaluator<ElseMatrixType>::Alignment) }; EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
diff --git a/Eigen/src/Core/DenseBase.h b/Eigen/src/Core/DenseBase.h index 439322d..d62c851 100644 --- a/Eigen/src/Core/DenseBase.h +++ b/Eigen/src/Core/DenseBase.h
@@ -674,8 +674,8 @@ * Only do it when debugging Eigen, as this borders on paranoia and could slow compilation down */ #ifdef EIGEN_INTERNAL_DEBUGGING - EIGEN_STATIC_ASSERT((EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, int(IsRowMajor)) - && EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, int(!IsRowMajor))), + EIGEN_STATIC_ASSERT((internal::check_implication(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, int(IsRowMajor)) + && internal::check_implication(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, int(!IsRowMajor))), INVALID_STORAGE_ORDER_FOR_THIS_VECTOR_EXPRESSION) #endif }
diff --git a/Eigen/src/Core/DenseStorage.h b/Eigen/src/Core/DenseStorage.h index 04afd72..371da3c 100644 --- a/Eigen/src/Core/DenseStorage.h +++ b/Eigen/src/Core/DenseStorage.h
@@ -62,7 +62,7 @@ #if defined(EIGEN_DISABLE_UNALIGNED_ARRAY_ASSERT) #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask) -#elif EIGEN_GNUC_AT_LEAST(4,7) +#elif EIGEN_COMP_GNUC // GCC 4.7 is too aggressive in its optimizations and remove the alignment test based on the fact the array is declared to be aligned. // See this bug report: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53900 // Hiding the origin of the array pointer behind a function argument seems to do the trick even if the function is inlined:
diff --git a/Eigen/src/Core/Diagonal.h b/Eigen/src/Core/Diagonal.h index 7564c4c..6d8df3d 100644 --- a/Eigen/src/Core/Diagonal.h +++ b/Eigen/src/Core/Diagonal.h
@@ -44,14 +44,14 @@ typedef typename MatrixType::StorageKind StorageKind; enum { RowsAtCompileTime = (int(DiagIndex) == DynamicIndex || int(MatrixType::SizeAtCompileTime) == Dynamic) ? Dynamic - : (EIGEN_PLAIN_ENUM_MIN(MatrixType::RowsAtCompileTime - EIGEN_PLAIN_ENUM_MAX(-DiagIndex, 0), - MatrixType::ColsAtCompileTime - EIGEN_PLAIN_ENUM_MAX( DiagIndex, 0))), + : (plain_enum_min(MatrixType::RowsAtCompileTime - plain_enum_max(-DiagIndex, 0), + MatrixType::ColsAtCompileTime - plain_enum_max( DiagIndex, 0))), ColsAtCompileTime = 1, MaxRowsAtCompileTime = int(MatrixType::MaxSizeAtCompileTime) == Dynamic ? Dynamic - : DiagIndex == DynamicIndex ? EIGEN_SIZE_MIN_PREFER_FIXED(MatrixType::MaxRowsAtCompileTime, - MatrixType::MaxColsAtCompileTime) - : (EIGEN_PLAIN_ENUM_MIN(MatrixType::MaxRowsAtCompileTime - EIGEN_PLAIN_ENUM_MAX(-DiagIndex, 0), - MatrixType::MaxColsAtCompileTime - EIGEN_PLAIN_ENUM_MAX( DiagIndex, 0))), + : DiagIndex == DynamicIndex ? min_size_prefer_fixed(MatrixType::MaxRowsAtCompileTime, + MatrixType::MaxColsAtCompileTime) + : (plain_enum_min(MatrixType::MaxRowsAtCompileTime - plain_enum_max(-DiagIndex, 0), + MatrixType::MaxColsAtCompileTime - plain_enum_max( DiagIndex, 0))), MaxColsAtCompileTime = 1, MaskLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0, Flags = (unsigned int)_MatrixTypeNested::Flags & (RowMajorBit | MaskLvalueBit | DirectAccessBit) & ~RowMajorBit, // FIXME DirectAccessBit should not be handled by expressions
diff --git a/Eigen/src/Core/GeneralProduct.h b/Eigen/src/Core/GeneralProduct.h index 251b5d4..33b667d 100644 --- a/Eigen/src/Core/GeneralProduct.h +++ b/Eigen/src/Core/GeneralProduct.h
@@ -59,10 +59,10 @@ Rows = traits<_Lhs>::RowsAtCompileTime, MaxCols = traits<_Rhs>::MaxColsAtCompileTime, Cols = traits<_Rhs>::ColsAtCompileTime, - MaxDepth = EIGEN_SIZE_MIN_PREFER_FIXED(traits<_Lhs>::MaxColsAtCompileTime, - traits<_Rhs>::MaxRowsAtCompileTime), - Depth = EIGEN_SIZE_MIN_PREFER_FIXED(traits<_Lhs>::ColsAtCompileTime, - traits<_Rhs>::RowsAtCompileTime) + MaxDepth = min_size_prefer_fixed(traits<_Lhs>::MaxColsAtCompileTime, + traits<_Rhs>::MaxRowsAtCompileTime), + Depth = min_size_prefer_fixed(traits<_Lhs>::ColsAtCompileTime, + traits<_Rhs>::RowsAtCompileTime) }; // the splitting into different lines of code here, introducing the _select enums and the typedef below, @@ -182,12 +182,13 @@ PacketSize = internal::packet_traits<Scalar>::size }; #if EIGEN_MAX_STATIC_ALIGN_BYTES!=0 - internal::plain_array<Scalar,EIGEN_SIZE_MIN_PREFER_FIXED(Size,MaxSize),0,EIGEN_PLAIN_ENUM_MIN(AlignedMax,PacketSize)> m_data; + internal::plain_array<Scalar, internal::min_size_prefer_fixed(Size, MaxSize), 0, + internal::plain_enum_min(AlignedMax, PacketSize)> m_data; EIGEN_STRONG_INLINE Scalar* data() { return m_data.array; } #else // Some architectures cannot align on the stack, // => let's manually enforce alignment by allocating more data and return the address of the first aligned element. - internal::plain_array<Scalar,EIGEN_SIZE_MIN_PREFER_FIXED(Size,MaxSize)+(ForceAlignment?EIGEN_MAX_ALIGN_BYTES:0),0> m_data; + internal::plain_array<Scalar, internal::min_size_prefer_fixed(Size, MaxSize)+(ForceAlignment?EIGEN_MAX_ALIGN_BYTES:0),0> m_data; EIGEN_STRONG_INLINE Scalar* data() { return ForceAlignment ? reinterpret_cast<Scalar*>((internal::UIntPtr(m_data.array) & ~(std::size_t(EIGEN_MAX_ALIGN_BYTES-1))) + EIGEN_MAX_ALIGN_BYTES) @@ -225,7 +226,7 @@ typedef internal::blas_traits<Rhs> RhsBlasTraits; typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType; - typedef Map<Matrix<ResScalar,Dynamic,1>, EIGEN_PLAIN_ENUM_MIN(AlignedMax,internal::packet_traits<ResScalar>::size)> MappedDest; + typedef Map<Matrix<ResScalar,Dynamic,1>, plain_enum_min(AlignedMax, internal::packet_traits<ResScalar>::size)> MappedDest; ActualLhsType actualLhs = LhsBlasTraits::extract(lhs); ActualRhsType actualRhs = RhsBlasTraits::extract(rhs);
diff --git a/Eigen/src/Core/GlobalFunctions.h b/Eigen/src/Core/GlobalFunctions.h index c6d36ea..53f9dfa 100644 --- a/Eigen/src/Core/GlobalFunctions.h +++ b/Eigen/src/Core/GlobalFunctions.h
@@ -116,10 +116,9 @@ #else template <typename Derived,typename ScalarExponent> EIGEN_DEVICE_FUNC inline - EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE( const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,typename internal::promote_scalar_arg<typename Derived::Scalar EIGEN_COMMA ScalarExponent EIGEN_COMMA - EIGEN_SCALAR_BINARY_SUPPORTED(pow,typename Derived::Scalar,ScalarExponent)>::type,pow)) + EIGEN_SCALAR_BINARY_SUPPORTED(pow,typename Derived::Scalar,ScalarExponent)>::type,pow) pow(const Eigen::ArrayBase<Derived>& x, const ScalarExponent& exponent) { typedef typename internal::promote_scalar_arg<typename Derived::Scalar,ScalarExponent, @@ -170,10 +169,9 @@ #else template <typename Scalar, typename Derived> EIGEN_DEVICE_FUNC inline - EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE( const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(typename internal::promote_scalar_arg<typename Derived::Scalar EIGEN_COMMA Scalar EIGEN_COMMA - EIGEN_SCALAR_BINARY_SUPPORTED(pow,Scalar,typename Derived::Scalar)>::type,Derived,pow)) + EIGEN_SCALAR_BINARY_SUPPORTED(pow,Scalar,typename Derived::Scalar)>::type,Derived,pow) pow(const Scalar& x, const Eigen::ArrayBase<Derived>& exponents) { typedef typename internal::promote_scalar_arg<typename Derived::Scalar,Scalar, EIGEN_SCALAR_BINARY_SUPPORTED(pow,Scalar,typename Derived::Scalar)>::type PromotedScalar;
diff --git a/Eigen/src/Core/MathFunctions.h b/Eigen/src/Core/MathFunctions.h index 957cca7..55e3159 100644 --- a/Eigen/src/Core/MathFunctions.h +++ b/Eigen/src/Core/MathFunctions.h
@@ -21,15 +21,6 @@ namespace Eigen { -// On WINCE, std::abs is defined for int only, so let's defined our own overloads: -// This issue has been confirmed with MSVC 2008 only, but the issue might exist for more recent versions too. -#if EIGEN_OS_WINCE && EIGEN_COMP_MSVC && EIGEN_COMP_MSVC<=1500 -long abs(long x) { return (labs(x)); } -double abs(double x) { return (fabs(x)); } -float abs(float x) { return (fabsf(x)); } -long double abs(long double x) { return (fabsl(x)); } -#endif - namespace internal { /** \internal \class global_math_functions_filtering_base @@ -925,8 +916,8 @@ #else enum { rand_bits = meta_floor_log2<(unsigned int)(RAND_MAX)+1>::value, scalar_bits = sizeof(Scalar) * CHAR_BIT, - shift = EIGEN_PLAIN_ENUM_MAX(0, int(rand_bits) - int(scalar_bits)), - offset = NumTraits<Scalar>::IsSigned ? (1 << (EIGEN_PLAIN_ENUM_MIN(rand_bits,scalar_bits)-1)) : 0 + shift = plain_enum_max(0, int(rand_bits) - int(scalar_bits)), + offset = NumTraits<Scalar>::IsSigned ? (1 << (plain_enum_min(rand_bits, scalar_bits)-1)) : 0 }; return Scalar((std::rand() >> shift) - offset); #endif @@ -963,7 +954,7 @@ // Implementation of is* functions // std::is* do not work with fast-math and gcc, std::is* are available on MSVC 2013 and newer, as well as in clang. -#if (EIGEN_HAS_CXX11_MATH && !(EIGEN_COMP_GNUC_STRICT && __FINITE_MATH_ONLY__)) || (EIGEN_COMP_MSVC>=1800) || (EIGEN_COMP_CLANG) +#if (EIGEN_HAS_CXX11_MATH && !(EIGEN_COMP_GNUC_STRICT && __FINITE_MATH_ONLY__)) || (EIGEN_COMP_MSVC) || (EIGEN_COMP_CLANG) #define EIGEN_USE_STD_FPCLASSIFY 1 #else #define EIGEN_USE_STD_FPCLASSIFY 0 @@ -1049,7 +1040,7 @@ #elif (defined __FINITE_MATH_ONLY__ && __FINITE_MATH_ONLY__ && EIGEN_COMP_GNUC) -#if EIGEN_GNUC_AT_LEAST(5,0) +#if EIGEN_COMP_GNUC #define EIGEN_TMP_NOOPT_ATTRIB EIGEN_DEVICE_FUNC inline __attribute__((optimize("no-finite-math-only"))) #else // NOTE the inline qualifier and noinline attribute are both needed: the former is to avoid linking issue (duplicate symbol),
diff --git a/Eigen/src/Core/MatrixBase.h b/Eigen/src/Core/MatrixBase.h index 3552d5a..70d0cf7 100644 --- a/Eigen/src/Core/MatrixBase.h +++ b/Eigen/src/Core/MatrixBase.h
@@ -94,8 +94,8 @@ #ifndef EIGEN_PARSED_BY_DOXYGEN /** type of the equivalent square matrix */ - typedef Matrix<Scalar,EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime), - EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime)> SquareMatrixType; + typedef Matrix<Scalar, internal::max_size_prefer_dynamic(RowsAtCompileTime, ColsAtCompileTime), + internal::max_size_prefer_dynamic(RowsAtCompileTime, ColsAtCompileTime)> SquareMatrixType; #endif // not EIGEN_PARSED_BY_DOXYGEN /** \returns the size of the main diagonal, which is min(rows(),cols()).
diff --git a/Eigen/src/Core/NumTraits.h b/Eigen/src/Core/NumTraits.h index 63ba416..e484bb6 100644 --- a/Eigen/src/Core/NumTraits.h +++ b/Eigen/src/Core/NumTraits.h
@@ -85,12 +85,10 @@ // TODO: Replace by std::bit_cast (available in C++20) template <typename Tgt, typename Src> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Tgt bit_cast(const Src& src) { -#if EIGEN_HAS_TYPE_TRAITS // The behaviour of memcpy is not specified for non-trivially copyable types EIGEN_STATIC_ASSERT(std::is_trivially_copyable<Src>::value, THIS_TYPE_IS_NOT_SUPPORTED); EIGEN_STATIC_ASSERT(std::is_trivially_copyable<Tgt>::value && std::is_default_constructible<Tgt>::value, THIS_TYPE_IS_NOT_SUPPORTED); -#endif EIGEN_STATIC_ASSERT(sizeof(Src) == sizeof(Tgt), THIS_TYPE_IS_NOT_SUPPORTED); Tgt tgt;
diff --git a/Eigen/src/Core/PlainObjectBase.h b/Eigen/src/Core/PlainObjectBase.h index 89960b9..4367ea5 100644 --- a/Eigen/src/Core/PlainObjectBase.h +++ b/Eigen/src/Core/PlainObjectBase.h
@@ -136,8 +136,8 @@ enum { NeedsToAlign = (SizeAtCompileTime != Dynamic) && (internal::traits<Derived>::Alignment>0) }; EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign) - EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, (int(Options)&RowMajor)==RowMajor), INVALID_MATRIX_TEMPLATE_PARAMETERS) - EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, (int(Options)&RowMajor)==0), INVALID_MATRIX_TEMPLATE_PARAMETERS) + EIGEN_STATIC_ASSERT(internal::check_implication(MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1, (int(Options)&RowMajor)==RowMajor), INVALID_MATRIX_TEMPLATE_PARAMETERS) + EIGEN_STATIC_ASSERT(internal::check_implication(MaxColsAtCompileTime==1 && MaxRowsAtCompileTime!=1, (int(Options)&RowMajor)==0), INVALID_MATRIX_TEMPLATE_PARAMETERS) EIGEN_STATIC_ASSERT((RowsAtCompileTime == Dynamic) || (RowsAtCompileTime >= 0), INVALID_MATRIX_TEMPLATE_PARAMETERS) EIGEN_STATIC_ASSERT((ColsAtCompileTime == Dynamic) || (ColsAtCompileTime >= 0), INVALID_MATRIX_TEMPLATE_PARAMETERS) EIGEN_STATIC_ASSERT((MaxRowsAtCompileTime == Dynamic) || (MaxRowsAtCompileTime >= 0), INVALID_MATRIX_TEMPLATE_PARAMETERS) @@ -282,10 +282,10 @@ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index rows, Index cols) { - eigen_assert(EIGEN_IMPLIES(RowsAtCompileTime!=Dynamic,rows==RowsAtCompileTime) - && EIGEN_IMPLIES(ColsAtCompileTime!=Dynamic,cols==ColsAtCompileTime) - && EIGEN_IMPLIES(RowsAtCompileTime==Dynamic && MaxRowsAtCompileTime!=Dynamic,rows<=MaxRowsAtCompileTime) - && EIGEN_IMPLIES(ColsAtCompileTime==Dynamic && MaxColsAtCompileTime!=Dynamic,cols<=MaxColsAtCompileTime) + eigen_assert(internal::check_implication(RowsAtCompileTime!=Dynamic, rows==RowsAtCompileTime) + && internal::check_implication(ColsAtCompileTime!=Dynamic, cols==ColsAtCompileTime) + && internal::check_implication(RowsAtCompileTime==Dynamic && MaxRowsAtCompileTime!=Dynamic, rows<=MaxRowsAtCompileTime) + && internal::check_implication(ColsAtCompileTime==Dynamic && MaxColsAtCompileTime!=Dynamic, cols<=MaxColsAtCompileTime) && rows>=0 && cols>=0 && "Invalid sizes when resizing a matrix or array."); internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(rows, cols); #ifdef EIGEN_INITIALIZE_COEFFS @@ -983,11 +983,7 @@ template <typename Derived, typename OtherDerived, bool IsVector> struct conservative_resize_like_impl { - #if EIGEN_HAS_TYPE_TRAITS static const bool IsRelocatable = std::is_trivially_copyable<typename Derived::Scalar>::value; - #else - static const bool IsRelocatable = !NumTraits<typename Derived::Scalar>::RequireInitialization; - #endif static void run(DenseBase<Derived>& _this, Index rows, Index cols) { if (_this.rows() == rows && _this.cols() == cols) return;
diff --git a/Eigen/src/Core/Product.h b/Eigen/src/Core/Product.h index 545fdb9..3b788b3 100644 --- a/Eigen/src/Core/Product.h +++ b/Eigen/src/Core/Product.h
@@ -42,7 +42,7 @@ MaxColsAtCompileTime = RhsTraits::MaxColsAtCompileTime, // FIXME: only needed by GeneralMatrixMatrixTriangular - InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(LhsTraits::ColsAtCompileTime, RhsTraits::RowsAtCompileTime), + InnerSize = min_size_prefer_fixed(LhsTraits::ColsAtCompileTime, RhsTraits::RowsAtCompileTime), // The storage order is somewhat arbitrary here. The correct one will be determined through the evaluator. Flags = (MaxRowsAtCompileTime==1 && MaxColsAtCompileTime!=1) ? RowMajorBit
diff --git a/Eigen/src/Core/ProductEvaluators.h b/Eigen/src/Core/ProductEvaluators.h index 42e92c2..aff3572 100644 --- a/Eigen/src/Core/ProductEvaluators.h +++ b/Eigen/src/Core/ProductEvaluators.h
@@ -537,7 +537,7 @@ enum { RowsAtCompileTime = LhsNestedCleaned::RowsAtCompileTime, ColsAtCompileTime = RhsNestedCleaned::ColsAtCompileTime, - InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(LhsNestedCleaned::ColsAtCompileTime, RhsNestedCleaned::RowsAtCompileTime), + InnerSize = min_size_prefer_fixed(LhsNestedCleaned::ColsAtCompileTime, RhsNestedCleaned::RowsAtCompileTime), MaxRowsAtCompileTime = LhsNestedCleaned::MaxRowsAtCompileTime, MaxColsAtCompileTime = RhsNestedCleaned::MaxColsAtCompileTime }; @@ -566,8 +566,8 @@ RhsVecPacketSize = unpacket_traits<RhsVecPacketType>::size, // Here, we don't care about alignment larger than the usable packet size. - LhsAlignment = EIGEN_PLAIN_ENUM_MIN(LhsEtorType::Alignment,LhsVecPacketSize*int(sizeof(typename LhsNestedCleaned::Scalar))), - RhsAlignment = EIGEN_PLAIN_ENUM_MIN(RhsEtorType::Alignment,RhsVecPacketSize*int(sizeof(typename RhsNestedCleaned::Scalar))), + LhsAlignment = plain_enum_min(LhsEtorType::Alignment, LhsVecPacketSize*int(sizeof(typename LhsNestedCleaned::Scalar))), + RhsAlignment = plain_enum_min(RhsEtorType::Alignment, RhsVecPacketSize*int(sizeof(typename RhsNestedCleaned::Scalar))), SameType = is_same<typename LhsNestedCleaned::Scalar,typename RhsNestedCleaned::Scalar>::value, @@ -587,8 +587,8 @@ LhsOuterStrideBytes = int(LhsNestedCleaned::OuterStrideAtCompileTime) * int(sizeof(typename LhsNestedCleaned::Scalar)), RhsOuterStrideBytes = int(RhsNestedCleaned::OuterStrideAtCompileTime) * int(sizeof(typename RhsNestedCleaned::Scalar)), - Alignment = bool(CanVectorizeLhs) ? (LhsOuterStrideBytes<=0 || (int(LhsOuterStrideBytes) % EIGEN_PLAIN_ENUM_MAX(1,LhsAlignment))!=0 ? 0 : LhsAlignment) - : bool(CanVectorizeRhs) ? (RhsOuterStrideBytes<=0 || (int(RhsOuterStrideBytes) % EIGEN_PLAIN_ENUM_MAX(1,RhsAlignment))!=0 ? 0 : RhsAlignment) + Alignment = bool(CanVectorizeLhs) ? (LhsOuterStrideBytes<=0 || (int(LhsOuterStrideBytes) % plain_enum_max(1, LhsAlignment))!=0 ? 0 : LhsAlignment) + : bool(CanVectorizeRhs) ? (RhsOuterStrideBytes<=0 || (int(RhsOuterStrideBytes) % plain_enum_max(1, RhsAlignment))!=0 ? 0 : RhsAlignment) : 0, /* CanVectorizeInner deserves special explanation. It does not affect the product flags. It is not used outside @@ -889,7 +889,7 @@ { enum { InnerSize = (MatrixType::Flags & RowMajorBit) ? MatrixType::ColsAtCompileTime : MatrixType::RowsAtCompileTime, - DiagonalPacketLoadMode = EIGEN_PLAIN_ENUM_MIN(LoadMode,((InnerSize%16) == 0) ? int(Aligned16) : int(evaluator<DiagonalType>::Alignment)) // FIXME hardcoded 16!! + DiagonalPacketLoadMode = plain_enum_min(LoadMode,((InnerSize%16) == 0) ? int(Aligned16) : int(evaluator<DiagonalType>::Alignment)) // FIXME hardcoded 16!! }; return internal::pmul(m_matImpl.template packet<LoadMode,PacketType>(row, col), m_diagImpl.template packet<DiagonalPacketLoadMode,PacketType>(id));
diff --git a/Eigen/src/Core/Redux.h b/Eigen/src/Core/Redux.h index e05a0cc..d3efad9 100644 --- a/Eigen/src/Core/Redux.h +++ b/Eigen/src/Core/Redux.h
@@ -240,7 +240,7 @@ const int packetAlignment = unpacket_traits<PacketScalar>::alignment; enum { alignment0 = (bool(Evaluator::Flags & DirectAccessBit) && bool(packet_traits<Scalar>::AlignedOnScalar)) ? int(packetAlignment) : int(Unaligned), - alignment = EIGEN_PLAIN_ENUM_MAX(alignment0, Evaluator::Alignment) + alignment = plain_enum_max(alignment0, Evaluator::Alignment) }; const Index alignedStart = internal::first_default_aligned(xpr); const Index alignedSize2 = ((size-alignedStart)/(2*packetSize))*(2*packetSize);
diff --git a/Eigen/src/Core/Reshaped.h b/Eigen/src/Core/Reshaped.h index 8a9cedb..9448445 100644 --- a/Eigen/src/Core/Reshaped.h +++ b/Eigen/src/Core/Reshaped.h
@@ -445,7 +445,7 @@ : mapbase_evaluator<XprType, typename XprType::PlainObject>(xpr) { // TODO: for the 3.4 release, this should be turned to an internal assertion, but let's keep it as is for the beta lifetime - eigen_assert(((internal::UIntPtr(xpr.data()) % EIGEN_PLAIN_ENUM_MAX(1,evaluator<XprType>::Alignment)) == 0) && "data is not aligned"); + eigen_assert(((internal::UIntPtr(xpr.data()) % plain_enum_max(1, evaluator<XprType>::Alignment)) == 0) && "data is not aligned"); } };
diff --git a/Eigen/src/Core/VectorwiseOp.h b/Eigen/src/Core/VectorwiseOp.h index 3c3cc45..5d4c11f 100644 --- a/Eigen/src/Core/VectorwiseOp.h +++ b/Eigen/src/Core/VectorwiseOp.h
@@ -232,9 +232,9 @@ typename ExtendedType<OtherDerived>::Type extendedTo(const DenseBase<OtherDerived>& other) const { - EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(isVertical, OtherDerived::MaxColsAtCompileTime==1), + EIGEN_STATIC_ASSERT(internal::check_implication(isVertical, OtherDerived::MaxColsAtCompileTime==1), YOU_PASSED_A_ROW_VECTOR_BUT_A_COLUMN_VECTOR_WAS_EXPECTED) - EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(isHorizontal, OtherDerived::MaxRowsAtCompileTime==1), + EIGEN_STATIC_ASSERT(internal::check_implication(isHorizontal, OtherDerived::MaxRowsAtCompileTime==1), YOU_PASSED_A_COLUMN_VECTOR_BUT_A_ROW_VECTOR_WAS_EXPECTED) return typename ExtendedType<OtherDerived>::Type (other.derived(), @@ -255,9 +255,9 @@ typename OppositeExtendedType<OtherDerived>::Type extendedToOpposite(const DenseBase<OtherDerived>& other) const { - EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(isHorizontal, OtherDerived::MaxColsAtCompileTime==1), + EIGEN_STATIC_ASSERT(internal::check_implication(isHorizontal, OtherDerived::MaxColsAtCompileTime==1), YOU_PASSED_A_ROW_VECTOR_BUT_A_COLUMN_VECTOR_WAS_EXPECTED) - EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(isVertical, OtherDerived::MaxRowsAtCompileTime==1), + EIGEN_STATIC_ASSERT(internal::check_implication(isVertical, OtherDerived::MaxRowsAtCompileTime==1), YOU_PASSED_A_COLUMN_VECTOR_BUT_A_ROW_VECTOR_WAS_EXPECTED) return typename OppositeExtendedType<OtherDerived>::Type (other.derived(),
diff --git a/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h b/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h index 071acf0..5f2a130 100644 --- a/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h +++ b/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
@@ -440,6 +440,7 @@ EIGEN_UNUSED Packet pexp_float(const Packet _x) { + const Packet cst_zero = pset1<Packet>(0.0f); const Packet cst_1 = pset1<Packet>(1.0f); const Packet cst_half = pset1<Packet>(0.5f); const Packet cst_exp_hi = pset1<Packet>( 88.723f); @@ -454,7 +455,8 @@ const Packet cst_cephes_exp_p5 = pset1<Packet>(5.0000001201E-1f); // Clamp x. - Packet x = pmax(pmin(_x, cst_exp_hi), cst_exp_lo); + Packet zero_mask = pcmp_lt(_x, cst_exp_lo); + Packet x = pmin(_x, cst_exp_hi); // Express exp(x) as exp(m*ln(2) + r), start by extracting // m = floor(x/ln(2) + 0.5). @@ -483,7 +485,7 @@ // Return 2^m * exp(r). // TODO: replace pldexp with faster implementation since y in [-1, 1). - return pmax(pldexp(y,m), _x); + return pselect(zero_mask, cst_zero, pmax(pldexp(y,m), _x)); } template <typename Packet> @@ -492,7 +494,7 @@ Packet pexp_double(const Packet _x) { Packet x = _x; - + const Packet cst_zero = pset1<Packet>(0.0f); const Packet cst_1 = pset1<Packet>(1.0); const Packet cst_2 = pset1<Packet>(2.0); const Packet cst_half = pset1<Packet>(0.5); @@ -514,7 +516,8 @@ Packet tmp, fx; // clamp x - x = pmax(pmin(x, cst_exp_hi), cst_exp_lo); + Packet zero_mask = pcmp_lt(_x, cst_exp_lo); + x = pmin(x, cst_exp_hi); // Express exp(x) as exp(g + n*log(2)). fx = pmadd(cst_cephes_LOG2EF, x, cst_half); @@ -552,7 +555,7 @@ // Construct the result 2^n * exp(g) = e * x. The max is used to catch // non-finite values in the input. // TODO: replace pldexp with faster implementation since x in [-1, 1). - return pmax(pldexp(x,fx), _x); + return pselect(zero_mask, cst_zero, pmax(pldexp(x,fx), _x)); } // The following code is inspired by the following stack-overflow answer: @@ -621,7 +624,7 @@ template<bool ComputeSine,typename Packet> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED -#if EIGEN_GNUC_AT_LEAST(4,4) && EIGEN_COMP_GNUC_STRICT +#if EIGEN_COMP_GNUC_STRICT __attribute__((optimize("-fno-unsafe-math-optimizations"))) #endif Packet psincos_float(const Packet& _x)
diff --git a/Eigen/src/Core/arch/NEON/PacketMath.h b/Eigen/src/Core/arch/NEON/PacketMath.h index e908bf5..707f7d7 100644 --- a/Eigen/src/Core/arch/NEON/PacketMath.h +++ b/Eigen/src/Core/arch/NEON/PacketMath.h
@@ -450,15 +450,6 @@ }; }; -#if EIGEN_GNUC_AT_MOST(4, 4) && !EIGEN_COMP_LLVM -// workaround gcc 4.2, 4.3 and 4.4 compilation issue -EIGEN_STRONG_INLINE float32x4_t vld1q_f32(const float* x) { return ::vld1q_f32((const float32_t*)x); } -EIGEN_STRONG_INLINE float32x2_t vld1_f32(const float* x) { return ::vld1_f32 ((const float32_t*)x); } -EIGEN_STRONG_INLINE float32x2_t vld1_dup_f32(const float* x) { return ::vld1_dup_f32 ((const float32_t*)x); } -EIGEN_STRONG_INLINE void vst1q_f32(float* to, float32x4_t from) { ::vst1q_f32((float32_t*)to,from); } -EIGEN_STRONG_INLINE void vst1_f32 (float* to, float32x2_t from) { ::vst1_f32 ((float32_t*)to,from); } -#endif - template<> struct unpacket_traits<Packet2f> { typedef float type;
diff --git a/Eigen/src/Core/arch/SSE/Complex.h b/Eigen/src/Core/arch/SSE/Complex.h index ccee04b..61e9406 100644 --- a/Eigen/src/Core/arch/SSE/Complex.h +++ b/Eigen/src/Core/arch/SSE/Complex.h
@@ -137,17 +137,9 @@ template<> EIGEN_STRONG_INLINE std::complex<float> pfirst<Packet2cf>(const Packet2cf& a) { - #if EIGEN_GNUC_AT_MOST(4,3) - // Workaround gcc 4.2 ICE - this is not performance wise ideal, but who cares... - // This workaround also fix invalid code generation with gcc 4.3 - EIGEN_ALIGN16 std::complex<float> res[2]; - _mm_store_ps((float*)res, a.v); - return res[0]; - #else std::complex<float> res; _mm_storel_pi((__m64*)&res, a.v); return res; - #endif } template<> EIGEN_STRONG_INLINE Packet2cf preverse(const Packet2cf& a) { return Packet2cf(_mm_castpd_ps(preverse(Packet2d(_mm_castps_pd(a.v))))); }
diff --git a/Eigen/src/Core/arch/SSE/PacketMath.h b/Eigen/src/Core/arch/SSE/PacketMath.h index f2d2667..45e219c 100755 --- a/Eigen/src/Core/arch/SSE/PacketMath.h +++ b/Eigen/src/Core/arch/SSE/PacketMath.h
@@ -247,18 +247,9 @@ template<> struct scalar_div_cost<double,true> { enum { value = 8 }; }; #endif -#if EIGEN_COMP_MSVC==1500 -// Workaround MSVC 9 internal compiler error. -// TODO: It has been detected with win64 builds (amd64), so let's check whether it also happens in 32bits+SSE mode -// TODO: let's check whether there does not exist a better fix, like adding a pset0() function. (it crashed on pset1(0)). -template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float& from) { return _mm_set_ps(from,from,from,from); } -template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double& from) { return _mm_set_pd(from,from); } -template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int& from) { return _mm_set_epi32(from,from,from,from); } -#else template<> EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(const float& from) { return _mm_set_ps1(from); } template<> EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(const double& from) { return _mm_set1_pd(from); } template<> EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(const int& from) { return _mm_set1_epi32(from); } -#endif template<> EIGEN_STRONG_INLINE Packet16b pset1<Packet16b>(const bool& from) { return _mm_set1_epi8(static_cast<char>(from)); } template<> EIGEN_STRONG_INLINE Packet4f pset1frombits<Packet4f>(unsigned int from) { return _mm_castsi128_ps(pset1<Packet4i>(from)); } @@ -721,15 +712,7 @@ #if EIGEN_COMP_MSVC template<> EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(const float* from) { EIGEN_DEBUG_UNALIGNED_LOAD - #if (EIGEN_COMP_MSVC==1600) - // NOTE Some version of MSVC10 generates bad code when using _mm_loadu_ps - // (i.e., it does not generate an unaligned load!! - __m128 res = _mm_loadl_pi(_mm_set1_ps(0.0f), (const __m64*)(from)); - res = _mm_loadh_pi(res, (const __m64*)(from+2)); - return res; - #else return _mm_loadu_ps(from); - #endif } #else // NOTE: with the code below, MSVC's compiler crashes!
diff --git a/Eigen/src/Core/functors/NullaryFunctors.h b/Eigen/src/Core/functors/NullaryFunctors.h index 8e43266..0293a99 100644 --- a/Eigen/src/Core/functors/NullaryFunctors.h +++ b/Eigen/src/Core/functors/NullaryFunctors.h
@@ -154,7 +154,7 @@ // For unreliable compilers, let's specialize the has_*ary_operator // helpers so that at least built-in nullary functors work fine. -#if !( (EIGEN_COMP_MSVC>1600) || (EIGEN_GNUC_AT_LEAST(4,8)) || (EIGEN_COMP_ICC>=1600)) +#if !( EIGEN_COMP_MSVC || EIGEN_COMP_GNUC || (EIGEN_COMP_ICC>=1600)) template<typename Scalar,typename IndexType> struct has_nullary_operator<scalar_constant_op<Scalar>,IndexType> { enum { value = 1}; }; template<typename Scalar,typename IndexType>
diff --git a/Eigen/src/Core/products/GeneralBlockPanelKernel.h b/Eigen/src/Core/products/GeneralBlockPanelKernel.h index 89e999b..938f5fb 100644 --- a/Eigen/src/Core/products/GeneralBlockPanelKernel.h +++ b/Eigen/src/Core/products/GeneralBlockPanelKernel.h
@@ -442,7 +442,7 @@ nr = 4, // register block size along the M direction (currently, this one cannot be modified) - default_mr = (EIGEN_PLAIN_ENUM_MIN(16,NumberOfRegisters)/2/nr)*LhsPacketSize, + default_mr = (plain_enum_min(16, NumberOfRegisters)/2/nr)*LhsPacketSize, #if defined(EIGEN_HAS_SINGLE_INSTRUCTION_MADD) && !defined(EIGEN_VECTORIZE_ALTIVEC) && !defined(EIGEN_VECTORIZE_VSX) \ && ((!EIGEN_COMP_MSVC) || (EIGEN_COMP_MSVC>=1914)) // we assume 16 registers or more @@ -571,7 +571,7 @@ // we assume 16 registers mr = 3*LhsPacketSize, #else - mr = (EIGEN_PLAIN_ENUM_MIN(16,NumberOfRegisters)/2/nr)*LhsPacketSize, + mr = (plain_enum_min(16, NumberOfRegisters)/2/nr)*LhsPacketSize, #endif LhsProgress = LhsPacketSize, @@ -954,7 +954,7 @@ NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS, // FIXME: should depend on NumberOfRegisters nr = 4, - mr = (EIGEN_PLAIN_ENUM_MIN(16,NumberOfRegisters)/2/nr)*ResPacketSize, + mr = (plain_enum_min(16, NumberOfRegisters)/2/nr)*ResPacketSize, LhsProgress = ResPacketSize, RhsProgress = 1
diff --git a/Eigen/src/Core/products/GeneralMatrixMatrix.h b/Eigen/src/Core/products/GeneralMatrixMatrix.h index 007c71e..df64232 100644 --- a/Eigen/src/Core/products/GeneralMatrixMatrix.h +++ b/Eigen/src/Core/products/GeneralMatrixMatrix.h
@@ -422,7 +422,7 @@ typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned; enum { - MaxDepthAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(Lhs::MaxColsAtCompileTime,Rhs::MaxRowsAtCompileTime) + MaxDepthAtCompileTime = min_size_prefer_fixed(Lhs::MaxColsAtCompileTime, Rhs::MaxRowsAtCompileTime) }; typedef generic_product_impl<Lhs,Rhs,DenseShape,DenseShape,CoeffBasedProductMode> lazyproduct;
diff --git a/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h b/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h index fc6f838..465294b 100644 --- a/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h +++ b/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
@@ -144,7 +144,7 @@ typedef typename Traits::ResScalar ResScalar; enum { - BlockSize = meta_least_common_multiple<EIGEN_PLAIN_ENUM_MAX(mr,nr),EIGEN_PLAIN_ENUM_MIN(mr,nr)>::ret + BlockSize = meta_least_common_multiple<plain_enum_max(mr, nr), plain_enum_min(mr,nr)>::ret }; void operator()(ResScalar* _res, Index resIncr, Index resStride, const LhsScalar* blockA, const RhsScalar* blockB, Index size, Index depth, const ResScalar& alpha) {
diff --git a/Eigen/src/Core/products/SelfadjointMatrixMatrix.h b/Eigen/src/Core/products/SelfadjointMatrixMatrix.h index 504fa0c..f6fdbca 100644 --- a/Eigen/src/Core/products/SelfadjointMatrixMatrix.h +++ b/Eigen/src/Core/products/SelfadjointMatrixMatrix.h
@@ -314,10 +314,10 @@ const Scalar& alpha, level3_blocking<Scalar,Scalar>& blocking) { product_selfadjoint_matrix<Scalar, Index, - EIGEN_LOGICAL_XOR(RhsSelfAdjoint,RhsStorageOrder==RowMajor) ? ColMajor : RowMajor, - RhsSelfAdjoint, NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(RhsSelfAdjoint,ConjugateRhs), - EIGEN_LOGICAL_XOR(LhsSelfAdjoint,LhsStorageOrder==RowMajor) ? ColMajor : RowMajor, - LhsSelfAdjoint, NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(LhsSelfAdjoint,ConjugateLhs), + logical_xor(RhsSelfAdjoint,RhsStorageOrder==RowMajor) ? ColMajor : RowMajor, + RhsSelfAdjoint, NumTraits<Scalar>::IsComplex && logical_xor(RhsSelfAdjoint, ConjugateRhs), + logical_xor(LhsSelfAdjoint,LhsStorageOrder==RowMajor) ? ColMajor : RowMajor, + LhsSelfAdjoint, NumTraits<Scalar>::IsComplex && logical_xor(LhsSelfAdjoint, ConjugateLhs), ColMajor,ResInnerStride> ::run(cols, rows, rhs, rhsStride, lhs, lhsStride, res, resIncr, resStride, alpha, blocking); } @@ -523,10 +523,10 @@ BlockingType blocking(lhs.rows(), rhs.cols(), lhs.cols(), 1, false); internal::product_selfadjoint_matrix<Scalar, Index, - EIGEN_LOGICAL_XOR(LhsIsUpper,internal::traits<Lhs>::Flags &RowMajorBit) ? RowMajor : ColMajor, LhsIsSelfAdjoint, - NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(LhsIsUpper,bool(LhsBlasTraits::NeedToConjugate)), - EIGEN_LOGICAL_XOR(RhsIsUpper,internal::traits<Rhs>::Flags &RowMajorBit) ? RowMajor : ColMajor, RhsIsSelfAdjoint, - NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(RhsIsUpper,bool(RhsBlasTraits::NeedToConjugate)), + internal::logical_xor(LhsIsUpper, internal::traits<Lhs>::Flags &RowMajorBit) ? RowMajor : ColMajor, LhsIsSelfAdjoint, + NumTraits<Scalar>::IsComplex && internal::logical_xor(LhsIsUpper, bool(LhsBlasTraits::NeedToConjugate)), + internal::logical_xor(RhsIsUpper, internal::traits<Rhs>::Flags &RowMajorBit) ? RowMajor : ColMajor, RhsIsSelfAdjoint, + NumTraits<Scalar>::IsComplex && internal::logical_xor(RhsIsUpper, bool(RhsBlasTraits::NeedToConjugate)), internal::traits<Dest>::Flags&RowMajorBit ? RowMajor : ColMajor, Dest::InnerStrideAtCompileTime> ::run(
diff --git a/Eigen/src/Core/products/SelfadjointMatrixVector.h b/Eigen/src/Core/products/SelfadjointMatrixVector.h index 3176398..086638e 100644 --- a/Eigen/src/Core/products/SelfadjointMatrixVector.h +++ b/Eigen/src/Core/products/SelfadjointMatrixVector.h
@@ -57,12 +57,12 @@ FirstTriangular = IsRowMajor == IsLower }; - conj_helper<Scalar,Scalar,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, IsRowMajor), ConjugateRhs> cj0; - conj_helper<Scalar,Scalar,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, !IsRowMajor), ConjugateRhs> cj1; + conj_helper<Scalar,Scalar,NumTraits<Scalar>::IsComplex && logical_xor(ConjugateLhs, IsRowMajor), ConjugateRhs> cj0; + conj_helper<Scalar,Scalar,NumTraits<Scalar>::IsComplex && logical_xor(ConjugateLhs, !IsRowMajor), ConjugateRhs> cj1; conj_helper<RealScalar,Scalar,false, ConjugateRhs> cjd; - conj_helper<Packet,Packet,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, IsRowMajor), ConjugateRhs> pcj0; - conj_helper<Packet,Packet,NumTraits<Scalar>::IsComplex && EIGEN_LOGICAL_XOR(ConjugateLhs, !IsRowMajor), ConjugateRhs> pcj1; + conj_helper<Packet,Packet,NumTraits<Scalar>::IsComplex && logical_xor(ConjugateLhs, IsRowMajor), ConjugateRhs> pcj0; + conj_helper<Packet,Packet,NumTraits<Scalar>::IsComplex && logical_xor(ConjugateLhs, !IsRowMajor), ConjugateRhs> pcj1; Scalar cjAlpha = ConjugateRhs ? numext::conj(alpha) : alpha; @@ -183,7 +183,7 @@ { typedef typename Dest::Scalar ResScalar; typedef typename Rhs::Scalar RhsScalar; - typedef Map<Matrix<ResScalar,Dynamic,1>, EIGEN_PLAIN_ENUM_MIN(AlignedMax,internal::packet_traits<ResScalar>::size)> MappedDest; + typedef Map<Matrix<ResScalar,Dynamic,1>, plain_enum_min(AlignedMax,internal::packet_traits<ResScalar>::size)> MappedDest; eigen_assert(dest.rows()==a_lhs.rows() && dest.cols()==a_rhs.cols());
diff --git a/Eigen/src/Core/products/TriangularMatrixMatrix.h b/Eigen/src/Core/products/TriangularMatrixMatrix.h index 60d4b05..5b8ca12 100644 --- a/Eigen/src/Core/products/TriangularMatrixMatrix.h +++ b/Eigen/src/Core/products/TriangularMatrixMatrix.h
@@ -91,7 +91,7 @@ typedef gebp_traits<Scalar,Scalar> Traits; enum { - SmallPanelWidth = 2 * EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr), + SmallPanelWidth = 2 * plain_enum_max(Traits::mr, Traits::nr), IsLower = (Mode&Lower) == Lower, SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1 }; @@ -249,7 +249,7 @@ { typedef gebp_traits<Scalar,Scalar> Traits; enum { - SmallPanelWidth = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr), + SmallPanelWidth = plain_enum_max(Traits::mr, Traits::nr), IsLower = (Mode&Lower) == Lower, SetDiag = (Mode&(ZeroDiag|UnitDiag)) ? 0 : 1 };
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h index 754345f..c6d5afa 100644 --- a/Eigen/src/Core/products/TriangularMatrixVector.h +++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -218,7 +218,7 @@ typedef internal::blas_traits<Rhs> RhsBlasTraits; typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType; - typedef Map<Matrix<ResScalar,Dynamic,1>, EIGEN_PLAIN_ENUM_MIN(AlignedMax,internal::packet_traits<ResScalar>::size)> MappedDest; + typedef Map<Matrix<ResScalar,Dynamic,1>, plain_enum_min(AlignedMax,internal::packet_traits<ResScalar>::size)> MappedDest; typename internal::add_const_on_value_type<ActualLhsType>::type actualLhs = LhsBlasTraits::extract(lhs); typename internal::add_const_on_value_type<ActualRhsType>::type actualRhs = RhsBlasTraits::extract(rhs);
diff --git a/Eigen/src/Core/products/TriangularSolverMatrix.h b/Eigen/src/Core/products/TriangularSolverMatrix.h index 0abc468..520cfc9 100644 --- a/Eigen/src/Core/products/TriangularSolverMatrix.h +++ b/Eigen/src/Core/products/TriangularSolverMatrix.h
@@ -63,7 +63,7 @@ typedef gebp_traits<Scalar,Scalar> Traits; enum { - SmallPanelWidth = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr), + SmallPanelWidth = plain_enum_max(Traits::mr, Traits::nr), IsLower = (Mode&Lower) == Lower }; @@ -216,7 +216,7 @@ typedef gebp_traits<Scalar,Scalar> Traits; enum { RhsStorageOrder = TriStorageOrder, - SmallPanelWidth = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr), + SmallPanelWidth = plain_enum_max(Traits::mr, Traits::nr), IsLower = (Mode&Lower) == Lower };
diff --git a/Eigen/src/Core/util/ConfigureVectorization.h b/Eigen/src/Core/util/ConfigureVectorization.h index 16ca3ef..ba2049b 100644 --- a/Eigen/src/Core/util/ConfigureVectorization.h +++ b/Eigen/src/Core/util/ConfigureVectorization.h
@@ -30,27 +30,13 @@ * * If we made alignment depend on whether or not EIGEN_VECTORIZE is defined, it would be impossible to link * vectorized and non-vectorized code. - * - * FIXME: this code can be cleaned up once we switch to proper C++11 only. */ #if (defined EIGEN_CUDACC) #define EIGEN_ALIGN_TO_BOUNDARY(n) __align__(n) #define EIGEN_ALIGNOF(x) __alignof(x) -#elif EIGEN_HAS_ALIGNAS +#else #define EIGEN_ALIGN_TO_BOUNDARY(n) alignas(n) #define EIGEN_ALIGNOF(x) alignof(x) -#elif EIGEN_COMP_GNUC || EIGEN_COMP_PGI || EIGEN_COMP_IBM || EIGEN_COMP_ARM - #define EIGEN_ALIGN_TO_BOUNDARY(n) __attribute__((aligned(n))) - #define EIGEN_ALIGNOF(x) __alignof(x) -#elif EIGEN_COMP_MSVC - #define EIGEN_ALIGN_TO_BOUNDARY(n) __declspec(align(n)) - #define EIGEN_ALIGNOF(x) __alignof(x) -#elif EIGEN_COMP_SUNCC - // FIXME not sure about this one: - #define EIGEN_ALIGN_TO_BOUNDARY(n) __attribute__((aligned(n))) - #define EIGEN_ALIGNOF(x) __alignof(x) -#else - #error Please tell me what is the equivalent of alignas(n) and alignof(x) for your compiler #endif // If the user explicitly disable vectorization, then we also disable alignment @@ -105,11 +91,6 @@ // try to keep heap alignment even when we have to disable static alignment. #if EIGEN_COMP_GNUC && !(EIGEN_ARCH_i386_OR_x86_64 || EIGEN_ARCH_ARM_OR_ARM64 || EIGEN_ARCH_PPC || EIGEN_ARCH_IA64 || EIGEN_ARCH_MIPS) #define EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT 1 - #elif EIGEN_ARCH_ARM_OR_ARM64 && EIGEN_COMP_GNUC_STRICT && EIGEN_GNUC_AT_MOST(4, 6) - // Old versions of GCC on ARM, at least 4.4, were once seen to have buggy static alignment support. - // Not sure which version fixed it, hopefully it doesn't affect 4.7, which is still somewhat in use. - // 4.8 and newer seem definitely unaffected. - #define EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT 1 #else #define EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT 0 #endif @@ -200,14 +181,12 @@ // removed as gcc 4.1 and msvc 2008 are not supported anyways. #if EIGEN_COMP_MSVC #include <malloc.h> // for _aligned_malloc -- need it regardless of whether vectorization is enabled - #if (EIGEN_COMP_MSVC >= 1500) // 2008 or later - // a user reported that in 64-bit mode, MSVC doesn't care to define _M_IX86_FP. - #if (defined(_M_IX86_FP) && (_M_IX86_FP >= 2)) || EIGEN_ARCH_x86_64 - #define EIGEN_SSE2_ON_MSVC_2008_OR_LATER - #endif + // a user reported that in 64-bit mode, MSVC doesn't care to define _M_IX86_FP. + #if (defined(_M_IX86_FP) && (_M_IX86_FP >= 2)) || EIGEN_ARCH_x86_64 + #define EIGEN_SSE2_ON_MSVC_2008_OR_LATER #endif #else - #if (defined __SSE2__) && ( (!EIGEN_COMP_GNUC) || EIGEN_COMP_ICC || EIGEN_GNUC_AT_LEAST(4,2) ) + #if (defined __SSE2__) && ( (!EIGEN_COMP_GNUC) || EIGEN_COMP_ICC || EIGEN_COMP_GNUC ) #define EIGEN_SSE2_ON_NON_MSVC_BUT_NOT_OLD_GCC #endif #endif
diff --git a/Eigen/src/Core/util/ForwardDeclarations.h b/Eigen/src/Core/util/ForwardDeclarations.h index 6b0ac50..2f33599 100644 --- a/Eigen/src/Core/util/ForwardDeclarations.h +++ b/Eigen/src/Core/util/ForwardDeclarations.h
@@ -53,20 +53,9 @@ template<typename Scalar_, int Rows_, int Cols_, int Options_ = AutoAlign | -#if EIGEN_GNUC_AT(3,4) - // workaround a bug in at least gcc 3.4.6 - // the innermost ?: ternary operator is misparsed. We write it slightly - // differently and this makes gcc 3.4.6 happy, but it's ugly. - // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined - // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor) - ( (Rows_==1 && Cols_!=1) ? Eigen::RowMajor - : !(Cols_==1 && Rows_!=1) ? EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION - : Eigen::ColMajor ), -#else ( (Rows_==1 && Cols_!=1) ? Eigen::RowMajor : (Cols_==1 && Rows_!=1) ? Eigen::ColMajor : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ), -#endif int MaxRows_ = Rows_, int MaxCols_ = Cols_ > class Matrix; @@ -246,20 +235,9 @@ // Array module template<typename Scalar_, int Rows_, int Cols_, int Options_ = AutoAlign | -#if EIGEN_GNUC_AT(3,4) - // workaround a bug in at least gcc 3.4.6 - // the innermost ?: ternary operator is misparsed. We write it slightly - // differently and this makes gcc 3.4.6 happy, but it's ugly. - // The error would only show up with EIGEN_DEFAULT_TO_ROW_MAJOR is defined - // (when EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION is RowMajor) - ( (Rows_==1 && Cols_!=1) ? Eigen::RowMajor - : !(Cols_==1 && Rows_!=1) ? EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION - : Eigen::ColMajor ), -#else ( (Rows_==1 && Cols_!=1) ? Eigen::RowMajor : (Cols_==1 && Rows_!=1) ? Eigen::ColMajor : EIGEN_DEFAULT_MATRIX_STORAGE_ORDER_OPTION ), -#endif int MaxRows_ = Rows_, int MaxCols_ = Cols_> class Array; template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType> class Select; template<typename MatrixType, typename BinaryOp, int Direction> class PartialReduxExpr;
diff --git a/Eigen/src/Core/util/IntegralConstant.h b/Eigen/src/Core/util/IntegralConstant.h index 0a9990c..6a60e11 100644 --- a/Eigen/src/Core/util/IntegralConstant.h +++ b/Eigen/src/Core/util/IntegralConstant.h
@@ -79,14 +79,10 @@ template<int M> FixedInt<N&M> operator&( FixedInt<M>) const { return FixedInt<N&M>(); } -#if EIGEN_HAS_CXX14_VARIABLE_TEMPLATES // Needed in C++14 to allow fix<N>(): FixedInt operator() () const { return *this; } VariableAndFixedInt<N> operator() (int val) const { return VariableAndFixedInt<N>(val); } -#else - FixedInt ( FixedInt<N> (*)() ) {} -#endif FixedInt(std::integral_constant<int,N>) {} }; @@ -138,12 +134,6 @@ static const int value = N; }; -#if !EIGEN_HAS_CXX14_VARIABLE_TEMPLATES -template<int N,int Default> struct get_fixed_value<FixedInt<N> (*)(),Default> { - static const int value = N; -}; -#endif - template<int N,int Default> struct get_fixed_value<VariableAndFixedInt<N>,Default> { static const int value = N ; }; @@ -154,9 +144,6 @@ }; template<typename T> EIGEN_DEVICE_FUNC Index get_runtime_value(const T &x) { return x; } -#if !EIGEN_HAS_CXX14_VARIABLE_TEMPLATES -template<int N> EIGEN_DEVICE_FUNC Index get_runtime_value(FixedInt<N> (*)()) { return N; } -#endif // Cleanup integer/FixedInt/VariableAndFixedInt/etc types: @@ -166,11 +153,6 @@ // Convert any integral type (e.g., short, int, unsigned int, etc.) to Eigen::Index template<typename T, int DynamicKey> struct cleanup_index_type<T,DynamicKey,typename internal::enable_if<internal::is_integral<T>::value>::type> { typedef Index type; }; -#if !EIGEN_HAS_CXX14_VARIABLE_TEMPLATES -// In c++98/c++11, fix<N> is a pointer to function that we better cleanup to a true FixedInt<N>: -template<int N, int DynamicKey> struct cleanup_index_type<FixedInt<N> (*)(), DynamicKey> { typedef FixedInt<N> type; }; -#endif - // If VariableAndFixedInt does not match DynamicKey, then we turn it to a pure compile-time value: template<int N, int DynamicKey> struct cleanup_index_type<VariableAndFixedInt<N>, DynamicKey> { typedef FixedInt<N> type; }; // If VariableAndFixedInt matches DynamicKey, then we turn it to a pure runtime-value (aka Index): @@ -182,18 +164,8 @@ #ifndef EIGEN_PARSED_BY_DOXYGEN -#if EIGEN_HAS_CXX14_VARIABLE_TEMPLATES template<int N> static const internal::FixedInt<N> fix{}; -#else -template<int N> -inline internal::FixedInt<N> fix() { return internal::FixedInt<N>(); } - -// The generic typename T is mandatory. Otherwise, a code like fix<N> could refer to either the function above or this next overload. -// This way a code like fix<N> can only refer to the previous function. -template<int N,typename T> -inline internal::VariableAndFixedInt<N> fix(T val) { return internal::VariableAndFixedInt<N>(internal::convert_index<int>(val)); } -#endif #else // EIGEN_PARSED_BY_DOXYGEN
diff --git a/Eigen/src/Core/util/Macros.h b/Eigen/src/Core/util/Macros.h index c5cbf73..0aafb9e 100644 --- a/Eigen/src/Core/util/Macros.h +++ b/Eigen/src/Core/util/Macros.h
@@ -133,10 +133,6 @@ // For the record, here is a table summarizing the possible values for EIGEN_COMP_MSVC: // name ver MSC_VER -// 2008 9 1500 -// 2010 10 1600 -// 2012 11 1700 -// 2013 12 1800 // 2015 14 1900 // "15" 15 1900 // 2017-14.1 15.0 1910 @@ -144,6 +140,9 @@ // 2017-14.12 15.5 1912 // 2017-14.13 15.6 1913 // 2017-14.14 15.7 1914 +// 2017 15.8 1915 +// 2017 15.9 1916 +// 2019 RTW 16.0 1920 /// \internal EIGEN_COMP_MSVC_LANG set to _MSVC_LANG if the compiler is Microsoft Visual C++, 0 otherwise. #if defined(_MSVC_LANG) @@ -585,16 +584,6 @@ # define __has_feature(x) 0 #endif -// Some old compilers do not support template specializations like: -// template<typename T,int N> void foo(const T x[N]); -#if !( EIGEN_COMP_CLANG && ( (EIGEN_COMP_CLANG<309) \ - || (defined(__apple_build_version__) && (__apple_build_version__ < 9000000))) \ - || EIGEN_COMP_GNUC_STRICT && EIGEN_COMP_GNUC<49) -#define EIGEN_HAS_STATIC_ARRAY_TEMPLATE 1 -#else -#define EIGEN_HAS_STATIC_ARRAY_TEMPLATE 0 -#endif - // The macro EIGEN_CPLUSPLUS is a replacement for __cplusplus/_MSVC_LANG that // works for both platforms, indicating the C++ standard version number. // @@ -627,30 +616,17 @@ #define EIGEN_COMP_CXXVER 03 #endif -#ifndef EIGEN_HAS_CXX14_VARIABLE_TEMPLATES - #if defined(__cpp_variable_templates) && __cpp_variable_templates >= 201304 && EIGEN_MAX_CPP_VER>=14 - #define EIGEN_HAS_CXX14_VARIABLE_TEMPLATES 1 - #else - #define EIGEN_HAS_CXX14_VARIABLE_TEMPLATES 0 - #endif -#endif - - // The macros EIGEN_HAS_CXX?? defines a rough estimate of available c++ features // but in practice we should not rely on them but rather on the availability of // individual features as defined later. // This is why there is no EIGEN_HAS_CXX17. -// FIXME: get rid of EIGEN_HAS_CXX14. -#if EIGEN_MAX_CPP_VER<11 || EIGEN_COMP_CXXVER<11 || (EIGEN_COMP_MSVC && EIGEN_COMP_MSVC < 1700) || (EIGEN_COMP_ICC && EIGEN_COMP_ICC < 1400) +#if EIGEN_MAX_CPP_VER<14 || EIGEN_COMP_CXXVER<14 || (EIGEN_COMP_MSVC && EIGEN_COMP_MSVC < 1900) || \ + (EIGEN_COMP_ICC && EIGEN_COMP_ICC < 1500) || (EIGEN_COMP_NVCC && EIGEN_COMP_NVCC < 80000) || \ + (EIGEN_COMP_CLANG && ((EIGEN_COMP_CLANG<309) || (defined(__apple_build_version__) && (__apple_build_version__ < 9000000)))) || \ + (EIGEN_COMP_GNUC_STRICT && EIGEN_COMP_GNUC<51) #error This compiler appears to be too old to be supported by Eigen #endif -#if EIGEN_MAX_CPP_VER>=14 && EIGEN_COMP_CXXVER>=14 -#define EIGEN_HAS_CXX14 1 -#else -#define EIGEN_HAS_CXX14 0 -#endif - // Does the compiler support C99? // Need to include <cmath> to make sure _GLIBCXX_USE_C99 gets defined #include <cmath> @@ -658,7 +634,7 @@ #if ((defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)) \ || (defined(__GNUC__) && defined(_GLIBCXX_USE_C99)) \ || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER)) \ - || (EIGEN_COMP_MSVC >= 1900) || defined(SYCL_DEVICE_ONLY)) + || (EIGEN_COMP_MSVC) || defined(SYCL_DEVICE_ONLY)) #define EIGEN_HAS_C99_MATH 1 #else #define EIGEN_HAS_C99_MATH 0 @@ -694,57 +670,14 @@ #endif #endif -#ifndef EIGEN_HAS_ALIGNAS -#if ( __has_feature(cxx_alignas) \ - || EIGEN_HAS_CXX14 \ - || (EIGEN_COMP_MSVC >= 1800) \ - || (EIGEN_GNUC_AT_LEAST(4,8)) \ - || (EIGEN_COMP_CLANG>=305) \ - || (EIGEN_COMP_ICC>=1500) \ - || (EIGEN_COMP_PGI>=1500) \ - || (EIGEN_COMP_SUNCC>=0x5130)) -#define EIGEN_HAS_ALIGNAS 1 -#else -#define EIGEN_HAS_ALIGNAS 0 -#endif -#endif - -// Does the compiler support type_traits? -// - full support of type traits was added only to GCC 5.1.0. -// - 20150626 corresponds to the last release of 4.x libstdc++ -#ifndef EIGEN_HAS_TYPE_TRAITS -#if ((!EIGEN_COMP_GNUC_STRICT) || EIGEN_GNUC_AT_LEAST(5, 1)) \ - && ((!defined(__GLIBCXX__)) || __GLIBCXX__ > 20150626) -#define EIGEN_HAS_TYPE_TRAITS 1 -#define EIGEN_INCLUDE_TYPE_TRAITS -#else -#define EIGEN_HAS_TYPE_TRAITS 0 -#endif -#endif - -// Does the compiler support variadic templates? -#ifndef EIGEN_HAS_VARIADIC_TEMPLATES -#if (!defined(__NVCC__) || !EIGEN_ARCH_ARM_OR_ARM64 || (EIGEN_COMP_NVCC >= 80000) ) - // ^^ Disable the use of variadic templates when compiling with versions of nvcc older than 8.0 on ARM devices: - // this prevents nvcc from crashing when compiling Eigen on Tegra X1 -#define EIGEN_HAS_VARIADIC_TEMPLATES 1 -#elif defined(SYCL_DEVICE_ONLY) -#define EIGEN_HAS_VARIADIC_TEMPLATES 1 -#else -#define EIGEN_HAS_VARIADIC_TEMPLATES 0 -#endif -#endif - // Does the compiler fully support const expressions? (as in c++14) #ifndef EIGEN_HAS_CONSTEXPR #if defined(EIGEN_CUDACC) // Const expressions are supported provided that c++11 is enabled and we're using either clang or nvcc 7.5 or above - #if EIGEN_MAX_CPP_VER>=14 && (EIGEN_COMP_CLANG || EIGEN_COMP_NVCC >= 70500) + #if (EIGEN_COMP_CLANG || EIGEN_COMP_NVCC >= 70500) #define EIGEN_HAS_CONSTEXPR 1 #endif - #elif EIGEN_MAX_CPP_VER>=14 && (__has_feature(cxx_relaxed_constexpr) || (EIGEN_COMP_CXXVER >= 14) || \ - (EIGEN_GNUC_AT_LEAST(4,8) && (EIGEN_COMP_CXXVER >= 11)) || \ - (EIGEN_COMP_CLANG >= 306 && (EIGEN_COMP_CXXVER >= 11))) + #else #define EIGEN_HAS_CONSTEXPR 1 #endif @@ -763,8 +696,7 @@ // Does the compiler support C++11 math? // Let's be conservative and enable the default C++11 implementation only if we are sure it exists #ifndef EIGEN_HAS_CXX11_MATH - #if ((EIGEN_COMP_CXXVER > 11) || (EIGEN_COMP_GNUC_STRICT || EIGEN_COMP_CLANG || EIGEN_COMP_MSVC || EIGEN_COMP_ICC) \ - && (EIGEN_ARCH_i386_OR_x86_64) && (EIGEN_OS_GNULINUX || EIGEN_OS_WIN_STRICT || EIGEN_OS_MAC)) + #if (EIGEN_ARCH_i386_OR_x86_64 && (EIGEN_OS_GNULINUX || EIGEN_OS_WIN_STRICT || EIGEN_OS_MAC)) #define EIGEN_HAS_CXX11_MATH 1 #else #define EIGEN_HAS_CXX11_MATH 0 @@ -848,15 +780,11 @@ #endif #endif -// EIGEN_ALWAYS_INLINE is the stronget, it has the effect of making the function inline and adding every possible +// EIGEN_ALWAYS_INLINE is the strongest, it has the effect of making the function inline and adding every possible // attribute to maximize inlining. This should only be used when really necessary: in particular, // it uses __attribute__((always_inline)) on GCC, which most of the time is useless and can severely harm compile times. // FIXME with the always_inline attribute, -// gcc 3.4.x and 4.1 reports the following compilation error: -// Eval.h:91: sorry, unimplemented: inlining failed in call to 'const Eigen::Eval<Derived> Eigen::MatrixBase<Scalar, Derived>::eval() const' -// : function body not available -// See also bug 1367 -#if EIGEN_GNUC_AT_LEAST(4,2) && !defined(SYCL_DEVICE_ONLY) +#if EIGEN_COMP_GNUC && !defined(SYCL_DEVICE_ONLY) #define EIGEN_ALWAYS_INLINE __attribute__((always_inline)) inline #else #define EIGEN_ALWAYS_INLINE EIGEN_STRONG_INLINE @@ -1037,14 +965,8 @@ // General, NEON. // Clang doesn't like "r", // error: non-trivial scalar-to-vector conversion, possible invalid - // constraint for vector type - // GCC < 5 doesn't like "g", - // error: 'asm' operand requires impossible reload - #if EIGEN_COMP_GNUC_STRICT && EIGEN_GNUC_AT_MOST(5, 0) - #define EIGEN_OPTIMIZATION_BARRIER(X) __asm__ ("" : "+r,w" (X)); - #else - #define EIGEN_OPTIMIZATION_BARRIER(X) __asm__ ("" : "+g,w" (X)); - #endif + // constraint for vector typ + #define EIGEN_OPTIMIZATION_BARRIER(X) __asm__ ("" : "+g,w" (X)); #elif EIGEN_ARCH_i386_OR_x86_64 // General, SSE. #define EIGEN_OPTIMIZATION_BARRIER(X) __asm__ ("" : "+g,x" (X)); @@ -1098,8 +1020,8 @@ #define EIGEN_USING_STD(FUNC) using std::FUNC; #endif -#if EIGEN_COMP_MSVC_STRICT && (EIGEN_COMP_MSVC < 1900 || EIGEN_COMP_NVCC) - // For older MSVC versions, as well as when compiling with NVCC, using the base operator is necessary, +#if EIGEN_COMP_MSVC_STRICT && EIGEN_COMP_NVCC + // Wwhen compiling with NVCC, using the base operator is necessary, // otherwise we get duplicate definition errors // For later MSVC versions, we require explicit operator= definition, otherwise we get // use of implicitly deleted operator errors. @@ -1188,35 +1110,6 @@ typedef typename Base::PacketScalar PacketScalar; -#define EIGEN_PLAIN_ENUM_MIN(a,b) (((int)a <= (int)b) ? (int)a : (int)b) -#define EIGEN_PLAIN_ENUM_MAX(a,b) (((int)a >= (int)b) ? (int)a : (int)b) - -// EIGEN_SIZE_MIN_PREFER_DYNAMIC gives the min between compile-time sizes. 0 has absolute priority, followed by 1, -// followed by Dynamic, followed by other finite values. The reason for giving Dynamic the priority over -// finite values is that min(3, Dynamic) should be Dynamic, since that could be anything between 0 and 3. -#define EIGEN_SIZE_MIN_PREFER_DYNAMIC(a,b) (((int)a == 0 || (int)b == 0) ? 0 \ - : ((int)a == 1 || (int)b == 1) ? 1 \ - : ((int)a == Dynamic || (int)b == Dynamic) ? Dynamic \ - : ((int)a <= (int)b) ? (int)a : (int)b) - -// EIGEN_SIZE_MIN_PREFER_FIXED is a variant of EIGEN_SIZE_MIN_PREFER_DYNAMIC comparing MaxSizes. The difference is that finite values -// now have priority over Dynamic, so that min(3, Dynamic) gives 3. Indeed, whatever the actual value is -// (between 0 and 3), it is not more than 3. -#define EIGEN_SIZE_MIN_PREFER_FIXED(a,b) (((int)a == 0 || (int)b == 0) ? 0 \ - : ((int)a == 1 || (int)b == 1) ? 1 \ - : ((int)a == Dynamic && (int)b == Dynamic) ? Dynamic \ - : ((int)a == Dynamic) ? (int)b \ - : ((int)b == Dynamic) ? (int)a \ - : ((int)a <= (int)b) ? (int)a : (int)b) - -// see EIGEN_SIZE_MIN_PREFER_DYNAMIC. No need for a separate variant for MaxSizes here. -#define EIGEN_SIZE_MAX(a,b) (((int)a == Dynamic || (int)b == Dynamic) ? Dynamic \ - : ((int)a >= (int)b) ? (int)a : (int)b) - -#define EIGEN_LOGICAL_XOR(a,b) (((a) || (b)) && !((a) && (b))) - -#define EIGEN_IMPLIES(a,b) (!(a) || (b)) - #if EIGEN_HAS_BUILTIN(__builtin_expect) || EIGEN_COMP_GNUC #define EIGEN_PREDICT_FALSE(x) (__builtin_expect(x, false)) #define EIGEN_PREDICT_TRUE(x) (__builtin_expect(false || (x), true)) @@ -1255,16 +1148,9 @@ CwiseBinaryOp<EIGEN_CAT(EIGEN_CAT(internal::scalar_,OPNAME),_op)<SCALAR,typename internal::traits<EXPR>::Scalar>, \ const typename internal::plain_constant_type<EXPR,SCALAR>::type, const EXPR> -// Workaround for MSVC 2010 (see ML thread "patch with compile for for MSVC 2010") -#if EIGEN_COMP_MSVC_STRICT && (EIGEN_COMP_MSVC_STRICT<=1600) -#define EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(X) typename internal::enable_if<true,X>::type -#else -#define EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(X) X -#endif - #define EIGEN_MAKE_SCALAR_BINARY_OP_ONTHERIGHT(METHOD,OPNAME) \ template <typename T> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE \ - EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,typename internal::promote_scalar_arg<Scalar EIGEN_COMMA T EIGEN_COMMA EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,Scalar,T)>::type,OPNAME))\ + const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,typename internal::promote_scalar_arg<Scalar EIGEN_COMMA T EIGEN_COMMA EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,Scalar,T)>::type,OPNAME)\ (METHOD)(const T& scalar) const { \ typedef typename internal::promote_scalar_arg<Scalar,T,EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,Scalar,T)>::type PromotedT; \ return EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(Derived,PromotedT,OPNAME)(derived(), \ @@ -1273,7 +1159,7 @@ #define EIGEN_MAKE_SCALAR_BINARY_OP_ONTHELEFT(METHOD,OPNAME) \ template <typename T> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE friend \ - EIGEN_MSVC10_WORKAROUND_BINARYOP_RETURN_TYPE(const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(typename internal::promote_scalar_arg<Scalar EIGEN_COMMA T EIGEN_COMMA EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,T,Scalar)>::type,Derived,OPNAME)) \ + const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(typename internal::promote_scalar_arg<Scalar EIGEN_COMMA T EIGEN_COMMA EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,T,Scalar)>::type,Derived,OPNAME) \ (METHOD)(const T& scalar, const StorageBaseType& matrix) { \ typedef typename internal::promote_scalar_arg<Scalar,T,EIGEN_SCALAR_BINARY_SUPPORTED(OPNAME,T,Scalar)>::type PromotedT; \ return EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(PromotedT,Derived,OPNAME)( \ @@ -1311,14 +1197,12 @@ #endif -#define EIGEN_INCLUDE_TYPE_TRAITS #define EIGEN_NOEXCEPT noexcept #define EIGEN_NOEXCEPT_IF(x) noexcept(x) #define EIGEN_NO_THROW noexcept(true) #define EIGEN_EXCEPTION_SPEC(X) noexcept(false) -#if EIGEN_HAS_VARIADIC_TEMPLATES // The all function is used to enable a variadic version of eigen_assert which can take a parameter pack as its input. namespace Eigen { namespace internal { @@ -1330,7 +1214,6 @@ } } -#endif // provide override and final specifiers if they are available: #define EIGEN_OVERRIDE override
diff --git a/Eigen/src/Core/util/Memory.h b/Eigen/src/Core/util/Memory.h index 5211d04..dc6cec7 100644 --- a/Eigen/src/Core/util/Memory.h +++ b/Eigen/src/Core/util/Memory.h
@@ -936,7 +936,7 @@ __asm__ __volatile__ ("cpuid": "=a" (abcd[0]), "=b" (abcd[1]), "=c" (abcd[2]), "=d" (abcd[3]) : "0" (func), "2" (id) ); # endif # elif EIGEN_COMP_MSVC -# if (EIGEN_COMP_MSVC > 1500) && EIGEN_ARCH_i386_OR_x86_64 +# if EIGEN_ARCH_i386_OR_x86_64 # define EIGEN_CPUID(abcd,func,id) __cpuidex((int*)abcd,func,id) # endif # endif
diff --git a/Eigen/src/Core/util/Meta.h b/Eigen/src/Core/util/Meta.h index f2c4dfe..b641f97 100755 --- a/Eigen/src/Core/util/Meta.h +++ b/Eigen/src/Core/util/Meta.h
@@ -371,7 +371,7 @@ #endif // C++14 integer/index_sequence. -#if defined(__cpp_lib_integer_sequence) && __cpp_lib_integer_sequence >= 201304L && EIGEN_MAX_CPP_VER >= 14 +#if defined(__cpp_lib_integer_sequence) && __cpp_lib_integer_sequence >= 201304L using std::integer_sequence; using std::make_integer_sequence; @@ -579,6 +579,82 @@ } // end namespace numext +namespace internal { +/// \internal Returns true if its argument is of integer or enum type. +/// FIXME this has the same purpose as `is_valid_index_type` in XprHelper.h +template<typename A> +constexpr bool is_int_or_enum_v = std::is_enum<A>::value || std::is_integral<A>::value; + +/// \internal Gets the minimum of two values which may be integers or enums +template<typename A, typename B> +inline constexpr int plain_enum_min(A a, B b) { + static_assert(is_int_or_enum_v<A>, "Argument a must be an integer or enum"); + static_assert(is_int_or_enum_v<B>, "Argument b must be an integer or enum"); + return ((int) a <= (int) b) ? (int) a : (int) b; +} + +/// \internal Gets the maximum of two values which may be integers or enums +template<typename A, typename B> +inline constexpr int plain_enum_max(A a, B b) { + static_assert(is_int_or_enum_v<A>, "Argument a must be an integer or enum"); + static_assert(is_int_or_enum_v<B>, "Argument b must be an integer or enum"); + return ((int) a >= (int) b) ? (int) a : (int) b; +} + +/** + * \internal + * `min_size_prefer_dynamic` gives the min between compile-time sizes. 0 has absolute priority, followed by 1, + * followed by Dynamic, followed by other finite values. The reason for giving Dynamic the priority over + * finite values is that min(3, Dynamic) should be Dynamic, since that could be anything between 0 and 3. + */ +template<typename A, typename B> +inline constexpr int min_size_prefer_dynamic(A a, B b) { + static_assert(is_int_or_enum_v<A>, "Argument a must be an integer or enum"); + static_assert(is_int_or_enum_v<B>, "Argument b must be an integer or enum"); + if ((int) a == 0 || (int) b == 0) return 0; + if ((int) a == 1 || (int) b == 1) return 1; + if ((int) a == Dynamic || (int) b == Dynamic) return Dynamic; + return plain_enum_min(a, b); +} + +/** + * \internal + * min_size_prefer_fixed is a variant of `min_size_prefer_dynamic` comparing MaxSizes. The difference is that finite values + * now have priority over Dynamic, so that min(3, Dynamic) gives 3. Indeed, whatever the actual value is + * (between 0 and 3), it is not more than 3. + */ +template<typename A, typename B> +inline constexpr int min_size_prefer_fixed(A a, B b) { + static_assert(is_int_or_enum_v<A>, "Argument a must be an integer or enum"); + static_assert(is_int_or_enum_v<B>, "Argument b must be an integer or enum"); + if ((int) a == 0 || (int) b == 0) return 0; + if ((int) a == 1 || (int) b == 1) return 1; + if ((int) a == Dynamic && (int) b == Dynamic) return Dynamic; + if ((int) a == Dynamic) return (int) b; + if ((int) b == Dynamic) return (int) a; + return plain_enum_min(a, b); +} + +/// \internal see `min_size_prefer_fixed`. No need for a separate variant for MaxSizes here. +template<typename A, typename B> +inline constexpr int max_size_prefer_dynamic(A a, B b) { + static_assert(is_int_or_enum_v<A>, "Argument a must be an integer or enum"); + static_assert(is_int_or_enum_v<B>, "Argument b must be an integer or enum"); + if ((int) a == Dynamic || (int) b == Dynamic) return Dynamic; + return plain_enum_max(a, b); +} + +/// \internal Calculate logical XOR at compile time +inline constexpr bool logical_xor(bool a, bool b) { + return (a || b) && !(a && b); +} + +/// \internal Calculate logical IMPLIES at compile time +inline constexpr bool check_implication(bool a, bool b) { + return !a || b; +} +} // end namespace internal + } // end namespace Eigen #endif // EIGEN_META_H
diff --git a/Eigen/src/Core/util/SymbolicIndex.h b/Eigen/src/Core/util/SymbolicIndex.h index 9135a4a..533890d 100644 --- a/Eigen/src/Core/util/SymbolicIndex.h +++ b/Eigen/src/Core/util/SymbolicIndex.h
@@ -92,10 +92,8 @@ template<typename T> Index eval(const T& values) const { return derived().eval_impl(values); } -#if EIGEN_HAS_CXX14 template<typename... Types> Index eval(Types&&... values) const { return derived().eval_impl(std::make_tuple(values...)); } -#endif NegateExpr<Derived> operator-() const { return NegateExpr<Derived>(derived()); } @@ -143,34 +141,6 @@ friend QuotientExpr<ValueExpr<internal::FixedInt<N> >,Derived> operator/(internal::FixedInt<N>, const BaseExpr& b) { return QuotientExpr<ValueExpr<internal::FixedInt<N> > ,Derived>(ValueExpr<internal::FixedInt<N> >(),b.derived()); } -#if (!EIGEN_HAS_CXX14) - template<int N> - AddExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator+(internal::FixedInt<N> (*)()) const - { return AddExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(), ValueExpr<internal::FixedInt<N> >()); } - template<int N> - AddExpr<Derived,ValueExpr<internal::FixedInt<-N> > > operator-(internal::FixedInt<N> (*)()) const - { return AddExpr<Derived,ValueExpr<internal::FixedInt<-N> > >(derived(), ValueExpr<internal::FixedInt<-N> >()); } - template<int N> - ProductExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator*(internal::FixedInt<N> (*)()) const - { return ProductExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(),ValueExpr<internal::FixedInt<N> >()); } - template<int N> - QuotientExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator/(internal::FixedInt<N> (*)()) const - { return QuotientExpr<Derived,ValueExpr<internal::FixedInt<N> > >(derived(),ValueExpr<internal::FixedInt<N> >()); } - - template<int N> - friend AddExpr<Derived,ValueExpr<internal::FixedInt<N> > > operator+(internal::FixedInt<N> (*)(), const BaseExpr& b) - { return AddExpr<Derived,ValueExpr<internal::FixedInt<N> > >(b.derived(), ValueExpr<internal::FixedInt<N> >()); } - template<int N> - friend AddExpr<NegateExpr<Derived>,ValueExpr<internal::FixedInt<N> > > operator-(internal::FixedInt<N> (*)(), const BaseExpr& b) - { return AddExpr<NegateExpr<Derived>,ValueExpr<internal::FixedInt<N> > >(-b.derived(), ValueExpr<internal::FixedInt<N> >()); } - template<int N> - friend ProductExpr<ValueExpr<internal::FixedInt<N> >,Derived> operator*(internal::FixedInt<N> (*)(), const BaseExpr& b) - { return ProductExpr<ValueExpr<internal::FixedInt<N> >,Derived>(ValueExpr<internal::FixedInt<N> >(),b.derived()); } - template<int N> - friend QuotientExpr<ValueExpr<internal::FixedInt<N> >,Derived> operator/(internal::FixedInt<N> (*)(), const BaseExpr& b) - { return QuotientExpr<ValueExpr<internal::FixedInt<N> > ,Derived>(ValueExpr<internal::FixedInt<N> >(),b.derived()); } -#endif - template<typename OtherDerived> AddExpr<Derived,OtherDerived> operator+(const BaseExpr<OtherDerived> &b) const @@ -232,11 +202,9 @@ Index eval_impl(const SymbolValue<Tag> &values) const { return values.value(); } -#if EIGEN_HAS_CXX14 // C++14 versions suitable for multiple symbols template<typename... Types> Index eval_impl(const std::tuple<Types...>& values) const { return std::get<SymbolValue<Tag> >(values).value(); } -#endif }; template<typename Arg0>
diff --git a/Eigen/src/Core/util/XprHelper.h b/Eigen/src/Core/util/XprHelper.h index 5740510..a1314e9 100644 --- a/Eigen/src/Core/util/XprHelper.h +++ b/Eigen/src/Core/util/XprHelper.h
@@ -14,7 +14,7 @@ // just a workaround because GCC seems to not really like empty structs // FIXME: gcc 4.3 generates bad code when strict-aliasing is enabled // so currently we simply disable this optimization for gcc 4.3 -#if EIGEN_COMP_GNUC && !EIGEN_GNUC_AT(4,3) +#if EIGEN_COMP_GNUC #define EIGEN_EMPTY_STRUCT_CTOR(X) \ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE X() {} \ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE X(const X& ) {} @@ -39,15 +39,7 @@ // 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 { - enum { value = -#if EIGEN_HAS_TYPE_TRAITS - internal::is_integral<T>::value || std::is_enum<T>::value -#elif EIGEN_COMP_MSVC - internal::is_integral<T>::value || __is_enum(T) -#else - // without C++11, we use is_convertible to Index instead of is_integral in order to treat enums as Index. - internal::is_convertible<T,Index>::value && !internal::is_same<T,float>::value && !is_same<T,double>::value -#endif + enum { value = internal::is_integral<T>::value || std::is_enum<T>::value }; }; @@ -654,8 +646,9 @@ template<typename ExpressionType, typename Scalar = typename ExpressionType::Scalar> struct plain_diag_type { - enum { diag_size = EIGEN_SIZE_MIN_PREFER_DYNAMIC(ExpressionType::RowsAtCompileTime, ExpressionType::ColsAtCompileTime), - max_diag_size = EIGEN_SIZE_MIN_PREFER_FIXED(ExpressionType::MaxRowsAtCompileTime, ExpressionType::MaxColsAtCompileTime) + enum { diag_size = internal::min_size_prefer_dynamic(ExpressionType::RowsAtCompileTime, ExpressionType::ColsAtCompileTime), + max_diag_size = min_size_prefer_fixed(ExpressionType::MaxRowsAtCompileTime, + ExpressionType::MaxColsAtCompileTime) }; typedef Matrix<Scalar, diag_size, 1, ExpressionType::PlainObject::Options & ~RowMajor, max_diag_size, 1> MatrixDiagType; typedef Array<Scalar, diag_size, 1, ExpressionType::PlainObject::Options & ~RowMajor, max_diag_size, 1> ArrayDiagType;
diff --git a/Eigen/src/Geometry/Transform.h b/Eigen/src/Geometry/Transform.h index 27ea962..ca9e34f 100644 --- a/Eigen/src/Geometry/Transform.h +++ b/Eigen/src/Geometry/Transform.h
@@ -319,12 +319,12 @@ check_template_params(); // prevent conversions as: // Affine | AffineCompact | Isometry = Projective - EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(OtherMode==int(Projective), Mode==int(Projective)), + EIGEN_STATIC_ASSERT(internal::check_implication(OtherMode==int(Projective), Mode==int(Projective)), YOU_PERFORMED_AN_INVALID_TRANSFORMATION_CONVERSION) // prevent conversions as: // Isometry = Affine | AffineCompact - EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(OtherMode==int(Affine)||OtherMode==int(AffineCompact), Mode!=int(Isometry)), + EIGEN_STATIC_ASSERT(internal::check_implication(OtherMode==int(Affine)||OtherMode==int(AffineCompact), Mode!=int(Isometry)), YOU_PERFORMED_AN_INVALID_TRANSFORMATION_CONVERSION) enum { ModeIsAffineCompact = Mode == int(AffineCompact), @@ -1404,7 +1404,7 @@ Dim = TransformType::Dim, HDim = TransformType::HDim, OtherRows = MatrixType::RowsAtCompileTime, - WorkingRows = EIGEN_PLAIN_ENUM_MIN(TransformMatrix::RowsAtCompileTime,HDim) + WorkingRows = plain_enum_min(TransformMatrix::RowsAtCompileTime, HDim) }; typedef typename MatrixType::PlainObject ResultType;
diff --git a/Eigen/src/Geometry/Umeyama.h b/Eigen/src/Geometry/Umeyama.h index 5f79b3a..08ef930 100644 --- a/Eigen/src/Geometry/Umeyama.h +++ b/Eigen/src/Geometry/Umeyama.h
@@ -34,7 +34,7 @@ struct umeyama_transform_matrix_type { enum { - MinRowsAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(MatrixType::RowsAtCompileTime, OtherMatrixType::RowsAtCompileTime), + MinRowsAtCompileTime = internal::min_size_prefer_dynamic(MatrixType::RowsAtCompileTime, OtherMatrixType::RowsAtCompileTime), // When possible we want to choose some small fixed size value since the result // is likely to fit on the stack. So here, EIGEN_SIZE_MIN_PREFER_DYNAMIC is not what we want. @@ -104,7 +104,7 @@ EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename internal::traits<OtherDerived>::Scalar>::value), YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY) - enum { Dimension = EIGEN_SIZE_MIN_PREFER_DYNAMIC(Derived::RowsAtCompileTime, OtherDerived::RowsAtCompileTime) }; + enum { Dimension = internal::min_size_prefer_dynamic(Derived::RowsAtCompileTime, OtherDerived::RowsAtCompileTime) }; typedef Matrix<Scalar, Dimension, 1> VectorType; typedef Matrix<Scalar, Dimension, Dimension> MatrixType;
diff --git a/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h b/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h index a1408a6..ce2b688 100644 --- a/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h +++ b/Eigen/src/IterativeLinearSolvers/ConjugateGradient.h
@@ -208,7 +208,7 @@ && (!NumTraits<Scalar>::IsComplex) }; typedef typename internal::conditional<TransposeInput,Transpose<const ActualMatrixType>, ActualMatrixType const&>::type RowMajorWrapper; - EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(MatrixWrapper::MatrixFree,UpLo==(Lower|Upper)),MATRIX_FREE_CONJUGATE_GRADIENT_IS_COMPATIBLE_WITH_UPPER_UNION_LOWER_MODE_ONLY); + EIGEN_STATIC_ASSERT(internal::check_implication(MatrixWrapper::MatrixFree,UpLo==(Lower|Upper)),MATRIX_FREE_CONJUGATE_GRADIENT_IS_COMPATIBLE_WITH_UPPER_UNION_LOWER_MODE_ONLY); typedef typename internal::conditional<UpLo==(Lower|Upper), RowMajorWrapper, typename MatrixWrapper::template ConstSelfAdjointViewReturnType<UpLo>::Type
diff --git a/Eigen/src/Jacobi/Jacobi.h b/Eigen/src/Jacobi/Jacobi.h index 55a94c2..6a533a0 100644 --- a/Eigen/src/Jacobi/Jacobi.h +++ b/Eigen/src/Jacobi/Jacobi.h
@@ -474,7 +474,7 @@ apply_rotation_in_the_plane_selector< Scalar,OtherScalar, VectorX::SizeAtCompileTime, - EIGEN_PLAIN_ENUM_MIN(evaluator<VectorX>::Alignment, evaluator<VectorY>::Alignment), + plain_enum_min(evaluator<VectorX>::Alignment, evaluator<VectorY>::Alignment), Vectorizable>::run(x,incrx,y,incry,size,c,s); }
diff --git a/Eigen/src/LU/FullPivLU.h b/Eigen/src/LU/FullPivLU.h index 1dd0a4e..fce7c34 100644 --- a/Eigen/src/LU/FullPivLU.h +++ b/Eigen/src/LU/FullPivLU.h
@@ -616,9 +616,9 @@ { EIGEN_MAKE_KERNEL_HELPERS(FullPivLU<MatrixType_>) - enum { MaxSmallDimAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED( - MatrixType::MaxColsAtCompileTime, - MatrixType::MaxRowsAtCompileTime) + enum { MaxSmallDimAtCompileTime = min_size_prefer_fixed( + MatrixType::MaxColsAtCompileTime, + MatrixType::MaxRowsAtCompileTime) }; template<typename Dest> void evalTo(Dest& dst) const @@ -702,9 +702,9 @@ { EIGEN_MAKE_IMAGE_HELPERS(FullPivLU<MatrixType_>) - enum { MaxSmallDimAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED( - MatrixType::MaxColsAtCompileTime, - MatrixType::MaxRowsAtCompileTime) + enum { MaxSmallDimAtCompileTime = min_size_prefer_fixed( + MatrixType::MaxColsAtCompileTime, + MatrixType::MaxRowsAtCompileTime) }; template<typename Dest> void evalTo(Dest& dst) const
diff --git a/Eigen/src/LU/InverseImpl.h b/Eigen/src/LU/InverseImpl.h index 9c1a605..050737b 100644 --- a/Eigen/src/LU/InverseImpl.h +++ b/Eigen/src/LU/InverseImpl.h
@@ -311,7 +311,7 @@ if((dst.rows()!=dstRows) || (dst.cols()!=dstCols)) dst.resize(dstRows, dstCols); - const int Size = EIGEN_PLAIN_ENUM_MIN(XprType::ColsAtCompileTime,DstXprType::ColsAtCompileTime); + const int Size = plain_enum_min(XprType::ColsAtCompileTime, DstXprType::ColsAtCompileTime); EIGEN_ONLY_USED_FOR_DEBUG(Size); eigen_assert(( (Size<=1) || (Size>4) || (extract_data(src.nestedExpression())!=extract_data(dst))) && "Aliasing problem detected in inverse(), you need to do inverse().eval() here.");
diff --git a/Eigen/src/LU/PartialPivLU.h b/Eigen/src/LU/PartialPivLU.h index 4034745..aba4a67 100644 --- a/Eigen/src/LU/PartialPivLU.h +++ b/Eigen/src/LU/PartialPivLU.h
@@ -514,7 +514,7 @@ partial_lu_impl < typename MatrixType::Scalar, MatrixType::Flags&RowMajorBit?RowMajor:ColMajor, typename TranspositionType::StorageIndex, - EIGEN_SIZE_MIN_PREFER_FIXED(MatrixType::RowsAtCompileTime,MatrixType::ColsAtCompileTime)> + internal::min_size_prefer_fixed(MatrixType::RowsAtCompileTime, MatrixType::ColsAtCompileTime)> ::blocked_lu(lu.rows(), lu.cols(), &lu.coeffRef(0,0), lu.outerStride(), &row_transpositions.coeffRef(0), nb_transpositions); }
diff --git a/Eigen/src/LU/PartialPivLU_LAPACKE.h b/Eigen/src/LU/PartialPivLU_LAPACKE.h index 2f244f6..b636442 100644 --- a/Eigen/src/LU/PartialPivLU_LAPACKE.h +++ b/Eigen/src/LU/PartialPivLU_LAPACKE.h
@@ -39,44 +39,55 @@ namespace internal { -/** \internal Specialization for the data types supported by LAPACKe */ +namespace lapacke_helpers { +// ------------------------------------------------------------------------------------------------------------------- +// Generic lapacke partial lu implementation that converts arguments and dispatches to the function above +// ------------------------------------------------------------------------------------------------------------------- -#define EIGEN_LAPACKE_LU_PARTPIV(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX) \ -template<int StorageOrder> \ -struct partial_lu_impl<EIGTYPE, StorageOrder, lapack_int> \ -{ \ - /* \internal performs the LU decomposition in-place of the matrix represented */ \ - static lapack_int blocked_lu(Index rows, Index cols, EIGTYPE* lu_data, Index luStride, lapack_int* row_transpositions, lapack_int& nb_transpositions, lapack_int maxBlockSize=256) \ - { \ - EIGEN_UNUSED_VARIABLE(maxBlockSize);\ - lapack_int matrix_order, first_zero_pivot; \ - lapack_int m, n, lda, *ipiv, info; \ - EIGTYPE* a; \ -/* Set up parameters for ?getrf */ \ - matrix_order = StorageOrder==RowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; \ - lda = convert_index<lapack_int>(luStride); \ - a = lu_data; \ - ipiv = row_transpositions; \ - m = convert_index<lapack_int>(rows); \ - n = convert_index<lapack_int>(cols); \ - nb_transpositions = 0; \ -\ - info = LAPACKE_##LAPACKE_PREFIX##getrf( matrix_order, m, n, (LAPACKE_TYPE*)a, lda, ipiv ); \ -\ - for(int i=0;i<m;i++) { ipiv[i]--; if (ipiv[i]!=i) nb_transpositions++; } \ -\ - eigen_assert(info >= 0); \ -/* something should be done with nb_transpositions */ \ -\ - first_zero_pivot = info; \ - return first_zero_pivot; \ - } \ +template<typename Scalar, int StorageOrder> +struct lapacke_partial_lu { + /** \internal performs the LU decomposition in-place of the matrix represented */ + static lapack_int blocked_lu(Index rows, Index cols, Scalar* lu_data, Index luStride, lapack_int* row_transpositions, + lapack_int& nb_transpositions, lapack_int maxBlockSize=256) + { + EIGEN_UNUSED_VARIABLE(maxBlockSize); + // Set up parameters for getrf + lapack_int matrix_order = StorageOrder==RowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; + lapack_int lda = to_lapack(luStride); + Scalar* a = lu_data; + lapack_int* ipiv = row_transpositions; + lapack_int m = to_lapack(rows); + lapack_int n = to_lapack(cols); + nb_transpositions = 0; + + lapack_int info = getrf(matrix_order, m, n, to_lapack(a), lda, ipiv ); + eigen_assert(info >= 0); + + for(int i=0; i<m; i++) { + ipiv[i]--; + if (ipiv[i] != i) nb_transpositions++; + } + lapack_int first_zero_pivot = info; + return first_zero_pivot; + } }; +} // end namespace lapacke_helpers -EIGEN_LAPACKE_LU_PARTPIV(double, double, d) -EIGEN_LAPACKE_LU_PARTPIV(float, float, s) -EIGEN_LAPACKE_LU_PARTPIV(dcomplex, lapack_complex_double, z) -EIGEN_LAPACKE_LU_PARTPIV(scomplex, lapack_complex_float, c) +/* + * Here, we just put the generic implementation from lapacke_partial_lu into a partial specialization of the partial_lu_impl + * type. This specialization is more specialized than the generic implementations that Eigen implements, so if the + * Scalar type matches they will be chosen. + */ +#define EIGEN_LAPACKE_PARTIAL_LU(EIGTYPE) \ +template<int StorageOrder> \ +struct partial_lu_impl<EIGTYPE, StorageOrder, lapack_int, Dynamic> : public lapacke_helpers::lapacke_partial_lu<EIGTYPE, StorageOrder> {}; + +EIGEN_LAPACKE_PARTIAL_LU(double) +EIGEN_LAPACKE_PARTIAL_LU(float) +EIGEN_LAPACKE_PARTIAL_LU(std::complex<double>) +EIGEN_LAPACKE_PARTIAL_LU(std::complex<float>) + +#undef EIGEN_LAPACKE_PARTIAL_LU } // end namespace internal
diff --git a/Eigen/src/QR/FullPivHouseholderQR.h b/Eigen/src/QR/FullPivHouseholderQR.h index 0a61f22..dcb9e1a 100644 --- a/Eigen/src/QR/FullPivHouseholderQR.h +++ b/Eigen/src/QR/FullPivHouseholderQR.h
@@ -76,8 +76,8 @@ typedef internal::FullPivHouseholderQRMatrixQReturnType<MatrixType> MatrixQReturnType; typedef typename internal::plain_diag_type<MatrixType>::type HCoeffsType; typedef Matrix<StorageIndex, 1, - EIGEN_SIZE_MIN_PREFER_DYNAMIC(ColsAtCompileTime,RowsAtCompileTime), RowMajor, 1, - EIGEN_SIZE_MIN_PREFER_FIXED(MaxColsAtCompileTime,MaxRowsAtCompileTime)> IntDiagSizeVectorType; + internal::min_size_prefer_dynamic(ColsAtCompileTime,RowsAtCompileTime), RowMajor, 1, + internal::min_size_prefer_fixed(MaxColsAtCompileTime, MaxRowsAtCompileTime)> IntDiagSizeVectorType; typedef PermutationMatrix<ColsAtCompileTime, MaxColsAtCompileTime> PermutationType; typedef typename internal::plain_row_type<MatrixType>::type RowVectorType; typedef typename internal::plain_col_type<MatrixType>::type ColVectorType;
diff --git a/Eigen/src/QR/HouseholderQR_LAPACKE.h b/Eigen/src/QR/HouseholderQR_LAPACKE.h index ef67760..57c2f6a 100644 --- a/Eigen/src/QR/HouseholderQR_LAPACKE.h +++ b/Eigen/src/QR/HouseholderQR_LAPACKE.h
@@ -40,28 +40,35 @@ namespace internal { -/** \internal Specialization for the data types supported by LAPACKe */ +namespace lapacke_helpers { -#define EIGEN_LAPACKE_QR_NOPIV(EIGTYPE, LAPACKE_TYPE, LAPACKE_PREFIX) \ -template<typename MatrixQR, typename HCoeffs> \ -struct householder_qr_inplace_blocked<MatrixQR, HCoeffs, EIGTYPE, true> \ -{ \ - static void run(MatrixQR& mat, HCoeffs& hCoeffs, Index = 32, \ - typename MatrixQR::Scalar* = 0) \ - { \ - lapack_int m = (lapack_int) mat.rows(); \ - lapack_int n = (lapack_int) mat.cols(); \ - lapack_int lda = (lapack_int) mat.outerStride(); \ - lapack_int matrix_order = (MatrixQR::IsRowMajor) ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; \ - LAPACKE_##LAPACKE_PREFIX##geqrf( matrix_order, m, n, (LAPACKE_TYPE*)mat.data(), lda, (LAPACKE_TYPE*)hCoeffs.data()); \ - hCoeffs.adjointInPlace(); \ - } \ +template<typename MatrixQR, typename HCoeffs> +struct lapacke_hqr +{ + static void run(MatrixQR& mat, HCoeffs& hCoeffs, Index = 32, typename MatrixQR::Scalar* = 0) + { + lapack_int m = to_lapack(mat.rows()); + lapack_int n = to_lapack(mat.cols()); + lapack_int lda = to_lapack(mat.outerStride()); + lapack_int matrix_order = lapack_storage_of(mat); + geqrf(matrix_order, m, n, to_lapack(mat.data()), lda, to_lapack(hCoeffs.data())); + hCoeffs.adjointInPlace(); + } }; -EIGEN_LAPACKE_QR_NOPIV(double, double, d) -EIGEN_LAPACKE_QR_NOPIV(float, float, s) -EIGEN_LAPACKE_QR_NOPIV(dcomplex, lapack_complex_double, z) -EIGEN_LAPACKE_QR_NOPIV(scomplex, lapack_complex_float, c) +} + +/** \internal Specialization for the data types supported by LAPACKe */ +#define EIGEN_LAPACKE_HH_QR(EIGTYPE) \ +template<typename MatrixQR, typename HCoeffs> \ +struct householder_qr_inplace_blocked<MatrixQR, HCoeffs, EIGTYPE, true> : public lapacke_helpers::lapacke_hqr<MatrixQR, HCoeffs> {}; + +EIGEN_LAPACKE_HH_QR(double) +EIGEN_LAPACKE_HH_QR(float) +EIGEN_LAPACKE_HH_QR(std::complex<double>) +EIGEN_LAPACKE_HH_QR(std::complex<float>) + +#undef EIGEN_LAPACKE_HH_QR } // end namespace internal
diff --git a/Eigen/src/SVD/BDCSVD.h b/Eigen/src/SVD/BDCSVD.h index 8bb30cd..0ad453f 100644 --- a/Eigen/src/SVD/BDCSVD.h +++ b/Eigen/src/SVD/BDCSVD.h
@@ -93,10 +93,10 @@ enum { RowsAtCompileTime = MatrixType::RowsAtCompileTime, ColsAtCompileTime = MatrixType::ColsAtCompileTime, - DiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime, ColsAtCompileTime), + DiagSizeAtCompileTime = internal::min_size_prefer_dynamic(RowsAtCompileTime, ColsAtCompileTime), MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime, MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime, - MaxDiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(MaxRowsAtCompileTime, MaxColsAtCompileTime), + MaxDiagSizeAtCompileTime = internal::min_size_prefer_fixed(MaxRowsAtCompileTime, MaxColsAtCompileTime), MatrixOptions = MatrixType::Options };
diff --git a/Eigen/src/SVD/JacobiSVD.h b/Eigen/src/SVD/JacobiSVD.h index 91c95ec..e69d13a 100644 --- a/Eigen/src/SVD/JacobiSVD.h +++ b/Eigen/src/SVD/JacobiSVD.h
@@ -499,10 +499,10 @@ enum { RowsAtCompileTime = MatrixType::RowsAtCompileTime, ColsAtCompileTime = MatrixType::ColsAtCompileTime, - DiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime,ColsAtCompileTime), + DiagSizeAtCompileTime = internal::min_size_prefer_dynamic(RowsAtCompileTime,ColsAtCompileTime), MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime, MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime, - MaxDiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(MaxRowsAtCompileTime,MaxColsAtCompileTime), + MaxDiagSizeAtCompileTime = internal::min_size_prefer_fixed(MaxRowsAtCompileTime,MaxColsAtCompileTime), MatrixOptions = MatrixType::Options }; @@ -638,7 +638,7 @@ m_computeThinV = (computationOptions & ComputeThinV) != 0; eigen_assert(!(m_computeFullU && m_computeThinU) && "JacobiSVD: you can't ask for both full and thin U"); eigen_assert(!(m_computeFullV && m_computeThinV) && "JacobiSVD: you can't ask for both full and thin V"); - eigen_assert(EIGEN_IMPLIES(m_computeThinU || m_computeThinV, MatrixType::ColsAtCompileTime==Dynamic) && + eigen_assert(internal::check_implication(m_computeThinU || m_computeThinV, MatrixType::ColsAtCompileTime==Dynamic) && "JacobiSVD: thin U and V are only available when your matrix has a dynamic number of columns."); if (QRPreconditioner == FullPivHouseholderQRPreconditioner) {
diff --git a/Eigen/src/SVD/SVDBase.h b/Eigen/src/SVD/SVDBase.h index 7ecaf21..1e58404 100644 --- a/Eigen/src/SVD/SVDBase.h +++ b/Eigen/src/SVD/SVDBase.h
@@ -77,10 +77,10 @@ enum { RowsAtCompileTime = MatrixType::RowsAtCompileTime, ColsAtCompileTime = MatrixType::ColsAtCompileTime, - DiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_DYNAMIC(RowsAtCompileTime,ColsAtCompileTime), + DiagSizeAtCompileTime = internal::min_size_prefer_dynamic(RowsAtCompileTime,ColsAtCompileTime), MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime, MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime, - MaxDiagSizeAtCompileTime = EIGEN_SIZE_MIN_PREFER_FIXED(MaxRowsAtCompileTime,MaxColsAtCompileTime), + MaxDiagSizeAtCompileTime = internal::min_size_prefer_fixed(MaxRowsAtCompileTime,MaxColsAtCompileTime), MatrixOptions = MatrixType::Options }; @@ -355,7 +355,7 @@ m_computeThinV = (computationOptions & ComputeThinV) != 0; eigen_assert(!(m_computeFullU && m_computeThinU) && "SVDBase: you can't ask for both full and thin U"); eigen_assert(!(m_computeFullV && m_computeThinV) && "SVDBase: you can't ask for both full and thin V"); - eigen_assert(EIGEN_IMPLIES(m_computeThinU || m_computeThinV, MatrixType::ColsAtCompileTime==Dynamic) && + eigen_assert(internal::check_implication(m_computeThinU || m_computeThinV, MatrixType::ColsAtCompileTime==Dynamic) && "SVDBase: thin U and V are only available when your matrix has a dynamic number of columns."); m_diagSize = (std::min)(m_rows, m_cols);
diff --git a/Eigen/src/SparseCore/SparseDenseProduct.h b/Eigen/src/SparseCore/SparseDenseProduct.h index 878a759..6f433fc 100644 --- a/Eigen/src/SparseCore/SparseDenseProduct.h +++ b/Eigen/src/SparseCore/SparseDenseProduct.h
@@ -65,10 +65,18 @@ static void processRow(const LhsEval& lhsEval, const DenseRhsType& rhs, DenseResType& res, const typename Res::Scalar& alpha, Index i, Index col) { - typename Res::Scalar tmp(0); - for(LhsInnerIterator it(lhsEval,i); it ;++it) - tmp += it.value() * rhs.coeff(it.index(),col); - res.coeffRef(i,col) += alpha * tmp; + // Two accumulators, which breaks the dependency chain on the accumulator + // and allows more instruction-level parallelism in the following loop + typename Res::Scalar tmp_a(0); + typename Res::Scalar tmp_b(0); + for(LhsInnerIterator it(lhsEval,i); it ;++it) { + tmp_a += it.value() * rhs.coeff(it.index(), col); + ++it; + if(it) { + tmp_b += it.value() * rhs.coeff(it.index(), col); + } + } + res.coeffRef(i, col) += alpha * (tmp_a + tmp_b); } };
diff --git a/Eigen/src/SparseCore/SparseMatrix.h b/Eigen/src/SparseCore/SparseMatrix.h index 9cb5d21..5d31c7d 100644 --- a/Eigen/src/SparseCore/SparseMatrix.h +++ b/Eigen/src/SparseCore/SparseMatrix.h
@@ -288,10 +288,7 @@ #else template<class SizesType> inline void reserve(const SizesType& reserveSizes, const typename SizesType::value_type& enableif = - #if (!EIGEN_COMP_MSVC) || (EIGEN_COMP_MSVC>=1500) // MSVC 2005 fails to compile with this typename - typename - #endif - SizesType::value_type()) + typename SizesType::value_type()) { EIGEN_UNUSED_VARIABLE(enableif); reserveInnerVectors(reserveSizes);
diff --git a/Eigen/src/SparseCore/SparseMatrixBase.h b/Eigen/src/SparseCore/SparseMatrixBase.h index ee5eafc..fd6547f 100644 --- a/Eigen/src/SparseCore/SparseMatrixBase.h +++ b/Eigen/src/SparseCore/SparseMatrixBase.h
@@ -139,8 +139,8 @@ /** type of the equivalent dense matrix */ typedef Matrix<Scalar,RowsAtCompileTime,ColsAtCompileTime> DenseMatrixType; /** type of the equivalent square matrix */ - typedef Matrix<Scalar,EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime), - EIGEN_SIZE_MAX(RowsAtCompileTime,ColsAtCompileTime)> SquareMatrixType; + typedef Matrix<Scalar, internal::max_size_prefer_dynamic(RowsAtCompileTime, ColsAtCompileTime), + internal::max_size_prefer_dynamic(RowsAtCompileTime, ColsAtCompileTime)> SquareMatrixType; inline const Derived& derived() const { return *static_cast<const Derived*>(this); } inline Derived& derived() { return *static_cast<Derived*>(this); }
diff --git a/Eigen/src/SparseCore/SparseUtil.h b/Eigen/src/SparseCore/SparseUtil.h index 19b59d1..33049b9 100644 --- a/Eigen/src/SparseCore/SparseUtil.h +++ b/Eigen/src/SparseCore/SparseUtil.h
@@ -65,10 +65,10 @@ template<typename Lhs, typename Rhs> struct SparseSparseProductReturnType; template<typename Lhs, typename Rhs, - int InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(internal::traits<Lhs>::ColsAtCompileTime,internal::traits<Rhs>::RowsAtCompileTime)> struct DenseSparseProductReturnType; + int InnerSize = internal::min_size_prefer_fixed(internal::traits<Lhs>::ColsAtCompileTime, internal::traits<Rhs>::RowsAtCompileTime)> struct DenseSparseProductReturnType; template<typename Lhs, typename Rhs, - int InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(internal::traits<Lhs>::ColsAtCompileTime,internal::traits<Rhs>::RowsAtCompileTime)> struct SparseDenseProductReturnType; + int InnerSize = internal::min_size_prefer_fixed(internal::traits<Lhs>::ColsAtCompileTime, internal::traits<Rhs>::RowsAtCompileTime)> struct SparseDenseProductReturnType; template<typename MatrixType,int UpLo> class SparseSymmetricPermutationProduct; namespace internal {
diff --git a/Eigen/src/misc/lapacke_helpers.h b/Eigen/src/misc/lapacke_helpers.h new file mode 100644 index 0000000..6fff863 --- /dev/null +++ b/Eigen/src/misc/lapacke_helpers.h
@@ -0,0 +1,159 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2021 Erik Schultheis <erik.schultheis@aalto.fi> +// +// 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_LAPACKE_HELPERS_H +#define EIGEN_LAPACKE_HELPERS_H + +#include "./InternalHeaderCheck.h" + +#ifdef EIGEN_USE_MKL +#include "mkl_lapacke.h" +#else +#include "lapacke.h" +#endif + +namespace Eigen { +namespace internal { +/** + * \internal + * \brief Implementation details and helper functions for the lapacke glue code. + */ +namespace lapacke_helpers { + +// --------------------------------------------------------------------------------------------------------------------- +// Translation from Eigen to Lapacke for types and constants +// --------------------------------------------------------------------------------------------------------------------- + +// For complex numbers, the types in Eigen and Lapacke are different, but layout compatible. +template<typename Scalar> +struct translate_type_imp; +template<> +struct translate_type_imp<float> { + using type = float; +}; +template<> +struct translate_type_imp<double> { + using type = double; +}; +template<> +struct translate_type_imp<std::complex<double>> { + using type = lapack_complex_double; +}; +template<> +struct translate_type_imp<std::complex<float>> { + using type = lapack_complex_float; +}; + +/// Given an Eigen types, this is defined to be the corresponding, layout-compatible lapack type +template<typename Scalar> +using translated_type = typename translate_type_imp<Scalar>::type; + +/// These functions convert their arguments from Eigen to Lapack types +/// This function performs conversion for any of the translations defined above. +template<typename Source, typename Target=translated_type<Source>> +auto to_lapack(Source value) { return static_cast<Target>(value); } + +/// This function performs conversions for pointer types corresponding to the translations abovce. +/// This is valid because the translations are between layout-compatible types. +template<typename Source, typename Target=translated_type<Source>> +auto to_lapack(Source *value) { return reinterpret_cast<Target*>(value); } + +/// This function converts the Eigen Index to a lapack index, with possible range checks +/// \sa internal::convert_index +lapack_int to_lapack(Index index) { + return convert_index<lapack_int>(index); +} + +/// translates storage order of the given Eigen object to the corresponding lapack constant +template<typename Derived> +EIGEN_CONSTEXPR lapack_int lapack_storage_of(const EigenBase<Derived> &) { + return Derived::IsRowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; +} + +/// translate UpLo type to the corresponding letter code +template<UpLoType mode> char translate_mode; +template<> EIGEN_CONSTEXPR const char translate_mode<Lower> = 'L'; +template<> EIGEN_CONSTEXPR const char translate_mode<Upper> = 'U'; + + +// --------------------------------------------------------------------------------------------------------------------- +// Automatic generation of low-level wrappers +// --------------------------------------------------------------------------------------------------------------------- + +/*! + * \internal + * \brief Helper type to facilitate the wrapping of raw LAPACKE functions for different types into a single, overloaded C++ function. + * This is achieved in combination with \r EIGEN_MAKE_LAPACKE_WRAPPER + * \details This implementation works by providing an overloaded call function that just forwards its arguments to the + * underlying lapack function. Each of these overloads is enabled only if the call is actually well formed. + * Because these lapack functions take pointers to the underlying scalar type as arguments, even though the actual Scalars + * would be implicitly convertible, the pointers are not and therefore only a single overload can be valid at the same time. + * Thus, despite all functions taking fully generic `Args&&... args` as arguments, there is never any ambiguity. + */ +template<typename DoubleFn, typename SingleFn, typename DoubleCpxFn, typename SingleCpxFn> +struct WrappingHelper { + // The naming of double, single, double complex and single complex is purely for readability + // and doesn't actually affect the workings of this class. In principle, the arguments can + // be supplied in any permuted order. + DoubleFn double_; SingleFn single_; DoubleCpxFn double_cpx_; SingleCpxFn single_cpx_; + + template<typename... Args> + auto call(Args&&... args) -> decltype(double_(std::forward<Args>(args)...)) { + return double_(std::forward<Args>(args)...); + } + + template<typename... Args> + auto call(Args&&... args) -> decltype(single_(std::forward<Args>(args)...)){ + return single_(std::forward<Args>(args)...); + } + + template<typename... Args> + auto call(Args&&... args) -> decltype(double_cpx_(std::forward<Args>(args)...)){ + return double_cpx_(std::forward<Args>(args)...); + } + + template<typename... Args> + auto call(Args&&... args) -> decltype(single_cpx_(std::forward<Args>(args)...)){ + return single_cpx_(std::forward<Args>(args)...); + } +}; + +/** \internal Helper function that generates a `WrappingHelper` object with the given function pointers and + * invokes its `call` method, thus selecting one of the overloads. + * \sa EIGEN_MAKE_LAPACKE_WRAPPER + */ +template<typename DoubleFn, typename SingleFn, typename DoubleCpxFn, typename SingleCpxFn, typename... Args> +auto call_wrapper(DoubleFn df, SingleFn sf, DoubleCpxFn dcf, SingleCpxFn scf, Args&&... args) { + WrappingHelper<DoubleFn, SingleFn, DoubleCpxFn, SingleCpxFn> helper{df, sf, dcf, scf}; + return helper.call(std::forward<Args>(args)...); +} + +/** + * \internal + * Generates a new function `Function` that dispatches to the corresponding LAPACKE_? prefixed functions. + * \sa WrappingHelper + */ +#define EIGEN_MAKE_LAPACKE_WRAPPER(FUNCTION) \ +template<typename... Args> \ +auto FUNCTION(Args&&... args) { return call_wrapper(LAPACKE_d##FUNCTION, LAPACKE_s##FUNCTION, LAPACKE_z##FUNCTION, LAPACKE_c##FUNCTION, std::forward<Args>(args)...); } + +// Now with this macro and the helper wrappers, we can generate the dispatch for all the lapacke functions that are +// used in Eigen. +// We define these here instead of in the files where they are used because this allows us to #undef the macro again +// right here +EIGEN_MAKE_LAPACKE_WRAPPER(potrf) +EIGEN_MAKE_LAPACKE_WRAPPER(getrf) +EIGEN_MAKE_LAPACKE_WRAPPER(geqrf) + +#undef EIGEN_MAKE_LAPACKE_WRAPPER +} +} +} + +#endif // EIGEN_LAPACKE_HELPERS_H \ No newline at end of file
diff --git a/Eigen/src/plugins/IndexedViewMethods.h b/Eigen/src/plugins/IndexedViewMethods.h index 463602a..8acd87e 100644 --- a/Eigen/src/plugins/IndexedViewMethods.h +++ b/Eigen/src/plugins/IndexedViewMethods.h
@@ -105,8 +105,6 @@ return Base::operator()(internal::eval_expr_given_size(rowIndices,rows()),internal::eval_expr_given_size(colIndices,cols())); } -#if EIGEN_HAS_STATIC_ARRAY_TEMPLATE - // The following three overloads are needed to handle raw Index[N] arrays. template<typename RowIndicesT, std::size_t RowIndicesN, typename ColIndices> @@ -133,7 +131,6 @@ (derived(), rowIndices, colIndices); } -#endif // EIGEN_HAS_STATIC_ARRAY_TEMPLATE // Overloads for 1D vectors/arrays @@ -178,8 +175,6 @@ return Base::operator()(internal::eval_expr_given_size(id,size())); } -#if EIGEN_HAS_STATIC_ARRAY_TEMPLATE - template<typename IndicesT, std::size_t IndicesN> typename internal::enable_if<IsRowMajor, IndexedView<EIGEN_INDEXED_VIEW_METHOD_CONST Derived,IvcIndex,const IndicesT (&)[IndicesN]> >::type @@ -200,8 +195,6 @@ (derived(), indices, IvcIndex(0)); } -#endif // EIGEN_HAS_STATIC_ARRAY_TEMPLATE - #undef EIGEN_INDEXED_VIEW_METHOD_CONST #undef EIGEN_INDEXED_VIEW_METHOD_TYPE
diff --git a/blas/PackedTriangularMatrixVector.h b/blas/PackedTriangularMatrixVector.h index 0039536..cc2a9b8 100644 --- a/blas/PackedTriangularMatrixVector.h +++ b/blas/PackedTriangularMatrixVector.h
@@ -31,15 +31,16 @@ typedef typename conj_expr_if<ConjLhs,LhsMap>::type ConjLhsType; typedef Map<Matrix<ResScalar,Dynamic,1> > ResMap; - for (Index i=0; i<size; ++i) - { - Index s = IsLower&&(HasUnitDiag||HasZeroDiag) ? 1 : 0; - Index r = IsLower ? size-i: i+1; - if (EIGEN_IMPLIES(HasUnitDiag||HasZeroDiag, (--r)>0)) - ResMap(res+(IsLower ? s+i : 0),r) += alpha * cj(rhs[i]) * ConjLhsType(LhsMap(lhs+s,r)); - if (HasUnitDiag) - res[i] += alpha * cj(rhs[i]); - lhs += IsLower ? size-i: i+1; + for (Index i = 0; i < size; ++i) { + Index s = IsLower && (HasUnitDiag || HasZeroDiag) ? 1 : 0; + Index r = IsLower ? size - i : i + 1; + if (!(HasUnitDiag || HasZeroDiag) || (--r > 0)) { + ResMap(res + (IsLower ? s + i : 0), r) += alpha * cj(rhs[i]) * ConjLhsType(LhsMap(lhs + s, r)); + } + if (HasUnitDiag) { + res[i] += alpha * cj(rhs[i]); + } + lhs += IsLower ? size - i : i + 1; } }; }; @@ -61,15 +62,16 @@ typedef Map<const Matrix<RhsScalar,Dynamic,1> > RhsMap; typedef typename conj_expr_if<ConjRhs,RhsMap>::type ConjRhsType; - for (Index i=0; i<size; ++i) - { - Index s = !IsLower&&(HasUnitDiag||HasZeroDiag) ? 1 : 0; - Index r = IsLower ? i+1 : size-i; - if (EIGEN_IMPLIES(HasUnitDiag||HasZeroDiag, (--r)>0)) - res[i] += alpha * (ConjLhsType(LhsMap(lhs+s,r)).cwiseProduct(ConjRhsType(RhsMap(rhs+(IsLower ? 0 : s+i),r)))).sum(); - if (HasUnitDiag) - res[i] += alpha * cj(rhs[i]); - lhs += IsLower ? i+1 : size-i; + for (Index i = 0; i < size; ++i) { + Index s = !IsLower && (HasUnitDiag || HasZeroDiag) ? 1 : 0; + Index r = IsLower ? i + 1 : size - i; + if (!(HasUnitDiag || HasZeroDiag) || (--r > 0)) { + res[i] += alpha * (ConjLhsType(LhsMap(lhs + s, r)).cwiseProduct(ConjRhsType(RhsMap(rhs + (IsLower ? 0 : s + i), r)))).sum(); + } + if (HasUnitDiag) { + res[i] += alpha * cj(rhs[i]); + } + lhs += IsLower ? i + 1 : size - i; } }; };
diff --git a/cmake/EigenTesting.cmake b/cmake/EigenTesting.cmake index 3fce0f5..3581941 100644 --- a/cmake/EigenTesting.cmake +++ b/cmake/EigenTesting.cmake
@@ -28,7 +28,9 @@ set(is_gpu_test ON) if(EIGEN_TEST_HIP) hip_reset_flags() - hip_add_executable(${targetname} ${filename} HIPCC_OPTIONS "-DEIGEN_USE_HIP ${ARGV2}") + hip_add_executable(${targetname} ${filename} HIPCC_OPTIONS -std=c++14) + target_compile_definitions(${targetname} PRIVATE -DEIGEN_USE_HIP) + set_property(TARGET ${targetname} PROPERTY HIP_ARCHITECTURES gfx900 gfx906 gfx908 gfx90a gfx1030) elseif(EIGEN_TEST_CUDA_CLANG) set_source_files_properties(${filename} PROPERTIES LANGUAGE CXX) @@ -38,22 +40,14 @@ link_directories("${CUDA_TOOLKIT_ROOT_DIR}/lib") endif() - if (${ARGC} GREATER 2) - add_executable(${targetname} ${filename}) - else() - add_executable(${targetname} ${filename} OPTIONS ${ARGV2}) - endif() + add_executable(${targetname} ${filename}) set(CUDA_CLANG_LINK_LIBRARIES "cudart_static" "cuda" "dl" "pthread") if (CMAKE_SYSTEM_NAME STREQUAL "Linux") set(CUDA_CLANG_LINK_LIBRARIES ${CUDA_CLANG_LINK_LIBRARIES} "rt") endif() target_link_libraries(${targetname} ${CUDA_CLANG_LINK_LIBRARIES}) else() - if (${ARGC} GREATER 2) - cuda_add_executable(${targetname} ${filename} OPTIONS ${ARGV2}) - else() - cuda_add_executable(${targetname} ${filename}) - endif() + cuda_add_executable(${targetname} ${filename}) endif() else() add_executable(${targetname} ${filename}) @@ -66,26 +60,26 @@ endif() if(EIGEN_NO_ASSERTION_CHECKING) - ei_add_target_property(${targetname} COMPILE_FLAGS "-DEIGEN_NO_ASSERTION_CHECKING=1") + target_compile_definitions(${targetname} PRIVATE EIGEN_NO_ASSERTION_CHECKING=1) else() if(EIGEN_DEBUG_ASSERTS) - ei_add_target_property(${targetname} COMPILE_FLAGS "-DEIGEN_DEBUG_ASSERTS=1") + target_compile_definitions(${targetname} PRIVATE EIGEN_DEBUG_ASSERTS=1) endif() endif() - ei_add_target_property(${targetname} COMPILE_FLAGS "-DEIGEN_TEST_MAX_SIZE=${EIGEN_TEST_MAX_SIZE}") + target_compile_definitions(${targetname} PRIVATE EIGEN_TEST_MAX_SIZE=${EIGEN_TEST_MAX_SIZE}) if(MSVC) - ei_add_target_property(${targetname} COMPILE_FLAGS "/bigobj") + target_compile_options(${targetname} PRIVATE "/bigobj") endif() # let the user pass flags. if(${ARGC} GREATER 2) - ei_add_target_property(${targetname} COMPILE_FLAGS "${ARGV2}") + target_compile_options(${targetname} PRIVATE ${ARGV2}) endif() if(EIGEN_TEST_CUSTOM_CXX_FLAGS) - ei_add_target_property(${targetname} COMPILE_FLAGS "${EIGEN_TEST_CUSTOM_CXX_FLAGS}") + target_compile_options(${targetname} PRIVATE ${EIGEN_TEST_CUSTOM_CXX_FLAGS}) endif() if(EIGEN_STANDARD_LIBRARIES_TO_LINK_TO) @@ -216,12 +210,13 @@ if( (EIGEN_SPLIT_LARGE_TESTS AND suffixes) OR explicit_suffixes) add_custom_target(${testname}) foreach(suffix ${suffixes}) - ei_add_test_internal(${testname} ${testname}_${suffix} - "${ARGV1} -DEIGEN_TEST_PART_${suffix}=1" "${ARGV2}") + ei_add_test_internal(${testname} ${testname}_${suffix} "${ARGV1}" "${ARGV2}") add_dependencies(${testname} ${testname}_${suffix}) + target_compile_definitions(${testname}_${suffix} PRIVATE -DEIGEN_TEST_PART_${suffix}=1) endforeach() else() - ei_add_test_internal(${testname} ${testname} "${ARGV1} -DEIGEN_TEST_PART_ALL=1" "${ARGV2}") + ei_add_test_internal(${testname} ${testname} "${ARGV1}" "${ARGV2}") + target_compile_definitions(${testname} PRIVATE -DEIGEN_TEST_PART_ALL=1) endif() endmacro()
diff --git a/cmake/FindBLAS.cmake b/cmake/FindBLAS.cmake deleted file mode 100644 index 1bb8f19..0000000 --- a/cmake/FindBLAS.cmake +++ /dev/null
@@ -1,1407 +0,0 @@ -### -# -# @copyright (c) 2009-2014 The University of Tennessee and The University -# of Tennessee Research Foundation. -# All rights reserved. -# @copyright (c) 2012-2016 Inria. All rights reserved. -# @copyright (c) 2012-2014 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria, Univ. Bordeaux. All rights reserved. -# -### -# -# - Find BLAS library -# This module finds an installed fortran library that implements the BLAS -# linear-algebra interface (see http://www.netlib.org/blas/). -# The list of libraries searched for is taken -# from the autoconf macro file, acx_blas.m4 (distributed at -# http://ac-archive.sourceforge.net/ac-archive/acx_blas.html). -# -# This module sets the following variables: -# BLAS_FOUND - set to true if a library implementing the BLAS interface -# is found -# BLAS_LINKER_FLAGS - uncached list of required linker flags (excluding -l -# and -L). -# BLAS_COMPILER_FLAGS - uncached list of required compiler flags (including -I for mkl headers). -# BLAS_LIBRARIES - uncached list of libraries (using full path name) to -# link against to use BLAS -# BLAS95_LIBRARIES - uncached list of libraries (using full path name) -# to link against to use BLAS95 interface -# BLAS95_FOUND - set to true if a library implementing the BLAS f95 interface -# is found -# BLA_STATIC if set on this determines what kind of linkage we do (static) -# BLA_VENDOR if set checks only the specified vendor, if not set checks -# all the possibilities -# BLAS_VENDOR_FOUND stores the BLAS vendor found -# BLA_F95 if set on tries to find the f95 interfaces for BLAS/LAPACK -# The user can give specific paths where to find the libraries adding cmake -# options at configure (ex: cmake path/to/project -DBLAS_DIR=path/to/blas): -# BLAS_DIR - Where to find the base directory of blas -# BLAS_INCDIR - Where to find the header files -# BLAS_LIBDIR - Where to find the library files -# The module can also look for the following environment variables if paths -# are not given as cmake variable: BLAS_DIR, BLAS_INCDIR, BLAS_LIBDIR -# For MKL case and if no paths are given as hints, we will try to use the MKLROOT -# environment variable -# BLAS_VERBOSE Print some additional information during BLAS libraries detection -########## -### List of vendors (BLA_VENDOR) valid in this module -########## List of vendors (BLA_VENDOR) valid in this module -## Open (for OpenBlas), Eigen (for EigenBlas), Goto, ATLAS PhiPACK, -## CXML, DXML, SunPerf, SCSL, SGIMATH, IBMESSL, IBMESSLMT -## Intel10_32 (intel mkl v10 32 bit), Intel10_64lp (intel mkl v10 64 bit,lp thread model, lp64 model), -## Intel10_64lp_seq (intel mkl v10 64 bit,sequential code, lp64 model), -## Intel( older versions of mkl 32 and 64 bit), -## ACML, ACML_MP, ACML_GPU, Apple, NAS, Generic -# C/CXX should be enabled to use Intel mkl -### -# We handle different modes to find the dependency -# -# - Detection if already installed on the system -# - BLAS libraries can be detected from different ways -# Here is the order of precedence: -# 1) we look in cmake variable BLAS_LIBDIR or BLAS_DIR (we guess the libdirs) if defined -# 2) we look in environment variable BLAS_LIBDIR or BLAS_DIR (we guess the libdirs) if defined -# 3) we look in common environnment variables depending on the system (INCLUDE, C_INCLUDE_PATH, CPATH - LIB, DYLD_LIBRARY_PATH, LD_LIBRARY_PATH) -# 4) we look in common system paths depending on the system, see for example paths contained in the following cmake variables: -# - CMAKE_PLATFORM_IMPLICIT_INCLUDE_DIRECTORIES, CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES -# - CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES, CMAKE_C_IMPLICIT_LINK_DIRECTORIES -# - -#============================================================================= -# Copyright 2007-2009 Kitware, Inc. -# -# Distributed under the OSI-approved BSD License (the "License"); -# see accompanying file Copyright.txt for details. -# -# This software is distributed WITHOUT ANY WARRANTY; without even the -# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -# See the License for more information. -#============================================================================= -# (To distribute this file outside of CMake, substitute the full -# License text for the above reference.) - -## Some macros to print status when search for headers and libs -# This macro informs why the _lib_to_find file has not been found -macro(Print_Find_Library_Blas_Status _libname _lib_to_find) - - # save _libname upper/lower case - string(TOUPPER ${_libname} LIBNAME) - string(TOLOWER ${_libname} libname) - - # print status - #message(" ") - if(${LIBNAME}_LIBDIR) - message("${Yellow}${LIBNAME}_LIBDIR is defined but ${_lib_to_find}" - "has not been found in ${ARGN}${ColourReset}") - else() - if(${LIBNAME}_DIR) - message("${Yellow}${LIBNAME}_DIR is defined but ${_lib_to_find}" - "has not been found in ${ARGN}${ColourReset}") - else() - message("${Yellow}${_lib_to_find} not found." - "Nor ${LIBNAME}_DIR neither ${LIBNAME}_LIBDIR" - "are defined so that we look for ${_lib_to_find} in" - "system paths (Linux: LD_LIBRARY_PATH, Windows: LIB," - "Mac: DYLD_LIBRARY_PATH," - "CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES," - "CMAKE_C_IMPLICIT_LINK_DIRECTORIES)${ColourReset}") - if(_lib_env) - message("${Yellow}${_lib_to_find} has not been found in" - "${_lib_env}${ColourReset}") - endif() - endif() - endif() - message("${BoldYellow}Please indicate where to find ${_lib_to_find}. You have three options:\n" - "- Option 1: Provide the Installation directory of BLAS library with cmake option: -D${LIBNAME}_DIR=your/path/to/${libname}/\n" - "- Option 2: Provide the directory where to find the library with cmake option: -D${LIBNAME}_LIBDIR=your/path/to/${libname}/lib/\n" - "- Option 3: Update your environment variable (Linux: LD_LIBRARY_PATH, Windows: LIB, Mac: DYLD_LIBRARY_PATH)\n" - "- Option 4: If your library provides a PkgConfig file, make sure pkg-config finds your library${ColourReset}") - -endmacro() - -# This macro informs why the _lib_to_find file has not been found -macro(Print_Find_Library_Blas_CheckFunc_Status _name) - - # save _libname upper/lower case - string(TOUPPER ${_name} FUNCNAME) - string(TOLOWER ${_name} funcname) - - # print status - #message(" ") - message("${Red}Libs have been found but check of symbol ${_name} failed " - "with following libraries ${ARGN}${ColourReset}") - message("${BoldRed}Please open your error file CMakeFiles/CMakeError.log" - "to figure out why it fails${ColourReset}") - #message(" ") - -endmacro() - -if (NOT BLAS_FOUND) - set(BLAS_DIR "" CACHE PATH "Installation directory of BLAS library") - if (NOT BLAS_FIND_QUIETLY) - message(STATUS "A cache variable, namely BLAS_DIR, has been set to specify the install directory of BLAS") - endif() -endif() - -option(BLAS_VERBOSE "Print some additional information during BLAS libraries detection" OFF) -mark_as_advanced(BLAS_VERBOSE) - -include(CheckFunctionExists) -include(CheckFortranFunctionExists) -include(CMakeFindDependencyMacro) - -set(_blas_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES}) - -# Check the language being used -get_property( _LANGUAGES_ GLOBAL PROPERTY ENABLED_LANGUAGES ) -if( _LANGUAGES_ MATCHES Fortran AND CMAKE_Fortran_COMPILER) - set( _CHECK_FORTRAN TRUE ) -elseif( (_LANGUAGES_ MATCHES C) OR (_LANGUAGES_ MATCHES CXX) ) - set( _CHECK_FORTRAN FALSE ) -else() - if(BLAS_FIND_REQUIRED) - message(FATAL_ERROR "FindBLAS requires Fortran, C, or C++ to be enabled.") - else() - message(STATUS "Looking for BLAS... - NOT found (Unsupported languages)") - return() - endif() -endif() - -macro(Check_Fortran_Libraries LIBRARIES _prefix _name _flags _list _thread) - # This macro checks for the existence of the combination of fortran libraries - # given by _list. If the combination is found, this macro checks (using the - # Check_Fortran_Function_Exists macro) whether can link against that library - # combination using the name of a routine given by _name using the linker - # flags given by _flags. If the combination of libraries is found and passes - # the link test, LIBRARIES is set to the list of complete library paths that - # have been found. Otherwise, LIBRARIES is set to FALSE. - - # N.B. _prefix is the prefix applied to the names of all cached variables that - # are generated internally and marked advanced by this macro. - - set(_libdir ${ARGN}) - - set(_libraries_work TRUE) - set(${LIBRARIES}) - set(_combined_name) - set(ENV_MKLROOT "$ENV{MKLROOT}") - set(ENV_BLAS_DIR "$ENV{BLAS_DIR}") - set(ENV_BLAS_LIBDIR "$ENV{BLAS_LIBDIR}") - if (NOT _libdir) - if (BLAS_LIBDIR) - list(APPEND _libdir "${BLAS_LIBDIR}") - elseif (BLAS_DIR) - list(APPEND _libdir "${BLAS_DIR}") - list(APPEND _libdir "${BLAS_DIR}/lib") - if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8") - list(APPEND _libdir "${BLAS_DIR}/lib64") - list(APPEND _libdir "${BLAS_DIR}/lib/intel64") - else() - list(APPEND _libdir "${BLAS_DIR}/lib32") - list(APPEND _libdir "${BLAS_DIR}/lib/ia32") - endif() - elseif(ENV_BLAS_LIBDIR) - list(APPEND _libdir "${ENV_BLAS_LIBDIR}") - elseif(ENV_BLAS_DIR) - list(APPEND _libdir "${ENV_BLAS_DIR}") - list(APPEND _libdir "${ENV_BLAS_DIR}/lib") - if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8") - list(APPEND _libdir "${ENV_BLAS_DIR}/lib64") - list(APPEND _libdir "${ENV_BLAS_DIR}/lib/intel64") - else() - list(APPEND _libdir "${ENV_BLAS_DIR}/lib32") - list(APPEND _libdir "${ENV_BLAS_DIR}/lib/ia32") - endif() - else() - if (ENV_MKLROOT) - list(APPEND _libdir "${ENV_MKLROOT}/lib") - if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8") - list(APPEND _libdir "${ENV_MKLROOT}/lib64") - list(APPEND _libdir "${ENV_MKLROOT}/lib/intel64") - else() - list(APPEND _libdir "${ENV_MKLROOT}/lib32") - list(APPEND _libdir "${ENV_MKLROOT}/lib/ia32") - endif() - endif() - if (WIN32) - string(REPLACE ":" ";" _libdir2 "$ENV{LIB}") - elseif (APPLE) - string(REPLACE ":" ";" _libdir2 "$ENV{DYLD_LIBRARY_PATH}") - else () - string(REPLACE ":" ";" _libdir2 "$ENV{LD_LIBRARY_PATH}") - endif () - list(APPEND _libdir "${_libdir2}") - list(APPEND _libdir "${CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES}") - list(APPEND _libdir "${CMAKE_C_IMPLICIT_LINK_DIRECTORIES}") - endif() - endif () - - if (BLAS_VERBOSE) - message("${Cyan}Try to find BLAS libraries: ${_list}") - endif () - - foreach(_library ${_list}) - set(_combined_name ${_combined_name}_${_library}) - - if(_libraries_work) - if (BLA_STATIC) - if (WIN32) - set(CMAKE_FIND_LIBRARY_SUFFIXES .lib ${CMAKE_FIND_LIBRARY_SUFFIXES}) - endif () - if (APPLE) - set(CMAKE_FIND_LIBRARY_SUFFIXES .lib ${CMAKE_FIND_LIBRARY_SUFFIXES}) - else () - set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES}) - endif () - else () - if (CMAKE_SYSTEM_NAME STREQUAL "Linux") - # for ubuntu's libblas3gf and liblapack3gf packages - set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES} .so.3gf) - endif () - endif () - find_library(${_prefix}_${_library}_LIBRARY - NAMES ${_library} - HINTS ${_libdir} - NO_DEFAULT_PATH - ) - mark_as_advanced(${_prefix}_${_library}_LIBRARY) - # Print status if not found - # ------------------------- - if (NOT ${_prefix}_${_library}_LIBRARY AND NOT BLAS_FIND_QUIETLY AND BLAS_VERBOSE) - Print_Find_Library_Blas_Status(blas ${_library} ${_libdir}) - endif () - set(${LIBRARIES} ${${LIBRARIES}} ${${_prefix}_${_library}_LIBRARY}) - set(_libraries_work ${${_prefix}_${_library}_LIBRARY}) - endif() - endforeach() - - if(_libraries_work) - # Test this combination of libraries. - if (CMAKE_SYSTEM_NAME STREQUAL "Linux" AND BLA_STATIC) - list(INSERT ${LIBRARIES} 0 "-Wl,--start-group") - list(APPEND ${LIBRARIES} "-Wl,--end-group") - endif() - set(CMAKE_REQUIRED_LIBRARIES "${_flags};${${LIBRARIES}};${_thread}") - set(CMAKE_REQUIRED_FLAGS "${BLAS_COMPILER_FLAGS}") - if (BLAS_VERBOSE) - message("${Cyan}BLAS libs found for BLA_VENDOR ${BLA_VENDOR}." - "Try to compile symbol ${_name} with following libraries:" - "${CMAKE_REQUIRED_LIBRARIES}") - endif () - if(NOT BLAS_FOUND) - unset(${_prefix}${_combined_name}_WORKS CACHE) - endif() - if (_CHECK_FORTRAN) - if (CMAKE_Fortran_COMPILER_ID STREQUAL "GNU") - string(REPLACE "mkl_intel_lp64" "mkl_gf_lp64" CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES}") - string(REPLACE "mkl_intel_ilp64" "mkl_gf_ilp64" CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES}") - endif() - check_fortran_function_exists("${_name}" ${_prefix}${_combined_name}_WORKS) - else() - check_function_exists("${_name}_" ${_prefix}${_combined_name}_WORKS) - endif() - mark_as_advanced(${_prefix}${_combined_name}_WORKS) - set(_libraries_work ${${_prefix}${_combined_name}_WORKS}) - # Print status if not found - # ------------------------- - if (NOT _libraries_work AND NOT BLAS_FIND_QUIETLY AND BLAS_VERBOSE) - Print_Find_Library_Blas_CheckFunc_Status(${_name} ${CMAKE_REQUIRED_LIBRARIES}) - endif () - set(CMAKE_REQUIRED_LIBRARIES) - endif() - - if(_libraries_work) - set(${LIBRARIES} ${${LIBRARIES}} ${_thread}) - else() - set(${LIBRARIES} FALSE) - endif() - -endmacro() - - -set(BLAS_LINKER_FLAGS) -set(BLAS_LIBRARIES) -set(BLAS95_LIBRARIES) -if ($ENV{BLA_VENDOR} MATCHES ".+") - set(BLA_VENDOR $ENV{BLA_VENDOR}) -else () - if(NOT BLA_VENDOR) - set(BLA_VENDOR "All") - endif() -endif () - -#BLAS in intel mkl 10 library? (em64t 64bit) -if (BLA_VENDOR MATCHES "Intel*" OR BLA_VENDOR STREQUAL "All") - - if(NOT BLAS_LIBRARIES OR BLA_VENDOR MATCHES "Intel*") - # Looking for include - # ------------------- - - # Add system include paths to search include - # ------------------------------------------ - unset(_inc_env) - set(ENV_MKLROOT "$ENV{MKLROOT}") - set(ENV_BLAS_DIR "$ENV{BLAS_DIR}") - set(ENV_BLAS_INCDIR "$ENV{BLAS_INCDIR}") - if(ENV_BLAS_INCDIR) - list(APPEND _inc_env "${ENV_BLAS_INCDIR}") - elseif(ENV_BLAS_DIR) - list(APPEND _inc_env "${ENV_BLAS_DIR}") - list(APPEND _inc_env "${ENV_BLAS_DIR}/include") - else() - if (ENV_MKLROOT) - list(APPEND _inc_env "${ENV_MKLROOT}/include") - endif() - # system variables - if(WIN32) - string(REPLACE ":" ";" _path_env "$ENV{INCLUDE}") - list(APPEND _inc_env "${_path_env}") - else() - string(REPLACE ":" ";" _path_env "$ENV{INCLUDE}") - list(APPEND _inc_env "${_path_env}") - string(REPLACE ":" ";" _path_env "$ENV{C_INCLUDE_PATH}") - list(APPEND _inc_env "${_path_env}") - string(REPLACE ":" ";" _path_env "$ENV{CPATH}") - list(APPEND _inc_env "${_path_env}") - string(REPLACE ":" ";" _path_env "$ENV{INCLUDE_PATH}") - list(APPEND _inc_env "${_path_env}") - endif() - endif() - list(APPEND _inc_env "${CMAKE_PLATFORM_IMPLICIT_INCLUDE_DIRECTORIES}") - list(APPEND _inc_env "${CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES}") - list(REMOVE_DUPLICATES _inc_env) - - # set paths where to look for - set(PATH_TO_LOOK_FOR "${_inc_env}") - - # Try to find the fftw header in the given paths - # ------------------------------------------------- - # call cmake macro to find the header path - if(BLAS_INCDIR) - set(BLAS_mkl.h_DIRS "BLAS_mkl.h_DIRS-NOTFOUND") - find_path(BLAS_mkl.h_DIRS - NAMES mkl.h - HINTS ${BLAS_INCDIR}) - else() - if(BLAS_DIR) - set(BLAS_mkl.h_DIRS "BLAS_mkl.h_DIRS-NOTFOUND") - find_path(BLAS_mkl.h_DIRS - NAMES mkl.h - HINTS ${BLAS_DIR} - PATH_SUFFIXES "include") - else() - set(BLAS_mkl.h_DIRS "BLAS_mkl.h_DIRS-NOTFOUND") - find_path(BLAS_mkl.h_DIRS - NAMES mkl.h - HINTS ${PATH_TO_LOOK_FOR}) - endif() - endif() - mark_as_advanced(BLAS_mkl.h_DIRS) - - # If found, add path to cmake variable - # ------------------------------------ - if (BLAS_mkl.h_DIRS) - set(BLAS_INCLUDE_DIRS "${BLAS_mkl.h_DIRS}") - else () - set(BLAS_INCLUDE_DIRS "BLAS_INCLUDE_DIRS-NOTFOUND") - if(NOT BLAS_FIND_QUIETLY) - message(STATUS "Looking for BLAS -- mkl.h not found") - endif() - endif() - - if (WIN32) - string(REPLACE ":" ";" _libdir "$ENV{LIB}") - elseif (APPLE) - string(REPLACE ":" ";" _libdir "$ENV{DYLD_LIBRARY_PATH}") - else () - string(REPLACE ":" ";" _libdir "$ENV{LD_LIBRARY_PATH}") - endif () - list(APPEND _libdir "${CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES}") - list(APPEND _libdir "${CMAKE_C_IMPLICIT_LINK_DIRECTORIES}") - # libiomp5 - # -------- - set(OMP_iomp5_LIBRARY "OMP_iomp5_LIBRARY-NOTFOUND") - find_library(OMP_iomp5_LIBRARY - NAMES iomp5 - HINTS ${_libdir} - ) - mark_as_advanced(OMP_iomp5_LIBRARY) - set(OMP_LIB "") - # libgomp - # ------- - set(OMP_gomp_LIBRARY "OMP_gomp_LIBRARY-NOTFOUND") - find_library(OMP_gomp_LIBRARY - NAMES gomp - HINTS ${_libdir} - ) - mark_as_advanced(OMP_gomp_LIBRARY) - # choose one or another depending on the compilo - if (CMAKE_C_COMPILER_ID STREQUAL "GNU") - if (OMP_gomp_LIBRARY) - set(OMP_LIB "${OMP_gomp_LIBRARY}") - endif() - else() - if (OMP_iomp5_LIBRARY) - set(OMP_LIB "${OMP_iomp5_LIBRARY}") - endif() - endif() - - if (UNIX AND NOT WIN32) - # m - find_library(M_LIBRARY - NAMES m - HINTS ${_libdir}) - mark_as_advanced(M_LIBRARY) - if(M_LIBRARY) - set(LM "-lm") - else() - set(LM "") - endif() - # Fortran - set(LGFORTRAN "") - if (CMAKE_C_COMPILER_ID MATCHES "GNU") - find_library( - FORTRAN_gfortran_LIBRARY - NAMES gfortran - HINTS ${_libdir} - ) - mark_as_advanced(FORTRAN_gfortran_LIBRARY) - if (FORTRAN_gfortran_LIBRARY) - set(LGFORTRAN "${FORTRAN_gfortran_LIBRARY}") - endif() - elseif (CMAKE_C_COMPILER_ID MATCHES "Intel") - find_library( - FORTRAN_ifcore_LIBRARY - NAMES ifcore - HINTS ${_libdir} - ) - mark_as_advanced(FORTRAN_ifcore_LIBRARY) - if (FORTRAN_ifcore_LIBRARY) - set(LGFORTRAN "{FORTRAN_ifcore_LIBRARY}") - endif() - endif() - set(BLAS_COMPILER_FLAGS "") - if (NOT BLA_VENDOR STREQUAL "Intel10_64lp_seq") - if (CMAKE_C_COMPILER_ID STREQUAL "Intel") - list(APPEND BLAS_COMPILER_FLAGS "-openmp") - endif() - if (CMAKE_C_COMPILER_ID STREQUAL "GNU") - list(APPEND BLAS_COMPILER_FLAGS "-fopenmp") - endif() - endif() - if (CMAKE_C_COMPILER_ID STREQUAL "GNU") - if (BLA_VENDOR STREQUAL "Intel10_32") - list(APPEND BLAS_COMPILER_FLAGS "-m32") - else() - list(APPEND BLAS_COMPILER_FLAGS "-m64") - endif() - if (NOT BLA_VENDOR STREQUAL "Intel10_64lp_seq") - list(APPEND OMP_LIB "-ldl") - endif() - if (ENV_MKLROOT) - list(APPEND BLAS_COMPILER_FLAGS "-I${ENV_MKLROOT}/include") - endif() - endif() - - set(additional_flags "") - if (CMAKE_C_COMPILER_ID STREQUAL "GNU" AND CMAKE_SYSTEM_NAME STREQUAL "Linux") - set(additional_flags "-Wl,--no-as-needed") - endif() - endif () - - if (_LANGUAGES_ MATCHES C OR _LANGUAGES_ MATCHES CXX) - if(BLAS_FIND_QUIETLY OR NOT BLAS_FIND_REQUIRED) - find_dependency(Threads) - else() - find_dependency(Threads REQUIRED) - endif() - - set(BLAS_SEARCH_LIBS "") - - if(BLA_F95) - - set(BLAS_mkl_SEARCH_SYMBOL SGEMM) - set(_LIBRARIES BLAS95_LIBRARIES) - if (WIN32) - if (BLA_STATIC) - set(BLAS_mkl_DLL_SUFFIX "") - else() - set(BLAS_mkl_DLL_SUFFIX "_dll") - endif() - - # Find the main file (32-bit or 64-bit) - set(BLAS_SEARCH_LIBS_WIN_MAIN "") - if (BLA_VENDOR STREQUAL "Intel10_32" OR BLA_VENDOR STREQUAL "All") - list(APPEND BLAS_SEARCH_LIBS_WIN_MAIN - "mkl_blas95${BLAS_mkl_DLL_SUFFIX} mkl_intel_c${BLAS_mkl_DLL_SUFFIX}") - endif() - if (BLA_VENDOR STREQUAL "Intel10_64lp*" OR BLA_VENDOR STREQUAL "All") - list(APPEND BLAS_SEARCH_LIBS_WIN_MAIN - "mkl_blas95_lp64${BLAS_mkl_DLL_SUFFIX} mkl_intel_lp64${BLAS_mkl_DLL_SUFFIX}") - endif () - - # Add threading/sequential libs - set(BLAS_SEARCH_LIBS_WIN_THREAD "") - if (BLA_VENDOR STREQUAL "*_seq" OR BLA_VENDOR STREQUAL "All") - list(APPEND BLAS_SEARCH_LIBS_WIN_THREAD - "mkl_sequential${BLAS_mkl_DLL_SUFFIX}") - endif() - if (NOT BLA_VENDOR STREQUAL "*_seq" OR BLA_VENDOR STREQUAL "All") - # old version - list(APPEND BLAS_SEARCH_LIBS_WIN_THREAD - "libguide40 mkl_intel_thread${BLAS_mkl_DLL_SUFFIX}") - # mkl >= 10.3 - list(APPEND BLAS_SEARCH_LIBS_WIN_THREAD - "libiomp5md mkl_intel_thread${BLAS_mkl_DLL_SUFFIX}") - endif() - - # Cartesian product of the above - foreach (MAIN ${BLAS_SEARCH_LIBS_WIN_MAIN}) - foreach (THREAD ${BLAS_SEARCH_LIBS_WIN_THREAD}) - list(APPEND BLAS_SEARCH_LIBS - "${MAIN} ${THREAD} mkl_core${BLAS_mkl_DLL_SUFFIX}") - endforeach() - endforeach() - else () - if (BLA_VENDOR STREQUAL "Intel10_32" OR BLA_VENDOR STREQUAL "All") - list(APPEND BLAS_SEARCH_LIBS - "mkl_blas95 mkl_intel mkl_intel_thread mkl_core guide") - endif () - if (BLA_VENDOR STREQUAL "Intel10_64lp" OR BLA_VENDOR STREQUAL "All") - # old version - list(APPEND BLAS_SEARCH_LIBS - "mkl_blas95 mkl_intel_lp64 mkl_intel_thread mkl_core guide") - # mkl >= 10.3 - if (CMAKE_C_COMPILER_ID STREQUAL "Intel") - list(APPEND BLAS_SEARCH_LIBS - "mkl_blas95_lp64 mkl_intel_lp64 mkl_intel_thread mkl_core") - endif() - if (CMAKE_C_COMPILER_ID STREQUAL "GNU") - list(APPEND BLAS_SEARCH_LIBS - "mkl_blas95_lp64 mkl_intel_lp64 mkl_gnu_thread mkl_core") - endif() - endif () - if (BLA_VENDOR STREQUAL "Intel10_64lp_seq" OR BLA_VENDOR STREQUAL "All") - list(APPEND BLAS_SEARCH_LIBS - "mkl_intel_lp64 mkl_sequential mkl_core") - if (BLA_VENDOR STREQUAL "Intel10_64lp_seq") - set(OMP_LIB "") - endif() - endif () - endif () - - else () - - set(BLAS_mkl_SEARCH_SYMBOL sgemm) - set(_LIBRARIES BLAS_LIBRARIES) - if (WIN32) - if (BLA_STATIC) - set(BLAS_mkl_DLL_SUFFIX "") - else() - set(BLAS_mkl_DLL_SUFFIX "_dll") - endif() - - # Find the main file (32-bit or 64-bit) - set(BLAS_SEARCH_LIBS_WIN_MAIN "") - if (BLA_VENDOR STREQUAL "Intel10_32" OR BLA_VENDOR STREQUAL "All") - list(APPEND BLAS_SEARCH_LIBS_WIN_MAIN - "mkl_intel_c${BLAS_mkl_DLL_SUFFIX}") - endif() - if (BLA_VENDOR STREQUAL "Intel10_64lp*" OR BLA_VENDOR STREQUAL "All") - list(APPEND BLAS_SEARCH_LIBS_WIN_MAIN - "mkl_intel_lp64${BLAS_mkl_DLL_SUFFIX}") - endif () - - # Add threading/sequential libs - set(BLAS_SEARCH_LIBS_WIN_THREAD "") - if (NOT BLA_VENDOR STREQUAL "*_seq" OR BLA_VENDOR STREQUAL "All") - # old version - list(APPEND BLAS_SEARCH_LIBS_WIN_THREAD - "libguide40 mkl_intel_thread${BLAS_mkl_DLL_SUFFIX}") - # mkl >= 10.3 - list(APPEND BLAS_SEARCH_LIBS_WIN_THREAD - "libiomp5md mkl_intel_thread${BLAS_mkl_DLL_SUFFIX}") - endif() - if (BLA_VENDOR STREQUAL "*_seq" OR BLA_VENDOR STREQUAL "All") - list(APPEND BLAS_SEARCH_LIBS_WIN_THREAD - "mkl_sequential${BLAS_mkl_DLL_SUFFIX}") - endif() - - # Cartesian product of the above - foreach (MAIN ${BLAS_SEARCH_LIBS_WIN_MAIN}) - foreach (THREAD ${BLAS_SEARCH_LIBS_WIN_THREAD}) - list(APPEND BLAS_SEARCH_LIBS - "${MAIN} ${THREAD} mkl_core${BLAS_mkl_DLL_SUFFIX}") - endforeach() - endforeach() - else () - if (BLA_VENDOR STREQUAL "Intel10_32" OR BLA_VENDOR STREQUAL "All") - list(APPEND BLAS_SEARCH_LIBS - "mkl_intel mkl_intel_thread mkl_core guide") - endif () - if (BLA_VENDOR STREQUAL "Intel10_64lp" OR BLA_VENDOR STREQUAL "All") - # old version - list(APPEND BLAS_SEARCH_LIBS - "mkl_intel_lp64 mkl_intel_thread mkl_core guide") - # mkl >= 10.3 - if (CMAKE_C_COMPILER_ID STREQUAL "Intel") - list(APPEND BLAS_SEARCH_LIBS - "mkl_intel_lp64 mkl_intel_thread mkl_core") - endif() - if (CMAKE_C_COMPILER_ID STREQUAL "GNU") - list(APPEND BLAS_SEARCH_LIBS - "mkl_intel_lp64 mkl_gnu_thread mkl_core") - endif() - endif () - if (BLA_VENDOR STREQUAL "Intel10_64lp_seq" OR BLA_VENDOR STREQUAL "All") - list(APPEND BLAS_SEARCH_LIBS - "mkl_intel_lp64 mkl_sequential mkl_core") - if (BLA_VENDOR STREQUAL "Intel10_64lp_seq") - set(OMP_LIB "") - endif() - endif () - #older vesions of intel mkl libs - if (BLA_VENDOR STREQUAL "Intel" OR BLA_VENDOR STREQUAL "All") - list(APPEND BLAS_SEARCH_LIBS - "mkl") - list(APPEND BLAS_SEARCH_LIBS - "mkl_ia32") - list(APPEND BLAS_SEARCH_LIBS - "mkl_em64t") - endif () - endif () - - endif () - - foreach (IT ${BLAS_SEARCH_LIBS}) - string(REPLACE " " ";" SEARCH_LIBS ${IT}) - if (${_LIBRARIES}) - else () - check_fortran_libraries( - ${_LIBRARIES} - BLAS - ${BLAS_mkl_SEARCH_SYMBOL} - "${additional_flags}" - "${SEARCH_LIBS}" - "${OMP_LIB};${CMAKE_THREAD_LIBS_INIT};${LM}" - ) - if(_LIBRARIES) - set(BLAS_LINKER_FLAGS "${additional_flags}") - endif() - endif() - endforeach () - if(NOT BLAS_FIND_QUIETLY) - if(${_LIBRARIES}) - message(STATUS "Looking for MKL BLAS: found") - else() - message(STATUS "Looking for MKL BLAS: not found") - endif() - endif() - if (${_LIBRARIES} AND NOT BLAS_VENDOR_FOUND) - set (BLAS_VENDOR_FOUND "Intel MKL") - endif() - endif () - endif() -endif () - - -if (BLA_VENDOR STREQUAL "Goto" OR BLA_VENDOR STREQUAL "All") - - if(NOT BLAS_LIBRARIES) - # gotoblas (http://www.tacc.utexas.edu/tacc-projects/gotoblas2) - check_fortran_libraries( - BLAS_LIBRARIES - BLAS - sgemm - "" - "goto2" - "" - ) - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_LIBRARIES) - message(STATUS "Looking for Goto BLAS: found") - else() - message(STATUS "Looking for Goto BLAS: not found") - endif() - endif() - endif() - if (BLAS_LIBRARIES AND NOT BLAS_VENDOR_FOUND) - set (BLAS_VENDOR_FOUND "Goto") - endif() - -endif () - - -# OpenBlas -if (BLA_VENDOR STREQUAL "Open" OR BLA_VENDOR STREQUAL "All") - - if(NOT BLAS_LIBRARIES) - # openblas (http://www.openblas.net/) - check_fortran_libraries( - BLAS_LIBRARIES - BLAS - sgemm - "" - "openblas" - "" - ) - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_LIBRARIES) - message(STATUS "Looking for Open BLAS: found") - else() - message(STATUS "Looking for Open BLAS: not found") - endif() - endif() - endif() - if (BLAS_LIBRARIES AND NOT BLAS_VENDOR_FOUND) - set (BLAS_VENDOR_FOUND "Openblas") - endif() - -endif () - - -# EigenBlas -if (BLA_VENDOR STREQUAL "Eigen" OR BLA_VENDOR STREQUAL "All") - - if(NOT BLAS_LIBRARIES) - # eigenblas (http://eigen.tuxfamily.org/index.php?title=Main_Page) - check_fortran_libraries( - BLAS_LIBRARIES - BLAS - sgemm - "" - "eigen_blas" - "" - ) - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_LIBRARIES AND NOT BLAS_VENDOR_FOUND) - message(STATUS "Looking for Eigen BLAS: found") - else() - message(STATUS "Looking for Eigen BLAS: not found") - endif() - endif() - endif() - - if(NOT BLAS_LIBRARIES) - # eigenblas (http://eigen.tuxfamily.org/index.php?title=Main_Page) - check_fortran_libraries( - BLAS_LIBRARIES - BLAS - sgemm - "" - "eigen_blas_static" - "" - ) - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_LIBRARIES) - message(STATUS "Looking for Eigen BLAS: found") - else() - message(STATUS "Looking for Eigen BLAS: not found") - endif() - endif() - endif() - if (BLAS_LIBRARIES AND NOT BLAS_VENDOR_FOUND) - set (BLAS_VENDOR_FOUND "Eigen") - endif() - -endif () - - -if (BLA_VENDOR STREQUAL "ATLAS" OR BLA_VENDOR STREQUAL "All") - - if(NOT BLAS_LIBRARIES) - # BLAS in ATLAS library? (http://math-atlas.sourceforge.net/) - check_fortran_libraries( - BLAS_LIBRARIES - BLAS - dgemm - "" - "f77blas;atlas" - "" - ) - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_LIBRARIES) - message(STATUS "Looking for Atlas BLAS: found") - else() - message(STATUS "Looking for Atlas BLAS: not found") - endif() - endif() - endif() - - if (BLAS_LIBRARIES AND NOT BLAS_VENDOR_FOUND) - set (BLAS_VENDOR_FOUND "Atlas") - endif() - -endif () - - -# BLAS in PhiPACK libraries? (requires generic BLAS lib, too) -if (BLA_VENDOR STREQUAL "PhiPACK" OR BLA_VENDOR STREQUAL "All") - - if(NOT BLAS_LIBRARIES) - check_fortran_libraries( - BLAS_LIBRARIES - BLAS - sgemm - "" - "sgemm;dgemm;blas" - "" - ) - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_LIBRARIES) - message(STATUS "Looking for PhiPACK BLAS: found") - else() - message(STATUS "Looking for PhiPACK BLAS: not found") - endif() - endif() - endif() - - if (BLAS_LIBRARIES AND NOT BLAS_VENDOR_FOUND) - set (BLAS_VENDOR_FOUND "PhiPACK") - endif() - -endif () - - -# BLAS in Alpha CXML library? -if (BLA_VENDOR STREQUAL "CXML" OR BLA_VENDOR STREQUAL "All") - - if(NOT BLAS_LIBRARIES) - check_fortran_libraries( - BLAS_LIBRARIES - BLAS - sgemm - "" - "cxml" - "" - ) - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_LIBRARIES) - message(STATUS "Looking for CXML BLAS: found") - else() - message(STATUS "Looking for CXML BLAS: not found") - endif() - endif() - endif() - - if (BLAS_LIBRARIES AND NOT BLAS_VENDOR_FOUND) - set (BLAS_VENDOR_FOUND "CXML") - endif() - -endif () - - -# BLAS in Alpha DXML library? (now called CXML, see above) -if (BLA_VENDOR STREQUAL "DXML" OR BLA_VENDOR STREQUAL "All") - - if(NOT BLAS_LIBRARIES) - check_fortran_libraries( - BLAS_LIBRARIES - BLAS - sgemm - "" - "dxml" - "" - ) - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_LIBRARIES) - message(STATUS "Looking for DXML BLAS: found") - else() - message(STATUS "Looking for DXML BLAS: not found") - endif() - endif() - endif() - - if (BLAS_LIBRARIES AND NOT BLAS_VENDOR_FOUND) - set (BLAS_VENDOR_FOUND "DXML") - endif() - -endif () - - -# BLAS in Sun Performance library? -if (BLA_VENDOR STREQUAL "SunPerf" OR BLA_VENDOR STREQUAL "All") - - if(NOT BLAS_LIBRARIES) - check_fortran_libraries( - BLAS_LIBRARIES - BLAS - sgemm - "-xlic_lib=sunperf" - "sunperf;sunmath" - "" - ) - if(BLAS_LIBRARIES) - set(BLAS_LINKER_FLAGS "-xlic_lib=sunperf") - endif() - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_LIBRARIES) - message(STATUS "Looking for SunPerf BLAS: found") - else() - message(STATUS "Looking for SunPerf BLAS: not found") - endif() - endif() - endif() - - if (BLAS_LIBRARIES AND NOT BLAS_VENDOR_FOUND) - set (BLAS_VENDOR_FOUND "SunPerf") - endif() - -endif () - - -# BLAS in SCSL library? (SGI/Cray Scientific Library) -if (BLA_VENDOR STREQUAL "SCSL" OR BLA_VENDOR STREQUAL "All") - - if(NOT BLAS_LIBRARIES) - check_fortran_libraries( - BLAS_LIBRARIES - BLAS - sgemm - "" - "scsl" - "" - ) - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_LIBRARIES) - message(STATUS "Looking for SCSL BLAS: found") - else() - message(STATUS "Looking for SCSL BLAS: not found") - endif() - endif() - endif() - - if (BLAS_LIBRARIES AND NOT BLAS_VENDOR_FOUND) - set (BLAS_VENDOR_FOUND "SunPerf") - endif() - -endif () - - -# BLAS in SGIMATH library? -if (BLA_VENDOR STREQUAL "SGIMATH" OR BLA_VENDOR STREQUAL "All") - - if(NOT BLAS_LIBRARIES) - check_fortran_libraries( - BLAS_LIBRARIES - BLAS - sgemm - "" - "complib.sgimath" - "" - ) - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_LIBRARIES) - message(STATUS "Looking for SGIMATH BLAS: found") - else() - message(STATUS "Looking for SGIMATH BLAS: not found") - endif() - endif() - endif() - - if (BLAS_LIBRARIES AND NOT BLAS_VENDOR_FOUND) - set (BLAS_VENDOR_FOUND "SGIMATH") - endif() - -endif () - - -# BLAS in IBM ESSL library (requires generic BLAS lib, too) -if (BLA_VENDOR STREQUAL "IBMESSL" OR BLA_VENDOR STREQUAL "All") - - if(NOT BLAS_LIBRARIES) - check_fortran_libraries( - BLAS_LIBRARIES - BLAS - sgemm - "" - "essl;xlfmath;xlf90_r;blas" - "" - ) - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_LIBRARIES) - message(STATUS "Looking for IBM ESSL BLAS: found") - else() - message(STATUS "Looking for IBM ESSL BLAS: not found") - endif() - endif() - endif() - - if (BLAS_LIBRARIES AND NOT BLAS_VENDOR_FOUND) - set (BLAS_VENDOR_FOUND "IBM ESSL") - endif() - -endif () - -# BLAS in IBM ESSL_MT library (requires generic BLAS lib, too) -if (BLA_VENDOR STREQUAL "IBMESSLMT" OR BLA_VENDOR STREQUAL "All") - - if(NOT BLAS_LIBRARIES) - check_fortran_libraries( - BLAS_LIBRARIES - BLAS - sgemm - "" - "esslsmp;xlsmp;xlfmath;xlf90_r;blas" - "" - ) - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_LIBRARIES) - message(STATUS "Looking for IBM ESSL MT BLAS: found") - else() - message(STATUS "Looking for IBM ESSL MT BLAS: not found") - endif() - endif() - endif() - - if (BLAS_LIBRARIES AND NOT BLAS_VENDOR_FOUND) - set (BLAS_VENDOR_FOUND "IBM ESSL MT") - endif() - -endif () - - -#BLAS in acml library? -if (BLA_VENDOR MATCHES "ACML.*" OR BLA_VENDOR STREQUAL "All") - - if( ((BLA_VENDOR STREQUAL "ACML") AND (NOT BLAS_ACML_LIB_DIRS)) OR - ((BLA_VENDOR STREQUAL "ACML_MP") AND (NOT BLAS_ACML_MP_LIB_DIRS)) OR - ((BLA_VENDOR STREQUAL "ACML_GPU") AND (NOT BLAS_ACML_GPU_LIB_DIRS))) - - # try to find acml in "standard" paths - if( WIN32 ) - file( GLOB _ACML_ROOT "C:/AMD/acml*/ACML-EULA.txt" ) - else() - file( GLOB _ACML_ROOT "/opt/acml*/ACML-EULA.txt" ) - endif() - if( WIN32 ) - file( GLOB _ACML_GPU_ROOT "C:/AMD/acml*/GPGPUexamples" ) - else() - file( GLOB _ACML_GPU_ROOT "/opt/acml*/GPGPUexamples" ) - endif() - list(GET _ACML_ROOT 0 _ACML_ROOT) - list(GET _ACML_GPU_ROOT 0 _ACML_GPU_ROOT) - - if( _ACML_ROOT ) - - get_filename_component( _ACML_ROOT ${_ACML_ROOT} PATH ) - if( SIZEOF_INTEGER EQUAL 8 ) - set( _ACML_PATH_SUFFIX "_int64" ) - else() - set( _ACML_PATH_SUFFIX "" ) - endif() - if( CMAKE_Fortran_COMPILER_ID STREQUAL "Intel" ) - set( _ACML_COMPILER32 "ifort32" ) - set( _ACML_COMPILER64 "ifort64" ) - elseif( CMAKE_Fortran_COMPILER_ID STREQUAL "SunPro" ) - set( _ACML_COMPILER32 "sun32" ) - set( _ACML_COMPILER64 "sun64" ) - elseif( CMAKE_Fortran_COMPILER_ID STREQUAL "PGI" ) - set( _ACML_COMPILER32 "pgi32" ) - if( WIN32 ) - set( _ACML_COMPILER64 "win64" ) - else() - set( _ACML_COMPILER64 "pgi64" ) - endif() - elseif( CMAKE_Fortran_COMPILER_ID STREQUAL "Open64" ) - # 32 bit builds not supported on Open64 but for code simplicity - # We'll just use the same directory twice - set( _ACML_COMPILER32 "open64_64" ) - set( _ACML_COMPILER64 "open64_64" ) - elseif( CMAKE_Fortran_COMPILER_ID STREQUAL "NAG" ) - set( _ACML_COMPILER32 "nag32" ) - set( _ACML_COMPILER64 "nag64" ) - else() - set( _ACML_COMPILER32 "gfortran32" ) - set( _ACML_COMPILER64 "gfortran64" ) - endif() - - if( BLA_VENDOR STREQUAL "ACML_MP" ) - set(_ACML_MP_LIB_DIRS - "${_ACML_ROOT}/${_ACML_COMPILER32}_mp${_ACML_PATH_SUFFIX}/lib" - "${_ACML_ROOT}/${_ACML_COMPILER64}_mp${_ACML_PATH_SUFFIX}/lib" ) - else() - set(_ACML_LIB_DIRS - "${_ACML_ROOT}/${_ACML_COMPILER32}${_ACML_PATH_SUFFIX}/lib" - "${_ACML_ROOT}/${_ACML_COMPILER64}${_ACML_PATH_SUFFIX}/lib" ) - endif() - - endif() - - elseif(BLAS_${BLA_VENDOR}_LIB_DIRS) - - set(_${BLA_VENDOR}_LIB_DIRS ${BLAS_${BLA_VENDOR}_LIB_DIRS}) - - endif() - - if( BLA_VENDOR STREQUAL "ACML_MP" ) - foreach( BLAS_ACML_MP_LIB_DIRS ${_ACML_MP_LIB_DIRS}) - check_fortran_libraries ( - BLAS_LIBRARIES - BLAS - sgemm - "" "acml_mp;acml_mv" "" ${BLAS_ACML_MP_LIB_DIRS} - ) - if( BLAS_LIBRARIES ) - break() - endif() - endforeach() - elseif( BLA_VENDOR STREQUAL "ACML_GPU" ) - foreach( BLAS_ACML_GPU_LIB_DIRS ${_ACML_GPU_LIB_DIRS}) - check_fortran_libraries ( - BLAS_LIBRARIES - BLAS - sgemm - "" "acml;acml_mv;CALBLAS" "" ${BLAS_ACML_GPU_LIB_DIRS} - ) - if( BLAS_LIBRARIES ) - break() - endif() - endforeach() - else() - foreach( BLAS_ACML_LIB_DIRS ${_ACML_LIB_DIRS} ) - check_fortran_libraries ( - BLAS_LIBRARIES - BLAS - sgemm - "" "acml;acml_mv" "" ${BLAS_ACML_LIB_DIRS} - ) - if( BLAS_LIBRARIES ) - break() - endif() - endforeach() - endif() - - # Either acml or acml_mp should be in LD_LIBRARY_PATH but not both - if(NOT BLAS_LIBRARIES) - check_fortran_libraries( - BLAS_LIBRARIES - BLAS - sgemm - "" - "acml;acml_mv" - "" - ) - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_LIBRARIES) - message(STATUS "Looking for ACML BLAS: found") - else() - message(STATUS "Looking for ACML BLAS: not found") - endif() - endif() - endif() - - if(NOT BLAS_LIBRARIES) - check_fortran_libraries( - BLAS_LIBRARIES - BLAS - sgemm - "" - "acml_mp;acml_mv" - "" - ) - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_LIBRARIES) - message(STATUS "Looking for ACML BLAS: found") - else() - message(STATUS "Looking for ACML BLAS: not found") - endif() - endif() - endif() - - if(NOT BLAS_LIBRARIES) - check_fortran_libraries( - BLAS_LIBRARIES - BLAS - sgemm - "" - "acml;acml_mv;CALBLAS" - "" - ) - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_LIBRARIES) - message(STATUS "Looking for ACML BLAS: found") - else() - message(STATUS "Looking for ACML BLAS: not found") - endif() - endif() - endif() - - if (BLAS_LIBRARIES AND NOT BLAS_VENDOR_FOUND) - set (BLAS_VENDOR_FOUND "ACML") - endif() - -endif () # ACML - - -# Apple BLAS library? -if (BLA_VENDOR STREQUAL "Apple" OR BLA_VENDOR STREQUAL "All") - - if(NOT BLAS_LIBRARIES) - check_fortran_libraries( - BLAS_LIBRARIES - BLAS - dgemm - "" - "Accelerate" - "" - ) - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_LIBRARIES) - message(STATUS "Looking for Apple BLAS: found") - else() - message(STATUS "Looking for Apple BLAS: not found") - endif() - endif() - endif() - - if (BLAS_LIBRARIES AND NOT BLAS_VENDOR_FOUND) - set (BLAS_VENDOR_FOUND "Apple Accelerate") - endif() - -endif () - - -if (BLA_VENDOR STREQUAL "NAS" OR BLA_VENDOR STREQUAL "All") - - if ( NOT BLAS_LIBRARIES ) - check_fortran_libraries( - BLAS_LIBRARIES - BLAS - dgemm - "" - "vecLib" - "" - ) - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_LIBRARIES) - message(STATUS "Looking for NAS BLAS: found") - else() - message(STATUS "Looking for NAS BLAS: not found") - endif() - endif() - endif () - - if (BLAS_LIBRARIES AND NOT BLAS_VENDOR_FOUND) - set (BLAS_VENDOR_FOUND "NAS") - endif() - -endif () - - -# Generic BLAS library? -if (BLA_VENDOR STREQUAL "Generic" OR BLA_VENDOR STREQUAL "All") - - set(BLAS_SEARCH_LIBS "blas;blas_LINUX;blas_MAC;blas_WINDOWS;refblas") - foreach (SEARCH_LIB ${BLAS_SEARCH_LIBS}) - if (BLAS_LIBRARIES) - else () - check_fortran_libraries( - BLAS_LIBRARIES - BLAS - sgemm - "" - "${SEARCH_LIB}" - "${LGFORTRAN}" - ) - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_LIBRARIES) - message(STATUS "Looking for Generic BLAS: found") - else() - message(STATUS "Looking for Generic BLAS: not found") - endif() - endif() - endif() - endforeach () - - if (BLAS_LIBRARIES AND NOT BLAS_VENDOR_FOUND) - set (BLAS_VENDOR_FOUND "Netlib or other Generic libblas") - endif() - -endif () - - -if(BLA_F95) - - if(BLAS95_LIBRARIES) - set(BLAS95_FOUND TRUE) - else() - set(BLAS95_FOUND FALSE) - endif() - - if(NOT BLAS_FIND_QUIETLY) - if(BLAS95_FOUND) - message(STATUS "A library with BLAS95 API found.") - message(STATUS "BLAS_LIBRARIES ${BLAS_LIBRARIES}") - else() - message(WARNING "BLA_VENDOR has been set to ${BLA_VENDOR} but blas 95 libraries could not be found or check of symbols failed." - "\nPlease indicate where to find blas libraries. You have three options:\n" - "- Option 1: Provide the installation directory of BLAS library with cmake option: -DBLAS_DIR=your/path/to/blas\n" - "- Option 2: Provide the directory where to find BLAS libraries with cmake option: -DBLAS_LIBDIR=your/path/to/blas/libs\n" - "- Option 3: Update your environment variable (Linux: LD_LIBRARY_PATH, Windows: LIB, Mac: DYLD_LIBRARY_PATH)\n" - "\nTo follow libraries detection more precisely you can activate a verbose mode with -DBLAS_VERBOSE=ON at cmake configure." - "\nYou could also specify a BLAS vendor to look for by setting -DBLA_VENDOR=blas_vendor_name." - "\nList of possible BLAS vendor: Goto, ATLAS PhiPACK, CXML, DXML, SunPerf, SCSL, SGIMATH, IBMESSL, Intel10_32 (intel mkl v10 32 bit)," - "Intel10_64lp (intel mkl v10 64 bit, lp thread model, lp64 model), Intel10_64lp_seq (intel mkl v10 64 bit, sequential code, lp64 model)," - "Intel( older versions of mkl 32 and 64 bit), ACML, ACML_MP, ACML_GPU, Apple, NAS, Generic") - if(BLAS_FIND_REQUIRED) - message(FATAL_ERROR - "A required library with BLAS95 API not found. Please specify library location.") - else() - message(STATUS - "A library with BLAS95 API not found. Please specify library location.") - endif() - endif() - endif() - - set(BLAS_FOUND TRUE) - set(BLAS_LIBRARIES "${BLAS95_LIBRARIES}") - -else() - - if(BLAS_LIBRARIES) - set(BLAS_FOUND TRUE) - else() - set(BLAS_FOUND FALSE) - endif() - - if(NOT BLAS_FIND_QUIETLY) - if(BLAS_FOUND) - message(STATUS "A library with BLAS API found.") - message(STATUS "BLAS_LIBRARIES ${BLAS_LIBRARIES}") - else() - message(WARNING "BLA_VENDOR has been set to ${BLA_VENDOR} but blas libraries could not be found or check of symbols failed." - "\nPlease indicate where to find blas libraries. You have three options:\n" - "- Option 1: Provide the installation directory of BLAS library with cmake option: -DBLAS_DIR=your/path/to/blas\n" - "- Option 2: Provide the directory where to find BLAS libraries with cmake option: -DBLAS_LIBDIR=your/path/to/blas/libs\n" - "- Option 3: Update your environment variable (Linux: LD_LIBRARY_PATH, Windows: LIB, Mac: DYLD_LIBRARY_PATH)\n" - "\nTo follow libraries detection more precisely you can activate a verbose mode with -DBLAS_VERBOSE=ON at cmake configure." - "\nYou could also specify a BLAS vendor to look for by setting -DBLA_VENDOR=blas_vendor_name." - "\nList of possible BLAS vendor: Goto, ATLAS PhiPACK, CXML, DXML, SunPerf, SCSL, SGIMATH, IBMESSL, Intel10_32 (intel mkl v10 32 bit)," - "Intel10_64lp (intel mkl v10 64 bit, lp thread model, lp64 model), Intel10_64lp_seq (intel mkl v10 64 bit, sequential code, lp64 model)," - "Intel( older versions of mkl 32 and 64 bit), ACML, ACML_MP, ACML_GPU, Apple, NAS, Generic") - if(BLAS_FIND_REQUIRED) - message(FATAL_ERROR - "A required library with BLAS API not found. Please specify library location.") - else() - message(STATUS - "A library with BLAS API not found. Please specify library location.") - endif() - endif() - endif() - -endif() - -set(CMAKE_FIND_LIBRARY_SUFFIXES ${_blas_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES}) - -if (BLAS_FOUND) - list(GET BLAS_LIBRARIES 0 first_lib) - get_filename_component(first_lib_path "${first_lib}" PATH) - if (${first_lib_path} MATCHES "(/lib(32|64)?$)|(/lib/intel64$|/lib/ia32$)") - string(REGEX REPLACE "(/lib(32|64)?$)|(/lib/intel64$|/lib/ia32$)" "" not_cached_dir "${first_lib_path}") - set(BLAS_DIR_FOUND "${not_cached_dir}" CACHE PATH "Installation directory of BLAS library" FORCE) - else() - set(BLAS_DIR_FOUND "${first_lib_path}" CACHE PATH "Installation directory of BLAS library" FORCE) - endif() -endif() -mark_as_advanced(BLAS_DIR) -mark_as_advanced(BLAS_DIR_FOUND)
diff --git a/cmake/FindGLEW.cmake b/cmake/FindGLEW.cmake deleted file mode 100644 index 9d486d5..0000000 --- a/cmake/FindGLEW.cmake +++ /dev/null
@@ -1,105 +0,0 @@ -# Copyright (c) 2009 Boudewijn Rempt <boud@valdyas.org> -# -# Redistribution and use is allowed according to the terms of the BSD license. -# For details see the accompanying COPYING-CMAKE-SCRIPTS file. -# -# - try to find glew library and include files -# GLEW_INCLUDE_DIR, where to find GL/glew.h, etc. -# GLEW_LIBRARIES, the libraries to link against -# GLEW_FOUND, If false, do not try to use GLEW. -# Also defined, but not for general use are: -# GLEW_GLEW_LIBRARY = the full path to the glew library. - -if (WIN32) - - if(CYGWIN) - - find_path( GLEW_INCLUDE_DIR GL/glew.h) - - find_library( GLEW_GLEW_LIBRARY glew32 - ${OPENGL_LIBRARY_DIR} - /usr/lib/w32api - /usr/X11R6/lib - ) - - - else(CYGWIN) - - find_path( GLEW_INCLUDE_DIR GL/glew.h - $ENV{GLEW_ROOT_PATH}/include - ) - - find_library( GLEW_GLEW_LIBRARY - NAMES glew glew32 - PATHS - $ENV{GLEW_ROOT_PATH}/lib - ${OPENGL_LIBRARY_DIR} - ) - - endif(CYGWIN) - -else (WIN32) - - if (APPLE) -# These values for Apple could probably do with improvement. - find_path( GLEW_INCLUDE_DIR glew.h - /System/Library/Frameworks/GLEW.framework/Versions/A/Headers - ${OPENGL_LIBRARY_DIR} - ) - set(GLEW_GLEW_LIBRARY "-framework GLEW" CACHE STRING "GLEW library for OSX") - set(GLEW_cocoa_LIBRARY "-framework Cocoa" CACHE STRING "Cocoa framework for OSX") - else (APPLE) - - find_path( GLEW_INCLUDE_DIR GL/glew.h - /usr/include/GL - /usr/openwin/share/include - /usr/openwin/include - /usr/X11R6/include - /usr/include/X11 - /opt/graphics/OpenGL/include - /opt/graphics/OpenGL/contrib/libglew - ) - - find_library( GLEW_GLEW_LIBRARY GLEW - /usr/openwin/lib - /usr/X11R6/lib - ) - - endif (APPLE) - -endif (WIN32) - -set( GLEW_FOUND "NO" ) -if(GLEW_INCLUDE_DIR) - if(GLEW_GLEW_LIBRARY) - # Is -lXi and -lXmu required on all platforms that have it? - # If not, we need some way to figure out what platform we are on. - set( GLEW_LIBRARIES - ${GLEW_GLEW_LIBRARY} - ${GLEW_cocoa_LIBRARY} - ) - set( GLEW_FOUND "YES" ) - -#The following deprecated settings are for backwards compatibility with CMake1.4 - set (GLEW_LIBRARY ${GLEW_LIBRARIES}) - set (GLEW_INCLUDE_PATH ${GLEW_INCLUDE_DIR}) - - endif(GLEW_GLEW_LIBRARY) -endif(GLEW_INCLUDE_DIR) - -if(GLEW_FOUND) - if(NOT GLEW_FIND_QUIETLY) - message(STATUS "Found Glew: ${GLEW_LIBRARIES}") - endif(NOT GLEW_FIND_QUIETLY) -else(GLEW_FOUND) - if(GLEW_FIND_REQUIRED) - message(FATAL_ERROR "Could not find Glew") - endif(GLEW_FIND_REQUIRED) -endif(GLEW_FOUND) - -mark_as_advanced( - GLEW_INCLUDE_DIR - GLEW_GLEW_LIBRARY - GLEW_Xmu_LIBRARY - GLEW_Xi_LIBRARY -)
diff --git a/cmake/FindGSL.cmake b/cmake/FindGSL.cmake deleted file mode 100644 index 8632232..0000000 --- a/cmake/FindGSL.cmake +++ /dev/null
@@ -1,170 +0,0 @@ -# Try to find gnu scientific library GSL -# See -# http://www.gnu.org/software/gsl/ and -# http://gnuwin32.sourceforge.net/packages/gsl.htm -# -# Once run this will define: -# -# GSL_FOUND = system has GSL lib -# -# GSL_LIBRARIES = full path to the libraries -# on Unix/Linux with additional linker flags from "gsl-config --libs" -# -# CMAKE_GSL_CXX_FLAGS = Unix compiler flags for GSL, essentially "`gsl-config --cxxflags`" -# -# GSL_INCLUDE_DIR = where to find headers -# -# GSL_LINK_DIRECTORIES = link directories, useful for rpath on Unix -# GSL_EXE_LINKER_FLAGS = rpath on Unix -# -# Felix Woelk 07/2004 -# Jan Woetzel -# -# www.mip.informatik.uni-kiel.de -# -------------------------------- - -if(WIN32) - # JW tested with gsl-1.8, Windows XP, MSVS 7.1 - set(GSL_POSSIBLE_ROOT_DIRS - ${GSL_ROOT_DIR} - $ENV{GSL_ROOT_DIR} - ${GSL_DIR} - ${GSL_HOME} - $ENV{GSL_DIR} - $ENV{GSL_HOME} - $ENV{EXTRA} - "C:/Program Files/GnuWin32" - ) - find_path(GSL_INCLUDE_DIR - NAMES gsl/gsl_cdf.h gsl/gsl_randist.h - PATHS ${GSL_POSSIBLE_ROOT_DIRS} - PATH_SUFFIXES include - DOC "GSL header include dir" - ) - - find_library(GSL_GSL_LIBRARY - NAMES libgsl.dll.a gsl libgsl - PATHS ${GSL_POSSIBLE_ROOT_DIRS} - PATH_SUFFIXES lib - DOC "GSL library" ) - - if(NOT GSL_GSL_LIBRARY) - find_file(GSL_GSL_LIBRARY - NAMES libgsl.dll.a - PATHS ${GSL_POSSIBLE_ROOT_DIRS} - PATH_SUFFIXES lib - DOC "GSL library") - endif() - - find_library(GSL_GSLCBLAS_LIBRARY - NAMES libgslcblas.dll.a gslcblas libgslcblas - PATHS ${GSL_POSSIBLE_ROOT_DIRS} - PATH_SUFFIXES lib - DOC "GSL cblas library dir" ) - - if(NOT GSL_GSLCBLAS_LIBRARY) - find_file(GSL_GSLCBLAS_LIBRARY - NAMES libgslcblas.dll.a - PATHS ${GSL_POSSIBLE_ROOT_DIRS} - PATH_SUFFIXES lib - DOC "GSL library") - endif() - - set(GSL_LIBRARIES ${GSL_GSL_LIBRARY}) - - #message("DBG\n" - # "GSL_GSL_LIBRARY=${GSL_GSL_LIBRARY}\n" - # "GSL_GSLCBLAS_LIBRARY=${GSL_GSLCBLAS_LIBRARY}\n" - # "GSL_LIBRARIES=${GSL_LIBRARIES}") - - -else(WIN32) - - if(UNIX) - set(GSL_CONFIG_PREFER_PATH - "$ENV{GSL_DIR}/bin" - "$ENV{GSL_DIR}" - "$ENV{GSL_HOME}/bin" - "$ENV{GSL_HOME}" - CACHE STRING "preferred path to GSL (gsl-config)") - find_program(GSL_CONFIG gsl-config - ${GSL_CONFIG_PREFER_PATH} - /usr/bin/ - ) - # message("DBG GSL_CONFIG ${GSL_CONFIG}") - - if (GSL_CONFIG) - # set CXXFLAGS to be fed into CXX_FLAGS by the user: - set(GSL_CXX_FLAGS "`${GSL_CONFIG} --cflags`") - - # set INCLUDE_DIRS to prefix+include - exec_program(${GSL_CONFIG} - ARGS --prefix - OUTPUT_VARIABLE GSL_PREFIX) - set(GSL_INCLUDE_DIR ${GSL_PREFIX}/include CACHE STRING INTERNAL) - - # set link libraries and link flags - #set(GSL_LIBRARIES "`${GSL_CONFIG} --libs`") - exec_program(${GSL_CONFIG} - ARGS --libs - OUTPUT_VARIABLE GSL_LIBRARIES ) - - # extract link dirs for rpath - exec_program(${GSL_CONFIG} - ARGS --libs - OUTPUT_VARIABLE GSL_CONFIG_LIBS ) - - # extract version - exec_program(${GSL_CONFIG} - ARGS --version - OUTPUT_VARIABLE GSL_FULL_VERSION ) - - # split version as major/minor - string(REGEX MATCH "(.)\\..*" GSL_VERSION_MAJOR_ "${GSL_FULL_VERSION}") - set(GSL_VERSION_MAJOR ${CMAKE_MATCH_1}) - string(REGEX MATCH ".\\.(.*)" GSL_VERSION_MINOR_ "${GSL_FULL_VERSION}") - set(GSL_VERSION_MINOR ${CMAKE_MATCH_1}) - - # split off the link dirs (for rpath) - # use regular expression to match wildcard equivalent "-L*<endchar>" - # with <endchar> is a space or a semicolon - string(REGEX MATCHALL "[-][L]([^ ;])+" - GSL_LINK_DIRECTORIES_WITH_PREFIX - "${GSL_CONFIG_LIBS}" ) - # message("DBG GSL_LINK_DIRECTORIES_WITH_PREFIX=${GSL_LINK_DIRECTORIES_WITH_PREFIX}") - - # remove prefix -L because we need the pure directory for LINK_DIRECTORIES - - if (GSL_LINK_DIRECTORIES_WITH_PREFIX) - string(REGEX REPLACE "[-][L]" "" GSL_LINK_DIRECTORIES ${GSL_LINK_DIRECTORIES_WITH_PREFIX} ) - endif (GSL_LINK_DIRECTORIES_WITH_PREFIX) - set(GSL_EXE_LINKER_FLAGS "-Wl,-rpath,${GSL_LINK_DIRECTORIES}" CACHE STRING INTERNAL) - # message("DBG GSL_LINK_DIRECTORIES=${GSL_LINK_DIRECTORIES}") - # message("DBG GSL_EXE_LINKER_FLAGS=${GSL_EXE_LINKER_FLAGS}") - - # add_definitions("-DHAVE_GSL") - # set(GSL_DEFINITIONS "-DHAVE_GSL") - mark_as_advanced( - GSL_CXX_FLAGS - GSL_INCLUDE_DIR - GSL_LIBRARIES - GSL_LINK_DIRECTORIES - GSL_DEFINITIONS - ) - message(STATUS "Using GSL from ${GSL_PREFIX}") - - else(GSL_CONFIG) - message("FindGSL.cmake: gsl-config not found. Please set it manually. GSL_CONFIG=${GSL_CONFIG}") - endif(GSL_CONFIG) - - endif(UNIX) -endif(WIN32) - - -if(GSL_LIBRARIES) - if(GSL_INCLUDE_DIR OR GSL_CXX_FLAGS) - - set(GSL_FOUND 1) - - endif(GSL_INCLUDE_DIR OR GSL_CXX_FLAGS) -endif(GSL_LIBRARIES)
diff --git a/cmake/FindLAPACK.cmake b/cmake/FindLAPACK.cmake deleted file mode 100644 index 3fd7388..0000000 --- a/cmake/FindLAPACK.cmake +++ /dev/null
@@ -1,274 +0,0 @@ -# Find LAPACK library -# -# This module finds an installed library that implements the LAPACK -# linear-algebra interface (see http://www.netlib.org/lapack/). -# The approach follows mostly that taken for the autoconf macro file, acx_lapack.m4 -# (distributed at http://ac-archive.sourceforge.net/ac-archive/acx_lapack.html). -# -# This module sets the following variables: -# LAPACK_FOUND - set to true if a library implementing the LAPACK interface -# is found -# LAPACK_INCLUDE_DIR - Directories containing the LAPACK header files -# LAPACK_DEFINITIONS - Compilation options to use LAPACK -# LAPACK_LINKER_FLAGS - Linker flags to use LAPACK (excluding -l -# and -L). -# LAPACK_LIBRARIES_DIR - Directories containing the LAPACK libraries. -# May be null if LAPACK_LIBRARIES contains libraries name using full path. -# LAPACK_LIBRARIES - List of libraries to link against LAPACK interface. -# May be null if the compiler supports auto-link (e.g. VC++). -# LAPACK_USE_FILE - The name of the cmake module to include to compile -# applications or libraries using LAPACK. -# -# This module was modified by CGAL team: -# - find libraries for a C++ compiler, instead of Fortran -# - added LAPACK_INCLUDE_DIR, LAPACK_DEFINITIONS and LAPACK_LIBRARIES_DIR -# - removed LAPACK95_LIBRARIES - - -include(CheckFunctionExists) -include(CMakeFindDependencyMacro) - -# This macro checks for the existence of the combination of fortran libraries -# given by _list. If the combination is found, this macro checks (using the -# check_function_exists macro) whether can link against that library -# combination using the name of a routine given by _name using the linker -# flags given by _flags. If the combination of libraries is found and passes -# the link test, LIBRARIES is set to the list of complete library paths that -# have been found and DEFINITIONS to the required definitions. -# Otherwise, LIBRARIES is set to FALSE. -# N.B. _prefix is the prefix applied to the names of all cached variables that -# are generated internally and marked advanced by this macro. -macro(check_lapack_libraries DEFINITIONS LIBRARIES _prefix _name _flags _list _blas _path) - #message("DEBUG: check_lapack_libraries(${_list} in ${_path} with ${_blas})") - - # Check for the existence of the libraries given by _list - set(_libraries_found TRUE) - set(_libraries_work FALSE) - set(${DEFINITIONS} "") - set(${LIBRARIES} "") - set(_combined_name) - foreach(_library ${_list}) - set(_combined_name ${_combined_name}_${_library}) - - if(_libraries_found) - # search first in ${_path} - find_library(${_prefix}_${_library}_LIBRARY - NAMES ${_library} - PATHS ${_path} NO_DEFAULT_PATH - ) - # if not found, search in environment variables and system - if ( WIN32 ) - find_library(${_prefix}_${_library}_LIBRARY - NAMES ${_library} - PATHS ENV LIB - ) - elseif ( APPLE ) - find_library(${_prefix}_${_library}_LIBRARY - NAMES ${_library} - PATHS /usr/local/lib /usr/lib /usr/local/lib64 /usr/lib64 ENV DYLD_LIBRARY_PATH - ) - else () - find_library(${_prefix}_${_library}_LIBRARY - NAMES ${_library} - PATHS /usr/local/lib /usr/lib /usr/local/lib64 /usr/lib64 ENV LD_LIBRARY_PATH - ) - endif() - mark_as_advanced(${_prefix}_${_library}_LIBRARY) - set(${LIBRARIES} ${${LIBRARIES}} ${${_prefix}_${_library}_LIBRARY}) - set(_libraries_found ${${_prefix}_${_library}_LIBRARY}) - endif() - endforeach() - if(_libraries_found) - set(_libraries_found ${${LIBRARIES}}) - endif() - - # Test this combination of libraries with the Fortran/f2c interface. - # We test the Fortran interface first as it is well standardized. - if(_libraries_found AND NOT _libraries_work) - set(${DEFINITIONS} "-D${_prefix}_USE_F2C") - set(${LIBRARIES} ${_libraries_found}) - # Some C++ linkers require the f2c library to link with Fortran libraries. - # I do not know which ones, thus I just add the f2c library if it is available. - find_dependency( F2C QUIET ) - if ( F2C_FOUND ) - set(${DEFINITIONS} ${${DEFINITIONS}} ${F2C_DEFINITIONS}) - set(${LIBRARIES} ${${LIBRARIES}} ${F2C_LIBRARIES}) - endif() - set(CMAKE_REQUIRED_DEFINITIONS ${${DEFINITIONS}}) - set(CMAKE_REQUIRED_LIBRARIES ${_flags} ${${LIBRARIES}} ${_blas}) - #message("DEBUG: CMAKE_REQUIRED_DEFINITIONS = ${CMAKE_REQUIRED_DEFINITIONS}") - #message("DEBUG: CMAKE_REQUIRED_LIBRARIES = ${CMAKE_REQUIRED_LIBRARIES}") - # Check if function exists with f2c calling convention (ie a trailing underscore) - check_function_exists(${_name}_ ${_prefix}_${_name}_${_combined_name}_f2c_WORKS) - set(CMAKE_REQUIRED_DEFINITIONS} "") - set(CMAKE_REQUIRED_LIBRARIES "") - mark_as_advanced(${_prefix}_${_name}_${_combined_name}_f2c_WORKS) - set(_libraries_work ${${_prefix}_${_name}_${_combined_name}_f2c_WORKS}) - endif() - - # If not found, test this combination of libraries with a C interface. - # A few implementations (ie ACML) provide a C interface. Unfortunately, there is no standard. - if(_libraries_found AND NOT _libraries_work) - set(${DEFINITIONS} "") - set(${LIBRARIES} ${_libraries_found}) - set(CMAKE_REQUIRED_DEFINITIONS "") - set(CMAKE_REQUIRED_LIBRARIES ${_flags} ${${LIBRARIES}} ${_blas}) - #message("DEBUG: CMAKE_REQUIRED_LIBRARIES = ${CMAKE_REQUIRED_LIBRARIES}") - check_function_exists(${_name} ${_prefix}_${_name}${_combined_name}_WORKS) - set(CMAKE_REQUIRED_LIBRARIES "") - mark_as_advanced(${_prefix}_${_name}${_combined_name}_WORKS) - set(_libraries_work ${${_prefix}_${_name}${_combined_name}_WORKS}) - endif() - - # on failure - if(NOT _libraries_work) - set(${DEFINITIONS} "") - set(${LIBRARIES} FALSE) - endif() - #message("DEBUG: ${DEFINITIONS} = ${${DEFINITIONS}}") - #message("DEBUG: ${LIBRARIES} = ${${LIBRARIES}}") -endmacro() - - -# -# main -# - -# LAPACK requires BLAS -if(LAPACK_FIND_QUIETLY OR NOT LAPACK_FIND_REQUIRED) - find_dependency(BLAS) -else() - find_dependency(BLAS REQUIRED) -endif() - -if (NOT BLAS_FOUND) - - message(STATUS "LAPACK requires BLAS.") - set(LAPACK_FOUND FALSE) - -# Is it already configured? -elseif (LAPACK_LIBRARIES_DIR OR LAPACK_LIBRARIES) - - set(LAPACK_FOUND TRUE) - -else() - - # reset variables - set( LAPACK_INCLUDE_DIR "" ) - set( LAPACK_DEFINITIONS "" ) - set( LAPACK_LINKER_FLAGS "" ) # unused (yet) - set( LAPACK_LIBRARIES "" ) - set( LAPACK_LIBRARIES_DIR "" ) - - # - # If Unix, search for LAPACK function in possible libraries - # - - #intel mkl lapack? - if(NOT LAPACK_LIBRARIES) - check_lapack_libraries( - LAPACK_DEFINITIONS - LAPACK_LIBRARIES - LAPACK - cheev - "" - "mkl_lapack" - "${BLAS_LIBRARIES}" - "${CGAL_TAUCS_LIBRARIES_DIR} ENV LAPACK_LIB_DIR" - ) - endif() - - #acml lapack? - if(NOT LAPACK_LIBRARIES) - check_lapack_libraries( - LAPACK_DEFINITIONS - LAPACK_LIBRARIES - LAPACK - cheev - "" - "acml" - "${BLAS_LIBRARIES}" - "${CGAL_TAUCS_LIBRARIES_DIR} ENV LAPACK_LIB_DIR" - ) - endif() - - # Apple LAPACK library? - if(NOT LAPACK_LIBRARIES) - check_lapack_libraries( - LAPACK_DEFINITIONS - LAPACK_LIBRARIES - LAPACK - cheev - "" - "Accelerate" - "${BLAS_LIBRARIES}" - "${CGAL_TAUCS_LIBRARIES_DIR} ENV LAPACK_LIB_DIR" - ) - endif() - - if ( NOT LAPACK_LIBRARIES ) - check_lapack_libraries( - LAPACK_DEFINITIONS - LAPACK_LIBRARIES - LAPACK - cheev - "" - "vecLib" - "${BLAS_LIBRARIES}" - "${CGAL_TAUCS_LIBRARIES_DIR} ENV LAPACK_LIB_DIR" - ) - endif () - - # Generic LAPACK library? - # This configuration *must* be the last try as this library is notably slow. - if ( NOT LAPACK_LIBRARIES ) - check_lapack_libraries( - LAPACK_DEFINITIONS - LAPACK_LIBRARIES - LAPACK - cheev - "" - "lapack" - "${BLAS_LIBRARIES}" - "${CGAL_TAUCS_LIBRARIES_DIR} ENV LAPACK_LIB_DIR" - ) - endif() - - if(LAPACK_LIBRARIES_DIR OR LAPACK_LIBRARIES) - set(LAPACK_FOUND TRUE) - else() - set(LAPACK_FOUND FALSE) - endif() - - if(NOT LAPACK_FIND_QUIETLY) - if(LAPACK_FOUND) - message(STATUS "A library with LAPACK API found.") - else() - if(LAPACK_FIND_REQUIRED) - message(FATAL_ERROR "A required library with LAPACK API not found. Please specify library location.") - else() - message(STATUS "A library with LAPACK API not found. Please specify library location.") - endif() - endif() - endif() - - # Add variables to cache - set( LAPACK_INCLUDE_DIR "${LAPACK_INCLUDE_DIR}" - CACHE PATH "Directories containing the LAPACK header files" FORCE ) - set( LAPACK_DEFINITIONS "${LAPACK_DEFINITIONS}" - CACHE STRING "Compilation options to use LAPACK" FORCE ) - set( LAPACK_LINKER_FLAGS "${LAPACK_LINKER_FLAGS}" - CACHE STRING "Linker flags to use LAPACK" FORCE ) - set( LAPACK_LIBRARIES "${LAPACK_LIBRARIES}" - CACHE FILEPATH "LAPACK libraries name" FORCE ) - set( LAPACK_LIBRARIES_DIR "${LAPACK_LIBRARIES_DIR}" - CACHE PATH "Directories containing the LAPACK libraries" FORCE ) - - #message("DEBUG: LAPACK_INCLUDE_DIR = ${LAPACK_INCLUDE_DIR}") - #message("DEBUG: LAPACK_DEFINITIONS = ${LAPACK_DEFINITIONS}") - #message("DEBUG: LAPACK_LINKER_FLAGS = ${LAPACK_LINKER_FLAGS}") - #message("DEBUG: LAPACK_LIBRARIES = ${LAPACK_LIBRARIES}") - #message("DEBUG: LAPACK_LIBRARIES_DIR = ${LAPACK_LIBRARIES_DIR}") - #message("DEBUG: LAPACK_FOUND = ${LAPACK_FOUND}") - -endif()
diff --git a/doc/PreprocessorDirectives.dox b/doc/PreprocessorDirectives.dox index 79581a5..5a98539 100644 --- a/doc/PreprocessorDirectives.dox +++ b/doc/PreprocessorDirectives.dox
@@ -55,23 +55,17 @@ the information provided by the compiler. - \b EIGEN_MAX_CPP_VER - disables usage of C++ features requiring a version greater than EIGEN_MAX_CPP_VER. - Possible values are: 11, 14, 17, etc. If not defined (the default), %Eigen enables all features supported + Possible values are: 14, 17, etc. If not defined (the default), %Eigen enables all features supported by the compiler. Individual features can be explicitly enabled or disabled by defining the following token to 0 or 1 respectively. -For instance, one might limit the C++ version to C++03 by defining EIGEN_MAX_CPP_VER=03, but still enable C99 math +For instance, one might limit the C++ version to C++14 by defining EIGEN_MAX_CPP_VER=14, but still enable C99 math functions by defining EIGEN_HAS_C99_MATH=1. - \b EIGEN_HAS_C99_MATH - controls the usage of C99 math functions such as erf, erfc, lgamma, etc. - Automatic detection disabled if EIGEN_MAX_CPP_VER<11. - \b EIGEN_HAS_CXX11_MATH - controls the implementation of some functions such as round, logp1, isinf, isnan, etc. - Automatic detection disabled if EIGEN_MAX_CPP_VER<11. - \b EIGEN_HAS_STD_RESULT_OF - defines whether std::result_of is supported - Automatic detection disabled if EIGEN_MAX_CPP_VER<11. - - \b EIGEN_HAS_VARIADIC_TEMPLATES - defines whether variadic templates are supported - Automatic detection disabled if EIGEN_MAX_CPP_VER<11. - \b EIGEN_HAS_CONSTEXPR - defines whether relaxed const expression are supported - Automatic detection disabled if EIGEN_MAX_CPP_VER<14. - \b EIGEN_NO_IO - Disables any usage and support for `<iostreams>`. \section TopicPreprocessorDirectivesAssertions Assertions
diff --git a/doc/examples/Cwise_erf.cpp b/doc/examples/Cwise_erf.cpp index e7cd2c1..9ddc57d 100644 --- a/doc/examples/Cwise_erf.cpp +++ b/doc/examples/Cwise_erf.cpp
@@ -1,9 +1,8 @@ #include <Eigen/Core> #include <unsupported/Eigen/SpecialFunctions> #include <iostream> -using namespace Eigen; int main() { - Array4d v(-0.5,2,0,-7); + Eigen::Array4d v(-0.5,2,0,-7); std::cout << v.erf() << std::endl; }
diff --git a/doc/examples/Cwise_erfc.cpp b/doc/examples/Cwise_erfc.cpp index d8bb04c..4b7902c 100644 --- a/doc/examples/Cwise_erfc.cpp +++ b/doc/examples/Cwise_erfc.cpp
@@ -1,9 +1,8 @@ #include <Eigen/Core> #include <unsupported/Eigen/SpecialFunctions> #include <iostream> -using namespace Eigen; int main() { - Array4d v(-0.5,2,0,-7); + Eigen::Array4d v(-0.5,2,0,-7); std::cout << v.erfc() << std::endl; }
diff --git a/doc/examples/Cwise_lgamma.cpp b/doc/examples/Cwise_lgamma.cpp index 6bfaccb..f3c9fe6 100644 --- a/doc/examples/Cwise_lgamma.cpp +++ b/doc/examples/Cwise_lgamma.cpp
@@ -1,9 +1,8 @@ #include <Eigen/Core> #include <unsupported/Eigen/SpecialFunctions> #include <iostream> -using namespace Eigen; int main() { - Array4d v(0.5,10,0,-1); + Eigen::Array4d v(0.5,10,0,-1); std::cout << v.lgamma() << std::endl; }
diff --git a/doc/examples/DenseBase_middleCols_int.cpp b/doc/examples/DenseBase_middleCols_int.cpp index 0ebd955..d05a552 100644 --- a/doc/examples/DenseBase_middleCols_int.cpp +++ b/doc/examples/DenseBase_middleCols_int.cpp
@@ -1,15 +1,12 @@ #include <Eigen/Core> #include <iostream> -using namespace Eigen; -using namespace std; - -int main(void) +int main() { int const N = 5; - MatrixXi A(N,N); + Eigen::MatrixXi A(N,N); A.setRandom(); - cout << "A =\n" << A << '\n' << endl; - cout << "A(1..3,:) =\n" << A.middleCols(1,3) << endl; + std::cout << "A =\n" << A << '\n' << std::endl; + std::cout << "A(1..3,:) =\n" << A.middleCols(1,3) << std::endl; return 0; }
diff --git a/doc/examples/DenseBase_middleRows_int.cpp b/doc/examples/DenseBase_middleRows_int.cpp index a6fe9e8..8651629 100644 --- a/doc/examples/DenseBase_middleRows_int.cpp +++ b/doc/examples/DenseBase_middleRows_int.cpp
@@ -1,15 +1,12 @@ #include <Eigen/Core> #include <iostream> -using namespace Eigen; -using namespace std; - -int main(void) +int main() { int const N = 5; - MatrixXi A(N,N); + Eigen::MatrixXi A(N,N); A.setRandom(); - cout << "A =\n" << A << '\n' << endl; - cout << "A(2..3,:) =\n" << A.middleRows(2,2) << endl; + std::cout << "A =\n" << A << '\n' << std::endl; + std::cout << "A(2..3,:) =\n" << A.middleRows(2,2) << std::endl; return 0; }
diff --git a/doc/examples/DenseBase_template_int_middleCols.cpp b/doc/examples/DenseBase_template_int_middleCols.cpp index 6191d79..caefabf 100644 --- a/doc/examples/DenseBase_template_int_middleCols.cpp +++ b/doc/examples/DenseBase_template_int_middleCols.cpp
@@ -1,15 +1,12 @@ #include <Eigen/Core> #include <iostream> -using namespace Eigen; -using namespace std; - -int main(void) +int main() { int const N = 5; - MatrixXi A(N,N); + Eigen::MatrixXi A(N,N); A.setRandom(); - cout << "A =\n" << A << '\n' << endl; - cout << "A(:,1..3) =\n" << A.middleCols<3>(1) << endl; + std::cout << "A =\n" << A << '\n' << std::endl; + std::cout << "A(:,1..3) =\n" << A.middleCols<3>(1) << std::endl; return 0; }
diff --git a/doc/examples/DenseBase_template_int_middleRows.cpp b/doc/examples/DenseBase_template_int_middleRows.cpp index 7e8b657..ed5b295 100644 --- a/doc/examples/DenseBase_template_int_middleRows.cpp +++ b/doc/examples/DenseBase_template_int_middleRows.cpp
@@ -1,15 +1,12 @@ #include <Eigen/Core> #include <iostream> -using namespace Eigen; -using namespace std; - -int main(void) +int main() { int const N = 5; - MatrixXi A(N,N); + Eigen::MatrixXi A(N,N); A.setRandom(); - cout << "A =\n" << A << '\n' << endl; - cout << "A(1..3,:) =\n" << A.middleRows<3>(1) << endl; + std::cout << "A =\n" << A << '\n' << std::endl; + std::cout << "A(1..3,:) =\n" << A.middleRows<3>(1) << std::endl; return 0; }
diff --git a/doc/examples/QuickStart_example2_dynamic.cpp b/doc/examples/QuickStart_example2_dynamic.cpp index ff6746e..bc8d326 100644 --- a/doc/examples/QuickStart_example2_dynamic.cpp +++ b/doc/examples/QuickStart_example2_dynamic.cpp
@@ -1,15 +1,15 @@ #include <iostream> #include <Eigen/Dense> -using namespace Eigen; -using namespace std; +using Eigen::MatrixXd; +using Eigen::VectorXd; int main() { MatrixXd m = MatrixXd::Random(3,3); m = (m + MatrixXd::Constant(3,3,1.2)) * 50; - cout << "m =" << endl << m << endl; + std::cout << "m =" << std::endl << m << std::endl; VectorXd v(3); v << 1, 2, 3; - cout << "m * v =" << endl << m * v << endl; + std::cout << "m * v =" << std::endl << m * v << std::endl; }
diff --git a/doc/examples/QuickStart_example2_fixed.cpp b/doc/examples/QuickStart_example2_fixed.cpp index d911752..af6f9a9 100644 --- a/doc/examples/QuickStart_example2_fixed.cpp +++ b/doc/examples/QuickStart_example2_fixed.cpp
@@ -1,15 +1,15 @@ #include <iostream> #include <Eigen/Dense> -using namespace Eigen; -using namespace std; +using Eigen::Matrix3d; +using Eigen::Vector3d; int main() { Matrix3d m = Matrix3d::Random(); m = (m + Matrix3d::Constant(1.2)) * 50; - cout << "m =" << endl << m << endl; + std::cout << "m =" << std::endl << m << std::endl; Vector3d v(1,2,3); - cout << "m * v =" << endl << m * v << endl; + std::cout << "m * v =" << std::endl << m * v << std::endl; }
diff --git a/doc/examples/TemplateKeyword_flexible.cpp b/doc/examples/TemplateKeyword_flexible.cpp index 9d85292..efe458b 100644 --- a/doc/examples/TemplateKeyword_flexible.cpp +++ b/doc/examples/TemplateKeyword_flexible.cpp
@@ -1,19 +1,17 @@ #include <Eigen/Dense> #include <iostream> -using namespace Eigen; - template <typename Derived1, typename Derived2> -void copyUpperTriangularPart(MatrixBase<Derived1>& dst, const MatrixBase<Derived2>& src) +void copyUpperTriangularPart(Eigen::MatrixBase<Derived1>& dst, const Eigen::MatrixBase<Derived2>& src) { /* Note the 'template' keywords in the following line! */ - dst.template triangularView<Upper>() = src.template triangularView<Upper>(); + dst.template triangularView<Eigen::Upper>() = src.template triangularView<Eigen::Upper>(); } int main() { - MatrixXi m1 = MatrixXi::Ones(5,5); - MatrixXi m2 = MatrixXi::Random(4,4); + Eigen::MatrixXi m1 = Eigen::MatrixXi::Ones(5,5); + Eigen::MatrixXi m2 = Eigen::MatrixXi::Random(4,4); std::cout << "m2 before copy:" << std::endl; std::cout << m2 << std::endl << std::endl; copyUpperTriangularPart(m2, m1.topLeftCorner(4,4));
diff --git a/doc/examples/TemplateKeyword_simple.cpp b/doc/examples/TemplateKeyword_simple.cpp index 6998c17..6b946ad 100644 --- a/doc/examples/TemplateKeyword_simple.cpp +++ b/doc/examples/TemplateKeyword_simple.cpp
@@ -1,11 +1,11 @@ #include <Eigen/Dense> #include <iostream> -using namespace Eigen; +using Eigen::MatrixXf; void copyUpperTriangularPart(MatrixXf& dst, const MatrixXf& src) { - dst.triangularView<Upper>() = src.triangularView<Upper>(); + dst.triangularView<Eigen::Upper>() = src.triangularView<Eigen::Upper>(); } int main()
diff --git a/doc/examples/TutorialInplaceLU.cpp b/doc/examples/TutorialInplaceLU.cpp index cb9c59b..72bead2 100644 --- a/doc/examples/TutorialInplaceLU.cpp +++ b/doc/examples/TutorialInplaceLU.cpp
@@ -1,61 +1,57 @@ #include <iostream> struct init { - init() { std::cout << "[" << "init" << "]" << std::endl; } + init() { std::cout << "[init]\n"; } }; init init_obj; // [init] -#include <iostream> #include <Eigen/Dense> -using namespace std; -using namespace Eigen; - int main() { - MatrixXd A(2,2); + Eigen::MatrixXd A(2,2); A << 2, -1, 1, 3; - cout << "Here is the input matrix A before decomposition:\n" << A << endl; -cout << "[init]" << endl; + std::cout << "Here is the input matrix A before decomposition:\n" << A << "\n"; + std::cout << "[init]\n"; -cout << "[declaration]" << endl; - PartialPivLU<Ref<MatrixXd> > lu(A); - cout << "Here is the input matrix A after decomposition:\n" << A << endl; -cout << "[declaration]" << endl; + std::cout << "[declaration]\n"; + Eigen::PartialPivLU<Eigen::Ref<Eigen::MatrixXd> > lu(A); + std::cout << "Here is the input matrix A after decomposition:\n" << A << "\n"; + std::cout << "[declaration]\n"; -cout << "[matrixLU]" << endl; - cout << "Here is the matrix storing the L and U factors:\n" << lu.matrixLU() << endl; -cout << "[matrixLU]" << endl; + std::cout << "[matrixLU]\n"; + std::cout << "Here is the matrix storing the L and U factors:\n" << lu.matrixLU() << "\n"; + std::cout << "[matrixLU]\n"; -cout << "[solve]" << endl; - MatrixXd A0(2,2); A0 << 2, -1, 1, 3; - VectorXd b(2); b << 1, 2; - VectorXd x = lu.solve(b); - cout << "Residual: " << (A0 * x - b).norm() << endl; -cout << "[solve]" << endl; + std::cout << "[solve]\n"; + Eigen::MatrixXd A0(2,2); A0 << 2, -1, 1, 3; + Eigen::VectorXd b(2); b << 1, 2; + Eigen::VectorXd x = lu.solve(b); + std::cout << "Residual: " << (A0 * x - b).norm() << "\n"; + std::cout << "[solve]\n"; -cout << "[modifyA]" << endl; + std::cout << "[modifyA]\n"; A << 3, 4, -2, 1; x = lu.solve(b); - cout << "Residual: " << (A0 * x - b).norm() << endl; -cout << "[modifyA]" << endl; + std::cout << "Residual: " << (A0 * x - b).norm() << "\n"; + std::cout << "[modifyA]\n"; -cout << "[recompute]" << endl; + std::cout << "[recompute]\n"; A0 = A; // save A lu.compute(A); x = lu.solve(b); - cout << "Residual: " << (A0 * x - b).norm() << endl; -cout << "[recompute]" << endl; + std::cout << "Residual: " << (A0 * x - b).norm() << "\n"; + std::cout << "[recompute]\n"; -cout << "[recompute_bis0]" << endl; - MatrixXd A1(2,2); + std::cout << "[recompute_bis0]\n"; + Eigen::MatrixXd A1(2,2); A1 << 5,-2,3,4; lu.compute(A1); - cout << "Here is the input matrix A1 after decomposition:\n" << A1 << endl; -cout << "[recompute_bis0]" << endl; + std::cout << "Here is the input matrix A1 after decomposition:\n" << A1 << "\n"; + std::cout << "[recompute_bis0]\n"; -cout << "[recompute_bis1]" << endl; + std::cout << "[recompute_bis1]\n"; x = lu.solve(b); - cout << "Residual: " << (A1 * x - b).norm() << endl; -cout << "[recompute_bis1]" << endl; + std::cout << "Residual: " << (A1 * x - b).norm() << "\n"; + std::cout << "[recompute_bis1]\n"; }
diff --git a/doc/examples/TutorialLinAlgComputeTwice.cpp b/doc/examples/TutorialLinAlgComputeTwice.cpp index 06ba646..a561f08 100644 --- a/doc/examples/TutorialLinAlgComputeTwice.cpp +++ b/doc/examples/TutorialLinAlgComputeTwice.cpp
@@ -1,23 +1,20 @@ #include <iostream> #include <Eigen/Dense> -using namespace std; -using namespace Eigen; - int main() { - Matrix2f A, b; - LLT<Matrix2f> llt; + Eigen::Matrix2f A, b; + Eigen::LLT<Eigen::Matrix2f> llt; A << 2, -1, -1, 3; b << 1, 2, 3, 1; - cout << "Here is the matrix A:\n" << A << endl; - cout << "Here is the right hand side b:\n" << b << endl; - cout << "Computing LLT decomposition..." << endl; + std::cout << "Here is the matrix A:\n" << A << std::endl; + std::cout << "Here is the right hand side b:\n" << b << std::endl; + std::cout << "Computing LLT decomposition..." << std::endl; llt.compute(A); - cout << "The solution is:\n" << llt.solve(b) << endl; + std::cout << "The solution is:\n" << llt.solve(b) << std::endl; A(1,1)++; - cout << "The matrix A is now:\n" << A << endl; - cout << "Computing LLT decomposition..." << endl; + std::cout << "The matrix A is now:\n" << A << std::endl; + std::cout << "Computing LLT decomposition..." << std::endl; llt.compute(A); - cout << "The solution is now:\n" << llt.solve(b) << endl; + std::cout << "The solution is now:\n" << llt.solve(b) << std::endl; }
diff --git a/doc/examples/TutorialLinAlgExComputeSolveError.cpp b/doc/examples/TutorialLinAlgExComputeSolveError.cpp index f362fb7..199f3f5 100644 --- a/doc/examples/TutorialLinAlgExComputeSolveError.cpp +++ b/doc/examples/TutorialLinAlgExComputeSolveError.cpp
@@ -1,8 +1,7 @@ #include <iostream> #include <Eigen/Dense> -using namespace std; -using namespace Eigen; +using Eigen::MatrixXd; int main() { @@ -10,5 +9,5 @@ MatrixXd b = MatrixXd::Random(100,50); MatrixXd x = A.fullPivLu().solve(b); double relative_error = (A*x - b).norm() / b.norm(); // norm() is L2 norm - cout << "The relative error is:\n" << relative_error << endl; + std::cout << "The relative error is:\n" << relative_error << std::endl; }
diff --git a/doc/examples/TutorialLinAlgExSolveColPivHouseholderQR.cpp b/doc/examples/TutorialLinAlgExSolveColPivHouseholderQR.cpp index 3a99a94..5ee6b6a 100644 --- a/doc/examples/TutorialLinAlgExSolveColPivHouseholderQR.cpp +++ b/doc/examples/TutorialLinAlgExSolveColPivHouseholderQR.cpp
@@ -1,17 +1,14 @@ #include <iostream> #include <Eigen/Dense> -using namespace std; -using namespace Eigen; - int main() { - Matrix3f A; - Vector3f b; + Eigen::Matrix3f A; + Eigen::Vector3f b; A << 1,2,3, 4,5,6, 7,8,10; b << 3, 3, 4; - cout << "Here is the matrix A:\n" << A << endl; - cout << "Here is the vector b:\n" << b << endl; - Vector3f x = A.colPivHouseholderQr().solve(b); - cout << "The solution is:\n" << x << endl; + std::cout << "Here is the matrix A:\n" << A << std::endl; + std::cout << "Here is the vector b:\n" << b << std::endl; + Eigen::Vector3f x = A.colPivHouseholderQr().solve(b); + std::cout << "The solution is:\n" << x << std::endl; }
diff --git a/doc/examples/TutorialLinAlgExSolveLDLT.cpp b/doc/examples/TutorialLinAlgExSolveLDLT.cpp index f8beacd..82186d4 100644 --- a/doc/examples/TutorialLinAlgExSolveLDLT.cpp +++ b/doc/examples/TutorialLinAlgExSolveLDLT.cpp
@@ -1,16 +1,13 @@ #include <iostream> #include <Eigen/Dense> -using namespace std; -using namespace Eigen; - int main() { - Matrix2f A, b; + Eigen::Matrix2f A, b; A << 2, -1, -1, 3; b << 1, 2, 3, 1; - cout << "Here is the matrix A:\n" << A << endl; - cout << "Here is the right hand side b:\n" << b << endl; - Matrix2f x = A.ldlt().solve(b); - cout << "The solution is:\n" << x << endl; + std::cout << "Here is the matrix A:\n" << A << std::endl; + std::cout << "Here is the right hand side b:\n" << b << std::endl; + Eigen::Matrix2f x = A.ldlt().solve(b); + std::cout << "The solution is:\n" << x << std::endl; }
diff --git a/doc/examples/TutorialLinAlgInverseDeterminant.cpp b/doc/examples/TutorialLinAlgInverseDeterminant.cpp index 14dde5b..b31a92a 100644 --- a/doc/examples/TutorialLinAlgInverseDeterminant.cpp +++ b/doc/examples/TutorialLinAlgInverseDeterminant.cpp
@@ -1,16 +1,13 @@ #include <iostream> #include <Eigen/Dense> -using namespace std; -using namespace Eigen; - int main() { - Matrix3f A; + Eigen::Matrix3f A; A << 1, 2, 1, 2, 1, 0, -1, 1, 2; - cout << "Here is the matrix A:\n" << A << endl; - cout << "The determinant of A is " << A.determinant() << endl; - cout << "The inverse of A is:\n" << A.inverse() << endl; + std::cout << "Here is the matrix A:\n" << A << std::endl; + std::cout << "The determinant of A is " << A.determinant() << std::endl; + std::cout << "The inverse of A is:\n" << A.inverse() << std::endl; }
diff --git a/doc/examples/TutorialLinAlgRankRevealing.cpp b/doc/examples/TutorialLinAlgRankRevealing.cpp index c516507..fea52ab 100644 --- a/doc/examples/TutorialLinAlgRankRevealing.cpp +++ b/doc/examples/TutorialLinAlgRankRevealing.cpp
@@ -1,20 +1,17 @@ #include <iostream> #include <Eigen/Dense> -using namespace std; -using namespace Eigen; - int main() { - Matrix3f A; + Eigen::Matrix3f A; A << 1, 2, 5, 2, 1, 4, 3, 0, 3; - cout << "Here is the matrix A:\n" << A << endl; - FullPivLU<Matrix3f> lu_decomp(A); - cout << "The rank of A is " << lu_decomp.rank() << endl; - cout << "Here is a matrix whose columns form a basis of the null-space of A:\n" - << lu_decomp.kernel() << endl; - cout << "Here is a matrix whose columns form a basis of the column-space of A:\n" - << lu_decomp.image(A) << endl; // yes, have to pass the original A + std::cout << "Here is the matrix A:\n" << A << std::endl; + Eigen::FullPivLU<Eigen::Matrix3f> lu_decomp(A); + std::cout << "The rank of A is " << lu_decomp.rank() << std::endl; + std::cout << "Here is a matrix whose columns form a basis of the null-space of A:\n" + << lu_decomp.kernel() << std::endl; + std::cout << "Here is a matrix whose columns form a basis of the column-space of A:\n" + << lu_decomp.image(A) << std::endl; // yes, have to pass the original A }
diff --git a/doc/examples/TutorialLinAlgSVDSolve.cpp b/doc/examples/TutorialLinAlgSVDSolve.cpp index f109f04..23ad422 100644 --- a/doc/examples/TutorialLinAlgSVDSolve.cpp +++ b/doc/examples/TutorialLinAlgSVDSolve.cpp
@@ -1,15 +1,12 @@ #include <iostream> #include <Eigen/Dense> -using namespace std; -using namespace Eigen; - int main() { - MatrixXf A = MatrixXf::Random(3, 2); - cout << "Here is the matrix A:\n" << A << endl; - VectorXf b = VectorXf::Random(3); - cout << "Here is the right hand side b:\n" << b << endl; - cout << "The least-squares solution is:\n" - << A.bdcSvd(ComputeThinU | ComputeThinV).solve(b) << endl; + Eigen::MatrixXf A = Eigen::MatrixXf::Random(3, 2); + std::cout << "Here is the matrix A:\n" << A << std::endl; + Eigen::VectorXf b = Eigen::VectorXf::Random(3); + std::cout << "Here is the right hand side b:\n" << b << std::endl; + std::cout << "The least-squares solution is:\n" + << A.bdcSvd(Eigen::ComputeThinU | Eigen::ComputeThinV).solve(b) << std::endl; }
diff --git a/doc/examples/TutorialLinAlgSelfAdjointEigenSolver.cpp b/doc/examples/TutorialLinAlgSelfAdjointEigenSolver.cpp index 8d1d1ed..fcf2f33 100644 --- a/doc/examples/TutorialLinAlgSelfAdjointEigenSolver.cpp +++ b/doc/examples/TutorialLinAlgSelfAdjointEigenSolver.cpp
@@ -1,18 +1,15 @@ #include <iostream> #include <Eigen/Dense> -using namespace std; -using namespace Eigen; - int main() { - Matrix2f A; + Eigen::Matrix2f A; A << 1, 2, 2, 3; - cout << "Here is the matrix A:\n" << A << endl; - SelfAdjointEigenSolver<Matrix2f> eigensolver(A); - if (eigensolver.info() != Success) abort(); - cout << "The eigenvalues of A are:\n" << eigensolver.eigenvalues() << endl; - cout << "Here's a matrix whose columns are eigenvectors of A \n" + std::cout << "Here is the matrix A:\n" << A << std::endl; + Eigen::SelfAdjointEigenSolver<Eigen::Matrix2f> eigensolver(A); + if (eigensolver.info() != Eigen::Success) abort(); + std::cout << "The eigenvalues of A are:\n" << eigensolver.eigenvalues() << std::endl; + std::cout << "Here's a matrix whose columns are eigenvectors of A \n" << "corresponding to these eigenvalues:\n" - << eigensolver.eigenvectors() << endl; + << eigensolver.eigenvectors() << std::endl; }
diff --git a/doc/examples/TutorialLinAlgSetThreshold.cpp b/doc/examples/TutorialLinAlgSetThreshold.cpp index 3956b13..e1335e7 100644 --- a/doc/examples/TutorialLinAlgSetThreshold.cpp +++ b/doc/examples/TutorialLinAlgSetThreshold.cpp
@@ -1,16 +1,13 @@ #include <iostream> #include <Eigen/Dense> -using namespace std; -using namespace Eigen; - int main() { - Matrix2d A; + Eigen::Matrix2d A; A << 2, 1, 2, 0.9999999999; - FullPivLU<Matrix2d> lu(A); - cout << "By default, the rank of A is found to be " << lu.rank() << endl; + Eigen::FullPivLU<Eigen::Matrix2d> lu(A); + std::cout << "By default, the rank of A is found to be " << lu.rank() << std::endl; lu.setThreshold(1e-5); - cout << "With threshold 1e-5, the rank of A is found to be " << lu.rank() << endl; + std::cout << "With threshold 1e-5, the rank of A is found to be " << lu.rank() << std::endl; }
diff --git a/doc/examples/Tutorial_ArrayClass_accessors.cpp b/doc/examples/Tutorial_ArrayClass_accessors.cpp index dc720ff..0db52a3 100644 --- a/doc/examples/Tutorial_ArrayClass_accessors.cpp +++ b/doc/examples/Tutorial_ArrayClass_accessors.cpp
@@ -1,24 +1,21 @@ #include <Eigen/Dense> #include <iostream> -using namespace Eigen; -using namespace std; - int main() { - ArrayXXf m(2,2); + Eigen::ArrayXXf m(2,2); // assign some values coefficient by coefficient m(0,0) = 1.0; m(0,1) = 2.0; m(1,0) = 3.0; m(1,1) = m(0,1) + m(1,0); // print values to standard output - cout << m << endl << endl; + std::cout << m << std::endl << std::endl; // using the comma-initializer is also allowed m << 1.0,2.0, 3.0,4.0; // print values to standard output - cout << m << endl; + std::cout << m << std::endl; }
diff --git a/doc/examples/Tutorial_ArrayClass_addition.cpp b/doc/examples/Tutorial_ArrayClass_addition.cpp index 480ffb0..4a407a7 100644 --- a/doc/examples/Tutorial_ArrayClass_addition.cpp +++ b/doc/examples/Tutorial_ArrayClass_addition.cpp
@@ -1,13 +1,10 @@ #include <Eigen/Dense> #include <iostream> -using namespace Eigen; -using namespace std; - int main() { - ArrayXXf a(3,3); - ArrayXXf b(3,3); + Eigen::ArrayXXf a(3,3); + Eigen::ArrayXXf b(3,3); a << 1,2,3, 4,5,6, 7,8,9; @@ -16,8 +13,8 @@ 1,2,3; // Adding two arrays - cout << "a + b = " << endl << a + b << endl << endl; + std::cout << "a + b = " << std::endl << a + b << std::endl << std::endl; // Subtracting a scalar from an array - cout << "a - 2 = " << endl << a - 2 << endl; + std::cout << "a - 2 = " << std::endl << a - 2 << std::endl; }
diff --git a/doc/examples/Tutorial_ArrayClass_cwise_other.cpp b/doc/examples/Tutorial_ArrayClass_cwise_other.cpp index d9046c6..12483f3 100644 --- a/doc/examples/Tutorial_ArrayClass_cwise_other.cpp +++ b/doc/examples/Tutorial_ArrayClass_cwise_other.cpp
@@ -1,19 +1,16 @@ #include <Eigen/Dense> #include <iostream> -using namespace Eigen; -using namespace std; - int main() { - ArrayXf a = ArrayXf::Random(5); + Eigen::ArrayXf a = Eigen::ArrayXf::Random(5); a *= 2; - cout << "a =" << endl - << a << endl; - cout << "a.abs() =" << endl - << a.abs() << endl; - cout << "a.abs().sqrt() =" << endl - << a.abs().sqrt() << endl; - cout << "a.min(a.abs().sqrt()) =" << endl - << a.min(a.abs().sqrt()) << endl; + std::cout << "a =" << std::endl + << a << std::endl; + std::cout << "a.abs() =" << std::endl + << a.abs() << std::endl; + std::cout << "a.abs().sqrt() =" << std::endl + << a.abs().sqrt() << std::endl; + std::cout << "a.min(a.abs().sqrt()) =" << std::endl + << a.min(a.abs().sqrt()) << std::endl; }
diff --git a/doc/examples/Tutorial_ArrayClass_interop.cpp b/doc/examples/Tutorial_ArrayClass_interop.cpp index 371f070..c9a8352 100644 --- a/doc/examples/Tutorial_ArrayClass_interop.cpp +++ b/doc/examples/Tutorial_ArrayClass_interop.cpp
@@ -1,8 +1,7 @@ #include <Eigen/Dense> #include <iostream> -using namespace Eigen; -using namespace std; +using Eigen::MatrixXf; int main() { @@ -16,7 +15,7 @@ 7,8; result = (m.array() + 4).matrix() * m; - cout << "-- Combination 1: --" << endl << result << endl << endl; + std::cout << "-- Combination 1: --\n" << result << "\n\n"; result = (m.array() * n.array()).matrix() * m; - cout << "-- Combination 2: --" << endl << result << endl << endl; + std::cout << "-- Combination 2: --\n" << result << "\n\n"; }
diff --git a/doc/examples/Tutorial_ArrayClass_interop_matrix.cpp b/doc/examples/Tutorial_ArrayClass_interop_matrix.cpp index 1014275..07ec9b0 100644 --- a/doc/examples/Tutorial_ArrayClass_interop_matrix.cpp +++ b/doc/examples/Tutorial_ArrayClass_interop_matrix.cpp
@@ -1,8 +1,7 @@ #include <Eigen/Dense> #include <iostream> -using namespace Eigen; -using namespace std; +using Eigen::MatrixXf; int main() { @@ -16,11 +15,11 @@ 7,8; result = m * n; - cout << "-- Matrix m*n: --" << endl << result << endl << endl; + std::cout << "-- Matrix m*n: --\n" << result << "\n\n"; result = m.array() * n.array(); - cout << "-- Array m*n: --" << endl << result << endl << endl; + std::cout << "-- Array m*n: --\n" << result << "\n\n"; result = m.cwiseProduct(n); - cout << "-- With cwiseProduct: --" << endl << result << endl << endl; + std::cout << "-- With cwiseProduct: --\n" << result << "\n\n"; result = m.array() + 4; - cout << "-- Array m + 4: --" << endl << result << endl << endl; + std::cout << "-- Array m + 4: --\n" << result << "\n\n"; }
diff --git a/doc/examples/Tutorial_ArrayClass_mult.cpp b/doc/examples/Tutorial_ArrayClass_mult.cpp index 6cb439f..bada36c 100644 --- a/doc/examples/Tutorial_ArrayClass_mult.cpp +++ b/doc/examples/Tutorial_ArrayClass_mult.cpp
@@ -1,16 +1,13 @@ #include <Eigen/Dense> #include <iostream> -using namespace Eigen; -using namespace std; - int main() { - ArrayXXf a(2,2); - ArrayXXf b(2,2); + Eigen::ArrayXXf a(2,2); + Eigen::ArrayXXf b(2,2); a << 1,2, 3,4; b << 5,6, 7,8; - cout << "a * b = " << endl << a * b << endl; + std::cout << "a * b = " << std::endl << a * b << std::endl; }
diff --git a/doc/examples/Tutorial_BlockOperations_block_assignment.cpp b/doc/examples/Tutorial_BlockOperations_block_assignment.cpp index 0b87313..26ad478 100644 --- a/doc/examples/Tutorial_BlockOperations_block_assignment.cpp +++ b/doc/examples/Tutorial_BlockOperations_block_assignment.cpp
@@ -1,18 +1,15 @@ #include <Eigen/Dense> #include <iostream> -using namespace std; -using namespace Eigen; - int main() { - Array22f m; + Eigen::Array22f m; m << 1,2, 3,4; - Array44f a = Array44f::Constant(0.6); - cout << "Here is the array a:" << endl << a << endl << endl; + Eigen::Array44f a = Eigen::Array44f::Constant(0.6); + std::cout << "Here is the array a:\n" << a << "\n\n"; a.block<2,2>(1,1) = m; - cout << "Here is now a with m copied into its central 2x2 block:" << endl << a << endl << endl; + std::cout << "Here is now a with m copied into its central 2x2 block:\n" << a << "\n\n"; a.block(0,0,2,3) = a.block(2,1,2,3); - cout << "Here is now a with bottom-right 2x3 block copied into top-left 2x3 block:" << endl << a << endl << endl; + std::cout << "Here is now a with bottom-right 2x3 block copied into top-left 2x3 block:\n" << a << "\n\n"; }
diff --git a/doc/examples/Tutorial_PartialLU_solve.cpp b/doc/examples/Tutorial_PartialLU_solve.cpp index a560879..ca72c99 100644 --- a/doc/examples/Tutorial_PartialLU_solve.cpp +++ b/doc/examples/Tutorial_PartialLU_solve.cpp
@@ -2,17 +2,14 @@ #include <Eigen/LU> #include <iostream> -using namespace std; -using namespace Eigen; - int main() { - Matrix3f A; - Vector3f b; + Eigen::Matrix3f A; + Eigen::Vector3f b; A << 1,2,3, 4,5,6, 7,8,10; b << 3, 3, 4; - cout << "Here is the matrix A:" << endl << A << endl; - cout << "Here is the vector b:" << endl << b << endl; - Vector3f x = A.lu().solve(b); - cout << "The solution is:" << endl << x << endl; + std::cout << "Here is the matrix A:" << std::endl << A << std::endl; + std::cout << "Here is the vector b:" << std::endl << b << std::endl; + Eigen::Vector3f x = A.lu().solve(b); + std::cout << "The solution is:" << std::endl << x << std::endl; }
diff --git a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_broadcast_1nn.cpp b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_broadcast_1nn.cpp index 334b4d8..8ef06be 100644 --- a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_broadcast_1nn.cpp +++ b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_broadcast_1nn.cpp
@@ -1,9 +1,6 @@ #include <iostream> #include <Eigen/Dense> -using namespace std; -using namespace Eigen; - int main() { Eigen::MatrixXf m(2,4); @@ -15,10 +12,10 @@ v << 2, 3; - MatrixXf::Index index; + Eigen::Index index; // find nearest neighbour (m.colwise() - v).colwise().squaredNorm().minCoeff(&index); - cout << "Nearest neighbour is column " << index << ":" << endl; - cout << m.col(index) << endl; + std::cout << "Nearest neighbour is column " << index << ":" << std::endl; + std::cout << m.col(index) << std::endl; }
diff --git a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_maxnorm.cpp b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_maxnorm.cpp index 049c747..b5d88c3 100644 --- a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_maxnorm.cpp +++ b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_maxnorm.cpp
@@ -1,15 +1,13 @@ #include <iostream> #include <Eigen/Dense> -using namespace std; -using namespace Eigen; int main() { - MatrixXf mat(2,4); + Eigen::MatrixXf mat(2,4); mat << 1, 2, 6, 9, 3, 1, 7, 2; - MatrixXf::Index maxIndex; + Eigen::Index maxIndex; float maxNorm = mat.colwise().sum().maxCoeff(&maxIndex); std::cout << "Maximum sum at position " << maxIndex << std::endl;
diff --git a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_bool.cpp b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_bool.cpp index 0cca37f..7b89bcf 100644 --- a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_bool.cpp +++ b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_bool.cpp
@@ -1,21 +1,18 @@ #include <Eigen/Dense> #include <iostream> -using namespace std; -using namespace Eigen; - int main() { - ArrayXXf a(2,2); + Eigen::ArrayXXf a(2,2); a << 1,2, 3,4; - cout << "(a > 0).all() = " << (a > 0).all() << endl; - cout << "(a > 0).any() = " << (a > 0).any() << endl; - cout << "(a > 0).count() = " << (a > 0).count() << endl; - cout << endl; - cout << "(a > 2).all() = " << (a > 2).all() << endl; - cout << "(a > 2).any() = " << (a > 2).any() << endl; - cout << "(a > 2).count() = " << (a > 2).count() << endl; + std::cout << "(a > 0).all() = " << (a > 0).all() << std::endl; + std::cout << "(a > 0).any() = " << (a > 0).any() << std::endl; + std::cout << "(a > 0).count() = " << (a > 0).count() << std::endl; + std::cout << std::endl; + std::cout << "(a > 2).all() = " << (a > 2).all() << std::endl; + std::cout << "(a > 2).any() = " << (a > 2).any() << std::endl; + std::cout << "(a > 2).count() = " << (a > 2).count() << std::endl; }
diff --git a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_norm.cpp b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_norm.cpp index 740439f..7519137 100644 --- a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_norm.cpp +++ b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_norm.cpp
@@ -1,13 +1,10 @@ #include <Eigen/Dense> #include <iostream> -using namespace std; -using namespace Eigen; - int main() { - VectorXf v(2); - MatrixXf m(2,2), n(2,2); + Eigen::VectorXf v(2); + Eigen::MatrixXf m(2,2), n(2,2); v << -1, 2; @@ -15,14 +12,14 @@ m << 1,-2, -3,4; - cout << "v.squaredNorm() = " << v.squaredNorm() << endl; - cout << "v.norm() = " << v.norm() << endl; - cout << "v.lpNorm<1>() = " << v.lpNorm<1>() << endl; - cout << "v.lpNorm<Infinity>() = " << v.lpNorm<Infinity>() << endl; + std::cout << "v.squaredNorm() = " << v.squaredNorm() << std::endl; + std::cout << "v.norm() = " << v.norm() << std::endl; + std::cout << "v.lpNorm<1>() = " << v.lpNorm<1>() << std::endl; + std::cout << "v.lpNorm<Infinity>() = " << v.lpNorm<Eigen::Infinity>() << std::endl; - cout << endl; - cout << "m.squaredNorm() = " << m.squaredNorm() << endl; - cout << "m.norm() = " << m.norm() << endl; - cout << "m.lpNorm<1>() = " << m.lpNorm<1>() << endl; - cout << "m.lpNorm<Infinity>() = " << m.lpNorm<Infinity>() << endl; + std::cout << std::endl; + std::cout << "m.squaredNorm() = " << m.squaredNorm() << std::endl; + std::cout << "m.norm() = " << m.norm() << std::endl; + std::cout << "m.lpNorm<1>() = " << m.lpNorm<1>() << std::endl; + std::cout << "m.lpNorm<Infinity>() = " << m.lpNorm<Eigen::Infinity>() << std::endl; }
diff --git a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_operatornorm.cpp b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_operatornorm.cpp index 62e28fc..8faa5a1 100644 --- a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_operatornorm.cpp +++ b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_reductions_operatornorm.cpp
@@ -1,18 +1,15 @@ #include <Eigen/Dense> #include <iostream> -using namespace Eigen; -using namespace std; - int main() { - MatrixXf m(2,2); + Eigen::MatrixXf m(2,2); m << 1,-2, -3,4; - cout << "1-norm(m) = " << m.cwiseAbs().colwise().sum().maxCoeff() - << " == " << m.colwise().lpNorm<1>().maxCoeff() << endl; + std::cout << "1-norm(m) = " << m.cwiseAbs().colwise().sum().maxCoeff() + << " == " << m.colwise().lpNorm<1>().maxCoeff() << std::endl; - cout << "infty-norm(m) = " << m.cwiseAbs().rowwise().sum().maxCoeff() - << " == " << m.rowwise().lpNorm<1>().maxCoeff() << endl; + std::cout << "infty-norm(m) = " << m.cwiseAbs().rowwise().sum().maxCoeff() + << " == " << m.rowwise().lpNorm<1>().maxCoeff() << std::endl; }
diff --git a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_visitors.cpp b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_visitors.cpp index b54e9aa..bd294bd 100644 --- a/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_visitors.cpp +++ b/doc/examples/Tutorial_ReductionsVisitorsBroadcasting_visitors.cpp
@@ -1,9 +1,6 @@ #include <iostream> #include <Eigen/Dense> -using namespace std; -using namespace Eigen; - int main() { Eigen::MatrixXf m(2,2); @@ -12,15 +9,15 @@ 3, 4; //get location of maximum - MatrixXf::Index maxRow, maxCol; + Eigen::Index maxRow, maxCol; float max = m.maxCoeff(&maxRow, &maxCol); //get location of minimum - MatrixXf::Index minRow, minCol; + Eigen::Index minRow, minCol; float min = m.minCoeff(&minRow, &minCol); - cout << "Max: " << max << ", at: " << - maxRow << "," << maxCol << endl; - cout << "Min: " << min << ", at: " << - minRow << "," << minCol << endl; + std::cout << "Max: " << max << ", at: " << + maxRow << "," << maxCol << std::endl; + std:: cout << "Min: " << min << ", at: " << + minRow << "," << minCol << std::endl; }
diff --git a/doc/examples/Tutorial_simple_example_dynamic_size.cpp b/doc/examples/Tutorial_simple_example_dynamic_size.cpp index defcb1e..796bd87 100644 --- a/doc/examples/Tutorial_simple_example_dynamic_size.cpp +++ b/doc/examples/Tutorial_simple_example_dynamic_size.cpp
@@ -1,13 +1,11 @@ #include <Eigen/Core> #include <iostream> -using namespace Eigen; - int main() { for (int size=1; size<=4; ++size) { - MatrixXi m(size,size+1); // a (size)x(size+1)-matrix of int's + Eigen::MatrixXi m(size,size+1); // a (size)x(size+1)-matrix of int's for (int j=0; j<m.cols(); ++j) // loop over columns for (int i=0; i<m.rows(); ++i) // loop over rows m(i,j) = i+j*size; // to access matrix coefficients, @@ -15,7 +13,7 @@ std::cout << m << "\n\n"; } - VectorXf v(4); // a vector of 4 float's + Eigen::VectorXf v(4); // a vector of 4 float's // to access vector coefficients, use either operator () or operator [] v[0] = 1; v[1] = 2; v(2) = 3; v(3) = 4; std::cout << "\nv:\n" << v << std::endl;
diff --git a/doc/examples/Tutorial_simple_example_fixed_size.cpp b/doc/examples/Tutorial_simple_example_fixed_size.cpp index bc4f95d..99a974d 100644 --- a/doc/examples/Tutorial_simple_example_fixed_size.cpp +++ b/doc/examples/Tutorial_simple_example_fixed_size.cpp
@@ -1,14 +1,12 @@ #include <Eigen/Core> #include <iostream> -using namespace Eigen; - int main() { - Matrix3f m3; + Eigen::Matrix3f m3; m3 << 1, 2, 3, 4, 5, 6, 7, 8, 9; - Matrix4f m4 = Matrix4f::Identity(); - Vector4i v4(1, 2, 3, 4); + Eigen::Matrix4f m4 = Eigen::Matrix4f::Identity(); + Eigen::Vector4i v4(1, 2, 3, 4); std::cout << "m3\n" << m3 << "\nm4:\n" << m4 << "\nv4:\n" << v4 << std::endl;
diff --git a/doc/examples/class_Block.cpp b/doc/examples/class_Block.cpp index ace719a..9ace0da 100644 --- a/doc/examples/class_Block.cpp +++ b/doc/examples/class_Block.cpp
@@ -1,27 +1,25 @@ #include <Eigen/Core> #include <iostream> -using namespace Eigen; -using namespace std; template<typename Derived> Eigen::Block<Derived> -topLeftCorner(MatrixBase<Derived>& m, int rows, int cols) +topLeftCorner(Eigen::MatrixBase<Derived>& m, int rows, int cols) { return Eigen::Block<Derived>(m.derived(), 0, 0, rows, cols); } template<typename Derived> const Eigen::Block<const Derived> -topLeftCorner(const MatrixBase<Derived>& m, int rows, int cols) +topLeftCorner(const Eigen::MatrixBase<Derived>& m, int rows, int cols) { return Eigen::Block<const Derived>(m.derived(), 0, 0, rows, cols); } int main(int, char**) { - Matrix4d m = Matrix4d::Identity(); - cout << topLeftCorner(4*m, 2, 3) << endl; // calls the const version + Eigen::Matrix4d m = Eigen::Matrix4d::Identity(); + std::cout << topLeftCorner(4*m, 2, 3) << std::endl; // calls the const version topLeftCorner(m, 2, 3) *= 5; // calls the non-const version - cout << "Now the matrix m is:" << endl << m << endl; + std::cout << "Now the matrix m is:" << std::endl << m << std::endl; return 0; }
diff --git a/doc/examples/class_CwiseBinaryOp.cpp b/doc/examples/class_CwiseBinaryOp.cpp index 682af46..aec926d 100644 --- a/doc/examples/class_CwiseBinaryOp.cpp +++ b/doc/examples/class_CwiseBinaryOp.cpp
@@ -1,18 +1,18 @@ #include <Eigen/Core> #include <iostream> -using namespace Eigen; -using namespace std; + +using Eigen::Matrix4d; // define a custom template binary functor template<typename Scalar> struct MakeComplexOp { EIGEN_EMPTY_STRUCT_CTOR(MakeComplexOp) - typedef complex<Scalar> result_type; - complex<Scalar> operator()(const Scalar& a, const Scalar& b) const { return complex<Scalar>(a,b); } + typedef std::complex<Scalar> result_type; + result_type operator()(const Scalar& a, const Scalar& b) const { return result_type(a,b); } }; int main(int, char**) { Matrix4d m1 = Matrix4d::Random(), m2 = Matrix4d::Random(); - cout << m1.binaryExpr(m2, MakeComplexOp<double>()) << endl; + std::cout << m1.binaryExpr(m2, MakeComplexOp<double>()) << std::endl; return 0; }
diff --git a/doc/examples/class_CwiseUnaryOp.cpp b/doc/examples/class_CwiseUnaryOp.cpp index a5fcc15..6c65f2e 100644 --- a/doc/examples/class_CwiseUnaryOp.cpp +++ b/doc/examples/class_CwiseUnaryOp.cpp
@@ -1,7 +1,5 @@ #include <Eigen/Core> #include <iostream> -using namespace Eigen; -using namespace std; // define a custom template unary functor template<typename Scalar> @@ -13,7 +11,7 @@ int main(int, char**) { - Matrix4d m1 = Matrix4d::Random(); - cout << m1 << endl << "becomes: " << endl << m1.unaryExpr(CwiseClampOp<double>(-0.5,0.5)) << endl; + Eigen::Matrix4d m1 = Eigen::Matrix4d::Random(); + std::cout << m1 << std::endl << "becomes: " << std::endl << m1.unaryExpr(CwiseClampOp<double>(-0.5,0.5)) << std::endl; return 0; }
diff --git a/doc/examples/class_CwiseUnaryOp_ptrfun.cpp b/doc/examples/class_CwiseUnaryOp_ptrfun.cpp index 36706d8..e97095e 100644 --- a/doc/examples/class_CwiseUnaryOp_ptrfun.cpp +++ b/doc/examples/class_CwiseUnaryOp_ptrfun.cpp
@@ -1,7 +1,5 @@ #include <Eigen/Core> #include <iostream> -using namespace Eigen; -using namespace std; // define function to be applied coefficient-wise double ramp(double x) @@ -14,7 +12,7 @@ int main(int, char**) { - Matrix4d m1 = Matrix4d::Random(); - cout << m1 << endl << "becomes: " << endl << m1.unaryExpr(ptr_fun(ramp)) << endl; + Eigen::Matrix4d m1 = Eigen::Matrix4d::Random(); + std::cout << m1 << std::endl << "becomes: " << std::endl << m1.unaryExpr(std::ptr_fun(ramp)) << std::endl; return 0; }
diff --git a/doc/examples/class_FixedBlock.cpp b/doc/examples/class_FixedBlock.cpp index 9978b32..4bb2d44 100644 --- a/doc/examples/class_FixedBlock.cpp +++ b/doc/examples/class_FixedBlock.cpp
@@ -1,27 +1,25 @@ #include <Eigen/Core> #include <iostream> -using namespace Eigen; -using namespace std; template<typename Derived> Eigen::Block<Derived, 2, 2> -topLeft2x2Corner(MatrixBase<Derived>& m) +topLeft2x2Corner(Eigen::MatrixBase<Derived>& m) { return Eigen::Block<Derived, 2, 2>(m.derived(), 0, 0); } template<typename Derived> const Eigen::Block<const Derived, 2, 2> -topLeft2x2Corner(const MatrixBase<Derived>& m) +topLeft2x2Corner(const Eigen::MatrixBase<Derived>& m) { return Eigen::Block<const Derived, 2, 2>(m.derived(), 0, 0); } int main(int, char**) { - Matrix3d m = Matrix3d::Identity(); - cout << topLeft2x2Corner(4*m) << endl; // calls the const version + Eigen::Matrix3d m = Eigen::Matrix3d::Identity(); + std::cout << topLeft2x2Corner(4*m) << std::endl; // calls the const version topLeft2x2Corner(m) *= 2; // calls the non-const version - cout << "Now the matrix m is:" << endl << m << endl; + std::cout << "Now the matrix m is:" << std::endl << m << std::endl; return 0; }
diff --git a/doc/examples/class_FixedReshaped.cpp b/doc/examples/class_FixedReshaped.cpp index b6d4085..be7069d 100644 --- a/doc/examples/class_FixedReshaped.cpp +++ b/doc/examples/class_FixedReshaped.cpp
@@ -1,22 +1,20 @@ #include <Eigen/Core> #include <iostream> -using namespace Eigen; -using namespace std; template<typename Derived> Eigen::Reshaped<Derived, 4, 2> -reshape_helper(MatrixBase<Derived>& m) +reshape_helper(Eigen::MatrixBase<Derived>& m) { return Eigen::Reshaped<Derived, 4, 2>(m.derived()); } int main(int, char**) { - MatrixXd m(2, 4); + Eigen::MatrixXd m(2, 4); m << 1, 2, 3, 4, 5, 6, 7, 8; - MatrixXd n = reshape_helper(m); - cout << "matrix m is:" << endl << m << endl; - cout << "matrix n is:" << endl << n << endl; + Eigen::MatrixXd n = reshape_helper(m); + std::cout << "matrix m is:" << std::endl << m << std::endl; + std::cout << "matrix n is:" << std::endl << n << std::endl; return 0; }
diff --git a/doc/examples/class_FixedVectorBlock.cpp b/doc/examples/class_FixedVectorBlock.cpp index c88c9fb..eed3007 100644 --- a/doc/examples/class_FixedVectorBlock.cpp +++ b/doc/examples/class_FixedVectorBlock.cpp
@@ -1,27 +1,25 @@ #include <Eigen/Core> #include <iostream> -using namespace Eigen; -using namespace std; template<typename Derived> Eigen::VectorBlock<Derived, 2> -firstTwo(MatrixBase<Derived>& v) +firstTwo(Eigen::MatrixBase<Derived>& v) { return Eigen::VectorBlock<Derived, 2>(v.derived(), 0); } template<typename Derived> const Eigen::VectorBlock<const Derived, 2> -firstTwo(const MatrixBase<Derived>& v) +firstTwo(const Eigen::MatrixBase<Derived>& v) { return Eigen::VectorBlock<const Derived, 2>(v.derived(), 0); } int main(int, char**) { - Matrix<int,1,6> v; v << 1,2,3,4,5,6; - cout << firstTwo(4*v) << endl; // calls the const version + Eigen::Matrix<int,1,6> v; v << 1,2,3,4,5,6; + std::cout << firstTwo(4*v) << std::endl; // calls the const version firstTwo(v) *= 2; // calls the non-const version - cout << "Now the vector v is:" << endl << v << endl; + std::cout << "Now the vector v is:" << std::endl << v << std::endl; return 0; }
diff --git a/doc/examples/class_Reshaped.cpp b/doc/examples/class_Reshaped.cpp index 18fb454..7219853 100644 --- a/doc/examples/class_Reshaped.cpp +++ b/doc/examples/class_Reshaped.cpp
@@ -1,23 +1,21 @@ #include <Eigen/Core> #include <iostream> -using namespace std; -using namespace Eigen; template<typename Derived> -const Reshaped<const Derived> -reshape_helper(const MatrixBase<Derived>& m, int rows, int cols) +const Eigen::Reshaped<const Derived> +reshape_helper(const Eigen::MatrixBase<Derived>& m, int rows, int cols) { - return Reshaped<const Derived>(m.derived(), rows, cols); + return Eigen::Reshaped<const Derived>(m.derived(), rows, cols); } int main(int, char**) { - MatrixXd m(3, 4); + Eigen::MatrixXd m(3, 4); m << 1, 4, 7, 10, 2, 5, 8, 11, 3, 6, 9, 12; - cout << m << endl; - Ref<const MatrixXd> n = reshape_helper(m, 2, 6); - cout << "Matrix m is:" << endl << m << endl; - cout << "Matrix n is:" << endl << n << endl; + std::cout << m << std::endl; + Eigen::Ref<const Eigen::MatrixXd> n = reshape_helper(m, 2, 6); + std::cout << "Matrix m is:" << std::endl << m << std::endl; + std::cout << "Matrix n is:" << std::endl << n << std::endl; }
diff --git a/doc/examples/class_VectorBlock.cpp b/doc/examples/class_VectorBlock.cpp index dc213df..5cee147 100644 --- a/doc/examples/class_VectorBlock.cpp +++ b/doc/examples/class_VectorBlock.cpp
@@ -1,27 +1,25 @@ #include <Eigen/Core> #include <iostream> -using namespace Eigen; -using namespace std; template<typename Derived> Eigen::VectorBlock<Derived> -segmentFromRange(MatrixBase<Derived>& v, int start, int end) +segmentFromRange(Eigen::MatrixBase<Derived>& v, int start, int end) { return Eigen::VectorBlock<Derived>(v.derived(), start, end-start); } template<typename Derived> const Eigen::VectorBlock<const Derived> -segmentFromRange(const MatrixBase<Derived>& v, int start, int end) +segmentFromRange(const Eigen::MatrixBase<Derived>& v, int start, int end) { return Eigen::VectorBlock<const Derived>(v.derived(), start, end-start); } int main(int, char**) { - Matrix<int,1,6> v; v << 1,2,3,4,5,6; - cout << segmentFromRange(2*v, 2, 4) << endl; // calls the const version + Eigen::Matrix<int,1,6> v; v << 1,2,3,4,5,6; + std::cout << segmentFromRange(2*v, 2, 4) << std::endl; // calls the const version segmentFromRange(v, 1, 3) *= 5; // calls the non-const version - cout << "Now the vector v is:" << endl << v << endl; + std::cout << "Now the vector v is:" << std::endl << v << std::endl; return 0; }
diff --git a/doc/examples/function_taking_eigenbase.cpp b/doc/examples/function_taking_eigenbase.cpp index 49d94b3..4e1e5a9 100644 --- a/doc/examples/function_taking_eigenbase.cpp +++ b/doc/examples/function_taking_eigenbase.cpp
@@ -1,9 +1,8 @@ #include <iostream> #include <Eigen/Core> -using namespace Eigen; template <typename Derived> -void print_size(const EigenBase<Derived>& b) +void print_size(const Eigen::EigenBase<Derived>& b) { std::cout << "size (rows, cols): " << b.size() << " (" << b.rows() << ", " << b.cols() << ")" << std::endl; @@ -11,7 +10,7 @@ int main() { - Vector3f v; + Eigen::Vector3f v; print_size(v); // v.asDiagonal() returns a 3x3 diagonal matrix pseudo-expression print_size(v.asDiagonal());
diff --git a/doc/examples/function_taking_ref.cpp b/doc/examples/function_taking_ref.cpp index 162a202..a837e19 100644 --- a/doc/examples/function_taking_ref.cpp +++ b/doc/examples/function_taking_ref.cpp
@@ -1,19 +1,17 @@ #include <iostream> #include <Eigen/SVD> -using namespace Eigen; -using namespace std; -float inv_cond(const Ref<const MatrixXf>& a) +float inv_cond(const Eigen::Ref<const Eigen::MatrixXf>& a) { - const VectorXf sing_vals = a.jacobiSvd().singularValues(); + const Eigen::VectorXf sing_vals = a.jacobiSvd().singularValues(); return sing_vals(sing_vals.size()-1) / sing_vals(0); } int main() { - Matrix4f m = Matrix4f::Random(); - cout << "matrix m:" << endl << m << endl << endl; - cout << "inv_cond(m): " << inv_cond(m) << endl; - cout << "inv_cond(m(1:3,1:3)): " << inv_cond(m.topLeftCorner(3,3)) << endl; - cout << "inv_cond(m+I): " << inv_cond(m+Matrix4f::Identity()) << endl; + Eigen::MatrixXf m = Eigen::MatrixXf::Random(4, 4); + std::cout << "matrix m:\n" << m << "\n\n"; + std::cout << "inv_cond(m): " << inv_cond(m) << "\n"; + std::cout << "inv_cond(m(1:3,1:3)): " << inv_cond(m.topLeftCorner(3,3)) << "\n"; + std::cout << "inv_cond(m+I): " << inv_cond(m+Eigen::MatrixXf::Identity(4, 4)) << "\n"; }
diff --git a/doc/examples/make_circulant2.cpp b/doc/examples/make_circulant2.cpp index 95d3dd3..d86a66b 100644 --- a/doc/examples/make_circulant2.cpp +++ b/doc/examples/make_circulant2.cpp
@@ -1,8 +1,6 @@ #include <Eigen/Core> #include <iostream> -using namespace Eigen; - // [circulant_func] template<class ArgType> class circulant_functor { @@ -10,8 +8,8 @@ public: circulant_functor(const ArgType& arg) : m_vec(arg) {} - const typename ArgType::Scalar& operator() (Index row, Index col) const { - Index index = row - col; + const typename ArgType::Scalar& operator() (Eigen::Index row, Eigen::Index col) const { + Eigen::Index index = row - col; if (index < 0) index += m_vec.size(); return m_vec(index); } @@ -21,10 +19,10 @@ // [square] template<class ArgType> struct circulant_helper { - typedef Matrix<typename ArgType::Scalar, + typedef Eigen::Matrix<typename ArgType::Scalar, ArgType::SizeAtCompileTime, ArgType::SizeAtCompileTime, - ColMajor, + Eigen::ColMajor, ArgType::MaxSizeAtCompileTime, ArgType::MaxSizeAtCompileTime> MatrixType; }; @@ -32,7 +30,7 @@ // [makeCirculant] template <class ArgType> -CwiseNullaryOp<circulant_functor<ArgType>, typename circulant_helper<ArgType>::MatrixType> +Eigen::CwiseNullaryOp<circulant_functor<ArgType>, typename circulant_helper<ArgType>::MatrixType> makeCirculant(const Eigen::MatrixBase<ArgType>& arg) { typedef typename circulant_helper<ArgType>::MatrixType MatrixType;
diff --git a/doc/examples/nullary_indexing.cpp b/doc/examples/nullary_indexing.cpp index f710c84..38260af 100644 --- a/doc/examples/nullary_indexing.cpp +++ b/doc/examples/nullary_indexing.cpp
@@ -1,8 +1,6 @@ #include <Eigen/Core> #include <iostream> -using namespace Eigen; - // [functor] template<class ArgType, class RowIndexType, class ColIndexType> class indexing_functor { @@ -10,10 +8,10 @@ const RowIndexType &m_rowIndices; const ColIndexType &m_colIndices; public: - typedef Matrix<typename ArgType::Scalar, + typedef Eigen::Matrix<typename ArgType::Scalar, RowIndexType::SizeAtCompileTime, ColIndexType::SizeAtCompileTime, - ArgType::Flags&RowMajorBit?RowMajor:ColMajor, + ArgType::Flags&Eigen::RowMajorBit?Eigen::RowMajor:Eigen::ColMajor, RowIndexType::MaxSizeAtCompileTime, ColIndexType::MaxSizeAtCompileTime> MatrixType; @@ -21,7 +19,7 @@ : m_arg(arg), m_rowIndices(row_indices), m_colIndices(col_indices) {} - const typename ArgType::Scalar& operator() (Index row, Index col) const { + const typename ArgType::Scalar& operator() (Eigen::Index row, Eigen::Index col) const { return m_arg(m_rowIndices[row], m_colIndices[col]); } }; @@ -29,7 +27,7 @@ // [function] template <class ArgType, class RowIndexType, class ColIndexType> -CwiseNullaryOp<indexing_functor<ArgType,RowIndexType,ColIndexType>, typename indexing_functor<ArgType,RowIndexType,ColIndexType>::MatrixType> +Eigen::CwiseNullaryOp<indexing_functor<ArgType,RowIndexType,ColIndexType>, typename indexing_functor<ArgType,RowIndexType,ColIndexType>::MatrixType> mat_indexing(const Eigen::MatrixBase<ArgType>& arg, const RowIndexType& row_indices, const ColIndexType& col_indices) { typedef indexing_functor<ArgType,RowIndexType,ColIndexType> Func; @@ -43,8 +41,8 @@ { std::cout << "[main1]\n"; Eigen::MatrixXi A = Eigen::MatrixXi::Random(4,4); - Array3i ri(1,2,1); - ArrayXi ci(6); ci << 3,2,1,0,0,2; + Eigen::Array3i ri(1,2,1); + Eigen::ArrayXi ci(6); ci << 3,2,1,0,0,2; Eigen::MatrixXi B = mat_indexing(A, ri, ci); std::cout << "A =" << std::endl; std::cout << A << std::endl << std::endl; @@ -56,7 +54,7 @@ B = mat_indexing(A, ri+1, ci); std::cout << "A(ri+1,ci) =" << std::endl; std::cout << B << std::endl << std::endl; - B = mat_indexing(A, ArrayXi::LinSpaced(13,0,12).unaryExpr([](int x){return x%4;}), ArrayXi::LinSpaced(4,0,3)); + B = mat_indexing(A, Eigen::ArrayXi::LinSpaced(13,0,12).unaryExpr([](int x){return x%4;}), Eigen::ArrayXi::LinSpaced(4,0,3)); std::cout << "A(ArrayXi::LinSpaced(13,0,12).unaryExpr([](int x){return x%4;}), ArrayXi::LinSpaced(4,0,3)) =" << std::endl; std::cout << B << std::endl << std::endl; std::cout << "[main2]\n";
diff --git a/doc/examples/tut_arithmetic_add_sub.cpp b/doc/examples/tut_arithmetic_add_sub.cpp index e97477b..95162c0 100644 --- a/doc/examples/tut_arithmetic_add_sub.cpp +++ b/doc/examples/tut_arithmetic_add_sub.cpp
@@ -1,14 +1,12 @@ #include <iostream> #include <Eigen/Dense> -using namespace Eigen; - int main() { - Matrix2d a; + Eigen::Matrix2d a; a << 1, 2, 3, 4; - MatrixXd b(2,2); + Eigen::MatrixXd b(2,2); b << 2, 3, 1, 4; std::cout << "a + b =\n" << a + b << std::endl; @@ -16,7 +14,7 @@ std::cout << "Doing a += b;" << std::endl; a += b; std::cout << "Now a =\n" << a << std::endl; - Vector3d v(1,2,3); - Vector3d w(1,0,0); + Eigen::Vector3d v(1,2,3); + Eigen::Vector3d w(1,0,0); std::cout << "-v + w - v =\n" << -v + w - v << std::endl; }
diff --git a/doc/examples/tut_arithmetic_dot_cross.cpp b/doc/examples/tut_arithmetic_dot_cross.cpp index 631c9a5..5b0fd1e 100644 --- a/doc/examples/tut_arithmetic_dot_cross.cpp +++ b/doc/examples/tut_arithmetic_dot_cross.cpp
@@ -1,15 +1,13 @@ #include <iostream> #include <Eigen/Dense> -using namespace Eigen; -using namespace std; int main() { - Vector3d v(1,2,3); - Vector3d w(0,1,2); + Eigen::Vector3d v(1,2,3); + Eigen::Vector3d w(0,1,2); - cout << "Dot product: " << v.dot(w) << endl; + std::cout << "Dot product: " << v.dot(w) << std::endl; double dp = v.adjoint()*w; // automatic conversion of the inner product to a scalar - cout << "Dot product via a matrix product: " << dp << endl; - cout << "Cross product:\n" << v.cross(w) << endl; + std::cout << "Dot product via a matrix product: " << dp << std::endl; + std::cout << "Cross product:\n" << v.cross(w) << std::endl; }
diff --git a/doc/examples/tut_arithmetic_matrix_mul.cpp b/doc/examples/tut_arithmetic_matrix_mul.cpp index f213902..c2d5e2d 100644 --- a/doc/examples/tut_arithmetic_matrix_mul.cpp +++ b/doc/examples/tut_arithmetic_matrix_mul.cpp
@@ -1,13 +1,12 @@ #include <iostream> #include <Eigen/Dense> -using namespace Eigen; int main() { - Matrix2d mat; + Eigen::Matrix2d mat; mat << 1, 2, 3, 4; - Vector2d u(-1,1), v(2,0); + Eigen::Vector2d u(-1,1), v(2,0); std::cout << "Here is mat*mat:\n" << mat*mat << std::endl; std::cout << "Here is mat*u:\n" << mat*u << std::endl; std::cout << "Here is u^T*mat:\n" << u.transpose()*mat << std::endl;
diff --git a/doc/examples/tut_arithmetic_scalar_mul_div.cpp b/doc/examples/tut_arithmetic_scalar_mul_div.cpp index d5f65b5..0ba8d6b 100644 --- a/doc/examples/tut_arithmetic_scalar_mul_div.cpp +++ b/doc/examples/tut_arithmetic_scalar_mul_div.cpp
@@ -1,14 +1,12 @@ #include <iostream> #include <Eigen/Dense> -using namespace Eigen; - int main() { - Matrix2d a; + Eigen::Matrix2d a; a << 1, 2, 3, 4; - Vector3d v(1,2,3); + Eigen::Vector3d v(1,2,3); std::cout << "a * 2.5 =\n" << a * 2.5 << std::endl; std::cout << "0.1 * v =\n" << 0.1 * v << std::endl; std::cout << "Doing v *= 2;" << std::endl;
diff --git a/doc/examples/tut_matrix_coefficient_accessors.cpp b/doc/examples/tut_matrix_coefficient_accessors.cpp index c2da171..040087c 100644 --- a/doc/examples/tut_matrix_coefficient_accessors.cpp +++ b/doc/examples/tut_matrix_coefficient_accessors.cpp
@@ -1,17 +1,15 @@ #include <iostream> #include <Eigen/Dense> -using namespace Eigen; - int main() { - MatrixXd m(2,2); + Eigen::MatrixXd m(2,2); m(0,0) = 3; m(1,0) = 2.5; m(0,1) = -1; m(1,1) = m(1,0) + m(0,1); std::cout << "Here is the matrix m:\n" << m << std::endl; - VectorXd v(2); + Eigen::VectorXd v(2); v(0) = 4; v(1) = v(0) - 1; std::cout << "Here is the vector v:\n" << v << std::endl;
diff --git a/doc/examples/tut_matrix_resize.cpp b/doc/examples/tut_matrix_resize.cpp index 0392c3a..aa80cf5 100644 --- a/doc/examples/tut_matrix_resize.cpp +++ b/doc/examples/tut_matrix_resize.cpp
@@ -1,16 +1,14 @@ #include <iostream> #include <Eigen/Dense> -using namespace Eigen; - int main() { - MatrixXd m(2,5); + Eigen::MatrixXd m(2,5); m.resize(4,3); std::cout << "The matrix m is of size " << m.rows() << "x" << m.cols() << std::endl; std::cout << "It has " << m.size() << " coefficients" << std::endl; - VectorXd v(2); + Eigen::VectorXd v(2); v.resize(5); std::cout << "The vector v is of size " << v.size() << std::endl; std::cout << "As a matrix, v is of size "
diff --git a/doc/examples/tut_matrix_resize_fixed_size.cpp b/doc/examples/tut_matrix_resize_fixed_size.cpp index dcbdfa7..3df87d2 100644 --- a/doc/examples/tut_matrix_resize_fixed_size.cpp +++ b/doc/examples/tut_matrix_resize_fixed_size.cpp
@@ -1,11 +1,9 @@ #include <iostream> #include <Eigen/Dense> -using namespace Eigen; - int main() { - Matrix4d m; + Eigen::Matrix4d m; m.resize(4,4); // no operation std::cout << "The matrix m is of size " << m.rows() << "x" << m.cols() << std::endl;
diff --git a/doc/snippets/Slicing_arrayexpr.cpp b/doc/snippets/Slicing_arrayexpr.cpp index 2df8180..6d09980 100644 --- a/doc/snippets/Slicing_arrayexpr.cpp +++ b/doc/snippets/Slicing_arrayexpr.cpp
@@ -1,4 +1,4 @@ ArrayXi ind(5); ind<<4,2,5,5,3; MatrixXi A = MatrixXi::Random(4,6); cout << "Initial matrix A:\n" << A << "\n\n"; -cout << "A(all,ind-1):\n" << A(all,ind-1) << "\n\n"; +cout << "A(all,ind-1):\n" << A(Eigen::placeholders::all,ind-1) << "\n\n";
diff --git a/doc/snippets/Slicing_rawarray_cxx11.cpp b/doc/snippets/Slicing_rawarray_cxx11.cpp index 1087131..7a3e6e5 100644 --- a/doc/snippets/Slicing_rawarray_cxx11.cpp +++ b/doc/snippets/Slicing_rawarray_cxx11.cpp
@@ -1,5 +1,3 @@ -#if EIGEN_HAS_STATIC_ARRAY_TEMPLATE MatrixXi A = MatrixXi::Random(4,6); cout << "Initial matrix A:\n" << A << "\n\n"; -cout << "A(all,{4,2,5,5,3}):\n" << A(all,{4,2,5,5,3}) << "\n\n"; -#endif +cout << "A(all,{4,2,5,5,3}):\n" << A(Eigen::placeholders::all,{4,2,5,5,3}) << "\n\n";
diff --git a/doc/snippets/Slicing_stdvector_cxx11.cpp b/doc/snippets/Slicing_stdvector_cxx11.cpp index 555f662..74f0727 100644 --- a/doc/snippets/Slicing_stdvector_cxx11.cpp +++ b/doc/snippets/Slicing_stdvector_cxx11.cpp
@@ -1,4 +1,4 @@ std::vector<int> ind{4,2,5,5,3}; MatrixXi A = MatrixXi::Random(4,6); cout << "Initial matrix A:\n" << A << "\n\n"; -cout << "A(all,ind):\n" << A(all,ind) << "\n\n"; +cout << "A(all,ind):\n" << A(Eigen::placeholders::all,ind) << "\n\n";
diff --git a/doc/special_examples/random_cpp11.cpp b/doc/special_examples/random_cpp11.cpp index 33744c0..bd73800 100644 --- a/doc/special_examples/random_cpp11.cpp +++ b/doc/special_examples/random_cpp11.cpp
@@ -2,13 +2,11 @@ #include <iostream> #include <random> -using namespace Eigen; - int main() { std::default_random_engine generator; std::poisson_distribution<int> distribution(4.1); auto poisson = [&] () {return distribution(generator);}; - RowVectorXi v = RowVectorXi::NullaryExpr(10, poisson ); + Eigen::RowVectorXi v = Eigen::RowVectorXi::NullaryExpr(10, poisson ); std::cout << v << "\n"; }
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index ad09599..c41855a 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt
@@ -303,7 +303,7 @@ endif() endif() -ei_add_test(fastmath " ${EIGEN_FASTMATH_FLAGS} ") +ei_add_test(fastmath "${EIGEN_FASTMATH_FLAGS}") # # ei_add_test(denseLM)
diff --git a/test/dense_storage.cpp b/test/dense_storage.cpp index 826874c..398cb32 100644 --- a/test/dense_storage.cpp +++ b/test/dense_storage.cpp
@@ -13,7 +13,6 @@ #include <Eigen/Core> -#if EIGEN_HAS_TYPE_TRAITS using DenseStorageD3x3 = Eigen::DenseStorage<double, 3, 3, 3, 3>; static_assert(std::is_trivially_move_constructible<DenseStorageD3x3>::value, "DenseStorage not trivially_move_constructible"); static_assert(std::is_trivially_move_assignable<DenseStorageD3x3>::value, "DenseStorage not trivially_move_assignable"); @@ -22,7 +21,6 @@ static_assert(std::is_trivially_copy_assignable<DenseStorageD3x3>::value, "DenseStorage not trivially_copy_assignable"); static_assert(std::is_trivially_copyable<DenseStorageD3x3>::value, "DenseStorage not trivially_copyable"); #endif -#endif template <typename T, int Size, int Rows, int Cols> void dense_storage_copy(int rows, int cols) @@ -90,8 +88,6 @@ template<typename T, int Size, std::size_t Alignment> void dense_storage_alignment() { - #if EIGEN_HAS_ALIGNAS - struct alignas(Alignment) Empty1 {}; VERIFY_IS_EQUAL(std::alignment_of<Empty1>::value, Alignment); @@ -109,8 +105,6 @@ VERIFY_IS_EQUAL( (std::alignment_of<Matrix<T,Size,1,AutoAlign> >::value), default_alignment); struct Nested2 { Matrix<T,Size,1,AutoAlign> mat; }; VERIFY_IS_EQUAL(std::alignment_of<Nested2>::value, default_alignment); - - #endif } template<typename T>
diff --git a/test/householder.cpp b/test/householder.cpp index cad8138..29a6c1d 100644 --- a/test/householder.cpp +++ b/test/householder.cpp
@@ -30,7 +30,7 @@ typedef Matrix<Scalar, MatrixType::ColsAtCompileTime, MatrixType::RowsAtCompileTime> TMatrixType; - Matrix<Scalar, EIGEN_SIZE_MAX(MatrixType::RowsAtCompileTime,MatrixType::ColsAtCompileTime), 1> _tmp((std::max)(rows,cols)); + Matrix<Scalar, internal::max_size_prefer_dynamic(MatrixType::RowsAtCompileTime,MatrixType::ColsAtCompileTime), 1> _tmp((std::max)(rows,cols)); Scalar* tmp = &_tmp.coeffRef(0,0); Scalar beta;
diff --git a/test/indexed_view.cpp b/test/indexed_view.cpp index a3b336c..d8a5532 100644 --- a/test/indexed_view.cpp +++ b/test/indexed_view.cpp
@@ -7,11 +7,6 @@ // 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/. -#ifdef EIGEN_TEST_PART_2 -// Make sure we also check c++11 max implementation -#define EIGEN_MAX_CPP_VER 11 -#endif - #include <valarray> #include <vector> #include "main.h" @@ -84,11 +79,7 @@ ArrayXd a = ArrayXd::LinSpaced(n,0,n-1); Array<double,1,Dynamic> b = a.transpose(); - #if EIGEN_COMP_CXXVER>=14 ArrayXXi A = ArrayXXi::NullaryExpr(n,n, std::ref(encode)); - #else - ArrayXXi A = ArrayXXi::NullaryExpr(n,n, std::ptr_fun(&encode)); - #endif for(Index i=0; i<n; ++i) for(Index j=0; j<n; ++j) @@ -299,7 +290,6 @@ VERIFY_IS_APPROX( (A(std::array<int,3>{{1,3,5}}, std::array<int,4>{{9,6,3,0}})), A(seqN(1,3,2), seqN(9,4,-3)) ); -#if EIGEN_HAS_STATIC_ARRAY_TEMPLATE VERIFY_IS_APPROX( A({3, 1, 6, 5}, all), A(std::array<int,4>{{3, 1, 6, 5}}, all) ); VERIFY_IS_APPROX( A(all,{3, 1, 6, 5}), A(all,std::array<int,4>{{3, 1, 6, 5}}) ); VERIFY_IS_APPROX( A({1,3,5},{3, 1, 6, 5}), A(std::array<int,3>{{1,3,5}},std::array<int,4>{{3, 1, 6, 5}}) ); @@ -312,7 +302,6 @@ VERIFY_IS_APPROX( b({3, 1, 6, 5}), b(std::array<int,4>{{3, 1, 6, 5}}) ); VERIFY_IS_EQUAL( b({1,3,5}).SizeAtCompileTime, 3 ); -#endif // check mat(i,j) with weird types for i and j { @@ -438,7 +427,6 @@ { // for(int i = 0; i < g_repeat; i++) { CALL_SUBTEST_1( check_indexed_view() ); - CALL_SUBTEST_2( check_indexed_view() ); // } // static checks of some internals:
diff --git a/test/meta.cpp b/test/meta.cpp index 7a8b93c..d362c9f 100644 --- a/test/meta.cpp +++ b/test/meta.cpp
@@ -114,13 +114,7 @@ // So the following tests are expected to fail with recent compilers. STATIC_CHECK(( !internal::is_convertible<MyInterface, MyImpl>::value )); - #if (!EIGEN_COMP_GNUC_STRICT) || (EIGEN_GNUC_AT_LEAST(4,8)) - // GCC prior to 4.8 fails to compile this test: - // error: cannot allocate an object of abstract type 'MyInterface' - // In other word, it does not obey SFINAE. - // Nevertheless, we don't really care about supporting abstract type as scalar type! STATIC_CHECK(( !internal::is_convertible<MyImpl, MyInterface>::value )); - #endif STATIC_CHECK(( internal::is_convertible<MyImpl, const MyInterface&>::value )); #endif
diff --git a/test/packetmath.cpp b/test/packetmath.cpp index 0600ddb..fcdc2bb 100644 --- a/test/packetmath.cpp +++ b/test/packetmath.cpp
@@ -48,7 +48,7 @@ template <typename T> inline T REF_FREXP(const T& x, T& exp) { - int iexp; + int iexp = 0; EIGEN_USING_STD(frexp) const T out = static_cast<T>(frexp(x, &iexp)); exp = static_cast<T>(iexp); @@ -713,6 +713,7 @@ for (int i = 0; i < size; ++i) { data1[i] = Scalar(internal::random<double>(-87, 88)); data2[i] = Scalar(internal::random<double>(-87, 88)); + data1[0] = -NumTraits<Scalar>::infinity(); } CHECK_CWISE1_IF(PacketTraits::HasExp, std::exp, internal::pexp);
diff --git a/test/random_matrix.cpp b/test/random_matrix.cpp index fb877de..873845f 100644 --- a/test/random_matrix.cpp +++ b/test/random_matrix.cpp
@@ -82,7 +82,7 @@ enum { Rows = MatrixType::RowsAtCompileTime, Cols = MatrixType::ColsAtCompileTime, - DiagSize = EIGEN_SIZE_MIN_PREFER_DYNAMIC(Rows, Cols) + DiagSize = internal::min_size_prefer_dynamic(Rows, Cols) }; typedef typename MatrixType::Scalar Scalar; typedef typename NumTraits<Scalar>::Real RealScalar;
diff --git a/test/ref.cpp b/test/ref.cpp index 5e7a3b3..d840800 100644 --- a/test/ref.cpp +++ b/test/ref.cpp
@@ -21,7 +21,7 @@ // Deal with i387 extended precision #if EIGEN_ARCH_i386 && !(EIGEN_ARCH_x86_64) -#if EIGEN_COMP_GNUC_STRICT && EIGEN_GNUC_AT_LEAST(4,4) +#if EIGEN_COMP_GNUC_STRICT #pragma GCC optimize ("-ffloat-store") #else #undef VERIFY_IS_EQUAL
diff --git a/test/stl_iterators.cpp b/test/stl_iterators.cpp index 533a3fe..aab3be9 100644 --- a/test/stl_iterators.cpp +++ b/test/stl_iterators.cpp
@@ -452,10 +452,8 @@ using VecOp = VectorwiseOp<ArrayXXi, 0>; STATIC_CHECK(( internal::is_same<VecOp::const_iterator, decltype(std::declval<const VecOp&>().cbegin())>::value )); STATIC_CHECK(( internal::is_same<VecOp::const_iterator, decltype(std::declval<const VecOp&>().cend ())>::value )); - #if EIGEN_COMP_CXXVER>=14 - STATIC_CHECK(( internal::is_same<VecOp::const_iterator, decltype(std::cbegin(std::declval<const VecOp&>()))>::value )); - STATIC_CHECK(( internal::is_same<VecOp::const_iterator, decltype(std::cend (std::declval<const VecOp&>()))>::value )); - #endif + STATIC_CHECK(( internal::is_same<VecOp::const_iterator, decltype(std::cbegin(std::declval<const VecOp&>()))>::value )); + STATIC_CHECK(( internal::is_same<VecOp::const_iterator, decltype(std::cend (std::declval<const VecOp&>()))>::value )); } }
diff --git a/test/symbolic_index.cpp b/test/symbolic_index.cpp index 22ed00c..53eb55d 100644 --- a/test/symbolic_index.cpp +++ b/test/symbolic_index.cpp
@@ -60,7 +60,6 @@ VERIFY_IS_EQUAL( ( lastp1-3*last ).eval(last=size-1), size- 3*(size-1) ); VERIFY_IS_EQUAL( ( (lastp1-3*last)/lastp1 ).eval(last=size-1), (size- 3*(size-1))/size ); -#if EIGEN_HAS_CXX14_VARIABLE_TEMPLATES { struct x_tag {}; static const symbolic::SymbolExpr<x_tag> x; struct y_tag {}; static const symbolic::SymbolExpr<y_tag> y; @@ -68,7 +67,6 @@ VERIFY_IS_APPROX( int(((x+3)/y+z).eval(x=6,y=3,z=-13)), (6+3)/3+(-13) ); } -#endif } EIGEN_DECLARE_TEST(symbolic_index)
diff --git a/test/vectorization_logic.cpp b/test/vectorization_logic.cpp index 62d3f60..1c086cb 100644 --- a/test/vectorization_logic.cpp +++ b/test/vectorization_logic.cpp
@@ -245,11 +245,11 @@ >(InnerVectorizedTraversal,CompleteUnrolling))); VERIFY((test_assign< - Map<Matrix<Scalar,EIGEN_PLAIN_ENUM_MAX(2,PacketSize),EIGEN_PLAIN_ENUM_MAX(2,PacketSize)>, AlignedMax, InnerStride<3*PacketSize> >, - Matrix<Scalar,EIGEN_PLAIN_ENUM_MAX(2,PacketSize),EIGEN_PLAIN_ENUM_MAX(2,PacketSize)> + Map<Matrix<Scalar, internal::plain_enum_max(2,PacketSize), internal::plain_enum_max(2, PacketSize)>, AlignedMax, InnerStride<3*PacketSize> >, + Matrix<Scalar, internal::plain_enum_max(2, PacketSize), internal::plain_enum_max(2, PacketSize)> >(DefaultTraversal,PacketSize>=8?InnerUnrolling:CompleteUnrolling))); - VERIFY((test_assign(Matrix11(), Matrix<Scalar,PacketSize,EIGEN_PLAIN_ENUM_MIN(2,PacketSize)>()*Matrix<Scalar,EIGEN_PLAIN_ENUM_MIN(2,PacketSize),PacketSize>(), + VERIFY((test_assign(Matrix11(), Matrix<Scalar,PacketSize, internal::plain_enum_min(2, PacketSize)>()*Matrix<Scalar, internal::plain_enum_min(2, PacketSize),PacketSize>(), InnerVectorizedTraversal, CompleteUnrolling))); #endif @@ -407,8 +407,8 @@ } VERIFY((test_assign< - Map<Matrix<Scalar,EIGEN_PLAIN_ENUM_MAX(2,PacketSize),EIGEN_PLAIN_ENUM_MAX(2,PacketSize)>, AlignedMax, InnerStride<3*PacketSize> >, - Matrix<Scalar,EIGEN_PLAIN_ENUM_MAX(2,PacketSize),EIGEN_PLAIN_ENUM_MAX(2,PacketSize)> + Map<Matrix<Scalar, plain_enum_max(2,PacketSize), plain_enum_max(2,PacketSize)>, AlignedMax, InnerStride<3*PacketSize> >, + Matrix<Scalar, plain_enum_max(2,PacketSize), plain_enum_max(2,PacketSize)> >(DefaultTraversal,PacketSize>4?InnerUnrolling:CompleteUnrolling))); VERIFY((test_assign(Matrix57(), Matrix<Scalar,5*PacketSize,3>()*Matrix<Scalar,3,7>(),
diff --git a/unsupported/Eigen/CXX11/src/Tensor/Tensor.h b/unsupported/Eigen/CXX11/src/Tensor/Tensor.h index 5a14c71..a3c8c48 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/Tensor.h +++ b/unsupported/Eigen/CXX11/src/Tensor/Tensor.h
@@ -89,14 +89,12 @@ protected: TensorStorage<Scalar, Dimensions, Options> m_storage; -#ifdef EIGEN_HAS_SFINAE template<typename CustomIndices> struct isOfNormalIndex{ static const bool is_array = internal::is_base_of<array<Index, NumIndices>, CustomIndices>::value; static const bool is_int = NumTraits<CustomIndices>::IsInteger; static const bool value = is_array | is_int; }; -#endif public: // Metadata @@ -113,7 +111,6 @@ inline Self& base() { return *this; } inline const Self& base() const { return *this; } -#if EIGEN_HAS_VARIADIC_TEMPLATES template<typename... IndexTypes> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff(Index firstIndex, Index secondIndex, IndexTypes... otherIndices) const { @@ -121,7 +118,6 @@ EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 2 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE) return coeff(array<Index, NumIndices>{{firstIndex, secondIndex, otherIndices...}}); } -#endif // normal indices EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff(const array<Index, NumIndices>& indices) const @@ -131,7 +127,6 @@ } // custom indices -#ifdef EIGEN_HAS_SFINAE template<typename CustomIndices, EIGEN_SFINAE_ENABLE_IF( !(isOfNormalIndex<CustomIndices>::value) ) > @@ -139,7 +134,6 @@ { return coeff(internal::customIndices2Array<Index,NumIndices>(indices)); } -#endif EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff() const { @@ -153,7 +147,6 @@ return m_storage.data()[index]; } -#if EIGEN_HAS_VARIADIC_TEMPLATES template<typename... IndexTypes> inline Scalar& coeffRef(Index firstIndex, Index secondIndex, IndexTypes... otherIndices) { @@ -161,7 +154,6 @@ EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 2 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE) return coeffRef(array<Index, NumIndices>{{firstIndex, secondIndex, otherIndices...}}); } -#endif // normal indices EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(const array<Index, NumIndices>& indices) @@ -171,7 +163,6 @@ } // custom indices -#ifdef EIGEN_HAS_SFINAE template<typename CustomIndices, EIGEN_SFINAE_ENABLE_IF( !(isOfNormalIndex<CustomIndices>::value) ) > @@ -179,7 +170,6 @@ { return coeffRef(internal::customIndices2Array<Index,NumIndices>(indices)); } -#endif EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef() { @@ -193,7 +183,6 @@ return m_storage.data()[index]; } -#if EIGEN_HAS_VARIADIC_TEMPLATES template<typename... IndexTypes> inline const Scalar& operator()(Index firstIndex, Index secondIndex, IndexTypes... otherIndices) const { @@ -201,31 +190,8 @@ EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 2 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE) return this->operator()(array<Index, NumIndices>{{firstIndex, secondIndex, otherIndices...}}); } -#else - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE const Scalar& operator()(Index i0, Index i1) const - { - return coeff(array<Index, 2>(i0, i1)); - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE const Scalar& operator()(Index i0, Index i1, Index i2) const - { - return coeff(array<Index, 3>(i0, i1, i2)); - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE const Scalar& operator()(Index i0, Index i1, Index i2, Index i3) const - { - return coeff(array<Index, 4>(i0, i1, i2, i3)); - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE const Scalar& operator()(Index i0, Index i1, Index i2, Index i3, Index i4) const - { - return coeff(array<Index, 5>(i0, i1, i2, i3, i4)); - } -#endif // custom indices -#ifdef EIGEN_HAS_SFINAE template<typename CustomIndices, EIGEN_SFINAE_ENABLE_IF( !(isOfNormalIndex<CustomIndices>::value) ) > @@ -233,7 +199,6 @@ { return coeff(internal::customIndices2Array<Index,NumIndices>(indices)); } -#endif // normal indices EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator()(const array<Index, NumIndices>& indices) const @@ -260,7 +225,6 @@ return coeff(index); } -#if EIGEN_HAS_VARIADIC_TEMPLATES template<typename... IndexTypes> inline Scalar& operator()(Index firstIndex, Index secondIndex, IndexTypes... otherIndices) { @@ -268,28 +232,6 @@ EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 2 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE) return operator()(array<Index, NumIndices>{{firstIndex, secondIndex, otherIndices...}}); } -#else - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE Scalar& operator()(Index i0, Index i1) - { - return coeffRef(array<Index, 2>(i0, i1)); - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE Scalar& operator()(Index i0, Index i1, Index i2) - { - return coeffRef(array<Index, 3>(i0, i1, i2)); - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE Scalar& operator()(Index i0, Index i1, Index i2, Index i3) - { - return coeffRef(array<Index, 4>(i0, i1, i2, i3)); - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE Scalar& operator()(Index i0, Index i1, Index i2, Index i3, Index i4) - { - return coeffRef(array<Index, 5>(i0, i1, i2, i3, i4)); - } -#endif // normal indices EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()(const array<Index, NumIndices>& indices) @@ -298,7 +240,6 @@ } // custom indices -#ifdef EIGEN_HAS_SFINAE template<typename CustomIndices, EIGEN_SFINAE_ENABLE_IF( !(isOfNormalIndex<CustomIndices>::value) ) > @@ -306,7 +247,6 @@ { return coeffRef(internal::customIndices2Array<Index,NumIndices>(indices)); } -#endif EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()(Index index) { @@ -339,7 +279,6 @@ { } -#if EIGEN_HAS_VARIADIC_TEMPLATES template<typename... IndexTypes> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor(Index firstDimension, IndexTypes... otherDimensions) : m_storage(firstDimension, otherDimensions...) @@ -347,33 +286,6 @@ // The number of dimensions used to construct a tensor must be equal to the rank of the tensor. EIGEN_STATIC_ASSERT(sizeof...(otherDimensions) + 1 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE) } -#else - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit Tensor(Index dim1) - : m_storage(dim1, array<Index, 1>(dim1)) - { - EIGEN_STATIC_ASSERT(1 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE) - } - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor(Index dim1, Index dim2) - : m_storage(dim1*dim2, array<Index, 2>(dim1, dim2)) - { - EIGEN_STATIC_ASSERT(2 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE) - } - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor(Index dim1, Index dim2, Index dim3) - : m_storage(dim1*dim2*dim3, array<Index, 3>(dim1, dim2, dim3)) - { - EIGEN_STATIC_ASSERT(3 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE) - } - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor(Index dim1, Index dim2, Index dim3, Index dim4) - : m_storage(dim1*dim2*dim3*dim4, array<Index, 4>(dim1, dim2, dim3, dim4)) - { - EIGEN_STATIC_ASSERT(4 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE) - } - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Tensor(Index dim1, Index dim2, Index dim3, Index dim4, Index dim5) - : m_storage(dim1*dim2*dim3*dim4*dim5, array<Index, 5>(dim1, dim2, dim3, dim4, dim5)) - { - EIGEN_STATIC_ASSERT(5 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE) - } -#endif /** Normal Dimension */ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit Tensor(const array<Index, NumIndices>& dimensions) @@ -434,7 +346,6 @@ return *this; } -#if EIGEN_HAS_VARIADIC_TEMPLATES template<typename... IndexTypes> EIGEN_DEVICE_FUNC void resize(Index firstDimension, IndexTypes... otherDimensions) { @@ -442,7 +353,6 @@ EIGEN_STATIC_ASSERT(sizeof...(otherDimensions) + 1 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE) resize(array<Index, NumIndices>{{firstDimension, otherDimensions...}}); } -#endif /** Normal Dimension */ EIGEN_DEVICE_FUNC void resize(const array<Index, NumIndices>& dimensions) @@ -491,7 +401,6 @@ #endif /** Custom Dimension */ -#ifdef EIGEN_HAS_SFINAE template<typename CustomDimension, EIGEN_SFINAE_ENABLE_IF( !(isOfNormalIndex<CustomDimension>::value) ) > @@ -499,7 +408,6 @@ { resize(internal::customIndices2Array<Index,NumIndices>(dimensions)); } -#endif #ifndef EIGEN_EMULATE_CXX11_META_H template <typename std::ptrdiff_t... Indices>
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorBase.h b/unsupported/Eigen/CXX11/src/Tensor/TensorBase.h index 9c356f4..945e9fc 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorBase.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorBase.h
@@ -1012,7 +1012,6 @@ return derived() = this->template random<RandomGenerator>(); } -#if EIGEN_HAS_VARIADIC_TEMPLATES EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& setValues( const typename internal::Initializer<Derived, NumDimensions>::InitList& vals) { @@ -1020,7 +1019,6 @@ internal::initialize_tensor<Derived, NumDimensions>(eval, vals); return derived(); } -#endif // EIGEN_HAS_VARIADIC_TEMPLATES template<typename OtherDerived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Derived& operator+=(const OtherDerived& other) {
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h b/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h index 6fc2aa8..84ae848 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h
@@ -111,12 +111,10 @@ explicit EIGEN_DEVICE_FUNC Sizes(const array<DenseIndex, Base::count>& /*indices*/) { // todo: add assertion } -#if EIGEN_HAS_VARIADIC_TEMPLATES template <typename... DenseIndex> EIGEN_DEVICE_FUNC Sizes(DenseIndex...) { } explicit EIGEN_DEVICE_FUNC Sizes(std::initializer_list<std::ptrdiff_t> /*l*/) { // todo: add assertion } -#endif template <typename T> Sizes& operator = (const T& /*other*/) { // add assertion failure if the size of other is different @@ -173,28 +171,16 @@ explicit Sizes(const array<DenseIndex, Base::count>& /*indices*/) { // todo: add assertion } + template <typename T> Sizes& operator = (const T& /*other*/) { // add assertion failure if the size of other is different return *this; } -#if EIGEN_HAS_VARIADIC_TEMPLATES template <typename... DenseIndex> Sizes(DenseIndex... /*indices*/) { } explicit Sizes(std::initializer_list<std::ptrdiff_t>) { // todo: add assertion } -#else - EIGEN_DEVICE_FUNC explicit Sizes(const DenseIndex) { - } - EIGEN_DEVICE_FUNC Sizes(const DenseIndex, const DenseIndex) { - } - EIGEN_DEVICE_FUNC Sizes(const DenseIndex, const DenseIndex, const DenseIndex) { - } - EIGEN_DEVICE_FUNC Sizes(const DenseIndex, const DenseIndex, const DenseIndex, const DenseIndex) { - } - EIGEN_DEVICE_FUNC Sizes(const DenseIndex, const DenseIndex, const DenseIndex, const DenseIndex, const DenseIndex) { - } -#endif EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index operator[] (const Index index) const { switch (index) { @@ -337,39 +323,10 @@ } #endif -#if EIGEN_HAS_VARIADIC_TEMPLATES template<typename... IndexTypes> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit DSizes(DenseIndex firstDimension, DenseIndex secondDimension, IndexTypes... otherDimensions) : Base({{firstDimension, secondDimension, otherDimensions...}}) { EIGEN_STATIC_ASSERT(sizeof...(otherDimensions) + 2 == NumDims, YOU_MADE_A_PROGRAMMING_MISTAKE) } -#else - EIGEN_DEVICE_FUNC DSizes(const DenseIndex i0, const DenseIndex i1) { - eigen_assert(NumDims == 2); - (*this)[0] = i0; - (*this)[1] = i1; - } - EIGEN_DEVICE_FUNC DSizes(const DenseIndex i0, const DenseIndex i1, const DenseIndex i2) { - eigen_assert(NumDims == 3); - (*this)[0] = i0; - (*this)[1] = i1; - (*this)[2] = i2; - } - EIGEN_DEVICE_FUNC DSizes(const DenseIndex i0, const DenseIndex i1, const DenseIndex i2, const DenseIndex i3) { - eigen_assert(NumDims == 4); - (*this)[0] = i0; - (*this)[1] = i1; - (*this)[2] = i2; - (*this)[3] = i3; - } - EIGEN_DEVICE_FUNC DSizes(const DenseIndex i0, const DenseIndex i1, const DenseIndex i2, const DenseIndex i3, const DenseIndex i4) { - eigen_assert(NumDims == 5); - (*this)[0] = i0; - (*this)[1] = i1; - (*this)[2] = i2; - (*this)[3] = i3; - (*this)[4] = i4; - } -#endif EIGEN_DEVICE_FUNC DSizes& operator = (const array<DenseIndex, NumDims>& other) { *static_cast<Base*>(this) = other;
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorFixedSize.h b/unsupported/Eigen/CXX11/src/Tensor/TensorFixedSize.h index 6b11b79..fe2d7c0 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorFixedSize.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorFixedSize.h
@@ -74,7 +74,6 @@ inline Self& base() { return *this; } inline const Self& base() const { return *this; } -#if EIGEN_HAS_VARIADIC_TEMPLATES template<typename... IndexTypes> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff(Index firstIndex, IndexTypes... otherIndices) const { @@ -82,7 +81,6 @@ EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 1 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE) return coeff(array<Index, NumIndices>{{firstIndex, otherIndices...}}); } -#endif EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& coeff(const array<Index, NumIndices>& indices) const @@ -106,7 +104,6 @@ } -#if EIGEN_HAS_VARIADIC_TEMPLATES template<typename... IndexTypes> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index firstIndex, IndexTypes... otherIndices) { @@ -114,7 +111,6 @@ EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 1 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE) return coeffRef(array<Index, NumIndices>{{firstIndex, otherIndices...}}); } -#endif EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(const array<Index, NumIndices>& indices) @@ -137,7 +133,6 @@ return m_storage.data()[0]; } -#if EIGEN_HAS_VARIADIC_TEMPLATES template<typename... IndexTypes> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator()(Index firstIndex, IndexTypes... otherIndices) const { @@ -145,53 +140,6 @@ EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 1 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE) return this->operator()(array<Index, NumIndices>{{firstIndex, otherIndices...}}); } -#else - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE const Scalar& operator()(Index i0, Index i1) const - { - if (Options&RowMajor) { - const Index index = i1 + i0 * m_storage.dimensions()[1]; - return m_storage.data()[index]; - } else { - const Index index = i0 + i1 * m_storage.dimensions()[0]; - return m_storage.data()[index]; - } - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE const Scalar& operator()(Index i0, Index i1, Index i2) const - { - if (Options&RowMajor) { - const Index index = i2 + m_storage.dimensions()[2] * (i1 + m_storage.dimensions()[1] * i0); - return m_storage.data()[index]; - } else { - const Index index = i0 + m_storage.dimensions()[0] * (i1 + m_storage.dimensions()[1] * i2); - return m_storage.data()[index]; - } - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE const Scalar& operator()(Index i0, Index i1, Index i2, Index i3) const - { - if (Options&RowMajor) { - const Index index = i3 + m_storage.dimensions()[3] * (i2 + m_storage.dimensions()[2] * (i1 + m_storage.dimensions()[1] * i0)); - return m_storage.data()[index]; - } else { - const Index index = i0 + m_storage.dimensions()[0] * (i1 + m_storage.dimensions()[1] * (i2 + m_storage.dimensions()[2] * i3)); - return m_storage.data()[index]; - } - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE const Scalar& operator()(Index i0, Index i1, Index i2, Index i3, Index i4) const - { - if (Options&RowMajor) { - const Index index = i4 + m_storage.dimensions()[4] * (i3 + m_storage.dimensions()[3] * (i2 + m_storage.dimensions()[2] * (i1 + m_storage.dimensions()[1] * i0))); - return m_storage.data()[index]; - } else { - const Index index = i0 + m_storage.dimensions()[0] * (i1 + m_storage.dimensions()[1] * (i2 + m_storage.dimensions()[2] * (i3 + m_storage.dimensions()[3] * i4))); - return m_storage.data()[index]; - } - } -#endif - EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar& operator()(const array<Index, NumIndices>& indices) const @@ -222,7 +170,6 @@ return coeff(index); } -#if EIGEN_HAS_VARIADIC_TEMPLATES template<typename... IndexTypes> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()(Index firstIndex, IndexTypes... otherIndices) { @@ -230,52 +177,6 @@ EIGEN_STATIC_ASSERT(sizeof...(otherIndices) + 1 == NumIndices, YOU_MADE_A_PROGRAMMING_MISTAKE) return operator()(array<Index, NumIndices>{{firstIndex, otherIndices...}}); } -#else - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE Scalar& operator()(Index i0, Index i1) - { - if (Options&RowMajor) { - const Index index = i1 + i0 * m_storage.dimensions()[1]; - return m_storage.data()[index]; - } else { - const Index index = i0 + i1 * m_storage.dimensions()[0]; - return m_storage.data()[index]; - } - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE Scalar& operator()(Index i0, Index i1, Index i2) - { - if (Options&RowMajor) { - const Index index = i2 + m_storage.dimensions()[2] * (i1 + m_storage.dimensions()[1] * i0); - return m_storage.data()[index]; - } else { - const Index index = i0 + m_storage.dimensions()[0] * (i1 + m_storage.dimensions()[1] * i2); - return m_storage.data()[index]; - } - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE Scalar& operator()(Index i0, Index i1, Index i2, Index i3) - { - if (Options&RowMajor) { - const Index index = i3 + m_storage.dimensions()[3] * (i2 + m_storage.dimensions()[2] * (i1 + m_storage.dimensions()[1] * i0)); - return m_storage.data()[index]; - } else { - const Index index = i0 + m_storage.dimensions()[0] * (i1 + m_storage.dimensions()[1] * (i2 + m_storage.dimensions()[2] * i3)); - return m_storage.data()[index]; - } - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE Scalar& operator()(Index i0, Index i1, Index i2, Index i3, Index i4) - { - if (Options&RowMajor) { - const Index index = i4 + m_storage.dimensions()[4] * (i3 + m_storage.dimensions()[3] * (i2 + m_storage.dimensions()[2] * (i1 + m_storage.dimensions()[1] * i0))); - return m_storage.data()[index]; - } else { - const Index index = i0 + m_storage.dimensions()[0] * (i1 + m_storage.dimensions()[1] * (i2 + m_storage.dimensions()[2] * (i3 + m_storage.dimensions()[3] * i4))); - return m_storage.data()[index]; - } - } -#endif EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& operator()(const array<Index, NumIndices>& indices)
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorIndexList.h b/unsupported/Eigen/CXX11/src/Tensor/TensorIndexList.h index 170fc6a..e5030e9 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorIndexList.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorIndexList.h
@@ -12,7 +12,7 @@ #include "./InternalHeaderCheck.h" -#if EIGEN_HAS_CONSTEXPR && EIGEN_HAS_VARIADIC_TEMPLATES +#if EIGEN_HAS_CONSTEXPR #define EIGEN_HAS_INDEX_LIST
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorInitializer.h b/unsupported/Eigen/CXX11/src/Tensor/TensorInitializer.h index fc177a8..d8d977c 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorInitializer.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorInitializer.h
@@ -10,8 +10,6 @@ #ifndef EIGEN_CXX11_TENSOR_TENSOR_INITIALIZER_H #define EIGEN_CXX11_TENSOR_TENSOR_INITIALIZER_H -#if EIGEN_HAS_VARIADIC_TEMPLATES - #include <initializer_list> #include "./InternalHeaderCheck.h" @@ -79,6 +77,4 @@ } // namespace internal } // namespace Eigen -#endif // EIGEN_HAS_VARIADIC_TEMPLATES - #endif // EIGEN_CXX11_TENSOR_TENSOR_INITIALIZER_H
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorMacros.h b/unsupported/Eigen/CXX11/src/Tensor/TensorMacros.h index 73ff3d2..f7cd827 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorMacros.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorMacros.h
@@ -26,20 +26,6 @@ * void foo(){} */ -// SFINAE requires variadic templates -#if !defined(EIGEN_GPUCC) -#if EIGEN_HAS_VARIADIC_TEMPLATES - // SFINAE doesn't work for gcc <= 4.7 - #ifdef EIGEN_COMP_GNUC - #if EIGEN_GNUC_AT_LEAST(4,8) - #define EIGEN_HAS_SFINAE - #endif - #else - #define EIGEN_HAS_SFINAE - #endif -#endif -#endif - #define EIGEN_SFINAE_ENABLE_IF( __condition__ ) \ typename internal::enable_if< ( __condition__ ) , int >::type = 0
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorMap.h b/unsupported/Eigen/CXX11/src/Tensor/TensorMap.h index 85dade6..7a2bad4 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorMap.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorMap.h
@@ -84,35 +84,11 @@ EIGEN_STATIC_ASSERT((0 == NumIndices || NumIndices == Dynamic), YOU_MADE_A_PROGRAMMING_MISTAKE) } -#if EIGEN_HAS_VARIADIC_TEMPLATES template<typename... IndexTypes> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorMap(StoragePointerType dataPtr, Index firstDimension, IndexTypes... otherDimensions) : m_data(dataPtr), m_dimensions(firstDimension, otherDimensions...) { // The number of dimensions used to construct a tensor must be equal to the rank of the tensor. EIGEN_STATIC_ASSERT((sizeof...(otherDimensions) + 1 == NumIndices || NumIndices == Dynamic), YOU_MADE_A_PROGRAMMING_MISTAKE) } -#else - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE TensorMap(StoragePointerType dataPtr, Index firstDimension) : m_data(dataPtr), m_dimensions(firstDimension) { - // The number of dimensions used to construct a tensor must be equal to the rank of the tensor. - EIGEN_STATIC_ASSERT((1 == NumIndices || NumIndices == Dynamic), YOU_MADE_A_PROGRAMMING_MISTAKE) - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE TensorMap(StoragePointerType dataPtr, Index dim1, Index dim2) : m_data(dataPtr), m_dimensions(dim1, dim2) { - EIGEN_STATIC_ASSERT(2 == NumIndices || NumIndices == Dynamic, YOU_MADE_A_PROGRAMMING_MISTAKE) - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE TensorMap(StoragePointerType dataPtr, Index dim1, Index dim2, Index dim3) : m_data(dataPtr), m_dimensions(dim1, dim2, dim3) { - EIGEN_STATIC_ASSERT(3 == NumIndices || NumIndices == Dynamic, YOU_MADE_A_PROGRAMMING_MISTAKE) - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE TensorMap(StoragePointerType dataPtr, Index dim1, Index dim2, Index dim3, Index dim4) : m_data(dataPtr), m_dimensions(dim1, dim2, dim3, dim4) { - EIGEN_STATIC_ASSERT(4 == NumIndices || NumIndices == Dynamic, YOU_MADE_A_PROGRAMMING_MISTAKE) - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE TensorMap(StoragePointerType dataPtr, Index dim1, Index dim2, Index dim3, Index dim4, Index dim5) : m_data(dataPtr), m_dimensions(dim1, dim2, dim3, dim4, dim5) { - EIGEN_STATIC_ASSERT(5 == NumIndices || NumIndices == Dynamic, YOU_MADE_A_PROGRAMMING_MISTAKE) - } -#endif EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorMap(StoragePointerType dataPtr, const array<Index, NumIndices>& dimensions) : m_data(dataPtr), m_dimensions(dimensions) @@ -167,7 +143,6 @@ return m_data[index]; } -#if EIGEN_HAS_VARIADIC_TEMPLATES template<typename... IndexTypes> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StorageRefType operator()(Index firstIndex, Index secondIndex, IndexTypes... otherIndices) const { @@ -181,52 +156,6 @@ return m_data[index]; } } -#else - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE StorageRefType operator()(Index i0, Index i1) const - { - if (PlainObjectType::Options&RowMajor) { - const Index index = i1 + i0 * m_dimensions[1]; - return m_data[index]; - } else { - const Index index = i0 + i1 * m_dimensions[0]; - return m_data[index]; - } - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE StorageRefType operator()(Index i0, Index i1, Index i2) const - { - if (PlainObjectType::Options&RowMajor) { - const Index index = i2 + m_dimensions[2] * (i1 + m_dimensions[1] * i0); - return m_data[index]; - } else { - const Index index = i0 + m_dimensions[0] * (i1 + m_dimensions[1] * i2); - return m_data[index]; - } - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE StorageRefType operator()(Index i0, Index i1, Index i2, Index i3) const - { - if (PlainObjectType::Options&RowMajor) { - const Index index = i3 + m_dimensions[3] * (i2 + m_dimensions[2] * (i1 + m_dimensions[1] * i0)); - return m_data[index]; - } else { - const Index index = i0 + m_dimensions[0] * (i1 + m_dimensions[1] * (i2 + m_dimensions[2] * i3)); - return m_data[index]; - } - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE StorageRefType operator()(Index i0, Index i1, Index i2, Index i3, Index i4) const - { - if (PlainObjectType::Options&RowMajor) { - const Index index = i4 + m_dimensions[4] * (i3 + m_dimensions[3] * (i2 + m_dimensions[2] * (i1 + m_dimensions[1] * i0))); - return m_data[index]; - } else { - const Index index = i0 + m_dimensions[0] * (i1 + m_dimensions[1] * (i2 + m_dimensions[2] * (i3 + m_dimensions[3] * i4))); - return m_data[index]; - } - } -#endif EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StorageRefType operator()(const array<Index, NumIndices>& indices) @@ -255,7 +184,6 @@ return m_data[index]; } -#if EIGEN_HAS_VARIADIC_TEMPLATES template<typename... IndexTypes> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE StorageRefType operator()(Index firstIndex, Index secondIndex, IndexTypes... otherIndices) { @@ -270,52 +198,6 @@ return m_data[index]; } } -#else - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE StorageRefType operator()(Index i0, Index i1) - { - if (PlainObjectType::Options&RowMajor) { - const Index index = i1 + i0 * m_dimensions[1]; - return m_data[index]; - } else { - const Index index = i0 + i1 * m_dimensions[0]; - return m_data[index]; - } - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE StorageRefType operator()(Index i0, Index i1, Index i2) - { - if (PlainObjectType::Options&RowMajor) { - const Index index = i2 + m_dimensions[2] * (i1 + m_dimensions[1] * i0); - return m_data[index]; - } else { - const Index index = i0 + m_dimensions[0] * (i1 + m_dimensions[1] * i2); - return m_data[index]; - } - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE StorageRefType operator()(Index i0, Index i1, Index i2, Index i3) - { - if (PlainObjectType::Options&RowMajor) { - const Index index = i3 + m_dimensions[3] * (i2 + m_dimensions[2] * (i1 + m_dimensions[1] * i0)); - return m_data[index]; - } else { - const Index index = i0 + m_dimensions[0] * (i1 + m_dimensions[1] * (i2 + m_dimensions[2] * i3)); - return m_data[index]; - } - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE StorageRefType operator()(Index i0, Index i1, Index i2, Index i3, Index i4) - { - if (PlainObjectType::Options&RowMajor) { - const Index index = i4 + m_dimensions[4] * (i3 + m_dimensions[3] * (i2 + m_dimensions[2] * (i1 + m_dimensions[1] * i0))); - return m_data[index]; - } else { - const Index index = i0 + m_dimensions[0] * (i1 + m_dimensions[1] * (i2 + m_dimensions[2] * (i3 + m_dimensions[3] * i4))); - return m_data[index]; - } - } -#endif EIGEN_TENSOR_INHERIT_ASSIGNMENT_OPERATORS(TensorMap)
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorMeta.h b/unsupported/Eigen/CXX11/src/Tensor/TensorMeta.h index cf891eb..8b107eb 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorMeta.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorMeta.h
@@ -264,13 +264,12 @@ }; -#ifdef EIGEN_HAS_SFINAE namespace internal { - template<typename IndexType, typename Index, Index... Is> + template<typename IndexType, typename Index, Index First, Index... Is> EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE - array<Index, sizeof...(Is)> customIndices2Array(IndexType& idx, numeric_list<Index, Is...>) { - return { idx[Is]... }; + array<Index, 1 + sizeof...(Is)> customIndices2Array(IndexType& idx, numeric_list<Index, First, Is...>) { + return { idx[First], idx[Is]... }; } template<typename IndexType, typename Index> EIGEN_CONSTEXPR EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE @@ -308,9 +307,6 @@ }; } -#endif - - } // namespace Eigen
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorReduction.h b/unsupported/Eigen/CXX11/src/Tensor/TensorReduction.h index 2939b98..0342528 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorReduction.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorReduction.h
@@ -108,7 +108,7 @@ static const bool value = false; }; -#if EIGEN_HAS_CONSTEXPR && EIGEN_HAS_VARIADIC_TEMPLATES +#if EIGEN_HAS_CONSTEXPR template <typename ReducedDims, int NumTensorDims> struct are_inner_most_dims<ReducedDims, NumTensorDims, ColMajor>{ static const bool tmp1 = indices_statically_known_to_increase<ReducedDims>();
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorRef.h b/unsupported/Eigen/CXX11/src/Tensor/TensorRef.h index a2e1af7..67631d2 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorRef.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorRef.h
@@ -206,7 +206,6 @@ return m_evaluator->coeff(index); } -#if EIGEN_HAS_VARIADIC_TEMPLATES template<typename... IndexTypes> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(Index firstIndex, IndexTypes... otherIndices) const { @@ -221,85 +220,6 @@ const array<Index, num_indices> indices{{firstIndex, otherIndices...}}; return coeffRef(indices); } -#else - - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE const Scalar operator()(Index i0, Index i1) const - { - array<Index, 2> indices; - indices[0] = i0; - indices[1] = i1; - return coeff(indices); - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE const Scalar operator()(Index i0, Index i1, Index i2) const - { - array<Index, 3> indices; - indices[0] = i0; - indices[1] = i1; - indices[2] = i2; - return coeff(indices); - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE const Scalar operator()(Index i0, Index i1, Index i2, Index i3) const - { - array<Index, 4> indices; - indices[0] = i0; - indices[1] = i1; - indices[2] = i2; - indices[3] = i3; - return coeff(indices); - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE const Scalar operator()(Index i0, Index i1, Index i2, Index i3, Index i4) const - { - array<Index, 5> indices; - indices[0] = i0; - indices[1] = i1; - indices[2] = i2; - indices[3] = i3; - indices[4] = i4; - return coeff(indices); - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE Scalar& coeffRef(Index i0, Index i1) - { - array<Index, 2> indices; - indices[0] = i0; - indices[1] = i1; - return coeffRef(indices); - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE Scalar& coeffRef(Index i0, Index i1, Index i2) - { - array<Index, 3> indices; - indices[0] = i0; - indices[1] = i1; - indices[2] = i2; - return coeffRef(indices); - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE Scalar& operator()(Index i0, Index i1, Index i2, Index i3) - { - array<Index, 4> indices; - indices[0] = i0; - indices[1] = i1; - indices[2] = i2; - indices[3] = i3; - return coeffRef(indices); - } - EIGEN_DEVICE_FUNC - EIGEN_STRONG_INLINE Scalar& coeffRef(Index i0, Index i1, Index i2, Index i3, Index i4) - { - array<Index, 5> indices; - indices[0] = i0; - indices[1] = i1; - indices[2] = i2; - indices[3] = i3; - indices[4] = i4; - return coeffRef(indices); - } -#endif template <std::size_t NumIndices> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar coeff(const array<Index, NumIndices>& indices) const
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorStorage.h b/unsupported/Eigen/CXX11/src/Tensor/TensorStorage.h index 2dff543..e79cddf 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorStorage.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorStorage.h
@@ -88,12 +88,10 @@ : m_data(internal::conditional_aligned_new_auto<T,(Options_&DontAlign)==0>(size)), m_dimensions(dimensions) { EIGEN_INTERNAL_TENSOR_STORAGE_CTOR_PLUGIN } -#if EIGEN_HAS_VARIADIC_TEMPLATES template <typename... DenseIndex> EIGEN_DEVICE_FUNC TensorStorage(DenseIndex... indices) : m_dimensions(indices...) { m_data = internal::conditional_aligned_new_auto<T,(Options_&DontAlign)==0>(internal::array_prod(m_dimensions)); } -#endif EIGEN_DEVICE_FUNC TensorStorage(const Self& other) : m_data(internal::conditional_aligned_new_auto<T,(Options_&DontAlign)==0>(internal::array_prod(other.m_dimensions)))
diff --git a/unsupported/Eigen/CXX11/src/ThreadPool/ThreadLocal.h b/unsupported/Eigen/CXX11/src/ThreadPool/ThreadLocal.h index 6bb67e4..4545119 100644 --- a/unsupported/Eigen/CXX11/src/ThreadPool/ThreadLocal.h +++ b/unsupported/Eigen/CXX11/src/ThreadPool/ThreadLocal.h
@@ -18,9 +18,7 @@ #else -#if ((EIGEN_COMP_GNUC && EIGEN_GNUC_AT_LEAST(4, 8)) || \ - __has_feature(cxx_thread_local) || \ - (EIGEN_COMP_MSVC >= 1900) ) +#if ((EIGEN_COMP_GNUC) || __has_feature(cxx_thread_local) || EIGEN_COMP_MSVC ) #define EIGEN_THREAD_LOCAL static thread_local #endif
diff --git a/unsupported/Eigen/CXX11/src/ThreadPool/ThreadYield.h b/unsupported/Eigen/CXX11/src/ThreadPool/ThreadYield.h index a859c7b..f556ff6 100644 --- a/unsupported/Eigen/CXX11/src/ThreadPool/ThreadYield.h +++ b/unsupported/Eigen/CXX11/src/ThreadPool/ThreadYield.h
@@ -11,10 +11,6 @@ #define EIGEN_CXX11_THREADPOOL_THREAD_YIELD_H // Try to come up with a portable way to yield -#if EIGEN_COMP_GNUC && EIGEN_GNUC_AT_MOST(4, 7) -#define EIGEN_THREAD_YIELD() sched_yield() -#else #define EIGEN_THREAD_YIELD() std::this_thread::yield() -#endif #endif // EIGEN_CXX11_THREADPOOL_THREAD_YIELD_H
diff --git a/unsupported/Eigen/CXX11/src/util/EmulateArray.h b/unsupported/Eigen/CXX11/src/util/EmulateArray.h index f87cb81..a4b1d0c 100644 --- a/unsupported/Eigen/CXX11/src/util/EmulateArray.h +++ b/unsupported/Eigen/CXX11/src/util/EmulateArray.h
@@ -10,10 +10,8 @@ #ifndef EIGEN_EMULATE_ARRAY_H #define EIGEN_EMULATE_ARRAY_H -// The array class is only available starting with cxx11. Emulate our own here -// if needed. Beware, msvc still doesn't advertise itself as a c++11 compiler! -// Moreover, CUDA doesn't support the STL containers, so we use our own instead. -#if (__cplusplus <= 199711L && EIGEN_COMP_MSVC < 1900) || defined(EIGEN_GPUCC) || defined(EIGEN_AVOID_STL_ARRAY) +// CUDA doesn't support the STL containers, so we use our own instead. +#if defined(EIGEN_GPUCC) || defined(EIGEN_AVOID_STL_ARRAY) namespace Eigen { template <typename T, size_t n> class array { @@ -152,13 +150,11 @@ values[7] = v8; } -#if EIGEN_HAS_VARIADIC_TEMPLATES EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array(std::initializer_list<T> l) { eigen_assert(l.size() == n); internal::smart_copy(l.begin(), l.end(), values); } -#endif }; @@ -202,12 +198,10 @@ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE array() : dummy() { } -#if EIGEN_HAS_VARIADIC_TEMPLATES EIGEN_DEVICE_FUNC array(std::initializer_list<T> l) : dummy() { EIGEN_UNUSED_VARIABLE(l); eigen_assert(l.size() == 0); } -#endif private: T dummy;
diff --git a/unsupported/Eigen/CXX11/src/util/MaxSizeVector.h b/unsupported/Eigen/CXX11/src/util/MaxSizeVector.h index 277ab14..ca0e3d1 100644 --- a/unsupported/Eigen/CXX11/src/util/MaxSizeVector.h +++ b/unsupported/Eigen/CXX11/src/util/MaxSizeVector.h
@@ -29,7 +29,7 @@ */ template <typename T> class MaxSizeVector { - static const size_t alignment = EIGEN_PLAIN_ENUM_MAX(EIGEN_ALIGNOF(T), sizeof(void*)); + static const size_t alignment = internal::plain_enum_max(EIGEN_ALIGNOF(T), sizeof(void*)); public: // Construct a new MaxSizeVector, reserve n elements. EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
diff --git a/unsupported/Eigen/IterativeSolvers b/unsupported/Eigen/IterativeSolvers index 3db7902..a22d2a3 100644 --- a/unsupported/Eigen/IterativeSolvers +++ b/unsupported/Eigen/IterativeSolvers
@@ -22,8 +22,10 @@ * - a constrained conjugate gradient * - a Householder GMRES implementation * - an IDR(s) implementation + * - a BiCGSTAB(L) implementation * - a DGMRES implementation * - a MINRES implementation + * - a IDRSTABL implementation * * Choosing the best solver for solving \c A \c x = \c b depends a lot on the preconditioner chosen as well as the properties of \c A. The following flowchart might help you. * \dot width=50% @@ -82,6 +84,8 @@ #include "src/IterativeSolvers/DGMRES.h" #include "src/IterativeSolvers/MINRES.h" #include "src/IterativeSolvers/IDRS.h" +#include "src/IterativeSolvers/BiCGSTABL.h" +#include "src/IterativeSolvers/IDRSTABL.h" #include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
diff --git a/unsupported/Eigen/src/AutoDiff/AutoDiffJacobian.h b/unsupported/Eigen/src/AutoDiff/AutoDiffJacobian.h index 5020f22..6ef6bf4 100644 --- a/unsupported/Eigen/src/AutoDiff/AutoDiffJacobian.h +++ b/unsupported/Eigen/src/AutoDiff/AutoDiffJacobian.h
@@ -22,17 +22,8 @@ AutoDiffJacobian(const Functor& f) : Functor(f) {} // forward constructors -#if EIGEN_HAS_VARIADIC_TEMPLATES template<typename... T> AutoDiffJacobian(const T& ...Values) : Functor(Values...) {} -#else - template<typename T0> - AutoDiffJacobian(const T0& a0) : Functor(a0) {} - template<typename T0, typename T1> - AutoDiffJacobian(const T0& a0, const T1& a1) : Functor(a0, a1) {} - template<typename T0, typename T1, typename T2> - AutoDiffJacobian(const T0& a0, const T1& a1, const T2& a2) : Functor(a0, a1, a2) {} -#endif typedef typename Functor::InputType InputType; typedef typename Functor::ValueType ValueType; @@ -52,7 +43,6 @@ typedef Matrix<ActiveScalar, InputsAtCompileTime, 1> ActiveInput; typedef Matrix<ActiveScalar, ValuesAtCompileTime, 1> ActiveValue; -#if EIGEN_HAS_VARIADIC_TEMPLATES // Some compilers don't accept variadic parameters after a default parameter, // i.e., we can't just write _jac=0 but we need to overload operator(): EIGEN_STRONG_INLINE @@ -63,19 +53,12 @@ template<typename... ParamsType> void operator() (const InputType& x, ValueType* v, JacobianType* _jac, const ParamsType&... Params) const -#else - void operator() (const InputType& x, ValueType* v, JacobianType* _jac=0) const -#endif { eigen_assert(v!=0); if (!_jac) { -#if EIGEN_HAS_VARIADIC_TEMPLATES Functor::operator()(x, v, Params...); -#else - Functor::operator()(x, v); -#endif return; } @@ -91,11 +74,7 @@ for (Index i=0; i<jac.cols(); i++) ax[i].derivatives() = DerivativeType::Unit(x.rows(),i); -#if EIGEN_HAS_VARIADIC_TEMPLATES Functor::operator()(ax, &av, Params...); -#else - Functor::operator()(ax, &av); -#endif for (Index i=0; i<jac.rows(); i++) {
diff --git a/unsupported/Eigen/src/IterativeSolvers/BiCGSTABL.h b/unsupported/Eigen/src/IterativeSolvers/BiCGSTABL.h new file mode 100755 index 0000000..141d705 --- /dev/null +++ b/unsupported/Eigen/src/IterativeSolvers/BiCGSTABL.h
@@ -0,0 +1,339 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2020 Chris Schoutrop <c.e.m.schoutrop@tue.nl> +// Copyright (C) 2020 Jens Wehner <j.wehner@esciencecenter.nl> +// Copyright (C) 2020 Jan van Dijk <j.v.dijk@tue.nl> +// Copyright (C) 2020 Adithya Vijaykumar +// +// 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/. + +/* + + This implementation of BiCGStab(L) is based on the papers + General algorithm: + 1. G.L.G. Sleijpen, D.R. Fokkema. (1993). BiCGstab(l) for linear equations + involving unsymmetric matrices with complex spectrum. Electronic Transactions + on Numerical Analysis. Polynomial step update: + 2. G.L.G. Sleijpen, M.B. Van Gijzen. (2010) Exploiting BiCGstab(l) + strategies to induce dimension reduction SIAM Journal on Scientific Computing. + 3. Fokkema, Diederik R. Enhanced implementation of BiCGstab (l) for + solving linear systems of equations. Universiteit Utrecht. Mathematisch + Instituut, 1996 + 4. Sleijpen, G. L., & van der Vorst, H. A. (1996). Reliable updated + residuals in hybrid Bi-CG methods. Computing, 56(2), 141-163. +*/ + +#ifndef EIGEN_BICGSTABL_H +#define EIGEN_BICGSTABL_H + +namespace Eigen { + +namespace internal { +/** \internal Low-level bi conjugate gradient stabilized algorithm with L + additional residual minimization steps \param mat The matrix A \param rhs The + right hand side vector b \param x On input and initial solution, on output + the computed solution. \param precond A preconditioner being able to + efficiently solve for an approximation of Ax=b (regardless of b) \param iters + On input the max number of iteration, on output the number of performed + iterations. \param tol_error On input the tolerance error, on output an + estimation of the relative error. \param L On input Number of additional + GMRES steps to take. If L is too large (~20) instabilities occur. \return + false in the case of numerical issue, for example a break down of BiCGSTABL. +*/ +template <typename MatrixType, typename Rhs, typename Dest, typename Preconditioner> +bool bicgstabl(const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond, Index &iters, + typename Dest::RealScalar &tol_error, Index L) { + using numext::abs; + using numext::sqrt; + typedef typename Dest::RealScalar RealScalar; + typedef typename Dest::Scalar Scalar; + const Index N = rhs.size(); + L = L < x.rows() ? L : x.rows(); + + Index k = 0; + + const RealScalar tol = tol_error; + const Index maxIters = iters; + + typedef Matrix<Scalar, Dynamic, 1> VectorType; + typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> DenseMatrixType; + + DenseMatrixType rHat(N, L + 1); + DenseMatrixType uHat(N, L + 1); + + // We start with an initial guess x_0 and let us set r_0 as (residual + // calculated from x_0) + VectorType x0 = x; + rHat.col(0) = rhs - mat * x0; // r_0 + + x.setZero(); // This will contain the updates to the solution. + // rShadow is arbritary, but must never be orthogonal to any residual. + VectorType rShadow = VectorType::Random(N); + + VectorType x_prime = x; + + // Redundant: x is already set to 0 + // x.setZero(); + VectorType b_prime = rHat.col(0); + + // Other vectors and scalars initialization + Scalar rho0 = 1.0; + Scalar alpha = 0.0; + Scalar omega = 1.0; + + uHat.col(0).setZero(); + + bool bicg_convergence = false; + + const RealScalar normb = rhs.stableNorm(); + if (internal::isApprox(normb, RealScalar(0))) { + x.setZero(); + iters = 0; + return true; + } + RealScalar normr = rHat.col(0).stableNorm(); + RealScalar Mx = normr; + RealScalar Mr = normr; + + // Keep track of the solution with the lowest residual + RealScalar normr_min = normr; + VectorType x_min = x_prime + x; + + // Criterion for when to apply the group-wise update, conform ref 3. + const RealScalar delta = 0.01; + + bool compute_res = false; + bool update_app = false; + + while (normr > tol * normb && k < maxIters) { + rho0 *= -omega; + + for (Index j = 0; j < L; ++j) { + const Scalar rho1 = rShadow.dot(rHat.col(j)); + + if (!(numext::isfinite)(rho1) || rho0 == RealScalar(0.0)) { + // We cannot continue computing, return the best solution found. + x += x_prime; + + // Check if x is better than the best stored solution thus far. + normr = (rhs - mat * (precond.solve(x) + x0)).stableNorm(); + + if (normr > normr_min || !(numext::isfinite)(normr)) { + // x_min is a better solution than x, return x_min + x = x_min; + normr = normr_min; + } + tol_error = normr / normb; + iters = k; + // x contains the updates to x0, add those back to obtain the solution + x = precond.solve(x); + x += x0; + return (normr < tol * normb); + } + + const Scalar beta = alpha * (rho1 / rho0); + rho0 = rho1; + // Update search directions + uHat.leftCols(j + 1) = rHat.leftCols(j + 1) - beta * uHat.leftCols(j + 1); + uHat.col(j + 1) = mat * precond.solve(uHat.col(j)); + const Scalar sigma = rShadow.dot(uHat.col(j + 1)); + alpha = rho1 / sigma; + // Update residuals + rHat.leftCols(j + 1) -= alpha * uHat.middleCols(1, j + 1); + rHat.col(j + 1) = mat * precond.solve(rHat.col(j)); + // Complete BiCG iteration by updating x + x += alpha * uHat.col(0); + normr = rHat.col(0).stableNorm(); + // Check for early exit + if (normr < tol * normb) { + /* + Convergence was achieved during BiCG step. + Without this check BiCGStab(L) fails for trivial matrices, such as + when the preconditioner already is the inverse, or the input matrix is + identity. + */ + bicg_convergence = true; + break; + } else if (normr < normr_min) { + // We found an x with lower residual, keep this one. + x_min = x + x_prime; + normr_min = normr; + } + } + if (!bicg_convergence) { + /* + The polynomial/minimize residual step. + + QR Householder method for argmin is more stable than (modified) + Gram-Schmidt, in the sense that there is less loss of orthogonality. It + is more accurate than solving the normal equations, since the normal + equations scale with condition number squared. + */ + const VectorType gamma = rHat.rightCols(L).householderQr().solve(rHat.col(0)); + x += rHat.leftCols(L) * gamma; + rHat.col(0) -= rHat.rightCols(L) * gamma; + uHat.col(0) -= uHat.rightCols(L) * gamma; + normr = rHat.col(0).stableNorm(); + omega = gamma(L - 1); + } + if (normr < normr_min) { + // We found an x with lower residual, keep this one. + x_min = x + x_prime; + normr_min = normr; + } + + k++; + + /* + Reliable update part + + The recursively computed residual can deviate from the actual residual + after several iterations. However, computing the residual from the + definition costs extra MVs and should not be done at each iteration. The + reliable update strategy computes the true residual from the definition: + r=b-A*x at strategic intervals. Furthermore a "group wise update" strategy + is used to combine updates, which improves accuracy. + */ + + // Maximum norm of residuals since last update of x. + Mx = numext::maxi(Mx, normr); + // Maximum norm of residuals since last computation of the true residual. + Mr = numext::maxi(Mr, normr); + + if (normr < delta * normb && normb <= Mx) { + update_app = true; + } + + if (update_app || (normr < delta * Mr && normb <= Mr)) { + compute_res = true; + } + + if (bicg_convergence) { + update_app = true; + compute_res = true; + bicg_convergence = false; + } + + if (compute_res) { + // Explicitly compute residual from the definition + + // This is equivalent to the shifted version of rhs - mat * + // (precond.solve(x)+x0) + rHat.col(0) = b_prime - mat * precond.solve(x); + normr = rHat.col(0).stableNorm(); + Mr = normr; + + if (update_app) { + // After the group wise update, the original problem is translated to a + // shifted one. + x_prime += x; + x.setZero(); + b_prime = rHat.col(0); + Mx = normr; + } + } + if (normr < normr_min) { + // We found an x with lower residual, keep this one. + x_min = x + x_prime; + normr_min = normr; + } + + compute_res = false; + update_app = false; + } + + // Convert internal variable to the true solution vector x + x += x_prime; + + normr = (rhs - mat * (precond.solve(x) + x0)).stableNorm(); + if (normr > normr_min || !(numext::isfinite)(normr)) { + // x_min is a better solution than x, return x_min + x = x_min; + normr = normr_min; + } + tol_error = normr / normb; + iters = k; + + // x contains the updates to x0, add those back to obtain the solution + x = precond.solve(x); + x += x0; + return true; +} + +} // namespace internal + +template <typename MatrixType_, typename Preconditioner_ = DiagonalPreconditioner<typename MatrixType_::Scalar>> +class BiCGSTABL; + +namespace internal { + +template <typename MatrixType_, typename Preconditioner_> +struct traits<Eigen::BiCGSTABL<MatrixType_, Preconditioner_>> { + typedef MatrixType_ MatrixType; + typedef Preconditioner_ Preconditioner; +}; + +} // namespace internal + +template <typename MatrixType_, typename Preconditioner_> +class BiCGSTABL : public IterativeSolverBase<BiCGSTABL<MatrixType_, Preconditioner_>> { + typedef IterativeSolverBase<BiCGSTABL> Base; + using Base::m_error; + using Base::m_info; + using Base::m_isInitialized; + using Base::m_iterations; + using Base::matrix; + Index m_L; + + public: + typedef MatrixType_ MatrixType; + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::RealScalar RealScalar; + typedef Preconditioner_ Preconditioner; + + /** Default constructor. */ + BiCGSTABL() : m_L(2) {} + + /** + Initialize the solver with matrix \a A for further \c Ax=b solving. + + This constructor is a shortcut for the default constructor followed + by a call to compute(). + + \warning this class stores a reference to the matrix A as well as some + precomputed values that depend on it. Therefore, if \a A is changed + this class becomes invalid. Call compute() to update it with the new + matrix A, or modify a copy of A. + */ + template <typename MatrixDerived> + explicit BiCGSTABL(const EigenBase<MatrixDerived> &A) : Base(A.derived()), m_L(2) {} + + /** \internal */ + /** Loops over the number of columns of b and does the following: + 1. sets the tolerence and maxIterations + 2. Calls the function that has the core solver routine + */ + template <typename Rhs, typename Dest> + void _solve_vector_with_guess_impl(const Rhs &b, Dest &x) const { + m_iterations = Base::maxIterations(); + + m_error = Base::m_tolerance; + + bool ret = internal::bicgstabl(matrix(), b, x, Base::m_preconditioner, m_iterations, m_error, m_L); + m_info = (!ret) ? NumericalIssue : m_error <= Base::m_tolerance ? Success : NoConvergence; + } + + /** Sets the parameter L, indicating how many minimize residual steps are + * used. Default: 2 */ + void setL(Index L) { + eigen_assert(L >= 1 && "L needs to be positive"); + m_L = L; + } +}; + +} // namespace Eigen + +#endif /* EIGEN_BICGSTABL_H */
diff --git a/unsupported/Eigen/src/IterativeSolvers/IDRS.h b/unsupported/Eigen/src/IterativeSolvers/IDRS.h index 63d7cb8..2c7d7b0 100755 --- a/unsupported/Eigen/src/IterativeSolvers/IDRS.h +++ b/unsupported/Eigen/src/IterativeSolvers/IDRS.h
@@ -9,429 +9,388 @@ // 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_IDRS_H #define EIGEN_IDRS_H #include "./InternalHeaderCheck.h" -namespace Eigen -{ +namespace Eigen { - namespace internal - { - /** \internal Low-level Induced Dimension Reduction algorithm - \param A The matrix A - \param b The right hand side vector b - \param x On input and initial solution, on output the computed solution. - \param precond A preconditioner being able to efficiently solve for an - approximation of Ax=b (regardless of b) - \param iter On input the max number of iteration, on output the number of performed iterations. - \param relres On input the tolerance error, on output an estimation of the relative error. - \param S On input Number of the dimension of the shadow space. - \param smoothing switches residual smoothing on. - \param angle small omega lead to faster convergence at the expense of numerical stability - \param replacement switches on a residual replacement strategy to increase accuracy of residual at the expense of more Mat*vec products - \return false in the case of numerical issue, for example a break down of IDRS. - */ - template<typename Vector, typename RealScalar> - typename Vector::Scalar omega(const Vector& t, const Vector& s, RealScalar angle) - { - using numext::abs; - typedef typename Vector::Scalar Scalar; - const RealScalar ns = s.norm(); - const RealScalar nt = t.norm(); - const Scalar ts = t.dot(s); - const RealScalar rho = abs(ts / (nt * ns)); +namespace internal { +/** \internal Low-level Induced Dimension Reduction algorithm + \param A The matrix A + \param b The right hand side vector b + \param x On input and initial solution, on output the computed solution. + \param precond A preconditioner being able to efficiently solve for an + approximation of Ax=b (regardless of b) + \param iter On input the max number of iteration, on output the number of performed iterations. + \param relres On input the tolerance error, on output an estimation of the relative error. + \param S On input Number of the dimension of the shadow space. + \param smoothing switches residual smoothing on. + \param angle small omega lead to faster convergence at the expense of numerical stability + \param replacement switches on a residual replacement strategy to increase accuracy of residual at the + expense of more Mat*vec products \return false in the case of numerical issue, for example a break down of IDRS. +*/ +template <typename Vector, typename RealScalar> +typename Vector::Scalar omega(const Vector& t, const Vector& s, RealScalar angle) { + using numext::abs; + typedef typename Vector::Scalar Scalar; + const RealScalar ns = s.stableNorm(); + const RealScalar nt = t.stableNorm(); + const Scalar ts = t.dot(s); + const RealScalar rho = abs(ts / (nt * ns)); - if (rho < angle) { - if (ts == Scalar(0)) { - return Scalar(0); - } - // Original relation for om is given by - // om = om * angle / rho; - // To alleviate potential (near) division by zero this can be rewritten as - // om = angle * (ns / nt) * (ts / abs(ts)) = angle * (ns / nt) * sgn(ts) - return angle * (ns / nt) * (ts / abs(ts)); - } - return ts / (nt * nt); - } + if (rho < angle) { + if (ts == Scalar(0)) { + return Scalar(0); + } + // Original relation for om is given by + // om = om * angle / rho; + // To alleviate potential (near) division by zero this can be rewritten as + // om = angle * (ns / nt) * (ts / abs(ts)) = angle * (ns / nt) * sgn(ts) + return angle * (ns / nt) * (ts / abs(ts)); + } + return ts / (nt * nt); +} - template <typename MatrixType, typename Rhs, typename Dest, typename Preconditioner> - bool idrs(const MatrixType& A, const Rhs& b, Dest& x, const Preconditioner& precond, - Index& iter, - typename Dest::RealScalar& relres, Index S, bool smoothing, typename Dest::RealScalar angle, bool replacement) - { - typedef typename Dest::RealScalar RealScalar; - typedef typename Dest::Scalar Scalar; - typedef Matrix<Scalar, Dynamic, 1> VectorType; - typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> DenseMatrixType; - const Index N = b.size(); - S = S < x.rows() ? S : x.rows(); - const RealScalar tol = relres; - const Index maxit = iter; +template <typename MatrixType, typename Rhs, typename Dest, typename Preconditioner> +bool idrs(const MatrixType& A, const Rhs& b, Dest& x, const Preconditioner& precond, Index& iter, + typename Dest::RealScalar& relres, Index S, bool smoothing, typename Dest::RealScalar angle, + bool replacement) { + typedef typename Dest::RealScalar RealScalar; + typedef typename Dest::Scalar Scalar; + typedef Matrix<Scalar, Dynamic, 1> VectorType; + typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> DenseMatrixType; + const Index N = b.size(); + S = S < x.rows() ? S : x.rows(); + const RealScalar tol = relres; + const Index maxit = iter; - Index replacements = 0; - bool trueres = false; + Index replacements = 0; + bool trueres = false; - FullPivLU<DenseMatrixType> lu_solver; + FullPivLU<DenseMatrixType> lu_solver; - DenseMatrixType P; - { - HouseholderQR<DenseMatrixType> qr(DenseMatrixType::Random(N, S)); - P = (qr.householderQ() * DenseMatrixType::Identity(N, S)); - } + DenseMatrixType P; + { + HouseholderQR<DenseMatrixType> qr(DenseMatrixType::Random(N, S)); + P = (qr.householderQ() * DenseMatrixType::Identity(N, S)); + } - const RealScalar normb = b.norm(); + const RealScalar normb = b.stableNorm(); - if (internal::isApprox(normb, RealScalar(0))) - { - //Solution is the zero vector - x.setZero(); - iter = 0; - relres = 0; - return true; - } - // from http://homepage.tudelft.nl/1w5b5/IDRS/manual.pdf - // A peak in the residual is considered dangerously high if‖ri‖/‖b‖> C(tol/epsilon). - // With epsilon the - // relative machine precision. The factor tol/epsilon corresponds to the size of a - // finite precision number that is so large that the absolute round-off error in - // this number, when propagated through the process, makes it impossible to - // achieve the required accuracy.The factor C accounts for the accumulation of - // round-off errors. This parameter has beenset to 10−3. - // mp is epsilon/C - // 10^3 * eps is very conservative, so normally no residual replacements will take place. - // It only happens if things go very wrong. Too many restarts may ruin the convergence. - const RealScalar mp = RealScalar(1e3) * NumTraits<Scalar>::epsilon(); + if (internal::isApprox(normb, RealScalar(0))) { + // Solution is the zero vector + x.setZero(); + iter = 0; + relres = 0; + return true; + } + // from http://homepage.tudelft.nl/1w5b5/IDRS/manual.pdf + // A peak in the residual is considered dangerously high if‖ri‖/‖b‖> C(tol/epsilon). + // With epsilon the + // relative machine precision. The factor tol/epsilon corresponds to the size of a + // finite precision number that is so large that the absolute round-off error in + // this number, when propagated through the process, makes it impossible to + // achieve the required accuracy.The factor C accounts for the accumulation of + // round-off errors. This parameter has beenset to 10−3. + // mp is epsilon/C + // 10^3 * eps is very conservative, so normally no residual replacements will take place. + // It only happens if things go very wrong. Too many restarts may ruin the convergence. + const RealScalar mp = RealScalar(1e3) * NumTraits<Scalar>::epsilon(); + // Compute initial residual + const RealScalar tolb = tol * normb; // Relative tolerance + VectorType r = b - A * x; + VectorType x_s, r_s; - //Compute initial residual - const RealScalar tolb = tol * normb; //Relative tolerance - VectorType r = b - A * x; + if (smoothing) { + x_s = x; + r_s = r; + } - VectorType x_s, r_s; + RealScalar normr = r.stableNorm(); - if (smoothing) - { - x_s = x; - r_s = r; - } + if (normr <= tolb) { + // Initial guess is a good enough solution + iter = 0; + relres = normr / normb; + return true; + } - RealScalar normr = r.norm(); + DenseMatrixType G = DenseMatrixType::Zero(N, S); + DenseMatrixType U = DenseMatrixType::Zero(N, S); + DenseMatrixType M = DenseMatrixType::Identity(S, S); + VectorType t(N), v(N); + Scalar om = 1.; - if (normr <= tolb) - { - //Initial guess is a good enough solution - iter = 0; - relres = normr / normb; - return true; - } + // Main iteration loop, guild G-spaces: + iter = 0; - DenseMatrixType G = DenseMatrixType::Zero(N, S); - DenseMatrixType U = DenseMatrixType::Zero(N, S); - DenseMatrixType M = DenseMatrixType::Identity(S, S); - VectorType t(N), v(N); - Scalar om = 1.; + while (normr > tolb && iter < maxit) { + // New right hand size for small system: + VectorType f = (r.adjoint() * P).adjoint(); - //Main iteration loop, guild G-spaces: - iter = 0; + for (Index k = 0; k < S; ++k) { + // Solve small system and make v orthogonal to P: + // c = M(k:s,k:s)\f(k:s); + lu_solver.compute(M.block(k, k, S - k, S - k)); + VectorType c = lu_solver.solve(f.segment(k, S - k)); + // v = r - G(:,k:s)*c; + v = r - G.rightCols(S - k) * c; + // Preconditioning + v = precond.solve(v); - while (normr > tolb && iter < maxit) - { - //New right hand size for small system: - VectorType f = (r.adjoint() * P).adjoint(); + // Compute new U(:,k) and G(:,k), G(:,k) is in space G_j + U.col(k) = U.rightCols(S - k) * c + om * v; + G.col(k) = A * U.col(k); - for (Index k = 0; k < S; ++k) - { - //Solve small system and make v orthogonal to P: - //c = M(k:s,k:s)\f(k:s); - lu_solver.compute(M.block(k , k , S -k, S - k )); - VectorType c = lu_solver.solve(f.segment(k , S - k )); - //v = r - G(:,k:s)*c; - v = r - G.rightCols(S - k ) * c; - //Preconditioning - v = precond.solve(v); + // Bi-Orthogonalise the new basis vectors: + for (Index i = 0; i < k - 1; ++i) { + // alpha = ( P(:,i)'*G(:,k) )/M(i,i); + Scalar alpha = P.col(i).dot(G.col(k)) / M(i, i); + G.col(k) = G.col(k) - alpha * G.col(i); + U.col(k) = U.col(k) - alpha * U.col(i); + } - //Compute new U(:,k) and G(:,k), G(:,k) is in space G_j - U.col(k) = U.rightCols(S - k ) * c + om * v; - G.col(k) = A * U.col(k ); + // New column of M = P'*G (first k-1 entries are zero) + // M(k:s,k) = (G(:,k)'*P(:,k:s))'; + M.block(k, k, S - k, 1) = (G.col(k).adjoint() * P.rightCols(S - k)).adjoint(); - //Bi-Orthogonalise the new basis vectors: - for (Index i = 0; i < k-1 ; ++i) - { - //alpha = ( P(:,i)'*G(:,k) )/M(i,i); - Scalar alpha = P.col(i ).dot(G.col(k )) / M(i, i ); - G.col(k ) = G.col(k ) - alpha * G.col(i ); - U.col(k ) = U.col(k ) - alpha * U.col(i ); - } + if (internal::isApprox(M(k, k), Scalar(0))) { + return false; + } - //New column of M = P'*G (first k-1 entries are zero) - //M(k:s,k) = (G(:,k)'*P(:,k:s))'; - M.block(k , k , S - k , 1) = (G.col(k ).adjoint() * P.rightCols(S - k )).adjoint(); + // Make r orthogonal to q_i, i = 0..k-1 + Scalar beta = f(k) / M(k, k); + r = r - beta * G.col(k); + x = x + beta * U.col(k); + normr = r.stableNorm(); - if (internal::isApprox(M(k,k), Scalar(0))) - { - return false; - } + if (replacement && normr > tolb / mp) { + trueres = true; + } - //Make r orthogonal to q_i, i = 0..k-1 - Scalar beta = f(k ) / M(k , k ); - r = r - beta * G.col(k ); - x = x + beta * U.col(k ); - normr = r.norm(); + // Smoothing: + if (smoothing) { + t = r_s - r; + // gamma is a Scalar, but the conversion is not allowed + Scalar gamma = t.dot(r_s) / t.stableNorm(); + r_s = r_s - gamma * t; + x_s = x_s - gamma * (x_s - x); + normr = r_s.stableNorm(); + } - if (replacement && normr > tolb / mp) - { - trueres = true; - } + if (normr < tolb || iter == maxit) { + break; + } - //Smoothing: - if (smoothing) - { - t = r_s - r; - //gamma is a Scalar, but the conversion is not allowed - Scalar gamma = t.dot(r_s) / t.norm(); - r_s = r_s - gamma * t; - x_s = x_s - gamma * (x_s - x); - normr = r_s.norm(); - } + // New f = P'*r (first k components are zero) + if (k < S - 1) { + f.segment(k + 1, S - (k + 1)) = f.segment(k + 1, S - (k + 1)) - beta * M.block(k + 1, k, S - (k + 1), 1); + } + } // end for - if (normr < tolb || iter == maxit) - { - break; - } + if (normr < tolb || iter == maxit) { + break; + } - //New f = P'*r (first k components are zero) - if (k < S-1) - { - f.segment(k + 1, S - (k + 1) ) = f.segment(k + 1 , S - (k + 1)) - beta * M.block(k + 1 , k , S - (k + 1), 1); - } - }//end for + // Now we have sufficient vectors in G_j to compute residual in G_j+1 + // Note: r is already perpendicular to P so v = r + // Preconditioning + v = r; + v = precond.solve(v); - if (normr < tolb || iter == maxit) - { - break; - } + // Matrix-vector multiplication: + t = A * v; - //Now we have sufficient vectors in G_j to compute residual in G_j+1 - //Note: r is already perpendicular to P so v = r - //Preconditioning - v = r; - v = precond.solve(v); + // Computation of a new omega + om = internal::omega(t, r, angle); - //Matrix-vector multiplication: - t = A * v; + if (om == RealScalar(0.0)) { + return false; + } - //Computation of a new omega - om = internal::omega(t, r, angle); + r = r - om * t; + x = x + om * v; + normr = r.stableNorm(); - if (om == RealScalar(0.0)) - { - return false; - } + if (replacement && normr > tolb / mp) { + trueres = true; + } - r = r - om * t; - x = x + om * v; - normr = r.norm(); + // Residual replacement? + if (trueres && normr < normb) { + r = b - A * x; + trueres = false; + replacements++; + } - if (replacement && normr > tolb / mp) - { - trueres = true; - } + // Smoothing: + if (smoothing) { + t = r_s - r; + Scalar gamma = t.dot(r_s) / t.stableNorm(); + r_s = r_s - gamma * t; + x_s = x_s - gamma * (x_s - x); + normr = r_s.stableNorm(); + } - //Residual replacement? - if (trueres && normr < normb) - { - r = b - A * x; - trueres = false; - replacements++; - } + iter++; - //Smoothing: - if (smoothing) - { - t = r_s - r; - Scalar gamma = t.dot(r_s) /t.norm(); - r_s = r_s - gamma * t; - x_s = x_s - gamma * (x_s - x); - normr = r_s.norm(); - } + } // end while - iter++; + if (smoothing) { + x = x_s; + } + relres = normr / normb; + return true; +} - }//end while +} // namespace internal - if (smoothing) - { - x = x_s; - } - relres=normr/normb; - return true; - } +template <typename MatrixType_, typename Preconditioner_ = DiagonalPreconditioner<typename MatrixType_::Scalar> > +class IDRS; - } // namespace internal +namespace internal { - template <typename MatrixType_, typename Preconditioner_ = DiagonalPreconditioner<typename MatrixType_::Scalar> > - class IDRS; +template <typename MatrixType_, typename Preconditioner_> +struct traits<Eigen::IDRS<MatrixType_, Preconditioner_> > { + typedef MatrixType_ MatrixType; + typedef Preconditioner_ Preconditioner; +}; - namespace internal - { - - template <typename MatrixType_, typename Preconditioner_> - struct traits<Eigen::IDRS<MatrixType_, Preconditioner_> > - { - typedef MatrixType_ MatrixType; - typedef Preconditioner_ Preconditioner; - }; - - } // namespace internal - +} // namespace internal /** \ingroup IterativeLinearSolvers_Module - * \brief The Induced Dimension Reduction method (IDR(s)) is a short-recurrences Krylov method for sparse square problems. - * - * This class allows to solve for A.x = b sparse linear problems. The vectors x and b can be either dense or sparse. - * he Induced Dimension Reduction method, IDR(), is a robust and efficient short-recurrence Krylov subspace method for - * solving large nonsymmetric systems of linear equations. - * - * For indefinite systems IDR(S) outperforms both BiCGStab and BiCGStab(L). Additionally, IDR(S) can handle matrices - * with complex eigenvalues more efficiently than BiCGStab. - * - * Many problems that do not converge for BiCGSTAB converge for IDR(s) (for larger values of s). And if both methods - * converge the convergence for IDR(s) is typically much faster for difficult systems (for example indefinite problems). - * - * IDR(s) is a limited memory finite termination method. In exact arithmetic it converges in at most N+N/s iterations, - * with N the system size. It uses a fixed number of 4+3s vector. In comparison, BiCGSTAB terminates in 2N iterations - * and uses 7 vectors. GMRES terminates in at most N iterations, and uses I+3 vectors, with I the number of iterations. - * Restarting GMRES limits the memory consumption, but destroys the finite termination property. - * - * \tparam MatrixType_ the type of the sparse matrix A, can be a dense or a sparse matrix. - * \tparam Preconditioner_ the type of the preconditioner. Default is DiagonalPreconditioner - * - * \implsparsesolverconcept - * - * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations() - * and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations - * and NumTraits<Scalar>::epsilon() for the tolerance. - * - * The tolerance corresponds to the relative residual error: |Ax-b|/|b| - * - * \b Performance: when using sparse matrices, best performance is achied for a row-major sparse matrix format. - * Moreover, in this case multi-threading can be exploited if the user code is compiled with OpenMP enabled. - * See \ref TopicMultiThreading for details. - * - * By default the iterations start with x=0 as an initial guess of the solution. - * One can control the start using the solveWithGuess() method. - * - * IDR(s) can also be used in a matrix-free context, see the following \link MatrixfreeSolverExample example \endlink. - * - * \sa class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner + * \brief The Induced Dimension Reduction method (IDR(s)) is a short-recurrences Krylov method for sparse square + * problems. + * + * This class allows to solve for A.x = b sparse linear problems. The vectors x and b can be either dense or sparse. + * he Induced Dimension Reduction method, IDR(), is a robust and efficient short-recurrence Krylov subspace method for + * solving large nonsymmetric systems of linear equations. + * + * For indefinite systems IDR(S) outperforms both BiCGStab and BiCGStab(L). Additionally, IDR(S) can handle matrices + * with complex eigenvalues more efficiently than BiCGStab. + * + * Many problems that do not converge for BiCGSTAB converge for IDR(s) (for larger values of s). And if both methods + * converge the convergence for IDR(s) is typically much faster for difficult systems (for example indefinite problems). + * + * IDR(s) is a limited memory finite termination method. In exact arithmetic it converges in at most N+N/s iterations, + * with N the system size. It uses a fixed number of 4+3s vector. In comparison, BiCGSTAB terminates in 2N iterations + * and uses 7 vectors. GMRES terminates in at most N iterations, and uses I+3 vectors, with I the number of iterations. + * Restarting GMRES limits the memory consumption, but destroys the finite termination property. + * + * \tparam MatrixType_ the type of the sparse matrix A, can be a dense or a sparse matrix. + * \tparam Preconditioner_ the type of the preconditioner. Default is DiagonalPreconditioner + * + * \implsparsesolverconcept + * + * The maximal number of iterations and tolerance value can be controlled via the setMaxIterations() + * and setTolerance() methods. The defaults are the size of the problem for the maximal number of iterations + * and NumTraits<Scalar>::epsilon() for the tolerance. + * + * The tolerance corresponds to the relative residual error: |Ax-b|/|b| + * + * \b Performance: when using sparse matrices, best performance is achied for a row-major sparse matrix format. + * Moreover, in this case multi-threading can be exploited if the user code is compiled with OpenMP enabled. + * See \ref TopicMultiThreading for details. + * + * By default the iterations start with x=0 as an initial guess of the solution. + * One can control the start using the solveWithGuess() method. + * + * IDR(s) can also be used in a matrix-free context, see the following \link MatrixfreeSolverExample example \endlink. + * + * \sa class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner + */ +template <typename MatrixType_, typename Preconditioner_> +class IDRS : public IterativeSolverBase<IDRS<MatrixType_, Preconditioner_> > { + public: + typedef MatrixType_ MatrixType; + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::RealScalar RealScalar; + typedef Preconditioner_ Preconditioner; + + private: + typedef IterativeSolverBase<IDRS> Base; + using Base::m_error; + using Base::m_info; + using Base::m_isInitialized; + using Base::m_iterations; + using Base::matrix; + Index m_S; + bool m_smoothing; + RealScalar m_angle; + bool m_residual; + + public: + /** Default constructor. */ + IDRS() : m_S(4), m_smoothing(false), m_angle(RealScalar(0.7)), m_residual(false) {} + + /** Initialize the solver with matrix \a A for further \c Ax=b solving. + + This constructor is a shortcut for the default constructor followed + by a call to compute(). + + \warning this class stores a reference to the matrix A as well as some + precomputed values that depend on it. Therefore, if \a A is changed + this class becomes invalid. Call compute() to update it with the new + matrix A, or modify a copy of A. */ - template <typename MatrixType_, typename Preconditioner_> - class IDRS : public IterativeSolverBase<IDRS<MatrixType_, Preconditioner_> > - { + template <typename MatrixDerived> + explicit IDRS(const EigenBase<MatrixDerived>& A) + : Base(A.derived()), m_S(4), m_smoothing(false), m_angle(RealScalar(0.7)), m_residual(false) {} - public: - typedef MatrixType_ MatrixType; - typedef typename MatrixType::Scalar Scalar; - typedef typename MatrixType::RealScalar RealScalar; - typedef Preconditioner_ Preconditioner; + /** \internal */ + /** Loops over the number of columns of b and does the following: + 1. sets the tolerance and maxIterations + 2. Calls the function that has the core solver routine + */ + template <typename Rhs, typename Dest> + void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const { + m_iterations = Base::maxIterations(); + m_error = Base::m_tolerance; - private: - typedef IterativeSolverBase<IDRS> Base; - using Base::m_error; - using Base::m_info; - using Base::m_isInitialized; - using Base::m_iterations; - using Base::matrix; - Index m_S; - bool m_smoothing; - RealScalar m_angle; - bool m_residual; + bool ret = internal::idrs(matrix(), b, x, Base::m_preconditioner, m_iterations, m_error, m_S, m_smoothing, m_angle, + m_residual); - public: - /** Default constructor. */ - IDRS(): m_S(4), m_smoothing(false), m_angle(RealScalar(0.7)), m_residual(false) {} + m_info = (!ret) ? NumericalIssue : m_error <= Base::m_tolerance ? Success : NoConvergence; + } - /** Initialize the solver with matrix \a A for further \c Ax=b solving. + /** Sets the parameter S, indicating the dimension of the shadow space. Default is 4*/ + void setS(Index S) { + if (S < 1) { + S = 4; + } - This constructor is a shortcut for the default constructor followed - by a call to compute(). + m_S = S; + } - \warning this class stores a reference to the matrix A as well as some - precomputed values that depend on it. Therefore, if \a A is changed - this class becomes invalid. Call compute() to update it with the new - matrix A, or modify a copy of A. - */ - template <typename MatrixDerived> - explicit IDRS(const EigenBase<MatrixDerived>& A) : Base(A.derived()), m_S(4), m_smoothing(false), - m_angle(RealScalar(0.7)), m_residual(false) {} + /** Switches off and on smoothing. + Residual smoothing results in monotonically decreasing residual norms at + the expense of two extra vectors of storage and a few extra vector + operations. Although monotonic decrease of the residual norms is a + desirable property, the rate of convergence of the unsmoothed process and + the smoothed process is basically the same. Default is off */ + void setSmoothing(bool smoothing) { m_smoothing = smoothing; } + /** The angle must be a real scalar. In IDR(s), a value for the + iteration parameter omega must be chosen in every s+1th step. The most + natural choice is to select a value to minimize the norm of the next residual. + This corresponds to the parameter omega = 0. In practice, this may lead to + values of omega that are so small that the other iteration parameters + cannot be computed with sufficient accuracy. In such cases it is better to + increase the value of omega sufficiently such that a compromise is reached + between accurate computations and reduction of the residual norm. The + parameter angle =0.7 (”maintaining the convergence strategy”) + results in such a compromise. */ + void setAngle(RealScalar angle) { m_angle = angle; } - /** \internal */ - /** Loops over the number of columns of b and does the following: - 1. sets the tolerance and maxIterations - 2. Calls the function that has the core solver routine - */ - template <typename Rhs, typename Dest> - void _solve_vector_with_guess_impl(const Rhs& b, Dest& x) const - { - m_iterations = Base::maxIterations(); - m_error = Base::m_tolerance; - - bool ret = internal::idrs(matrix(), b, x, Base::m_preconditioner, m_iterations, m_error, m_S,m_smoothing,m_angle,m_residual); - - m_info = (!ret) ? NumericalIssue : m_error <= Base::m_tolerance ? Success : NoConvergence; - } - - /** Sets the parameter S, indicating the dimension of the shadow space. Default is 4*/ - void setS(Index S) - { - if (S < 1) - { - S = 4; - } - - m_S = S; - } - - /** Switches off and on smoothing. - Residual smoothing results in monotonically decreasing residual norms at - the expense of two extra vectors of storage and a few extra vector - operations. Although monotonic decrease of the residual norms is a - desirable property, the rate of convergence of the unsmoothed process and - the smoothed process is basically the same. Default is off */ - void setSmoothing(bool smoothing) - { - m_smoothing=smoothing; - } - - /** The angle must be a real scalar. In IDR(s), a value for the - iteration parameter omega must be chosen in every s+1th step. The most - natural choice is to select a value to minimize the norm of the next residual. - This corresponds to the parameter omega = 0. In practice, this may lead to - values of omega that are so small that the other iteration parameters - cannot be computed with sufficient accuracy. In such cases it is better to - increase the value of omega sufficiently such that a compromise is reached - between accurate computations and reduction of the residual norm. The - parameter angle =0.7 (”maintaining the convergence strategy”) - results in such a compromise. */ - void setAngle(RealScalar angle) - { - m_angle=angle; - } - - /** The parameter replace is a logical that determines whether a - residual replacement strategy is employed to increase the accuracy of the - solution. */ - void setResidualUpdate(bool update) - { - m_residual=update; - } - - }; + /** The parameter replace is a logical that determines whether a + residual replacement strategy is employed to increase the accuracy of the + solution. */ + void setResidualUpdate(bool update) { m_residual = update; } +}; } // namespace Eigen
diff --git a/unsupported/Eigen/src/IterativeSolvers/IDRSTABL.h b/unsupported/Eigen/src/IterativeSolvers/IDRSTABL.h new file mode 100755 index 0000000..712c171 --- /dev/null +++ b/unsupported/Eigen/src/IterativeSolvers/IDRSTABL.h
@@ -0,0 +1,476 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2020 Chris Schoutrop <c.e.m.schoutrop@tue.nl> +// Copyright (C) 2020 Mischa Senders <m.j.senders@student.tue.nl> +// Copyright (C) 2020 Lex Kuijpers <l.kuijpers@student.tue.nl> +// Copyright (C) 2020 Jens Wehner <j.wehner@esciencecenter.nl> +// Copyright (C) 2020 Jan van Dijk <j.v.dijk@tue.nl> +// Copyright (C) 2020 Adithya Vijaykumar +// +// 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/. +/* + +The IDR(S)Stab(L) method is a combination of IDR(S) and BiCGStab(L) + +This implementation of IDRSTABL is based on +1. Aihara, K., Abe, K., & Ishiwata, E. (2014). A variant of IDRstab with +reliable update strategies for solving sparse linear systems. Journal of +Computational and Applied Mathematics, 259, 244-258. + doi:10.1016/j.cam.2013.08.028 + 2. Aihara, K., Abe, K., & Ishiwata, E. (2015). Preconditioned +IDRSTABL Algorithms for Solving Nonsymmetric Linear Systems. International +Journal of Applied Mathematics, 45(3). + 3. Saad, Y. (2003). Iterative Methods for Sparse Linear Systems: +Second Edition. Philadelphia, PA: SIAM. + 4. Sonneveld, P., & Van Gijzen, M. B. (2009). IDR(s): A Family +of Simple and Fast Algorithms for Solving Large Nonsymmetric Systems of Linear +Equations. SIAM Journal on Scientific Computing, 31(2), 1035-1062. + doi:10.1137/070685804 + 5. Sonneveld, P. (2012). On the convergence behavior of IDR (s) +and related methods. SIAM Journal on Scientific Computing, 34(5), A2576-A2598. + + Right-preconditioning based on Ref. 3 is implemented here. +*/ + +#ifndef EIGEN_IDRSTABL_H +#define EIGEN_IDRSTABL_H + +namespace Eigen { + +namespace internal { + +template <typename MatrixType, typename Rhs, typename Dest, typename Preconditioner> +bool idrstabl(const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond, Index &iters, + typename Dest::RealScalar &tol_error, Index L, Index S) { + /* + Setup and type definitions. + */ + using numext::abs; + using numext::sqrt; + typedef typename Dest::Scalar Scalar; + typedef typename Dest::RealScalar RealScalar; + typedef Matrix<Scalar, Dynamic, 1> VectorType; + typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> DenseMatrixType; + + const Index N = x.rows(); + + Index k = 0; // Iteration counter + const Index maxIters = iters; + + const RealScalar rhs_norm = rhs.stableNorm(); + const RealScalar tol = tol_error * rhs_norm; + + if (rhs_norm == 0) { + /* + If b==0, then the exact solution is x=0. + rhs_norm is needed for other calculations anyways, this exit is a freebie. + */ + x.setZero(); + tol_error = 0.0; + return true; + } + // Construct decomposition objects beforehand. + FullPivLU<DenseMatrixType> lu_solver; + + if (S >= N || L >= N) { + /* + The matrix is very small, or the choice of L and S is very poor + in that case solving directly will be best. + */ + lu_solver.compute(DenseMatrixType(mat)); + x = lu_solver.solve(rhs); + tol_error = (rhs - mat * x).stableNorm() / rhs_norm; + return true; + } + + // Define maximum sizes to prevent any reallocation later on. + DenseMatrixType u(N, L + 1); + DenseMatrixType r(N, L + 1); + + DenseMatrixType V(N * (L + 1), S); + + VectorType alpha(S); + VectorType gamma(L); + VectorType update(N); + + /* + Main IDRSTABL algorithm + */ + // Set up the initial residual + VectorType x0 = x; + r.col(0) = rhs - mat * x; + x.setZero(); // The final solution will be x0+x + + tol_error = r.col(0).stableNorm(); + + // FOM = Full orthogonalisation method + DenseMatrixType h_FOM = DenseMatrixType::Zero(S, S - 1); + + // Construct an initial U matrix of size N x S + DenseMatrixType U(N * (L + 1), S); + for (Index col_index = 0; col_index < S; ++col_index) { + // Arnoldi-like process to generate a set of orthogonal vectors spanning + // {u,A*u,A*A*u,...,A^(S-1)*u}. This construction can be combined with the + // Full Orthogonalization Method (FOM) from Ref.3 to provide a possible + // early exit with no additional MV. + if (col_index != 0) { + /* + Modified Gram-Schmidt strategy: + */ + VectorType w = mat * precond.solve(u.col(0)); + for (Index i = 0; i < col_index; ++i) { + auto v = U.col(i).head(N); + h_FOM(i, col_index - 1) = v.dot(w); + w -= h_FOM(i, col_index - 1) * v; + } + u.col(0) = w; + h_FOM(col_index, col_index - 1) = u.col(0).stableNorm(); + + if (abs(h_FOM(col_index, col_index - 1)) != RealScalar(0)) { + /* + This only happens if u is NOT exactly zero. In case it is exactly zero + it would imply that that this u has no component in the direction of the + current residual. + + By then setting u to zero it will not contribute any further (as it + should). Whereas attempting to normalize results in division by zero. + + Such cases occur if: + 1. The basis of dimension <S is sufficient to exactly solve the linear + system. I.e. the current residual is in span{r,Ar,...A^{m-1}r}, where + (m-1)<=S. + 2. Two vectors vectors generated from r, Ar,... are (numerically) + parallel. + + In case 1, the exact solution to the system can be obtained from the + "Full Orthogonalization Method" (Algorithm 6.4 in the book of Saad), + without any additional MV. + + Contrary to what one would suspect, the comparison with ==0.0 for + floating-point types is intended here. Any arbritary non-zero u is fine + to continue, however if u contains either NaN or Inf the algorithm will + break down. + */ + u.col(0) /= h_FOM(col_index, col_index - 1); + } + } else { + u.col(0) = r.col(0); + u.col(0).normalize(); + } + + U.col(col_index).head(N) = u.col(0); + } + + if (S > 1) { + // Check for early FOM exit. + Scalar beta = r.col(0).stableNorm(); + VectorType e1 = VectorType::Zero(S - 1); + e1(0) = beta; + lu_solver.compute(h_FOM.topLeftCorner(S - 1, S - 1)); + VectorType y = lu_solver.solve(e1); + VectorType x2 = x + U.topLeftCorner(N, S - 1) * y; + + // Using proposition 6.7 in Saad, one MV can be saved to calculate the + // residual + RealScalar FOM_residual = (h_FOM(S - 1, S - 2) * y(S - 2) * U.col(S - 1).head(N)).stableNorm(); + + if (FOM_residual < tol) { + // Exit, the FOM algorithm was already accurate enough + iters = k; + // Convert back to the unpreconditioned solution + x = precond.solve(x2); + // x contains the updates to x0, add those back to obtain the solution + x += x0; + tol_error = FOM_residual / rhs_norm; + return true; + } + } + + /* + Select an initial (N x S) matrix R0. + 1. Generate random R0, orthonormalize the result. + 2. This results in R0, however to save memory and compute we only need the + adjoint of R0. This is given by the matrix R_T.\ Additionally, the matrix + (mat.adjoint()*R_tilde).adjoint()=R_tilde.adjoint()*mat by the + anti-distributivity property of the adjoint. This results in AR_T, which is + constant if R_T does not have to be regenerated and can be precomputed. + Based on reference 4, this has zero probability in exact arithmetic. + */ + + // Original IDRSTABL and Kensuke choose S random vectors: + const HouseholderQR<DenseMatrixType> qr(DenseMatrixType::Random(N, S)); + DenseMatrixType R_T = (qr.householderQ() * DenseMatrixType::Identity(N, S)).adjoint(); + DenseMatrixType AR_T = DenseMatrixType(R_T * mat); + + // Pre-allocate sigma. + DenseMatrixType sigma(S, S); + + bool reset_while = false; // Should the while loop be reset for some reason? + + while (k < maxIters) { + for (Index j = 1; j <= L; ++j) { + /* + The IDR Step + */ + // Construction of the sigma-matrix, and the decomposition of sigma. + for (Index i = 0; i < S; ++i) { + sigma.col(i).noalias() = AR_T * precond.solve(U.block(N * (j - 1), i, N, 1)); + } + + lu_solver.compute(sigma); + // Obtain the update coefficients alpha + if (j == 1) { + // alpha=inverse(sigma)*(R_T*r_0); + alpha.noalias() = lu_solver.solve(R_T * r.col(0)); + } else { + // alpha=inverse(sigma)*(AR_T*r_{j-2}) + alpha.noalias() = lu_solver.solve(AR_T * precond.solve(r.col(j - 2))); + } + + // Obtain new solution and residual from this update + update.noalias() = U.topRows(N) * alpha; + r.col(0) -= mat * precond.solve(update); + x += update; + + for (Index i = 1; i <= j - 2; ++i) { + // This only affects the case L>2 + r.col(i) -= U.block(N * (i + 1), 0, N, S) * alpha; + } + if (j > 1) { + // r=[r;A*r_{j-2}] + r.col(j - 1).noalias() = mat * precond.solve(r.col(j - 2)); + } + tol_error = r.col(0).stableNorm(); + + if (tol_error < tol) { + // If at this point the algorithm has converged, exit. + reset_while = true; + break; + } + + bool break_normalization = false; + for (Index q = 1; q <= S; ++q) { + if (q == 1) { + // u = r; + u.leftCols(j + 1) = r.leftCols(j + 1); + } else { + // u=[u_1;u_2;...;u_j] + u.leftCols(j) = u.middleCols(1, j); + } + + // Obtain the update coefficients beta implicitly + // beta=lu_sigma.solve(AR_T * u.block(N * (j - 1), 0, N, 1) + u.reshaped().head(u.rows() * j) -= U.topRows(N * j) * lu_solver.solve(AR_T * precond.solve(u.col(j - 1))); + + // u=[u;Au_{j-1}] + u.col(j).noalias() = mat * precond.solve(u.col(j - 1)); + + // Orthonormalize u_j to the columns of V_j(:,1:q-1) + if (q > 1) { + /* + Modified Gram-Schmidt-like procedure to make u orthogonal to the + columns of V from Ref. 1. + + The vector mu from Ref. 1 is obtained implicitly: + mu=V.block(N * j, 0, N, q - 1).adjoint() * u.block(N * j, 0, N, 1). + */ + for (Index i = 0; i <= q - 2; ++i) { + auto v = V.col(i).segment(N * j, N); + Scalar h = v.squaredNorm(); + h = v.dot(u.col(j)) / h; + u.reshaped().head(u.rows() * (j + 1)) -= h * V.block(0, i, N * (j + 1), 1); + } + } + // Normalize u and assign to a column of V + Scalar normalization_constant = u.col(j).stableNorm(); + // If u is exactly zero, this will lead to a NaN. Small, non-zero u is + // fine. + if (normalization_constant == RealScalar(0.0)) { + break_normalization = true; + break; + } else { + u.leftCols(j + 1) /= normalization_constant; + } + + V.block(0, q - 1, N * (j + 1), 1).noalias() = u.reshaped().head(u.rows() * (j + 1)); + } + + if (break_normalization == false) { + U = V; + } + } + if (reset_while) { + break; + } + + // r=[r;mat*r_{L-1}] + r.col(L).noalias() = mat * precond.solve(r.col(L - 1)); + + /* + The polynomial step + */ + ColPivHouseholderQR<DenseMatrixType> qr_solver(r.rightCols(L)); + gamma.noalias() = qr_solver.solve(r.col(0)); + + // Update solution and residual using the "minimized residual coefficients" + update.noalias() = r.leftCols(L) * gamma; + x += update; + r.col(0) -= mat * precond.solve(update); + + // Update iteration info + ++k; + tol_error = r.col(0).stableNorm(); + + if (tol_error < tol) { + // Slightly early exit by moving the criterion before the update of U, + // after the main while loop the result of that calculation would not be + // needed. + break; + } + + /* + U=U0-sum(gamma_j*U_j) + Consider the first iteration. Then U only contains U0, so at the start of + the while-loop U should be U0. Therefore only the first N rows of U have to + be updated. + */ + for (Index i = 1; i <= L; ++i) { + U.topRows(N) -= U.block(N * i, 0, N, S) * gamma(i - 1); + } + } + + /* + Exit after the while loop terminated. + */ + iters = k; + // Convert back to the unpreconditioned solution + x = precond.solve(x); + // x contains the updates to x0, add those back to obtain the solution + x += x0; + tol_error = tol_error / rhs_norm; + return true; +} + +} // namespace internal + +template <typename MatrixType_, typename Preconditioner_ = DiagonalPreconditioner<typename MatrixType_::Scalar>> +class IDRSTABL; + +namespace internal { + +template <typename MatrixType_, typename Preconditioner_> +struct traits<IDRSTABL<MatrixType_, Preconditioner_>> { + typedef MatrixType_ MatrixType; + typedef Preconditioner_ Preconditioner; +}; + +} // namespace internal + +/** \ingroup IterativeLinearSolvers_Module + * \brief The IDR(s)STAB(l) is a combination of IDR(s) and BiCGSTAB(l). It is a + * short-recurrences Krylov method for sparse square problems. It can outperform + * both IDR(s) and BiCGSTAB(l). IDR(s)STAB(l) generally closely follows the + * optimal GMRES convergence in terms of the number of Matrix-Vector products. + * However, without the increasing cost per iteration of GMRES. IDR(s)STAB(l) is + * suitable for both indefinite systems and systems with complex eigenvalues. + * + * This class allows solving for A.x = b sparse linear problems. The vectors x + * and b can be either dense or sparse. + * + * \tparam MatrixType_ the type of the sparse matrix A, can be a dense or a + * sparse matrix. \tparam Preconditioner_ the type of the preconditioner. + * Default is DiagonalPreconditioner + * + * \implsparsesolverconcept + * + * The maximum number of iterations and tolerance value can be controlled via + * the setMaxIterations() and setTolerance() methods. The defaults are the size + * of the problem for the maximum number of iterations and + * NumTraits<Scalar>::epsilon() for the tolerance. + * + * The tolerance is the maximum relative residual error: |Ax-b|/|b| for which + * the linear system is considered solved. + * + * \b Performance: When using sparse matrices, best performance is achieved for + * a row-major sparse matrix format. Moreover, in this case multi-threading can + * be exploited if the user code is compiled with OpenMP enabled. See \ref + * TopicMultiThreading for details. + * + * By default the iterations start with x=0 as an initial guess of the solution. + * One can control the start using the solveWithGuess() method. + * + * IDR(s)STAB(l) can also be used in a matrix-free context, see the following + * \link MatrixfreeSolverExample example \endlink. + * + * \sa class SimplicialCholesky, DiagonalPreconditioner, IdentityPreconditioner + */ + +template <typename MatrixType_, typename Preconditioner_> +class IDRSTABL : public IterativeSolverBase<IDRSTABL<MatrixType_, Preconditioner_>> { + typedef IterativeSolverBase<IDRSTABL> Base; + using Base::m_error; + using Base::m_info; + using Base::m_isInitialized; + using Base::m_iterations; + using Base::matrix; + Index m_L; + Index m_S; + + public: + typedef MatrixType_ MatrixType; + typedef typename MatrixType::Scalar Scalar; + typedef typename MatrixType::RealScalar RealScalar; + typedef Preconditioner_ Preconditioner; + + public: + /** Default constructor. */ + IDRSTABL() : m_L(2), m_S(4) {} + + /** Initialize the solver with matrix \a A for further \c Ax=b solving. + + This constructor is a shortcut for the default constructor followed + by a call to compute(). + + \warning this class stores a reference to the matrix A as well as some + precomputed values that depend on it. Therefore, if \a A is changed + this class becomes invalid. Call compute() to update it with the new + matrix A, or modify a copy of A. + */ + template <typename MatrixDerived> + explicit IDRSTABL(const EigenBase<MatrixDerived> &A) : Base(A.derived()), m_L(2), m_S(4) {} + + /** \internal */ + /** Loops over the number of columns of b and does the following: + 1. sets the tolerance and maxIterations + 2. Calls the function that has the core solver + routine + */ + template <typename Rhs, typename Dest> + void _solve_vector_with_guess_impl(const Rhs &b, Dest &x) const { + m_iterations = Base::maxIterations(); + m_error = Base::m_tolerance; + bool ret = internal::idrstabl(matrix(), b, x, Base::m_preconditioner, m_iterations, m_error, m_L, m_S); + + m_info = (!ret) ? NumericalIssue : m_error <= 10 * Base::m_tolerance ? Success : NoConvergence; + } + + /** Sets the parameter L, indicating the amount of minimize residual steps are + * used. */ + void setL(Index L) { + eigen_assert(L >= 1 && "L needs to be positive"); + m_L = L; + } + /** Sets the parameter S, indicating the dimension of the shadow residual + * space.. */ + void setS(Index S) { + eigen_assert(S >= 1 && "S needs to be positive"); + m_S = S; + } +}; + +} // namespace Eigen + +#endif /* EIGEN_IDRSTABL_H */
diff --git a/unsupported/Eigen/src/IterativeSolvers/MINRES.h b/unsupported/Eigen/src/IterativeSolvers/MINRES.h index 907e635..70f8ae5 100644 --- a/unsupported/Eigen/src/IterativeSolvers/MINRES.h +++ b/unsupported/Eigen/src/IterativeSolvers/MINRES.h
@@ -246,7 +246,7 @@ && (!NumTraits<Scalar>::IsComplex) }; typedef typename internal::conditional<TransposeInput,Transpose<const ActualMatrixType>, ActualMatrixType const&>::type RowMajorWrapper; - EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(MatrixWrapper::MatrixFree,UpLo==(Lower|Upper)),MATRIX_FREE_CONJUGATE_GRADIENT_IS_COMPATIBLE_WITH_UPPER_UNION_LOWER_MODE_ONLY); + EIGEN_STATIC_ASSERT(internal::check_implication(MatrixWrapper::MatrixFree, UpLo==(Lower|Upper)),MATRIX_FREE_CONJUGATE_GRADIENT_IS_COMPATIBLE_WITH_UPPER_UNION_LOWER_MODE_ONLY); typedef typename internal::conditional<UpLo==(Lower|Upper), RowMajorWrapper, typename MatrixWrapper::template ConstSelfAdjointViewReturnType<UpLo>::Type
diff --git a/unsupported/Eigen/src/Skyline/SkylineMatrixBase.h b/unsupported/Eigen/src/Skyline/SkylineMatrixBase.h index cc41175..e68d833 100644 --- a/unsupported/Eigen/src/Skyline/SkylineMatrixBase.h +++ b/unsupported/Eigen/src/Skyline/SkylineMatrixBase.h
@@ -87,8 +87,8 @@ typedef typename NumTraits<Scalar>::Real RealScalar; /** type of the equivalent square matrix */ - typedef Matrix<Scalar, EIGEN_SIZE_MAX(RowsAtCompileTime, ColsAtCompileTime), - EIGEN_SIZE_MAX(RowsAtCompileTime, ColsAtCompileTime) > SquareMatrixType; + typedef Matrix<Scalar, internal::max_size_prefer_dynamic(RowsAtCompileTime, ColsAtCompileTime), + internal::max_size_prefer_dynamic(RowsAtCompileTime, ColsAtCompileTime) > SquareMatrixType; inline const Derived& derived() const { return *static_cast<const Derived*> (this);
diff --git a/unsupported/Eigen/src/Skyline/SkylineProduct.h b/unsupported/Eigen/src/Skyline/SkylineProduct.h index 4b41e10..dab7536 100644 --- a/unsupported/Eigen/src/Skyline/SkylineProduct.h +++ b/unsupported/Eigen/src/Skyline/SkylineProduct.h
@@ -37,7 +37,7 @@ RowsAtCompileTime = _LhsNested::RowsAtCompileTime, ColsAtCompileTime = _RhsNested::ColsAtCompileTime, - InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(_LhsNested::ColsAtCompileTime, _RhsNested::RowsAtCompileTime), + InnerSize = internal::min_size_prefer_fixed(_LhsNested::ColsAtCompileTime, _RhsNested::RowsAtCompileTime), MaxRowsAtCompileTime = _LhsNested::MaxRowsAtCompileTime, MaxColsAtCompileTime = _RhsNested::MaxColsAtCompileTime,
diff --git a/unsupported/test/CMakeLists.txt b/unsupported/test/CMakeLists.txt index f87bacd..0f05c28 100644 --- a/unsupported/test/CMakeLists.txt +++ b/unsupported/test/CMakeLists.txt
@@ -99,6 +99,8 @@ ei_add_test(dgmres) ei_add_test(minres) ei_add_test(idrs) +ei_add_test(bicgstabl) +ei_add_test(idrstabl) ei_add_test(levenberg_marquardt) ei_add_test(kronecker_product) ei_add_test(bessel_functions)
diff --git a/unsupported/test/autodiff.cpp b/unsupported/test/autodiff.cpp index fded7b8..0addf2c 100644 --- a/unsupported/test/autodiff.cpp +++ b/unsupported/test/autodiff.cpp
@@ -106,7 +106,6 @@ }; -#if EIGEN_HAS_VARIADIC_TEMPLATES /* Test functor for the C++11 features. */ template <typename Scalar> struct integratorFunctor @@ -186,7 +185,6 @@ VERIFY_IS_APPROX(y, yref); VERIFY_IS_APPROX(j, jref); } -#endif template<typename Func> void forward_jacobian(const Func& f) { @@ -247,9 +245,7 @@ CALL_SUBTEST(( forward_jacobian(TestFunc1<double,3,2>()) )); CALL_SUBTEST(( forward_jacobian(TestFunc1<double,3,3>()) )); CALL_SUBTEST(( forward_jacobian(TestFunc1<double>(3,3)) )); -#if EIGEN_HAS_VARIADIC_TEMPLATES CALL_SUBTEST(( forward_jacobian_cpp11(integratorFunctor<double>(10)) )); -#endif }
diff --git a/unsupported/test/bicgstabl.cpp b/unsupported/test/bicgstabl.cpp new file mode 100644 index 0000000..302848c --- /dev/null +++ b/unsupported/test/bicgstabl.cpp
@@ -0,0 +1,31 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2011 Gael Guennebaud <g.gael@free.fr> +// Copyright (C) 2012 Kolja Brix <brix@igpm.rwth-aaachen.de> +// +// 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/. + +#include "../../test/sparse_solver.h" +#include <Eigen/IterativeSolvers> + +template<typename T> void test_bicgstabl_T() +{ + BiCGSTABL<SparseMatrix<T>, DiagonalPreconditioner<T> > bicgstabl_colmajor_diag; + BiCGSTABL<SparseMatrix<T>, IncompleteLUT<T> > bicgstabl_colmajor_ilut; + + //This does not change the tolerance of the test, only the tolerance of the solver. + bicgstabl_colmajor_diag.setTolerance(NumTraits<T>::epsilon()*20); + bicgstabl_colmajor_ilut.setTolerance(NumTraits<T>::epsilon()*20); + + CALL_SUBTEST( check_sparse_square_solving(bicgstabl_colmajor_diag) ); + CALL_SUBTEST( check_sparse_square_solving(bicgstabl_colmajor_ilut) ); +} + +EIGEN_DECLARE_TEST(bicgstabl) +{ + CALL_SUBTEST_1(test_bicgstabl_T<double>()); + CALL_SUBTEST_2(test_bicgstabl_T<std::complex<double> >()); +}
diff --git a/unsupported/test/cxx11_tensor_assign.cpp b/unsupported/test/cxx11_tensor_assign.cpp index 8e3ca0f..015865e 100644 --- a/unsupported/test/cxx11_tensor_assign.cpp +++ b/unsupported/test/cxx11_tensor_assign.cpp
@@ -280,7 +280,6 @@ } static void test_std_initializers_tensor() { -#if EIGEN_HAS_VARIADIC_TEMPLATES Tensor<int, 1> a(3); a.setValues({0, 1, 2}); VERIFY_IS_EQUAL(a(0), 0); @@ -349,7 +348,6 @@ VERIFY_IS_EQUAL(c(2, 1, 1), 25); VERIFY_IS_EQUAL(c(2, 1, 2), 26); VERIFY_IS_EQUAL(c(2, 1, 3), 27); -#endif // EIGEN_HAS_VARIADIC_TEMPLATES } EIGEN_DECLARE_TEST(cxx11_tensor_assign)
diff --git a/unsupported/test/cxx11_tensor_broadcasting.cpp b/unsupported/test/cxx11_tensor_broadcasting.cpp index cbd92c3..1523657 100644 --- a/unsupported/test/cxx11_tensor_broadcasting.cpp +++ b/unsupported/test/cxx11_tensor_broadcasting.cpp
@@ -91,15 +91,7 @@ } } -#if EIGEN_HAS_VARIADIC_TEMPLATES tensor.resize(11,3,5); -#else - array<Index, 3> new_dims; - new_dims[0] = 11; - new_dims[1] = 3; - new_dims[2] = 5; - tensor.resize(new_dims); -#endif tensor.setRandom(); broadcast = tensor.broadcast(broadcasts); @@ -148,15 +140,7 @@ } } -#if EIGEN_HAS_VARIADIC_TEMPLATES tensor.resize(11,3,5); -#else - array<Index, 3> new_dims; - new_dims[0] = 11; - new_dims[1] = 3; - new_dims[2] = 5; - tensor.resize(new_dims); -#endif tensor.setRandom(); broadcast = tensor.broadcast(broadcasts);
diff --git a/unsupported/test/cxx11_tensor_custom_index.cpp b/unsupported/test/cxx11_tensor_custom_index.cpp index b5dbc97..38ce05b 100644 --- a/unsupported/test/cxx11_tensor_custom_index.cpp +++ b/unsupported/test/cxx11_tensor_custom_index.cpp
@@ -20,7 +20,6 @@ template <int DataLayout> static void test_map_as_index() { -#ifdef EIGEN_HAS_SFINAE Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7); tensor.setRandom(); @@ -35,14 +34,12 @@ VERIFY_IS_EQUAL(tensor.coeff(coeffC), tensor.coeff(coeff)); VERIFY_IS_EQUAL(tensor.coeffRef(coeffC), tensor.coeffRef(coeff)); -#endif } template <int DataLayout> static void test_matrix_as_index() { -#ifdef EIGEN_HAS_SFINAE Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7); tensor.setRandom(); @@ -53,14 +50,12 @@ VERIFY_IS_EQUAL(tensor.coeff(coeffC), tensor.coeff(coeff)); VERIFY_IS_EQUAL(tensor.coeffRef(coeffC), tensor.coeffRef(coeff)); -#endif } template <int DataLayout> static void test_varlist_as_index() { -#ifdef EIGEN_HAS_SFINAE Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7); tensor.setRandom(); @@ -68,14 +63,12 @@ VERIFY_IS_EQUAL(tensor.coeff({1,2,4,1}), tensor.coeff(coeff)); VERIFY_IS_EQUAL(tensor.coeffRef({1,2,4,1}), tensor.coeffRef(coeff)); -#endif } template <int DataLayout> static void test_sizes_as_index() { -#ifdef EIGEN_HAS_SFINAE Tensor<float, 4, DataLayout> tensor(2, 3, 5, 7); tensor.setRandom(); @@ -84,7 +77,6 @@ VERIFY_IS_EQUAL(tensor.coeff(coeffC), tensor.coeff(coeff)); VERIFY_IS_EQUAL(tensor.coeffRef(coeffC), tensor.coeffRef(coeff)); -#endif }
diff --git a/unsupported/test/cxx11_tensor_gpu.cu b/unsupported/test/cxx11_tensor_gpu.cu index 33cbac4..7b3fb5a 100644 --- a/unsupported/test/cxx11_tensor_gpu.cu +++ b/unsupported/test/cxx11_tensor_gpu.cu
@@ -17,8 +17,6 @@ #include <unsupported/Eigen/CXX11/src/Tensor/TensorGpuHipCudaDefines.h> -#define EIGEN_GPU_TEST_C99_MATH 1 - using Eigen::Tensor; void test_gpu_nullary() { @@ -660,7 +658,6 @@ } -#if EIGEN_GPU_TEST_C99_MATH template <typename Scalar> void test_gpu_lgamma(const Scalar stddev) { @@ -699,7 +696,6 @@ gpuFree(d_in); gpuFree(d_out); } -#endif template <typename Scalar> void test_gpu_digamma() @@ -1023,7 +1019,6 @@ gpuFree(d_out); } -#if EIGEN_GPU_TEST_C99_MATH template <typename Scalar> void test_gpu_erf(const Scalar stddev) { @@ -1101,7 +1096,7 @@ gpuFree(d_in); gpuFree(d_out); } -#endif + template <typename Scalar> void test_gpu_ndtri() { @@ -1588,7 +1583,6 @@ CALL_SUBTEST_3(test_gpu_convolution_3d<RowMajor>()); #endif -#if EIGEN_GPU_TEST_C99_MATH // std::erf, std::erfc, and so on where only added in c++11. We use them // as a golden reference to validate the results produced by Eigen. Therefore // we can only run these tests if we use a c++11 compiler. @@ -1666,6 +1660,4 @@ CALL_SUBTEST_6(test_gpu_gamma_sample_der_alpha<float>()); CALL_SUBTEST_6(test_gpu_gamma_sample_der_alpha<double>()); #endif - -#endif }
diff --git a/unsupported/test/idrstabl.cpp b/unsupported/test/idrstabl.cpp new file mode 100644 index 0000000..7e40dd6 --- /dev/null +++ b/unsupported/test/idrstabl.cpp
@@ -0,0 +1,28 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2011 Gael Guennebaud <g.gael@free.fr> +// +// 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/. + +#include "../../test/sparse_solver.h" +#include <unsupported/Eigen/IterativeSolvers> + +template <typename T> +void test_idrstabl_T() { + IDRSTABL<SparseMatrix<T>, DiagonalPreconditioner<T> > idrstabl_colmajor_diag; + IDRSTABL<SparseMatrix<T>, IncompleteLUT<T> > idrstabl_colmajor_ilut; + + idrstabl_colmajor_diag.setTolerance(NumTraits<T>::epsilon() * 4); + idrstabl_colmajor_ilut.setTolerance(NumTraits<T>::epsilon() * 4); + + CALL_SUBTEST(check_sparse_square_solving(idrstabl_colmajor_diag)); + CALL_SUBTEST(check_sparse_square_solving(idrstabl_colmajor_ilut)); +} + +EIGEN_DECLARE_TEST(idrstabl) { + CALL_SUBTEST_1((test_idrstabl_T<double>())); + CALL_SUBTEST_2((test_idrstabl_T<std::complex<double> >())); +}