fixing a lot of typos

Eigen/src/Core/CoreEvaluators.h

@@ -402,7 +402,7 @@ struct nullary_wrapper<Scalar, NullaryOp, false, false, false> {};
 #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 @@ struct unary_evaluator<CwiseUnaryOp<core_cast_op<SrcType, DstType>, ArgType>, In
   // 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 @@ struct unary_evaluator<CwiseUnaryOp<core_cast_op<SrcType, DstType>, ArgType>, In
         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 @@ struct ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>, IndexBased
   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>>>

Eigen/src/Core/DeviceWrapper.h

@@ -82,7 +82,7 @@ struct AssignmentWithDevice<DstXprType, SrcXprType, Functor, Device, Dense2Dense
   }
 };
 
-// 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 @@ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DeviceWrapper<const Derived, Device> Eigen
   return DeviceWrapper<const Derived, Device>(derived(), device);
 }
 }  // namespace Eigen
-#endif
+#endif

Eigen/src/Core/GenericPacketMath.h

@@ -207,7 +207,7 @@ struct type_casting_traits {
   };
 };
 
-// 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 {

Eigen/src/Core/MathFunctionsImpl.h

@@ -23,7 +23,7 @@ namespace internal {
  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 @@ struct generic_reciprocal_newton_step<Packet, 0> {
  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 @@ struct generic_rsqrt_newton_step<Packet, 0> {
    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.
 

Eigen/src/Core/PermutationMatrix.h

@@ -170,7 +170,7 @@ class PermutationBase : public EigenBase<Derived> {
    * \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
    */

Eigen/src/Core/StableNorm.h

@@ -218,7 +218,7 @@ inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real Matr
   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()

Eigen/src/Core/Transpositions.h

@@ -91,7 +91,7 @@ class TranspositionsBase {
   /** \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:

Eigen/src/Core/Visitor.h

@@ -38,7 +38,7 @@ struct short_circuit_eval_impl<Visitor, true> {
 // 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 @@ struct visitor_impl<Visitor, Derived, UnrollCount, Vectorize, false, ShortCircui
 // 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;

Eigen/src/Core/arch/AVX/PacketMath.h

@@ -1180,7 +1180,7 @@ EIGEN_STRONG_INLINE Packet8i psign(const Packet8i& a) {
 }
 #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>);

Eigen/src/Core/arch/AVX512/PacketMath.h

@@ -572,7 +572,7 @@ EIGEN_STRONG_INLINE Packet8l pmax<Packet8l>(const Packet8l& a, const Packet8l& b
   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>);

Eigen/src/Core/arch/AVX512/TrsmKernel.h

@@ -206,7 +206,7 @@ EIGEN_ALWAYS_INLINE void transStoreC(PacketBlock<vec, EIGEN_ARCH_DEFAULT_NUMBER_
 /**
  * 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

Eigen/src/Core/arch/AVX512/TrsmUnrolls.inc

@@ -28,7 +28,7 @@ EIGEN_ALWAYS_INLINE int64_t idA(int64_t i, int64_t j, int64_t LDA) {
  *     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 @@ EIGEN_ALWAYS_INLINE void trans8x8blocks(PacketBlock<Packet8d, 8> &kernel) {
 }
 
 /***
- * Unrolls for tranposed C stores
+ * Unrolls for transposed C stores
  */
 template <typename Scalar>
 class trans {
@@ -134,7 +134,7 @@ class trans {
   static constexpr int64_t PacketSize = packet_traits<Scalar>::size;
 
   /***********************************
-   * Auxillary Functions for:
+   * Auxiliary Functions for:
    *  - storeC
    ***********************************
    */
@@ -285,7 +285,7 @@ class transB {
   static constexpr int64_t PacketSize = packet_traits<Scalar>::size;
 
   /***********************************
-   * Auxillary Functions for:
+   * Auxiliary Functions for:
    *  - loadB
    *  - storeB
    *  - loadBBlock
@@ -588,7 +588,7 @@ class trsm {
   static constexpr int64_t PacketSize = packet_traits<Scalar>::size;
 
   /***********************************
-   * Auxillary Functions for:
+   * Auxiliary Functions for:
    *  - loadRHS
    *  - storeRHS
    *  - divRHSByDiag
@@ -867,7 +867,7 @@ class gemm {
   static constexpr int64_t PacketSize = packet_traits<Scalar>::size;
 
   /***********************************
-   * Auxillary Functions for:
+   * Auxiliary Functions for:
    *  - setzero
    *  - updateC
    *  - storeC
@@ -1101,7 +1101,7 @@ class gemm {
       }
     }
 
-    // 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_);
     }

Eigen/src/Core/arch/AltiVec/MatrixProduct.h

@@ -1590,7 +1590,7 @@ EIGEN_ALWAYS_INLINE void bscalec(PacketBlock<Packet, N>& aReal, PacketBlock<Pack
   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>

Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h

@@ -1655,7 +1655,7 @@ EIGEN_STRONG_INLINE void twoprod(const Packet& x_hi, const Packet& x_lo, const P
 }
 
 // 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 @@ template <typename Packet, typename ScalarExponent,
 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.

Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h

@@ -21,7 +21,7 @@ namespace internal {
 // 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.

Eigen/src/Core/arch/NEON/PacketMath.h

@@ -103,7 +103,7 @@ EIGEN_STRONG_INLINE Packet4f shuffle1(const Packet4f& m, int mask) {
   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 @@ EIGEN_STRONG_INLINE Packet4bf pnegate<Packet4bf>(const Packet4bf& a) {
 
 //---------- 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 @@ typedef float64x1_t Packet1d;
 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) {

Eigen/src/Core/arch/SSE/PacketMath.h

@@ -1127,7 +1127,7 @@ EIGEN_STRONG_INLINE Packet pminmax_propagate_nan(const Packet& a, const Packet&
   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>);

Eigen/src/Core/products/GeneralBlockPanelKernel.h

@@ -1257,7 +1257,7 @@ struct lhs_process_one_packet {
         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 @@ inline std::ptrdiff_t l2CacheSize() {
   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);

Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h

@@ -137,7 +137,7 @@ EIGEN_BLAS_RANKUPDATE_R(double, double, dsyrk_)
 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_)
 

Eigen/src/Core/products/GeneralMatrixVector.h

@@ -64,7 +64,7 @@ class gemv_traits {
 
 /* 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 @@ general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjugateLh
   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 @@ general_matrix_vector_product<Index, LhsScalar, LhsMapper, RowMajor, ConjugateLh
                               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);

Eigen/src/Core/util/Constants.h

@@ -152,7 +152,7 @@ const unsigned int LvalueBit = 0x20;
  * 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.
  */

Eigen/src/Core/util/IntegralConstant.h

@@ -263,8 +263,8 @@ static const auto fix();
  * }
  * \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

Eigen/src/Core/util/Macros.h

@@ -212,7 +212,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
@@ -221,7 +221,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