Update Eigen to commit:1dcae7cefcd479ec1f881dd4831665ab292ee1e7 CHANGELOG ========= 1dcae7cef - Revert "BDCSVD fix -Wmaybe-uninitialized" d14b0a4e5 - Remove C++23 check around has_denorm deprecation suppression 24db46050 - hlog symbol lookup should not restricted to global namespace 767e60e29 - Fix Woverflow warnings in PacketMathFP16 802568322 - Fix conversion of `Eigen::half` to `_Float16` in AVX512 code ec18dd09c - fix pi in kissfft 2b7b7aac5 - Speed up complex * complex matrix multiplication. b3e3b7b0e - Remove implicit this capture in lambdas e44db2109 - Optimize ThreadPool spinning c593e9e94 - Fix typos fd98cc49f - Avoid atomic false sharing in RunQueue 0b646f3f3 - Update file .clang-format 1dcb07bb2 - Update file eigen_navtree_hacks.js ddb163ffb - Update file .clang-format 3f06651fd - BDCSVD fix -Wmaybe-uninitialized 6331da95e - fixing a lot of typos c29c80012 - Fix formatting in README.md PiperOrigin-RevId: 659676252 Change-Id: I700b8fc2e3899bed3cca0dbf0b0c67f3b61fb8a0
diff --git a/Eigen/Geometry b/Eigen/Geometry index 3334874..019c98b 100644 --- a/Eigen/Geometry +++ b/Eigen/Geometry
@@ -23,7 +23,7 @@ * - translation, scaling, 2D and 3D rotations * - \link Quaternion quaternions \endlink * - cross products (\ref MatrixBase::cross, \ref MatrixBase::cross3) - * - orthognal vector generation (\ref MatrixBase::unitOrthogonal) + * - orthogonal vector generation (\ref MatrixBase::unitOrthogonal) * - some linear components: \link ParametrizedLine parametrized-lines \endlink and \link Hyperplane hyperplanes * \endlink * - \link AlignedBox axis aligned bounding boxes \endlink
diff --git a/Eigen/OrderingMethods b/Eigen/OrderingMethods index 921b8a0..0167419 100644 --- a/Eigen/OrderingMethods +++ b/Eigen/OrderingMethods
@@ -54,7 +54,7 @@ * \note Some of these methods (like AMD or METIS), need the sparsity pattern * of the input matrix to be symmetric. When the matrix is structurally unsymmetric, * Eigen computes internally the pattern of \f$A^T*A\f$ before calling the method. - * If your matrix is already symmetric (at leat in structure), you can avoid that + * If your matrix is already symmetric (at least in structure), you can avoid that * by calling the method with a SelfAdjointView type. * * \code
diff --git a/Eigen/ThreadPool b/Eigen/ThreadPool index 63e4758..af6d5a9 100644 --- a/Eigen/ThreadPool +++ b/Eigen/ThreadPool
@@ -99,7 +99,6 @@ #define EIGEN_CONDVAR ::Eigen::CondVar #endif - // IWYU pragma: begin_exports #include "src/ThreadPool/ThreadLocal.h" #include "src/ThreadPool/ThreadYield.h"
diff --git a/Eigen/src/CholmodSupport/CholmodSupport.h b/Eigen/src/CholmodSupport/CholmodSupport.h index e5b46c4..7e3c881 100644 --- a/Eigen/src/CholmodSupport/CholmodSupport.h +++ b/Eigen/src/CholmodSupport/CholmodSupport.h
@@ -425,7 +425,7 @@ RealScalar logDet = 0; Scalar* x = static_cast<Scalar*>(m_cholmodFactor->x); if (m_cholmodFactor->is_super) { - // Supernodal factorization stored as a packed list of dense column-major blocs, + // Supernodal factorization stored as a packed list of dense column-major blocks, // as described by the following structure: // super[k] == index of the first column of the j-th super node
diff --git a/Eigen/src/Core/CoreEvaluators.h b/Eigen/src/Core/CoreEvaluators.h index 5da9c57..3d78fd8 100644 --- a/Eigen/src/Core/CoreEvaluators.h +++ b/Eigen/src/Core/CoreEvaluators.h
@@ -402,7 +402,7 @@ #if 0 && EIGEN_COMP_MSVC > 0 // Disable this ugly workaround. This is now handled in traits<Ref>::match, // but this piece of code might still become handly if some other weird compilation -// erros pop up again. +// errors pop up again. // MSVC exhibits a weird compilation error when // compiling: @@ -645,7 +645,7 @@ // There is no source packet type with equal or fewer elements than DstPacketType. // This is problematic as the evaluation loop may attempt to access data outside the bounds of the array. // For example, consider the cast utilizing pcast<Packet4f,Packet2d> with an array of size 4: {0.0f,1.0f,2.0f,3.0f}. - // The first iteration of the evaulation loop will load 16 bytes: {0.0f,1.0f,2.0f,3.0f} and cast to {0.0,1.0}, which + // The first iteration of the evaluation loop will load 16 bytes: {0.0f,1.0f,2.0f,3.0f} and cast to {0.0,1.0}, which // is acceptable. The second iteration will load 16 bytes: {2.0f,3.0f,?,?}, which is outside the bounds of the array. // Instead, perform runtime check to determine if the load would access data outside the bounds of the array. @@ -701,7 +701,7 @@ srcPacket<SrcLoadMode>(row, col, 6), srcPacket<SrcLoadMode>(row, col, 7)); } - // Analagous routines for linear access. + // Analogous routines for linear access. template <int LoadMode, typename DstPacketType, AltSrcScalarOp<DstPacketType> = true> EIGEN_STRONG_INLINE DstPacketType packet(Index index) const { constexpr int DstPacketSize = unpacket_traits<DstPacketType>::size; @@ -838,7 +838,7 @@ Data m_d; }; -// specialization for expresions like (a < b).select(c, d) to enable full vectorization +// specialization for expressions like (a < b).select(c, d) to enable full vectorization template <typename Arg1, typename Arg2, typename Scalar, typename CmpLhsType, typename CmpRhsType, ComparisonName cmp> struct evaluator<CwiseTernaryOp<scalar_boolean_select_op<Scalar, Scalar, bool>, Arg1, Arg2, CwiseBinaryOp<scalar_cmp_op<Scalar, Scalar, cmp, false>, CmpLhsType, CmpRhsType>>>
diff --git a/Eigen/src/Core/DeviceWrapper.h b/Eigen/src/Core/DeviceWrapper.h index 9fdbe60..3ae8256 100644 --- a/Eigen/src/Core/DeviceWrapper.h +++ b/Eigen/src/Core/DeviceWrapper.h
@@ -82,7 +82,7 @@ } }; -// this allows us to use the default evaulation scheme if it is not specialized for the device +// this allows us to use the default evaluation scheme if it is not specialized for the device template <typename Kernel, typename Device, int Traversal = Kernel::AssignmentTraits::Traversal, int Unrolling = Kernel::AssignmentTraits::Unrolling> struct dense_assignment_loop_with_device { @@ -152,4 +152,4 @@ return DeviceWrapper<const Derived, Device>(derived(), device); } } // namespace Eigen -#endif \ No newline at end of file +#endif
diff --git a/Eigen/src/Core/GenericPacketMath.h b/Eigen/src/Core/GenericPacketMath.h index e1347b9..1d79b4a 100644 --- a/Eigen/src/Core/GenericPacketMath.h +++ b/Eigen/src/Core/GenericPacketMath.h
@@ -207,7 +207,7 @@ }; }; -// provides a succint template to define vectorized casting traits with respect to the largest accessible packet types +// provides a succinct template to define vectorized casting traits with respect to the largest accessible packet types template <typename Src, typename Tgt> struct vectorized_type_casting_traits { enum : int {
diff --git a/Eigen/src/Core/MathFunctionsImpl.h b/Eigen/src/Core/MathFunctionsImpl.h index 689c6d8..10ddabd 100644 --- a/Eigen/src/Core/MathFunctionsImpl.h +++ b/Eigen/src/Core/MathFunctionsImpl.h
@@ -23,7 +23,7 @@ Preconditions: 1. The starting guess provided in approx_a_recip must have at least half the leading mantissa bits in the correct result, such that a single - Newton-Raphson step is sufficient to get within 1-2 ulps of the currect + Newton-Raphson step is sufficient to get within 1-2 ulps of the correct result. 2. If a is zero, approx_a_recip must be infinite with the same sign as a. 3. If a is infinite, approx_a_recip must be zero with the same sign as a. @@ -61,7 +61,7 @@ Preconditions: 1. The starting guess provided in approx_a_recip must have at least half the leading mantissa bits in the correct result, such that a single - Newton-Raphson step is sufficient to get within 1-2 ulps of the currect + Newton-Raphson step is sufficient to get within 1-2 ulps of the correct result. 2. If a is zero, approx_a_recip must be infinite with the same sign as a. 3. If a is infinite, approx_a_recip must be zero with the same sign as a. @@ -112,7 +112,7 @@ 1. The starting guess for the reciprocal sqrt provided in approx_rsqrt must have at least half the leading mantissa bits in the correct result, such that a single Newton-Raphson step is sufficient to get within 1-2 ulps of - the currect result. + the correct result. 2. If a is zero, approx_rsqrt must be infinite. 3. If a is infinite, approx_rsqrt must be zero.
diff --git a/Eigen/src/Core/PermutationMatrix.h b/Eigen/src/Core/PermutationMatrix.h index 6945964..4748b11 100644 --- a/Eigen/src/Core/PermutationMatrix.h +++ b/Eigen/src/Core/PermutationMatrix.h
@@ -170,7 +170,7 @@ * \note \blank \note_try_to_help_rvo */ inline InverseReturnType inverse() const { return InverseReturnType(derived()); } - /** \returns the tranpose permutation matrix. + /** \returns the transpose permutation matrix. * * \note \blank \note_try_to_help_rvo */
diff --git a/Eigen/src/Core/StableNorm.h b/Eigen/src/Core/StableNorm.h index 6513120..de84d81 100644 --- a/Eigen/src/Core/StableNorm.h +++ b/Eigen/src/Core/StableNorm.h
@@ -218,7 +218,7 @@ return internal::blueNorm_impl(*this); } -/** \returns the \em l2 norm of \c *this avoiding undeflow and overflow. +/** \returns the \em l2 norm of \c *this avoiding underflow and overflow. * This version use a concatenation of hypot() calls, and it is very slow. * * \sa norm(), stableNorm()
diff --git a/Eigen/src/Core/Transpositions.h b/Eigen/src/Core/Transpositions.h index ad136d3..6fbbbd8 100644 --- a/Eigen/src/Core/Transpositions.h +++ b/Eigen/src/Core/Transpositions.h
@@ -91,7 +91,7 @@ /** \returns the inverse transformation */ inline Transpose<TranspositionsBase> inverse() const { return Transpose<TranspositionsBase>(derived()); } - /** \returns the tranpose transformation */ + /** \returns the transpose transformation */ inline Transpose<TranspositionsBase> transpose() const { return Transpose<TranspositionsBase>(derived()); } protected:
diff --git a/Eigen/src/Core/Visitor.h b/Eigen/src/Core/Visitor.h index 0302646..198ec95 100644 --- a/Eigen/src/Core/Visitor.h +++ b/Eigen/src/Core/Visitor.h
@@ -38,7 +38,7 @@ // unrolled inner-outer traversal template <typename Visitor, typename Derived, int UnrollCount, bool Vectorize, bool ShortCircuitEvaluation> struct visitor_impl<Visitor, Derived, UnrollCount, Vectorize, false, ShortCircuitEvaluation> { - // don't use short circuit evaulation for unrolled version + // don't use short circuit evaluation for unrolled version using Scalar = typename Derived::Scalar; using Packet = typename packet_traits<Scalar>::type; static constexpr bool RowMajor = Derived::IsRowMajor; @@ -93,7 +93,7 @@ // unrolled linear traversal template <typename Visitor, typename Derived, int UnrollCount, bool Vectorize, bool ShortCircuitEvaluation> struct visitor_impl<Visitor, Derived, UnrollCount, Vectorize, true, ShortCircuitEvaluation> { - // don't use short circuit evaulation for unrolled version + // don't use short circuit evaluation for unrolled version using Scalar = typename Derived::Scalar; using Packet = typename packet_traits<Scalar>::type; static constexpr int PacketSize = packet_traits<Scalar>::size;
diff --git a/Eigen/src/Core/arch/AVX/PacketMath.h b/Eigen/src/Core/arch/AVX/PacketMath.h index b05429c..ea58f0e 100644 --- a/Eigen/src/Core/arch/AVX/PacketMath.h +++ b/Eigen/src/Core/arch/AVX/PacketMath.h
@@ -1180,7 +1180,7 @@ } #endif -// Add specializations for min/max with prescribed NaN progation. +// Add specializations for min/max with prescribed NaN propagation. template <> EIGEN_STRONG_INLINE Packet8f pmin<PropagateNumbers, Packet8f>(const Packet8f& a, const Packet8f& b) { return pminmax_propagate_numbers(a, b, pmin<Packet8f>);
diff --git a/Eigen/src/Core/arch/AVX512/PacketMath.h b/Eigen/src/Core/arch/AVX512/PacketMath.h index 9a0edca..0659ddd 100644 --- a/Eigen/src/Core/arch/AVX512/PacketMath.h +++ b/Eigen/src/Core/arch/AVX512/PacketMath.h
@@ -572,7 +572,7 @@ return _mm512_max_epi64(b, a); } -// Add specializations for min/max with prescribed NaN progation. +// Add specializations for min/max with prescribed NaN propagation. template <> EIGEN_STRONG_INLINE Packet16f pmin<PropagateNumbers, Packet16f>(const Packet16f& a, const Packet16f& b) { return pminmax_propagate_numbers(a, b, pmin<Packet16f>);
diff --git a/Eigen/src/Core/arch/AVX512/PacketMathFP16.h b/Eigen/src/Core/arch/AVX512/PacketMathFP16.h index 088a264..038e233 100644 --- a/Eigen/src/Core/arch/AVX512/PacketMathFP16.h +++ b/Eigen/src/Core/arch/AVX512/PacketMathFP16.h
@@ -109,7 +109,13 @@ template <> EIGEN_STRONG_INLINE Packet32h pset1<Packet32h>(const Eigen::half& from) { - return _mm512_set1_ph(static_cast<_Float16>(from)); + // half/half_raw is bit compatible + return _mm512_set1_ph(numext::bit_cast<_Float16>(from)); +} + +template <> +EIGEN_STRONG_INLINE Packet32h pzero(const Packet32h& /*a*/) { + return _mm512_setzero_ph(); } // pset1frombits @@ -209,10 +215,8 @@ // plset template <> EIGEN_STRONG_INLINE Packet32h plset<Packet32h>(const half& a) { - return _mm512_add_ph(_mm512_set1_ph(a), - _mm512_set_ph(31.0f, 30.0f, 29.0f, 28.0f, 27.0f, 26.0f, 25.0f, 24.0f, 23.0f, 22.0f, 21.0f, 20.0f, - 19.0f, 18.0f, 17.0f, 16.0f, 15.0f, 14.0f, 13.0f, 12.0f, 11.0f, 10.0f, 9.0f, 8.0f, - 7.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f, 0.0f)); + return _mm512_add_ph(pset1<Packet32h>(a), _mm512_set_ph(31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, + 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)); } // por @@ -256,7 +260,7 @@ template <> EIGEN_STRONG_INLINE Packet32h pcmp_eq(const Packet32h& a, const Packet32h& b) { __mmask32 mask = _mm512_cmp_ph_mask(a, b, _CMP_EQ_OQ); - return _mm512_castsi512_ph(_mm512_mask_set1_epi16(_mm512_set1_epi32(0), mask, 0xffffu)); + return _mm512_castsi512_ph(_mm512_mask_set1_epi16(_mm512_set1_epi32(0), mask, static_cast<short>(0xffffu))); } // pcmp_le @@ -264,7 +268,7 @@ template <> EIGEN_STRONG_INLINE Packet32h pcmp_le(const Packet32h& a, const Packet32h& b) { __mmask32 mask = _mm512_cmp_ph_mask(a, b, _CMP_LE_OQ); - return _mm512_castsi512_ph(_mm512_mask_set1_epi16(_mm512_set1_epi32(0), mask, 0xffffu)); + return _mm512_castsi512_ph(_mm512_mask_set1_epi16(_mm512_set1_epi32(0), mask, static_cast<short>(0xffffu))); } // pcmp_lt @@ -272,7 +276,7 @@ template <> EIGEN_STRONG_INLINE Packet32h pcmp_lt(const Packet32h& a, const Packet32h& b) { __mmask32 mask = _mm512_cmp_ph_mask(a, b, _CMP_LT_OQ); - return _mm512_castsi512_ph(_mm512_mask_set1_epi16(_mm512_set1_epi32(0), mask, 0xffffu)); + return _mm512_castsi512_ph(_mm512_mask_set1_epi16(_mm512_set1_epi32(0), mask, static_cast<short>(0xffffu))); } // pcmp_lt_or_nan @@ -280,7 +284,7 @@ template <> EIGEN_STRONG_INLINE Packet32h pcmp_lt_or_nan(const Packet32h& a, const Packet32h& b) { __mmask32 mask = _mm512_cmp_ph_mask(a, b, _CMP_NGE_UQ); - return _mm512_castsi512_ph(_mm512_mask_set1_epi16(_mm512_set1_epi16(0), mask, 0xffffu)); + return _mm512_castsi512_ph(_mm512_mask_set1_epi16(_mm512_set1_epi16(0), mask, static_cast<short>(0xffffu))); } // padd @@ -510,7 +514,7 @@ template <> EIGEN_STRONG_INLINE Packet32h pnegate<Packet32h>(const Packet32h& a) { - return _mm512_sub_ph(_mm512_set1_ph(0.0), a); + return psub(pzero(a), a); } // pconj
diff --git a/Eigen/src/Core/arch/AVX512/TrsmKernel.h b/Eigen/src/Core/arch/AVX512/TrsmKernel.h index 903bca5..c763b5f 100644 --- a/Eigen/src/Core/arch/AVX512/TrsmKernel.h +++ b/Eigen/src/Core/arch/AVX512/TrsmKernel.h
@@ -206,7 +206,7 @@ /** * GEMM like operation for trsm panel updates. * Computes: C -= A*B - * K must be multipe of 4. + * K must be multiple of 4. * * Unrolls used are {1,2,4,8}x{U1,U2,U3}; * For good performance we want K to be large with M/N relatively small, but also large enough
diff --git a/Eigen/src/Core/arch/AVX512/TrsmUnrolls.inc b/Eigen/src/Core/arch/AVX512/TrsmUnrolls.inc index 4c6116c..1983c08 100644 --- a/Eigen/src/Core/arch/AVX512/TrsmUnrolls.inc +++ b/Eigen/src/Core/arch/AVX512/TrsmUnrolls.inc
@@ -28,7 +28,7 @@ * func(startI,startJ) startJ = (startC)%(endJ) * func(...) * - * The 1-D loop can be unrolled recursively by using enable_if and defining an auxillary function + * The 1-D loop can be unrolled recursively by using enable_if and defining an auxiliary function * with a template parameter used as a counter. * * template <endI, endJ, counter> @@ -124,7 +124,7 @@ } /*** - * Unrolls for tranposed C stores + * Unrolls for transposed C stores */ template <typename Scalar> class trans { @@ -134,7 +134,7 @@ static constexpr int64_t PacketSize = packet_traits<Scalar>::size; /*********************************** - * Auxillary Functions for: + * Auxiliary Functions for: * - storeC *********************************** */ @@ -285,7 +285,7 @@ static constexpr int64_t PacketSize = packet_traits<Scalar>::size; /*********************************** - * Auxillary Functions for: + * Auxiliary Functions for: * - loadB * - storeB * - loadBBlock @@ -588,7 +588,7 @@ static constexpr int64_t PacketSize = packet_traits<Scalar>::size; /*********************************** - * Auxillary Functions for: + * Auxiliary Functions for: * - loadRHS * - storeRHS * - divRHSByDiag @@ -867,7 +867,7 @@ static constexpr int64_t PacketSize = packet_traits<Scalar>::size; /*********************************** - * Auxillary Functions for: + * Auxiliary Functions for: * - setzero * - updateC * - storeC @@ -1101,7 +1101,7 @@ } } - // We have updated all accumlators, time to load next set of B's + // We have updated all accumulators, time to load next set of B's EIGEN_IF_CONSTEXPR((startN == endN - 1) && (startM == endM - 1)) { gemm::template loadB<endM, endN, startK, endK, numLoad, numBCast, rem>(B_t, LDB, zmm, rem_); }
diff --git a/Eigen/src/Core/arch/AltiVec/MatrixProduct.h b/Eigen/src/Core/arch/AltiVec/MatrixProduct.h index 94306da..be79eba 100644 --- a/Eigen/src/Core/arch/AltiVec/MatrixProduct.h +++ b/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
@@ -1590,7 +1590,7 @@ pger_common<Packet, false, N>(&cImag, bImag, aReal.packet); } -// Load a PacketBlock, the N parameters make tunning gemm easier so we can add more accumulators as needed. +// Load a PacketBlock, the N parameters make tuning gemm easier so we can add more accumulators as needed. // // full = operate (load) on the entire PacketBlock or only half template <typename DataMapper, typename Packet, const Index accCols, int StorageOrder, bool Complex, int N, bool full>
diff --git a/Eigen/src/Core/arch/Default/BFloat16.h b/Eigen/src/Core/arch/Default/BFloat16.h index 9e79a39..14f0524 100644 --- a/Eigen/src/Core/arch/Default/BFloat16.h +++ b/Eigen/src/Core/arch/Default/BFloat16.h
@@ -139,15 +139,11 @@ static EIGEN_CONSTEXPR const bool has_infinity = true; static EIGEN_CONSTEXPR const bool has_quiet_NaN = true; static EIGEN_CONSTEXPR const bool has_signaling_NaN = true; -#if __cplusplus >= 202302L EIGEN_DIAGNOSTICS(push) EIGEN_DISABLE_DEPRECATED_WARNING -#endif static EIGEN_CONSTEXPR const std::float_denorm_style has_denorm = std::denorm_present; static EIGEN_CONSTEXPR const bool has_denorm_loss = false; -#if __cplusplus >= 202302L EIGEN_DIAGNOSTICS(pop) -#endif static EIGEN_CONSTEXPR const std::float_round_style round_style = std::numeric_limits<float>::round_style; static EIGEN_CONSTEXPR const bool is_iec559 = true; // The C++ standard defines this as "true if the set of values representable @@ -194,17 +190,13 @@ EIGEN_CONSTEXPR const bool numeric_limits_bfloat16_impl<T>::has_quiet_NaN; template <typename T> EIGEN_CONSTEXPR const bool numeric_limits_bfloat16_impl<T>::has_signaling_NaN; -#if __cplusplus >= 202302L EIGEN_DIAGNOSTICS(push) EIGEN_DISABLE_DEPRECATED_WARNING -#endif template <typename T> EIGEN_CONSTEXPR const std::float_denorm_style numeric_limits_bfloat16_impl<T>::has_denorm; template <typename T> EIGEN_CONSTEXPR const bool numeric_limits_bfloat16_impl<T>::has_denorm_loss; -#if __cplusplus >= 202302L EIGEN_DIAGNOSTICS(pop) -#endif template <typename T> EIGEN_CONSTEXPR const std::float_round_style numeric_limits_bfloat16_impl<T>::round_style; template <typename T>
diff --git a/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h b/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h index 1c46ba4..d9e6d03 100644 --- a/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h +++ b/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
@@ -1655,7 +1655,7 @@ } // This function implements the division of double word {x_hi, x_lo} -// by float y. This is Algorithm 15 from "Tight and rigourous error bounds +// by float y. This is Algorithm 15 from "Tight and rigorous error bounds // for basic building blocks of double-word arithmetic", Joldes, Muller, & Popescu, // 2017. https://hal.archives-ouvertes.fr/hal-01351529 template <typename Packet> @@ -2376,7 +2376,7 @@ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet handle_negative_exponent(const Packet& x, const ScalarExponent& exponent) { using Scalar = typename unpacket_traits<Packet>::type; - // singed integer base, signed integer exponent case + // signed integer base, signed integer exponent case // This routine handles negative exponents. // The return value is either 0, 1, or -1.
diff --git a/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h b/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h index 1bf1128..4d113ca 100644 --- a/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h +++ b/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
@@ -21,7 +21,7 @@ // This is needed to workaround a circular dependency. /*************************************************************************** - * Some generic implementations to be used by implementors + * Some generic implementations to be used by implementers ***************************************************************************/ /** Default implementation of pfrexp.
diff --git a/Eigen/src/Core/arch/Default/Half.h b/Eigen/src/Core/arch/Default/Half.h index 7754e8f..1f314fa 100644 --- a/Eigen/src/Core/arch/Default/Half.h +++ b/Eigen/src/Core/arch/Default/Half.h
@@ -208,15 +208,11 @@ static EIGEN_CONSTEXPR const bool has_infinity = true; static EIGEN_CONSTEXPR const bool has_quiet_NaN = true; static EIGEN_CONSTEXPR const bool has_signaling_NaN = true; -#if __cplusplus >= 202302L EIGEN_DIAGNOSTICS(push) EIGEN_DISABLE_DEPRECATED_WARNING -#endif static EIGEN_CONSTEXPR const std::float_denorm_style has_denorm = std::denorm_present; static EIGEN_CONSTEXPR const bool has_denorm_loss = false; -#if __cplusplus >= 202302L EIGEN_DIAGNOSTICS(pop) -#endif static EIGEN_CONSTEXPR const std::float_round_style round_style = std::round_to_nearest; static EIGEN_CONSTEXPR const bool is_iec559 = true; // The C++ standard defines this as "true if the set of values representable @@ -263,17 +259,13 @@ EIGEN_CONSTEXPR const bool numeric_limits_half_impl<T>::has_quiet_NaN; template <typename T> EIGEN_CONSTEXPR const bool numeric_limits_half_impl<T>::has_signaling_NaN; -#if __cplusplus >= 202302L EIGEN_DIAGNOSTICS(push) EIGEN_DISABLE_DEPRECATED_WARNING -#endif template <typename T> EIGEN_CONSTEXPR const std::float_denorm_style numeric_limits_half_impl<T>::has_denorm; template <typename T> EIGEN_CONSTEXPR const bool numeric_limits_half_impl<T>::has_denorm_loss; -#if __cplusplus >= 202302L EIGEN_DIAGNOSTICS(pop) -#endif template <typename T> EIGEN_CONSTEXPR const std::float_round_style numeric_limits_half_impl<T>::round_style; template <typename T> @@ -327,7 +319,7 @@ #if (defined(EIGEN_HAS_CUDA_FP16) && defined(EIGEN_CUDA_ARCH) && EIGEN_CUDA_ARCH >= 530) || \ (defined(EIGEN_HAS_HIP_FP16) && defined(HIP_DEVICE_COMPILE)) // Note: We deliberately do *not* define this to 1 even if we have Arm's native -// fp16 type since GPU halfs are rather different from native CPU halfs. +// fp16 type since GPU half types are rather different from native CPU half types. // TODO: Rename to something like EIGEN_HAS_NATIVE_GPU_FP16 #define EIGEN_HAS_NATIVE_FP16 #endif @@ -685,7 +677,7 @@ #if (defined(EIGEN_HAS_CUDA_FP16) && EIGEN_CUDA_SDK_VER >= 80000 && defined(EIGEN_CUDA_ARCH) && \ EIGEN_CUDA_ARCH >= 530) || \ (defined(EIGEN_HAS_HIP_FP16) && defined(EIGEN_HIP_DEVICE_COMPILE)) - return half(::hlog(a)); + return half(hlog(a)); #else return half(::logf(float(a))); #endif
diff --git a/Eigen/src/Core/arch/NEON/MathFunctions.h b/Eigen/src/Core/arch/NEON/MathFunctions.h index 3d2e7bd..bebe081 100644 --- a/Eigen/src/Core/arch/NEON/MathFunctions.h +++ b/Eigen/src/Core/arch/NEON/MathFunctions.h
@@ -27,7 +27,7 @@ template <> EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet8hf ptanh<Packet8hf>(const Packet8hf& x) { - // Convert each 4 halfs to float, call the float ptanh, and then convert back. + // Convert each 4 half types to float, call the float ptanh, and then convert back. return vcombine_f16(vcvt_f16_f32(ptanh<Packet4f>(vcvt_f32_f16(vget_low_f16(x)))), vcvt_f16_f32(ptanh<Packet4f>(vcvt_high_f32_f16(x)))); }
diff --git a/Eigen/src/Core/arch/NEON/PacketMath.h b/Eigen/src/Core/arch/NEON/PacketMath.h index 50cf56f..794d063 100644 --- a/Eigen/src/Core/arch/NEON/PacketMath.h +++ b/Eigen/src/Core/arch/NEON/PacketMath.h
@@ -103,7 +103,7 @@ return res; } -// fuctionally equivalent to _mm_shuffle_ps in SSE when interleave +// functionally equivalent to _mm_shuffle_ps in SSE when interleave // == false (i.e. shuffle<false>(m, n, mask) equals _mm_shuffle_ps(m, n, mask)), // interleave m and n when interleave == true. Currently used in LU/arch/InverseSize4.h // to enable a shared implementation for fast inversion of matrices of size 4. @@ -5029,7 +5029,7 @@ //---------- double ---------- -// Clang 3.5 in the iOS toolchain has an ICE triggered by NEON intrisics for double. +// Clang 3.5 in the iOS toolchain has an ICE triggered by NEON intrinsics for double. // Confirmed at least with __apple_build_version__ = 6000054. #if EIGEN_COMP_CLANGAPPLE // Let's hope that by the time __apple_build_version__ hits the 601* range, the bug will be fixed. @@ -5075,7 +5075,7 @@ EIGEN_ALWAYS_INLINE Packet2d make_packet2d(double a, double b) { return Packet2d{a, b}; } #endif -// fuctionally equivalent to _mm_shuffle_pd in SSE (i.e. shuffle(m, n, mask) equals _mm_shuffle_pd(m,n,mask)) +// functionally equivalent to _mm_shuffle_pd in SSE (i.e. shuffle(m, n, mask) equals _mm_shuffle_pd(m,n,mask)) // Currently used in LU/arch/InverseSize4.h to enable a shared implementation // for fast inversion of matrices of size 4. EIGEN_STRONG_INLINE Packet2d shuffle(const Packet2d& m, const Packet2d& n, int mask) {
diff --git a/Eigen/src/Core/arch/SSE/PacketMath.h b/Eigen/src/Core/arch/SSE/PacketMath.h index e19e948..e5dce3b 100644 --- a/Eigen/src/Core/arch/SSE/PacketMath.h +++ b/Eigen/src/Core/arch/SSE/PacketMath.h
@@ -1127,7 +1127,7 @@ return pselect<Packet>(not_nan_mask_a, m, a); } -// Add specializations for min/max with prescribed NaN progation. +// Add specializations for min/max with prescribed NaN propagation. template <> EIGEN_STRONG_INLINE Packet4f pmin<PropagateNumbers, Packet4f>(const Packet4f& a, const Packet4f& b) { return pminmax_propagate_numbers(a, b, pmin<Packet4f>);
diff --git a/Eigen/src/Core/products/GeneralBlockPanelKernel.h b/Eigen/src/Core/products/GeneralBlockPanelKernel.h index c4fa771..b65c246 100644 --- a/Eigen/src/Core/products/GeneralBlockPanelKernel.h +++ b/Eigen/src/Core/products/GeneralBlockPanelKernel.h
@@ -718,10 +718,10 @@ LhsPacketSize = Vectorizable ? unpacket_traits<LhsPacket_>::size : 1, RhsPacketSize = Vectorizable ? unpacket_traits<RhsScalar>::size : 1, RealPacketSize = Vectorizable ? unpacket_traits<RealPacket>::size : 1, + NumberOfRegisters = EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS, - // FIXME: should depend on NumberOfRegisters nr = 4, - mr = ResPacketSize, + mr = (plain_enum_min(16, NumberOfRegisters) / 2 / nr) * ResPacketSize, LhsProgress = ResPacketSize, RhsProgress = 1 @@ -795,8 +795,8 @@ DoublePacket<ResPacketType>& c, TmpType& /*tmp*/, const LaneIdType&) const { - c.first = padd(pmul(a, b.first), c.first); - c.second = padd(pmul(a, b.second), c.second); + c.first = pmadd(a, b.first, c.first); + c.second = pmadd(a, b.second, c.second); } template <typename LaneIdType> @@ -1257,7 +1257,7 @@ traits.initAcc(C3); // To improve instruction pipelining, let's double the accumulation registers: // even k will accumulate in C*, while odd k will accumulate in D*. - // This trick is crutial to get good performance with FMA, otherwise it is + // This trick is crucial to get good performance with FMA, otherwise it is // actually faster to perform separated MUL+ADD because of a naturally // better instruction-level parallelism. AccPacket D0, D1, D2, D3; @@ -3130,9 +3130,8 @@ return l2; } -/** \returns the currently set level 3 cpu cache size (in bytes) used to estimate the ideal blocking size paramete\ -rs. -* \sa setCpuCacheSize */ +/** \returns the currently set level 3 cpu cache size (in bytes) used to estimate the ideal blocking size parameters. + * \sa setCpuCacheSize */ inline std::ptrdiff_t l3CacheSize() { std::ptrdiff_t l1, l2, l3; internal::manage_caching_sizes(GetAction, &l1, &l2, &l3);
diff --git a/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h b/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h index e138535..6817cc0 100644 --- a/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h +++ b/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h
@@ -137,7 +137,7 @@ EIGEN_BLAS_RANKUPDATE_R(float, float, ssyrk_) #endif -// TODO hanlde complex cases +// TODO handle complex cases // EIGEN_BLAS_RANKUPDATE_C(dcomplex, double, double, zherk_) // EIGEN_BLAS_RANKUPDATE_C(scomplex, float, float, cherk_)
diff --git a/Eigen/src/Core/products/GeneralMatrixVector.h b/Eigen/src/Core/products/GeneralMatrixVector.h index afd8155..ba72a8a 100644 --- a/Eigen/src/Core/products/GeneralMatrixVector.h +++ b/Eigen/src/Core/products/GeneralMatrixVector.h
@@ -64,7 +64,7 @@ /* Optimized col-major matrix * vector product: * This algorithm processes the matrix per vertical panels, - * which are then processed horizontally per chunck of 8*PacketSize x 1 vertical segments. + * which are then processed horizontally per chunk of 8*PacketSize x 1 vertical segments. * * Mixing type logic: C += alpha * A * B * | A | B |alpha| comments @@ -112,7 +112,7 @@ eigen_internal_assert(resIncr == 1); // The following copy tells the compiler that lhs's attributes are not modified outside this function - // This helps GCC to generate propoer code. + // This helps GCC to generate proper code. LhsMapper lhs(alhs); conj_helper<LhsScalar, RhsScalar, ConjugateLhs, ConjugateRhs> cj; @@ -302,7 +302,7 @@ Version>::run(Index rows, Index cols, const LhsMapper& alhs, const RhsMapper& rhs, ResScalar* res, Index resIncr, ResScalar alpha) { // The following copy tells the compiler that lhs's attributes are not modified outside this function - // This helps GCC to generate propoer code. + // This helps GCC to generate proper code. LhsMapper lhs(alhs); eigen_internal_assert(rhs.stride() == 1);
diff --git a/Eigen/src/Core/util/ConfigureVectorization.h b/Eigen/src/Core/util/ConfigureVectorization.h index 6c53b87..47ddd4f 100644 --- a/Eigen/src/Core/util/ConfigureVectorization.h +++ b/Eigen/src/Core/util/ConfigureVectorization.h
@@ -41,11 +41,10 @@ // Align to the boundary that avoids false sharing. // https://en.cppreference.com/w/cpp/thread/hardware_destructive_interference_size #ifdef __cpp_lib_hardware_interference_size -#define EIGEN_ALIGN_TO_AVOID_FALSE_SHARING \ - EIGEN_ALIGN_TO_BOUNDARY(std::hardware_destructive_interference_size) +#define EIGEN_ALIGN_TO_AVOID_FALSE_SHARING EIGEN_ALIGN_TO_BOUNDARY(std::hardware_destructive_interference_size) #else -#define EIGEN_ALIGN_TO_AVOID_FALSE_SHARING \ - EIGEN_ALIGN_TO_BOUNDARY(128) +// Overalign for the cache line size of 128 bytes (Apple M1) +#define EIGEN_ALIGN_TO_AVOID_FALSE_SHARING EIGEN_ALIGN_TO_BOUNDARY(128) #endif // If the user explicitly disable vectorization, then we also disable alignment
diff --git a/Eigen/src/Core/util/Constants.h b/Eigen/src/Core/util/Constants.h index 9f4a2d8..4f0b273 100644 --- a/Eigen/src/Core/util/Constants.h +++ b/Eigen/src/Core/util/Constants.h
@@ -152,7 +152,7 @@ * Means that the underlying array of coefficients can be directly accessed as a plain strided array. The memory layout * of the array of coefficients must be exactly the natural one suggested by rows(), cols(), * outerStride(), innerStride(), and the RowMajorBit. This rules out expressions such as Diagonal, whose coefficients, - * though referencable, do not have such a regular memory layout. + * though referenceable, do not have such a regular memory layout. * * See the comment on LvalueBit for an explanation of how LvalueBit and DirectAccessBit are mutually orthogonal. */
diff --git a/Eigen/src/Core/util/IntegralConstant.h b/Eigen/src/Core/util/IntegralConstant.h index 2eb5fd9..53fabd5 100644 --- a/Eigen/src/Core/util/IntegralConstant.h +++ b/Eigen/src/Core/util/IntegralConstant.h
@@ -263,8 +263,8 @@ * } * \endcode * In this example, the function Eigen::seqN knows that the second argument is expected to be a size. - * If the passed compile-time value N equals Eigen::Dynamic, then the proxy object returned by fix will be dissmissed, - * and converted to an Eigen::Index of value \c n. Otherwise, the runtime-value \c n will be dissmissed, and the + * If the passed compile-time value N equals Eigen::Dynamic, then the proxy object returned by fix will be dismissed, + * and converted to an Eigen::Index of value \c n. Otherwise, the runtime-value \c n will be dismissed, and the * returned ArithmeticSequence will be of the exact same type as <tt> seqN(0,fix<N>) </tt>. * * \sa fix, seqN, class ArithmeticSequence
diff --git a/Eigen/src/Core/util/Macros.h b/Eigen/src/Core/util/Macros.h index d2236cf..d6db90a 100644 --- a/Eigen/src/Core/util/Macros.h +++ b/Eigen/src/Core/util/Macros.h
@@ -216,7 +216,7 @@ /// \internal EIGEN_COMP_FCC set to FCC version if the compiler is Fujitsu Compiler (traditional mode) /// \note The Fujitsu C/C++ compiler uses the traditional mode based -/// on EDG g++ 6.1 by default or if envoked with the -Nnoclang flag +/// on EDG g++ 6.1 by default or if invoked with the -Nnoclang flag #if defined(__FUJITSU) #define EIGEN_COMP_FCC (__FCC_major__ * 100 + __FCC_minor__ * 10 + __FCC_patchlevel__) #else @@ -225,7 +225,7 @@ /// \internal EIGEN_COMP_CLANGFCC set to FCC version if the compiler is Fujitsu Compiler (Clang mode) /// \note The Fujitsu C/C++ compiler uses the non-traditional mode -/// based on Clang 7.1.0 if envoked with the -Nclang flag +/// based on Clang 7.1.0 if invoked with the -Nclang flag #if defined(__CLANG_FUJITSU) #define EIGEN_COMP_CLANGFCC (__FCC_major__ * 100 + __FCC_minor__ * 10 + __FCC_patchlevel__) #else
diff --git a/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h b/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h index 08f1e34..ca15e6d 100644 --- a/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h +++ b/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h
@@ -361,7 +361,7 @@ // Compute eigenvector in position (i+1) and then position (i) is just the conjugate cv.setZero(); cv.coeffRef(i + 1) = Scalar(1.0); - // here, the "static_cast" workaound expression template issues. + // here, the "static_cast" workaround expression template issues. cv.coeffRef(i) = -(static_cast<Scalar>(beta * mS.coeffRef(i, i + 1)) - alpha * mT.coeffRef(i, i + 1)) / (static_cast<Scalar>(beta * mS.coeffRef(i, i)) - alpha * mT.coeffRef(i, i)); for (Index j = i - 1; j >= 0; j--) {
diff --git a/Eigen/src/Geometry/Rotation2D.h b/Eigen/src/Geometry/Rotation2D.h index eb94b52..5918025 100644 --- a/Eigen/src/Geometry/Rotation2D.h +++ b/Eigen/src/Geometry/Rotation2D.h
@@ -60,7 +60,7 @@ /** Construct a 2D counter clock wise rotation from the angle \a a in radian. */ EIGEN_DEVICE_FUNC explicit inline Rotation2D(const Scalar& a) : m_angle(a) {} - /** Default constructor wihtout initialization. The represented rotation is undefined. */ + /** Default constructor without initialization. The represented rotation is undefined. */ EIGEN_DEVICE_FUNC Rotation2D() {} /** Construct a 2D rotation from a 2x2 rotation matrix \a mat.
diff --git a/Eigen/src/Householder/BlockHouseholder.h b/Eigen/src/Householder/BlockHouseholder.h index 1d6cc1c..8b92304 100644 --- a/Eigen/src/Householder/BlockHouseholder.h +++ b/Eigen/src/Householder/BlockHouseholder.h
@@ -35,7 +35,7 @@ // // Warning, note that hCoeffs may alias with vectors. // // It is then necessary to copy it before modifying vectors(i,i). // typename CoeffsType::Scalar h = hCoeffs(i); -// // This hack permits to pass trough nested Block<> and Transpose<> expressions. +// // This hack permits to pass through nested Block<> and Transpose<> expressions. // Scalar *Vii_ptr = const_cast<Scalar*>(vectors.data() + vectors.outerStride()*i + vectors.innerStride()*i); // Scalar Vii = *Vii_ptr; // *Vii_ptr = Scalar(1);
diff --git a/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h b/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h index 020241b..2b146b3 100644 --- a/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h +++ b/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h
@@ -23,7 +23,7 @@ * * \brief Pseudo expression representing a solving operation * - * \tparam Decomposition the type of the matrix or decomposion object + * \tparam Decomposition the type of the matrix or decomposition object * \tparam Rhstype the type of the right-hand side * * This class represents an expression of A.solve(B)
diff --git a/Eigen/src/LU/arch/InverseSize4.h b/Eigen/src/LU/arch/InverseSize4.h index f0ddb2f..29c9b03 100644 --- a/Eigen/src/LU/arch/InverseSize4.h +++ b/Eigen/src/LU/arch/InverseSize4.h
@@ -24,7 +24,7 @@ // // Copyright (c) 2001 Intel Corporation. // -// Permition is granted to use, copy, distribute and prepare derivative works +// Permission is granted to use, copy, distribute and prepare derivative works // of this library for any purpose and without fee, provided, that the above // copyright notice and this statement appear in all copies. // Intel makes no representations about the suitability of this software for
diff --git a/Eigen/src/OrderingMethods/Eigen_Colamd.h b/Eigen/src/OrderingMethods/Eigen_Colamd.h index 7bce3d5..f6c5be0 100644 --- a/Eigen/src/OrderingMethods/Eigen_Colamd.h +++ b/Eigen/src/OrderingMethods/Eigen_Colamd.h
@@ -1374,7 +1374,7 @@ /* order this column */ Col[c].shared2.order = order++; - /* collaps tree */ + /* collapse tree */ Col[c].shared1.parent = parent; /* get immediate parent of this column */
diff --git a/Eigen/src/SVD/BDCSVD.h b/Eigen/src/SVD/BDCSVD.h index 52f3564..192f42f 100644 --- a/Eigen/src/SVD/BDCSVD.h +++ b/Eigen/src/SVD/BDCSVD.h
@@ -164,10 +164,10 @@ * Like the default constructor but with preallocation of the internal data * according to the specified problem size and the \a computationOptions. * - * One \b cannot request unitiaries using both the \a Options template parameter + * One \b cannot request unitaries using both the \a Options template parameter * and the constructor. If possible, prefer using the \a Options template parameter. * - * \param computationOptions specifification for computing Thin/Full unitaries U/V + * \param computationOptions specification for computing Thin/Full unitaries U/V * \sa BDCSVD() * * \deprecated Will be removed in the next major Eigen version. Options should @@ -179,7 +179,7 @@ } /** \brief Constructor performing the decomposition of given matrix, using the custom options specified - * with the \a Options template paramter. + * with the \a Options template parameter. * * \param matrix the matrix to decompose */ @@ -190,11 +190,11 @@ /** \brief Constructor performing the decomposition of given matrix using specified options * for computing unitaries. * - * One \b cannot request unitiaries using both the \a Options template parameter + * One \b cannot request unitaries using both the \a Options template parameter * and the constructor. If possible, prefer using the \a Options template parameter. * * \param matrix the matrix to decompose - * \param computationOptions specifification for computing Thin/Full unitaries U/V + * \param computationOptions specification for computing Thin/Full unitaries U/V * * \deprecated Will be removed in the next major Eigen version. Options should * be specified in the \a Options template parameter. @@ -1048,7 +1048,7 @@ } else { // We have a problem as shifting on the left or right give either a positive or negative value // at the middle of [left,right]... - // Instead fo abbording or entering an infinite loop, + // Instead of abbording or entering an infinite loop, // let's just use the middle as the estimated zero-crossing: muCur = (right - left) * RealScalar(0.5); // we can test exact equality here, because shift comes from `... ? left : right`
diff --git a/Eigen/src/SVD/JacobiSVD.h b/Eigen/src/SVD/JacobiSVD.h index 086d750..615aad1 100644 --- a/Eigen/src/SVD/JacobiSVD.h +++ b/Eigen/src/SVD/JacobiSVD.h
@@ -559,7 +559,7 @@ } /** \brief Constructor performing the decomposition of given matrix, using the custom options specified - * with the \a Options template paramter. + * with the \a Options template parameter. * * \param matrix the matrix to decompose */
diff --git a/Eigen/src/SparseCore/SparseCwiseBinaryOp.h b/Eigen/src/SparseCore/SparseCwiseBinaryOp.h index 6858263..7fcf2c2 100644 --- a/Eigen/src/SparseCore/SparseCwiseBinaryOp.h +++ b/Eigen/src/SparseCore/SparseCwiseBinaryOp.h
@@ -834,7 +834,7 @@ const XprType& m_expr; }; -// when DupFunc is wrapped with scalar_dup_op, use disjunction evaulator +// when DupFunc is wrapped with scalar_dup_op, use disjunction evaluator template <typename T1, typename T2, typename DupFunc, typename Lhs, typename Rhs> struct binary_evaluator<CwiseBinaryOp<scalar_disjunction_op<DupFunc, T1, T2>, Lhs, Rhs>, IteratorBased, IteratorBased> : sparse_disjunction_evaluator<CwiseBinaryOp<scalar_disjunction_op<DupFunc, T1, T2>, Lhs, Rhs> > {
diff --git a/Eigen/src/SparseCore/SparseMatrix.h b/Eigen/src/SparseCore/SparseMatrix.h index fd92ab0..24ebb7c 100644 --- a/Eigen/src/SparseCore/SparseMatrix.h +++ b/Eigen/src/SparseCore/SparseMatrix.h
@@ -250,7 +250,7 @@ } } if ((dst < end) && (m_data.index(dst) == inner)) { - // this coefficient exists, return a refernece to it + // this coefficient exists, return a reference to it if (inserted != nullptr) { *inserted = false; } @@ -1226,8 +1226,8 @@ // matrix is finalized } -// thin wrapper around a generic binary functor to use the sparse disjunction evaulator instead of the default -// "arithmetic" evaulator +// thin wrapper around a generic binary functor to use the sparse disjunction evaluator instead of the default +// "arithmetic" evaluator template <typename DupFunctor, typename LhsScalar, typename RhsScalar = LhsScalar> struct scalar_disjunction_op { using result_type = typename result_of<DupFunctor(LhsScalar, RhsScalar)>::type; @@ -1633,7 +1633,7 @@ // first, check if there is adequate allocated memory if (m_data.allocatedSize() <= m_data.size()) { // if there is no capacity for a single insertion, double the capacity - // increase capacity by a mininum of 32 + // increase capacity by a minimum of 32 Index minReserve = 32; Index reserveSize = numext::maxi(minReserve, m_data.allocatedSize()); m_data.reserve(reserveSize);
diff --git a/Eigen/src/SparseCore/SparseSelfAdjointView.h b/Eigen/src/SparseCore/SparseSelfAdjointView.h index 3402bae..05b3de5 100644 --- a/Eigen/src/SparseCore/SparseSelfAdjointView.h +++ b/Eigen/src/SparseCore/SparseSelfAdjointView.h
@@ -143,7 +143,7 @@ return *this = src.twistedBy(pnull); } - // Since we override the copy-assignment operator, we need to explicitly re-declare the copy-constructor + // Since we override the copy-assignment operator, we need to explicitly redeclare the copy-constructor EIGEN_DEFAULT_COPY_CONSTRUCTOR(SparseSelfAdjointView) template <typename SrcMatrixType, unsigned int SrcMode>
diff --git a/Eigen/src/SparseCore/SparseVector.h b/Eigen/src/SparseCore/SparseVector.h index fac162e..6b1816b 100644 --- a/Eigen/src/SparseCore/SparseVector.h +++ b/Eigen/src/SparseCore/SparseVector.h
@@ -109,7 +109,7 @@ } /** \returns a reference to the coefficient value at given index \a i - * This operation involes a log(rho*size) binary search. If the coefficient does not + * This operation involves a log(rho*size) binary search. If the coefficient does not * exist yet, then a sorted insertion into a sequential buffer is performed. * * This insertion might be very costly if the number of nonzeros above \a i is large.
diff --git a/Eigen/src/SparseLU/SparseLU.h b/Eigen/src/SparseLU/SparseLU.h index 29be01a..cc69a42 100644 --- a/Eigen/src/SparseLU/SparseLU.h +++ b/Eigen/src/SparseLU/SparseLU.h
@@ -257,7 +257,7 @@ /** \brief Give the number of rows. */ inline Index rows() const { return m_mat.rows(); } - /** \brief Give the numver of columns. + /** \brief Give the number of columns. */ inline Index cols() const { return m_mat.cols(); } /** \brief Let you set that the pattern of the input matrix is symmetric @@ -600,7 +600,7 @@ * This exit was 0 if successful factorization. * > 0 if info = i, and i is been completed, but the factor U is exactly singular, * and division by zero will occur if it is used to solve a system of equation. - * > A->ncol: number of bytes allocated when memory allocation failure occured, plus A->ncol. + * > A->ncol: number of bytes allocated when memory allocation failure occurred, plus A->ncol. * If lwork = -1, it is the estimated amount of space needed, plus A->ncol. * * It seems that A was the name of the matrix in the past.
diff --git a/Eigen/src/SparseLU/SparseLU_Structs.h b/Eigen/src/SparseLU/SparseLU_Structs.h index 2afab01..85ba884 100644 --- a/Eigen/src/SparseLU/SparseLU_Structs.h +++ b/Eigen/src/SparseLU/SparseLU_Structs.h
@@ -50,7 +50,7 @@ * values. * * The last column structures (for pruning) will be removed - * after the numercial LU factorization phase. + * after the numerical LU factorization phase. * * (xlusup,lusup): lusup[*] contains the numerical values of the * rectangular supernodes; xlusup[j] points to the starting
diff --git a/Eigen/src/SparseLU/SparseLU_pivotL.h b/Eigen/src/SparseLU/SparseLU_pivotL.h index ada511e..10a090b 100644 --- a/Eigen/src/SparseLU/SparseLU_pivotL.h +++ b/Eigen/src/SparseLU/SparseLU_pivotL.h
@@ -37,7 +37,7 @@ namespace internal { /** - * \brief Performs the numerical pivotin on the current column of L, and the CDIV operation. + * \brief Performs the numerical pivoting on the current column of L, and the CDIV operation. * * Pivot policy : * (1) Compute thresh = u * max_(i>=j) abs(A_ij);
diff --git a/Eigen/src/SparseLU/SparseLU_pruneL.h b/Eigen/src/SparseLU/SparseLU_pruneL.h index 4f51d59..620f285 100644 --- a/Eigen/src/SparseLU/SparseLU_pruneL.h +++ b/Eigen/src/SparseLU/SparseLU_pruneL.h
@@ -101,7 +101,7 @@ kmin++; else { // kmin below pivrow (not yet pivoted), and kmax - // above pivrow: interchange the two suscripts + // above pivrow: interchange the two subscripts std::swap(glu.lsub(kmin), glu.lsub(kmax)); // If the supernode has only one column, then we
diff --git a/Eigen/src/ThreadPool/NonBlockingThreadPool.h b/Eigen/src/ThreadPool/NonBlockingThreadPool.h index b3575c7..7caeecf 100644 --- a/Eigen/src/ThreadPool/NonBlockingThreadPool.h +++ b/Eigen/src/ThreadPool/NonBlockingThreadPool.h
@@ -261,8 +261,7 @@ // Decodes `spinning_state_` value. static SpinningState Decode(uint64_t state) { uint64_t num_spinning = (state & kNumSpinningMask); - uint64_t num_no_notification = - (state & kNumNoNotifyMask) >> kNumNoNotifyShift; + uint64_t num_no_notification = (state & kNumNoNotifyMask) >> kNumNoNotifyShift; assert(num_no_notification <= num_spinning); return {num_spinning, num_no_notification}; @@ -319,9 +318,7 @@ // a constant rate, so we divide `kSpintCount` by number of threads and // number of spinning threads. The constant was picked based on a fair dice // roll, tune it. - const int spin_count = allow_spinning_ && num_threads_ > 0 - ? kSpinCount / kMaxSpinningThreads / num_threads_ - : 0; + const int spin_count = allow_spinning_ && num_threads_ > 0 ? kSpinCount / kMaxSpinningThreads / num_threads_ : 0; if (num_threads_ == 1) { // For num_threads_ == 1 there is no point in going through the expensive // steal loop. Moreover, since NonEmptyQueueIndex() calls PopBack() on the @@ -525,16 +522,14 @@ for (;;) { SpinningState state = SpinningState::Decode(spinning); - if ((state.num_spinning - state.num_no_notification) >= - kMaxSpinningThreads) { + if ((state.num_spinning - state.num_no_notification) >= kMaxSpinningThreads) { return false; } // Increment the number of spinning threads. ++state.num_spinning; - if (spinning_state_.compare_exchange_weak(spinning, state.Encode(), - std::memory_order_relaxed)) { + if (spinning_state_.compare_exchange_weak(spinning, state.Encode(), std::memory_order_relaxed)) { return true; } } @@ -557,8 +552,7 @@ bool has_no_notify_task = state.num_no_notification > 0; if (has_no_notify_task) --state.num_no_notification; - if (spinning_state_.compare_exchange_weak(spinning, state.Encode(), - std::memory_order_relaxed)) { + if (spinning_state_.compare_exchange_weak(spinning, state.Encode(), std::memory_order_relaxed)) { return has_no_notify_task; } } @@ -581,8 +575,7 @@ // Increment the number of tasks submitted without notification. ++state.num_no_notification; - if (spinning_state_.compare_exchange_weak(spinning, state.Encode(), - std::memory_order_relaxed)) { + if (spinning_state_.compare_exchange_weak(spinning, state.Encode(), std::memory_order_relaxed)) { return false; } }
diff --git a/Eigen/src/ThreadPool/RunQueue.h b/Eigen/src/ThreadPool/RunQueue.h index 9b1fb9e..9046b18 100644 --- a/Eigen/src/ThreadPool/RunQueue.h +++ b/Eigen/src/ThreadPool/RunQueue.h
@@ -45,8 +45,7 @@ eigen_plain_assert((kSize & (kSize - 1)) == 0); eigen_plain_assert(kSize > 2); // why would you do this? eigen_plain_assert(kSize <= (64 << 10)); // leave enough space for counter - for (unsigned i = 0; i < kSize; i++) - array_[i].state.store(kEmpty, std::memory_order_relaxed); + for (unsigned i = 0; i < kSize; i++) array_[i].state.store(kEmpty, std::memory_order_relaxed); } ~RunQueue() { eigen_plain_assert(Size() == 0); } @@ -57,9 +56,7 @@ unsigned front = front_.load(std::memory_order_relaxed); Elem* e = &array_[front & kMask]; uint8_t s = e->state.load(std::memory_order_relaxed); - if (s != kEmpty || - !e->state.compare_exchange_strong(s, kBusy, std::memory_order_acquire)) - return w; + if (s != kEmpty || !e->state.compare_exchange_strong(s, kBusy, std::memory_order_acquire)) return w; front_.store(front + 1 + (kSize << 1), std::memory_order_relaxed); e->w = std::move(w); e->state.store(kReady, std::memory_order_release); @@ -72,9 +69,7 @@ unsigned front = front_.load(std::memory_order_relaxed); Elem* e = &array_[(front - 1) & kMask]; uint8_t s = e->state.load(std::memory_order_relaxed); - if (s != kReady || - !e->state.compare_exchange_strong(s, kBusy, std::memory_order_acquire)) - return Work(); + if (s != kReady || !e->state.compare_exchange_strong(s, kBusy, std::memory_order_acquire)) return Work(); Work w = std::move(e->w); e->state.store(kEmpty, std::memory_order_release); front = ((front - 1) & kMask2) | (front & ~kMask2); @@ -89,9 +84,7 @@ unsigned back = back_.load(std::memory_order_relaxed); Elem* e = &array_[(back - 1) & kMask]; uint8_t s = e->state.load(std::memory_order_relaxed); - if (s != kEmpty || - !e->state.compare_exchange_strong(s, kBusy, std::memory_order_acquire)) - return w; + if (s != kEmpty || !e->state.compare_exchange_strong(s, kBusy, std::memory_order_acquire)) return w; back = ((back - 1) & kMask2) | (back & ~kMask2); back_.store(back, std::memory_order_relaxed); e->w = std::move(w); @@ -106,9 +99,7 @@ unsigned back = back_.load(std::memory_order_relaxed); Elem* e = &array_[back & kMask]; uint8_t s = e->state.load(std::memory_order_relaxed); - if (s != kReady || - !e->state.compare_exchange_strong(s, kBusy, std::memory_order_acquire)) - return Work(); + if (s != kReady || !e->state.compare_exchange_strong(s, kBusy, std::memory_order_acquire)) return Work(); Work w = std::move(e->w); e->state.store(kEmpty, std::memory_order_release); back_.store(back + 1 + (kSize << 1), std::memory_order_relaxed); @@ -130,9 +121,7 @@ Elem* e = &array_[mid & kMask]; uint8_t s = e->state.load(std::memory_order_relaxed); if (n == 0) { - if (s != kReady || !e->state.compare_exchange_strong( - s, kBusy, std::memory_order_acquire)) - continue; + if (s != kReady || !e->state.compare_exchange_strong(s, kBusy, std::memory_order_acquire)) continue; start = mid; } else { // Note: no need to store temporal kBusy, we exclusively own these @@ -143,8 +132,7 @@ e->state.store(kEmpty, std::memory_order_release); n++; } - if (n != 0) - back_.store(start + 1 + (kSize << 1), std::memory_order_relaxed); + if (n != 0) back_.store(start + 1 + (kSize << 1), std::memory_order_relaxed); return n; } @@ -221,8 +209,7 @@ } } - EIGEN_ALWAYS_INLINE unsigned CalculateSize(unsigned front, - unsigned back) const { + EIGEN_ALWAYS_INLINE unsigned CalculateSize(unsigned front, unsigned back) const { int size = (front & kMask2) - (back & kMask2); // Fix overflow. if (EIGEN_PREDICT_FALSE(size < 0)) size += 2 * kSize;
diff --git a/Eigen/src/plugins/ArrayCwiseUnaryOps.inc b/Eigen/src/plugins/ArrayCwiseUnaryOps.inc index 3f9d4e8..cc708fa 100644 --- a/Eigen/src/plugins/ArrayCwiseUnaryOps.inc +++ b/Eigen/src/plugins/ArrayCwiseUnaryOps.inc
@@ -518,7 +518,7 @@ const ScalarExponent& exponent) const { return UnaryPowReturnType<ScalarExponent>(derived(), internal::scalar_unary_pow_op<Scalar, ScalarExponent>(exponent)); #else -/** \returns an expression of the coefficients of \c *this rasied to the constant power \a exponent +/** \returns an expression of the coefficients of \c *this raised to the constant power \a exponent * * \tparam T is the scalar type of \a exponent. It must be compatible with the scalar type of the given expression. *
diff --git a/demos/opengl/gpuhelper.cpp b/demos/opengl/gpuhelper.cpp index 9e3ecbe..fdf559b 100644 --- a/demos/opengl/gpuhelper.cpp +++ b/demos/opengl/gpuhelper.cpp
@@ -46,7 +46,7 @@ } void GpuHelper::drawVector(const Vector3f& position, const Vector3f& vec, const Color& color, float aspect /* = 50.*/) { - static GLUquadricObj* cylindre = gluNewQuadric(); + static GLUquadricObj* cylinder = gluNewQuadric(); glColor4fv(color.data()); float length = vec.norm(); pushMatrix(GL_MODELVIEW); @@ -57,15 +57,15 @@ tmp.normalize(); float angle = 180.f / M_PI * acos(tmp.z()); if (angle > 1e-3) glRotatef(angle, ax.x(), ax.y(), ax.z()); - gluCylinder(cylindre, length / aspect, length / aspect, 0.8 * length, 10, 10); + gluCylinder(cylinder, length / aspect, length / aspect, 0.8 * length, 10, 10); glTranslatef(0.0, 0.0, 0.8 * length); - gluCylinder(cylindre, 2.0 * length / aspect, 0.0, 0.2 * length, 10, 10); + gluCylinder(cylinder, 2.0 * length / aspect, 0.0, 0.2 * length, 10, 10); popMatrix(GL_MODELVIEW); } void GpuHelper::drawVectorBox(const Vector3f& position, const Vector3f& vec, const Color& color, float aspect) { - static GLUquadricObj* cylindre = gluNewQuadric(); + static GLUquadricObj* cylinder = gluNewQuadric(); glColor4fv(color.data()); float length = vec.norm(); pushMatrix(GL_MODELVIEW); @@ -76,7 +76,7 @@ tmp.normalize(); float angle = 180.f / M_PI * acos(tmp.z()); if (angle > 1e-3) glRotatef(angle, ax.x(), ax.y(), ax.z()); - gluCylinder(cylindre, length / aspect, length / aspect, 0.8 * length, 10, 10); + gluCylinder(cylinder, length / aspect, length / aspect, 0.8 * length, 10, 10); glTranslatef(0.0, 0.0, 0.8 * length); glScalef(4.0 * length / aspect, 4.0 * length / aspect, 4.0 * length / aspect); drawUnitCube();
diff --git a/doc/InsideEigenExample.dox b/doc/InsideEigenExample.dox index 4af185d..570ecbf 100644 --- a/doc/InsideEigenExample.dox +++ b/doc/InsideEigenExample.dox
@@ -278,7 +278,7 @@ EvalBeforeAssigning is here to enforce the EvalBeforeAssigningBit. As explained <a href="TopicLazyEvaluation.html">here</a>, certain expressions have this flag which makes them automatically evaluate into temporaries before assigning them to another expression. This is the case of the Product expression, in order to avoid strange aliasing effects when doing "m = m * m;" However, of course here our CwiseBinaryOp expression doesn't have the EvalBeforeAssigningBit: we said since the beginning that we didn't want a temporary to be introduced here. So if you go to src/Core/CwiseBinaryOp.h, you'll see that the Flags in internal::traits\<CwiseBinaryOp\> don't include the EvalBeforeAssigningBit. The Flags member of CwiseBinaryOp is then imported from the internal::traits by the EIGEN_GENERIC_PUBLIC_INTERFACE macro. Anyway, here the template parameter EvalBeforeAssigning has the value \c false. -NeedToTranspose is here for the case where the user wants to copy a row-vector into a column-vector. We allow this as a special exception to the general rule that in assignments we require the dimesions to match. Anyway, here both the left-hand and right-hand sides are column vectors, in the sense that ColsAtCompileTime is equal to 1. So NeedToTranspose is \c false too. +NeedToTranspose is here for the case where the user wants to copy a row-vector into a column-vector. We allow this as a special exception to the general rule that in assignments we require the dimensions to match. Anyway, here both the left-hand and right-hand sides are column vectors, in the sense that ColsAtCompileTime is equal to 1. So NeedToTranspose is \c false too. So, here we are in the partial specialization: \code
diff --git a/doc/PreprocessorDirectives.dox b/doc/PreprocessorDirectives.dox index be47ac9..27ae531 100644 --- a/doc/PreprocessorDirectives.dox +++ b/doc/PreprocessorDirectives.dox
@@ -29,7 +29,7 @@ initialized to zero, as are new entries in matrices and arrays after resizing. Not defined by default. \warning The unary (resp. binary) constructor of \c 1x1 (resp. \c 2x1 or \c 1x2) fixed size matrices is always interpreted as an initialization constructor where the argument(s) are the coefficient values - and not the sizes. For instance, \code Vector2d v(2,1); \endcode will create a vector with coeficients [2,1], + and not the sizes. For instance, \code Vector2d v(2,1); \endcode will create a vector with coefficients [2,1], and \b not a \c 2x1 vector initialized with zeros (i.e., [0,0]). If such cases might occur, then it is recommended to use the default constructor with a explicit call to resize: \code
diff --git a/doc/SparseQuickReference.dox b/doc/SparseQuickReference.dox index 66288cd..b8eac8d 100644 --- a/doc/SparseQuickReference.dox +++ b/doc/SparseQuickReference.dox
@@ -89,7 +89,7 @@ sm1.nonZeros(); // Number of non zero values sm1.outerSize(); // Number of columns (resp. rows) for a column major (resp. row major ) sm1.innerSize(); // Number of rows (resp. columns) for a row major (resp. column major) - sm1.norm(); // Euclidian norm of the matrix + sm1.norm(); // Euclidean norm of the matrix sm1.squaredNorm(); // Squared norm of the matrix sm1.blueNorm(); sm1.isVector(); // Check if sm1 is a sparse vector or a sparse matrix
diff --git a/doc/TopicAssertions.dox b/doc/TopicAssertions.dox index c8b4d84..a2cc6cf 100644 --- a/doc/TopicAssertions.dox +++ b/doc/TopicAssertions.dox
@@ -70,9 +70,9 @@ - \b EIGEN_STATIC_ASSERT_FIXED_SIZE(TYPE) - passes if \a TYPE is fixed size. - \b EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(TYPE) - passes if \a TYPE is dynamic size. -- \b EIGEN_STATIC_ASSERT_LVALUE(Derived) - failes if \a Derived is read-only. +- \b EIGEN_STATIC_ASSERT_LVALUE(Derived) - fails if \a Derived is read-only. - \b EIGEN_STATIC_ASSERT_ARRAYXPR(Derived) - passes if \a Derived is an array expression. -- <b>EIGEN_STATIC_ASSERT_SAME_XPR_KIND(Derived1, Derived2)</b> - failes if the two expressions are an array one and a matrix one. +- <b>EIGEN_STATIC_ASSERT_SAME_XPR_KIND(Derived1, Derived2)</b> - fails if the two expressions are an array one and a matrix one. Because Eigen handles both fixed-size and dynamic-size expressions, some conditions cannot be clearly determined at compile time. We classify them into strict assertions and permissive assertions.
diff --git a/doc/eigen_navtree_hacks.js b/doc/eigen_navtree_hacks.js index f36b332..38a498a 100644 --- a/doc/eigen_navtree_hacks.js +++ b/doc/eigen_navtree_hacks.js
@@ -360,8 +360,8 @@ (function (){ // wait until the first "selected" element has been created try { - - // this line will triger an exception if there is no #selected element, i.e., before the tree structure is complete. + // this line will trigger an exception if there is no #selected element, i.e., before the tree structure is + // complete. document.getElementById("selected").className = "item selected"; // ok, the default tree has been created, we can keep going...
diff --git a/scripts/ci_cmake_msvc.ps1 b/scripts/ci_cmake_msvc.ps1 index 5dae3c8..c08b9ae 100644 --- a/scripts/ci_cmake_msvc.ps1 +++ b/scripts/ci_cmake_msvc.ps1
@@ -52,7 +52,7 @@ IF (-Not (Test-Path -Path $EIGEN_CI_BUILDDIR) ) { mkdir $EIGEN_CI_BUILDDIR } cd $EIGEN_CI_BUILDDIR -# We need to split EIGEN_CI_ADDITIONAL_ARGS, otherwise they are interpretted +# We need to split EIGEN_CI_ADDITIONAL_ARGS, otherwise they are interpreted # as a single argument. Split by space, unless double-quoted. $split_args = [regex]::Split(${EIGEN_CI_ADDITIONAL_ARGS}, ' (?=(?:[^"]|"[^"]*")*$)' ) cmake -G "${EIGEN_CI_CMAKE_GENERATOR}" -DCMAKE_BUILD_TYPE=MinSizeRel -DEIGEN_TEST_CUSTOM_CXX_FLAGS="${EIGEN_CI_TEST_CUSTOM_CXX_FLAGS}" ${split_args} "${EIGEN_CI_ROOTDIR}"
diff --git a/test/block.cpp b/test/block.cpp index 9f96498..c67dd22 100644 --- a/test/block.cpp +++ b/test/block.cpp
@@ -153,7 +153,7 @@ VERIFY_IS_EQUAL(numext::real(ones.col(c1).dot(ones.col(c2))), RealScalar(rows)); VERIFY_IS_EQUAL(numext::real(ones.row(r1).dot(ones.row(r2))), RealScalar(cols)); - // check that linear acccessors works on blocks + // check that linear accessors works on blocks m1 = m1_copy; // now test some block-inside-of-block.
diff --git a/test/eigensolver_complex.cpp b/test/eigensolver_complex.cpp index 67aff4b..afb24b9 100644 --- a/test/eigensolver_complex.cpp +++ b/test/eigensolver_complex.cpp
@@ -44,7 +44,7 @@ /* Check that two column vectors are approximately equal up to permutations. * Initially, this method checked that the k-th power sums are equal for all k = 1, ..., vec1.rows(), - * however this strategy is numerically inacurate because of numerical cancellation issues. + * however this strategy is numerically inaccurate because of numerical cancellation issues. */ template <typename VectorType> void verify_is_approx_upto_permutation(const VectorType& vec1, const VectorType& vec2) {
diff --git a/unsupported/Eigen/CXX11/src/Tensor/README.md b/unsupported/Eigen/CXX11/src/Tensor/README.md index 443500a..6cd0ca3 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/README.md +++ b/unsupported/Eigen/CXX11/src/Tensor/README.md
@@ -898,7 +898,7 @@ ### (Operation) imag() -Returns a tensor with the same dimensions as the orginal tensor +Returns a tensor with the same dimensions as the original tensor containing the imaginary part of the complex values of the original tensor. @@ -910,7 +910,7 @@ The type of the exponent, Scalar, is always the same as the type of the tensor coefficients. For example, only integer exponents can be used in -conjuntion with tensors of integer values. +conjunction with tensors of integer values. You can use cast() to lift this restriction. For example this computes cubic roots of an int Tensor:
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h index 2f84787..c7203a9 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
@@ -104,10 +104,10 @@ static EIGEN_CONSTEXPR StorageIndex TileSizeDimM = LocalThreadSizeM * WorkLoadPerThreadM; // TileSizeDimN: determines the tile size for the n dimension static EIGEN_CONSTEXPR StorageIndex TileSizeDimN = LocalThreadSizeN * WorkLoadPerThreadN; - // LoadPerThreadLhs: determines workload per thread for loading Lhs Tensor. This must be divisable by packetsize + // LoadPerThreadLhs: determines workload per thread for loading Lhs Tensor. This must be divisible by packetsize static EIGEN_CONSTEXPR StorageIndex LoadPerThreadLhs = ((TileSizeDimK * WorkLoadPerThreadM * WorkLoadPerThreadN) / (TileSizeDimN)); - // LoadPerThreadRhs: determines workload per thread for loading Rhs Tensor. This must be divisable by packetsize + // LoadPerThreadRhs: determines workload per thread for loading Rhs Tensor. This must be divisible by packetsize static EIGEN_CONSTEXPR StorageIndex LoadPerThreadRhs = ((TileSizeDimK * WorkLoadPerThreadM * WorkLoadPerThreadN) / (TileSizeDimM)); // BC : determines if supporting bank conflict is required @@ -674,7 +674,7 @@ for (StorageIndex wLPTN = 0; wLPTN < Properties::WorkLoadPerThreadN / PrivateNStride; wLPTN++) { // output leading dimension StorageIndex outputLD = 0; - // When local memory is used the PrivateNstride is always 1 because the coalesed access on N is loaded into Local + // When local memory is used the PrivateNstride is always 1 because the coalesced access on N is loaded into Local // memory and extracting from local to global is the same as no transposed version. However, when local memory is // not used and RHS is transposed we packetize the load for RHS. EIGEN_UNROLL_LOOP @@ -898,7 +898,7 @@ EIGEN_CONSTEXPR StorageIndex LSD = InputBlockProperties::is_rhs ? LSDR : LSDL; static_assert(((LocalOffset % (TileSizeDimNC / InputBlockProperties::nc_stride) == 0) && (LocalOffset % (Properties::TileSizeDimK / InputBlockProperties::c_stride) == 0)), - " LocalOffset must be divisable by stride"); + " LocalOffset must be divisible by stride"); const StorageIndex &NC = InputBlockProperties::is_rhs ? triple_dim.N : triple_dim.M; StorageIndex localThreadNC = local_index.first; StorageIndex localThreadC = local_index.second;
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionThreadPool.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionThreadPool.h index e55459d..288d79f 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionThreadPool.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionThreadPool.h
@@ -932,7 +932,9 @@ kernel(m, n, k, use_thread_local); } else { eigen_assert(!use_thread_local); - device_.enqueueNoNotification([=]() { kernel(m, n, k, use_thread_local); }); + device_.enqueueNoNotification([this, m, n, k, use_thread_local]() { + kernel(m, n, k, use_thread_local); + }); } } @@ -980,7 +982,9 @@ } else { while (end - start > 1) { Index mid = (start + end) / 2; - device_.enqueueNoNotification([=]() { enqueue_packing_helper(mid, end, k, rhs); }); + device_.enqueueNoNotification([this, mid, end, k, rhs]() { + enqueue_packing_helper(mid, end, k, rhs); + }); end = mid; } @@ -996,7 +1000,9 @@ (k > 0 || std::this_thread::get_id() == created_by_thread_id_); if (pack_async) { - device_.enqueueNoNotification([=]() { enqueue_packing_helper(start, end, k, rhs); }); + device_.enqueueNoNotification([this, start, end, k, rhs]() { + enqueue_packing_helper(start, end, k, rhs); + }); } else { enqueue_packing_helper(start, end, k, rhs); } @@ -1277,7 +1283,9 @@ while (end_block_idx - start_block_idx > 1) { Index mid_block_idx = (start_block_idx + end_block_idx) / 2; evaluator->m_device.enqueueNoNotification( - [this, mid_block_idx, end_block_idx]() { evalAsync<Alignment>(mid_block_idx, end_block_idx); }); + [this, mid_block_idx, end_block_idx]() { + evalAsync<Alignment>(mid_block_idx, end_block_idx); + }); end_block_idx = mid_block_idx; }
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorDeviceThreadPool.h b/unsupported/Eigen/CXX11/src/Tensor/TensorDeviceThreadPool.h index ca1fe6a..c95c8f2 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorDeviceThreadPool.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorDeviceThreadPool.h
@@ -192,7 +192,7 @@ // block_count leaves that do actual computations. Barrier barrier(static_cast<unsigned int>(block.count)); std::function<void(Index, Index)> handleRange; - handleRange = [=, &handleRange, &barrier, &f](Index firstIdx, Index lastIdx) { + handleRange = [this, block, &handleRange, &barrier, &f](Index firstIdx, Index lastIdx) { while (lastIdx - firstIdx > block.size) { // Split into halves and schedule the second half on a different thread. const Index midIdx = firstIdx + numext::div_ceil((lastIdx - firstIdx) / 2, block.size) * block.size;
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorForwardDeclarations.h b/unsupported/Eigen/CXX11/src/Tensor/TensorForwardDeclarations.h index efb7f02..3bc3a5b 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorForwardDeclarations.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorForwardDeclarations.h
@@ -36,7 +36,7 @@ // used for referring to a Pointer on TensorEvaluator class. While the TensorExpression // is a device-agnostic type and need MakePointer class for type conversion, // the TensorEvaluator class can be specialized for a device, hence it is possible -// to construct different types of temproray storage memory in TensorEvaluator +// to construct different types of temporary storage memory in TensorEvaluator // for different devices by specializing the following StorageMemory class. template <typename T, typename device> struct StorageMemory : MakePointer<T> {};
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorRandom.h b/unsupported/Eigen/CXX11/src/Tensor/TensorRandom.h index 19404fe..c9c613a 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorRandom.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorRandom.h
@@ -136,7 +136,7 @@ // thread but for SYCL ((CLOCK * 6364136223846793005ULL) + 0xda3e39cb94b95bdbULL) is passed to each thread and each // thread adds the (global_thread_id* 6364136223846793005ULL) for itself only once, in order to complete the // construction similar to CUDA Therefore, the thread Id injection is not available at this stage. - // However when the operator() is called the thread ID will be available. So inside the opeator, + // However when the operator() is called the thread ID will be available. So inside the operator, // we add the thrreadID, BlockId,... (which is equivalent of i) // to the seed and construct the unique m_state per thead similar to cuda. m_exec_once = false;
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorReductionSycl.h b/unsupported/Eigen/CXX11/src/Tensor/TensorReductionSycl.h index fe0b849..6944c03 100644 --- a/unsupported/Eigen/CXX11/src/Tensor/TensorReductionSycl.h +++ b/unsupported/Eigen/CXX11/src/Tensor/TensorReductionSycl.h
@@ -433,7 +433,7 @@ EIGEN_CONSTEXPR Index localRange = PannelParameters::LocalThreadSizeP * PannelParameters::LocalThreadSizeR; // In this step, we force the code not to be more than 2-step reduction: // Our empirical research shows that if each thread reduces at least 64 - // elemnts individually, we get better performance. However, this can change + // elements individually, we get better performance. However, this can change // on different platforms. In this step we force the code not to be // morthan step reduction: Our empirical research shows that for inner_most // dim reducer, it is better to have 8 group in a reduce dimension for sizes @@ -495,7 +495,7 @@ typename Self::Index inputSize = self.impl().dimensions().TotalSize(); // In this step we force the code not to be more than 2-step reduction: // Our empirical research shows that if each thread reduces at least 512 - // elemnts individually, we get better performance. + // elements individually, we get better performance. const Index reductionPerThread = 2048; // const Index num_work_group = Index reductionGroup = dev.getPowerOfTwo(
diff --git a/unsupported/Eigen/NNLS b/unsupported/Eigen/NNLS index 2804508..2923f59 100644 --- a/unsupported/Eigen/NNLS +++ b/unsupported/Eigen/NNLS
@@ -275,7 +275,7 @@ const Index numActive = A_.cols() - numInactive_; Index argmaxGradient = -1; const Scalar maxGradient = gradient_(index_sets_.tail(numActive)).maxCoeff(&argmaxGradient); - argmaxGradient += numInactive_; // beacause tail() skipped the first numInactive_ elements + argmaxGradient += numInactive_; // because tail() skipped the first numInactive_ elements if (maxGradient < tolerance_) { info_ = ComputationInfo::Success; @@ -299,7 +299,7 @@ solveInactiveSet_(b); ++iterations_; // The solve is expensive, so that is what we count as an iteration. - // Check feasability... + // Check feasibility... bool feasible = true; Scalar alpha = NumTraits<Scalar>::highest(); Index infeasibleIdx = -1; // Which variable became infeasible first.
diff --git a/unsupported/Eigen/src/FFT/ei_kissfft_impl.h b/unsupported/Eigen/src/FFT/ei_kissfft_impl.h index 0d2b3cf..c201d80 100644 --- a/unsupported/Eigen/src/FFT/ei_kissfft_impl.h +++ b/unsupported/Eigen/src/FFT/ei_kissfft_impl.h
@@ -27,12 +27,14 @@ std::vector<Complex> m_scratchBuf; bool m_inverse; + static const Scalar m_pi4; // constant pi / 4 + inline void make_twiddles(int nfft, bool inverse) { using numext::cos; using numext::sin; m_inverse = inverse; m_twiddles.resize(nfft); - double phinc = 0.25 * double(EIGEN_PI) / nfft; + Scalar phinc = m_pi4 / nfft; Scalar flip = inverse ? Scalar(1) : Scalar(-1); m_twiddles[0] = Complex(Scalar(1), Scalar(0)); if ((nfft & 1) == 0) m_twiddles[nfft / 2] = Complex(Scalar(-1), Scalar(0)); @@ -279,6 +281,10 @@ } }; +template <typename _Scalar> +const typename kiss_cpx_fft<_Scalar>::Scalar kiss_cpx_fft<_Scalar>::m_pi4 = + numext::atan(kiss_cpx_fft<_Scalar>::Scalar(1)); + template <typename Scalar_> struct kissfft_impl { typedef Scalar_ Scalar;
diff --git a/unsupported/Eigen/src/IterativeSolvers/BiCGSTABL.h b/unsupported/Eigen/src/IterativeSolvers/BiCGSTABL.h index 141d705..0469a5a 100644 --- a/unsupported/Eigen/src/IterativeSolvers/BiCGSTABL.h +++ b/unsupported/Eigen/src/IterativeSolvers/BiCGSTABL.h
@@ -70,7 +70,7 @@ 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. + // rShadow is arbitrary, but must never be orthogonal to any residual. VectorType rShadow = VectorType::Random(N); VectorType x_prime = x; @@ -313,7 +313,7 @@ /** \internal */ /** Loops over the number of columns of b and does the following: - 1. sets the tolerence and maxIterations + 1. sets the tolerance and maxIterations 2. Calls the function that has the core solver routine */ template <typename Rhs, typename Dest>
diff --git a/unsupported/Eigen/src/IterativeSolvers/IDRSTABL.h b/unsupported/Eigen/src/IterativeSolvers/IDRSTABL.h index 712c171..e55c3b3 100644 --- a/unsupported/Eigen/src/IterativeSolvers/IDRSTABL.h +++ b/unsupported/Eigen/src/IterativeSolvers/IDRSTABL.h
@@ -150,7 +150,7 @@ 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 + floating-point types is intended here. Any arbitrary non-zero u is fine to continue, however if u contains either NaN or Inf the algorithm will break down. */
diff --git a/unsupported/Eigen/src/SparseExtra/SparseInverse.h b/unsupported/Eigen/src/SparseExtra/SparseInverse.h index 23a5fc4..142cc8f 100644 --- a/unsupported/Eigen/src/SparseExtra/SparseInverse.h +++ b/unsupported/Eigen/src/SparseExtra/SparseInverse.h
@@ -33,7 +33,7 @@ */ template <typename Scalar> class KahanSum { - // Straighforward Kahan summation for accurate accumulation of a sum of numbers + // Straightforward Kahan summation for accurate accumulation of a sum of numbers Scalar _sum{}; Scalar _correction{};
diff --git a/unsupported/test/levenberg_marquardt.cpp b/unsupported/test/levenberg_marquardt.cpp index 0203c65..8a8c838 100644 --- a/unsupported/test/levenberg_marquardt.cpp +++ b/unsupported/test/levenberg_marquardt.cpp
@@ -21,7 +21,7 @@ using std::sqrt; -// tolerance for chekcing number of iterations +// tolerance for checking number of iterations #define LM_EVAL_COUNT_TOL 2 struct lmder_functor : DenseFunctor<double> {
diff --git a/unsupported/test/minres.cpp b/unsupported/test/minres.cpp index 0d625c4..dfd5b9a 100644 --- a/unsupported/test/minres.cpp +++ b/unsupported/test/minres.cpp
@@ -37,5 +37,5 @@ EIGEN_DECLARE_TEST(minres) { CALL_SUBTEST_1(test_minres_T<double>()); - // CALL_SUBTEST_2(test_minres_T<std::compex<double> >()); + // CALL_SUBTEST_2(test_minres_T<std::complex<double> >()); }
diff --git a/unsupported/test/openglsupport.cpp b/unsupported/test/openglsupport.cpp index 18f990d..c70552a 100644 --- a/unsupported/test/openglsupport.cpp +++ b/unsupported/test/openglsupport.cpp
@@ -231,7 +231,7 @@ std::cerr << "GL version: " << gl_version_string << std::endl; std::cerr << "GLSL version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl; // Parse version from string since GL_MAJOR_VERSION is only supported in GL 3.0+. - // Version string guaranteed to be <major>.<minor><vender extension>. + // Version string guaranteed to be <major>.<minor><vendor extension>. GLint gl_major_version = gl_version_string[0] - '0'; GLint gl_minor_version = gl_version_string[2] - '0'; bool legacy_gl = gl_major_version < 3 || (gl_major_version == 3 && gl_minor_version < 2);