Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-07-01 02:41:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

[upstream_utils] Upgrade Eigen to fix warning suppression upstream (#6923)

Browse Source
This commit is contained in:
Tyler Veness
2024-08-03 22:17:17 -07:00
committed by GitHub
parent ed37bd5ab1
commit 712db6711a
49 changed files with 222 additions and 219 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/Core vendored
View File

@@ -348,6 +348,7 @@ using std::ptrdiff_t;
#include "src/Core/TriangularMatrix.h"
#include "src/Core/SelfAdjointView.h"
#include "src/Core/products/GeneralBlockPanelKernel.h"
#include "src/Core/DeviceWrapper.h"
#ifdef EIGEN_GEMM_THREADPOOL
// #include "ThreadPool"
#endif
@@ -404,7 +405,6 @@ using std::ptrdiff_t;
#endif
#include "src/Core/GlobalFunctions.h"
#include "src/Core/DeviceWrapper.h"
// IWYU pragma: end_exports
#include "src/Core/util/ReenableStupidWarnings.h"

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/OrderingMethods vendored
View File

@@ -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

8
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/CoreEvaluators.h vendored
View File

@@ -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>>>

4
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/DeviceWrapper.h vendored
View File

@@ -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

22
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/GenericPacketMath.h vendored
View File

@@ -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 {
@@ -579,12 +579,6 @@ EIGEN_DEVICE_FUNC inline Packet pandnot(const Packet& a, const Packet& b) {
return pand(a, pnot(b));
}
/** \internal \returns isnan(a) */
template <typename Packet>
EIGEN_DEVICE_FUNC inline Packet pisnan(const Packet& a) {
return pandnot(ptrue(a), pcmp_eq(a, a));
}
// In the general case, use bitwise select.
template <typename Packet, typename EnableIf = void>
struct pselect_impl {
@@ -1002,6 +996,20 @@ EIGEN_DEVICE_FUNC inline Packet pcplxflip(const Packet& a) {
* Special math functions
***************************/
/** \internal \returns isnan(a) */
template <typename Packet>
EIGEN_DEVICE_FUNC inline Packet pisnan(const Packet& a) {
return pandnot(ptrue(a), pcmp_eq(a, a));
}
/** \internal \returns isinf(a) */
template <typename Packet>
EIGEN_DEVICE_FUNC inline Packet pisinf(const Packet& a) {
using Scalar = typename unpacket_traits<Packet>::type;
constexpr Scalar inf = NumTraits<Scalar>::infinity();
return pcmp_eq(pabs(a), pset1<Packet>(inf));
}
/** \internal \returns the sine of \a a (coeff-wise) */
template <typename Packet>
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet psin(const Packet& a) {

6
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/MathFunctionsImpl.h vendored
View File

@@ -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.

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/PermutationMatrix.h vendored
View File

@@ -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
*/

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/ProductEvaluators.h vendored
View File

@@ -810,7 +810,7 @@ struct diagonal_product_evaluator_base : evaluator_base<Derived> {
: (Derived::MaxColsAtCompileTime == 1 && Derived::MaxRowsAtCompileTime != 1) ? ColMajor
: MatrixFlags & RowMajorBit ? RowMajor
: ColMajor,
SameStorageOrder_ = StorageOrder_ == (MatrixFlags & RowMajorBit ? RowMajor : ColMajor),
SameStorageOrder_ = int(StorageOrder_) == ((MatrixFlags & RowMajorBit) ? RowMajor : ColMajor),
ScalarAccessOnDiag_ = !((int(StorageOrder_) == ColMajor && int(ProductOrder) == OnTheLeft) ||
(int(StorageOrder_) == RowMajor && int(ProductOrder) == OnTheRight)),

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/StableNorm.h vendored
View File

@@ -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()

6
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/StlIterators.h vendored
View File

@@ -325,7 +325,13 @@ class pointer_based_stl_iterator {
public:
typedef Index difference_type;
typedef typename XprType::Scalar value_type;
#if __cplusplus >= 202002L
typedef std::conditional_t<XprType::InnerStrideAtCompileTime == 1, std::contiguous_iterator_tag,
std::random_access_iterator_tag>
iterator_category;
#else
typedef std::random_access_iterator_tag iterator_category;
#endif
typedef std::conditional_t<bool(is_lvalue), value_type*, const value_type*> pointer;
typedef std::conditional_t<bool(is_lvalue), value_type&, const value_type&> reference;

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/Transpositions.h vendored
View File

@@ -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:

6
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/Visitor.h vendored
View File

@@ -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;
@@ -781,7 +781,7 @@ EIGEN_DEVICE_FUNC inline bool DenseBase<Derived>::hasNaN() const {
*/
template <typename Derived>
EIGEN_DEVICE_FUNC inline bool DenseBase<Derived>::allFinite() const {
return derived().array().isFinite().all();
return derived().array().isFiniteTyped().all();
}
} // end namespace Eigen

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/arch/AVX/PacketMath.h vendored
View File

@@ -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>);

4
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h vendored
View File

@@ -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.

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h vendored
View File

@@ -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.

4
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/arch/Default/Half.h vendored
View File

@@ -319,7 +319,7 @@ namespace half_impl {
#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
@@ -677,7 +677,7 @@ EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC half log(const half& a) {
#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

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/arch/NEON/MathFunctions.h vendored
View File

@@ -27,7 +27,7 @@ EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Packet4hf ptanh<Packet4hf>(const Packet4hf
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))));
}

6
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/arch/NEON/PacketMath.h vendored
View File

@@ -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) {

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/arch/SSE/PacketMath.h vendored
View File

@@ -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>);

49
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/functors/UnaryFunctors.h vendored
View File

@@ -989,10 +989,9 @@ struct functor_traits<scalar_isnan_op<Scalar, UseTypedPredicate>> {
* \brief Template functor to check whether a scalar is +/-inf
* \sa class CwiseUnaryOp, ArrayBase::isinf()
*/
template <typename Scalar>
template <typename Scalar, bool UseTypedPredicate = false>
struct scalar_isinf_op {
typedef bool result_type;
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator()(const Scalar& a) const {
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const Scalar& a) const {
#if defined(SYCL_DEVICE_ONLY)
return numext::isinf(a);
#else
@@ -1000,19 +999,33 @@ struct scalar_isinf_op {
#endif
}
};
template <typename Scalar>
struct functor_traits<scalar_isinf_op<Scalar>> {
enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = false };
struct scalar_isinf_op<Scalar, true> {
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a) const {
#if defined(SYCL_DEVICE_ONLY)
return (numext::isinf(a) ? ptrue(a) : pzero(a));
#else
return (numext::isinf EIGEN_NOT_A_MACRO(a) ? ptrue(a) : pzero(a));
#endif
}
template <typename Packet>
EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const {
return pisinf(a);
}
};
template <typename Scalar, bool UseTypedPredicate>
struct functor_traits<scalar_isinf_op<Scalar, UseTypedPredicate>> {
enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasCmp && UseTypedPredicate };
};
/** \internal
* \brief Template functor to check whether a scalar has a finite value
* \sa class CwiseUnaryOp, ArrayBase::isfinite()
*/
template <typename Scalar>
template <typename Scalar, bool UseTypedPredicate = false>
struct scalar_isfinite_op {
typedef bool result_type;
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator()(const Scalar& a) const {
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE bool operator()(const Scalar& a) const {
#if defined(SYCL_DEVICE_ONLY)
return numext::isfinite(a);
#else
@@ -1020,9 +1033,25 @@ struct scalar_isfinite_op {
#endif
}
};
template <typename Scalar>
struct functor_traits<scalar_isfinite_op<Scalar>> {
enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = false };
struct scalar_isfinite_op<Scalar, true> {
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const Scalar& a) const {
#if defined(SYCL_DEVICE_ONLY)
return (numext::isfinite(a) ? ptrue(a) : pzero(a));
#else
return (numext::isfinite EIGEN_NOT_A_MACRO(a) ? ptrue(a) : pzero(a));
#endif
}
template <typename Packet>
EIGEN_DEVICE_FUNC inline Packet packetOp(const Packet& a) const {
constexpr Scalar inf = NumTraits<Scalar>::infinity();
return pcmp_lt(pabs(a), pset1<Packet>(inf));
}
};
template <typename Scalar, bool UseTypedPredicate>
struct functor_traits<scalar_isfinite_op<Scalar, UseTypedPredicate>> {
enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = packet_traits<Scalar>::HasCmp && UseTypedPredicate };
};
/** \internal

15
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/products/GeneralBlockPanelKernel.h vendored
View File

@@ -718,10 +718,10 @@ class gebp_traits<std::complex<RealScalar>, std::complex<RealScalar>, ConjLhs_,
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 @@ class gebp_traits<std::complex<RealScalar>, std::complex<RealScalar>, ConjLhs_,
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 @@ 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);

6
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/products/GeneralMatrixVector.h vendored
View File

@@ -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);

9
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/util/ConfigureVectorization.h vendored
View File

@@ -38,6 +38,15 @@
#define EIGEN_ALIGNOF(x) alignof(x)
#endif
// 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)
#else
// 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
#if defined(EIGEN_DONT_VECTORIZE)
#if defined(EIGEN_GPUCC)

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/util/Constants.h vendored
View File

@@ -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.
*/

4
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/util/IntegralConstant.h vendored
View File

@@ -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

4
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/util/Macros.h vendored
View File

@@ -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

56
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Core/util/Meta.h vendored
View File

@@ -638,19 +638,23 @@ EIGEN_STRONG_INLINE bool is_identically_zero(const Scalar& s) {
template <typename A>
constexpr bool is_int_or_enum_v = std::is_enum<A>::value || std::is_integral<A>::value;
template <typename A, typename B>
inline constexpr void plain_enum_asserts(A, B) {
static_assert(is_int_or_enum_v<A>, "Argument a must be an integer or enum");
static_assert(is_int_or_enum_v<B>, "Argument b must be an integer or enum");
}
/// \internal Gets the minimum of two values which may be integers or enums
template <typename A, typename B>
inline constexpr int plain_enum_min(A a, B b) {
static_assert(is_int_or_enum_v<A>, "Argument a must be an integer or enum");
static_assert(is_int_or_enum_v<B>, "Argument b must be an integer or enum");
plain_enum_asserts(a, b);
return ((int)a <= (int)b) ? (int)a : (int)b;
}
/// \internal Gets the maximum of two values which may be integers or enums
template <typename A, typename B>
inline constexpr int plain_enum_max(A a, B b) {
static_assert(is_int_or_enum_v<A>, "Argument a must be an integer or enum");
static_assert(is_int_or_enum_v<B>, "Argument b must be an integer or enum");
plain_enum_asserts(a, b);
return ((int)a >= (int)b) ? (int)a : (int)b;
}
@@ -662,8 +666,7 @@ inline constexpr int plain_enum_max(A a, B b) {
*/
template <typename A, typename B>
inline constexpr int min_size_prefer_dynamic(A a, B b) {
static_assert(is_int_or_enum_v<A>, "Argument a must be an integer or enum");
static_assert(is_int_or_enum_v<B>, "Argument b must be an integer or enum");
plain_enum_asserts(a, b);
if ((int)a == 0 || (int)b == 0) return 0;
if ((int)a == 1 || (int)b == 1) return 1;
if ((int)a == Dynamic || (int)b == Dynamic) return Dynamic;
@@ -678,8 +681,7 @@ inline constexpr int min_size_prefer_dynamic(A a, B b) {
*/
template <typename A, typename B>
inline constexpr int min_size_prefer_fixed(A a, B b) {
static_assert(is_int_or_enum_v<A>, "Argument a must be an integer or enum");
static_assert(is_int_or_enum_v<B>, "Argument b must be an integer or enum");
plain_enum_asserts(a, b);
if ((int)a == 0 || (int)b == 0) return 0;
if ((int)a == 1 || (int)b == 1) return 1;
if ((int)a == Dynamic && (int)b == Dynamic) return Dynamic;
@@ -691,12 +693,46 @@ inline constexpr int min_size_prefer_fixed(A a, B b) {
/// \internal see `min_size_prefer_fixed`. No need for a separate variant for MaxSizes here.
template <typename A, typename B>
inline constexpr int max_size_prefer_dynamic(A a, B b) {
static_assert(is_int_or_enum_v<A>, "Argument a must be an integer or enum");
static_assert(is_int_or_enum_v<B>, "Argument b must be an integer or enum");
plain_enum_asserts(a, b);
if ((int)a == Dynamic || (int)b == Dynamic) return Dynamic;
return plain_enum_max(a, b);
}
template <typename A, typename B>
inline constexpr bool enum_eq_not_dynamic(A a, B b) {
plain_enum_asserts(a, b);
if ((int)a == Dynamic || (int)b == Dynamic) return false;
return (int)a == (int)b;
}
template <typename A, typename B>
inline constexpr bool enum_lt_not_dynamic(A a, B b) {
plain_enum_asserts(a, b);
if ((int)a == Dynamic || (int)b == Dynamic) return false;
return (int)a < (int)b;
}
template <typename A, typename B>
inline constexpr bool enum_le_not_dynamic(A a, B b) {
plain_enum_asserts(a, b);
if ((int)a == Dynamic || (int)b == Dynamic) return false;
return (int)a <= (int)b;
}
template <typename A, typename B>
inline constexpr bool enum_gt_not_dynamic(A a, B b) {
plain_enum_asserts(a, b);
if ((int)a == Dynamic || (int)b == Dynamic) return false;
return (int)a > (int)b;
}
template <typename A, typename B>
inline constexpr bool enum_ge_not_dynamic(A a, B b) {
plain_enum_asserts(a, b);
if ((int)a == Dynamic || (int)b == Dynamic) return false;
return (int)a >= (int)b;
}
/// \internal Calculate logical XOR at compile time
inline constexpr bool logical_xor(bool a, bool b) { return a != b; }

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Eigenvalues/GeneralizedEigenSolver.h vendored
View File

@@ -361,7 +361,7 @@ GeneralizedEigenSolver<MatrixType>& GeneralizedEigenSolver<MatrixType>::compute(
// 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--) {

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/Householder/BlockHouseholder.h vendored
View File

@@ -35,7 +35,7 @@ namespace internal {
// // 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);

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/IterativeLinearSolvers/SolveWithGuess.h vendored
View File

@@ -23,7 +23,7 @@ class SolveWithGuess;
*
* \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)

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/LU/arch/InverseSize4.h vendored
View File

@@ -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

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/OrderingMethods/Eigen_Colamd.h vendored
View File

@@ -1374,7 +1374,7 @@ static inline void order_children(
/* order this column */
Col[c].shared2.order = order++;
/* collaps tree */
/* collapse tree */
Col[c].shared1.parent = parent;
/* get immediate parent of this column */

19
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/SVD/BDCSVD.h vendored
View File

@@ -52,9 +52,8 @@ struct traits<BDCSVD<MatrixType_, Options> > : svd_traits<MatrixType_, Options>
template <typename MatrixType, int Options>
struct allocate_small_svd {
static void run(JacobiSVD<MatrixType, Options>& smallSvd, Index rows, Index cols, unsigned int computationOptions) {
(void)computationOptions;
smallSvd = JacobiSVD<MatrixType, Options>(rows, cols);
static void run(JacobiSVD<MatrixType, Options>& smallSvd, Index rows, Index cols, unsigned int) {
internal::construct_at(&smallSvd, rows, cols);
}
};
@@ -64,7 +63,7 @@ EIGEN_DISABLE_DEPRECATED_WARNING
template <typename MatrixType>
struct allocate_small_svd<MatrixType, 0> {
static void run(JacobiSVD<MatrixType>& smallSvd, Index rows, Index cols, unsigned int computationOptions) {
smallSvd = JacobiSVD<MatrixType>(rows, cols, computationOptions);
internal::construct_at(&smallSvd, rows, cols, computationOptions);
}
};
@@ -164,10 +163,10 @@ class BDCSVD : public SVDBase<BDCSVD<MatrixType_, Options_> > {
* 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 +178,7 @@ class BDCSVD : public SVDBase<BDCSVD<MatrixType_, Options_> > {
}
/** \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 +189,11 @@ class BDCSVD : public SVDBase<BDCSVD<MatrixType_, Options_> > {
/** \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 +1047,7 @@ void BDCSVD<MatrixType, Options>::computeSingVals(const ArrayRef& col0, const Ar
} 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`

5
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/SVD/JacobiSVD.h vendored
View File

@@ -553,13 +553,14 @@ class JacobiSVD : public SVDBase<JacobiSVD<MatrixType_, Options_> > {
* \deprecated Will be removed in the next major Eigen version. Options should
* be specified in the \a Options template parameter.
*/
EIGEN_DEPRECATED JacobiSVD(Index rows, Index cols, unsigned int computationOptions) {
// EIGEN_DEPRECATED // this constructor is used to allocate memory in BDCSVD
JacobiSVD(Index rows, Index cols, unsigned int computationOptions) {
internal::check_svd_options_assertions<MatrixType, Options>(computationOptions, rows, cols);
allocate(rows, cols, computationOptions);
}
/** \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
*/

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/SparseCore/SparseCwiseBinaryOp.h vendored
View File

@@ -834,7 +834,7 @@ struct sparse_disjunction_evaluator<XprType, IteratorBased, IndexBased> : evalua
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> > {

8
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/SparseCore/SparseMatrix.h vendored
View File

@@ -250,7 +250,7 @@ class SparseMatrix : public SparseCompressedBase<SparseMatrix<Scalar_, Options_,
}
}
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 @@ void set_from_triplets_sorted(const InputIterator& begin, const InputIterator& e
// 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 @@ SparseMatrix<Scalar_, Options_, StorageIndex_>::insertCompressedAtByOuterInner(I
// 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);

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/SparseCore/SparseSelfAdjointView.h vendored
View File

@@ -143,7 +143,7 @@ class SparseSelfAdjointView : public EigenBase<SparseSelfAdjointView<MatrixType,
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>

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/SparseCore/SparseVector.h vendored
View File

@@ -109,7 +109,7 @@ class SparseVector : public SparseCompressedBase<SparseVector<Scalar_, Options_,
}
/** \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.

4
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/SparseLU/SparseLU.h vendored
View File

@@ -257,7 +257,7 @@ class SparseLU : public SparseSolverBase<SparseLU<MatrixType_, OrderingType_>>,
/** \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 @@ void SparseLU<MatrixType, OrderingType>::analyzePattern(const MatrixType& mat) {
* 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.

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/SparseLU/SparseLU_Structs.h vendored
View File

@@ -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

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/SparseLU/SparseLU_pivotL.h vendored
View File

@@ -37,7 +37,7 @@ namespace Eigen {
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);

2
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/SparseLU/SparseLU_pruneL.h vendored
View File

@@ -101,7 +101,7 @@ void SparseLUImpl<Scalar, StorageIndex>::pruneL(const Index jcol, const IndexVec
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

42
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/ThreadPool/CoreThreadPoolDevice.h vendored
View File

@@ -15,24 +15,24 @@ namespace Eigen {
// CoreThreadPoolDevice provides an easy-to-understand Device for parallelizing Eigen Core expressions with
// Threadpool. Expressions are recursively split evenly until the evaluation cost is less than the threshold for
// delegating the task to a thread.
// a
// / \
// / \
// / \
// / \
// / \
// / \
// / \
// a e
// / \ / \
// / \ / \
// / \ / \
// a c e g
// / \ / \ / \ / \
// / \ / \ / \ / \
// a b c d e f g h
/*
a
/ \
/ \
/ \
/ \
/ \
/ \
/ \
a e
/ \ / \
/ \ / \
/ \ / \
a c e g
/ \ / \ / \ / \
/ \ / \ / \ / \
a b c d e f g h
*/
// Each task descends the binary tree to the left, delegates the right task to a new thread, and continues to the
// left. This ensures that work is evenly distributed to the thread pool as quickly as possible and minimizes the number
// of tasks created during the evaluation. Consider an expression that is divided into 8 chunks. The
@@ -77,7 +77,7 @@ struct CoreThreadPoolDevice {
Index size = end - begin;
eigen_assert(size % PacketSize == 0 && "this function assumes size is a multiple of PacketSize");
Index mid = begin + numext::round_down(size >> 1, PacketSize);
Task right = [=, this, &f, &barrier]() {
Task right = [this, mid, end, &f, &barrier, level]() {
parallelForImpl<UnaryFunctor, PacketSize>(mid, end, f, barrier, level);
};
m_pool.Schedule(std::move(right));
@@ -96,7 +96,7 @@ struct CoreThreadPoolDevice {
Index outerSize = outerEnd - outerBegin;
if (outerSize > 1) {
Index outerMid = outerBegin + (outerSize >> 1);
Task right = [=, this, &f, &barrier]() {
Task right = [this, &f, &barrier, outerMid, outerEnd, innerBegin, innerEnd, level]() {
parallelForImpl<BinaryFunctor, PacketSize>(outerMid, outerEnd, innerBegin, innerEnd, f, barrier, level);
};
m_pool.Schedule(std::move(right));
@@ -105,7 +105,7 @@ struct CoreThreadPoolDevice {
Index innerSize = innerEnd - innerBegin;
eigen_assert(innerSize % PacketSize == 0 && "this function assumes innerSize is a multiple of PacketSize");
Index innerMid = innerBegin + numext::round_down(innerSize >> 1, PacketSize);
Task right = [=, this, &f, &barrier]() {
Task right = [this, &f, &barrier, outerBegin, outerEnd, innerMid, innerEnd, level]() {
parallelForImpl<BinaryFunctor, PacketSize>(outerBegin, outerEnd, innerMid, innerEnd, f, barrier, level);
};
m_pool.Schedule(std::move(right));

8
wpimath/src/main/native/thirdparty/eigen/include/Eigen/src/plugins/ArrayCwiseUnaryOps.inc vendored
View File

@@ -1,5 +1,3 @@
typedef CwiseUnaryOp<internal::scalar_abs_op<Scalar>, const Derived> AbsReturnType;
typedef CwiseUnaryOp<internal::scalar_arg_op<Scalar>, const Derived> ArgReturnType;
typedef CwiseUnaryOp<internal::scalar_carg_op<Scalar>, const Derived> CArgReturnType;
@@ -41,6 +39,7 @@ typedef CwiseUnaryOp<internal::scalar_trunc_op<Scalar>, const Derived> TruncRetu
typedef CwiseUnaryOp<internal::scalar_isnan_op<Scalar>, const Derived> IsNaNReturnType;
typedef CwiseUnaryOp<internal::scalar_isinf_op<Scalar>, const Derived> IsInfReturnType;
typedef CwiseUnaryOp<internal::scalar_isfinite_op<Scalar>, const Derived> IsFiniteReturnType;
typedef CwiseUnaryOp<internal::scalar_isfinite_op<Scalar, true>, const Derived> IsFiniteTypedReturnType;
/** \returns an expression of the coefficient-wise absolute value of \c *this
*
@@ -417,6 +416,9 @@ EIGEN_DEVICE_FUNC inline const IsInfReturnType isInf() const { return IsInfRetur
* \sa isnan(), isinf()
*/
EIGEN_DEVICE_FUNC inline const IsFiniteReturnType isFinite() const { return IsFiniteReturnType(derived()); }
EIGEN_DEVICE_FUNC inline const IsFiniteTypedReturnType isFiniteTyped() const {
return IsFiniteTypedReturnType(derived());
}
/** \returns an expression of the coefficient-wise ! operator of *this
*
@@ -516,7 +518,7 @@ EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const UnaryPowReturnType<ScalarExponent> p
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.
*