Showing preview only (6,567K chars total). Download the full file or copy to clipboard to get everything.
Repository: SsageParuders/SsagePass
Branch: master
Commit: e8ce440ced94
Files: 383
Total size: 6.2 MB
Directory structure:
gitextract_l0eydqq_/
├── .gitignore
├── Demo/
│ ├── help.txt
│ ├── main
│ ├── main.cpp
│ └── symbols_obf.yaml
├── Obfuscation/
│ ├── CMakeLists.txt
│ ├── include/
│ │ ├── BogusControlFlow.h
│ │ ├── CryptoUtils.h
│ │ ├── Eigen/
│ │ │ ├── Cholesky
│ │ │ ├── CholmodSupport
│ │ │ ├── Core
│ │ │ ├── Dense
│ │ │ ├── Eigen
│ │ │ ├── Eigenvalues
│ │ │ ├── Geometry
│ │ │ ├── Householder
│ │ │ ├── IterativeLinearSolvers
│ │ │ ├── Jacobi
│ │ │ ├── KLUSupport
│ │ │ ├── LU
│ │ │ ├── MetisSupport
│ │ │ ├── OrderingMethods
│ │ │ ├── PaStiXSupport
│ │ │ ├── PardisoSupport
│ │ │ ├── QR
│ │ │ ├── QtAlignedMalloc
│ │ │ ├── SPQRSupport
│ │ │ ├── SVD
│ │ │ ├── Sparse
│ │ │ ├── SparseCholesky
│ │ │ ├── SparseCore
│ │ │ ├── SparseLU
│ │ │ ├── SparseQR
│ │ │ ├── StdDeque
│ │ │ ├── StdList
│ │ │ ├── StdVector
│ │ │ ├── SuperLUSupport
│ │ │ ├── UmfPackSupport
│ │ │ └── src/
│ │ │ ├── Cholesky/
│ │ │ │ ├── LDLT.h
│ │ │ │ ├── LLT.h
│ │ │ │ └── LLT_LAPACKE.h
│ │ │ ├── CholmodSupport/
│ │ │ │ └── CholmodSupport.h
│ │ │ ├── Core/
│ │ │ │ ├── ArithmeticSequence.h
│ │ │ │ ├── Array.h
│ │ │ │ ├── ArrayBase.h
│ │ │ │ ├── ArrayWrapper.h
│ │ │ │ ├── Assign.h
│ │ │ │ ├── AssignEvaluator.h
│ │ │ │ ├── Assign_MKL.h
│ │ │ │ ├── BandMatrix.h
│ │ │ │ ├── Block.h
│ │ │ │ ├── BooleanRedux.h
│ │ │ │ ├── CommaInitializer.h
│ │ │ │ ├── ConditionEstimator.h
│ │ │ │ ├── CoreEvaluators.h
│ │ │ │ ├── CoreIterators.h
│ │ │ │ ├── CwiseBinaryOp.h
│ │ │ │ ├── CwiseNullaryOp.h
│ │ │ │ ├── CwiseTernaryOp.h
│ │ │ │ ├── CwiseUnaryOp.h
│ │ │ │ ├── CwiseUnaryView.h
│ │ │ │ ├── DenseBase.h
│ │ │ │ ├── DenseCoeffsBase.h
│ │ │ │ ├── DenseStorage.h
│ │ │ │ ├── Diagonal.h
│ │ │ │ ├── DiagonalMatrix.h
│ │ │ │ ├── DiagonalProduct.h
│ │ │ │ ├── Dot.h
│ │ │ │ ├── EigenBase.h
│ │ │ │ ├── ForceAlignedAccess.h
│ │ │ │ ├── Fuzzy.h
│ │ │ │ ├── GeneralProduct.h
│ │ │ │ ├── GenericPacketMath.h
│ │ │ │ ├── GlobalFunctions.h
│ │ │ │ ├── IO.h
│ │ │ │ ├── IndexedView.h
│ │ │ │ ├── Inverse.h
│ │ │ │ ├── Map.h
│ │ │ │ ├── MapBase.h
│ │ │ │ ├── MathFunctions.h
│ │ │ │ ├── MathFunctionsImpl.h
│ │ │ │ ├── Matrix.h
│ │ │ │ ├── MatrixBase.h
│ │ │ │ ├── NestByValue.h
│ │ │ │ ├── NoAlias.h
│ │ │ │ ├── NumTraits.h
│ │ │ │ ├── PartialReduxEvaluator.h
│ │ │ │ ├── PermutationMatrix.h
│ │ │ │ ├── PlainObjectBase.h
│ │ │ │ ├── Product.h
│ │ │ │ ├── ProductEvaluators.h
│ │ │ │ ├── Random.h
│ │ │ │ ├── Redux.h
│ │ │ │ ├── Ref.h
│ │ │ │ ├── Replicate.h
│ │ │ │ ├── Reshaped.h
│ │ │ │ ├── ReturnByValue.h
│ │ │ │ ├── Reverse.h
│ │ │ │ ├── Select.h
│ │ │ │ ├── SelfAdjointView.h
│ │ │ │ ├── SelfCwiseBinaryOp.h
│ │ │ │ ├── Solve.h
│ │ │ │ ├── SolveTriangular.h
│ │ │ │ ├── SolverBase.h
│ │ │ │ ├── StableNorm.h
│ │ │ │ ├── StlIterators.h
│ │ │ │ ├── Stride.h
│ │ │ │ ├── Swap.h
│ │ │ │ ├── Transpose.h
│ │ │ │ ├── Transpositions.h
│ │ │ │ ├── TriangularMatrix.h
│ │ │ │ ├── VectorBlock.h
│ │ │ │ ├── VectorwiseOp.h
│ │ │ │ ├── Visitor.h
│ │ │ │ ├── arch/
│ │ │ │ │ ├── AVX/
│ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ ├── AVX512/
│ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ ├── AltiVec/
│ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ ├── MatrixProduct.h
│ │ │ │ │ │ ├── MatrixProductCommon.h
│ │ │ │ │ │ ├── MatrixProductMMA.h
│ │ │ │ │ │ └── PacketMath.h
│ │ │ │ │ ├── CUDA/
│ │ │ │ │ │ └── Complex.h
│ │ │ │ │ ├── Default/
│ │ │ │ │ │ ├── BFloat16.h
│ │ │ │ │ │ ├── ConjHelper.h
│ │ │ │ │ │ ├── GenericPacketMathFunctions.h
│ │ │ │ │ │ ├── GenericPacketMathFunctionsFwd.h
│ │ │ │ │ │ ├── Half.h
│ │ │ │ │ │ ├── Settings.h
│ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ ├── GPU/
│ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ ├── HIP/
│ │ │ │ │ │ └── hcc/
│ │ │ │ │ │ └── math_constants.h
│ │ │ │ │ ├── MSA/
│ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ └── PacketMath.h
│ │ │ │ │ ├── NEON/
│ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ ├── GeneralBlockPanelKernel.h
│ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ ├── SSE/
│ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ ├── SVE/
│ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ ├── SYCL/
│ │ │ │ │ │ ├── InteropHeaders.h
│ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ │ ├── SyclMemoryModel.h
│ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ └── ZVector/
│ │ │ │ │ ├── Complex.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ └── PacketMath.h
│ │ │ │ ├── functors/
│ │ │ │ │ ├── AssignmentFunctors.h
│ │ │ │ │ ├── BinaryFunctors.h
│ │ │ │ │ ├── NullaryFunctors.h
│ │ │ │ │ ├── StlFunctors.h
│ │ │ │ │ ├── TernaryFunctors.h
│ │ │ │ │ └── UnaryFunctors.h
│ │ │ │ ├── products/
│ │ │ │ │ ├── GeneralBlockPanelKernel.h
│ │ │ │ │ ├── GeneralMatrixMatrix.h
│ │ │ │ │ ├── GeneralMatrixMatrixTriangular.h
│ │ │ │ │ ├── GeneralMatrixMatrixTriangular_BLAS.h
│ │ │ │ │ ├── GeneralMatrixMatrix_BLAS.h
│ │ │ │ │ ├── GeneralMatrixVector.h
│ │ │ │ │ ├── GeneralMatrixVector_BLAS.h
│ │ │ │ │ ├── Parallelizer.h
│ │ │ │ │ ├── SelfadjointMatrixMatrix.h
│ │ │ │ │ ├── SelfadjointMatrixMatrix_BLAS.h
│ │ │ │ │ ├── SelfadjointMatrixVector.h
│ │ │ │ │ ├── SelfadjointMatrixVector_BLAS.h
│ │ │ │ │ ├── SelfadjointProduct.h
│ │ │ │ │ ├── SelfadjointRank2Update.h
│ │ │ │ │ ├── TriangularMatrixMatrix.h
│ │ │ │ │ ├── TriangularMatrixMatrix_BLAS.h
│ │ │ │ │ ├── TriangularMatrixVector.h
│ │ │ │ │ ├── TriangularMatrixVector_BLAS.h
│ │ │ │ │ ├── TriangularSolverMatrix.h
│ │ │ │ │ ├── TriangularSolverMatrix_BLAS.h
│ │ │ │ │ └── TriangularSolverVector.h
│ │ │ │ └── util/
│ │ │ │ ├── BlasUtil.h
│ │ │ │ ├── ConfigureVectorization.h
│ │ │ │ ├── Constants.h
│ │ │ │ ├── DisableStupidWarnings.h
│ │ │ │ ├── ForwardDeclarations.h
│ │ │ │ ├── IndexedViewHelper.h
│ │ │ │ ├── IntegralConstant.h
│ │ │ │ ├── MKL_support.h
│ │ │ │ ├── Macros.h
│ │ │ │ ├── Memory.h
│ │ │ │ ├── Meta.h
│ │ │ │ ├── NonMPL2.h
│ │ │ │ ├── ReenableStupidWarnings.h
│ │ │ │ ├── ReshapedHelper.h
│ │ │ │ ├── StaticAssert.h
│ │ │ │ ├── SymbolicIndex.h
│ │ │ │ └── XprHelper.h
│ │ │ ├── Eigenvalues/
│ │ │ │ ├── ComplexEigenSolver.h
│ │ │ │ ├── ComplexSchur.h
│ │ │ │ ├── ComplexSchur_LAPACKE.h
│ │ │ │ ├── EigenSolver.h
│ │ │ │ ├── GeneralizedEigenSolver.h
│ │ │ │ ├── GeneralizedSelfAdjointEigenSolver.h
│ │ │ │ ├── HessenbergDecomposition.h
│ │ │ │ ├── MatrixBaseEigenvalues.h
│ │ │ │ ├── RealQZ.h
│ │ │ │ ├── RealSchur.h
│ │ │ │ ├── RealSchur_LAPACKE.h
│ │ │ │ ├── SelfAdjointEigenSolver.h
│ │ │ │ ├── SelfAdjointEigenSolver_LAPACKE.h
│ │ │ │ └── Tridiagonalization.h
│ │ │ ├── Geometry/
│ │ │ │ ├── AlignedBox.h
│ │ │ │ ├── AngleAxis.h
│ │ │ │ ├── EulerAngles.h
│ │ │ │ ├── Homogeneous.h
│ │ │ │ ├── Hyperplane.h
│ │ │ │ ├── OrthoMethods.h
│ │ │ │ ├── ParametrizedLine.h
│ │ │ │ ├── Quaternion.h
│ │ │ │ ├── Rotation2D.h
│ │ │ │ ├── RotationBase.h
│ │ │ │ ├── Scaling.h
│ │ │ │ ├── Transform.h
│ │ │ │ ├── Translation.h
│ │ │ │ ├── Umeyama.h
│ │ │ │ └── arch/
│ │ │ │ └── Geometry_SIMD.h
│ │ │ ├── Householder/
│ │ │ │ ├── BlockHouseholder.h
│ │ │ │ ├── Householder.h
│ │ │ │ └── HouseholderSequence.h
│ │ │ ├── IterativeLinearSolvers/
│ │ │ │ ├── BasicPreconditioners.h
│ │ │ │ ├── BiCGSTAB.h
│ │ │ │ ├── ConjugateGradient.h
│ │ │ │ ├── IncompleteCholesky.h
│ │ │ │ ├── IncompleteLUT.h
│ │ │ │ ├── IterativeSolverBase.h
│ │ │ │ ├── LeastSquareConjugateGradient.h
│ │ │ │ └── SolveWithGuess.h
│ │ │ ├── Jacobi/
│ │ │ │ └── Jacobi.h
│ │ │ ├── KLUSupport/
│ │ │ │ └── KLUSupport.h
│ │ │ ├── LU/
│ │ │ │ ├── Determinant.h
│ │ │ │ ├── FullPivLU.h
│ │ │ │ ├── InverseImpl.h
│ │ │ │ ├── PartialPivLU.h
│ │ │ │ ├── PartialPivLU_LAPACKE.h
│ │ │ │ └── arch/
│ │ │ │ └── InverseSize4.h
│ │ │ ├── MetisSupport/
│ │ │ │ └── MetisSupport.h
│ │ │ ├── OrderingMethods/
│ │ │ │ ├── Amd.h
│ │ │ │ ├── Eigen_Colamd.h
│ │ │ │ └── Ordering.h
│ │ │ ├── PaStiXSupport/
│ │ │ │ └── PaStiXSupport.h
│ │ │ ├── PardisoSupport/
│ │ │ │ └── PardisoSupport.h
│ │ │ ├── QR/
│ │ │ │ ├── ColPivHouseholderQR.h
│ │ │ │ ├── ColPivHouseholderQR_LAPACKE.h
│ │ │ │ ├── CompleteOrthogonalDecomposition.h
│ │ │ │ ├── FullPivHouseholderQR.h
│ │ │ │ ├── HouseholderQR.h
│ │ │ │ └── HouseholderQR_LAPACKE.h
│ │ │ ├── SPQRSupport/
│ │ │ │ └── SuiteSparseQRSupport.h
│ │ │ ├── SVD/
│ │ │ │ ├── BDCSVD.h
│ │ │ │ ├── JacobiSVD.h
│ │ │ │ ├── JacobiSVD_LAPACKE.h
│ │ │ │ ├── SVDBase.h
│ │ │ │ └── UpperBidiagonalization.h
│ │ │ ├── SparseCholesky/
│ │ │ │ ├── SimplicialCholesky.h
│ │ │ │ └── SimplicialCholesky_impl.h
│ │ │ ├── SparseCore/
│ │ │ │ ├── AmbiVector.h
│ │ │ │ ├── CompressedStorage.h
│ │ │ │ ├── ConservativeSparseSparseProduct.h
│ │ │ │ ├── MappedSparseMatrix.h
│ │ │ │ ├── SparseAssign.h
│ │ │ │ ├── SparseBlock.h
│ │ │ │ ├── SparseColEtree.h
│ │ │ │ ├── SparseCompressedBase.h
│ │ │ │ ├── SparseCwiseBinaryOp.h
│ │ │ │ ├── SparseCwiseUnaryOp.h
│ │ │ │ ├── SparseDenseProduct.h
│ │ │ │ ├── SparseDiagonalProduct.h
│ │ │ │ ├── SparseDot.h
│ │ │ │ ├── SparseFuzzy.h
│ │ │ │ ├── SparseMap.h
│ │ │ │ ├── SparseMatrix.h
│ │ │ │ ├── SparseMatrixBase.h
│ │ │ │ ├── SparsePermutation.h
│ │ │ │ ├── SparseProduct.h
│ │ │ │ ├── SparseRedux.h
│ │ │ │ ├── SparseRef.h
│ │ │ │ ├── SparseSelfAdjointView.h
│ │ │ │ ├── SparseSolverBase.h
│ │ │ │ ├── SparseSparseProductWithPruning.h
│ │ │ │ ├── SparseTranspose.h
│ │ │ │ ├── SparseTriangularView.h
│ │ │ │ ├── SparseUtil.h
│ │ │ │ ├── SparseVector.h
│ │ │ │ ├── SparseView.h
│ │ │ │ └── TriangularSolver.h
│ │ │ ├── SparseLU/
│ │ │ │ ├── SparseLU.h
│ │ │ │ ├── SparseLUImpl.h
│ │ │ │ ├── SparseLU_Memory.h
│ │ │ │ ├── SparseLU_Structs.h
│ │ │ │ ├── SparseLU_SupernodalMatrix.h
│ │ │ │ ├── SparseLU_Utils.h
│ │ │ │ ├── SparseLU_column_bmod.h
│ │ │ │ ├── SparseLU_column_dfs.h
│ │ │ │ ├── SparseLU_copy_to_ucol.h
│ │ │ │ ├── SparseLU_gemm_kernel.h
│ │ │ │ ├── SparseLU_heap_relax_snode.h
│ │ │ │ ├── SparseLU_kernel_bmod.h
│ │ │ │ ├── SparseLU_panel_bmod.h
│ │ │ │ ├── SparseLU_panel_dfs.h
│ │ │ │ ├── SparseLU_pivotL.h
│ │ │ │ ├── SparseLU_pruneL.h
│ │ │ │ └── SparseLU_relax_snode.h
│ │ │ ├── SparseQR/
│ │ │ │ └── SparseQR.h
│ │ │ ├── StlSupport/
│ │ │ │ ├── StdDeque.h
│ │ │ │ ├── StdList.h
│ │ │ │ ├── StdVector.h
│ │ │ │ └── details.h
│ │ │ ├── SuperLUSupport/
│ │ │ │ └── SuperLUSupport.h
│ │ │ ├── UmfPackSupport/
│ │ │ │ └── UmfPackSupport.h
│ │ │ ├── misc/
│ │ │ │ ├── Image.h
│ │ │ │ ├── Kernel.h
│ │ │ │ ├── RealSvd2x2.h
│ │ │ │ ├── blas.h
│ │ │ │ ├── lapack.h
│ │ │ │ ├── lapacke.h
│ │ │ │ └── lapacke_mangling.h
│ │ │ └── plugins/
│ │ │ ├── ArrayCwiseBinaryOps.h
│ │ │ ├── ArrayCwiseUnaryOps.h
│ │ │ ├── BlockMethods.h
│ │ │ ├── CommonCwiseBinaryOps.h
│ │ │ ├── CommonCwiseUnaryOps.h
│ │ │ ├── IndexedViewMethods.h
│ │ │ ├── MatrixCwiseBinaryOps.h
│ │ │ ├── MatrixCwiseUnaryOps.h
│ │ │ └── ReshapedMethods.h
│ │ ├── Flattening.h
│ │ ├── FlatteningEnhanced.h
│ │ ├── FunctionWrapper.h
│ │ ├── IPObfuscationContext.h
│ │ ├── IndirectBranch.h
│ │ ├── IndirectCall.h
│ │ ├── LegacyLowerSwitch.h
│ │ ├── MBAObfuscation.h
│ │ ├── MBAUtils.h
│ │ ├── ObfuscationOptions.h
│ │ ├── SplitBasicBlock.h
│ │ ├── StringEncryption.h
│ │ ├── Utils.h
│ │ ├── VMFlatten.h
│ │ └── compat/
│ │ └── CallSite.h
│ └── src/
│ ├── BogusControlFlow.cpp
│ ├── CryptoUtils.cpp
│ ├── Flattening.cpp
│ ├── FlatteningEnhanced.cpp
│ ├── FunctionWrapper.cpp
│ ├── IPObfuscationContext.cpp
│ ├── IndirectBranch.cpp
│ ├── IndirectCall.cpp
│ ├── LegacyLowerSwitch.cpp
│ ├── MBAObfuscation.cpp
│ ├── MBAUtils.cpp
│ ├── ObfuscationOptions.cpp
│ ├── PMRegistration.cpp
│ ├── SplitBasicBlock.cpp
│ ├── StringEncryption.cpp
│ ├── Utils.cpp
│ └── VMFlatten.cpp
├── README.md
├── demo.sh
└── docs/
├── LLVM_API.md
├── LLVM_IR.md
├── LLVM_Obfuscation.md
└── README.md
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
build
.vscode
Demo/*.ll
llvm-pass-tutorial-dev
SsagePass-master
obfuscator-AutoRegistration
*.cmake
*/CMakeFiles
*/CMakeCache*
Obfuscation/Makefile
Obfuscation/libSsageObfuscator.so
.cache
================================================
FILE: Demo/help.txt
================================================
OVERVIEW: clang LLVM compiler
USAGE: clang-14 [options] file...
OPTIONS:
-### Print (but do not run) the commands to run for this compilation
--amdgpu-arch-tool=<value>
Tool used for detecting AMD GPU arch in the system.
--analyzer-output <value>
Static analyzer report output format (html|plist|plist-multi-file|plist-html|sarif|sarif-html|text).
--analyze Run the static analyzer
-arcmt-migrate-emit-errors
Emit ARC errors even if the migrator can fix them
-arcmt-migrate-report-output <value>
Output path for the plist report
-B <prefix> Search $prefix$file for executables, libraries, and data files. If $prefix is a directory, search $prefix/$file
-b <arg> Pass -b <arg> to the linker on AIX (only).
-CC Include comments from within macros in preprocessed output
-cl-denorms-are-zero OpenCL only. Allow denormals to be flushed to zero.
-cl-fast-relaxed-math OpenCL only. Sets -cl-finite-math-only and -cl-unsafe-math-optimizations, and defines __FAST_RELAXED_MATH__.
-cl-finite-math-only OpenCL only. Allow floating-point optimizations that assume arguments and results are not NaNs or +-Inf.
-cl-fp32-correctly-rounded-divide-sqrt
OpenCL only. Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded.
-cl-kernel-arg-info OpenCL only. Generate kernel argument metadata.
-cl-mad-enable OpenCL only. Allow use of less precise MAD computations in the generated binary.
-cl-no-signed-zeros OpenCL only. Allow use of less precise no signed zeros computations in the generated binary.
-cl-no-stdinc OpenCL only. Disables all standard includes containing non-native compiler types and functions.
-cl-opt-disable OpenCL only. This option disables all optimizations. By default optimizations are enabled.
-cl-single-precision-constant
OpenCL only. Treat double precision floating-point constant as single precision constant.
-cl-std=<value> OpenCL language standard to compile for.
-cl-strict-aliasing OpenCL only. This option is added for compatibility with OpenCL 1.0.
-cl-uniform-work-group-size
OpenCL only. Defines that the global work-size be a multiple of the work-group size specified to clEnqueueNDRangeKernel
-cl-unsafe-math-optimizations
OpenCL only. Allow unsafe floating-point optimizations. Also implies -cl-no-signed-zeros and -cl-mad-enable.
--config <value> Specifies configuration file
--cuda-compile-host-device
Compile CUDA code for both host and device (default). Has no effect on non-CUDA compilations.
--cuda-device-only Compile CUDA code for device only
--cuda-host-only Compile CUDA code for host only. Has no effect on non-CUDA compilations.
--cuda-include-ptx=<value>
Include PTX for the following GPU architecture (e.g. sm_35) or 'all'. May be specified more than once.
--cuda-noopt-device-debug
Enable device-side debug info generation. Disables ptxas optimizations.
--cuda-path-ignore-env Ignore environment variables to detect CUDA installation
--cuda-path=<value> CUDA installation path
-cuid=<value> An ID for compilation unit, which should be the same for the same compilation unit but different for different compilation units. It is used to externalize device-side static variables for single source offloading languages CUDA and HIP so that they can be accessed by the host code of the same compilation unit.
-cxx-isystem <directory>
Add directory to the C++ SYSTEM include search path
-C Include comments in preprocessed output
-c Only run preprocess, compile, and assemble steps
-dD Print macro definitions in -E mode in addition to normal output
-dependency-dot <value> Filename to write DOT-formatted header dependencies to
-dependency-file <value>
Filename (or -) to write dependency output to
-dI Print include directives in -E mode in addition to normal output
-dM Print macro definitions in -E mode instead of normal output
-dsym-dir <dir> Directory to output dSYM's (if any) to
-D <macro>=<value> Define <macro> to <value> (or 1 if <value> omitted)
-emit-ast Emit Clang AST files for source inputs
-emit-interface-stubs Generate Interface Stub Files.
-emit-llvm Use the LLVM representation for assembler and object files
-emit-merged-ifs Generate Interface Stub Files, emit merged text not binary.
--emit-static-lib Enable linker job to emit a static library.
-enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clang
Trivial automatic variable initialization to zero is only here for benchmarks, it'll eventually be removed, and I'm OK with that because I'm only using it to benchmark
--end-no-unused-arguments
Start emitting warnings for unused driver arguments
-extract-api Extract API information
-E Only run the preprocessor
-faapcs-bitfield-load Follows the AAPCS standard that all volatile bit-field write generates at least one load. (ARM only).
-faapcs-bitfield-width Follow the AAPCS standard requirement stating that volatile bit-field width is dictated by the field container type. (ARM only).
-faddrsig Emit an address-significance table
-falign-loops=<N> N must be a power of two. Align loops to the boundary
-faligned-allocation Enable C++17 aligned allocation functions
-fallow-editor-placeholders
Treat editor placeholders as valid source code
-faltivec-src-compat=<value>
Source-level compatibility for Altivec vectors (for PowerPC targets). This includes results of vector comparison (scalar for 'xl', vector for 'gcc') as well as behavior when initializing with a scalar (splatting for 'xl', element zero only for 'gcc'). For 'mixed', the compatibility is as 'gcc' for 'vector bool/vector pixel' and as 'xl' for other types. Current default is 'mixed'.
-fansi-escape-codes Use ANSI escape codes for diagnostics
-fapple-kext Use Apple's kernel extensions ABI
-fapple-link-rtlib Force linking the clang builtins runtime library
-fapple-pragma-pack Enable Apple gcc-compatible #pragma pack handling
-fapplication-extension Restrict code to those available for App Extensions
-fapprox-func Allow certain math function calls to be replaced with an approximately equivalent calculation
-fasync-exceptions Enable EH Asynchronous exceptions
-fbasic-block-sections=<value>
Place each function's basic blocks in unique sections (ELF Only) : all | labels | none | list=<file>
-fbinutils-version=<major.minor>
Produced object files can use all ELF features supported by this binutils version and newer. If -fno-integrated-as is specified, the generated assembly will consider GNU as support. 'none' means that all ELF features can be used, regardless of binutils support. Defaults to 2.26.
-fblocks Enable the 'blocks' language feature
-fborland-extensions Accept non-standard constructs supported by the Borland compiler
-fbuild-session-file=<file>
Use the last modification time of <file> as the build session timestamp
-fbuild-session-timestamp=<time since Epoch in seconds>
Time when the current build session started
-fbuiltin-module-map Load the clang builtins module map file.
-fc++-abi=<value> C++ ABI to use. This will override the target C++ ABI.
-fcall-saved-x10 Make the x10 register call-saved (AArch64 only)
-fcall-saved-x11 Make the x11 register call-saved (AArch64 only)
-fcall-saved-x12 Make the x12 register call-saved (AArch64 only)
-fcall-saved-x13 Make the x13 register call-saved (AArch64 only)
-fcall-saved-x14 Make the x14 register call-saved (AArch64 only)
-fcall-saved-x15 Make the x15 register call-saved (AArch64 only)
-fcall-saved-x18 Make the x18 register call-saved (AArch64 only)
-fcall-saved-x8 Make the x8 register call-saved (AArch64 only)
-fcall-saved-x9 Make the x9 register call-saved (AArch64 only)
-fcf-protection=<value> Instrument control-flow architecture protection. Options: return, branch, full, none.
-fcf-protection Enable cf-protection in 'full' mode
-fchar8_t Enable C++ builtin type char8_t
-fclang-abi-compat=<version>
Attempt to match the ABI of Clang <version>
-fcolor-diagnostics Enable colors in diagnostics
-fcomment-block-commands=<arg>
Treat each comma separated argument in <arg> as a documentation comment block command
-fcommon Place uninitialized global variables in a common block
-fcomplete-member-pointers
Require member pointer base types to be complete if they would be significant under the Microsoft ABI
-fconvergent-functions Assume functions may be convergent
-fcoroutines-ts Enable support for the C++ Coroutines TS
-fcoverage-compilation-dir=<value>
The compilation directory to embed in the coverage mapping.
-fcoverage-mapping Generate coverage mapping to enable code coverage analysis
-fcoverage-prefix-map=<value>
remap file source paths in coverage mapping
-fcrash-diagnostics-dir=<dir>
Put crash-report files in <dir>
-fcs-profile-generate=<directory>
Generate instrumented code to collect context sensitive execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)
-fcs-profile-generate Generate instrumented code to collect context sensitive execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)
-fcuda-approx-transcendentals
Use approximate transcendental functions
-fcuda-short-ptr Use 32-bit pointers for accessing const/local/shared address spaces
-fcxx-exceptions Enable C++ exceptions
-fcxx-modules Enable modules for C++
-fdata-sections Place each data in its own section
-fdebug-compilation-dir=<value>
The compilation directory to embed in the debug info
-fdebug-default-version=<value>
Default DWARF version to use, if a -g option caused DWARF debug info to be produced
-fdebug-info-for-profiling
Emit extra debug info to make sample profile more accurate
-fdebug-macro Emit macro debug information
-fdebug-prefix-map=<value>
remap file source paths in debug info
-fdebug-ranges-base-address
Use DWARF base address selection entries in .debug_ranges
-fdebug-types-section Place debug types in their own section (ELF Only)
-fdeclspec Allow __declspec as a keyword
-fdelayed-template-parsing
Parse templated function definitions at the end of the translation unit
-fdelete-null-pointer-checks
Treat usage of null pointers as undefined behavior (default)
-fdiagnostics-absolute-paths
Print absolute paths in diagnostics
-fdiagnostics-hotness-threshold=<value>
Prevent optimization remarks from being output if they do not have at least this profile count. Use 'auto' to apply the threshold from profile summary
-fdiagnostics-parseable-fixits
Print fix-its in machine parseable form
-fdiagnostics-print-source-range-info
Print source range spans in numeric form
-fdiagnostics-show-hotness
Enable profile hotness information in diagnostic line
-fdiagnostics-show-note-include-stack
Display include stacks for diagnostic notes
-fdiagnostics-show-option
Print option name with mappable diagnostics
-fdiagnostics-show-template-tree
Print a template comparison tree for differing templates
-fdigraphs Enable alternative token representations '<:', ':>', '<%', '%>', '%:', '%:%:' (default)
-fdirect-access-external-data
Don't use GOT indirection to reference external data symbols
-fdiscard-value-names Discard value names in LLVM IR
-fdollars-in-identifiers
Allow '$' in identifiers
-fdouble-square-bracket-attributes
Enable '[[]]' attributes in all C and C++ language modes
-fdwarf-exceptions Use DWARF style exceptions
-feliminate-unused-debug-types
Do not emit debug info for defined but unused types
-fembed-bitcode-marker Embed placeholder LLVM IR data as a marker
-fembed-bitcode=<option>
Embed LLVM bitcode (option: off, all, bitcode, marker)
-fembed-bitcode Embed LLVM IR bitcode as data
-fembed-offload-object=<value>
Embed Offloading device-side binary into host object file as a section.
-femit-all-decls Emit all declarations, even if unused
-femulated-tls Use emutls functions to access thread_local variables
-fenable-matrix Enable matrix data type and related builtin functions
-fexceptions Enable support for exception handling
-fexperimental-new-constant-interpreter
Enable the experimental new constant interpreter
-fexperimental-relative-c++-abi-vtables
Use the experimental C++ class ABI for classes with virtual tables
-fexperimental-strict-floating-point
Enables experimental strict floating point in LLVM.
-fextend-arguments=<value>
Controls how scalar integer arguments are extended in calls to unprototyped and varargs functions
-ffast-math Allow aggressive, lossy floating-point optimizations
-ffile-compilation-dir=<value>
The compilation directory to embed in the debug info and coverage mapping.
-ffile-prefix-map=<value>
remap file source paths in debug info, predefined preprocessor macros and __builtin_FILE()
-ffine-grained-bitfield-accesses
Use separate accesses for consecutive bitfield runs with legal widths and alignments.
-ffinite-loops Assume all loops are finite.
-ffixed-a0 Reserve the a0 register (M68k only)
-ffixed-a1 Reserve the a1 register (M68k only)
-ffixed-a2 Reserve the a2 register (M68k only)
-ffixed-a3 Reserve the a3 register (M68k only)
-ffixed-a4 Reserve the a4 register (M68k only)
-ffixed-a5 Reserve the a5 register (M68k only)
-ffixed-a6 Reserve the a6 register (M68k only)
-ffixed-d0 Reserve the d0 register (M68k only)
-ffixed-d1 Reserve the d1 register (M68k only)
-ffixed-d2 Reserve the d2 register (M68k only)
-ffixed-d3 Reserve the d3 register (M68k only)
-ffixed-d4 Reserve the d4 register (M68k only)
-ffixed-d5 Reserve the d5 register (M68k only)
-ffixed-d6 Reserve the d6 register (M68k only)
-ffixed-d7 Reserve the d7 register (M68k only)
-ffixed-point Enable fixed point types
-ffixed-r19 Reserve register r19 (Hexagon only)
-ffixed-r9 Reserve the r9 register (ARM only)
-ffixed-x10 Reserve the x10 register (AArch64/RISC-V only)
-ffixed-x11 Reserve the x11 register (AArch64/RISC-V only)
-ffixed-x12 Reserve the x12 register (AArch64/RISC-V only)
-ffixed-x13 Reserve the x13 register (AArch64/RISC-V only)
-ffixed-x14 Reserve the x14 register (AArch64/RISC-V only)
-ffixed-x15 Reserve the x15 register (AArch64/RISC-V only)
-ffixed-x16 Reserve the x16 register (AArch64/RISC-V only)
-ffixed-x17 Reserve the x17 register (AArch64/RISC-V only)
-ffixed-x18 Reserve the x18 register (AArch64/RISC-V only)
-ffixed-x19 Reserve the x19 register (AArch64/RISC-V only)
-ffixed-x1 Reserve the x1 register (AArch64/RISC-V only)
-ffixed-x20 Reserve the x20 register (AArch64/RISC-V only)
-ffixed-x21 Reserve the x21 register (AArch64/RISC-V only)
-ffixed-x22 Reserve the x22 register (AArch64/RISC-V only)
-ffixed-x23 Reserve the x23 register (AArch64/RISC-V only)
-ffixed-x24 Reserve the x24 register (AArch64/RISC-V only)
-ffixed-x25 Reserve the x25 register (AArch64/RISC-V only)
-ffixed-x26 Reserve the x26 register (AArch64/RISC-V only)
-ffixed-x27 Reserve the x27 register (AArch64/RISC-V only)
-ffixed-x28 Reserve the x28 register (AArch64/RISC-V only)
-ffixed-x29 Reserve the x29 register (AArch64/RISC-V only)
-ffixed-x2 Reserve the x2 register (AArch64/RISC-V only)
-ffixed-x30 Reserve the x30 register (AArch64/RISC-V only)
-ffixed-x31 Reserve the x31 register (AArch64/RISC-V only)
-ffixed-x3 Reserve the x3 register (AArch64/RISC-V only)
-ffixed-x4 Reserve the x4 register (AArch64/RISC-V only)
-ffixed-x5 Reserve the x5 register (AArch64/RISC-V only)
-ffixed-x6 Reserve the x6 register (AArch64/RISC-V only)
-ffixed-x7 Reserve the x7 register (AArch64/RISC-V only)
-ffixed-x8 Reserve the x8 register (AArch64/RISC-V only)
-ffixed-x9 Reserve the x9 register (AArch64/RISC-V only)
-fforce-dwarf-frame Always emit a debug frame section
-fforce-emit-vtables Emits more virtual tables to improve devirtualization
-fforce-enable-int128 Enable support for int128_t type
-ffp-contract=<value> Form fused FP ops (e.g. FMAs): fast (fuses across statements disregarding pragmas) | on (only fuses in the same statement unless dictated by pragmas) | off (never fuses) | fast-honor-pragmas (fuses across statements unless diectated by pragmas). Default is 'fast' for CUDA, 'fast-honor-pragmas' for HIP, and 'on' otherwise.
-ffp-exception-behavior=<value>
Specifies the exception behavior of floating-point operations.
-ffp-model=<value> Controls the semantics of floating-point calculations.
-ffreestanding Assert that the compilation takes place in a freestanding environment
-ffuchsia-api-level=<value>
Set Fuchsia API level
-ffunction-sections Place each function in its own section
-fglobal-isel Enables the global instruction selector
-fgnu-keywords Allow GNU-extension keywords regardless of language standard
-fgnu-runtime Generate output compatible with the standard GNU Objective-C runtime
-fgnu89-inline Use the gnu89 inline semantics
-fgnuc-version=<value> Sets various macros to claim compatibility with the given GCC version (default is 4.2.1)
-fgpu-allow-device-init Allow device side init function in HIP (experimental)
-fgpu-defer-diag Defer host/device related diagnostic messages for CUDA/HIP
-fgpu-flush-denormals-to-zero
Flush denormal floating point values to zero in CUDA/HIP device mode.
-fgpu-rdc Generate relocatable device code, also known as separate compilation mode
-fgpu-sanitize Enable sanitizer for AMDGPU target
-fhip-fp32-correctly-rounded-divide-sqrt
Specify that single precision floating-point divide and sqrt used in the program source are correctly rounded (HIP device compilation only)
-fhip-new-launch-api Use new kernel launching API for HIP
-fignore-exceptions Enable support for ignoring exception handling constructs
-fimplicit-module-maps Implicitly search the file system for module map files.
-finline-functions Inline suitable functions
-finline-hint-functions Inline functions which are (explicitly or implicitly) marked inline
-finput-charset=<value> Specify the default character set for source files
-finstrument-function-entry-bare
Instrument function entry only, after inlining, without arguments to the instrumentation call
-finstrument-functions-after-inlining
Like -finstrument-functions, but insert the calls after inlining
-finstrument-functions Generate calls to instrument function entry and exit
-fintegrated-as Enable the integrated assembler
-fintegrated-cc1 Run cc1 in-process
-fjump-tables Use jump tables for lowering switches
-fkeep-static-consts Keep static const variables if unused
-flax-vector-conversions=<value>
Enable implicit vector bit-casts
-flegacy-pass-manager Use the legacy pass manager in LLVM (deprecated, to be removed in a future release)
-flto-jobs=<value> Controls the backend parallelism of -flto=thin (default of 0 means the number of threads will be derived from the number of CPUs detected)
-flto=auto Enable LTO in 'full' mode
-flto=jobserver Enable LTO in 'full' mode
-flto=<value> Set LTO mode to either 'full' or 'thin'
-flto Enable LTO in 'full' mode
-fmacro-prefix-map=<value>
remap file source paths in predefined preprocessor macros and __builtin_FILE()
-fmath-errno Require math functions to indicate errors by setting errno
-fmax-tokens=<value> Max total number of preprocessed tokens for -Wmax-tokens.
-fmax-type-align=<value>
Specify the maximum alignment to enforce on pointers lacking an explicit alignment
-fmemory-profile=<directory>
Enable heap memory profiling and dump results into <directory>
-fmemory-profile Enable heap memory profiling
-fmerge-all-constants Allow merging of constants
-fmessage-length=<value>
Format message diagnostics so that they fit within N columns
-fminimize-whitespace Minimize whitespace when emitting preprocessor output
-fmodule-file=[<name>=]<file>
Specify the mapping of module name to precompiled module file, or load a module file if name is omitted.
-fmodule-map-file=<file>
Load this module map file
-fmodule-name=<name> Specify the name of the module to build
-fmodules-cache-path=<directory>
Specify the module cache path
-fmodules-decluse Require declaration of modules used within a module
-fmodules-disable-diagnostic-validation
Disable validation of the diagnostic options when loading the module
-fmodules-ignore-macro=<value>
Ignore the definition of the given macro when building and loading modules
-fmodules-prune-after=<seconds>
Specify the interval (in seconds) after which a module file will be considered unused
-fmodules-prune-interval=<seconds>
Specify the interval (in seconds) between attempts to prune the module cache
-fmodules-search-all Search even non-imported modules to resolve references
-fmodules-strict-decluse
Like -fmodules-decluse but requires all headers to be in modules
-fmodules-ts Enable support for the C++ Modules TS
-fmodules-user-build-path <directory>
Specify the module user build path
-fmodules-validate-input-files-content
Validate PCM input files based on content if mtime differs
-fmodules-validate-once-per-build-session
Don't verify input files for the modules if the module has been successfully validated or loaded during this build session
-fmodules-validate-system-headers
Validate the system headers that a module depends on when loading the module
-fmodules Enable the 'modules' language feature
-fms-compatibility-version=<value>
Dot-separated value representing the Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))
-fms-compatibility Enable full Microsoft Visual C++ compatibility
-fms-extensions Accept some non-standard constructs supported by the Microsoft compiler
-fms-hotpatch Ensure that all functions can be hotpatched at runtime
-fmsc-version=<value> Microsoft compiler version number to report in _MSC_VER (0 = don't define it (default))
-fnew-alignment=<align> Specifies the largest alignment guaranteed by '::operator new(size_t)'
-fnew-infallible Enable treating throwing global C++ operator new as always returning valid memory (annotates with __attribute__((returns_nonnull)) and throw()). This is detectable in source.
-fno-aapcs-bitfield-width
Do not follow the AAPCS standard requirement stating that volatile bit-field width is dictated by the field container type. (ARM only).
-fno-access-control Disable C++ access control
-fno-addrsig Don't emit an address-significance table
-fno-assume-sane-operator-new
Don't assume that C++'s global operator new can't alias any pointer
-fno-autolink Disable generation of linker directives for automatic library linking
-fno-builtin-<value> Disable implicit builtin knowledge of a specific function
-fno-builtin Disable implicit builtin knowledge of functions
-fno-c++-static-destructors
Disable C++ static destructor registration
-fno-char8_t Disable C++ builtin type char8_t
-fno-color-diagnostics Disable colors in diagnostics
-fno-common Compile common globals like normal definitions
-fno-complete-member-pointers
Do not require member pointer base types to be complete if they would be significant under the Microsoft ABI
-fno-constant-cfstrings Disable creation of CodeFoundation-type constant strings
-fno-coverage-mapping Disable code coverage analysis
-fno-crash-diagnostics Disable auto-generation of preprocessed source files and a script for reproduction during a clang crash
-fno-cuda-approx-transcendentals
Don't use approximate transcendental functions
-fno-cxx-modules Disable modules for C++
-fno-debug-macro Do not emit macro debug information
-fno-declspec Disallow __declspec as a keyword
-fno-delayed-template-parsing
Disable delayed template parsing
-fno-delete-null-pointer-checks
Do not treat usage of null pointers as undefined behavior
-fno-diagnostics-fixit-info
Do not include fixit information in diagnostics
-fno-digraphs Disallow alternative token representations '<:', ':>', '<%', '%>', '%:', '%:%:'
-fno-direct-access-external-data
Use GOT indirection to reference external data symbols
-fno-discard-value-names
Do not discard value names in LLVM IR
-fno-dollars-in-identifiers
Disallow '$' in identifiers
-fno-double-square-bracket-attributes
Disable '[[]]' attributes in all C and C++ language modes
-fno-elide-constructors Disable C++ copy constructor elision
-fno-elide-type Do not elide types when printing diagnostics
-fno-eliminate-unused-debug-types
Emit debug info for defined but unused types
-fno-exceptions Disable support for exception handling
-fno-experimental-relative-c++-abi-vtables
Do not use the experimental C++ class ABI for classes with virtual tables
-fno-fine-grained-bitfield-accesses
Use large-integer access for consecutive bitfield runs.
-fno-finite-loops Do not assume that any loop is finite.
-fno-fixed-point Disable fixed point types
-fno-force-enable-int128
Disable support for int128_t type
-fno-global-isel Disables the global instruction selector
-fno-gnu-inline-asm Disable GNU style inline asm
-fno-gpu-allow-device-init
Don't allow device side init function in HIP (experimental)
-fno-gpu-defer-diag Don't defer host/device related diagnostic messages for CUDA/HIP
-fno-hip-fp32-correctly-rounded-divide-sqrt
Don't specify that single precision floating-point divide and sqrt used in the program source are correctly rounded (HIP device compilation only)
-fno-hip-new-launch-api Don't use new kernel launching API for HIP
-fno-integrated-as Disable the integrated assembler
-fno-integrated-cc1 Spawn a separate process for each cc1
-fno-jump-tables Do not use jump tables for lowering switches
-fno-keep-static-consts Don't keep static const variables if unused
-fno-legacy-pass-manager
Use the new pass manager in LLVM
-fno-lto Disable LTO mode (default)
-fno-memory-profile Disable heap memory profiling
-fno-merge-all-constants
Disallow merging of constants
-fno-new-infallible Disable treating throwing global C++ operator new as always returning valid memory (annotates with __attribute__((returns_nonnull)) and throw()). This is detectable in source.
-fno-objc-infer-related-result-type
do not infer Objective-C related result type based on method family
-fno-offload-lto Disable LTO mode (default) for offload compilation
-fno-openmp-extensions Disable all Clang extensions for OpenMP directives and clauses
-fno-operator-names Do not treat C++ operator name keywords as synonyms for operators
-fno-pch-codegen Do not generate code for uses of this PCH that assumes an explicit object file will be built for the PCH
-fno-pch-debuginfo Do not generate debug info for types in an object file built from this PCH and do not generate them elsewhere
-fno-plt Use GOT indirection instead of PLT to make external function calls (x86 only)
-fno-preserve-as-comments
Do not preserve comments in inline assembly
-fno-profile-generate Disable generation of profile instrumentation.
-fno-profile-instr-generate
Disable generation of profile instrumentation.
-fno-profile-instr-use Disable using instrumentation data for profile-guided optimization
-fno-pseudo-probe-for-profiling
Do not emit pseudo probes for sample profiling
-fno-register-global-dtors-with-atexit
Don't use atexit or __cxa_atexit to register global destructors
-fno-rtlib-add-rpath Do not add -rpath with architecture-specific resource directory to the linker flags
-fno-rtti-data Disable generation of RTTI data
-fno-rtti Disable generation of rtti information
-fno-sanitize-address-outline-instrumentation
Use default code inlining logic for the address sanitizer
-fno-sanitize-address-poison-custom-array-cookie
Disable poisoning array cookies when using custom operator new[] in AddressSanitizer
-fno-sanitize-address-use-after-scope
Disable use-after-scope detection in AddressSanitizer
-fno-sanitize-address-use-odr-indicator
Disable ODR indicator globals
-fno-sanitize-cfi-canonical-jump-tables
Do not make the jump table addresses canonical in the symbol table
-fno-sanitize-cfi-cross-dso
Disable control flow integrity (CFI) checks for cross-DSO calls.
-fno-sanitize-coverage=<value>
Disable features of coverage instrumentation for Sanitizers
-fno-sanitize-hwaddress-experimental-aliasing
Disable aliasing mode in HWAddressSanitizer
-fno-sanitize-ignorelist
Don't use ignorelist file for sanitizers
-fno-sanitize-memory-param-retval
Disable detection of uninitialized parameters and return values
-fno-sanitize-memory-track-origins
Disable origins tracking in MemorySanitizer
-fno-sanitize-memory-use-after-dtor
Disable use-after-destroy detection in MemorySanitizer
-fno-sanitize-recover=<value>
Disable recovery for specified sanitizers
-fno-sanitize-stats Disable sanitizer statistics gathering.
-fno-sanitize-thread-atomics
Disable atomic operations instrumentation in ThreadSanitizer
-fno-sanitize-thread-func-entry-exit
Disable function entry/exit instrumentation in ThreadSanitizer
-fno-sanitize-thread-memory-access
Disable memory access instrumentation in ThreadSanitizer
-fno-sanitize-trap=<value>
Disable trapping for specified sanitizers
-fno-sanitize-trap Disable trapping for all sanitizers
-fno-short-wchar Force wchar_t to be an unsigned int
-fno-show-column Do not include column number on diagnostics
-fno-show-source-location
Do not include source location information with diagnostics
-fno-signed-char char is unsigned
-fno-signed-zeros Allow optimizations that ignore the sign of floating point zeros
-fno-spell-checking Disable spell-checking
-fno-split-machine-functions
Disable late function splitting using profile information (x86 ELF)
-fno-split-stack Wouldn't use segmented stack
-fno-stack-clash-protection
Disable stack clash protection
-fno-stack-protector Disable the use of stack protectors
-fno-standalone-debug Limit debug information produced to reduce size of debug binary
-fno-strict-float-cast-overflow
Relax language rules and try to match the behavior of the target's native float-to-int conversion instructions
-fno-strict-return Don't treat control flow paths that fall off the end of a non-void function as unreachable
-fno-sycl Disables SYCL kernels compilation for device
-fno-temp-file Directly create compilation output files. This may lead to incorrect incremental builds if the compiler crashes
-fno-threadsafe-statics Do not emit code to make initialization of local statics thread safe
-fno-trigraphs Do not process trigraph sequences
-fno-unique-section-names
Don't use unique names for text and data sections
-fno-unroll-loops Turn off loop unroller
-fno-use-cxa-atexit Don't use __cxa_atexit for calling destructors
-fno-use-init-array Use .ctors/.dtors instead of .init_array/.fini_array
-fno-visibility-inlines-hidden-static-local-var
Disables -fvisibility-inlines-hidden-static-local-var (this is the default on non-darwin targets)
-fno-xray-function-index
Omit function index section at the expense of single-function patching performance
-fno-zero-initialized-in-bss
Don't place zero initialized data in BSS
-fobjc-arc-exceptions Use EH-safe code when synthesizing retains and releases in -fobjc-arc
-fobjc-arc Synthesize retain and release calls for Objective-C pointers
-fobjc-disable-direct-methods-for-testing
Ignore attribute objc_direct so that direct methods can be tested
-fobjc-encode-cxx-class-template-spec
Fully encode c++ class template specialization
-fobjc-exceptions Enable Objective-C exceptions
-fobjc-runtime=<value> Specify the target Objective-C runtime kind and version
-fobjc-weak Enable ARC-style weak references in Objective-C
-foffload-lto=<value> Set LTO mode to either 'full' or 'thin' for offload compilation
-foffload-lto Enable LTO in 'full' mode for offload compilation
-fopenmp-extensions Enable all Clang extensions for OpenMP directives and clauses
-fopenmp-implicit-rpath Set rpath on OpenMP executables
-fopenmp-new-driver Use the new driver for OpenMP offloading.
-fopenmp-simd Emit OpenMP code only for SIMD-based constructs.
-fopenmp-target-debug Enable debugging in the OpenMP offloading device RTL
-fopenmp-target-new-runtime
Use the new bitcode library for OpenMP offloading
-fopenmp-targets=<value>
Specify comma-separated list of triples OpenMP offloading targets to be supported
-fopenmp-version=<value>
Set OpenMP version (e.g. 45 for OpenMP 4.5, 50 for OpenMP 5.0). Default value is 50.
-fopenmp Parse OpenMP pragmas and generate parallel code.
-foptimization-record-file=<file>
Specify the output name of the file containing the optimization remarks. Implies -fsave-optimization-record. On Darwin platforms, this cannot be used with multiple -arch <arch> options.
-foptimization-record-passes=<regex>
Only include passes which match a specified regular expression in the generated optimization record (by default, include all passes)
-forder-file-instrumentation
Generate instrumented code to collect order file into default.profraw file (overridden by '=' form of option or LLVM_PROFILE_FILE env var)
-fpack-struct=<value> Specify the default maximum struct packing alignment
-fpascal-strings Recognize and construct Pascal-style string literals
-fpass-plugin=<dsopath> Load pass plugin from a dynamic shared object file (only with new pass manager).
-fpatchable-function-entry=<N,M>
Generate M NOPs before function entry and N-M NOPs after function entry
-fpcc-struct-return Override the default ABI to return all structs on the stack
-fpch-codegen Generate code for uses of this PCH that assumes an explicit object file will be built for the PCH
-fpch-debuginfo Generate debug info for types in an object file built from this PCH and do not generate them elsewhere
-fpch-instantiate-templates
Instantiate templates already while building a PCH
-fpch-validate-input-files-content
Validate PCH input files based on content if mtime differs
-fplugin-arg-<name>-<arg>
Pass <arg> to plugin <name>
-fplugin=<dsopath> Load the named plugin (dynamic shared object)
-fprebuilt-implicit-modules
Look up implicit modules in the prebuilt module path
-fprebuilt-module-path=<directory>
Specify the prebuilt module path
-fproc-stat-report=<value>
Save subprocess statistics to the given file
-fproc-stat-report<value>
Print subprocess statistics
-fprofile-exclude-files=<value>
Instrument only functions from files where names don't match all the regexes separated by a semi-colon
-fprofile-filter-files=<value>
Instrument only functions from files where names match any regex separated by a semi-colon
-fprofile-generate=<directory>
Generate instrumented code to collect execution counts into <directory>/default.profraw (overridden by LLVM_PROFILE_FILE env var)
-fprofile-generate Generate instrumented code to collect execution counts into default.profraw (overridden by LLVM_PROFILE_FILE env var)
-fprofile-instr-generate=<file>
Generate instrumented code to collect execution counts into <file> (overridden by LLVM_PROFILE_FILE env var)
-fprofile-instr-generate
Generate instrumented code to collect execution counts into default.profraw file (overridden by '=' form of option or LLVM_PROFILE_FILE env var)
-fprofile-instr-use=<value>
Use instrumentation data for profile-guided optimization
-fprofile-list=<value> Filename defining the list of functions/files to instrument
-fprofile-remapping-file=<file>
Use the remappings described in <file> to match the profile data against names in the program
-fprofile-sample-accurate
Specifies that the sample profile is accurate
-fprofile-sample-use=<value>
Enable sample-based profile guided optimizations
-fprofile-update=<method>
Set update method of profile counters (atomic,prefer-atomic,single)
-fprofile-use=<pathname>
Use instrumentation data for profile-guided optimization. If pathname is a directory, it reads from <pathname>/default.profdata. Otherwise, it reads from file <pathname>.
-fprotect-parens Determines whether the optimizer honors parentheses when floating-point expressions are evaluated
-fpseudo-probe-for-profiling
Emit pseudo probes for sample profiling
-freciprocal-math Allow division operations to be reassociated
-freg-struct-return Override the default ABI to return small structs in registers
-fregister-global-dtors-with-atexit
Use atexit or __cxa_atexit to register global destructors
-frelaxed-template-template-args
Enable C++17 relaxed template template argument matching
-freroll-loops Turn on loop reroller
-fropi Generate read-only position independent code (ARM only)
-frtlib-add-rpath Add -rpath with architecture-specific resource directory to the linker flags
-frwpi Generate read-write position independent code (ARM only)
-fsanitize-address-destructor=<value>
Set destructor type used in ASan instrumentation
-fsanitize-address-field-padding=<value>
Level of field padding for AddressSanitizer
-fsanitize-address-globals-dead-stripping
Enable linker dead stripping of globals in AddressSanitizer
-fsanitize-address-outline-instrumentation
Always generate function calls for address sanitizer instrumentation
-fsanitize-address-poison-custom-array-cookie
Enable poisoning array cookies when using custom operator new[] in AddressSanitizer
-fsanitize-address-use-after-return=<mode>
Select the mode of detecting stack use-after-return in AddressSanitizer: never | runtime (default) | always
-fsanitize-address-use-after-scope
Enable use-after-scope detection in AddressSanitizer
-fsanitize-address-use-odr-indicator
Enable ODR indicator globals to avoid false ODR violation reports in partially sanitized programs at the cost of an increase in binary size
-fsanitize-blacklist=<value>
Alias for -fsanitize-ignorelist=
-fsanitize-cfi-canonical-jump-tables
Make the jump table addresses canonical in the symbol table
-fsanitize-cfi-cross-dso
Enable control flow integrity (CFI) checks for cross-DSO calls.
-fsanitize-cfi-icall-generalize-pointers
Generalize pointers in CFI indirect call type signature checks
-fsanitize-coverage-allowlist=<value>
Restrict sanitizer coverage instrumentation exclusively to modules and functions that match the provided special case list, except the blocked ones
-fsanitize-coverage-blacklist=<value>
Deprecated, use -fsanitize-coverage-ignorelist= instead
-fsanitize-coverage-ignorelist=<value>
Disable sanitizer coverage instrumentation for modules and functions that match the provided special case list, even the allowed ones
-fsanitize-coverage-whitelist=<value>
Deprecated, use -fsanitize-coverage-allowlist= instead
-fsanitize-coverage=<value>
Specify the type of coverage instrumentation for Sanitizers
-fsanitize-hwaddress-abi=<value>
Select the HWAddressSanitizer ABI to target (interceptor or platform, default interceptor). This option is currently unused.
-fsanitize-hwaddress-experimental-aliasing
Enable aliasing mode in HWAddressSanitizer
-fsanitize-ignorelist=<value>
Path to ignorelist file for sanitizers
-fsanitize-memory-param-retval
Enable detection of uninitialized parameters and return values
-fsanitize-memory-track-origins=<value>
Enable origins tracking in MemorySanitizer
-fsanitize-memory-track-origins
Enable origins tracking in MemorySanitizer
-fsanitize-memory-use-after-dtor
Enable use-after-destroy detection in MemorySanitizer
-fsanitize-recover=<value>
Enable recovery for specified sanitizers
-fsanitize-stats Enable sanitizer statistics gathering.
-fsanitize-system-blacklist=<value>
Alias for -fsanitize-system-ignorelist=
-fsanitize-system-ignorelist=<value>
Path to system ignorelist file for sanitizers
-fsanitize-thread-atomics
Enable atomic operations instrumentation in ThreadSanitizer (default)
-fsanitize-thread-func-entry-exit
Enable function entry/exit instrumentation in ThreadSanitizer (default)
-fsanitize-thread-memory-access
Enable memory access instrumentation in ThreadSanitizer (default)
-fsanitize-trap=<value> Enable trapping for specified sanitizers
-fsanitize-trap Enable trapping for all sanitizers
-fsanitize-undefined-strip-path-components=<number>
Strip (or keep only, if negative) a given number of path components when emitting check metadata.
-fsanitize=<check> Turn on runtime checks for various forms of undefined or suspicious behavior. See user manual for available checks
-fsave-optimization-record=<format>
Generate an optimization record file in a specific format
-fsave-optimization-record
Generate a YAML optimization record file
-fseh-exceptions Use SEH style exceptions
-fshort-enums Allocate to an enum type only as many bytes as it needs for the declared range of possible values
-fshort-wchar Force wchar_t to be a short unsigned int
-fshow-overloads=<value>
Which overload candidates to show when overload resolution fails: best|all; defaults to all
-fshow-skipped-includes Show skipped includes in -H output.
-fsigned-char char is signed
-fsized-deallocation Enable C++14 sized global deallocation functions
-fsjlj-exceptions Use SjLj style exceptions
-fslp-vectorize Enable the superword-level parallelism vectorization passes
-fsplit-dwarf-inlining Provide minimal debug info in the object/executable to facilitate online symbolication/stack traces in the absence of .dwo/.dwp files when using Split DWARF
-fsplit-lto-unit Enables splitting of the LTO unit
-fsplit-machine-functions
Enable late function splitting using profile information (x86 ELF)
-fsplit-stack Use segmented stack
-fstack-clash-protection
Enable stack clash protection
-fstack-protector-all Enable stack protectors for all functions
-fstack-protector-strong
Enable stack protectors for some functions vulnerable to stack smashing. Compared to -fstack-protector, this uses a stronger heuristic that includes functions containing arrays of any size (and any type), as well as any calls to alloca or the taking of an address from a local variable
-fstack-protector Enable stack protectors for some functions vulnerable to stack smashing. This uses a loose heuristic which considers functions vulnerable if they contain a char (or 8bit integer) array or constant sized calls to alloca , which are of greater size than ssp-buffer-size (default: 8 bytes). All variable sized calls to alloca are considered vulnerable. A function with a stack protector has a guard value added to the stack frame that is checked on function exit. The guard value must be positioned in the stack frame such that a buffer overflow from a vulnerable variable will overwrite the guard value before overwriting the function's return address. The reference stack guard value is stored in a global variable.
-fstack-size-section Emit section containing metadata on function stack sizes
-fstack-usage Emit .su file containing information on function stack sizes
-fstandalone-debug Emit full debug info for all types used by the program
-fstrict-enums Enable optimizations based on the strict definition of an enum's value range
-fstrict-float-cast-overflow
Assume that overflowing float-to-int casts are undefined (default)
-fstrict-vtable-pointers
Enable optimizations based on the strict rules for overwriting polymorphic C++ objects
-fswift-async-fp=<option>
Control emission of Swift async extended frame info (option: auto, always, never)
-fsycl Enables SYCL kernels compilation for device
-fsystem-module Build this module as a system module. Only used with -emit-module
-fthin-link-bitcode=<value>
Write minimized bitcode to <file> for the ThinLTO thin link only
-fthinlto-index=<value> Perform ThinLTO importing using provided function summary index
-ftime-report=<value> (For new pass manager) "per-pass": one report for each pass; "per-pass-run": one report for each pass invocation
-ftime-trace-granularity=<value>
Minimum time granularity (in microseconds) traced by time profiler
-ftime-trace Turn on time profiler. Generates JSON file based on output filename.
-ftrap-function=<value> Issue call to specified function rather than a trap instruction
-ftrapv-handler=<function name>
Specify the function to be called on overflow
-ftrapv Trap on integer overflow
-ftrigraphs Process trigraph sequences
-ftrivial-auto-var-init-stop-after=<value>
Stop initializing trivial automatic stack variables after the specified number of instances
-ftrivial-auto-var-init=<value>
Initialize trivial automatic stack variables: uninitialized (default) | pattern
-funique-basic-block-section-names
Use unique names for basic block sections (ELF Only)
-funique-internal-linkage-names
Uniqueify Internal Linkage Symbol Names by appending the MD5 hash of the module path
-funroll-loops Turn on loop unroller
-fuse-cuid=<value> Method to generate ID's for compilation units for single source offloading languages CUDA and HIP: 'hash' (ID's generated by hashing file path and command line options) | 'random' (ID's generated as random numbers) | 'none' (disabled). Default is 'hash'. This option will be overridden by option '-cuid=[ID]' if it is specified.
-fuse-line-directives Use #line in preprocessed output
-fvalidate-ast-input-files-content
Compute and store the hash of input files used to build an AST. Files with mismatching mtime's are considered valid if both contents is identical
-fveclib=<value> Use the given vector functions library
-fvectorize Enable the loop vectorization passes
-fverbose-asm Generate verbose assembly output
-fvirtual-function-elimination
Enables dead virtual function elimination optimization. Requires -flto=full
-fvisibility-dllexport=<value>
The visibility for dllexport definitions [-fvisibility-from-dllstorageclass]
-fvisibility-externs-dllimport=<value>
The visibility for dllimport external declarations [-fvisibility-from-dllstorageclass]
-fvisibility-externs-nodllstorageclass=<value>
The visibility for external declarations without an explicit DLL dllstorageclass [-fvisibility-from-dllstorageclass]
-fvisibility-from-dllstorageclass
Set the visibility of symbols in the generated code from their DLL storage class
-fvisibility-global-new-delete-hidden
Give global C++ operator new and delete declarations hidden visibility
-fvisibility-inlines-hidden-static-local-var
When -fvisibility-inlines-hidden is enabled, static variables in inline C++ member functions will also be given hidden visibility by default
-fvisibility-inlines-hidden
Give inline C++ member functions hidden visibility by default
-fvisibility-ms-compat Give global types 'default' visibility and global functions and variables 'hidden' visibility by default
-fvisibility-nodllstorageclass=<value>
The visibility for defintiions without an explicit DLL export class [-fvisibility-from-dllstorageclass]
-fvisibility=<value> Set the default symbol visibility for all global declarations
-fwasm-exceptions Use WebAssembly style exceptions
-fwhole-program-vtables Enables whole-program vtable optimization. Requires -flto
-fwrapv Treat signed integer overflow as two's complement
-fwritable-strings Store string literals as writable data
-fxl-pragma-pack Enable IBM XL #pragma pack handling
-fxray-always-emit-customevents
Always emit __xray_customevent(...) calls even if the containing function is not always instrumented
-fxray-always-emit-typedevents
Always emit __xray_typedevent(...) calls even if the containing function is not always instrumented
-fxray-always-instrument= <value>
DEPRECATED: Filename defining the whitelist for imbuing the 'always instrument' XRay attribute.
-fxray-attr-list= <value>
Filename defining the list of functions/types for imbuing XRay attributes.
-fxray-function-groups=<value>
Only instrument 1 of N groups
-fxray-ignore-loops Don't instrument functions with loops unless they also meet the minimum function size
-fxray-instruction-threshold= <value>
Sets the minimum function size to instrument with XRay
-fxray-instrumentation-bundle= <value>
Select which XRay instrumentation points to emit. Options: all, none, function-entry, function-exit, function, custom. Default is 'all'. 'function' includes both 'function-entry' and 'function-exit'.
-fxray-instrument Generate XRay instrumentation sleds on function entry and exit
-fxray-link-deps Tells clang to add the link dependencies for XRay.
-fxray-modes= <value> List of modes to link in by default into XRay instrumented binaries.
-fxray-never-instrument= <value>
DEPRECATED: Filename defining the whitelist for imbuing the 'never instrument' XRay attribute.
-fxray-selected-function-group=<value>
When using -fxray-function-groups, select which group of functions to instrument. Valid range is 0 to fxray-function-groups - 1
-fzvector Enable System z vector language extension
-F <value> Add directory to framework include search path
--gcc-toolchain=<value> Search for GCC installation in the specified directory on targets which commonly use GCC. The directory usually contains 'lib{,32,64}/gcc{,-cross}/$triple' and 'include'. If specified, sysroot is skipped for GCC detection. Note: executables (e.g. ld) used by the compiler are not overridden by the selected GCC installation
-gcodeview-ghash Emit type record hashes in a .debug$H section
-gcodeview Generate CodeView debug information
-gdwarf-2 Generate source-level debug information with dwarf version 2
-gdwarf-3 Generate source-level debug information with dwarf version 3
-gdwarf-4 Generate source-level debug information with dwarf version 4
-gdwarf-5 Generate source-level debug information with dwarf version 5
-gdwarf32 Enables DWARF32 format for ELF binaries, if debug information emission is enabled.
-gdwarf64 Enables DWARF64 format for ELF binaries, if debug information emission is enabled.
-gdwarf Generate source-level debug information with the default dwarf version
-gembed-source Embed source text in DWARF debug sections
-gline-directives-only Emit debug line info directives only
-gline-tables-only Emit debug line number tables only
-gmodules Generate debug info with external references to clang modules or precompiled headers
-gno-embed-source Restore the default behavior of not embedding source text in DWARF debug sections
-gno-inline-line-tables Don't emit inline line tables.
--gpu-bundle-output Bundle output files of HIP device compilation
--gpu-instrument-lib=<value>
Instrument device library for HIP, which is a LLVM bitcode containing __cyg_profile_func_enter and __cyg_profile_func_exit
--gpu-max-threads-per-block=<value>
Default max threads per block for kernel launch bounds for HIP
-gsplit-dwarf=<value> Set DWARF fission mode to either 'split' or 'single'
-gz=<value> DWARF debug sections compression type
-G <size> Put objects of at most <size> bytes into small data section (MIPS / Hexagon)
-g Generate source-level debug information
--help-hidden Display help for hidden options
-help Display available options
--hip-device-lib=<value>
HIP device library
--hip-link Link clang-offload-bundler bundles for HIP
--hip-path=<value> HIP runtime installation path, used for finding HIP version and adding HIP include path.
--hip-version=<value> HIP version in the format of major.minor.patch
--hipspv-pass-plugin=<dsopath>
path to a pass plugin for HIP to SPIR-V passes.
-H Show header includes and nesting depth
-I- Restrict all prior -I flags to double-quoted inclusion and remove current directory from include path
-ibuiltininc Enable builtin #include directories even when -nostdinc is used before or after -ibuiltininc. Using -nobuiltininc after the option disables it
-idirafter <value> Add directory to AFTER include search path
-iframeworkwithsysroot <directory>
Add directory to SYSTEM framework search path, absolute paths are relative to -isysroot
-iframework <value> Add directory to SYSTEM framework search path
-imacros <file> Include macros from file before parsing
-include-pch <file> Include precompiled header file
-include <file> Include file before parsing
-index-header-map Make the next included directory (-I or -F) an indexer header map
-iprefix <dir> Set the -iwithprefix/-iwithprefixbefore prefix
-iquote <directory> Add directory to QUOTE include search path
-isysroot <dir> Set the system root directory (usually /)
-isystem-after <directory>
Add directory to end of the SYSTEM include search path
-isystem <directory> Add directory to SYSTEM include search path
-ivfsoverlay <value> Overlay the virtual filesystem described by file over the real file system
-iwithprefixbefore <dir>
Set directory to include search path with prefix
-iwithprefix <dir> Set directory to SYSTEM include search path with prefix
-iwithsysroot <directory>
Add directory to SYSTEM include search path, absolute paths are relative to -isysroot
-I <dir> Add directory to the end of the list of include search paths
--libomptarget-amdgcn-bc-path=<value>
Path to libomptarget-amdgcn bitcode library
--libomptarget-nvptx-bc-path=<value>
Path to libomptarget-nvptx bitcode library
-L <dir> Add directory to library search path
-mabi=vec-default Enable the default Altivec ABI on AIX (AIX only). Uses only volatile vector registers.
-mabi=vec-extabi Enable the extended Altivec ABI on AIX (AIX only). Uses volatile and nonvolatile vector registers
-mabicalls Enable SVR4-style position-independent code (Mips only)
-maix-struct-return Return all structs in memory (PPC32 only)
-malign-branch-boundary=<value>
Specify the boundary's size to align branches
-malign-branch=<value> Specify types of branches to align
-malign-double Align doubles to two words in structs (x86 only)
-mamdgpu-ieee Sets the IEEE bit in the expected default floating point mode register. Floating point opcodes that support exception flag gathering quiet and propagate signaling NaN inputs per IEEE 754-2008. This option changes the ABI. (AMDGPU only)
-mbackchain Link stack frames through backchain on System Z
-mbranch-protection=<value>
Enforce targets of indirect branches and function returns
-mbranches-within-32B-boundaries
Align selected branches (fused, jcc, jmp) within 32-byte boundary
-mcmodel=medany Equivalent to -mcmodel=medium, compatible with RISC-V gcc.
-mcmodel=medlow Equivalent to -mcmodel=small, compatible with RISC-V gcc.
-mcmse Allow use of CMSE (Armv8-M Security Extensions)
-mcode-object-v3 Legacy option to specify code object ABI V3 (AMDGPU only)
-mcode-object-version=<version>
Specify code object ABI version. Defaults to 3. (AMDGPU only)
-mcrc Allow use of CRC instructions (ARM/Mips only)
-mcumode Specify CU wavefront execution mode (AMDGPU only)
-mdouble=<value> Force double to be 32 bits or 64 bits
-MD Write a depfile containing user and system headers
-meabi <value> Set EABI type, e.g. 4, 5 or gnu (default depends on triple)
-membedded-data Place constants in the .rodata section instead of the .sdata section even if they meet the -G <size> threshold (MIPS)
-menable-experimental-extensions
Enable use of experimental RISC-V extensions.
-menable-unsafe-fp-math Allow unsafe floating-point math optimizations which may decrease precision
-mexec-model=<value> Execution model (WebAssembly only)
-mexecute-only Disallow generation of data access to code sections (ARM only)
-mextern-sdata Assume that externally defined data is in the small data if it meets the -G <size> threshold (MIPS)
-mfentry Insert calls to fentry at function entry (x86/SystemZ only)
-mfix-cmse-cve-2021-35465
Work around VLLDM erratum CVE-2021-35465 (ARM only)
-mfix-cortex-a53-835769 Workaround Cortex-A53 erratum 835769 (AArch64 only)
-mfp32 Use 32-bit floating point registers (MIPS only)
-mfp64 Use 64-bit floating point registers (MIPS only)
-MF <file> Write depfile output from -MMD, -MD, -MM, or -M to <file>
-mgeneral-regs-only Generate code which only uses the general purpose registers (AArch64/x86 only)
-mglobal-merge Enable merging of globals
-mgpopt Use GP relative accesses for symbols known to be in a small data section (MIPS)
-MG Add missing headers to depfile
-mharden-sls=<value> Select straight-line speculation hardening scope
-mhvx-ieee-fp Enable Hexagon HVX IEEE floating-point
-mhvx-length=<value> Set Hexagon Vector Length
-mhvx-qfloat Enable Hexagon HVX QFloat instructions
-mhvx=<value> Enable Hexagon Vector eXtensions
-mhvx Enable Hexagon Vector eXtensions
-miamcu Use Intel MCU ABI
-mibt-seal Optimize fcf-protection=branch/full (requires LTO).
-mignore-xcoff-visibility
Not emit the visibility attribute for asm in AIX OS or give all symbols 'unspecified' visibility in XCOFF object file
--migrate Run the migrator
-mincremental-linker-compatible
(integrated-as) Emit an object file which can be used with an incremental linker
-mindirect-jump=<value> Change indirect jump instructions to inhibit speculation
-mios-version-min=<value>
Set iOS deployment target
-MJ <value> Write a compilation database entry per input
-mllvm <value> Additional arguments to forward to LLVM's option processing
-mlocal-sdata Extend the -G behaviour to object local data (MIPS)
-mlong-calls Generate branches with extended addressability, usually via indirect jumps.
-mlong-double-128 Force long double to be 128 bits
-mlong-double-64 Force long double to be 64 bits
-mlong-double-80 Force long double to be 80 bits, padded to 128 bits for storage
-mlvi-cfi Enable only control-flow mitigations for Load Value Injection (LVI)
-mlvi-hardening Enable all mitigations for Load Value Injection (LVI)
-mmacosx-version-min=<value>
Set Mac OS X deployment target
-mmadd4 Enable the generation of 4-operand madd.s, madd.d and related instructions.
-mmark-bti-property Add .note.gnu.property with BTI to assembly files (AArch64 only)
-MMD Write a depfile containing user headers
-mmemops Enable generation of memop instructions
-mms-bitfields Set the default structure layout to be compatible with the Microsoft compiler standard
-mmsa Enable MSA ASE (MIPS only)
-mmt Enable MT ASE (MIPS only)
-MM Like -MMD, but also implies -E and writes to stdout by default
-mno-abicalls Disable SVR4-style position-independent code (Mips only)
-mno-bti-at-return-twice
Do not add a BTI instruction after a setjmp or other return-twice construct (Arm only)
-mno-code-object-v3 Legacy option to specify code object ABI V2 (AMDGPU only)
-mno-crc Disallow use of CRC instructions (Mips only)
-mno-cumode Specify WGP wavefront execution mode (AMDGPU only)
-mno-embedded-data Do not place constants in the .rodata section instead of the .sdata if they meet the -G <size> threshold (MIPS)
-mno-execute-only Allow generation of data access to code sections (ARM only)
-mno-extern-sdata Do not assume that externally defined data is in the small data if it meets the -G <size> threshold (MIPS)
-mno-fix-cmse-cve-2021-35465
Don't work around VLLDM erratum CVE-2021-35465 (ARM only)
-mno-fix-cortex-a53-835769
Don't workaround Cortex-A53 erratum 835769 (AArch64 only)
-mno-global-merge Disable merging of globals
-mno-gpopt Do not use GP relative accesses for symbols known to be in a small data section (MIPS)
-mno-hvx-ieee-fp Disable Hexagon HVX IEEE floating-point
-mno-hvx-qfloat Disable Hexagon HVX QFloat instructions
-mno-hvx Disable Hexagon Vector eXtensions
-mno-implicit-float Don't generate implicit floating point instructions
-mno-incremental-linker-compatible
(integrated-as) Emit an object file which cannot be used with an incremental linker
-mno-local-sdata Do not extend the -G behaviour to object local data (MIPS)
-mno-long-calls Restore the default behaviour of not generating long calls
-mno-lvi-cfi Disable control-flow mitigations for Load Value Injection (LVI)
-mno-lvi-hardening Disable mitigations for Load Value Injection (LVI)
-mno-madd4 Disable the generation of 4-operand madd.s, madd.d and related instructions.
-mno-memops Disable generation of memop instructions
-mno-movt Disallow use of movt/movw pairs (ARM only)
-mno-ms-bitfields Do not set the default structure layout to be compatible with the Microsoft compiler standard
-mno-msa Disable MSA ASE (MIPS only)
-mno-mt Disable MT ASE (MIPS only)
-mno-neg-immediates Disallow converting instructions with negative immediates to their negation or inversion.
-mno-nvj Disable generation of new-value jumps
-mno-nvs Disable generation of new-value stores
-mno-outline-atomics Don't generate local calls to out-of-line atomic operations
-mno-outline Disable function outlining (AArch64 only)
-mno-packets Disable generation of instruction packets
-mno-relax Disable linker relaxation
-mno-restrict-it Allow generation of deprecated IT blocks for ARMv8. It is off by default for ARMv8 Thumb mode
-mno-save-restore Disable using library calls for save and restore
-mno-seses Disable speculative execution side effect suppression (SESES)
-mno-stack-arg-probe Disable stack probes which are enabled by default
-mno-tgsplit Disable threadgroup split execution mode (AMDGPU only)
-mno-tls-direct-seg-refs
Disable direct TLS access through segment registers
-mno-unaligned-access Force all memory accesses to be aligned (AArch32/AArch64 only)
-mno-wavefrontsize64 Specify wavefront size 32 mode (AMDGPU only)
-mnocrc Disallow use of CRC instructions (ARM only)
-mnop-mcount Generate mcount/__fentry__ calls as nops. To activate they need to be patched in.
-mnvj Enable generation of new-value jumps
-mnvs Enable generation of new-value stores
-module-dependency-dir <value>
Directory to dump module dependencies to
-module-file-info Provide information about a particular module file
-momit-leaf-frame-pointer
Omit frame pointer setup for leaf functions
-moutline-atomics Generate local calls to out-of-line atomic operations
-moutline Enable function outlining (AArch64 only)
-mpacked-stack Use packed stack layout (SystemZ only).
-mpackets Enable generation of instruction packets
-mpad-max-prefix-size=<value>
Specify maximum number of prefixes to use for padding
-mprefer-vector-width=<value>
Specifies preferred vector width for auto-vectorization. Defaults to 'none' which allows target specific decisions.
-MP Create phony target for each dependency (other than main file)
-mqdsp6-compat Enable hexagon-qdsp6 backward compatibility
-MQ <value> Specify name of main file output to quote in depfile
-mrecord-mcount Generate a __mcount_loc section entry for each __fentry__ call.
-mrelax-all (integrated-as) Relax all machine instructions
-mrelax Enable linker relaxation
-mrestrict-it Disallow generation of deprecated IT blocks for ARMv8. It is on by default for ARMv8 Thumb mode.
-mrtd Make StdCall calling convention the default
-msave-restore Enable using library calls for save and restore
-mseses Enable speculative execution side effect suppression (SESES). Includes LVI control flow integrity mitigations
-msign-return-address=<value>
Select return address signing scope
-mskip-rax-setup Skip setting up RAX register when passing variable arguments (x86 only)
-msmall-data-limit=<value>
Put global and static data smaller than the limit into a special section
-msoft-float Use software floating point
-mstack-alignment=<value>
Set the stack alignment
-mstack-arg-probe Enable stack probes
-mstack-probe-size=<value>
Set the stack probe size
-mstack-protector-guard-offset=<value>
Use the given offset for addressing the stack-protector guard
-mstack-protector-guard-reg=<value>
Use the given reg for addressing the stack-protector guard
-mstack-protector-guard=<value>
Use the given guard (global, tls) for addressing the stack-protector guard
-mstackrealign Force realign the stack at entry to every function
-msve-vector-bits=<value>
Specify the size in bits of an SVE vector register. Defaults to the vector length agnostic value of "scalable". (AArch64 only)
-msvr4-struct-return Return small structs in registers (PPC32 only)
-mtargetos=<value> Set the deployment target to be the specified OS and OS version
-mtgsplit Enable threadgroup split execution mode (AMDGPU only)
-mthread-model <value> The thread model to use, e.g. posix, single (posix by default)
-mtls-direct-seg-refs Enable direct TLS access through segment registers (default)
-mtls-size=<value> Specify bit size of immediate TLS offsets (AArch64 ELF only): 12 (for 4KB) | 24 (for 16MB, default) | 32 (for 4GB) | 48 (for 256TB, needs -mcmodel=large)
-mtp=<value> Thread pointer access method (AArch32/AArch64 only)
-mtune=<value> Only supported on X86 and RISC-V. Otherwise accepted for compatibility with GCC.
-MT <value> Specify name of main file output in depfile
-munaligned-access Allow memory accesses to be unaligned (AArch32/AArch64 only)
-munsafe-fp-atomics Enable unsafe floating point atomic instructions (AMDGPU only)
-mvscale-max=<value> Specify the vscale maximum. Defaults to the vector length agnostic value of "0". (AArch64 only)
-mvscale-min=<value> Specify the vscale minimum. Defaults to "1". (AArch64 only)
-MV Use NMake/Jom format for the depfile
-mwavefrontsize64 Specify wavefront size 64 mode (AMDGPU only)
-M Like -MD, but also implies -E and writes to stdout by default
--no-cuda-include-ptx=<value>
Do not include PTX for the following GPU architecture (e.g. sm_35) or 'all'. May be specified more than once.
--no-cuda-version-check Don't error out if the detected version of the CUDA install is too low for the requested CUDA gpu architecture.
--no-gpu-bundle-output Do not bundle output files of HIP device compilation
--no-offload-arch=<value>
Remove CUDA/HIP offloading device architecture (e.g. sm_35, gfx906) from the list of devices to compile for. 'all' resets the list to its default value.
--no-system-header-prefix=<prefix>
Treat all #include paths starting with <prefix> as not including a system header.
-nobuiltininc Disable builtin #include directories
-nogpuinc Do not add include paths for CUDA/HIP and do not include the default CUDA/HIP wrapper headers
-nogpulib Do not link device library for CUDA/HIP device compilation
-nohipwrapperinc Do not include the default HIP wrapper headers and include paths
-nostdinc++ Disable standard #include directories for the C++ standard library
-ObjC++ Treat source input files as Objective-C++ inputs
-objcmt-allowlist-dir-path=<value>
Only modify files with a filename contained in the provided directory path
-objcmt-atomic-property Make migration to 'atomic' properties
-objcmt-migrate-all Enable migration to modern ObjC
-objcmt-migrate-annotation
Enable migration to property and method annotations
-objcmt-migrate-designated-init
Enable migration to infer NS_DESIGNATED_INITIALIZER for initializer methods
-objcmt-migrate-instancetype
Enable migration to infer instancetype for method result type
-objcmt-migrate-literals
Enable migration to modern ObjC literals
-objcmt-migrate-ns-macros
Enable migration to NS_ENUM/NS_OPTIONS macros
-objcmt-migrate-property-dot-syntax
Enable migration of setter/getter messages to property-dot syntax
-objcmt-migrate-property
Enable migration to modern ObjC property
-objcmt-migrate-protocol-conformance
Enable migration to add protocol conformance on classes
-objcmt-migrate-readonly-property
Enable migration to modern ObjC readonly property
-objcmt-migrate-readwrite-property
Enable migration to modern ObjC readwrite property
-objcmt-migrate-subscripting
Enable migration to modern ObjC subscripting
-objcmt-ns-nonatomic-iosonly
Enable migration to use NS_NONATOMIC_IOSONLY macro for setting property's 'atomic' attribute
-objcmt-returns-innerpointer-property
Enable migration to annotate property with NS_RETURNS_INNER_POINTER
-objcmt-whitelist-dir-path=<value>
Alias for -objcmt-allowlist-dir-path
-ObjC Treat source input files as Objective-C inputs
-object-file-name=<file>
Set the output <file> for debug infos
--offload-arch=<value> CUDA offloading device architecture (e.g. sm_35), or HIP offloading target ID in the form of a device architecture followed by target ID features delimited by a colon. Each target ID feature is a pre-defined string followed by a plus or minus sign (e.g. gfx908:xnack+:sramecc-). May be specified more than once.
--offload=<value> Specify comma-separated list of offloading target triples (CUDA and HIP only)
-o <file> Write output to <file>
-pedantic Warn on language extensions
-pg Enable mcount instrumentation
-pipe Use pipes between commands, when possible
--precompile Only precompile the input
-print-effective-triple Print the effective target triple
-print-file-name=<file> Print the full library path of <file>
-print-ivar-layout Enable Objective-C Ivar layout bitmap print trace
-print-libgcc-file-name Print the library path for the currently used compiler runtime library ("libgcc.a" or "libclang_rt.builtins.*.a")
-print-multiarch Print the multiarch target triple
-print-prog-name=<name> Print the full program path of <name>
-print-resource-dir Print the resource directory pathname
-print-rocm-search-dirs Print the paths used for finding ROCm installation
-print-runtime-dir Print the directory pathname containing clangs runtime libraries
-print-search-dirs Print the paths used for finding libraries and programs
-print-supported-cpus Print supported cpu models for the given target (if target is not specified, it will print the supported cpus for the default target)
-print-target-triple Print the normalized target triple
-print-targets Print the registered targets
-pthread Support POSIX threads in generated code
--ptxas-path=<value> Path to ptxas (used for compiling CUDA code)
-P Disable linemarker output in -E mode
-Qn Do not emit metadata containing compiler name and version
-Qunused-arguments Don't emit warning for unused driver arguments
-Qy Emit metadata containing compiler name and version
-relocatable-pch Whether to build a relocatable precompiled header
-rewrite-legacy-objc Rewrite Legacy Objective-C source to C++
-rewrite-objc Rewrite Objective-C source to C++
--rocm-device-lib-path=<value>
ROCm device library path. Alternative to rocm-path.
--rocm-path=<value> ROCm installation path, used for finding and automatically linking required bitcode libraries.
-Rpass-analysis=<value> Report transformation analysis from optimization passes whose name matches the given POSIX regular expression
-Rpass-missed=<value> Report missed transformations by optimization passes whose name matches the given POSIX regular expression
-Rpass=<value> Report transformations performed by optimization passes whose name matches the given POSIX regular expression
-rtlib=<value> Compiler runtime library to use
-R<remark> Enable the specified remark
-save-stats=<value> Save llvm statistics.
-save-stats Save llvm statistics.
-save-temps=<value> Save intermediate compilation results.
-save-temps Save intermediate compilation results
-serialize-diagnostics <value>
Serialize compiler diagnostics to a file
-shared-libsan Dynamically link the sanitizer runtime
--start-no-unused-arguments
Don't emit warnings about unused arguments for the following arguments
-static-libsan Statically link the sanitizer runtime
-static-openmp Use the static host OpenMP runtime while linking.
-std=<value> Language standard to compile for
-stdlib++-isystem <directory>
Use directory as the C++ standard library include path
-stdlib=<value> C++ standard library to use
-sycl-std=<value> SYCL language standard to compile for.
--system-header-prefix=<prefix>
Treat all #include paths starting with <prefix> as including a system header.
-S Only run preprocess and compilation steps
--target=<value> Generate code for the given target
-Tbss <addr> Set starting address of BSS to <addr>
-Tdata <addr> Set starting address of DATA to <addr>
-time Time individual commands
-traditional-cpp Enable some traditional CPP emulation
-trigraphs Process trigraph sequences
-Ttext <addr> Set starting address of TEXT to <addr>
-T <script> Specify <script> as linker script
-undef undef all system defines
-unwindlib=<value> Unwind library to use
-U <macro> Undefine macro <macro>
--verify-debug-info Verify the binary representation of debug output
-verify-pch Load and verify that a pre-compiled header file is not stale
--version Print version information
-v Show commands to run and use verbose output
-Wa,<arg> Pass the comma separated arguments in <arg> to the assembler
-Wdeprecated Enable warnings for deprecated constructs and define __DEPRECATED
-Wl,<arg> Pass the comma separated arguments in <arg> to the linker
-working-directory <value>
Resolve file paths relative to the specified directory
-Wp,<arg> Pass the comma separated arguments in <arg> to the preprocessor
-W<warning> Enable the specified warning
-w Suppress all warnings
-Xanalyzer <arg> Pass <arg> to the static analyzer
-Xarch_device <arg> Pass <arg> to the CUDA/HIP device compilation
-Xarch_host <arg> Pass <arg> to the CUDA/HIP host compilation
-Xassembler <arg> Pass <arg> to the assembler
-Xclang <arg> Pass <arg> to the clang compiler
-Xcuda-fatbinary <arg> Pass <arg> to fatbinary invocation
-Xcuda-ptxas <arg> Pass <arg> to the ptxas assembler
-Xlinker <arg> Pass <arg> to the linker
-Xopenmp-target=<triple> <arg>
Pass <arg> to the target offloading toolchain identified by <triple>.
-Xopenmp-target <arg> Pass <arg> to the target offloading toolchain.
-Xpreprocessor <arg> Pass <arg> to the preprocessor
-x <language> Treat subsequent input files as having type <language>
-z <arg> Pass -z <arg> to the linker
================================================
FILE: Demo/main.cpp
================================================
// 本测试主要适配arm64方向
#include <stdlib.h>
#include <stdio.h>
static int aaa = 88;
int add(int a, int b) __attribute((__annotate__(("split vmf")))){
return (a+b);
}
// strenc indibr strenc
void say_hello()
// indibr split vmf
__attribute((__annotate__(("icall"))))
{
printf("Hello~\n");
}
int main(){
say_hello();
int ret = add(10, 20);
printf("ret is %d\n", ret);
printf("aaa is %d\n",aaa);
return 0;
}
================================================
FILE: Demo/symbols_obf.yaml
================================================
function: { source: _Z3addii, target: dfffff} # 函数替换
global variable: { source: _ZL3aaa, transform: ccccc} # 变量替换
================================================
FILE: Obfuscation/CMakeLists.txt
================================================
# 参考官方文档:https://llvm.org/docs/CMake.html#developing-llvm-passes-out-of-source
# 参考文献资料:https://github.com/LeadroyaL/llvm-pass-tutorial
## 请确保编译器是来自NDK的clang 自举编译
cmake_minimum_required(VERSION 3.13.4)
# SET (CMAKE_C_COMPILER_WORKS 1)
# SET (CMAKE_CXX_COMPILER_WORKS 1)
set(CMAKE_C_COMPILER /home/ssage/Android/ndk-llvm/out/install/linux-x86/clang-dev/bin/clang) # 调用原生NDK的clang 来自AOSP
set(CMAKE_CXX_COMPILER /home/ssage/Android/ndk-llvm/out/install/linux-x86/clang-dev/bin/clang) # 调用原生NDK的clang++ 来自AOSP
project(SsagePass) # 项目名称
# we need LLVM_HOME in order not automatically set LLVM_DIR
set(ENV{LLVM_HOME} /home/ssage/Android/ndk-llvm/out/install/linux-x86/clang-dev) # 指定LLVM_HOME为来自原生NDK的
set(ENV{LLVM_DIR} /home/ssage/Android/ndk-llvm/out/install/linux-x86/clang-dev/lib64/cmake/llvm) # 指定cmake文件 如此可以连接到LLVM库
find_package(LLVM REQUIRED CONFIG) # 寻找LLVM依赖包
add_definitions(${LLVM_DEFINITIONS}) # 预定义
include_directories(/home/ssage/Android/ndk-llvm/out/install/linux-x86/clang-dev/include) # LLVM的头文件
include_directories("./include") # 包含 ./include 文件夹中的头文件 主要是为Pass项目服务
link_directories(${LLVM_LIBRARY_DIRS}) # LLVM依赖库
## 如果LLVM版本高于10 则需要启用C++14特性
set(CMAKE_CXX_STANDARD 14) # LLVM启用14特性
## 确保使用llvm的libc++ 而不是来自gcc的libstdc++
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++") # libc++
include_directories(/home/ssage/Android/ndk-llvm/out/install/linux-x86/clang-dev/include/c++/v1) # libc++的头文件包含路径
set(CMAKE_SKIP_RPATH ON)
add_library( SsageObfuscator MODULE # 生成动态库文件
src/SplitBasicBlock.cpp
src/Utils.cpp
src/CryptoUtils.cpp
src/Flattening.cpp
src/LegacyLowerSwitch.cpp
src/PMRegistration.cpp
src/StringEncryption.cpp
src/IndirectBranch.cpp
src/FunctionWrapper.cpp
src/BogusControlFlow.cpp
src/VMFlatten.cpp
src/IndirectCall.cpp
src/ObfuscationOptions.cpp
src/IPObfuscationContext.cpp
src/MBAObfuscation.cpp
src/MBAUtils.cpp
src/FlatteningEnhanced.cpp
)
# Use C++11 to compile your pass (i.e., supply -std=c++11).
target_compile_features(SsageObfuscator PRIVATE
cxx_range_for cxx_auto_type
)
# LLVM is (typically) built with no C++ RTTI. We need to match that;
# otherwise, we'll get linker errors about missing RTTI data.
set_target_properties(SsageObfuscator PROPERTIES
COMPILE_FLAGS "-fno-rtti"
)
================================================
FILE: Obfuscation/include/BogusControlFlow.h
================================================
#ifndef _BOGUSCONTROLFLOW_H_
#define _BOGUSCONTROLFLOW_H_
// LLVM libs
#include "llvm/Pass.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/InstrTypes.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/Type.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/Transforms/Utils/Cloning.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/CodeGen/ISDOpcodes.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Transforms/IPO.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/NoFolder.h"
#include "llvm/Support/TargetSelect.h"
#include "llvm/Transforms/Utils/Local.h"
// System libs
#include <list>
#include <memory>
// User libs
#include "CryptoUtils.h"
#include "Utils.h"
using namespace std;
using namespace llvm;
namespace llvm{ // 基本块分割
class BogusControlFlowPass : public PassInfoMixin<BogusControlFlowPass>{
public:
bool flag;
BogusControlFlowPass(bool flag){
this->flag = flag;
} // 携带flag的构造函数
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM); // Pass实现函数
void bogus(Function &F);
void addBogusFlow(BasicBlock *basicBlock, Function &F);
BasicBlock *createAlteredBasicBlock(BasicBlock *basicBlock, const Twine &Name, Function *F);
bool doF(Module &M);
static bool isRequired() { return true; } // 直接返回true即可
};
BogusControlFlowPass *createBogusControlFlow(bool flag); // 创建基本块分割
}
#endif
================================================
FILE: Obfuscation/include/CryptoUtils.h
================================================
//===- CryptoUtils.h - Cryptographically Secure Pseudo-Random Generator ---===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains includes and defines for the AES CTR PRNG
// The AES implementation has been derived and adapted
// from libtomcrypt (see http://libtom.org)
// Created on: 22 juin 2012
// Author(s): jrinaldini, pjunod
//===----------------------------------------------------------------------===//
#ifndef _OBFUSCATION_CRYPTUTILS_H
#define _OBFUSCATION_CRYPTUTILS_H
#include "llvm/Support/ManagedStatic.h"
#include <cstdint>
#include <cstdio>
#include <string>
namespace llvm {
class CryptoUtils;
extern ManagedStatic<CryptoUtils> cryptoutils;
#define BYTE(x, n) (((x) >> (8 * (n))) & 0xFF)
#if defined(__i386) || defined(__i386__) || defined(_M_IX86) || \
defined(INTEL_CC) || defined(_WIN64) || defined(_WIN32)
#ifndef ENDIAN_LITTLE
#define ENDIAN_LITTLE
#endif
#define ENDIAN_32BITWORD
#if !defined(_WIN64) || !defined(_WIN32)
#ifndef UNALIGNED
#define UNALIGNED
#endif
#endif
#elif defined(__alpha)
#ifndef ENDIAN_LITTLE
#define ENDIAN_LITTLE
#endif
#define ENDIAN_64BITWORD
#elif defined(__x86_64__)
#ifndef ENDIAN_LITTLE
#define ENDIAN_LITTLE
#endif
#define ENDIAN_64BITWORD
#define UNALIGNED
#elif (defined(__R5900) || defined(R5900) || defined(__R5900__)) && \
(defined(_mips) || defined(__mips__) || defined(mips))
#ifndef ENDIAN_LITTLE
#define ENDIAN_LITTLE
#endif
#define ENDIAN_64BITWORD
#elif defined(__sparc) || defined(__aarch64__)
#ifndef ENDIAN_BIG
#define ENDIAN_BIG
#endif
#if defined(__arch64__) || defined(__aarch64__)
#define ENDIAN_64BITWORD
#else
#define ENDIAN_32BITWORD
#endif
#endif
#if defined(__BIG_ENDIAN__) || defined(_BIG_ENDIAN)
#define ENDIAN_BIG
#endif
#if !defined(ENDIAN_BIG) && !defined(ENDIAN_LITTLE)
#error \
"Unknown endianness of the compilation platform, check this header aes_encrypt.h"
#endif
#define CryptoUtils_POOL_SIZE (0x1 << 17) // 2^17
class CryptoUtils {
public:
CryptoUtils();
~CryptoUtils();
char *get_seed();
void get_bytes(char *buffer, const int len);
char get_char();
bool prng_seed(std::string const &seed);
// Returns a uniformly distributed 8-bit value
uint8_t get_uint8_t();
// Returns a uniformly distributed 16-bit value
uint16_t get_uint16_t();
// Returns a uniformly distributed 32-bit value
uint32_t get_uint32_t();
// Returns an integer uniformly distributed on [0, max[
uint32_t get_range(const uint32_t max);
// Returns a uniformly distributed 64-bit value
uint64_t get_uint64_t();
// Scramble a 32-bit value depending on a 128-bit value
unsigned scramble32(const unsigned in, const char key[16]);
int sha256(const char *msg, unsigned char *hash);
private:
uint32_t ks[44];
char key[16];
char ctr[16];
char pool[CryptoUtils_POOL_SIZE];
uint32_t idx;
std::string seed;
bool seeded;
typedef struct {
uint64_t length;
uint32_t state[8], curlen;
unsigned char buf[64];
} sha256_state;
void aes_compute_ks(uint32_t *ks, const char *k);
void aes_encrypt(char *out, const char *in, const uint32_t *ks);
bool prng_seed();
void inc_ctr();
void populate_pool();
int sha256_done(sha256_state *md, unsigned char *out);
int sha256_init(sha256_state *md);
static int sha256_compress(sha256_state *md, unsigned char *buf);
int sha256_process(sha256_state *md, const unsigned char *in,
unsigned long inlen);
};
} // namespace llvm
#endif
================================================
FILE: Obfuscation/include/Eigen/Cholesky
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_CHOLESKY_MODULE_H
#define EIGEN_CHOLESKY_MODULE_H
#include "Core"
#include "Jacobi"
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup Cholesky_Module Cholesky module
*
*
*
* This module provides two variants of the Cholesky decomposition for selfadjoint (hermitian) matrices.
* Those decompositions are also accessible via the following methods:
* - MatrixBase::llt()
* - MatrixBase::ldlt()
* - SelfAdjointView::llt()
* - SelfAdjointView::ldlt()
*
* \code
* #include <Eigen/Cholesky>
* \endcode
*/
#include "src/Cholesky/LLT.h"
#include "src/Cholesky/LDLT.h"
#ifdef EIGEN_USE_LAPACKE
#ifdef EIGEN_USE_MKL
#include "mkl_lapacke.h"
#else
#include "src/misc/lapacke.h"
#endif
#include "src/Cholesky/LLT_LAPACKE.h"
#endif
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_CHOLESKY_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/CholmodSupport
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_CHOLMODSUPPORT_MODULE_H
#define EIGEN_CHOLMODSUPPORT_MODULE_H
#include "SparseCore"
#include "src/Core/util/DisableStupidWarnings.h"
extern "C" {
#include <cholmod.h>
}
/** \ingroup Support_modules
* \defgroup CholmodSupport_Module CholmodSupport module
*
* This module provides an interface to the Cholmod library which is part of the <a href="http://www.suitesparse.com">suitesparse</a> package.
* It provides the two following main factorization classes:
* - class CholmodSupernodalLLT: a supernodal LLT Cholesky factorization.
* - class CholmodDecomposiiton: a general L(D)LT Cholesky factorization with automatic or explicit runtime selection of the underlying factorization method (supernodal or simplicial).
*
* For the sake of completeness, this module also propose the two following classes:
* - class CholmodSimplicialLLT
* - class CholmodSimplicialLDLT
* Note that these classes does not bring any particular advantage compared to the built-in
* SimplicialLLT and SimplicialLDLT factorization classes.
*
* \code
* #include <Eigen/CholmodSupport>
* \endcode
*
* In order to use this module, the cholmod headers must be accessible from the include paths, and your binary must be linked to the cholmod library and its dependencies.
* The dependencies depend on how cholmod has been compiled.
* For a cmake based project, you can use our FindCholmod.cmake module to help you in this task.
*
*/
#include "src/CholmodSupport/CholmodSupport.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_CHOLMODSUPPORT_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/Core
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2007-2011 Benoit Jacob <jacob.benoit.1@gmail.com>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_CORE_H
#define EIGEN_CORE_H
// first thing Eigen does: stop the compiler from reporting useless warnings.
#include "src/Core/util/DisableStupidWarnings.h"
// then include this file where all our macros are defined. It's really important to do it first because
// it's where we do all the compiler/OS/arch detections and define most defaults.
#include "src/Core/util/Macros.h"
// This detects SSE/AVX/NEON/etc. and configure alignment settings
#include "src/Core/util/ConfigureVectorization.h"
// We need cuda_runtime.h/hip_runtime.h to ensure that
// the EIGEN_USING_STD macro works properly on the device side
#if defined(EIGEN_CUDACC)
#include <cuda_runtime.h>
#elif defined(EIGEN_HIPCC)
#include <hip/hip_runtime.h>
#endif
#ifdef EIGEN_EXCEPTIONS
#include <new>
#endif
// Disable the ipa-cp-clone optimization flag with MinGW 6.x or newer (enabled by default with -O3)
// See http://eigen.tuxfamily.org/bz/show_bug.cgi?id=556 for details.
#if EIGEN_COMP_MINGW && EIGEN_GNUC_AT_LEAST(4,6) && EIGEN_GNUC_AT_MOST(5,5)
#pragma GCC optimize ("-fno-ipa-cp-clone")
#endif
// Prevent ICC from specializing std::complex operators that silently fail
// on device. This allows us to use our own device-compatible specializations
// instead.
#if defined(EIGEN_COMP_ICC) && defined(EIGEN_GPU_COMPILE_PHASE) \
&& !defined(_OVERRIDE_COMPLEX_SPECIALIZATION_)
#define _OVERRIDE_COMPLEX_SPECIALIZATION_ 1
#endif
#include <complex>
// this include file manages BLAS and MKL related macros
// and inclusion of their respective header files
#include "src/Core/util/MKL_support.h"
#if defined(EIGEN_HAS_CUDA_FP16) || defined(EIGEN_HAS_HIP_FP16)
#define EIGEN_HAS_GPU_FP16
#endif
#if defined(EIGEN_HAS_CUDA_BF16) || defined(EIGEN_HAS_HIP_BF16)
#define EIGEN_HAS_GPU_BF16
#endif
#if (defined _OPENMP) && (!defined EIGEN_DONT_PARALLELIZE)
#define EIGEN_HAS_OPENMP
#endif
#ifdef EIGEN_HAS_OPENMP
#include <omp.h>
#endif
// MSVC for windows mobile does not have the errno.h file
#if !(EIGEN_COMP_MSVC && EIGEN_OS_WINCE) && !EIGEN_COMP_ARM
#define EIGEN_HAS_ERRNO
#endif
#ifdef EIGEN_HAS_ERRNO
#include <cerrno>
#endif
#include <cstddef>
#include <cstdlib>
#include <cmath>
#include <cassert>
#include <functional>
#include <sstream>
#ifndef EIGEN_NO_IO
#include <iosfwd>
#endif
#include <cstring>
#include <string>
#include <limits>
#include <climits> // for CHAR_BIT
// for min/max:
#include <algorithm>
#if EIGEN_HAS_CXX11
#include <array>
#endif
// for std::is_nothrow_move_assignable
#ifdef EIGEN_INCLUDE_TYPE_TRAITS
#include <type_traits>
#endif
// for outputting debug info
#ifdef EIGEN_DEBUG_ASSIGN
#include <iostream>
#endif
// required for __cpuid, needs to be included after cmath
#if EIGEN_COMP_MSVC && EIGEN_ARCH_i386_OR_x86_64 && !EIGEN_OS_WINCE
#include <intrin.h>
#endif
#if defined(EIGEN_USE_SYCL)
#undef min
#undef max
#undef isnan
#undef isinf
#undef isfinite
#include <CL/sycl.hpp>
#include <map>
#include <memory>
#include <utility>
#include <thread>
#ifndef EIGEN_SYCL_LOCAL_THREAD_DIM0
#define EIGEN_SYCL_LOCAL_THREAD_DIM0 16
#endif
#ifndef EIGEN_SYCL_LOCAL_THREAD_DIM1
#define EIGEN_SYCL_LOCAL_THREAD_DIM1 16
#endif
#endif
#if defined EIGEN2_SUPPORT_STAGE40_FULL_EIGEN3_STRICTNESS || defined EIGEN2_SUPPORT_STAGE30_FULL_EIGEN3_API || defined EIGEN2_SUPPORT_STAGE20_RESOLVE_API_CONFLICTS || defined EIGEN2_SUPPORT_STAGE10_FULL_EIGEN2_API || defined EIGEN2_SUPPORT
// This will generate an error message:
#error Eigen2-support is only available up to version 3.2. Please go to "http://eigen.tuxfamily.org/index.php?title=Eigen2" for further information
#endif
namespace Eigen {
// we use size_t frequently and we'll never remember to prepend it with std:: every time just to
// ensure QNX/QCC support
using std::size_t;
// gcc 4.6.0 wants std:: for ptrdiff_t
using std::ptrdiff_t;
}
/** \defgroup Core_Module Core module
* This is the main module of Eigen providing dense matrix and vector support
* (both fixed and dynamic size) with all the features corresponding to a BLAS library
* and much more...
*
* \code
* #include <Eigen/Core>
* \endcode
*/
#include "src/Core/util/Constants.h"
#include "src/Core/util/Meta.h"
#include "src/Core/util/ForwardDeclarations.h"
#include "src/Core/util/StaticAssert.h"
#include "src/Core/util/XprHelper.h"
#include "src/Core/util/Memory.h"
#include "src/Core/util/IntegralConstant.h"
#include "src/Core/util/SymbolicIndex.h"
#include "src/Core/NumTraits.h"
#include "src/Core/MathFunctions.h"
#include "src/Core/GenericPacketMath.h"
#include "src/Core/MathFunctionsImpl.h"
#include "src/Core/arch/Default/ConjHelper.h"
// Generic half float support
#include "src/Core/arch/Default/Half.h"
#include "src/Core/arch/Default/BFloat16.h"
#include "src/Core/arch/Default/TypeCasting.h"
#include "src/Core/arch/Default/GenericPacketMathFunctionsFwd.h"
#if defined EIGEN_VECTORIZE_AVX512
#include "src/Core/arch/SSE/PacketMath.h"
#include "src/Core/arch/SSE/TypeCasting.h"
#include "src/Core/arch/SSE/Complex.h"
#include "src/Core/arch/AVX/PacketMath.h"
#include "src/Core/arch/AVX/TypeCasting.h"
#include "src/Core/arch/AVX/Complex.h"
#include "src/Core/arch/AVX512/PacketMath.h"
#include "src/Core/arch/AVX512/TypeCasting.h"
#include "src/Core/arch/AVX512/Complex.h"
#include "src/Core/arch/SSE/MathFunctions.h"
#include "src/Core/arch/AVX/MathFunctions.h"
#include "src/Core/arch/AVX512/MathFunctions.h"
#elif defined EIGEN_VECTORIZE_AVX
// Use AVX for floats and doubles, SSE for integers
#include "src/Core/arch/SSE/PacketMath.h"
#include "src/Core/arch/SSE/TypeCasting.h"
#include "src/Core/arch/SSE/Complex.h"
#include "src/Core/arch/AVX/PacketMath.h"
#include "src/Core/arch/AVX/TypeCasting.h"
#include "src/Core/arch/AVX/Complex.h"
#include "src/Core/arch/SSE/MathFunctions.h"
#include "src/Core/arch/AVX/MathFunctions.h"
#elif defined EIGEN_VECTORIZE_SSE
#include "src/Core/arch/SSE/PacketMath.h"
#include "src/Core/arch/SSE/TypeCasting.h"
#include "src/Core/arch/SSE/MathFunctions.h"
#include "src/Core/arch/SSE/Complex.h"
#elif defined(EIGEN_VECTORIZE_ALTIVEC) || defined(EIGEN_VECTORIZE_VSX)
#include "src/Core/arch/AltiVec/PacketMath.h"
#include "src/Core/arch/AltiVec/MathFunctions.h"
#include "src/Core/arch/AltiVec/Complex.h"
#elif defined EIGEN_VECTORIZE_NEON
#include "src/Core/arch/NEON/PacketMath.h"
#include "src/Core/arch/NEON/TypeCasting.h"
#include "src/Core/arch/NEON/MathFunctions.h"
#include "src/Core/arch/NEON/Complex.h"
#elif defined EIGEN_VECTORIZE_SVE
#include "src/Core/arch/SVE/PacketMath.h"
#include "src/Core/arch/SVE/TypeCasting.h"
#include "src/Core/arch/SVE/MathFunctions.h"
#elif defined EIGEN_VECTORIZE_ZVECTOR
#include "src/Core/arch/ZVector/PacketMath.h"
#include "src/Core/arch/ZVector/MathFunctions.h"
#include "src/Core/arch/ZVector/Complex.h"
#elif defined EIGEN_VECTORIZE_MSA
#include "src/Core/arch/MSA/PacketMath.h"
#include "src/Core/arch/MSA/MathFunctions.h"
#include "src/Core/arch/MSA/Complex.h"
#endif
#if defined EIGEN_VECTORIZE_GPU
#include "src/Core/arch/GPU/PacketMath.h"
#include "src/Core/arch/GPU/MathFunctions.h"
#include "src/Core/arch/GPU/TypeCasting.h"
#endif
#if defined(EIGEN_USE_SYCL)
#include "src/Core/arch/SYCL/SyclMemoryModel.h"
#include "src/Core/arch/SYCL/InteropHeaders.h"
#if !defined(EIGEN_DONT_VECTORIZE_SYCL)
#include "src/Core/arch/SYCL/PacketMath.h"
#include "src/Core/arch/SYCL/MathFunctions.h"
#include "src/Core/arch/SYCL/TypeCasting.h"
#endif
#endif
#include "src/Core/arch/Default/Settings.h"
// This file provides generic implementations valid for scalar as well
#include "src/Core/arch/Default/GenericPacketMathFunctions.h"
#include "src/Core/functors/TernaryFunctors.h"
#include "src/Core/functors/BinaryFunctors.h"
#include "src/Core/functors/UnaryFunctors.h"
#include "src/Core/functors/NullaryFunctors.h"
#include "src/Core/functors/StlFunctors.h"
#include "src/Core/functors/AssignmentFunctors.h"
// Specialized functors to enable the processing of complex numbers
// on CUDA devices
#ifdef EIGEN_CUDACC
#include "src/Core/arch/CUDA/Complex.h"
#endif
#include "src/Core/util/IndexedViewHelper.h"
#include "src/Core/util/ReshapedHelper.h"
#include "src/Core/ArithmeticSequence.h"
#ifndef EIGEN_NO_IO
#include "src/Core/IO.h"
#endif
#include "src/Core/DenseCoeffsBase.h"
#include "src/Core/DenseBase.h"
#include "src/Core/MatrixBase.h"
#include "src/Core/EigenBase.h"
#include "src/Core/Product.h"
#include "src/Core/CoreEvaluators.h"
#include "src/Core/AssignEvaluator.h"
#ifndef EIGEN_PARSED_BY_DOXYGEN // work around Doxygen bug triggered by Assign.h r814874
// at least confirmed with Doxygen 1.5.5 and 1.5.6
#include "src/Core/Assign.h"
#endif
#include "src/Core/ArrayBase.h"
#include "src/Core/util/BlasUtil.h"
#include "src/Core/DenseStorage.h"
#include "src/Core/NestByValue.h"
// #include "src/Core/ForceAlignedAccess.h"
#include "src/Core/ReturnByValue.h"
#include "src/Core/NoAlias.h"
#include "src/Core/PlainObjectBase.h"
#include "src/Core/Matrix.h"
#include "src/Core/Array.h"
#include "src/Core/CwiseTernaryOp.h"
#include "src/Core/CwiseBinaryOp.h"
#include "src/Core/CwiseUnaryOp.h"
#include "src/Core/CwiseNullaryOp.h"
#include "src/Core/CwiseUnaryView.h"
#include "src/Core/SelfCwiseBinaryOp.h"
#include "src/Core/Dot.h"
#include "src/Core/StableNorm.h"
#include "src/Core/Stride.h"
#include "src/Core/MapBase.h"
#include "src/Core/Map.h"
#include "src/Core/Ref.h"
#include "src/Core/Block.h"
#include "src/Core/VectorBlock.h"
#include "src/Core/IndexedView.h"
#include "src/Core/Reshaped.h"
#include "src/Core/Transpose.h"
#include "src/Core/DiagonalMatrix.h"
#include "src/Core/Diagonal.h"
#include "src/Core/DiagonalProduct.h"
#include "src/Core/Redux.h"
#include "src/Core/Visitor.h"
#include "src/Core/Fuzzy.h"
#include "src/Core/Swap.h"
#include "src/Core/CommaInitializer.h"
#include "src/Core/GeneralProduct.h"
#include "src/Core/Solve.h"
#include "src/Core/Inverse.h"
#include "src/Core/SolverBase.h"
#include "src/Core/PermutationMatrix.h"
#include "src/Core/Transpositions.h"
#include "src/Core/TriangularMatrix.h"
#include "src/Core/SelfAdjointView.h"
#include "src/Core/products/GeneralBlockPanelKernel.h"
#include "src/Core/products/Parallelizer.h"
#include "src/Core/ProductEvaluators.h"
#include "src/Core/products/GeneralMatrixVector.h"
#include "src/Core/products/GeneralMatrixMatrix.h"
#include "src/Core/SolveTriangular.h"
#include "src/Core/products/GeneralMatrixMatrixTriangular.h"
#include "src/Core/products/SelfadjointMatrixVector.h"
#include "src/Core/products/SelfadjointMatrixMatrix.h"
#include "src/Core/products/SelfadjointProduct.h"
#include "src/Core/products/SelfadjointRank2Update.h"
#include "src/Core/products/TriangularMatrixVector.h"
#include "src/Core/products/TriangularMatrixMatrix.h"
#include "src/Core/products/TriangularSolverMatrix.h"
#include "src/Core/products/TriangularSolverVector.h"
#include "src/Core/BandMatrix.h"
#include "src/Core/CoreIterators.h"
#include "src/Core/ConditionEstimator.h"
#if defined(EIGEN_VECTORIZE_ALTIVEC) || defined(EIGEN_VECTORIZE_VSX)
#include "src/Core/arch/AltiVec/MatrixProduct.h"
#elif defined EIGEN_VECTORIZE_NEON
#include "src/Core/arch/NEON/GeneralBlockPanelKernel.h"
#endif
#include "src/Core/BooleanRedux.h"
#include "src/Core/Select.h"
#include "src/Core/VectorwiseOp.h"
#include "src/Core/PartialReduxEvaluator.h"
#include "src/Core/Random.h"
#include "src/Core/Replicate.h"
#include "src/Core/Reverse.h"
#include "src/Core/ArrayWrapper.h"
#include "src/Core/StlIterators.h"
#ifdef EIGEN_USE_BLAS
#include "src/Core/products/GeneralMatrixMatrix_BLAS.h"
#include "src/Core/products/GeneralMatrixVector_BLAS.h"
#include "src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h"
#include "src/Core/products/SelfadjointMatrixMatrix_BLAS.h"
#include "src/Core/products/SelfadjointMatrixVector_BLAS.h"
#include "src/Core/products/TriangularMatrixMatrix_BLAS.h"
#include "src/Core/products/TriangularMatrixVector_BLAS.h"
#include "src/Core/products/TriangularSolverMatrix_BLAS.h"
#endif // EIGEN_USE_BLAS
#ifdef EIGEN_USE_MKL_VML
#include "src/Core/Assign_MKL.h"
#endif
#include "src/Core/GlobalFunctions.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_CORE_H
================================================
FILE: Obfuscation/include/Eigen/Dense
================================================
#include "Core"
#include "LU"
#include "Cholesky"
#include "QR"
#include "SVD"
#include "Geometry"
#include "Eigenvalues"
================================================
FILE: Obfuscation/include/Eigen/Eigen
================================================
#include "Dense"
#include "Sparse"
================================================
FILE: Obfuscation/include/Eigen/Eigenvalues
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_EIGENVALUES_MODULE_H
#define EIGEN_EIGENVALUES_MODULE_H
#include "Core"
#include "Cholesky"
#include "Jacobi"
#include "Householder"
#include "LU"
#include "Geometry"
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup Eigenvalues_Module Eigenvalues module
*
*
*
* This module mainly provides various eigenvalue solvers.
* This module also provides some MatrixBase methods, including:
* - MatrixBase::eigenvalues(),
* - MatrixBase::operatorNorm()
*
* \code
* #include <Eigen/Eigenvalues>
* \endcode
*/
#include "src/misc/RealSvd2x2.h"
#include "src/Eigenvalues/Tridiagonalization.h"
#include "src/Eigenvalues/RealSchur.h"
#include "src/Eigenvalues/EigenSolver.h"
#include "src/Eigenvalues/SelfAdjointEigenSolver.h"
#include "src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h"
#include "src/Eigenvalues/HessenbergDecomposition.h"
#include "src/Eigenvalues/ComplexSchur.h"
#include "src/Eigenvalues/ComplexEigenSolver.h"
#include "src/Eigenvalues/RealQZ.h"
#include "src/Eigenvalues/GeneralizedEigenSolver.h"
#include "src/Eigenvalues/MatrixBaseEigenvalues.h"
#ifdef EIGEN_USE_LAPACKE
#ifdef EIGEN_USE_MKL
#include "mkl_lapacke.h"
#else
#include "src/misc/lapacke.h"
#endif
#include "src/Eigenvalues/RealSchur_LAPACKE.h"
#include "src/Eigenvalues/ComplexSchur_LAPACKE.h"
#include "src/Eigenvalues/SelfAdjointEigenSolver_LAPACKE.h"
#endif
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_EIGENVALUES_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/Geometry
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_GEOMETRY_MODULE_H
#define EIGEN_GEOMETRY_MODULE_H
#include "Core"
#include "SVD"
#include "LU"
#include <limits>
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup Geometry_Module Geometry module
*
* This module provides support for:
* - fixed-size homogeneous transformations
* - translation, scaling, 2D and 3D rotations
* - \link Quaternion quaternions \endlink
* - cross products (\ref MatrixBase::cross, \ref MatrixBase::cross3)
* - orthognal 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
* - \link umeyama least-square transformation fitting \endlink
*
* \code
* #include <Eigen/Geometry>
* \endcode
*/
#include "src/Geometry/OrthoMethods.h"
#include "src/Geometry/EulerAngles.h"
#include "src/Geometry/Homogeneous.h"
#include "src/Geometry/RotationBase.h"
#include "src/Geometry/Rotation2D.h"
#include "src/Geometry/Quaternion.h"
#include "src/Geometry/AngleAxis.h"
#include "src/Geometry/Transform.h"
#include "src/Geometry/Translation.h"
#include "src/Geometry/Scaling.h"
#include "src/Geometry/Hyperplane.h"
#include "src/Geometry/ParametrizedLine.h"
#include "src/Geometry/AlignedBox.h"
#include "src/Geometry/Umeyama.h"
// Use the SSE optimized version whenever possible.
#if (defined EIGEN_VECTORIZE_SSE) || (defined EIGEN_VECTORIZE_NEON)
#include "src/Geometry/arch/Geometry_SIMD.h"
#endif
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_GEOMETRY_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/Householder
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_HOUSEHOLDER_MODULE_H
#define EIGEN_HOUSEHOLDER_MODULE_H
#include "Core"
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup Householder_Module Householder module
* This module provides Householder transformations.
*
* \code
* #include <Eigen/Householder>
* \endcode
*/
#include "src/Householder/Householder.h"
#include "src/Householder/HouseholderSequence.h"
#include "src/Householder/BlockHouseholder.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_HOUSEHOLDER_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/IterativeLinearSolvers
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
#define EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
#include "SparseCore"
#include "OrderingMethods"
#include "src/Core/util/DisableStupidWarnings.h"
/**
* \defgroup IterativeLinearSolvers_Module IterativeLinearSolvers module
*
* This module currently provides iterative methods to solve problems of the form \c A \c x = \c b, where \c A is a squared matrix, usually very large and sparse.
* Those solvers are accessible via the following classes:
* - ConjugateGradient for selfadjoint (hermitian) matrices,
* - LeastSquaresConjugateGradient for rectangular least-square problems,
* - BiCGSTAB for general square matrices.
*
* These iterative solvers are associated with some preconditioners:
* - IdentityPreconditioner - not really useful
* - DiagonalPreconditioner - also called Jacobi preconditioner, work very well on diagonal dominant matrices.
* - IncompleteLUT - incomplete LU factorization with dual thresholding
*
* Such problems can also be solved using the direct sparse decomposition modules: SparseCholesky, CholmodSupport, UmfPackSupport, SuperLUSupport.
*
\code
#include <Eigen/IterativeLinearSolvers>
\endcode
*/
#include "src/IterativeLinearSolvers/SolveWithGuess.h"
#include "src/IterativeLinearSolvers/IterativeSolverBase.h"
#include "src/IterativeLinearSolvers/BasicPreconditioners.h"
#include "src/IterativeLinearSolvers/ConjugateGradient.h"
#include "src/IterativeLinearSolvers/LeastSquareConjugateGradient.h"
#include "src/IterativeLinearSolvers/BiCGSTAB.h"
#include "src/IterativeLinearSolvers/IncompleteLUT.h"
#include "src/IterativeLinearSolvers/IncompleteCholesky.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_ITERATIVELINEARSOLVERS_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/Jacobi
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_JACOBI_MODULE_H
#define EIGEN_JACOBI_MODULE_H
#include "Core"
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup Jacobi_Module Jacobi module
* This module provides Jacobi and Givens rotations.
*
* \code
* #include <Eigen/Jacobi>
* \endcode
*
* In addition to listed classes, it defines the two following MatrixBase methods to apply a Jacobi or Givens rotation:
* - MatrixBase::applyOnTheLeft()
* - MatrixBase::applyOnTheRight().
*/
#include "src/Jacobi/Jacobi.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_JACOBI_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/KLUSupport
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_KLUSUPPORT_MODULE_H
#define EIGEN_KLUSUPPORT_MODULE_H
#include <Eigen/SparseCore>
#include <Eigen/src/Core/util/DisableStupidWarnings.h>
extern "C" {
#include <btf.h>
#include <klu.h>
}
/** \ingroup Support_modules
* \defgroup KLUSupport_Module KLUSupport module
*
* This module provides an interface to the KLU library which is part of the <a href="http://www.suitesparse.com">suitesparse</a> package.
* It provides the following factorization class:
* - class KLU: a sparse LU factorization, well-suited for circuit simulation.
*
* \code
* #include <Eigen/KLUSupport>
* \endcode
*
* In order to use this module, the klu and btf headers must be accessible from the include paths, and your binary must be linked to the klu library and its dependencies.
* The dependencies depend on how umfpack has been compiled.
* For a cmake based project, you can use our FindKLU.cmake module to help you in this task.
*
*/
#include "src/KLUSupport/KLUSupport.h"
#include <Eigen/src/Core/util/ReenableStupidWarnings.h>
#endif // EIGEN_KLUSUPPORT_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/LU
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_LU_MODULE_H
#define EIGEN_LU_MODULE_H
#include "Core"
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup LU_Module LU module
* This module includes %LU decomposition and related notions such as matrix inversion and determinant.
* This module defines the following MatrixBase methods:
* - MatrixBase::inverse()
* - MatrixBase::determinant()
*
* \code
* #include <Eigen/LU>
* \endcode
*/
#include "src/misc/Kernel.h"
#include "src/misc/Image.h"
#include "src/LU/FullPivLU.h"
#include "src/LU/PartialPivLU.h"
#ifdef EIGEN_USE_LAPACKE
#ifdef EIGEN_USE_MKL
#include "mkl_lapacke.h"
#else
#include "src/misc/lapacke.h"
#endif
#include "src/LU/PartialPivLU_LAPACKE.h"
#endif
#include "src/LU/Determinant.h"
#include "src/LU/InverseImpl.h"
#if defined EIGEN_VECTORIZE_SSE || defined EIGEN_VECTORIZE_NEON
#include "src/LU/arch/InverseSize4.h"
#endif
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_LU_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/MetisSupport
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_METISSUPPORT_MODULE_H
#define EIGEN_METISSUPPORT_MODULE_H
#include "SparseCore"
#include "src/Core/util/DisableStupidWarnings.h"
extern "C" {
#include <metis.h>
}
/** \ingroup Support_modules
* \defgroup MetisSupport_Module MetisSupport module
*
* \code
* #include <Eigen/MetisSupport>
* \endcode
* This module defines an interface to the METIS reordering package (http://glaros.dtc.umn.edu/gkhome/views/metis).
* It can be used just as any other built-in method as explained in \link OrderingMethods_Module here. \endlink
*/
#include "src/MetisSupport/MetisSupport.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_METISSUPPORT_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/OrderingMethods
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_ORDERINGMETHODS_MODULE_H
#define EIGEN_ORDERINGMETHODS_MODULE_H
#include "SparseCore"
#include "src/Core/util/DisableStupidWarnings.h"
/**
* \defgroup OrderingMethods_Module OrderingMethods module
*
* This module is currently for internal use only
*
* It defines various built-in and external ordering methods for sparse matrices.
* They are typically used to reduce the number of elements during
* the sparse matrix decomposition (LLT, LU, QR).
* Precisely, in a preprocessing step, a permutation matrix P is computed using
* those ordering methods and applied to the columns of the matrix.
* Using for instance the sparse Cholesky decomposition, it is expected that
* the nonzeros elements in LLT(A*P) will be much smaller than that in LLT(A).
*
*
* Usage :
* \code
* #include <Eigen/OrderingMethods>
* \endcode
*
* A simple usage is as a template parameter in the sparse decomposition classes :
*
* \code
* SparseLU<MatrixType, COLAMDOrdering<int> > solver;
* \endcode
*
* \code
* SparseQR<MatrixType, COLAMDOrdering<int> > solver;
* \endcode
*
* It is possible as well to call directly a particular ordering method for your own purpose,
* \code
* AMDOrdering<int> ordering;
* PermutationMatrix<Dynamic, Dynamic, int> perm;
* SparseMatrix<double> A;
* //Fill the matrix ...
*
* ordering(A, perm); // Call AMD
* \endcode
*
* \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
* by calling the method with a SelfAdjointView type.
*
* \code
* // Call the ordering on the pattern of the lower triangular matrix A
* ordering(A.selfadjointView<Lower>(), perm);
* \endcode
*/
#include "src/OrderingMethods/Amd.h"
#include "src/OrderingMethods/Ordering.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_ORDERINGMETHODS_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/PaStiXSupport
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_PASTIXSUPPORT_MODULE_H
#define EIGEN_PASTIXSUPPORT_MODULE_H
#include "SparseCore"
#include "src/Core/util/DisableStupidWarnings.h"
extern "C" {
#include <pastix_nompi.h>
#include <pastix.h>
}
#ifdef complex
#undef complex
#endif
/** \ingroup Support_modules
* \defgroup PaStiXSupport_Module PaStiXSupport module
*
* This module provides an interface to the <a href="http://pastix.gforge.inria.fr/">PaSTiX</a> library.
* PaSTiX is a general \b supernodal, \b parallel and \b opensource sparse solver.
* It provides the two following main factorization classes:
* - class PastixLLT : a supernodal, parallel LLt Cholesky factorization.
* - class PastixLDLT: a supernodal, parallel LDLt Cholesky factorization.
* - class PastixLU : a supernodal, parallel LU factorization (optimized for a symmetric pattern).
*
* \code
* #include <Eigen/PaStiXSupport>
* \endcode
*
* In order to use this module, the PaSTiX headers must be accessible from the include paths, and your binary must be linked to the PaSTiX library and its dependencies.
* This wrapper resuires PaStiX version 5.x compiled without MPI support.
* The dependencies depend on how PaSTiX has been compiled.
* For a cmake based project, you can use our FindPaSTiX.cmake module to help you in this task.
*
*/
#include "src/PaStiXSupport/PaStiXSupport.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_PASTIXSUPPORT_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/PardisoSupport
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_PARDISOSUPPORT_MODULE_H
#define EIGEN_PARDISOSUPPORT_MODULE_H
#include "SparseCore"
#include "src/Core/util/DisableStupidWarnings.h"
#include <mkl_pardiso.h>
/** \ingroup Support_modules
* \defgroup PardisoSupport_Module PardisoSupport module
*
* This module brings support for the Intel(R) MKL PARDISO direct sparse solvers.
*
* \code
* #include <Eigen/PardisoSupport>
* \endcode
*
* In order to use this module, the MKL headers must be accessible from the include paths, and your binary must be linked to the MKL library and its dependencies.
* See this \ref TopicUsingIntelMKL "page" for more information on MKL-Eigen integration.
*
*/
#include "src/PardisoSupport/PardisoSupport.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_PARDISOSUPPORT_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/QR
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_QR_MODULE_H
#define EIGEN_QR_MODULE_H
#include "Core"
#include "Cholesky"
#include "Jacobi"
#include "Householder"
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup QR_Module QR module
*
*
*
* This module provides various QR decompositions
* This module also provides some MatrixBase methods, including:
* - MatrixBase::householderQr()
* - MatrixBase::colPivHouseholderQr()
* - MatrixBase::fullPivHouseholderQr()
*
* \code
* #include <Eigen/QR>
* \endcode
*/
#include "src/QR/HouseholderQR.h"
#include "src/QR/FullPivHouseholderQR.h"
#include "src/QR/ColPivHouseholderQR.h"
#include "src/QR/CompleteOrthogonalDecomposition.h"
#ifdef EIGEN_USE_LAPACKE
#ifdef EIGEN_USE_MKL
#include "mkl_lapacke.h"
#else
#include "src/misc/lapacke.h"
#endif
#include "src/QR/HouseholderQR_LAPACKE.h"
#include "src/QR/ColPivHouseholderQR_LAPACKE.h"
#endif
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_QR_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/QtAlignedMalloc
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_QTMALLOC_MODULE_H
#define EIGEN_QTMALLOC_MODULE_H
#include "Core"
#if (!EIGEN_MALLOC_ALREADY_ALIGNED)
#include "src/Core/util/DisableStupidWarnings.h"
void *qMalloc(std::size_t size)
{
return Eigen::internal::aligned_malloc(size);
}
void qFree(void *ptr)
{
Eigen::internal::aligned_free(ptr);
}
void *qRealloc(void *ptr, std::size_t size)
{
void* newPtr = Eigen::internal::aligned_malloc(size);
std::memcpy(newPtr, ptr, size);
Eigen::internal::aligned_free(ptr);
return newPtr;
}
#include "src/Core/util/ReenableStupidWarnings.h"
#endif
#endif // EIGEN_QTMALLOC_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/SPQRSupport
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_SPQRSUPPORT_MODULE_H
#define EIGEN_SPQRSUPPORT_MODULE_H
#include "SparseCore"
#include "src/Core/util/DisableStupidWarnings.h"
#include "SuiteSparseQR.hpp"
/** \ingroup Support_modules
* \defgroup SPQRSupport_Module SuiteSparseQR module
*
* This module provides an interface to the SPQR library, which is part of the <a href="http://www.suitesparse.com">suitesparse</a> package.
*
* \code
* #include <Eigen/SPQRSupport>
* \endcode
*
* In order to use this module, the SPQR headers must be accessible from the include paths, and your binary must be linked to the SPQR library and its dependencies (Cholmod, AMD, COLAMD,...).
* For a cmake based project, you can use our FindSPQR.cmake and FindCholmod.Cmake modules
*
*/
#include "src/CholmodSupport/CholmodSupport.h"
#include "src/SPQRSupport/SuiteSparseQRSupport.h"
#endif
================================================
FILE: Obfuscation/include/Eigen/SVD
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_SVD_MODULE_H
#define EIGEN_SVD_MODULE_H
#include "QR"
#include "Householder"
#include "Jacobi"
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup SVD_Module SVD module
*
*
*
* This module provides SVD decomposition for matrices (both real and complex).
* Two decomposition algorithms are provided:
* - JacobiSVD implementing two-sided Jacobi iterations is numerically very accurate, fast for small matrices, but very slow for larger ones.
* - BDCSVD implementing a recursive divide & conquer strategy on top of an upper-bidiagonalization which remains fast for large problems.
* These decompositions are accessible via the respective classes and following MatrixBase methods:
* - MatrixBase::jacobiSvd()
* - MatrixBase::bdcSvd()
*
* \code
* #include <Eigen/SVD>
* \endcode
*/
#include "src/misc/RealSvd2x2.h"
#include "src/SVD/UpperBidiagonalization.h"
#include "src/SVD/SVDBase.h"
#include "src/SVD/JacobiSVD.h"
#include "src/SVD/BDCSVD.h"
#if defined(EIGEN_USE_LAPACKE) && !defined(EIGEN_USE_LAPACKE_STRICT)
#ifdef EIGEN_USE_MKL
#include "mkl_lapacke.h"
#else
#include "src/misc/lapacke.h"
#endif
#include "src/SVD/JacobiSVD_LAPACKE.h"
#endif
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_SVD_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/Sparse
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_SPARSE_MODULE_H
#define EIGEN_SPARSE_MODULE_H
/** \defgroup Sparse_Module Sparse meta-module
*
* Meta-module including all related modules:
* - \ref SparseCore_Module
* - \ref OrderingMethods_Module
* - \ref SparseCholesky_Module
* - \ref SparseLU_Module
* - \ref SparseQR_Module
* - \ref IterativeLinearSolvers_Module
*
\code
#include <Eigen/Sparse>
\endcode
*/
#include "SparseCore"
#include "OrderingMethods"
#include "SparseCholesky"
#include "SparseLU"
#include "SparseQR"
#include "IterativeLinearSolvers"
#endif // EIGEN_SPARSE_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/SparseCholesky
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008-2013 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_SPARSECHOLESKY_MODULE_H
#define EIGEN_SPARSECHOLESKY_MODULE_H
#include "SparseCore"
#include "OrderingMethods"
#include "src/Core/util/DisableStupidWarnings.h"
/**
* \defgroup SparseCholesky_Module SparseCholesky module
*
* This module currently provides two variants of the direct sparse Cholesky decomposition for selfadjoint (hermitian) matrices.
* Those decompositions are accessible via the following classes:
* - SimplicialLLt,
* - SimplicialLDLt
*
* Such problems can also be solved using the ConjugateGradient solver from the IterativeLinearSolvers module.
*
* \code
* #include <Eigen/SparseCholesky>
* \endcode
*/
#include "src/SparseCholesky/SimplicialCholesky.h"
#include "src/SparseCholesky/SimplicialCholesky_impl.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_SPARSECHOLESKY_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/SparseCore
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_SPARSECORE_MODULE_H
#define EIGEN_SPARSECORE_MODULE_H
#include "Core"
#include "src/Core/util/DisableStupidWarnings.h"
#include <vector>
#include <map>
#include <cstdlib>
#include <cstring>
#include <algorithm>
/**
* \defgroup SparseCore_Module SparseCore module
*
* This module provides a sparse matrix representation, and basic associated matrix manipulations
* and operations.
*
* See the \ref TutorialSparse "Sparse tutorial"
*
* \code
* #include <Eigen/SparseCore>
* \endcode
*
* This module depends on: Core.
*/
#include "src/SparseCore/SparseUtil.h"
#include "src/SparseCore/SparseMatrixBase.h"
#include "src/SparseCore/SparseAssign.h"
#include "src/SparseCore/CompressedStorage.h"
#include "src/SparseCore/AmbiVector.h"
#include "src/SparseCore/SparseCompressedBase.h"
#include "src/SparseCore/SparseMatrix.h"
#include "src/SparseCore/SparseMap.h"
#include "src/SparseCore/MappedSparseMatrix.h"
#include "src/SparseCore/SparseVector.h"
#include "src/SparseCore/SparseRef.h"
#include "src/SparseCore/SparseCwiseUnaryOp.h"
#include "src/SparseCore/SparseCwiseBinaryOp.h"
#include "src/SparseCore/SparseTranspose.h"
#include "src/SparseCore/SparseBlock.h"
#include "src/SparseCore/SparseDot.h"
#include "src/SparseCore/SparseRedux.h"
#include "src/SparseCore/SparseView.h"
#include "src/SparseCore/SparseDiagonalProduct.h"
#include "src/SparseCore/ConservativeSparseSparseProduct.h"
#include "src/SparseCore/SparseSparseProductWithPruning.h"
#include "src/SparseCore/SparseProduct.h"
#include "src/SparseCore/SparseDenseProduct.h"
#include "src/SparseCore/SparseSelfAdjointView.h"
#include "src/SparseCore/SparseTriangularView.h"
#include "src/SparseCore/TriangularSolver.h"
#include "src/SparseCore/SparsePermutation.h"
#include "src/SparseCore/SparseFuzzy.h"
#include "src/SparseCore/SparseSolverBase.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_SPARSECORE_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/SparseLU
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
// Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_SPARSELU_MODULE_H
#define EIGEN_SPARSELU_MODULE_H
#include "SparseCore"
/**
* \defgroup SparseLU_Module SparseLU module
* This module defines a supernodal factorization of general sparse matrices.
* The code is fully optimized for supernode-panel updates with specialized kernels.
* Please, see the documentation of the SparseLU class for more details.
*/
// Ordering interface
#include "OrderingMethods"
#include "src/Core/util/DisableStupidWarnings.h"
#include "src/SparseLU/SparseLU_gemm_kernel.h"
#include "src/SparseLU/SparseLU_Structs.h"
#include "src/SparseLU/SparseLU_SupernodalMatrix.h"
#include "src/SparseLU/SparseLUImpl.h"
#include "src/SparseCore/SparseColEtree.h"
#include "src/SparseLU/SparseLU_Memory.h"
#include "src/SparseLU/SparseLU_heap_relax_snode.h"
#include "src/SparseLU/SparseLU_relax_snode.h"
#include "src/SparseLU/SparseLU_pivotL.h"
#include "src/SparseLU/SparseLU_panel_dfs.h"
#include "src/SparseLU/SparseLU_kernel_bmod.h"
#include "src/SparseLU/SparseLU_panel_bmod.h"
#include "src/SparseLU/SparseLU_column_dfs.h"
#include "src/SparseLU/SparseLU_column_bmod.h"
#include "src/SparseLU/SparseLU_copy_to_ucol.h"
#include "src/SparseLU/SparseLU_pruneL.h"
#include "src/SparseLU/SparseLU_Utils.h"
#include "src/SparseLU/SparseLU.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_SPARSELU_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/SparseQR
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_SPARSEQR_MODULE_H
#define EIGEN_SPARSEQR_MODULE_H
#include "SparseCore"
#include "OrderingMethods"
#include "src/Core/util/DisableStupidWarnings.h"
/** \defgroup SparseQR_Module SparseQR module
* \brief Provides QR decomposition for sparse matrices
*
* This module provides a simplicial version of the left-looking Sparse QR decomposition.
* The columns of the input matrix should be reordered to limit the fill-in during the
* decomposition. Built-in methods (COLAMD, AMD) or external methods (METIS) can be used to this end.
* See the \link OrderingMethods_Module OrderingMethods\endlink module for the list
* of built-in and external ordering methods.
*
* \code
* #include <Eigen/SparseQR>
* \endcode
*
*
*/
#include "src/SparseCore/SparseColEtree.h"
#include "src/SparseQR/SparseQR.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif
================================================
FILE: Obfuscation/include/Eigen/StdDeque
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_STDDEQUE_MODULE_H
#define EIGEN_STDDEQUE_MODULE_H
#include "Core"
#include <deque>
#if EIGEN_COMP_MSVC && EIGEN_OS_WIN64 && (EIGEN_MAX_STATIC_ALIGN_BYTES<=16) /* MSVC auto aligns up to 16 bytes in 64 bit builds */
#define EIGEN_DEFINE_STL_DEQUE_SPECIALIZATION(...)
#else
#include "src/StlSupport/StdDeque.h"
#endif
#endif // EIGEN_STDDEQUE_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/StdList
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_STDLIST_MODULE_H
#define EIGEN_STDLIST_MODULE_H
#include "Core"
#include <list>
#if EIGEN_COMP_MSVC && EIGEN_OS_WIN64 && (EIGEN_MAX_STATIC_ALIGN_BYTES<=16) /* MSVC auto aligns up to 16 bytes in 64 bit builds */
#define EIGEN_DEFINE_STL_LIST_SPECIALIZATION(...)
#else
#include "src/StlSupport/StdList.h"
#endif
#endif // EIGEN_STDLIST_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/StdVector
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_STDVECTOR_MODULE_H
#define EIGEN_STDVECTOR_MODULE_H
#include "Core"
#include <vector>
#if EIGEN_COMP_MSVC && EIGEN_OS_WIN64 && (EIGEN_MAX_STATIC_ALIGN_BYTES<=16) /* MSVC auto aligns up to 16 bytes in 64 bit builds */
#define EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION(...)
#else
#include "src/StlSupport/StdVector.h"
#endif
#endif // EIGEN_STDVECTOR_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/SuperLUSupport
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_SUPERLUSUPPORT_MODULE_H
#define EIGEN_SUPERLUSUPPORT_MODULE_H
#include "SparseCore"
#include "src/Core/util/DisableStupidWarnings.h"
#ifdef EMPTY
#define EIGEN_EMPTY_WAS_ALREADY_DEFINED
#endif
typedef int int_t;
#include <slu_Cnames.h>
#include <supermatrix.h>
#include <slu_util.h>
// slu_util.h defines a preprocessor token named EMPTY which is really polluting,
// so we remove it in favor of a SUPERLU_EMPTY token.
// If EMPTY was already defined then we don't undef it.
#if defined(EIGEN_EMPTY_WAS_ALREADY_DEFINED)
# undef EIGEN_EMPTY_WAS_ALREADY_DEFINED
#elif defined(EMPTY)
# undef EMPTY
#endif
#define SUPERLU_EMPTY (-1)
namespace Eigen { struct SluMatrix; }
/** \ingroup Support_modules
* \defgroup SuperLUSupport_Module SuperLUSupport module
*
* This module provides an interface to the <a href="http://crd-legacy.lbl.gov/~xiaoye/SuperLU/">SuperLU</a> library.
* It provides the following factorization class:
* - class SuperLU: a supernodal sequential LU factorization.
* - class SuperILU: a supernodal sequential incomplete LU factorization (to be used as a preconditioner for iterative methods).
*
* \warning This wrapper requires at least versions 4.0 of SuperLU. The 3.x versions are not supported.
*
* \warning When including this module, you have to use SUPERLU_EMPTY instead of EMPTY which is no longer defined because it is too polluting.
*
* \code
* #include <Eigen/SuperLUSupport>
* \endcode
*
* In order to use this module, the superlu headers must be accessible from the include paths, and your binary must be linked to the superlu library and its dependencies.
* The dependencies depend on how superlu has been compiled.
* For a cmake based project, you can use our FindSuperLU.cmake module to help you in this task.
*
*/
#include "src/SuperLUSupport/SuperLUSupport.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_SUPERLUSUPPORT_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/UmfPackSupport
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_UMFPACKSUPPORT_MODULE_H
#define EIGEN_UMFPACKSUPPORT_MODULE_H
#include "SparseCore"
#include "src/Core/util/DisableStupidWarnings.h"
extern "C" {
#include <umfpack.h>
}
/** \ingroup Support_modules
* \defgroup UmfPackSupport_Module UmfPackSupport module
*
* This module provides an interface to the UmfPack library which is part of the <a href="http://www.suitesparse.com">suitesparse</a> package.
* It provides the following factorization class:
* - class UmfPackLU: a multifrontal sequential LU factorization.
*
* \code
* #include <Eigen/UmfPackSupport>
* \endcode
*
* In order to use this module, the umfpack headers must be accessible from the include paths, and your binary must be linked to the umfpack library and its dependencies.
* The dependencies depend on how umfpack has been compiled.
* For a cmake based project, you can use our FindUmfPack.cmake module to help you in this task.
*
*/
#include "src/UmfPackSupport/UmfPackSupport.h"
#include "src/Core/util/ReenableStupidWarnings.h"
#endif // EIGEN_UMFPACKSUPPORT_MODULE_H
================================================
FILE: Obfuscation/include/Eigen/src/Cholesky/LDLT.h
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2009 Keir Mierle <mierle@gmail.com>
// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
// Copyright (C) 2011 Timothy E. Holy <tim.holy@gmail.com >
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_LDLT_H
#define EIGEN_LDLT_H
namespace Eigen {
namespace internal {
template<typename _MatrixType, int _UpLo> struct traits<LDLT<_MatrixType, _UpLo> >
: traits<_MatrixType>
{
typedef MatrixXpr XprKind;
typedef SolverStorage StorageKind;
typedef int StorageIndex;
enum { Flags = 0 };
};
template<typename MatrixType, int UpLo> struct LDLT_Traits;
// PositiveSemiDef means positive semi-definite and non-zero; same for NegativeSemiDef
enum SignMatrix { PositiveSemiDef, NegativeSemiDef, ZeroSign, Indefinite };
}
/** \ingroup Cholesky_Module
*
* \class LDLT
*
* \brief Robust Cholesky decomposition of a matrix with pivoting
*
* \tparam _MatrixType the type of the matrix of which to compute the LDL^T Cholesky decomposition
* \tparam _UpLo the triangular part that will be used for the decompositon: Lower (default) or Upper.
* The other triangular part won't be read.
*
* Perform a robust Cholesky decomposition of a positive semidefinite or negative semidefinite
* matrix \f$ A \f$ such that \f$ A = P^TLDL^*P \f$, where P is a permutation matrix, L
* is lower triangular with a unit diagonal and D is a diagonal matrix.
*
* The decomposition uses pivoting to ensure stability, so that D will have
* zeros in the bottom right rank(A) - n submatrix. Avoiding the square root
* on D also stabilizes the computation.
*
* Remember that Cholesky decompositions are not rank-revealing. Also, do not use a Cholesky
* decomposition to determine whether a system of equations has a solution.
*
* This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
*
* \sa MatrixBase::ldlt(), SelfAdjointView::ldlt(), class LLT
*/
template<typename _MatrixType, int _UpLo> class LDLT
: public SolverBase<LDLT<_MatrixType, _UpLo> >
{
public:
typedef _MatrixType MatrixType;
typedef SolverBase<LDLT> Base;
friend class SolverBase<LDLT>;
EIGEN_GENERIC_PUBLIC_INTERFACE(LDLT)
enum {
MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime,
UpLo = _UpLo
};
typedef Matrix<Scalar, RowsAtCompileTime, 1, 0, MaxRowsAtCompileTime, 1> TmpMatrixType;
typedef Transpositions<RowsAtCompileTime, MaxRowsAtCompileTime> TranspositionType;
typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime> PermutationType;
typedef internal::LDLT_Traits<MatrixType,UpLo> Traits;
/** \brief Default Constructor.
*
* The default constructor is useful in cases in which the user intends to
* perform decompositions via LDLT::compute(const MatrixType&).
*/
LDLT()
: m_matrix(),
m_transpositions(),
m_sign(internal::ZeroSign),
m_isInitialized(false)
{}
/** \brief Default Constructor with memory preallocation
*
* Like the default constructor but with preallocation of the internal data
* according to the specified problem \a size.
* \sa LDLT()
*/
explicit LDLT(Index size)
: m_matrix(size, size),
m_transpositions(size),
m_temporary(size),
m_sign(internal::ZeroSign),
m_isInitialized(false)
{}
/** \brief Constructor with decomposition
*
* This calculates the decomposition for the input \a matrix.
*
* \sa LDLT(Index size)
*/
template<typename InputType>
explicit LDLT(const EigenBase<InputType>& matrix)
: m_matrix(matrix.rows(), matrix.cols()),
m_transpositions(matrix.rows()),
m_temporary(matrix.rows()),
m_sign(internal::ZeroSign),
m_isInitialized(false)
{
compute(matrix.derived());
}
/** \brief Constructs a LDLT factorization from a given matrix
*
* This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when \c MatrixType is a Eigen::Ref.
*
* \sa LDLT(const EigenBase&)
*/
template<typename InputType>
explicit LDLT(EigenBase<InputType>& matrix)
: m_matrix(matrix.derived()),
m_transpositions(matrix.rows()),
m_temporary(matrix.rows()),
m_sign(internal::ZeroSign),
m_isInitialized(false)
{
compute(matrix.derived());
}
/** Clear any existing decomposition
* \sa rankUpdate(w,sigma)
*/
void setZero()
{
m_isInitialized = false;
}
/** \returns a view of the upper triangular matrix U */
inline typename Traits::MatrixU matrixU() const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
return Traits::getU(m_matrix);
}
/** \returns a view of the lower triangular matrix L */
inline typename Traits::MatrixL matrixL() const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
return Traits::getL(m_matrix);
}
/** \returns the permutation matrix P as a transposition sequence.
*/
inline const TranspositionType& transpositionsP() const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
return m_transpositions;
}
/** \returns the coefficients of the diagonal matrix D */
inline Diagonal<const MatrixType> vectorD() const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
return m_matrix.diagonal();
}
/** \returns true if the matrix is positive (semidefinite) */
inline bool isPositive() const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
return m_sign == internal::PositiveSemiDef || m_sign == internal::ZeroSign;
}
/** \returns true if the matrix is negative (semidefinite) */
inline bool isNegative(void) const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
return m_sign == internal::NegativeSemiDef || m_sign == internal::ZeroSign;
}
#ifdef EIGEN_PARSED_BY_DOXYGEN
/** \returns a solution x of \f$ A x = b \f$ using the current decomposition of A.
*
* This function also supports in-place solves using the syntax <tt>x = decompositionObject.solve(x)</tt> .
*
* \note_about_checking_solutions
*
* More precisely, this method solves \f$ A x = b \f$ using the decomposition \f$ A = P^T L D L^* P \f$
* by solving the systems \f$ P^T y_1 = b \f$, \f$ L y_2 = y_1 \f$, \f$ D y_3 = y_2 \f$,
* \f$ L^* y_4 = y_3 \f$ and \f$ P x = y_4 \f$ in succession. If the matrix \f$ A \f$ is singular, then
* \f$ D \f$ will also be singular (all the other matrices are invertible). In that case, the
* least-square solution of \f$ D y_3 = y_2 \f$ is computed. This does not mean that this function
* computes the least-square solution of \f$ A x = b \f$ if \f$ A \f$ is singular.
*
* \sa MatrixBase::ldlt(), SelfAdjointView::ldlt()
*/
template<typename Rhs>
inline const Solve<LDLT, Rhs>
solve(const MatrixBase<Rhs>& b) const;
#endif
template<typename Derived>
bool solveInPlace(MatrixBase<Derived> &bAndX) const;
template<typename InputType>
LDLT& compute(const EigenBase<InputType>& matrix);
/** \returns an estimate of the reciprocal condition number of the matrix of
* which \c *this is the LDLT decomposition.
*/
RealScalar rcond() const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
return internal::rcond_estimate_helper(m_l1_norm, *this);
}
template <typename Derived>
LDLT& rankUpdate(const MatrixBase<Derived>& w, const RealScalar& alpha=1);
/** \returns the internal LDLT decomposition matrix
*
* TODO: document the storage layout
*/
inline const MatrixType& matrixLDLT() const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
return m_matrix;
}
MatrixType reconstructedMatrix() const;
/** \returns the adjoint of \c *this, that is, a const reference to the decomposition itself as the underlying matrix is self-adjoint.
*
* This method is provided for compatibility with other matrix decompositions, thus enabling generic code such as:
* \code x = decomposition.adjoint().solve(b) \endcode
*/
const LDLT& adjoint() const { return *this; };
EIGEN_DEVICE_FUNC inline EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
EIGEN_DEVICE_FUNC inline EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
/** \brief Reports whether previous computation was successful.
*
* \returns \c Success if computation was successful,
* \c NumericalIssue if the factorization failed because of a zero pivot.
*/
ComputationInfo info() const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
return m_info;
}
#ifndef EIGEN_PARSED_BY_DOXYGEN
template<typename RhsType, typename DstType>
void _solve_impl(const RhsType &rhs, DstType &dst) const;
template<bool Conjugate, typename RhsType, typename DstType>
void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
#endif
protected:
static void check_template_parameters()
{
EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
}
/** \internal
* Used to compute and store the Cholesky decomposition A = L D L^* = U^* D U.
* The strict upper part is used during the decomposition, the strict lower
* part correspond to the coefficients of L (its diagonal is equal to 1 and
* is not stored), and the diagonal entries correspond to D.
*/
MatrixType m_matrix;
RealScalar m_l1_norm;
TranspositionType m_transpositions;
TmpMatrixType m_temporary;
internal::SignMatrix m_sign;
bool m_isInitialized;
ComputationInfo m_info;
};
namespace internal {
template<int UpLo> struct ldlt_inplace;
template<> struct ldlt_inplace<Lower>
{
template<typename MatrixType, typename TranspositionType, typename Workspace>
static bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, SignMatrix& sign)
{
using std::abs;
typedef typename MatrixType::Scalar Scalar;
typedef typename MatrixType::RealScalar RealScalar;
typedef typename TranspositionType::StorageIndex IndexType;
eigen_assert(mat.rows()==mat.cols());
const Index size = mat.rows();
bool found_zero_pivot = false;
bool ret = true;
if (size <= 1)
{
transpositions.setIdentity();
if(size==0) sign = ZeroSign;
else if (numext::real(mat.coeff(0,0)) > static_cast<RealScalar>(0) ) sign = PositiveSemiDef;
else if (numext::real(mat.coeff(0,0)) < static_cast<RealScalar>(0)) sign = NegativeSemiDef;
else sign = ZeroSign;
return true;
}
for (Index k = 0; k < size; ++k)
{
// Find largest diagonal element
Index index_of_biggest_in_corner;
mat.diagonal().tail(size-k).cwiseAbs().maxCoeff(&index_of_biggest_in_corner);
index_of_biggest_in_corner += k;
transpositions.coeffRef(k) = IndexType(index_of_biggest_in_corner);
if(k != index_of_biggest_in_corner)
{
// apply the transposition while taking care to consider only
// the lower triangular part
Index s = size-index_of_biggest_in_corner-1; // trailing size after the biggest element
mat.row(k).head(k).swap(mat.row(index_of_biggest_in_corner).head(k));
mat.col(k).tail(s).swap(mat.col(index_of_biggest_in_corner).tail(s));
std::swap(mat.coeffRef(k,k),mat.coeffRef(index_of_biggest_in_corner,index_of_biggest_in_corner));
for(Index i=k+1;i<index_of_biggest_in_corner;++i)
{
Scalar tmp = mat.coeffRef(i,k);
mat.coeffRef(i,k) = numext::conj(mat.coeffRef(index_of_biggest_in_corner,i));
mat.coeffRef(index_of_biggest_in_corner,i) = numext::conj(tmp);
}
if(NumTraits<Scalar>::IsComplex)
mat.coeffRef(index_of_biggest_in_corner,k) = numext::conj(mat.coeff(index_of_biggest_in_corner,k));
}
// partition the matrix:
// A00 | - | -
// lu = A10 | A11 | -
// A20 | A21 | A22
Index rs = size - k - 1;
Block<MatrixType,Dynamic,1> A21(mat,k+1,k,rs,1);
Block<MatrixType,1,Dynamic> A10(mat,k,0,1,k);
Block<MatrixType,Dynamic,Dynamic> A20(mat,k+1,0,rs,k);
if(k>0)
{
temp.head(k) = mat.diagonal().real().head(k).asDiagonal() * A10.adjoint();
mat.coeffRef(k,k) -= (A10 * temp.head(k)).value();
if(rs>0)
A21.noalias() -= A20 * temp.head(k);
}
// In some previous versions of Eigen (e.g., 3.2.1), the scaling was omitted if the pivot
// was smaller than the cutoff value. However, since LDLT is not rank-revealing
// we should only make sure that we do not introduce INF or NaN values.
// Remark that LAPACK also uses 0 as the cutoff value.
RealScalar realAkk = numext::real(mat.coeffRef(k,k));
bool pivot_is_valid = (abs(realAkk) > RealScalar(0));
if(k==0 && !pivot_is_valid)
{
// The entire diagonal is zero, there is nothing more to do
// except filling the transpositions, and checking whether the matrix is zero.
sign = ZeroSign;
for(Index j = 0; j<size; ++j)
{
transpositions.coeffRef(j) = IndexType(j);
ret = ret && (mat.col(j).tail(size-j-1).array()==Scalar(0)).all();
}
return ret;
}
if((rs>0) && pivot_is_valid)
A21 /= realAkk;
else if(rs>0)
ret = ret && (A21.array()==Scalar(0)).all();
if(found_zero_pivot && pivot_is_valid) ret = false; // factorization failed
else if(!pivot_is_valid) found_zero_pivot = true;
if (sign == PositiveSemiDef) {
if (realAkk < static_cast<RealScalar>(0)) sign = Indefinite;
} else if (sign == NegativeSemiDef) {
if (realAkk > static_cast<RealScalar>(0)) sign = Indefinite;
} else if (sign == ZeroSign) {
if (realAkk > static_cast<RealScalar>(0)) sign = PositiveSemiDef;
else if (realAkk < static_cast<RealScalar>(0)) sign = NegativeSemiDef;
}
}
return ret;
}
// Reference for the algorithm: Davis and Hager, "Multiple Rank
// Modifications of a Sparse Cholesky Factorization" (Algorithm 1)
// Trivial rearrangements of their computations (Timothy E. Holy)
// allow their algorithm to work for rank-1 updates even if the
// original matrix is not of full rank.
// Here only rank-1 updates are implemented, to reduce the
// requirement for intermediate storage and improve accuracy
template<typename MatrixType, typename WDerived>
static bool updateInPlace(MatrixType& mat, MatrixBase<WDerived>& w, const typename MatrixType::RealScalar& sigma=1)
{
using numext::isfinite;
typedef typename MatrixType::Scalar Scalar;
typedef typename MatrixType::RealScalar RealScalar;
const Index size = mat.rows();
eigen_assert(mat.cols() == size && w.size()==size);
RealScalar alpha = 1;
// Apply the update
for (Index j = 0; j < size; j++)
{
// Check for termination due to an original decomposition of low-rank
if (!(isfinite)(alpha))
break;
// Update the diagonal terms
RealScalar dj = numext::real(mat.coeff(j,j));
Scalar wj = w.coeff(j);
RealScalar swj2 = sigma*numext::abs2(wj);
RealScalar gamma = dj*alpha + swj2;
mat.coeffRef(j,j) += swj2/alpha;
alpha += swj2/dj;
// Update the terms of L
Index rs = size-j-1;
w.tail(rs) -= wj * mat.col(j).tail(rs);
if(gamma != 0)
mat.col(j).tail(rs) += (sigma*numext::conj(wj)/gamma)*w.tail(rs);
}
return true;
}
template<typename MatrixType, typename TranspositionType, typename Workspace, typename WType>
static bool update(MatrixType& mat, const TranspositionType& transpositions, Workspace& tmp, const WType& w, const typename MatrixType::RealScalar& sigma=1)
{
// Apply the permutation to the input w
tmp = transpositions * w;
return ldlt_inplace<Lower>::updateInPlace(mat,tmp,sigma);
}
};
template<> struct ldlt_inplace<Upper>
{
template<typename MatrixType, typename TranspositionType, typename Workspace>
static EIGEN_STRONG_INLINE bool unblocked(MatrixType& mat, TranspositionType& transpositions, Workspace& temp, SignMatrix& sign)
{
Transpose<MatrixType> matt(mat);
return ldlt_inplace<Lower>::unblocked(matt, transpositions, temp, sign);
}
template<typename MatrixType, typename TranspositionType, typename Workspace, typename WType>
static EIGEN_STRONG_INLINE bool update(MatrixType& mat, TranspositionType& transpositions, Workspace& tmp, WType& w, const typename MatrixType::RealScalar& sigma=1)
{
Transpose<MatrixType> matt(mat);
return ldlt_inplace<Lower>::update(matt, transpositions, tmp, w.conjugate(), sigma);
}
};
template<typename MatrixType> struct LDLT_Traits<MatrixType,Lower>
{
typedef const TriangularView<const MatrixType, UnitLower> MatrixL;
typedef const TriangularView<const typename MatrixType::AdjointReturnType, UnitUpper> MatrixU;
static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
};
template<typename MatrixType> struct LDLT_Traits<MatrixType,Upper>
{
typedef const TriangularView<const typename MatrixType::AdjointReturnType, UnitLower> MatrixL;
typedef const TriangularView<const MatrixType, UnitUpper> MatrixU;
static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); }
static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
};
} // end namespace internal
/** Compute / recompute the LDLT decomposition A = L D L^* = U^* D U of \a matrix
*/
template<typename MatrixType, int _UpLo>
template<typename InputType>
LDLT<MatrixType,_UpLo>& LDLT<MatrixType,_UpLo>::compute(const EigenBase<InputType>& a)
{
check_template_parameters();
eigen_assert(a.rows()==a.cols());
const Index size = a.rows();
m_matrix = a.derived();
// Compute matrix L1 norm = max abs column sum.
m_l1_norm = RealScalar(0);
// TODO move this code to SelfAdjointView
for (Index col = 0; col < size; ++col) {
RealScalar abs_col_sum;
if (_UpLo == Lower)
abs_col_sum = m_matrix.col(col).tail(size - col).template lpNorm<1>() + m_matrix.row(col).head(col).template lpNorm<1>();
else
abs_col_sum = m_matrix.col(col).head(col).template lpNorm<1>() + m_matrix.row(col).tail(size - col).template lpNorm<1>();
if (abs_col_sum > m_l1_norm)
m_l1_norm = abs_col_sum;
}
m_transpositions.resize(size);
m_isInitialized = false;
m_temporary.resize(size);
m_sign = internal::ZeroSign;
m_info = internal::ldlt_inplace<UpLo>::unblocked(m_matrix, m_transpositions, m_temporary, m_sign) ? Success : NumericalIssue;
m_isInitialized = true;
return *this;
}
/** Update the LDLT decomposition: given A = L D L^T, efficiently compute the decomposition of A + sigma w w^T.
* \param w a vector to be incorporated into the decomposition.
* \param sigma a scalar, +1 for updates and -1 for "downdates," which correspond to removing previously-added column vectors. Optional; default value is +1.
* \sa setZero()
*/
template<typename MatrixType, int _UpLo>
template<typename Derived>
LDLT<MatrixType,_UpLo>& LDLT<MatrixType,_UpLo>::rankUpdate(const MatrixBase<Derived>& w, const typename LDLT<MatrixType,_UpLo>::RealScalar& sigma)
{
typedef typename TranspositionType::StorageIndex IndexType;
const Index size = w.rows();
if (m_isInitialized)
{
eigen_assert(m_matrix.rows()==size);
}
else
{
m_matrix.resize(size,size);
m_matrix.setZero();
m_transpositions.resize(size);
for (Index i = 0; i < size; i++)
m_transpositions.coeffRef(i) = IndexType(i);
m_temporary.resize(size);
m_sign = sigma>=0 ? internal::PositiveSemiDef : internal::NegativeSemiDef;
m_isInitialized = true;
}
internal::ldlt_inplace<UpLo>::update(m_matrix, m_transpositions, m_temporary, w, sigma);
return *this;
}
#ifndef EIGEN_PARSED_BY_DOXYGEN
template<typename _MatrixType, int _UpLo>
template<typename RhsType, typename DstType>
void LDLT<_MatrixType,_UpLo>::_solve_impl(const RhsType &rhs, DstType &dst) const
{
_solve_impl_transposed<true>(rhs, dst);
}
template<typename _MatrixType,int _UpLo>
template<bool Conjugate, typename RhsType, typename DstType>
void LDLT<_MatrixType,_UpLo>::_solve_impl_transposed(const RhsType &rhs, DstType &dst) const
{
// dst = P b
dst = m_transpositions * rhs;
// dst = L^-1 (P b)
// dst = L^-*T (P b)
matrixL().template conjugateIf<!Conjugate>().solveInPlace(dst);
// dst = D^-* (L^-1 P b)
// dst = D^-1 (L^-*T P b)
// more precisely, use pseudo-inverse of D (see bug 241)
using std::abs;
const typename Diagonal<const MatrixType>::RealReturnType vecD(vectorD());
// In some previous versions, tolerance was set to the max of 1/highest (or rather numeric_limits::min())
// and the maximal diagonal entry * epsilon as motivated by LAPACK's xGELSS:
// RealScalar tolerance = numext::maxi(vecD.array().abs().maxCoeff() * NumTraits<RealScalar>::epsilon(),RealScalar(1) / NumTraits<RealScalar>::highest());
// However, LDLT is not rank revealing, and so adjusting the tolerance wrt to the highest
// diagonal element is not well justified and leads to numerical issues in some cases.
// Moreover, Lapack's xSYTRS routines use 0 for the tolerance.
// Using numeric_limits::min() gives us more robustness to denormals.
RealScalar tolerance = (std::numeric_limits<RealScalar>::min)();
for (Index i = 0; i < vecD.size(); ++i)
{
if(abs(vecD(i)) > tolerance)
dst.row(i) /= vecD(i);
else
dst.row(i).setZero();
}
// dst = L^-* (D^-* L^-1 P b)
// dst = L^-T (D^-1 L^-*T P b)
matrixL().transpose().template conjugateIf<Conjugate>().solveInPlace(dst);
// dst = P^T (L^-* D^-* L^-1 P b) = A^-1 b
// dst = P^-T (L^-T D^-1 L^-*T P b) = A^-1 b
dst = m_transpositions.transpose() * dst;
}
#endif
/** \internal use x = ldlt_object.solve(x);
*
* This is the \em in-place version of solve().
*
* \param bAndX represents both the right-hand side matrix b and result x.
*
* \returns true always! If you need to check for existence of solutions, use another decomposition like LU, QR, or SVD.
*
* This version avoids a copy when the right hand side matrix b is not
* needed anymore.
*
* \sa LDLT::solve(), MatrixBase::ldlt()
*/
template<typename MatrixType,int _UpLo>
template<typename Derived>
bool LDLT<MatrixType,_UpLo>::solveInPlace(MatrixBase<Derived> &bAndX) const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
eigen_assert(m_matrix.rows() == bAndX.rows());
bAndX = this->solve(bAndX);
return true;
}
/** \returns the matrix represented by the decomposition,
* i.e., it returns the product: P^T L D L^* P.
* This function is provided for debug purpose. */
template<typename MatrixType, int _UpLo>
MatrixType LDLT<MatrixType,_UpLo>::reconstructedMatrix() const
{
eigen_assert(m_isInitialized && "LDLT is not initialized.");
const Index size = m_matrix.rows();
MatrixType res(size,size);
// P
res.setIdentity();
res = transpositionsP() * res;
// L^* P
res = matrixU() * res;
// D(L^*P)
res = vectorD().real().asDiagonal() * res;
// L(DL^*P)
res = matrixL() * res;
// P^T (LDL^*P)
res = transpositionsP().transpose() * res;
return res;
}
/** \cholesky_module
* \returns the Cholesky decomposition with full pivoting without square root of \c *this
* \sa MatrixBase::ldlt()
*/
template<typename MatrixType, unsigned int UpLo>
inline const LDLT<typename SelfAdjointView<MatrixType, UpLo>::PlainObject, UpLo>
SelfAdjointView<MatrixType, UpLo>::ldlt() const
{
return LDLT<PlainObject,UpLo>(m_matrix);
}
/** \cholesky_module
* \returns the Cholesky decomposition with full pivoting without square root of \c *this
* \sa SelfAdjointView::ldlt()
*/
template<typename Derived>
inline const LDLT<typename MatrixBase<Derived>::PlainObject>
MatrixBase<Derived>::ldlt() const
{
return LDLT<PlainObject>(derived());
}
} // end namespace Eigen
#endif // EIGEN_LDLT_H
================================================
FILE: Obfuscation/include/Eigen/src/Cholesky/LLT.h
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_LLT_H
#define EIGEN_LLT_H
namespace Eigen {
namespace internal{
template<typename _MatrixType, int _UpLo> struct traits<LLT<_MatrixType, _UpLo> >
: traits<_MatrixType>
{
typedef MatrixXpr XprKind;
typedef SolverStorage StorageKind;
typedef int StorageIndex;
enum { Flags = 0 };
};
template<typename MatrixType, int UpLo> struct LLT_Traits;
}
/** \ingroup Cholesky_Module
*
* \class LLT
*
* \brief Standard Cholesky decomposition (LL^T) of a matrix and associated features
*
* \tparam _MatrixType the type of the matrix of which we are computing the LL^T Cholesky decomposition
* \tparam _UpLo the triangular part that will be used for the decompositon: Lower (default) or Upper.
* The other triangular part won't be read.
*
* This class performs a LL^T Cholesky decomposition of a symmetric, positive definite
* matrix A such that A = LL^* = U^*U, where L is lower triangular.
*
* While the Cholesky decomposition is particularly useful to solve selfadjoint problems like D^*D x = b,
* for that purpose, we recommend the Cholesky decomposition without square root which is more stable
* and even faster. Nevertheless, this standard Cholesky decomposition remains useful in many other
* situations like generalised eigen problems with hermitian matrices.
*
* Remember that Cholesky decompositions are not rank-revealing. This LLT decomposition is only stable on positive definite matrices,
* use LDLT instead for the semidefinite case. Also, do not use a Cholesky decomposition to determine whether a system of equations
* has a solution.
*
* Example: \include LLT_example.cpp
* Output: \verbinclude LLT_example.out
*
* \b Performance: for best performance, it is recommended to use a column-major storage format
* with the Lower triangular part (the default), or, equivalently, a row-major storage format
* with the Upper triangular part. Otherwise, you might get a 20% slowdown for the full factorization
* step, and rank-updates can be up to 3 times slower.
*
* This class supports the \link InplaceDecomposition inplace decomposition \endlink mechanism.
*
* Note that during the decomposition, only the lower (or upper, as defined by _UpLo) triangular part of A is considered.
* Therefore, the strict lower part does not have to store correct values.
*
* \sa MatrixBase::llt(), SelfAdjointView::llt(), class LDLT
*/
template<typename _MatrixType, int _UpLo> class LLT
: public SolverBase<LLT<_MatrixType, _UpLo> >
{
public:
typedef _MatrixType MatrixType;
typedef SolverBase<LLT> Base;
friend class SolverBase<LLT>;
EIGEN_GENERIC_PUBLIC_INTERFACE(LLT)
enum {
MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
};
enum {
PacketSize = internal::packet_traits<Scalar>::size,
AlignmentMask = int(PacketSize)-1,
UpLo = _UpLo
};
typedef internal::LLT_Traits<MatrixType,UpLo> Traits;
/**
* \brief Default Constructor.
*
* The default constructor is useful in cases in which the user intends to
* perform decompositions via LLT::compute(const MatrixType&).
*/
LLT() : m_matrix(), m_isInitialized(false) {}
/** \brief Default Constructor with memory preallocation
*
* Like the default constructor but with preallocation of the internal data
* according to the specified problem \a size.
* \sa LLT()
*/
explicit LLT(Index size) : m_matrix(size, size),
m_isInitialized(false) {}
template<typename InputType>
explicit LLT(const EigenBase<InputType>& matrix)
: m_matrix(matrix.rows(), matrix.cols()),
m_isInitialized(false)
{
compute(matrix.derived());
}
/** \brief Constructs a LLT factorization from a given matrix
*
* This overloaded constructor is provided for \link InplaceDecomposition inplace decomposition \endlink when
* \c MatrixType is a Eigen::Ref.
*
* \sa LLT(const EigenBase&)
*/
template<typename InputType>
explicit LLT(EigenBase<InputType>& matrix)
: m_matrix(matrix.derived()),
m_isInitialized(false)
{
compute(matrix.derived());
}
/** \returns a view of the upper triangular matrix U */
inline typename Traits::MatrixU matrixU() const
{
eigen_assert(m_isInitialized && "LLT is not initialized.");
return Traits::getU(m_matrix);
}
/** \returns a view of the lower triangular matrix L */
inline typename Traits::MatrixL matrixL() const
{
eigen_assert(m_isInitialized && "LLT is not initialized.");
return Traits::getL(m_matrix);
}
#ifdef EIGEN_PARSED_BY_DOXYGEN
/** \returns the solution x of \f$ A x = b \f$ using the current decomposition of A.
*
* Since this LLT class assumes anyway that the matrix A is invertible, the solution
* theoretically exists and is unique regardless of b.
*
* Example: \include LLT_solve.cpp
* Output: \verbinclude LLT_solve.out
*
* \sa solveInPlace(), MatrixBase::llt(), SelfAdjointView::llt()
*/
template<typename Rhs>
inline const Solve<LLT, Rhs>
solve(const MatrixBase<Rhs>& b) const;
#endif
template<typename Derived>
void solveInPlace(const MatrixBase<Derived> &bAndX) const;
template<typename InputType>
LLT& compute(const EigenBase<InputType>& matrix);
/** \returns an estimate of the reciprocal condition number of the matrix of
* which \c *this is the Cholesky decomposition.
*/
RealScalar rcond() const
{
eigen_assert(m_isInitialized && "LLT is not initialized.");
eigen_assert(m_info == Success && "LLT failed because matrix appears to be negative");
return internal::rcond_estimate_helper(m_l1_norm, *this);
}
/** \returns the LLT decomposition matrix
*
* TODO: document the storage layout
*/
inline const MatrixType& matrixLLT() const
{
eigen_assert(m_isInitialized && "LLT is not initialized.");
return m_matrix;
}
MatrixType reconstructedMatrix() const;
/** \brief Reports whether previous computation was successful.
*
* \returns \c Success if computation was successful,
* \c NumericalIssue if the matrix.appears not to be positive definite.
*/
ComputationInfo info() const
{
eigen_assert(m_isInitialized && "LLT is not initialized.");
return m_info;
}
/** \returns the adjoint of \c *this, that is, a const reference to the decomposition itself as the underlying matrix is self-adjoint.
*
* This method is provided for compatibility with other matrix decompositions, thus enabling generic code such as:
* \code x = decomposition.adjoint().solve(b) \endcode
*/
const LLT& adjoint() const EIGEN_NOEXCEPT { return *this; };
inline EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
inline EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
template<typename VectorType>
LLT & rankUpdate(const VectorType& vec, const RealScalar& sigma = 1);
#ifndef EIGEN_PARSED_BY_DOXYGEN
template<typename RhsType, typename DstType>
void _solve_impl(const RhsType &rhs, DstType &dst) const;
template<bool Conjugate, typename RhsType, typename DstType>
void _solve_impl_transposed(const RhsType &rhs, DstType &dst) const;
#endif
protected:
static void check_template_parameters()
{
EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
}
/** \internal
* Used to compute and store L
* The strict upper part is not used and even not initialized.
*/
MatrixType m_matrix;
RealScalar m_l1_norm;
bool m_isInitialized;
ComputationInfo m_info;
};
namespace internal {
template<typename Scalar, int UpLo> struct llt_inplace;
template<typename MatrixType, typename VectorType>
static Index llt_rank_update_lower(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma)
{
using std::sqrt;
typedef typename MatrixType::Scalar Scalar;
typedef typename MatrixType::RealScalar RealScalar;
typedef typename MatrixType::ColXpr ColXpr;
typedef typename internal::remove_all<ColXpr>::type ColXprCleaned;
typedef typename ColXprCleaned::SegmentReturnType ColXprSegment;
typedef Matrix<Scalar,Dynamic,1> TempVectorType;
typedef typename TempVectorType::SegmentReturnType TempVecSegment;
Index n = mat.cols();
eigen_assert(mat.rows()==n && vec.size()==n);
TempVectorType temp;
if(sigma>0)
{
// This version is based on Givens rotations.
// It is faster than the other one below, but only works for updates,
// i.e., for sigma > 0
temp = sqrt(sigma) * vec;
for(Index i=0; i<n; ++i)
{
JacobiRotation<Scalar> g;
g.makeGivens(mat(i,i), -temp(i), &mat(i,i));
Index rs = n-i-1;
if(rs>0)
{
ColXprSegment x(mat.col(i).tail(rs));
TempVecSegment y(temp.tail(rs));
apply_rotation_in_the_plane(x, y, g);
}
}
}
else
{
temp = vec;
RealScalar beta = 1;
for(Index j=0; j<n; ++j)
{
RealScalar Ljj = numext::real(mat.coeff(j,j));
RealScalar dj = numext::abs2(Ljj);
Scalar wj = temp.coeff(j);
RealScalar swj2 = sigma*numext::abs2(wj);
RealScalar gamma = dj*beta + swj2;
RealScalar x = dj + swj2/beta;
if (x<=RealScalar(0))
return j;
RealScalar nLjj = sqrt(x);
mat.coeffRef(j,j) = nLjj;
beta += swj2/dj;
// Update the terms of L
Index rs = n-j-1;
if(rs)
{
temp.tail(rs) -= (wj/Ljj) * mat.col(j).tail(rs);
if(gamma != 0)
mat.col(j).tail(rs) = (nLjj/Ljj) * mat.col(j).tail(rs) + (nLjj * sigma*numext::conj(wj)/gamma)*temp.tail(rs);
}
}
}
return -1;
}
template<typename Scalar> struct llt_inplace<Scalar, Lower>
{
typedef typename NumTraits<Scalar>::Real RealScalar;
template<typename MatrixType>
static Index unblocked(MatrixType& mat)
{
using std::sqrt;
eigen_assert(mat.rows()==mat.cols());
const Index size = mat.rows();
for(Index k = 0; k < size; ++k)
{
Index rs = size-k-1; // remaining size
Block<MatrixType,Dynamic,1> A21(mat,k+1,k,rs,1);
Block<MatrixType,1,Dynamic> A10(mat,k,0,1,k);
Block<MatrixType,Dynamic,Dynamic> A20(mat,k+1,0,rs,k);
RealScalar x = numext::real(mat.coeff(k,k));
if (k>0) x -= A10.squaredNorm();
if (x<=RealScalar(0))
return k;
mat.coeffRef(k,k) = x = sqrt(x);
if (k>0 && rs>0) A21.noalias() -= A20 * A10.adjoint();
if (rs>0) A21 /= x;
}
return -1;
}
template<typename MatrixType>
static Index blocked(MatrixType& m)
{
eigen_assert(m.rows()==m.cols());
Index size = m.rows();
if(size<32)
return unblocked(m);
Index blockSize = size/8;
blockSize = (blockSize/16)*16;
blockSize = (std::min)((std::max)(blockSize,Index(8)), Index(128));
for (Index k=0; k<size; k+=blockSize)
{
// partition the matrix:
// A00 | - | -
// lu = A10 | A11 | -
// A20 | A21 | A22
Index bs = (std::min)(blockSize, size-k);
Index rs = size - k - bs;
Block<MatrixType,Dynamic,Dynamic> A11(m,k, k, bs,bs);
Block<MatrixType,Dynamic,Dynamic> A21(m,k+bs,k, rs,bs);
Block<MatrixType,Dynamic,Dynamic> A22(m,k+bs,k+bs,rs,rs);
Index ret;
if((ret=unblocked(A11))>=0) return k+ret;
if(rs>0) A11.adjoint().template triangularView<Upper>().template solveInPlace<OnTheRight>(A21);
if(rs>0) A22.template selfadjointView<Lower>().rankUpdate(A21,typename NumTraits<RealScalar>::Literal(-1)); // bottleneck
}
return -1;
}
template<typename MatrixType, typename VectorType>
static Index rankUpdate(MatrixType& mat, const VectorType& vec, const RealScalar& sigma)
{
return Eigen::internal::llt_rank_update_lower(mat, vec, sigma);
}
};
template<typename Scalar> struct llt_inplace<Scalar, Upper>
{
typedef typename NumTraits<Scalar>::Real RealScalar;
template<typename MatrixType>
static EIGEN_STRONG_INLINE Index unblocked(MatrixType& mat)
{
Transpose<MatrixType> matt(mat);
return llt_inplace<Scalar, Lower>::unblocked(matt);
}
template<typename MatrixType>
static EIGEN_STRONG_INLINE Index blocked(MatrixType& mat)
{
Transpose<MatrixType> matt(mat);
return llt_inplace<Scalar, Lower>::blocked(matt);
}
template<typename MatrixType, typename VectorType>
static Index rankUpdate(MatrixType& mat, const VectorType& vec, const RealScalar& sigma)
{
Transpose<MatrixType> matt(mat);
return llt_inplace<Scalar, Lower>::rankUpdate(matt, vec.conjugate(), sigma);
}
};
template<typename MatrixType> struct LLT_Traits<MatrixType,Lower>
{
typedef const TriangularView<const MatrixType, Lower> MatrixL;
typedef const TriangularView<const typename MatrixType::AdjointReturnType, Upper> MatrixU;
static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoint()); }
static bool inplace_decomposition(MatrixType& m)
{ return llt_inplace<typename MatrixType::Scalar, Lower>::blocked(m)==-1; }
};
template<typename MatrixType> struct LLT_Traits<MatrixType,Upper>
{
typedef const TriangularView<const typename MatrixType::AdjointReturnType, Lower> MatrixL;
typedef const TriangularView<const MatrixType, Upper> MatrixU;
static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoint()); }
static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
static bool inplace_decomposition(MatrixType& m)
{ return llt_inplace<typename MatrixType::Scalar, Upper>::blocked(m)==-1; }
};
} // end namespace internal
/** Computes / recomputes the Cholesky decomposition A = LL^* = U^*U of \a matrix
*
* \returns a reference to *this
*
* Example: \include TutorialLinAlgComputeTwice.cpp
* Output: \verbinclude TutorialLinAlgComputeTwice.out
*/
template<typename MatrixType, int _UpLo>
template<typename InputType>
LLT<MatrixType,_UpLo>& LLT<MatrixType,_UpLo>::compute(const EigenBase<InputType>& a)
{
check_template_parameters();
eigen_assert(a.rows()==a.cols());
const Index size = a.rows();
m_matrix.resize(size, size);
if (!internal::is_same_dense(m_matrix, a.derived()))
m_matrix = a.derived();
// Compute matrix L1 norm = max abs column sum.
m_l1_norm = RealScalar(0);
// TODO move this code to SelfAdjointView
for (Index col = 0; col < size; ++col) {
RealScalar abs_col_sum;
if (_UpLo == Lower)
abs_col_sum = m_matrix.col(col).tail(size - col).template lpNorm<1>() + m_matrix.row(col).head(col).template lpNorm<1>();
else
abs_col_sum = m_matrix.col(col).head(col).template lpNorm<1>() + m_matrix.row(col).tail(size - col).template lpNorm<1>();
if (abs_col_sum > m_l1_norm)
m_l1_norm = abs_col_sum;
}
m_isInitialized = true;
bool ok = Traits::inplace_decomposition(m_matrix);
m_info = ok ? Success : NumericalIssue;
return *this;
}
/** Performs a rank one update (or dowdate) of the current decomposition.
* If A = LL^* before the rank one update,
* then after it we have LL^* = A + sigma * v v^* where \a v must be a vector
* of same dimension.
*/
template<typename _MatrixType, int _UpLo>
template<typename VectorType>
LLT<_MatrixType,_UpLo> & LLT<_MatrixType,_UpLo>::rankUpdate(const VectorType& v, const RealScalar& sigma)
{
EIGEN_STATIC_ASSERT_VECTOR_ONLY(VectorType);
eigen_assert(v.size()==m_matrix.cols());
eigen_assert(m_isInitialized);
if(internal::llt_inplace<typename MatrixType::Scalar, UpLo>::rankUpdate(m_matrix,v,sigma)>=0)
m_info = NumericalIssue;
else
m_info = Success;
return *this;
}
#ifndef EIGEN_PARSED_BY_DOXYGEN
template<typename _MatrixType,int _UpLo>
template<typename RhsType, typename DstType>
void LLT<_MatrixType,_UpLo>::_solve_impl(const RhsType &rhs, DstType &dst) const
{
_solve_impl_transposed<true>(rhs, dst);
}
template<typename _MatrixType,int _UpLo>
template<bool Conjugate, typename RhsType, typename DstType>
void LLT<_MatrixType,_UpLo>::_solve_impl_transposed(const RhsType &rhs, DstType &dst) const
{
dst = rhs;
matrixL().template conjugateIf<!Conjugate>().solveInPlace(dst);
matrixU().template conjugateIf<!Conjugate>().solveInPlace(dst);
}
#endif
/** \internal use x = llt_object.solve(x);
*
* This is the \em in-place version of solve().
*
* \param bAndX represents both the right-hand side matrix b and result x.
*
* This version avoids a copy when the right hand side matrix b is not needed anymore.
*
* \warning The parameter is only marked 'const' to make the C++ compiler accept a temporary expression here.
* This function will const_cast it, so constness isn't honored here.
*
* \sa LLT::solve(), MatrixBase::llt()
*/
template<typename MatrixType, int _UpLo>
template<typename Derived>
void LLT<MatrixType,_UpLo>::solveInPlace(const MatrixBase<Derived> &bAndX) const
{
eigen_assert(m_isInitialized && "LLT is not initialized.");
eigen_assert(m_matrix.rows()==bAndX.rows());
matrixL().solveInPlace(bAndX);
matrixU().solveInPlace(bAndX);
}
/** \returns the matrix represented by the decomposition,
* i.e., it returns the product: L L^*.
* This function is provided for debug purpose. */
template<typename MatrixType, int _UpLo>
MatrixType LLT<MatrixType,_UpLo>::reconstructedMatrix() const
{
eigen_assert(m_isInitialized && "LLT is not initialized.");
return matrixL() * matrixL().adjoint().toDenseMatrix();
}
/** \cholesky_module
* \returns the LLT decomposition of \c *this
* \sa SelfAdjointView::llt()
*/
template<typename Derived>
inline const LLT<typename MatrixBase<Derived>::PlainObject>
MatrixBase<Derived>::llt() const
{
return LLT<PlainObject>(derived());
}
/** \cholesky_module
* \returns the LLT decomposition of \c *this
* \sa SelfAdjointView::llt()
*/
template<typename MatrixType, unsigned int UpLo>
inline const LLT<typename SelfAdjointView<MatrixType, UpLo>::PlainObject, UpLo>
SelfAdjointView<MatrixType, UpLo>::llt() const
{
return LLT<PlainObject,UpLo>(m_matrix);
}
} // end namespace Eigen
#endif // EIGEN_LLT_H
================================================
FILE: Obfuscation/include/Eigen/src/Cholesky/LLT_LAPACKE.h
================================================
/*
Copyright (c) 2011, Intel Corporation. All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of Intel Corporation nor the names of its contributors may
be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
********************************************************************************
* Content : Eigen bindings to LAPACKe
* LLt decomposition based on LAPACKE_?potrf function.
********************************************************************************
*/
#ifndef EIGEN_LLT_LAPACKE_H
#define EIGEN_LLT_LAPACKE_H
namespace Eigen {
namespace internal {
template<typename Scalar> struct lapacke_llt;
#define EIGEN_LAPACKE_LLT(EIGTYPE, BLASTYPE, LAPACKE_PREFIX) \
template<> struct lapacke_llt<EIGTYPE> \
{ \
template<typename MatrixType> \
static inline Index potrf(MatrixType& m, char uplo) \
{ \
lapack_int matrix_order; \
lapack_int size, lda, info, StorageOrder; \
EIGTYPE* a; \
eigen_assert(m.rows()==m.cols()); \
/* Set up parameters for ?potrf */ \
size = convert_index<lapack_int>(m.rows()); \
StorageOrder = MatrixType::Flags&RowMajorBit?RowMajor:ColMajor; \
matrix_order = StorageOrder==RowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; \
a = &(m.coeffRef(0,0)); \
lda = convert_index<lapack_int>(m.outerStride()); \
\
info = LAPACKE_##LAPACKE_PREFIX##potrf( matrix_order, uplo, size, (BLASTYPE*)a, lda ); \
info = (info==0) ? -1 : info>0 ? info-1 : size; \
return info; \
} \
}; \
template<> struct llt_inplace<EIGTYPE, Lower> \
{ \
template<typename MatrixType> \
static Index blocked(MatrixType& m) \
{ \
return lapacke_llt<EIGTYPE>::potrf(m, 'L'); \
} \
template<typename MatrixType, typename VectorType> \
static Index rankUpdate(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma) \
{ return Eigen::internal::llt_rank_update_lower(mat, vec, sigma); } \
}; \
template<> struct llt_inplace<EIGTYPE, Upper> \
{ \
template<typename MatrixType> \
static Index blocked(MatrixType& m) \
{ \
return lapacke_llt<EIGTYPE>::potrf(m, 'U'); \
} \
template<typename MatrixType, typename VectorType> \
static Index rankUpdate(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma) \
{ \
Transpose<MatrixType> matt(mat); \
return llt_inplace<EIGTYPE, Lower>::rankUpdate(matt, vec.conjugate(), sigma); \
} \
};
EIGEN_LAPACKE_LLT(double, double, d)
EIGEN_LAPACKE_LLT(float, float, s)
EIGEN_LAPACKE_LLT(dcomplex, lapack_complex_double, z)
EIGEN_LAPACKE_LLT(scomplex, lapack_complex_float, c)
} // end namespace internal
} // end namespace Eigen
#endif // EIGEN_LLT_LAPACKE_H
================================================
FILE: Obfuscation/include/Eigen/src/CholmodSupport/CholmodSupport.h
================================================
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_CHOLMODSUPPORT_H
#define EIGEN_CHOLMODSUPPORT_H
namespace Eigen {
namespace internal {
template<typename Scalar> struct cholmod_configure_matrix;
template<> struct cholmod_configure_matrix<double> {
template<typename CholmodType>
static void run(CholmodType& mat) {
mat.xtype = CHOLMOD_REAL;
mat.dtype = CHOLMOD_DOUBLE;
}
};
template<> struct cholmod_configure_matrix<std::complex<double> > {
template<typename Cholmod
gitextract_l0eydqq_/
├── .gitignore
├── Demo/
│ ├── help.txt
│ ├── main
│ ├── main.cpp
│ └── symbols_obf.yaml
├── Obfuscation/
│ ├── CMakeLists.txt
│ ├── include/
│ │ ├── BogusControlFlow.h
│ │ ├── CryptoUtils.h
│ │ ├── Eigen/
│ │ │ ├── Cholesky
│ │ │ ├── CholmodSupport
│ │ │ ├── Core
│ │ │ ├── Dense
│ │ │ ├── Eigen
│ │ │ ├── Eigenvalues
│ │ │ ├── Geometry
│ │ │ ├── Householder
│ │ │ ├── IterativeLinearSolvers
│ │ │ ├── Jacobi
│ │ │ ├── KLUSupport
│ │ │ ├── LU
│ │ │ ├── MetisSupport
│ │ │ ├── OrderingMethods
│ │ │ ├── PaStiXSupport
│ │ │ ├── PardisoSupport
│ │ │ ├── QR
│ │ │ ├── QtAlignedMalloc
│ │ │ ├── SPQRSupport
│ │ │ ├── SVD
│ │ │ ├── Sparse
│ │ │ ├── SparseCholesky
│ │ │ ├── SparseCore
│ │ │ ├── SparseLU
│ │ │ ├── SparseQR
│ │ │ ├── StdDeque
│ │ │ ├── StdList
│ │ │ ├── StdVector
│ │ │ ├── SuperLUSupport
│ │ │ ├── UmfPackSupport
│ │ │ └── src/
│ │ │ ├── Cholesky/
│ │ │ │ ├── LDLT.h
│ │ │ │ ├── LLT.h
│ │ │ │ └── LLT_LAPACKE.h
│ │ │ ├── CholmodSupport/
│ │ │ │ └── CholmodSupport.h
│ │ │ ├── Core/
│ │ │ │ ├── ArithmeticSequence.h
│ │ │ │ ├── Array.h
│ │ │ │ ├── ArrayBase.h
│ │ │ │ ├── ArrayWrapper.h
│ │ │ │ ├── Assign.h
│ │ │ │ ├── AssignEvaluator.h
│ │ │ │ ├── Assign_MKL.h
│ │ │ │ ├── BandMatrix.h
│ │ │ │ ├── Block.h
│ │ │ │ ├── BooleanRedux.h
│ │ │ │ ├── CommaInitializer.h
│ │ │ │ ├── ConditionEstimator.h
│ │ │ │ ├── CoreEvaluators.h
│ │ │ │ ├── CoreIterators.h
│ │ │ │ ├── CwiseBinaryOp.h
│ │ │ │ ├── CwiseNullaryOp.h
│ │ │ │ ├── CwiseTernaryOp.h
│ │ │ │ ├── CwiseUnaryOp.h
│ │ │ │ ├── CwiseUnaryView.h
│ │ │ │ ├── DenseBase.h
│ │ │ │ ├── DenseCoeffsBase.h
│ │ │ │ ├── DenseStorage.h
│ │ │ │ ├── Diagonal.h
│ │ │ │ ├── DiagonalMatrix.h
│ │ │ │ ├── DiagonalProduct.h
│ │ │ │ ├── Dot.h
│ │ │ │ ├── EigenBase.h
│ │ │ │ ├── ForceAlignedAccess.h
│ │ │ │ ├── Fuzzy.h
│ │ │ │ ├── GeneralProduct.h
│ │ │ │ ├── GenericPacketMath.h
│ │ │ │ ├── GlobalFunctions.h
│ │ │ │ ├── IO.h
│ │ │ │ ├── IndexedView.h
│ │ │ │ ├── Inverse.h
│ │ │ │ ├── Map.h
│ │ │ │ ├── MapBase.h
│ │ │ │ ├── MathFunctions.h
│ │ │ │ ├── MathFunctionsImpl.h
│ │ │ │ ├── Matrix.h
│ │ │ │ ├── MatrixBase.h
│ │ │ │ ├── NestByValue.h
│ │ │ │ ├── NoAlias.h
│ │ │ │ ├── NumTraits.h
│ │ │ │ ├── PartialReduxEvaluator.h
│ │ │ │ ├── PermutationMatrix.h
│ │ │ │ ├── PlainObjectBase.h
│ │ │ │ ├── Product.h
│ │ │ │ ├── ProductEvaluators.h
│ │ │ │ ├── Random.h
│ │ │ │ ├── Redux.h
│ │ │ │ ├── Ref.h
│ │ │ │ ├── Replicate.h
│ │ │ │ ├── Reshaped.h
│ │ │ │ ├── ReturnByValue.h
│ │ │ │ ├── Reverse.h
│ │ │ │ ├── Select.h
│ │ │ │ ├── SelfAdjointView.h
│ │ │ │ ├── SelfCwiseBinaryOp.h
│ │ │ │ ├── Solve.h
│ │ │ │ ├── SolveTriangular.h
│ │ │ │ ├── SolverBase.h
│ │ │ │ ├── StableNorm.h
│ │ │ │ ├── StlIterators.h
│ │ │ │ ├── Stride.h
│ │ │ │ ├── Swap.h
│ │ │ │ ├── Transpose.h
│ │ │ │ ├── Transpositions.h
│ │ │ │ ├── TriangularMatrix.h
│ │ │ │ ├── VectorBlock.h
│ │ │ │ ├── VectorwiseOp.h
│ │ │ │ ├── Visitor.h
│ │ │ │ ├── arch/
│ │ │ │ │ ├── AVX/
│ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ ├── AVX512/
│ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ ├── AltiVec/
│ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ ├── MatrixProduct.h
│ │ │ │ │ │ ├── MatrixProductCommon.h
│ │ │ │ │ │ ├── MatrixProductMMA.h
│ │ │ │ │ │ └── PacketMath.h
│ │ │ │ │ ├── CUDA/
│ │ │ │ │ │ └── Complex.h
│ │ │ │ │ ├── Default/
│ │ │ │ │ │ ├── BFloat16.h
│ │ │ │ │ │ ├── ConjHelper.h
│ │ │ │ │ │ ├── GenericPacketMathFunctions.h
│ │ │ │ │ │ ├── GenericPacketMathFunctionsFwd.h
│ │ │ │ │ │ ├── Half.h
│ │ │ │ │ │ ├── Settings.h
│ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ ├── GPU/
│ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ ├── HIP/
│ │ │ │ │ │ └── hcc/
│ │ │ │ │ │ └── math_constants.h
│ │ │ │ │ ├── MSA/
│ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ └── PacketMath.h
│ │ │ │ │ ├── NEON/
│ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ ├── GeneralBlockPanelKernel.h
│ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ ├── SSE/
│ │ │ │ │ │ ├── Complex.h
│ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ ├── SVE/
│ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ ├── SYCL/
│ │ │ │ │ │ ├── InteropHeaders.h
│ │ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ │ ├── PacketMath.h
│ │ │ │ │ │ ├── SyclMemoryModel.h
│ │ │ │ │ │ └── TypeCasting.h
│ │ │ │ │ └── ZVector/
│ │ │ │ │ ├── Complex.h
│ │ │ │ │ ├── MathFunctions.h
│ │ │ │ │ └── PacketMath.h
│ │ │ │ ├── functors/
│ │ │ │ │ ├── AssignmentFunctors.h
│ │ │ │ │ ├── BinaryFunctors.h
│ │ │ │ │ ├── NullaryFunctors.h
│ │ │ │ │ ├── StlFunctors.h
│ │ │ │ │ ├── TernaryFunctors.h
│ │ │ │ │ └── UnaryFunctors.h
│ │ │ │ ├── products/
│ │ │ │ │ ├── GeneralBlockPanelKernel.h
│ │ │ │ │ ├── GeneralMatrixMatrix.h
│ │ │ │ │ ├── GeneralMatrixMatrixTriangular.h
│ │ │ │ │ ├── GeneralMatrixMatrixTriangular_BLAS.h
│ │ │ │ │ ├── GeneralMatrixMatrix_BLAS.h
│ │ │ │ │ ├── GeneralMatrixVector.h
│ │ │ │ │ ├── GeneralMatrixVector_BLAS.h
│ │ │ │ │ ├── Parallelizer.h
│ │ │ │ │ ├── SelfadjointMatrixMatrix.h
│ │ │ │ │ ├── SelfadjointMatrixMatrix_BLAS.h
│ │ │ │ │ ├── SelfadjointMatrixVector.h
│ │ │ │ │ ├── SelfadjointMatrixVector_BLAS.h
│ │ │ │ │ ├── SelfadjointProduct.h
│ │ │ │ │ ├── SelfadjointRank2Update.h
│ │ │ │ │ ├── TriangularMatrixMatrix.h
│ │ │ │ │ ├── TriangularMatrixMatrix_BLAS.h
│ │ │ │ │ ├── TriangularMatrixVector.h
│ │ │ │ │ ├── TriangularMatrixVector_BLAS.h
│ │ │ │ │ ├── TriangularSolverMatrix.h
│ │ │ │ │ ├── TriangularSolverMatrix_BLAS.h
│ │ │ │ │ └── TriangularSolverVector.h
│ │ │ │ └── util/
│ │ │ │ ├── BlasUtil.h
│ │ │ │ ├── ConfigureVectorization.h
│ │ │ │ ├── Constants.h
│ │ │ │ ├── DisableStupidWarnings.h
│ │ │ │ ├── ForwardDeclarations.h
│ │ │ │ ├── IndexedViewHelper.h
│ │ │ │ ├── IntegralConstant.h
│ │ │ │ ├── MKL_support.h
│ │ │ │ ├── Macros.h
│ │ │ │ ├── Memory.h
│ │ │ │ ├── Meta.h
│ │ │ │ ├── NonMPL2.h
│ │ │ │ ├── ReenableStupidWarnings.h
│ │ │ │ ├── ReshapedHelper.h
│ │ │ │ ├── StaticAssert.h
│ │ │ │ ├── SymbolicIndex.h
│ │ │ │ └── XprHelper.h
│ │ │ ├── Eigenvalues/
│ │ │ │ ├── ComplexEigenSolver.h
│ │ │ │ ├── ComplexSchur.h
│ │ │ │ ├── ComplexSchur_LAPACKE.h
│ │ │ │ ├── EigenSolver.h
│ │ │ │ ├── GeneralizedEigenSolver.h
│ │ │ │ ├── GeneralizedSelfAdjointEigenSolver.h
│ │ │ │ ├── HessenbergDecomposition.h
│ │ │ │ ├── MatrixBaseEigenvalues.h
│ │ │ │ ├── RealQZ.h
│ │ │ │ ├── RealSchur.h
│ │ │ │ ├── RealSchur_LAPACKE.h
│ │ │ │ ├── SelfAdjointEigenSolver.h
│ │ │ │ ├── SelfAdjointEigenSolver_LAPACKE.h
│ │ │ │ └── Tridiagonalization.h
│ │ │ ├── Geometry/
│ │ │ │ ├── AlignedBox.h
│ │ │ │ ├── AngleAxis.h
│ │ │ │ ├── EulerAngles.h
│ │ │ │ ├── Homogeneous.h
│ │ │ │ ├── Hyperplane.h
│ │ │ │ ├── OrthoMethods.h
│ │ │ │ ├── ParametrizedLine.h
│ │ │ │ ├── Quaternion.h
│ │ │ │ ├── Rotation2D.h
│ │ │ │ ├── RotationBase.h
│ │ │ │ ├── Scaling.h
│ │ │ │ ├── Transform.h
│ │ │ │ ├── Translation.h
│ │ │ │ ├── Umeyama.h
│ │ │ │ └── arch/
│ │ │ │ └── Geometry_SIMD.h
│ │ │ ├── Householder/
│ │ │ │ ├── BlockHouseholder.h
│ │ │ │ ├── Householder.h
│ │ │ │ └── HouseholderSequence.h
│ │ │ ├── IterativeLinearSolvers/
│ │ │ │ ├── BasicPreconditioners.h
│ │ │ │ ├── BiCGSTAB.h
│ │ │ │ ├── ConjugateGradient.h
│ │ │ │ ├── IncompleteCholesky.h
│ │ │ │ ├── IncompleteLUT.h
│ │ │ │ ├── IterativeSolverBase.h
│ │ │ │ ├── LeastSquareConjugateGradient.h
│ │ │ │ └── SolveWithGuess.h
│ │ │ ├── Jacobi/
│ │ │ │ └── Jacobi.h
│ │ │ ├── KLUSupport/
│ │ │ │ └── KLUSupport.h
│ │ │ ├── LU/
│ │ │ │ ├── Determinant.h
│ │ │ │ ├── FullPivLU.h
│ │ │ │ ├── InverseImpl.h
│ │ │ │ ├── PartialPivLU.h
│ │ │ │ ├── PartialPivLU_LAPACKE.h
│ │ │ │ └── arch/
│ │ │ │ └── InverseSize4.h
│ │ │ ├── MetisSupport/
│ │ │ │ └── MetisSupport.h
│ │ │ ├── OrderingMethods/
│ │ │ │ ├── Amd.h
│ │ │ │ ├── Eigen_Colamd.h
│ │ │ │ └── Ordering.h
│ │ │ ├── PaStiXSupport/
│ │ │ │ └── PaStiXSupport.h
│ │ │ ├── PardisoSupport/
│ │ │ │ └── PardisoSupport.h
│ │ │ ├── QR/
│ │ │ │ ├── ColPivHouseholderQR.h
│ │ │ │ ├── ColPivHouseholderQR_LAPACKE.h
│ │ │ │ ├── CompleteOrthogonalDecomposition.h
│ │ │ │ ├── FullPivHouseholderQR.h
│ │ │ │ ├── HouseholderQR.h
│ │ │ │ └── HouseholderQR_LAPACKE.h
│ │ │ ├── SPQRSupport/
│ │ │ │ └── SuiteSparseQRSupport.h
│ │ │ ├── SVD/
│ │ │ │ ├── BDCSVD.h
│ │ │ │ ├── JacobiSVD.h
│ │ │ │ ├── JacobiSVD_LAPACKE.h
│ │ │ │ ├── SVDBase.h
│ │ │ │ └── UpperBidiagonalization.h
│ │ │ ├── SparseCholesky/
│ │ │ │ ├── SimplicialCholesky.h
│ │ │ │ └── SimplicialCholesky_impl.h
│ │ │ ├── SparseCore/
│ │ │ │ ├── AmbiVector.h
│ │ │ │ ├── CompressedStorage.h
│ │ │ │ ├── ConservativeSparseSparseProduct.h
│ │ │ │ ├── MappedSparseMatrix.h
│ │ │ │ ├── SparseAssign.h
│ │ │ │ ├── SparseBlock.h
│ │ │ │ ├── SparseColEtree.h
│ │ │ │ ├── SparseCompressedBase.h
│ │ │ │ ├── SparseCwiseBinaryOp.h
│ │ │ │ ├── SparseCwiseUnaryOp.h
│ │ │ │ ├── SparseDenseProduct.h
│ │ │ │ ├── SparseDiagonalProduct.h
│ │ │ │ ├── SparseDot.h
│ │ │ │ ├── SparseFuzzy.h
│ │ │ │ ├── SparseMap.h
│ │ │ │ ├── SparseMatrix.h
│ │ │ │ ├── SparseMatrixBase.h
│ │ │ │ ├── SparsePermutation.h
│ │ │ │ ├── SparseProduct.h
│ │ │ │ ├── SparseRedux.h
│ │ │ │ ├── SparseRef.h
│ │ │ │ ├── SparseSelfAdjointView.h
│ │ │ │ ├── SparseSolverBase.h
│ │ │ │ ├── SparseSparseProductWithPruning.h
│ │ │ │ ├── SparseTranspose.h
│ │ │ │ ├── SparseTriangularView.h
│ │ │ │ ├── SparseUtil.h
│ │ │ │ ├── SparseVector.h
│ │ │ │ ├── SparseView.h
│ │ │ │ └── TriangularSolver.h
│ │ │ ├── SparseLU/
│ │ │ │ ├── SparseLU.h
│ │ │ │ ├── SparseLUImpl.h
│ │ │ │ ├── SparseLU_Memory.h
│ │ │ │ ├── SparseLU_Structs.h
│ │ │ │ ├── SparseLU_SupernodalMatrix.h
│ │ │ │ ├── SparseLU_Utils.h
│ │ │ │ ├── SparseLU_column_bmod.h
│ │ │ │ ├── SparseLU_column_dfs.h
│ │ │ │ ├── SparseLU_copy_to_ucol.h
│ │ │ │ ├── SparseLU_gemm_kernel.h
│ │ │ │ ├── SparseLU_heap_relax_snode.h
│ │ │ │ ├── SparseLU_kernel_bmod.h
│ │ │ │ ├── SparseLU_panel_bmod.h
│ │ │ │ ├── SparseLU_panel_dfs.h
│ │ │ │ ├── SparseLU_pivotL.h
│ │ │ │ ├── SparseLU_pruneL.h
│ │ │ │ └── SparseLU_relax_snode.h
│ │ │ ├── SparseQR/
│ │ │ │ └── SparseQR.h
│ │ │ ├── StlSupport/
│ │ │ │ ├── StdDeque.h
│ │ │ │ ├── StdList.h
│ │ │ │ ├── StdVector.h
│ │ │ │ └── details.h
│ │ │ ├── SuperLUSupport/
│ │ │ │ └── SuperLUSupport.h
│ │ │ ├── UmfPackSupport/
│ │ │ │ └── UmfPackSupport.h
│ │ │ ├── misc/
│ │ │ │ ├── Image.h
│ │ │ │ ├── Kernel.h
│ │ │ │ ├── RealSvd2x2.h
│ │ │ │ ├── blas.h
│ │ │ │ ├── lapack.h
│ │ │ │ ├── lapacke.h
│ │ │ │ └── lapacke_mangling.h
│ │ │ └── plugins/
│ │ │ ├── ArrayCwiseBinaryOps.h
│ │ │ ├── ArrayCwiseUnaryOps.h
│ │ │ ├── BlockMethods.h
│ │ │ ├── CommonCwiseBinaryOps.h
│ │ │ ├── CommonCwiseUnaryOps.h
│ │ │ ├── IndexedViewMethods.h
│ │ │ ├── MatrixCwiseBinaryOps.h
│ │ │ ├── MatrixCwiseUnaryOps.h
│ │ │ └── ReshapedMethods.h
│ │ ├── Flattening.h
│ │ ├── FlatteningEnhanced.h
│ │ ├── FunctionWrapper.h
│ │ ├── IPObfuscationContext.h
│ │ ├── IndirectBranch.h
│ │ ├── IndirectCall.h
│ │ ├── LegacyLowerSwitch.h
│ │ ├── MBAObfuscation.h
│ │ ├── MBAUtils.h
│ │ ├── ObfuscationOptions.h
│ │ ├── SplitBasicBlock.h
│ │ ├── StringEncryption.h
│ │ ├── Utils.h
│ │ ├── VMFlatten.h
│ │ └── compat/
│ │ └── CallSite.h
│ └── src/
│ ├── BogusControlFlow.cpp
│ ├── CryptoUtils.cpp
│ ├── Flattening.cpp
│ ├── FlatteningEnhanced.cpp
│ ├── FunctionWrapper.cpp
│ ├── IPObfuscationContext.cpp
│ ├── IndirectBranch.cpp
│ ├── IndirectCall.cpp
│ ├── LegacyLowerSwitch.cpp
│ ├── MBAObfuscation.cpp
│ ├── MBAUtils.cpp
│ ├── ObfuscationOptions.cpp
│ ├── PMRegistration.cpp
│ ├── SplitBasicBlock.cpp
│ ├── StringEncryption.cpp
│ ├── Utils.cpp
│ └── VMFlatten.cpp
├── README.md
├── demo.sh
└── docs/
├── LLVM_API.md
├── LLVM_IR.md
├── LLVM_Obfuscation.md
└── README.md
Showing preview only (339K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (3868 symbols across 331 files)
FILE: Demo/main.cpp
function add (line 7) | int add(int a, int b) __attribute((__annotate__(("split vmf")))){
function say_hello (line 11) | void say_hello()
function main (line 18) | int main(){
FILE: Obfuscation/include/BogusControlFlow.h
function namespace (line 34) | namespace llvm{ // 基本块分割
FILE: Obfuscation/include/CryptoUtils.h
function namespace (line 25) | namespace llvm {
FILE: Obfuscation/include/Eigen/src/Cholesky/LDLT.h
function namespace (line 16) | namespace Eigen {
type SolverBase (line 64) | typedef SolverBase<LDLT> Base;
function enum (line 67) | EIGEN_GENERIC_PUBLIC_INTERFACE(LDLT)
type Matrix (line 73) | typedef Matrix<Scalar, RowsAtCompileTime, 1, 0, MaxRowsAtCompileTime, 1>...
type Transpositions (line 75) | typedef Transpositions<RowsAtCompileTime, MaxRowsAtCompileTime> Transpos...
type PermutationMatrix (line 76) | typedef PermutationMatrix<RowsAtCompileTime, MaxRowsAtCompileTime> Permu...
type internal (line 78) | typedef internal::LDLT_Traits<MatrixType,UpLo> Traits;
function setZero (line 143) | void setZero()
function typename (line 149) | inline typename Traits::MatrixU matrixU() const
function isNegative (line 185) | inline bool isNegative(void) const
function MatrixType (line 234) | inline const MatrixType& matrixLDLT() const
function namespace (line 293) | namespace internal {
function Upper (line 460) | struct ldlt_inplace<Upper>
type TriangularView (line 480) | typedef const TriangularView<const typename
function MatrixL (line 481) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
function MatrixU (line 482) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoi...
type TriangularView (line 488) | typedef const TriangularView<const MatrixType, UnitUpper> MatrixU;
function MatrixL (line 489) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoi...
function MatrixU (line 490) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
type typename (line 541) | typedef typename TranspositionType::StorageIndex IndexType;
FILE: Obfuscation/include/Eigen/src/Cholesky/LLT.h
function namespace (line 13) | namespace Eigen {
type SolverBase (line 71) | typedef SolverBase<LLT> Base;
function enum (line 74) | EIGEN_GENERIC_PUBLIC_INTERFACE(LLT)
type internal (line 85) | typedef internal::LLT_Traits<MatrixType,UpLo> Traits;
function explicit (line 101) | explicit LLT(Index size) : m_matrix(size, size),
function typename (line 128) | inline typename Traits::MatrixU matrixU() const
function MatrixType (line 177) | inline const MatrixType& matrixLLT() const
function namespace (line 235) | namespace internal {
type typename (line 379) | typedef typename NumTraits<Scalar>::Real RealScalar;
type TriangularView (line 404) | typedef const TriangularView<const typename
function MatrixL (line 405) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m); }
function MatrixU (line 406) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m.adjoi...
function inplace_decomposition (line 407) | static bool inplace_decomposition(MatrixType& m)
type TriangularView (line 414) | typedef const TriangularView<const MatrixType, Upper> MatrixU;
function MatrixL (line 415) | static inline MatrixL getL(const MatrixType& m) { return MatrixL(m.adjoi...
function MatrixU (line 416) | static inline MatrixU getU(const MatrixType& m) { return MatrixU(m); }
function inplace_decomposition (line 417) | static bool inplace_decomposition(MatrixType& m)
FILE: Obfuscation/include/Eigen/src/Cholesky/LLT_LAPACKE.h
function namespace (line 36) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/CholmodSupport/CholmodSupport.h
function namespace (line 13) | namespace Eigen {
function cholmod_sparse (line 105) | cholmod_sparse viewAsCholmod(const SparseMatrix<_Scalar,_Options,_Index>...
function cholmod_sparse (line 112) | cholmod_sparse viewAsCholmod(const SparseVector<_Scalar,_Options,_Index>...
type typename (line 140) | typedef typename Derived::Scalar Scalar;
function namespace (line 165) | namespace internal {
type CholmodMode (line 203) | enum CholmodMode {
type typename (line 223) | typedef typename MatrixType::Scalar Scalar;
type typename (line 224) | typedef typename MatrixType::RealScalar RealScalar;
type MatrixType (line 225) | typedef MatrixType CholMatrixType;
type typename (line 226) | typedef typename MatrixType::StorageIndex StorageIndex;
function StorageIndex (line 258) | inline StorageIndex cols() const { return internal::convert_index<Storag...
function analyzePattern (line 286) | void analyzePattern(const MatrixType& matrix)
function factorize (line 308) | void factorize(const MatrixType& matrix)
function Scalar (line 391) | Scalar determinant() const
function Base (line 488) | CholmodSimplicialLLT(const MatrixType& matrix) : Base()
function Base (line 539) | CholmodSimplicialLDLT(const MatrixType& matrix) : Base()
function Base (line 588) | CholmodSupernodalLLT(const MatrixType& matrix) : Base()
function Base (line 639) | CholmodDecomposition(const MatrixType& matrix) : Base()
function setMode (line 647) | void setMode(CholmodMode mode)
FILE: Obfuscation/include/Eigen/src/Core/ArithmeticSequence.h
function namespace (line 13) | namespace Eigen {
function namespace (line 399) | namespace indexing {
FILE: Obfuscation/include/Eigen/src/Core/Array.h
function namespace (line 13) | namespace Eigen {
function enum (line 51) | EIGEN_DENSE_PUBLIC_INTERFACE(Array)
function EIGEN_DEVICE_FUNC (line 141) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 151) | EIGEN_DEVICE_FUNC
function EIGEN_STRONG_INLINE (line 175) | EIGEN_STRONG_INLINE
function EIGEN_STRONG_INLINE (line 207) | EIGEN_STRONG_INLINE explicit Array(const T& x)
function EIGEN_STRONG_INLINE (line 215) | EIGEN_STRONG_INLINE Array(const T0& val0, const T1& val1)
function Base (line 274) | Array(const Array& other)
type PrivateType (line 279) | struct PrivateType {}
function EIGEN_STRONG_INLINE (line 285) | EIGEN_STRONG_INLINE Array(const EigenBase<OtherDerived> &other,
type internal (line 303) | struct internal
FILE: Obfuscation/include/Eigen/src/Core/ArrayBase.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/ArrayWrapper.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/Assign.h
function namespace (line 15) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/AssignEvaluator.h
function namespace (line 15) | namespace Eigen {
function run (line 245) | void run(Kernel& kernel)
type typename (line 266) | typedef typename Kernel::DstEvaluatorType DstEvaluatorType;
type typename (line 267) | typedef typename DstEvaluatorType::XprType DstXprType;
type typename (line 268) | typedef typename Kernel::PacketType PacketType;
function run (line 277) | void run(Kernel &kernel)
type typename (line 294) | typedef typename Kernel::PacketType PacketType;
function run (line 295) | void run(Kernel &kernel, Index outer)
type typename (line 330) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 358) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 368) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type unaligned_dense_assignment_loop (line 393) | struct unaligned_dense_assignment_loop
type typename (line 421) | typedef typename Kernel::Scalar Scalar;
type typename (line 422) | typedef typename Kernel::PacketType PacketType;
type typename (line 448) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 449) | typedef typename Kernel::PacketType PacketType;
function run (line 472) | void run(Kernel &kernel)
type typename (line 488) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 498) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 499) | typedef typename Kernel::AssignmentTraits Traits;
type typename (line 527) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 541) | typedef typename Kernel::Scalar Scalar;
type typename (line 542) | typedef typename Kernel::PacketType PacketType;
type typename (line 589) | typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
type typename (line 590) | typedef typename Kernel::PacketType PacketType;
type typename (line 622) | typedef typename SrcEvaluatorTypeT::XprType SrcXprType;
type SrcEvaluatorTypeT (line 626) | typedef SrcEvaluatorTypeT SrcEvaluatorType;
type typename (line 627) | typedef typename DstEvaluatorType::Scalar Scalar;
type copy_using_evaluator_traits (line 628) | typedef copy_using_evaluator_traits<DstEvaluatorTypeT, SrcEvaluatorTypeT...
type typename (line 629) | typedef typename AssignmentTraits::PacketType PacketType;
function EIGEN_DEVICE_FUNC (line 648) | EIGEN_DEVICE_FUNC DstEvaluatorType& dstEvaluator() EIGEN_NOEXCEPT { retu...
function EIGEN_DEVICE_FUNC (line 649) | EIGEN_DEVICE_FUNC const SrcEvaluatorType& srcEvaluator() const EIGEN_NOE...
function assignCoeff (line 658) | void assignCoeff(Index index)
function assignCoeffByOuterInner (line 664) | void assignCoeffByOuterInner(Index outer, Index inner)
function assignPacket (line 673) | void assignPacket(Index row, Index col)
function assignPacket (line 679) | void assignPacket(Index index)
function assignPacketByOuterInner (line 685) | void assignPacketByOuterInner(Index outer, Index inner)
function Index (line 692) | Index rowIndexByOuterInner(Index outer, Index inner)
function Index (line 701) | Index colIndexByOuterInner(Index outer, Index inner)
function EIGEN_DEVICE_FUNC (line 710) | EIGEN_DEVICE_FUNC const Scalar* dstDataPtr() const
type typename (line 734) | typedef typename Base::DstXprType DstXprType;
type copy_using_evaluator_traits (line 735) | typedef copy_using_evaluator_traits<DstEvaluatorTypeT, SrcEvaluatorTypeT...
type typename (line 736) | typedef typename AssignmentTraits::PacketType PacketType;
function EIGEN_DEVICE_FUNC (line 738) | EIGEN_DEVICE_FUNC restricted_packet_dense_assignment_kernel(DstEvaluator...
function resize_if_allowed (line 750) | void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const Fun...
type evaluator (line 772) | typedef evaluator<SrcXprType> SrcEvaluatorType;
type generic_dense_assignment_kernel (line 782) | typedef generic_dense_assignment_kernel<DstEvaluatorType,SrcEvaluatorTyp...
function call_dense_assignment_loop (line 791) | void call_dense_assignment_loop(DstXprType& dst, const Eigen::CwiseNulla...
function call_dense_assignment_loop (line 799) | void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src)
type Dense2Dense (line 814) | struct Dense2Dense {}
type EigenBase2EigenBase (line 815) | struct EigenBase2EigenBase {}
type EigenBase2EigenBase (line 817) | typedef EigenBase2EigenBase Kind;
type AssignmentKind (line 818) | struct AssignmentKind
type Dense2Dense (line 818) | typedef Dense2Dense Kind;
function call_assignment (line 834) | void call_assignment(Dst& dst, const Src& src)
function call_assignment (line 840) | void call_assignment(const Dst& dst, const Src& src)
function call_assignment_no_alias (line 873) | void call_assignment_no_alias(Dst& dst, const Src& src, const Func& func)
function call_restricted_packet_assignment_no_alias (line 895) | void call_restricted_packet_assignment_no_alias(Dst& dst, const Src& src...
function call_assignment_no_alias (line 915) | void call_assignment_no_alias(Dst& dst, const Src& src)
function call_assignment_no_alias_no_transpose (line 922) | void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src, con...
function call_assignment_no_alias_no_transpose (line 933) | void call_assignment_no_alias_no_transpose(Dst& dst, const Src& src)
type Assignment (line 963) | struct Assignment
FILE: Obfuscation/include/Eigen/src/Core/Assign_MKL.h
function namespace (line 37) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/BandMatrix.h
function namespace (line 13) | namespace Eigen {
type typename (line 103) | typedef typename internal::conditional<Conjugate,
function typename (line 115) | const typename DiagonalIntReturnType<N>::Type diagonal() const
function DenseMatrixType (line 145) | DenseMatrixType toDenseMatrix() const
type Dense (line 181) | typedef Dense StorageKind;
type Eigen (line 182) | typedef Eigen::Index StorageIndex;
type Matrix (line 195) | typedef Matrix<Scalar, DataRowsAtCompileTime, ColsAtCompileTime, int(Opt...
type typename (line 203) | typedef typename internal::traits<BandMatrix>::Scalar Scalar;
type typename (line 204) | typedef typename internal::traits<BandMatrix>::StorageIndex StorageIndex;
type typename (line 205) | typedef typename internal::traits<BandMatrix>::CoefficientsType Coeffici...
function CoefficientsType (line 226) | inline CoefficientsType& coeffs() { return m_coeffs; }
type typename (line 243) | typedef typename _CoefficientsType::StorageKind StorageKind;
type typename (line 244) | typedef typename _CoefficientsType::StorageIndex StorageIndex;
type _CoefficientsType (line 257) | typedef _CoefficientsType CoefficientsType;
type typename (line 266) | typedef typename internal::traits<BandMatrixWrapper>::CoefficientsType C...
type typename (line 267) | typedef typename internal::traits<BandMatrixWrapper>::StorageIndex Stora...
type typename (line 315) | typedef typename Base::StorageIndex StorageIndex;
type BandShape (line 331) | struct BandShape {}
type AssignmentKind (line 347) | struct AssignmentKind
type EigenBase2EigenBase (line 347) | typedef EigenBase2EigenBase Kind;
FILE: Obfuscation/include/Eigen/src/Core/Block.h
function namespace (line 14) | namespace Eigen {
type typename (line 158) | typedef typename XprType::StorageIndex StorageIndex;
function EIGEN_STRONG_INLINE (line 162) | EIGEN_STRONG_INLINE BlockImpl(XprType& xpr, Index i) : Impl(xpr,i) {}
function namespace (line 169) | namespace internal {
FILE: Obfuscation/include/Eigen/src/Core/BooleanRedux.h
function namespace (line 13) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 51) | EIGEN_DEVICE_FUNC static inline bool run(const Derived &mat)
function run (line 60) | static inline bool run(const Derived & /*mat*/) { return false; }
function run (line 66) | static inline bool run(const Derived &) { return false; }
function all (line 79) | inline bool DenseBase<Derived>::all() const
function any (line 103) | inline bool DenseBase<Derived>::any() const
FILE: Obfuscation/include/Eigen/src/Core/CommaInitializer.h
function namespace (line 14) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 120) | EIGEN_DEVICE_FUNC
FILE: Obfuscation/include/Eigen/src/Core/ConditionEstimator.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/CoreEvaluators.h
function namespace (line 16) | namespace Eigen {
type typename (line 167) | typedef typename PlainObjectType::Scalar Scalar;
type typename (line 168) | typedef typename PlainObjectType::CoeffReturnType CoeffReturnType;
function explicit (line 195) | explicit evaluator(const PlainObjectType& m)
function CoeffReturnType (line 202) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 211) | CoeffReturnType coeff(Index index) const
function PacketType (line 233) | PacketType packet(Index row, Index col) const
function PacketType (line 243) | PacketType packet(Index index) const
function writePacket (line 250) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 262) | void writePacket(Index index, const PacketType& x)
function EIGEN_DEVICE_FUNC (line 278) | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
function explicit (line 282) | explicit evaluator(const XprType& m)
function EIGEN_DEVICE_FUNC (line 293) | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
function explicit (line 297) | explicit evaluator(const XprType& m)
function explicit (line 317) | explicit unary_evaluator(const XprType& t) : m_argImpl(t.nestedExpressio...
type typename (line 319) | typedef typename XprType::Scalar Scalar;
type typename (line 320) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 323) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 329) | CoeffReturnType coeff(Index index) const
function typename (line 341) | typename XprType::Scalar& coeffRef(Index index)
function PacketType (line 348) | PacketType packet(Index row, Index col) const
function PacketType (line 355) | PacketType packet(Index index) const
function writePacket (line 362) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 369) | void writePacket(Index index, const PacketType& x)
function EIGEN_STRONG_INLINE (line 391) | EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) ...
function EIGEN_STRONG_INLINE (line 393) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexTy...
function EIGEN_STRONG_INLINE (line 394) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const {...
function EIGEN_STRONG_INLINE (line 424) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexTy...
function EIGEN_STRONG_INLINE (line 430) | EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) ...
function EIGEN_STRONG_INLINE (line 432) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const {...
function EIGEN_STRONG_INLINE (line 472) | EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) ...
function EIGEN_STRONG_INLINE (line 480) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexTy...
function EIGEN_STRONG_INLINE (line 487) | EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const {
type typename (line 501) | typedef typename internal::remove_all<PlainObjectType>::type PlainObject...
function EIGEN_DEVICE_FUNC (line 514) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& n)
type typename (line 520) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function EIGEN_STRONG_INLINE (line 523) | EIGEN_STRONG_INLINE
function EIGEN_STRONG_INLINE (line 530) | EIGEN_STRONG_INLINE
function PacketType (line 538) | PacketType packet(IndexType row, IndexType col) const
function PacketType (line 545) | PacketType packet(IndexType index) const
function explicit (line 572) | explicit unary_evaluator(const XprType& op) : m_d(op)
type typename (line 578) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 581) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 587) | CoeffReturnType coeff(Index index) const
function PacketType (line 594) | PacketType packet(Index row, Index col) const
function PacketType (line 601) | PacketType packet(Index index) const
type Data (line 609) | struct Data
type ternary_evaluator (line 630) | typedef ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> > ...
function EIGEN_DEVICE_FUNC (line 632) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : Base(xpr) {}
function EIGEN_DEVICE_FUNC (line 663) | EIGEN_DEVICE_FUNC explicit ternary_evaluator(const XprType& xpr) : m_d(xpr)
type typename (line 669) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 672) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 678) | CoeffReturnType coeff(Index index) const
function PacketType (line 685) | PacketType packet(Index row, Index col) const
function PacketType (line 694) | PacketType packet(Index index) const
type Data (line 703) | struct Data
type binary_evaluator (line 726) | typedef binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs> > Base;
function explicit (line 729) | explicit evaluator(const XprType& xpr) : Base(xpr) {}
function explicit (line 758) | explicit binary_evaluator(const XprType& xpr) : m_d(xpr)
type typename (line 764) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 767) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 773) | CoeffReturnType coeff(Index index) const
function PacketType (line 780) | PacketType packet(Index row, Index col) const
function PacketType (line 788) | PacketType packet(Index index) const
type Data (line 797) | struct Data
function EIGEN_DEVICE_FUNC (line 827) | EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op) : m_d(op)
type typename (line 833) | typedef typename XprType::Scalar Scalar;
type typename (line 834) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 837) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 843) | CoeffReturnType coeff(Index index) const
type Data (line 863) | struct Data
type Derived (line 886) | typedef Derived XprType;
type typename (line 887) | typedef typename XprType::PointerType PointerType;
type typename (line 888) | typedef typename XprType::Scalar Scalar;
type typename (line 889) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 909) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 915) | CoeffReturnType coeff(Index index) const
function PacketType (line 934) | PacketType packet(Index row, Index col) const
function PacketType (line 942) | PacketType packet(Index index) const
function writePacket (line 949) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 957) | void writePacket(Index index, const PacketType& x)
function EIGEN_CONSTEXPR (line 962) | EIGEN_CONSTEXPR
function explicit (line 1093) | explicit block_evaluator(const XprType& block)
function CoeffReturnType (line 1121) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 1127) | CoeffReturnType coeff(Index index) const
function PacketType (line 1146) | PacketType packet(Index row, Index col) const
function PacketType (line 1153) | PacketType packet(Index index) const
function writePacket (line 1164) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 1171) | void writePacket(Index index, const PacketType& x)
function CoeffReturnType (line 1183) | CoeffReturnType linear_coeff_impl(Index index, internal::true_type /* Fo...
function CoeffReturnType (line 1188) | CoeffReturnType linear_coeff_impl(Index index, internal::false_type /* n...
type typename (line 1219) | typedef typename XprType::Scalar Scalar;
function explicit (line 1222) | explicit block_evaluator(const XprType& block)
type typename (line 1259) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 1262) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 1271) | CoeffReturnType coeff(Index index) const
type typename (line 1293) | typedef typename XprType::CoeffReturnType CoeffReturnType;
type typename (line 1297) | typedef typename internal::nested_eval<ArgType,Factor>::type ArgTypeNested;
type typename (line 1298) | typedef typename internal::remove_all<ArgTypeNested>::type ArgTypeNested...
function CoeffReturnType (line 1331) | CoeffReturnType coeff(Index index) const
function PacketType (line 1343) | PacketType packet(Index row, Index col) const
function PacketType (line 1357) | PacketType packet(Index index) const
type typename (line 1382) | typedef typename remove_all<typename XprType::NestedExpressionType>::typ...
function explicit (line 1390) | explicit evaluator_wrapper_base(const ArgType& arg) : m_argImpl(arg) {}
type typename (line 1392) | typedef typename ArgType::Scalar Scalar;
type typename (line 1393) | typedef typename ArgType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 1396) | CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 1402) | CoeffReturnType coeff(Index index) const
function PacketType (line 1421) | PacketType packet(Index row, Index col) const
function PacketType (line 1428) | PacketType packet(Index index) const
function writePacket (line 1435) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 1442) | void writePacket(Index index, const PacketType& x)
function explicit (line 1458) | explicit unary_evaluator(const XprType& wrapper)
function explicit (line 1470) | explicit unary_evaluator(const XprType& wrapper)
type typename (line 1486) | typedef typename XprType::Scalar Scalar;
type typename (line 1487) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 1527) | CoeffReturnType coeff(Index index) const
function PacketType (line 1547) | PacketType packet(Index row, Index col) const
function PacketType (line 1562) | PacketType packet(Index index) const
function writePacket (line 1570) | void writePacket(Index row, Index col, const PacketType& x)
function writePacket (line 1587) | void writePacket(Index index, const PacketType& x)
function explicit (line 1621) | explicit evaluator(const XprType& diagonal)
type typename (line 1626) | typedef typename XprType::Scalar Scalar;
type typename (line 1627) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function CoeffReturnType (line 1630) | CoeffReturnType coeff(Index row, Index) const
function CoeffReturnType (line 1636) | CoeffReturnType coeff(Index index) const
function EvalToTemp (line 1687) | EIGEN_GENERIC_PUBLIC_INTERFACE(EvalToTemp)
type typename (line 1717) | typedef typename ArgType::PlainObject PlainObject;
type evaluator (line 1718) | typedef evaluator<PlainObject> Base;
function EIGEN_DEVICE_FUNC (line 1720) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
function EIGEN_DEVICE_FUNC (line 1727) | EIGEN_DEVICE_FUNC evaluator(const ArgType& arg)
FILE: Obfuscation/include/Eigen/src/Core/CoreIterators.h
function namespace (line 13) | namespace Eigen {
function namespace (line 75) | namespace internal {
FILE: Obfuscation/include/Eigen/src/Core/CwiseBinaryOp.h
function namespace (line 14) | namespace Eigen {
type typename (line 88) | typedef typename internal::remove_all<LhsType>::type Lhs;
type typename (line 89) | typedef typename internal::remove_all<RhsType>::type Rhs;
type typename (line 91) | typedef typename CwiseBinaryOpImpl<
type typename (line 99) | typedef typename internal::ref_selector<RhsType>::type RhsNested;
type typename (line 100) | typedef typename internal::remove_reference<LhsNested>::type _LhsNested;
type typename (line 101) | typedef typename internal::remove_reference<RhsNested>::type _RhsNested;
FILE: Obfuscation/include/Eigen/src/Core/CwiseNullaryOp.h
function namespace (line 13) | namespace Eigen {
function EIGEN_STATIC_ASSERT_FIXED_SIZE (line 302) | EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
function fill (line 335) | void DenseBase<Derived>::fill(const Scalar& val)
function namespace (line 838) | namespace internal {
FILE: Obfuscation/include/Eigen/src/Core/CwiseTernaryOp.h
function namespace (line 15) | namespace Eigen {
type typename (line 91) | typedef typename internal::remove_all<Arg2Type>::type Arg2;
type typename (line 92) | typedef typename internal::remove_all<Arg3Type>::type Arg3;
type typename (line 94) | typedef typename CwiseTernaryOpImpl<
type typename (line 100) | typedef typename internal::ref_selector<Arg2Type>::type Arg2Nested;
type typename (line 101) | typedef typename internal::ref_selector<Arg3Type>::type Arg3Nested;
type typename (line 102) | typedef typename internal::remove_reference<Arg1Nested>::type _Arg1Nested;
type typename (line 103) | typedef typename internal::remove_reference<Arg2Nested>::type _Arg2Nested;
type typename (line 104) | typedef typename internal::remove_reference<Arg3Nested>::type _Arg3Nested;
FILE: Obfuscation/include/Eigen/src/Core/CwiseUnaryOp.h
function namespace (line 14) | namespace Eigen {
type typename (line 62) | typedef typename internal::remove_all<XprType>::type NestedExpression;
function typename (line 84) | typename internal::remove_all<XprTypeNested>::type&
FILE: Obfuscation/include/Eigen/src/Core/CwiseUnaryView.h
function namespace (line 13) | namespace Eigen {
type typename (line 65) | typedef typename internal::remove_all<MatrixType>::type NestedExpression;
type typename (line 109) | typedef typename internal::dense_xpr_base< CwiseUnaryView<ViewOp, Matrix...
function EIGEN_INHERIT_ASSIGNMENT_OPERATORS (line 111) | EIGEN_DENSE_PUBLIC_INTERFACE(Derived)
FILE: Obfuscation/include/Eigen/src/Core/DenseBase.h
function namespace (line 16) | namespace internal {
type typename (line 55) | typedef typename internal::traits<Derived>::StorageKind StorageKind;
type typename (line 63) | typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
type typename (line 66) | typedef typename internal::traits<Derived>::Scalar Scalar;
type Scalar (line 71) | typedef Scalar value_type;
type typename (line 73) | typedef typename NumTraits<Scalar>::Real RealScalar;
type DenseCoeffsBase (line 74) | typedef DenseCoeffsBase<Derived, internal::accessors_level<Derived>::val...
type typename (line 96) | typedef typename Base::CoeffReturnType CoeffReturnType;
type typename (line 179) | typedef typename internal::find_best_packet<Scalar,SizeAtCompileTime>::t...
type Matrix (line 185) | typedef Matrix<typename
type Array (line 195) | typedef Array<typename
type typename (line 209) | typedef typename internal::conditional<internal::is_same<typename
function EIGEN_DEVICE_FUNC (line 245) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 256) | EIGEN_DEVICE_FUNC
type CwiseNullaryOp (line 267) | typedef CwiseNullaryOp<internal::scalar_constant_op<Scalar>,PlainObject>...
type CwiseNullaryOp (line 271) | typedef CwiseNullaryOp<internal::linspaced_op<Scalar>,PlainObject> Rando...
type Matrix (line 273) | typedef Matrix<typename
type Transpose (line 324) | typedef Transpose<Derived> TransposeReturnType;
type typename (line 327) | typedef typename internal::add_const<Transpose<const Derived> >::type Co...
FILE: Obfuscation/include/Eigen/src/Core/DenseCoeffsBase.h
function namespace (line 13) | namespace Eigen {
type typename (line 486) | typedef typename internal::traits<Derived>::Scalar Scalar;
type typename (line 487) | typedef typename NumTraits<Scalar>::Real RealScalar;
function EIGEN_CONSTEXPR (line 516) | EIGEN_CONSTEXPR inline Index stride() const
function Index (line 585) | inline Index outerStride() const EIGEN_NOEXCEPT
function Index (line 601) | inline Index rowStride() const EIGEN_NOEXCEPT
function Index (line 643) | inline Index first_aligned(const DenseBase<Derived>& m)
function Index (line 650) | inline Index first_default_aligned(const DenseBase<Derived>& m)
FILE: Obfuscation/include/Eigen/src/Core/DenseStorage.h
function namespace (line 21) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 125) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 132) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 144) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 151) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 162) | EIGEN_DEVICE_FUNC plain_array() {}
function EIGEN_DEVICE_FUNC (line 163) | EIGEN_DEVICE_FUNC plain_array(constructor_without_unaligned_array_assert...
type plain_array_helper (line 166) | struct plain_array_helper {
function EIGEN_DEVICE_FUNC (line 218) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 237) | EIGEN_DEVICE_FUNC DenseStorage(DenseStorage&& other) EIGEN_NOEXCEPT
function EIGEN_DEVICE_FUNC (line 252) | EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) {
function Index (line 262) | Index rows(void) EIGEN_NOEXCEPT {return _Rows;}
function Index (line 263) | Index cols(void) EIGEN_NOEXCEPT {return _Cols;}
function EIGEN_DEVICE_FUNC (line 264) | EIGEN_DEVICE_FUNC void conservativeResize(Index,Index,Index) {}
function EIGEN_DEVICE_FUNC (line 265) | EIGEN_DEVICE_FUNC void resize(Index,Index,Index) {}
function EIGEN_DEVICE_FUNC (line 266) | EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 267) | EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 274) | EIGEN_DEVICE_FUNC DenseStorage() {}
function EIGEN_DEVICE_FUNC (line 275) | EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_un...
function EIGEN_DEVICE_FUNC (line 276) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage&) {}
function EIGEN_DEVICE_FUNC (line 278) | EIGEN_DEVICE_FUNC DenseStorage(Index,Index,Index) {}
function EIGEN_DEVICE_FUNC (line 323) | EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index cols) : m_rows(r...
function EIGEN_DEVICE_FUNC (line 332) | EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index cols)...
function EIGEN_DEVICE_FUNC (line 333) | EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index cols) { m_rows = ...
function EIGEN_DEVICE_FUNC (line 334) | EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 335) | EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 345) | EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_un...
function EIGEN_DEVICE_FUNC (line 347) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
function EIGEN_DEVICE_FUNC (line 362) | EIGEN_DEVICE_FUNC DenseStorage(Index, Index rows, Index) : m_rows(rows) {}
function EIGEN_DEVICE_FUNC (line 368) | EIGEN_DEVICE_FUNC Index rows(void) const EIGEN_NOEXCEPT {return m_rows;}
function Index (line 369) | Index cols(void) const EIGEN_NOEXCEPT {return _Cols;}
function EIGEN_DEVICE_FUNC (line 370) | EIGEN_DEVICE_FUNC void conservativeResize(Index, Index rows, Index) { m_...
function EIGEN_DEVICE_FUNC (line 371) | EIGEN_DEVICE_FUNC void resize(Index, Index rows, Index) { m_rows = rows; }
function EIGEN_DEVICE_FUNC (line 372) | EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 373) | EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 383) | EIGEN_DEVICE_FUNC explicit DenseStorage(internal::constructor_without_un...
function EIGEN_DEVICE_FUNC (line 385) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
function EIGEN_DEVICE_FUNC (line 399) | EIGEN_DEVICE_FUNC DenseStorage(Index, Index, Index cols) : m_cols(cols) {}
function Index (line 404) | Index rows(void) const EIGEN_NOEXCEPT {return _Rows;}
function EIGEN_DEVICE_FUNC (line 405) | EIGEN_DEVICE_FUNC Index cols(void) const EIGEN_NOEXCEPT {return m_cols;}
function EIGEN_DEVICE_FUNC (line 406) | EIGEN_DEVICE_FUNC void conservativeResize(Index, Index, Index cols) { m_...
function EIGEN_DEVICE_FUNC (line 407) | EIGEN_DEVICE_FUNC void resize(Index, Index, Index cols) { m_cols = cols; }
function EIGEN_DEVICE_FUNC (line 408) | EIGEN_DEVICE_FUNC const T *data() const { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 409) | EIGEN_DEVICE_FUNC T *data() { return m_data.array; }
function EIGEN_DEVICE_FUNC (line 465) | EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete...
function EIGEN_DEVICE_FUNC (line 472) | EIGEN_DEVICE_FUNC Index rows(void) const EIGEN_NOEXCEPT {return m_rows;}
function EIGEN_DEVICE_FUNC (line 473) | EIGEN_DEVICE_FUNC Index cols(void) const EIGEN_NOEXCEPT {return m_cols;}
function conservativeResize (line 474) | void conservativeResize(Index size, Index rows, Index cols)
function EIGEN_DEVICE_FUNC (line 480) | EIGEN_DEVICE_FUNC void resize(Index size, Index rows, Index cols)
function EIGEN_DEVICE_FUNC (line 494) | EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
function EIGEN_DEVICE_FUNC (line 495) | EIGEN_DEVICE_FUNC T *data() { return m_data; }
function explicit (line 505) | explicit DenseStorage(internal::constructor_without_unaligned_array_asse...
function EIGEN_DEVICE_FUNC (line 506) | EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) : m_d...
function EIGEN_DEVICE_FUNC (line 512) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
function EIGEN_DEVICE_FUNC (line 529) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 545) | EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete...
function Index (line 550) | Index rows(void) EIGEN_NOEXCEPT {return _Rows;}
function EIGEN_DEVICE_FUNC (line 551) | EIGEN_DEVICE_FUNC Index cols(void) const EIGEN_NOEXCEPT {return m_cols;}
function EIGEN_DEVICE_FUNC (line 552) | EIGEN_DEVICE_FUNC void conservativeResize(Index size, Index, Index cols)
function resize (line 557) | void resize(Index size, Index, Index cols)
function EIGEN_DEVICE_FUNC (line 570) | EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
function EIGEN_DEVICE_FUNC (line 571) | EIGEN_DEVICE_FUNC T *data() { return m_data; }
function explicit (line 581) | explicit DenseStorage(internal::constructor_without_unaligned_array_asse...
function EIGEN_DEVICE_FUNC (line 582) | EIGEN_DEVICE_FUNC DenseStorage(Index size, Index rows, Index cols) : m_d...
function EIGEN_DEVICE_FUNC (line 588) | EIGEN_DEVICE_FUNC DenseStorage(const DenseStorage& other)
function EIGEN_DEVICE_FUNC (line 605) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 621) | EIGEN_DEVICE_FUNC ~DenseStorage() { internal::conditional_aligned_delete...
function EIGEN_DEVICE_FUNC (line 626) | EIGEN_DEVICE_FUNC Index rows(void) const EIGEN_NOEXCEPT {return m_rows;}
function Index (line 627) | Index cols(void) {return _Cols;}
function conservativeResize (line 628) | void conservativeResize(Index size, Index rows, Index)
function resize (line 633) | void resize(Index size, Index rows, Index)
function EIGEN_DEVICE_FUNC (line 646) | EIGEN_DEVICE_FUNC const T *data() const { return m_data; }
function EIGEN_DEVICE_FUNC (line 647) | EIGEN_DEVICE_FUNC T *data() { return m_data; }
FILE: Obfuscation/include/Eigen/src/Core/Diagonal.h
function namespace (line 14) | namespace Eigen {
type typename (line 69) | typedef typename internal::dense_xpr_base<Diagonal>::type Base;
function explicit (line 73) | explicit inline Diagonal(MatrixType& matrix, Index a_index = DiagIndex) ...
type typename (line 98) | typedef typename internal::conditional<
function EIGEN_DEVICE_FUNC (line 104) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 106) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 109) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 116) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 122) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 128) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 135) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 141) | EIGEN_DEVICE_FUNC
FILE: Obfuscation/include/Eigen/src/Core/DiagonalMatrix.h
function namespace (line 14) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 162) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 166) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 170) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 174) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 178) | EIGEN_DEVICE_FUNC
function EIGEN_STRONG_INLINE (line 193) | EIGEN_STRONG_INLINE
function EIGEN_STRONG_INLINE (line 201) | EIGEN_STRONG_INLINE DiagonalMatrix(const std::initializer_list<std::init...
function m_diagonal (line 208) | inline DiagonalMatrix(const DiagonalBase<OtherDerived>& other) : m_diago...
function m_diagonal (line 212) | inline DiagonalMatrix(const DiagonalMatrix& other) : m_diagonal(other.di...
function explicit (line 218) | explicit inline DiagonalMatrix(const MatrixBase<OtherDerived>& other) : ...
function EIGEN_DEVICE_FUNC (line 243) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 246) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 249) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 252) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 255) | EIGEN_DEVICE_FUNC
function namespace (line 273) | namespace internal {
type _DiagonalVectorType (line 298) | typedef _DiagonalVectorType DiagonalVectorType;
type DiagonalWrapper (line 299) | typedef DiagonalWrapper Nested;
function m_diagonal (line 304) | inline DiagonalWrapper(DiagonalVectorType& a_diagonal) : m_diagonal(a_di...
function DiagonalWrapper (line 324) | inline const DiagonalWrapper<const Derived>
function namespace (line 357) | namespace internal {
function run (line 383) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
FILE: Obfuscation/include/Eigen/src/Core/DiagonalProduct.h
function namespace (line 14) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/Dot.h
function namespace (line 13) | namespace Eigen {
type internal (line 78) | typedef internal::scalar_conj_product_op<Scalar,typename
type typename (line 126) | typedef typename internal::nested_eval<Derived,2>::type _Nested;
type typename (line 169) | typedef typename internal::nested_eval<Derived,3>::type _Nested;
function namespace (line 201) | namespace internal {
FILE: Obfuscation/include/Eigen/src/Core/EigenBase.h
function namespace (line 14) | namespace Eigen {
function Index (line 60) | inline Index rows() const EIGEN_NOEXCEPT { return derived().rows(); }
function addTo (line 78) | inline void addTo(Dest& dst) const
function subTo (line 90) | inline void subTo(Dest& dst) const
function applyThisOnTheRight (line 101) | inline void applyThisOnTheRight(Dest& dst) const
function applyThisOnTheLeft (line 110) | inline void applyThisOnTheLeft(Dest& dst) const
FILE: Obfuscation/include/Eigen/src/Core/ForceAlignedAccess.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/Fuzzy.h
function namespace (line 14) | namespace Eigen {
function typename (line 65) | typename Derived::RealScalar& prec)
function EIGEN_DEVICE_FUNC (line 74) | EIGEN_DEVICE_FUNC
FILE: Obfuscation/include/Eigen/src/Core/GeneralProduct.h
function namespace (line 14) | namespace Eigen {
type product_type_selector (line 103) | struct product_type_selector
type product_type_selector (line 104) | struct product_type_selector
type product_type_selector (line 105) | struct product_type_selector
type product_type_selector (line 106) | struct product_type_selector
type product_type_selector (line 107) | struct product_type_selector
type product_type_selector (line 108) | struct product_type_selector
type product_type_selector (line 109) | struct product_type_selector
type product_type_selector (line 110) | struct product_type_selector
type product_type_selector (line 111) | struct product_type_selector
type product_type_selector (line 112) | struct product_type_selector
type product_type_selector (line 113) | struct product_type_selector
type product_type_selector (line 114) | struct product_type_selector
type product_type_selector (line 115) | struct product_type_selector
type product_type_selector (line 116) | struct product_type_selector
type product_type_selector (line 117) | struct product_type_selector
type product_type_selector (line 118) | struct product_type_selector
type product_type_selector (line 119) | struct product_type_selector
type product_type_selector (line 120) | struct product_type_selector
type product_type_selector (line 121) | struct product_type_selector
type product_type_selector (line 122) | struct product_type_selector
function namespace (line 152) | namespace internal {
function namespace (line 159) | namespace internal {
function EIGEN_STRONG_INLINE (line 184) | EIGEN_STRONG_INLINE Scalar* data() { return m_data.array; }
function EIGEN_STRONG_INLINE (line 189) | EIGEN_STRONG_INLINE Scalar* data() {
type gemv_dense_selector (line 211) | struct gemv_dense_selector
function run (line 214) | inline void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typena...
type gemv_dense_selector (line 304) | struct gemv_dense_selector
function run (line 307) | void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest...
type gemv_dense_selector (line 356) | struct gemv_dense_selector
function run (line 359) | void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest...
type gemv_dense_selector (line 370) | struct gemv_dense_selector
function run (line 373) | void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest...
FILE: Obfuscation/include/Eigen/src/Core/GenericPacketMath.h
function namespace (line 14) | namespace Eigen {
function Packet (line 466) | inline Packet run(const Packet& a, const Packet& b, Op op) {
function PropagateNaN (line 474) | struct pminmax_impl<PropagateNaN> {
function PropagateNumbers (line 489) | struct pminmax_impl<PropagateNumbers> {
function Packet (line 511) | inline Packet
function Packet (line 517) | inline Packet pmin(const Packet& a, const Packet& b) {
function Packet (line 523) | inline Packet
function Packet (line 529) | inline Packet pmax(const Packet& a, const Packet& b) {
function Packet (line 534) | inline Packet
function pabs (line 536) | inline unsigned int
function pabs (line 538) | inline unsigned long
function pabs (line 540) | inline unsigned long long
function Packet (line 544) | inline Packet
function Packet (line 550) | inline Packet
function parithmetic_shift_right (line 555) | inline int
function parithmetic_shift_right (line 557) | inline long int
function plogical_shift_right (line 561) | inline int
function plogical_shift_right (line 563) | inline long int
function plogical_shift_left (line 567) | inline int
function plogical_shift_left (line 569) | inline long int
function Packet (line 576) | inline Packet pfrexp(const Packet& a, Packet& exponent) {
function Packet (line 587) | inline Packet
function Packet (line 594) | inline Packet
function Packet (line 598) | inline Packet
function Packet (line 602) | inline Packet
function Packet (line 614) | inline Packet
function Packet (line 622) | inline Packet
function EIGEN_STRONG_INLINE (line 630) | EIGEN_STRONG_INLINE Packet
function Packet (line 639) | inline Packet
function pbroadcast4 (line 653) | inline void pbroadcast4(const typename unpacket_traits<Packet>::type *a,
function pbroadcast2 (line 670) | inline void pbroadcast2(const typename unpacket_traits<Packet>::type *a,
function EIGEN_STRONG_INLINE (line 678) | EIGEN_STRONG_INLINE Packet
function Packet (line 683) | inline Packet
function pstore (line 696) | inline void pstore(Scalar* to, const Packet& from)
function pstoreu (line 700) | inline void pstoreu(Scalar* to, const Packet& from)
function Packet (line 712) | inline Packet pgather(const Scalar* from, Index /*stride*/)
function pscatter (line 715) | inline void pscatter(Scalar* to, const Packet& from, Index /*stride*/)
function prefetch (line 719) | inline void prefetch(const Scalar* addr)
function Packet (line 737) | inline Packet preverse(const Packet& a)
function Packet (line 741) | inline Packet pcplxflip(const Packet& a)
function Packet (line 752) | Packet psin(const Packet& a) { EIGEN_USING_STD(sin); return sin(a); }
function Packet (line 756) | Packet pcos(const Packet& a) { EIGEN_USING_STD(cos); return cos(a); }
function Packet (line 760) | Packet ptan(const Packet& a) { EIGEN_USING_STD(tan); return tan(a); }
function Packet (line 764) | Packet pasin(const Packet& a) { EIGEN_USING_STD(asin); return asin(a); }
function Packet (line 768) | Packet pacos(const Packet& a) { EIGEN_USING_STD(acos); return acos(a); }
function Packet (line 772) | Packet patan(const Packet& a) { EIGEN_USING_STD(atan); return atan(a); }
function Packet (line 776) | Packet psinh(const Packet& a) { EIGEN_USING_STD(sinh); return sinh(a); }
function Packet (line 780) | Packet pcosh(const Packet& a) { EIGEN_USING_STD(cosh); return cosh(a); }
function Packet (line 784) | Packet ptanh(const Packet& a) { EIGEN_USING_STD(tanh); return tanh(a); }
function Packet (line 788) | Packet pexp(const Packet& a) { EIGEN_USING_STD(exp); return exp(a); }
function Packet (line 792) | Packet pexpm1(const Packet& a) { return numext::expm1(a); }
function Packet (line 796) | Packet plog(const Packet& a) { EIGEN_USING_STD(log); return log(a); }
function Packet (line 800) | Packet plog1p(const Packet& a) { return numext::log1p(a); }
function Packet (line 804) | Packet plog10(const Packet& a) { EIGEN_USING_STD(log10); return log10(a); }
function Packet (line 808) | Packet plog2(const Packet& a) {
function Packet (line 815) | Packet psqrt(const Packet& a) { return numext::sqrt(a); }
function Packet (line 819) | Packet prsqrt(const Packet& a) {
function Packet (line 826) | Packet pround(const Packet& a) { using numext::round; return round(a); }
function Packet (line 830) | Packet pfloor(const Packet& a) { using numext::floor; return floor(a); }
function Packet (line 835) | Packet print(const Packet& a) { using numext::rint; return rint(a); }
function Packet (line 839) | Packet pceil(const Packet& a) { using numext::ceil; return ceil(a); }
function typename (line 843) | inline typename unpacket_traits<Packet>::type
function typename (line 858) | inline typename unpacket_traits<Packet>::type
function typename (line 874) | inline typename unpacket_traits<Packet>::type
function typename (line 882) | inline typename unpacket_traits<Packet>::type predux_mul(
function typename (line 890) | inline typename unpacket_traits<Packet>::type predux_min(
function typename (line 897) | inline typename unpacket_traits<Packet>::type predux_min(
function typename (line 905) | inline typename unpacket_traits<Packet>::type predux_max(
function typename (line 912) | inline typename unpacket_traits<Packet>::type predux_max(
function predux_any (line 930) | inline bool predux_any(const Packet& a)
function pstore1 (line 949) | void pstore1(typename unpacket_traits<Packet>::type* to, const typename ...
function Packet (line 955) | inline Packet
function EIGEN_ALWAYS_INLINE (line 964) | EIGEN_ALWAYS_INLINE Packet ploadt(const typename unpacket_traits<Packet>...
function pstoret (line 975) | void pstoret(Scalar* to, const Packet& from)
function EIGEN_ALWAYS_INLINE (line 989) | EIGEN_ALWAYS_INLINE Packet ploadt_ro(const typename unpacket_traits<Pack...
function ptranspose (line 1018) | inline void
function Packet (line 1031) | inline Packet
FILE: Obfuscation/include/Eigen/src/Core/GlobalFunctions.h
function namespace (line 54) | namespace Eigen
FILE: Obfuscation/include/Eigen/src/Core/IO.h
function namespace (line 14) | namespace Eigen {
function namespace (line 114) | namespace internal {
FILE: Obfuscation/include/Eigen/src/Core/IndexedView.h
function namespace (line 13) | namespace Eigen {
function Index (line 125) | Index rows() const { return internal::size(m_rowIndices); }
function typename (line 135) | typename internal::remove_reference<XprType>::type&
function namespace (line 160) | namespace internal {
FILE: Obfuscation/include/Eigen/src/Core/Inverse.h
function namespace (line 13) | namespace Eigen {
type typename (line 73) | typedef typename XprType::Scalar Scalar;
function namespace (line 80) | namespace internal {
FILE: Obfuscation/include/Eigen/src/Core/Map.h
function namespace (line 14) | namespace Eigen {
type PointerType (line 103) | typedef PointerType PointerArgType;
function EIGEN_DEVICE_FUNC (line 104) | EIGEN_DEVICE_FUNC
function Index (line 108) | inline Index innerStride() const
function EIGEN_DEVICE_FUNC (line 128) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 141) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 155) | EIGEN_DEVICE_FUNC
FILE: Obfuscation/include/Eigen/src/Core/MapBase.h
function namespace (line 18) | namespace Eigen {
type typename (line 231) | typedef typename Base::Scalar Scalar;
type typename (line 232) | typedef typename Base::PacketScalar PacketScalar;
type typename (line 233) | typedef typename Base::StorageIndex StorageIndex;
type typename (line 234) | typedef typename Base::PointerType PointerType;
type typename (line 248) | typedef typename internal::conditional<
function EIGEN_DEVICE_FUNC (line 254) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 256) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 259) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 265) | EIGEN_DEVICE_FUNC
function writePacket (line 273) | void writePacket(Index row, Index col, const PacketScalar& val)
function writePacket (line 280) | void writePacket(Index index, const PacketScalar& val)
function EIGEN_DEVICE_FUNC (line 287) | EIGEN_DEVICE_FUNC explicit inline MapBase(PointerType dataPtr) : Base(da...
function EIGEN_DEVICE_FUNC (line 288) | EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index vecSize) : B...
function EIGEN_DEVICE_FUNC (line 289) | EIGEN_DEVICE_FUNC inline MapBase(PointerType dataPtr, Index rows, Index ...
FILE: Obfuscation/include/Eigen/src/Core/MathFunctions.h
function namespace (line 20) | namespace Eigen {
type Scalar (line 818) | typedef Scalar type;
function Scalar (line 831) | static inline Scalar run()
type typename (line 892) | typedef typename make_unsigned<Scalar>::type ScalarU;
type typename (line 896) | typedef typename conditional<(ScalarU(-1) > unsigned(-1)), ScalarU, unsi...
function Scalar (line 914) | static inline Scalar run()
function Scalar (line 937) | static inline Scalar run()
function isinf_impl (line 997) | bool>::type
function isinf_msvc_helper (line 1029) | bool isinf_msvc_helper(T x)
function EIGEN_DEVICE_FUNC (line 1035) | EIGEN_DEVICE_FUNC inline bool isnan_impl(const long double& x) { return ...
function EIGEN_DEVICE_FUNC (line 1036) | EIGEN_DEVICE_FUNC inline bool isnan_impl(const double& x) { return ...
function EIGEN_DEVICE_FUNC (line 1037) | EIGEN_DEVICE_FUNC inline bool isnan_impl(const float& x) { return ...
function EIGEN_DEVICE_FUNC (line 1039) | EIGEN_DEVICE_FUNC inline bool isinf_impl(const long double& x) { return ...
function EIGEN_DEVICE_FUNC (line 1040) | EIGEN_DEVICE_FUNC inline bool isinf_impl(const double& x) { return ...
function EIGEN_DEVICE_FUNC (line 1041) | EIGEN_DEVICE_FUNC inline bool isinf_impl(const float& x) { return ...
function isnan_impl (line 1053) | bool isnan_impl(const long double& x) { return __builtin_isnan(x); }
function isnan_impl (line 1054) | bool isnan_impl(const double& x) { return __builtin_isnan(x); }
function isnan_impl (line 1055) | bool isnan_impl(const float& x) { return __builtin_isnan(x); }
function isinf_impl (line 1056) | bool isinf_impl(const double& x) { return __builtin_isinf(x); }
function isinf_impl (line 1057) | bool isinf_impl(const float& x) { return __builtin_isinf(x); }
function isinf_impl (line 1058) | bool isinf_impl(const long double& x) { return __builtin_isinf(x); }
function namespace (line 1078) | namespace numext {
function floor (line 1412) | float floor(const float &x) { return ::floorf(x); }
function floor (line 1415) | double floor(const double &x) { return ::floor(x); }
function ceil (line 1432) | float ceil(const float &x) { return ::ceilf(x); }
function ceil (line 1435) | double ceil(const double &x) { return ::ceil(x); }
function log2 (line 1441) | inline int log2(int x)
function log (line 1500) | float log(const float &x) { return ::logf(x); }
function log (line 1503) | double log(const double &x) { return ::log(x); }
function typename (line 1516) | typename NumTraits<T>::Real>::type
function abs (line 1528) | float abs(const float &x) { return ::fabsf(x); }
function abs (line 1531) | double abs(const double &x) { return ::fabs(x); }
function exp (line 1557) | float exp(const float &x) { return ::expf(x); }
function exp (line 1560) | double exp(const double &x) { return ::exp(x); }
function expm1 (line 1592) | float expm1(const float &x) { return ::expm1f(x); }
function expm1 (line 1595) | double expm1(const double &x) { return ::expm1(x); }
function cos (line 1611) | float cos(const float &x) { return ::cosf(x); }
function cos (line 1614) | double cos(const double &x) { return ::cos(x); }
function sin (line 1630) | float sin(const float &x) { return ::sinf(x); }
function sin (line 1633) | double sin(const double &x) { return ::sin(x); }
function tan (line 1649) | float tan(const float &x) { return ::tanf(x); }
function tan (line 1652) | double tan(const double &x) { return ::tan(x); }
function EIGEN_ALWAYS_INLINE (line 1664) | EIGEN_ALWAYS_INLINE
function acos (line 1678) | float acos(const float &x) { return ::acosf(x); }
function acos (line 1681) | double acos(const double &x) { return ::acos(x); }
function EIGEN_ALWAYS_INLINE (line 1693) | EIGEN_ALWAYS_INLINE
function asin (line 1707) | float asin(const float &x) { return ::asinf(x); }
function asin (line 1710) | double asin(const double &x) { return ::asin(x); }
function EIGEN_ALWAYS_INLINE (line 1722) | EIGEN_ALWAYS_INLINE
function atan (line 1736) | float atan(const float &x) { return ::atanf(x); }
function atan (line 1739) | double atan(const double &x) { return ::atan(x); }
function cosh (line 1756) | float cosh(const float &x) { return ::coshf(x); }
function cosh (line 1759) | double cosh(const double &x) { return ::cosh(x); }
function sinh (line 1775) | float sinh(const float &x) { return ::sinhf(x); }
function sinh (line 1778) | double sinh(const double &x) { return ::sinh(x); }
function tanh (line 1790) | float tanh(float x) { return internal::generic_fast_tanh_float(x); }
function tanh (line 1799) | float tanh(const float &x) { return ::tanhf(x); }
function tanh (line 1802) | double tanh(const double &x) { return ::tanh(x); }
function fmod (line 1819) | float fmod(const float& a, const float& b) {
function fmod (line 1825) | double fmod(const double& a, const double& b) {
function namespace (line 1849) | namespace internal {
type typename (line 1902) | typedef typename NumTraits<Scalar>::Real RealScalar;
function isMuchSmallerThan (line 1904) | static inline bool isMuchSmallerThan(const Scalar& x, const Scalar&, con...
function EIGEN_DEVICE_FUNC (line 1908) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 1913) | EIGEN_DEVICE_FUNC
type typename (line 1923) | typedef typename NumTraits<Scalar>::Real RealScalar;
function isMuchSmallerThan (line 1925) | static inline bool isMuchSmallerThan(const Scalar& x, const OtherScalar&...
function EIGEN_DEVICE_FUNC (line 1929) | EIGEN_DEVICE_FUNC
function isMuchSmallerThan (line 1940) | bool isMuchSmallerThan(const Scalar& x, const OtherScalar& y,
function isApprox (line 1947) | bool isApprox(const Scalar& x, const Scalar& y,
function isApproxOrLessThan (line 1954) | bool isApproxOrLessThan(const Scalar& x, const Scalar& y,
function bool (line 1964) | struct random_impl<bool>
function bool (line 1977) | struct scalar_fuzzy_impl<bool>
function namespace (line 2004) | namespace internal {
FILE: Obfuscation/include/Eigen/src/Core/MathFunctionsImpl.h
function namespace (line 14) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/Matrix.h
function namespace (line 14) | namespace Eigen {
type PlainObjectBase (line 186) | typedef PlainObjectBase<Matrix> Base;
function EIGEN_STRONG_INLINE (line 266) | EIGEN_STRONG_INLINE
function EIGEN_STRONG_INLINE (line 295) | EIGEN_STRONG_INLINE
function EIGEN_STRONG_INLINE (line 321) | EIGEN_STRONG_INLINE Matrix(const std::initializer_list<std::initializer_...
function EIGEN_STRONG_INLINE (line 328) | EIGEN_STRONG_INLINE
function EIGEN_STRONG_INLINE (line 336) | EIGEN_STRONG_INLINE
function Base (line 414) | Matrix(const Matrix& other) : Base(other)
function EIGEN_STRONG_INLINE (line 422) | EIGEN_STRONG_INLINE Matrix(const EigenBase<OtherDerived> &other)
type internal (line 447) | struct internal
FILE: Obfuscation/include/Eigen/src/Core/MatrixBase.h
function namespace (line 14) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/NestByValue.h
function namespace (line 14) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/NoAlias.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/NumTraits.h
function namespace (line 13) | namespace Eigen {
function run (line 56) | static int run() { return std::numeric_limits<T>::digits; }
function EIGEN_CONSTEXPR (line 62) | EIGEN_CONSTEXPR
function EIGEN_CONSTEXPR (line 74) | EIGEN_CONSTEXPR
function namespace (line 80) | namespace numext {
type T (line 164) | typedef T Real;
type typename (line 165) | typedef typename internal::conditional<
type T (line 170) | typedef T Nested;
type T (line 171) | typedef T Literal;
function Real (line 174) | static inline Real epsilon()
function digits10 (line 180) | static inline int digits10()
function digits (line 186) | static inline int digits()
function min_exponent (line 192) | static inline int min_exponent()
function max_exponent (line 198) | static inline int max_exponent()
function Real (line 204) | static inline Real dummy_precision()
function T (line 211) | static inline T highest() {
function T (line 216) | static inline T lowest() {
function T (line 222) | static inline T infinity() {
function T (line 227) | static inline T quiet_NaN() {
type NumTraits (line 235) | struct NumTraits
function dummy_precision (line 239) | static inline float dummy_precision() { return 1e-5f; }
type NumTraits (line 242) | struct NumTraits
function dummy_precision (line 245) | static inline double dummy_precision() { return 1e-12; }
type NumTraits (line 248) | struct NumTraits
function dummy_precision (line 252) | double dummy_precision() { return 1e-15l; }
type _Real (line 258) | typedef _Real Real;
type typename (line 259) | typedef typename NumTraits<_Real>::Literal Literal;
function Real (line 269) | static inline Real epsilon() { return NumTraits<Real>::epsilon(); }
function Real (line 271) | static inline Real dummy_precision() { return NumTraits<Real>::dummy_pre...
function digits10 (line 273) | static inline int digits10() { return NumTraits<Real>::digits10(); }
type typename (line 280) | typedef typename NumTraits<Scalar>::Real RealScalar;
type Array (line 281) | typedef Array<RealScalar, Rows, Cols, Options, MaxRows, MaxCols> Real;
type typename (line 282) | typedef typename NumTraits<Scalar>::NonInteger NonIntegerScalar;
type Array (line 283) | typedef Array<NonIntegerScalar, Rows, Cols, Options, MaxRows, MaxCols> N...
type ArrayType (line 284) | typedef ArrayType & Nested;
type typename (line 285) | typedef typename NumTraits<Scalar>::Literal Literal;
function RealScalar (line 298) | static inline RealScalar epsilon() { return NumTraits<RealScalar>::epsil...
function RealScalar (line 300) | static inline RealScalar dummy_precision() { return NumTraits<RealScalar...
function EIGEN_CONSTEXPR (line 302) | EIGEN_CONSTEXPR
function string (line 306) | struct NumTraits<std::string>
function void (line 329) | struct NumTraits<void> {}
type NumTraits (line 331) | struct NumTraits
FILE: Obfuscation/include/Eigen/src/Core/PartialReduxEvaluator.h
function namespace (line 13) | namespace Eigen {
type typename (line 105) | typedef typename redux_traits<Func, Evaluator>::PacketType PacketScalar;
function PacketType (line 109) | static PacketType run(const Evaluator &eval, const Func& func, Index size)
type typename (line 136) | typedef typename internal::nested_eval<ArgType,1>::type ArgTypeNested;
type typename (line 137) | typedef typename internal::add_const_on_value_type<ArgTypeNested>::type ...
type typename (line 138) | typedef typename internal::remove_all<ArgTypeNested>::type ArgTypeNested...
type typename (line 139) | typedef typename ArgType::Scalar InputScalar;
type typename (line 140) | typedef typename XprType::Scalar Scalar;
type typename (line 144) | typedef typename MemberOp::template Cost<int(TraversalSize)> CostOpType;
function EIGEN_DEVICE_FUNC (line 165) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType xpr)
type typename (line 172) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function Scalar (line 175) | const Scalar coeff(Index i, Index j) const
function Scalar (line 181) | const Scalar coeff(Index index) const
function EIGEN_STRONG_INLINE (line 187) | EIGEN_STRONG_INLINE
function EIGEN_DEVICE_FUNC (line 194) | EIGEN_DEVICE_FUNC
FILE: Obfuscation/include/Eigen/src/Core/PermutationMatrix.h
function namespace (line 14) | namespace Eigen {
type internal (line 300) | typedef internal::traits<PermutationMatrix> Traits;
type typename (line 306) | typedef typename Traits::IndicesType IndicesType;
type typename (line 307) | typedef typename Traits::StorageIndex StorageIndex;
function explicit (line 315) | explicit inline PermutationMatrix(Index size) : m_indices(size)
function m_indices (line 333) | inline PermutationMatrix(const MatrixBase<Other>& indices) : m_indices(i...
function namespace (line 391) | namespace internal {
type internal (line 408) | typedef internal::traits<Map> Traits;
type typename (line 412) | typedef typename Traits::IndicesType IndicesType;
type typename (line 413) | typedef typename IndicesType::Scalar StorageIndex;
function m_indices (line 416) | inline Map(const StorageIndex* indicesPtr)
function namespace (line 456) | namespace internal {
type internal (line 489) | typedef internal::traits<PermutationWrapper> Traits;
type typename (line 493) | typedef typename Traits::IndicesType IndicesType;
function m_indices (line 496) | inline PermutationWrapper(const IndicesType& indices)
type internal (line 540) | typedef internal::traits<PermutationType> PermTraits;
type typename (line 548) | typedef typename PermutationType::DenseMatrixType DenseMatrixType;
function namespace (line 597) | namespace internal {
FILE: Obfuscation/include/Eigen/src/Core/PlainObjectBase.h
function namespace (line 25) | namespace Eigen {
function Scalar (line 152) | const Scalar& coeff(Index rowId, Index colId) const
function Scalar (line 165) | const Scalar& coeff(Index index) const
function Scalar (line 196) | const Scalar& coeffRef(Index rowId, Index colId) const
function Scalar (line 207) | const Scalar& coeffRef(Index index) const
function PacketScalar (line 214) | PacketScalar packet(Index rowId, Index colId) const
function PacketScalar (line 224) | PacketScalar packet(Index index) const
function writePacket (line 231) | void writePacket(Index rowId, Index colId, const PacketScalar& val)
function writePacket (line 241) | void writePacket(Index index, const PacketScalar& val)
function Scalar (line 247) | const Scalar *data() const
function Scalar (line 251) | Scalar *data()
function resize (line 271) | void resize(Index rows, Index cols)
function EIGEN_DEVICE_FUNC (line 300) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 325) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 339) | EIGEN_DEVICE_FUNC
function conservativeResize (line 382) | void conservativeResize(Index rows, Index cols)
function conservativeResize (line 395) | void conservativeResize(Index rows, NoChange_t)
function conservativeResize (line 409) | void conservativeResize(NoChange_t, Index cols)
function conservativeResize (line 424) | void conservativeResize(Index size)
function EIGEN_DEVICE_FUNC (line 485) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 494) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 513) | EIGEN_DEVICE_FUNC
function EIGEN_STRONG_INLINE (line 533) | EIGEN_STRONG_INLINE
function EIGEN_STRONG_INLINE (line 552) | EIGEN_STRONG_INLINE PlainObjectBase(const std::initializer_list<std::ini...
function _init2 (line 824) | void _init2(const Index& val0, const Index& val1,
function _init1 (line 862) | void _init1(const Index& val0,
function _init1 (line 875) | void _init1(const Scalar* data){
function _init1 (line 889) | void _init1(const Derived& other){
function EIGEN_STRONG_INLINE (line 910) | EIGEN_STRONG_INLINE void _init1(const RotationBase<OtherDerived,ColsAtCo...
FILE: Obfuscation/include/Eigen/src/Core/Product.h
function namespace (line 13) | namespace Eigen {
type _Rhs (line 79) | typedef _Rhs Rhs;
type typename (line 81) | typedef typename ProductImpl<
type typename (line 89) | typedef typename internal::ref_selector<Rhs>::type RhsNested;
type typename (line 90) | typedef typename internal::remove_all<LhsNested>::type LhsNestedCleaned;
type typename (line 91) | typedef typename internal::remove_all<RhsNested>::type RhsNestedCleaned;
function namespace (line 117) | namespace internal {
FILE: Obfuscation/include/Eigen/src/Core/ProductEvaluators.h
function namespace (line 16) | namespace Eigen {
type evaluator (line 56) | typedef evaluator<Product<EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar1...
function explicit (line 58) | explicit evaluator(const XprType& xpr)
type evaluator (line 69) | typedef evaluator<Diagonal<const Product<Lhs, Rhs, LazyProduct>, DiagInd...
function explicit (line 71) | explicit evaluator(const XprType& xpr)
type typename (line 100) | typedef typename XprType::PlainObject PlainObject;
type evaluator (line 101) | typedef evaluator<PlainObject> Base;
function explicit (line 107) | explicit product_evaluator(const XprType& xpr)
function run (line 141) | void run(DstXprType &dst, const SrcXprType &src, const internal::assign_...
function run (line 159) | void run(DstXprType &dst, const SrcXprType &src, const internal::add_ass...
function run (line 174) | void run(DstXprType &dst, const SrcXprType &src, const internal::sub_ass...
function run (line 194) | void run(DstXprType &dst, const SrcXprType &src, const AssignFunc& func)
function addTo (line 255) | void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
function subTo (line 261) | void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
type typename (line 543) | typedef typename find_best_packet<Scalar,RowsAtCompileTime>::type LhsVec...
type typename (line 544) | typedef typename find_best_packet<Scalar,ColsAtCompileTime>::type RhsVec...
function CoeffReturnType (line 604) | const CoeffReturnType coeff(Index row, Index col) const
function CoeffReturnType (line 614) | const CoeffReturnType coeff(Index index) const
function EIGEN_STRONG_INLINE (line 622) | EIGEN_STRONG_INLINE
function EIGEN_STRONG_INLINE (line 634) | EIGEN_STRONG_INLINE
type Product (line 657) | typedef Product<Lhs, Rhs, DefaultProduct> XprType;
type Product (line 658) | typedef Product<Lhs, Rhs, LazyProduct> BaseProduct;
type product_evaluator (line 659) | typedef product_evaluator<BaseProduct, CoeffBasedProductMode, DenseShape...
function explicit (line 664) | explicit product_evaluator(const XprType& xpr)
function run (line 676) | void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index inn...
function run (line 686) | void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index inn...
function run (line 696) | void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index /*i...
function run (line 705) | void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index /*i...
function run (line 714) | void run(Index /*row*/, Index /*col*/, const Lhs& /*lhs*/, const Rhs& /*...
function run (line 723) | void run(Index /*row*/, Index /*col*/, const Lhs& /*lhs*/, const Rhs& /*...
function run (line 732) | void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index inn...
function run (line 743) | void run(Index row, Index col, const Lhs& lhs, const Rhs& rhs, Index inn...
type typename (line 764) | typedef typename Product<Lhs,Rhs>::Scalar Scalar;
type typename (line 778) | typedef typename Product<Lhs,Rhs>::Scalar Scalar;
type typename (line 799) | typedef typename Product<Lhs,Rhs>::Scalar Scalar;
function scaleAndAddTo (line 803) | void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scal...
type typename (line 813) | typedef typename Product<Lhs,Rhs>::Scalar Scalar;
type typename (line 831) | typedef typename ScalarBinaryOpTraits<typename MatrixType::Scalar, typename
function EIGEN_DEVICE_FUNC (line 862) | EIGEN_DEVICE_FUNC diagonal_product_evaluator_base(const MatrixType &mat,...
function Scalar (line 869) | const Scalar coeff(Index idx) const
function PacketType (line 879) | PacketType packet_impl(Index row, Index col, Index id, internal::true_ty...
function PacketType (line 886) | PacketType packet_impl(Index row, Index col, Index id, internal::false_t...
type diagonal_product_evaluator_base (line 905) | typedef diagonal_product_evaluator_base<Rhs, typename
type typename (line 909) | typedef typename Base::Scalar Scalar;
type Product (line 911) | typedef Product<Lhs, Rhs, ProductKind> XprType;
type typename (line 912) | typedef typename XprType::PlainObject PlainObject;
type typename (line 913) | typedef typename Lhs::DiagonalVectorType DiagonalType;
function EIGEN_DEVICE_FUNC (line 918) | EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
function Scalar (line 923) | const Scalar coeff(Index row, Index col) const
function PacketType (line 930) | PacketType packet(Index row, Index col) const
function PacketType (line 939) | PacketType packet(Index idx) const
type diagonal_product_evaluator_base (line 951) | typedef diagonal_product_evaluator_base<Lhs, typename
type typename (line 955) | typedef typename Base::Scalar Scalar;
type Product (line 957) | typedef Product<Lhs, Rhs, ProductKind> XprType;
type typename (line 958) | typedef typename XprType::PlainObject PlainObject;
function EIGEN_DEVICE_FUNC (line 962) | EIGEN_DEVICE_FUNC explicit product_evaluator(const XprType& xpr)
function Scalar (line 967) | const Scalar coeff(Index row, Index col) const
function PacketType (line 974) | PacketType packet(Index row, Index col) const
function PacketType (line 981) | PacketType packet(Index idx) const
type typename (line 1003) | typedef typename nested_eval<ExpressionType, 1>::type MatrixType;
type typename (line 1004) | typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
function run (line 1007) | void run(Dest& dst, const PermutationType& perm, const ExpressionType& xpr)
type typename (line 1111) | typedef typename nested_eval<ExpressionType, 1>::type MatrixType;
type typename (line 1112) | typedef typename remove_all<MatrixType>::type MatrixTypeCleaned;
function run (line 1115) | void run(Dest& dst, const TranspositionType& tr, const ExpressionType& xpr)
FILE: Obfuscation/include/Eigen/src/Core/Random.h
function namespace (line 15) | namespace internal {
FILE: Obfuscation/include/Eigen/src/Core/Redux.h
function namespace (line 16) | namespace internal {
FILE: Obfuscation/include/Eigen/src/Core/Ref.h
function namespace (line 13) | namespace Eigen {
type typename (line 62) | typedef typename internal::traits<Derived>::PlainObjectType PlainObjectT...
type typename (line 63) | typedef typename internal::traits<Derived>::StrideType StrideType;
function EIGEN_CONSTEXPR (line 70) | EIGEN_CONSTEXPR inline Index innerStride() const
function Index (line 97) | Index resolveInnerStride(Index inner) {
function Index (line 102) | Index resolveOuterStride(Index inner, Index outer, Index rows, Index col...
function EIGEN_DEVICE_FUNC (line 348) | EIGEN_DEVICE_FUNC inline Ref(const Ref& other) : Base(other) {
function construct (line 360) | void construct(const Expression& expr,internal::true_type)
function construct (line 369) | void construct(const Expression& expr, internal::false_type)
FILE: Obfuscation/include/Eigen/src/Core/Replicate.h
function namespace (line 13) | namespace Eigen {
type typename (line 64) | typedef typename internal::traits<Replicate>::MatrixTypeNested MatrixTyp...
type typename (line 65) | typedef typename internal::traits<Replicate>::_MatrixTypeNested _MatrixT...
FILE: Obfuscation/include/Eigen/src/Core/Reshaped.h
function namespace (line 14) | namespace Eigen {
function EIGEN_INHERIT_ASSIGNMENT_OPERATORS (line 103) | EIGEN_GENERIC_PUBLIC_INTERFACE(Reshaped)
function EIGEN_DEVICE_FUNC (line 118) | EIGEN_DEVICE_FUNC
function Impl (line 139) | inline ReshapedImpl(XprType& xpr) : Impl(xpr) {}
function EIGEN_DEVICE_FUNC (line 140) | EIGEN_DEVICE_FUNC inline ReshapedImpl(XprType& xpr, Index reshapeRows, I...
function namespace (line 144) | namespace internal {
function EIGEN_DEVICE_FUNC (line 183) | EIGEN_DEVICE_FUNC inline Index innerStride() const;
function EIGEN_DEVICE_FUNC (line 227) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 239) | EIGEN_DEVICE_FUNC
type typename (line 269) | typedef typename XprType::Scalar Scalar;
type typename (line 271) | typedef typename packet_traits<Scalar>::type PacketScalar;
type reshaped_evaluator (line 296) | typedef reshaped_evaluator<ArgType, Rows, Cols, Order, HasDirectAccess> ...
function EIGEN_DEVICE_FUNC (line 297) | EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr) : reshaped_eval...
function EIGEN_DEVICE_FUNC (line 317) | EIGEN_DEVICE_FUNC explicit reshaped_evaluator(const XprType& xpr) : m_ar...
type typename (line 322) | typedef typename XprType::Scalar Scalar;
type typename (line 323) | typedef typename XprType::CoeffReturnType CoeffReturnType;
type std (line 325) | typedef std::pair<Index, Index> RowCol;
function RowCol (line 327) | inline RowCol index_remap(Index rowId, Index colId) const
function EIGEN_DEVICE_FUNC (line 343) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 351) | EIGEN_DEVICE_FUNC
function CoeffReturnType (line 359) | const CoeffReturnType coeff(Index rowId, Index colId) const
function EIGEN_DEVICE_FUNC (line 365) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 375) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 383) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 391) | EIGEN_DEVICE_FUNC
function writePacket (line 402) | inline void writePacket(Index rowId, Index colId, const PacketScalar& val)
function PacketScalar (line 411) | inline PacketScalar packet(Index index) const
function writePacket (line 420) | inline void writePacket(Index index, const PacketScalar& val)
type typename (line 440) | typedef typename XprType::Scalar Scalar;
FILE: Obfuscation/include/Eigen/src/Core/ReturnByValue.h
function namespace (line 14) | namespace Eigen {
type typename (line 56) | typedef typename internal::dense_xpr_base<ReturnByValue>::type Base;
function evalTo (line 61) | inline void evalTo(Dest& dst) const
function class (line 70) | class Unusable{
function namespace (line 90) | namespace internal {
FILE: Obfuscation/include/Eigen/src/Core/Reverse.h
function namespace (line 15) | namespace Eigen {
type internal (line 85) | typedef internal::reverse_packet_cond<PacketScalar,ReversePacket> revers...
function m_matrix (line 88) | inline Reverse(const MatrixType& matrix) : m_matrix(matrix) { }
function EIGEN_CONSTEXPR (line 92) | EIGEN_CONSTEXPR
function reverseInPlace (line 141) | inline void DenseBase<Derived>::reverseInPlace()
function namespace (line 165) | namespace internal {
FILE: Obfuscation/include/Eigen/src/Core/Select.h
function namespace (line 13) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 75) | inline EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 84) | inline EIGEN_DEVICE_FUNC
FILE: Obfuscation/include/Eigen/src/Core/SelfAdjointView.h
function namespace (line 13) | namespace Eigen {
type _MatrixType (line 54) | typedef _MatrixType MatrixType;
type TriangularBase (line 55) | typedef TriangularBase<SelfAdjointView> Base;
type typename (line 56) | typedef typename internal::traits<SelfAdjointView>::MatrixTypeNested Mat...
type typename (line 57) | typedef typename internal::traits<SelfAdjointView>::MatrixTypeNestedClea...
type MatrixTypeNestedCleaned (line 58) | typedef MatrixTypeNestedCleaned NestedExpression;
type typename (line 61) | typedef typename internal::traits<SelfAdjointView>::Scalar Scalar;
type typename (line 62) | typedef typename MatrixType::StorageIndex StorageIndex;
type typename (line 63) | typedef typename internal::remove_all<typename
type SelfAdjointView (line 64) | typedef SelfAdjointView<typename
type typename (line 71) | typedef typename MatrixType::PlainObject PlainObject;
function m_matrix (line 74) | inline SelfAdjointView(MatrixType& matrix) : m_matrix(matrix)
function EIGEN_DEVICE_FUNC (line 91) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 101) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 115) | EIGEN_DEVICE_FUNC
type SelfAdjointView (line 195) | typedef SelfAdjointView<const MatrixConjugateReturnType,UpLo> ConjugateR...
function EIGEN_DEVICE_FUNC (line 197) | EIGEN_DEVICE_FUNC
type typename (line 297) | typedef typename Base::DstXprType DstXprType;
type typename (line 298) | typedef typename Base::SrcXprType SrcXprType;
type typename (line 305) | typedef typename Base::SrcEvaluatorType SrcEvaluatorType;
type typename (line 306) | typedef typename Base::Scalar Scalar;
type typename (line 307) | typedef typename Base::AssignmentTraits AssignmentTraits;
function EIGEN_DEVICE_FUNC (line 310) | EIGEN_DEVICE_FUNC triangular_dense_assignment_kernel(DstEvaluatorType &d...
function EIGEN_DEVICE_FUNC (line 314) | EIGEN_DEVICE_FUNC void assignCoeff(Index row, Index col)
function EIGEN_DEVICE_FUNC (line 322) | EIGEN_DEVICE_FUNC void assignDiagonalCoeff(Index id)
function EIGEN_DEVICE_FUNC (line 327) | EIGEN_DEVICE_FUNC void assignOppositeCoeff(Index, Index)
FILE: Obfuscation/include/Eigen/src/Core/SelfCwiseBinaryOp.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/Solve.h
function namespace (line 13) | namespace Eigen {
type typename (line 66) | typedef typename internal::traits<Solve>::StorageIndex StorageIndex;
function namespace (line 110) | namespace internal {
type Solve (line 139) | typedef Solve<DecType,RhsType> SrcXprType;
function run (line 140) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
type Solve (line 155) | typedef Solve<Transpose<const DecType>,RhsType> SrcXprType;
function run (line 156) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
function run (line 173) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
FILE: Obfuscation/include/Eigen/src/Core/SolveTriangular.h
function namespace (line 13) | namespace Eigen {
function EIGEN_DEVICE_FUNC (line 121) | static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
function EIGEN_DEVICE_FUNC (line 141) | static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
type typename (line 177) | typedef typename internal::conditional<copy,
function namespace (line 197) | namespace internal {
type ReturnByValue (line 210) | typedef ReturnByValue<triangular_solve_retval> Base;
FILE: Obfuscation/include/Eigen/src/Core/SolverBase.h
function namespace (line 13) | namespace Eigen {
type typename (line 73) | typedef typename internal::traits<Derived>::Scalar Scalar;
type Scalar (line 74) | typedef Scalar CoeffReturnType;
type internal (line 77) | struct internal
type typename (line 113) | typedef typename internal::add_const<Transpose<const Derived> >::type Co...
function ConstTransposeReturnType (line 121) | inline ConstTransposeReturnType transpose() const
function namespace (line 155) | namespace internal {
FILE: Obfuscation/include/Eigen/src/Core/StableNorm.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/StlIterators.h
function namespace (line 13) | namespace Eigen {
function operator (line 78) | bool operator< (const indexed_based_stl_iterator_base& other) const { ei...
function operator (line 80) | bool operator> (const indexed_based_stl_iterator_base& other) const { ei...
function operator (line 85) | bool operator< (const other_iterator& other) const { eigen_assert(mp_xpr...
function operator (line 87) | bool operator> (const other_iterator& other) const { eigen_assert(mp_xpr...
type typename (line 104) | typedef typename traits::XprType XprType;
type indexed_based_stl_reverse_iterator_base (line 105) | typedef indexed_based_stl_reverse_iterator_base<typename
type indexed_based_stl_reverse_iterator_base (line 106) | typedef indexed_based_stl_reverse_iterator_base<typename
type typename (line 107) | typedef typename internal::conditional<internal::is_const<XprType>::valu...
type std (line 113) | typedef std::random_access_iterator_tag iterator_category;
function operator (line 157) | bool operator< (const indexed_based_stl_reverse_iterator_base& other) co...
function operator (line 159) | bool operator> (const indexed_based_stl_reverse_iterator_base& other) co...
function operator (line 164) | bool operator< (const other_iterator& other) const { eigen_assert(mp_xpr...
function operator (line 166) | bool operator> (const other_iterator& other) const { eigen_assert(mp_xpr...
type pointer_based_stl_iterator (line 182) | typedef pointer_based_stl_iterator<typename
type pointer_based_stl_iterator (line 183) | typedef pointer_based_stl_iterator<typename
type typename (line 184) | typedef typename internal::conditional<internal::is_const<XprType>::valu...
type typename (line 190) | typedef typename XprType::Scalar value_type;
type std (line 191) | typedef std::random_access_iterator_tag iterator_category;
type typename (line 192) | typedef typename internal::conditional<bool(is_lvalue), value_type*, const
type typename (line 193) | typedef typename internal::conditional<bool(is_lvalue), value_type&, const
function reference (line 213) | reference operator*() const { return *m_ptr; }
function reference (line 214) | reference operator[](Index i) const { return *(m_ptr+i*m_incr.value()); }
function pointer (line 215) | pointer operator->() const { return m_ptr; }
function operator (line 241) | bool operator< (const pointer_based_stl_iterator& other) const { return ...
function operator (line 243) | bool operator> (const pointer_based_stl_iterator& other) const { return ...
function operator (line 248) | bool operator< (const other_iterator& other) const { return m_ptr < oth...
function operator (line 250) | bool operator> (const other_iterator& other) const { return m_ptr > oth...
type _XprType (line 262) | typedef _XprType XprType;
type generic_randaccess_stl_iterator (line 263) | typedef generic_randaccess_stl_iterator<typename
type generic_randaccess_stl_iterator (line 264) | typedef generic_randaccess_stl_iterator<typename
type indexed_based_stl_iterator_base (line 280) | typedef indexed_based_stl_iterator_base<generic_randaccess_stl_iterator>...
type value_type (line 287) | typedef const value_type read_only_ref_t;
type typename (line 292) | typedef typename internal::conditional<bool(is_lvalue), value_type&, rea...
function Base (line 296) | generic_randaccess_stl_iterator(const typename Base::non_const_iterator&...
function reference (line 299) | reference operator*() const { return (*mp_xpr)(m_index); }
function reference (line 300) | reference operator[](Index i) const { return (*mp_xpr)(m_index+i); }
function pointer (line 301) | pointer operator->() const { return &((*mp_xpr)(m_index)); }
type subvector_stl_iterator (line 308) | typedef subvector_stl_iterator<typename
type subvector_stl_iterator (line 309) | typedef subvector_stl_iterator<typename
type indexed_based_stl_iterator_base (line 319) | typedef indexed_based_stl_iterator_base<subvector_stl_iterator> Base;
type typename (line 323) | typedef typename internal::conditional<Direction==Vertical,typename
type typename (line 324) | typedef typename internal::conditional<Direction==Vertical,typename
type typename (line 329) | typedef typename reference::PlainObject value_type;
function reference (line 347) | reference operator*() const { return (*mp_xpr).template subVecto...
function reference (line 348) | reference operator[](Index i) const { return (*mp_xpr).template subVecto...
function pointer (line 349) | pointer operator->() const { return (*mp_xpr).template subVecto...
type subvector_stl_reverse_iterator (line 356) | typedef subvector_stl_reverse_iterator<typename
type subvector_stl_reverse_iterator (line 357) | typedef subvector_stl_reverse_iterator<typename
type indexed_based_stl_reverse_iterator_base (line 367) | typedef indexed_based_stl_reverse_iterator_base<subvector_stl_reverse_it...
type typename (line 371) | typedef typename internal::conditional<Direction==Vertical,typename
type typename (line 372) | typedef typename internal::conditional<Direction==Vertical,typename
type typename (line 377) | typedef typename reference::PlainObject value_type;
function reference (line 395) | reference operator*() const { return (*mp_xpr).template subVecto...
function reference (line 396) | reference operator[](Index i) const { return (*mp_xpr).template subVecto...
function pointer (line 397) | pointer operator->() const { return (*mp_xpr).template subVecto...
FILE: Obfuscation/include/Eigen/src/Core/Stride.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/Swap.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/Transpose.h
function namespace (line 14) | namespace Eigen {
function namespace (line 93) | namespace internal {
type typename (line 133) | typedef typename internal::conditional<
function ScalarWithConstIfNotLvalue (line 140) | ScalarWithConstIfNotLvalue* data() { return derived().nestedExpression()...
function Scalar (line 142) | const Scalar* data() const { return derived().nestedExpression().data(); }
function Scalar (line 146) | const Scalar& coeffRef(Index rowId, Index colId) const
function Scalar (line 152) | const Scalar& coeffRef(Index index) const
function namespace (line 230) | namespace internal {
type typename (line 249) | typedef typename MatrixType::Scalar Scalar;
type typename (line 250) | typedef typename internal::packet_traits<typename
type typename (line 265) | typedef typename MatrixType::Scalar Scalar;
type typename (line 266) | typedef typename internal::packet_traits<typename
type typename (line 303) | typedef typename MatrixType::Scalar Scalar;
function transposeInPlace (line 344) | inline void DenseBase<Derived>::transposeInPlace()
function adjointInPlace (line 375) | inline void MatrixBase<Derived>::adjointInPlace()
function namespace (line 384) | namespace internal {
function run (line 403) | static bool run(const Scalar* dest, const OtherDerived& src)
function run (line 432) | static void run(const Derived& dst, const OtherDerived& other)
FILE: Obfuscation/include/Eigen/src/Core/Transpositions.h
function namespace (line 13) | namespace Eigen {
type typename (line 161) | typedef typename Traits::IndicesType IndicesType;
type typename (line 162) | typedef typename IndicesType::Scalar StorageIndex;
function m_indices (line 173) | inline Transpositions(const MatrixBase<Other>& indices) : m_indices(indi...
function m_indices (line 185) | inline Transpositions(Index size) : m_indices(size)
function EIGEN_DEVICE_FUNC (line 192) | EIGEN_DEVICE_FUNC
function namespace (line 201) | namespace internal {
type typename (line 220) | typedef typename Traits::IndicesType IndicesType;
type typename (line 221) | typedef typename IndicesType::Scalar StorageIndex;
function explicit (line 223) | explicit inline Map(const StorageIndex* indicesPtr)
function EIGEN_DEVICE_FUNC (line 254) | EIGEN_DEVICE_FUNC
function namespace (line 262) | namespace internal {
type typename (line 279) | typedef typename Traits::IndicesType IndicesType;
type typename (line 280) | typedef typename IndicesType::Scalar StorageIndex;
function explicit (line 282) | explicit inline TranspositionsWrapper(IndicesType& indices)
function EIGEN_DEVICE_FUNC (line 298) | EIGEN_DEVICE_FUNC
function namespace (line 334) | namespace internal {
type TranspositionsDerived (line 346) | typedef TranspositionsDerived TranspositionType;
type typename (line 347) | typedef typename TranspositionType::IndicesType IndicesType;
FILE: Obfuscation/include/Eigen/src/Core/TriangularMatrix.h
function namespace (line 14) | namespace Eigen {
type typename (line 193) | typedef typename internal::traits<TriangularView>::Scalar Scalar;
type _MatrixType (line 194) | typedef _MatrixType MatrixType;
type typename (line 198) | typedef typename internal::traits<TriangularView>::MatrixTypeNestedNonRe...
type typename (line 200) | typedef typename internal::remove_all<typename
type TriangularView (line 201) | typedef TriangularView<typename
type typename (line 206) | typedef typename internal::traits<TriangularView>::MatrixTypeNestedClean...
function m_matrix (line 219) | inline TriangularView(MatrixType& matrix) : m_matrix(matrix)
function EIGEN_CONSTEXPR (line 225) | EIGEN_CONSTEXPR
function EIGEN_DEVICE_FUNC (line 236) | EIGEN_DEVICE_FUNC
type TriangularView (line 239) | typedef TriangularView<const MatrixConjugateReturnType,Mode> ConjugateRe...
function EIGEN_DEVICE_FUNC (line 241) | EIGEN_DEVICE_FUNC
type TriangularBase (line 351) | typedef TriangularBase<TriangularViewType> Base;
type typename (line 352) | typedef typename internal::traits<TriangularViewType>::Scalar Scalar;
type _MatrixType (line 354) | typedef _MatrixType MatrixType;
type typename (line 355) | typedef typename MatrixType::PlainObject DenseMatrixType;
type DenseMatrixType (line 356) | typedef DenseMatrixType PlainObject;
type typename (line 362) | typedef typename internal::traits<TriangularViewType>::StorageKind Stora...
function EIGEN_DEVICE_FUNC (line 401) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 404) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 408) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 411) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 417) | EIGEN_DEVICE_FUNC
function EIGEN_DEVICE_FUNC (line 427) | EIGEN_DEVICE_FUNC
function solveInPlace (line 521) | void solveInPlace(const MatrixBase<OtherDerived>& other) const
function swap (line 530) | void swap(TriangularBase<OtherDerived> const & other)
function namespace (line 716) | namespace internal {
type evaluator (line 734) | typedef evaluator<typename
function EIGEN_DEVICE_FUNC (line 735) | EIGEN_DEVICE_FUNC
type Triangular2Triangular (line 740) | struct Triangular2Triangular {}
type Triangular2Dense (line 741) | struct Triangular2Dense {}
type Dense2Triangular (line 742) | struct Dense2Triangular {}
type typename (line 758) | typedef typename Base::DstXprType DstXprType;
type typename (line 759) | typedef typename Base::SrcXprType SrcXprType;
type typename (line 766) | typedef typename Base::SrcEvaluatorType SrcEvaluatorType;
type typename (line 767) | typedef typename Base::Scalar Scalar;
type typename (line 768) | typedef typename Base::AssignmentTraits AssignmentTraits;
function EIGEN_DEVICE_FUNC (line 771) | EIGEN_DEVICE_FUNC triangular_dense_assignment_kernel(DstEvaluatorType &d...
function EIGEN_DEVICE_FUNC (line 776) | EIGEN_DEVICE_FUNC void assignCoeff(Index row, Index col)
function EIGEN_DEVICE_FUNC (line 785) | EIGEN_DEVICE_FUNC void assignDiagonalCoeff(Index id)
function EIGEN_DEVICE_FUNC (line 792) | EIGEN_DEVICE_FUNC void assignOppositeCoeff(Index row, Index col)
type evaluator (line 804) | typedef evaluator<DstXprType> DstEvaluatorType;
type evaluator (line 805) | typedef evaluator<SrcXprType> SrcEvaluatorType;
type triangular_dense_assignment_kernel (line 815) | typedef triangular_dense_assignment_kernel< Mode
function Kernel (line 817) | Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
type AssignmentKind (line 836) | struct AssignmentKind
type Triangular2Dense (line 836) | typedef Triangular2Dense Kind;
type AssignmentKind (line 837) | struct AssignmentKind
type Dense2Triangular (line 837) | typedef Dense2Triangular Kind;
type typename (line 875) | typedef typename DstEvaluatorType::XprType DstXprType;
type typename (line 882) | typedef typename Kernel::Scalar Scalar;
function namespace (line 957) | namespace internal {
function run (line 980) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
function run (line 991) | static void run(DstXprType &dst, const SrcXprType &src, const internal::...
FILE: Obfuscation/include/Eigen/src/Core/VectorBlock.h
function namespace (line 14) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/VectorwiseOp.h
function namespace (line 14) | namespace Eigen {
function namespace (line 104) | namespace internal {
type typename (line 191) | typedef typename ExpressionType::RealScalar RealScalar;
type Eigen (line 192) | typedef Eigen::Index Index;
type typename (line 193) | typedef typename internal::ref_selector<ExpressionType>::non_const_type ...
type typename (line 194) | typedef typename internal::remove_all<ExpressionTypeNested>::type Expres...
type PartialReduxExpr (line 199) | typedef PartialReduxExpr<ExpressionType,
type PartialReduxExpr (line 207) | typedef PartialReduxExpr<ExpressionType,
type Replicate (line 221) | typedef Replicate<OtherDerived,
type Replicate (line 244) | typedef Replicate<OtherDerived,
function m_matrix (line 268) | inline VectorwiseOp(ExpressionType& matrix) : m_matrix(matrix) {}
function EIGEN_DEVICE_FUNC (line 271) | EIGEN_DEVICE_FUNC
function reverse_iterator (line 300) | reverse_iterator rbegin() { return reverse_iterator (...
function iterator (line 309) | iterator end() { return iterator (m_matrix,...
function reverse_iterator (line 318) | reverse_iterator rend() { return reverse_iterator (...
type typename (line 343) | typedef typename ReturnType<internal::member_minCoeff>::Type MinCoeffRet...
type typename (line 344) | typedef typename ReturnType<internal::member_maxCoeff>::Type MaxCoeffRet...
type PartialReduxExpr (line 345) | typedef PartialReduxExpr<const CwiseUnaryOp<internal::scalar_abs2_op<Sca...
type CwiseUnaryOp (line 346) | typedef CwiseUnaryOp<internal::scalar_sqrt_op<RealScalar>, const
type typename (line 347) | typedef typename ReturnType<internal::member_blueNorm,RealScalar>::Type ...
type typename (line 348) | typedef typename ReturnType<internal::member_stableNorm,RealScalar>::Typ...
type typename (line 349) | typedef typename ReturnType<internal::member_hypotNorm,RealScalar>::Type...
type typename (line 350) | typedef typename ReturnType<internal::member_sum>::Type SumReturnType;
type MeanReturnType (line 351) | typedef EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(SumReturnType,Scalar,quot...
type typename (line 352) | typedef typename ReturnType<internal::member_all>::Type AllReturnType;
type typename (line 353) | typedef typename ReturnType<internal::member_any>::Type AnyReturnType;
type PartialReduxExpr (line 354) | typedef PartialReduxExpr<ExpressionType, internal::member_count<Index,Sc...
type typename (line 355) | typedef typename ReturnType<internal::member_prod>::Type ProdReturnType;
type Reverse (line 356) | typedef Reverse<const ExpressionType, Direction> ConstReverseReturnType;
type Reverse (line 357) | typedef Reverse<ExpressionType, Direction> ReverseReturnType;
type PartialReduxExpr (line 360) | typedef PartialReduxExpr<ExpressionType, internal::member_lpnorm<p,RealS...
function EIGEN_DEVICE_FUNC (line 409) | EIGEN_DEVICE_FUNC
function typename (line 435) | const typename LpNormReturnType<p>::Type lpNorm() const
function EIGEN_DEVICE_FUNC (line 504) | EIGEN_DEVICE_FUNC
FILE: Obfuscation/include/Eigen/src/Core/Visitor.h
function namespace (line 13) | namespace Eigen {
function run (line 55) | static inline void run(const Derived& mat, Visitor& visitor)
type typename (line 74) | typedef typename XprType::Scalar Scalar;
type typename (line 75) | typedef typename XprType::CoeffReturnType CoeffReturnType;
function EIGEN_DEVICE_FUNC (line 86) | EIGEN_DEVICE_FUNC CoeffReturnType coeff(Index row, Index col) const
type typename (line 122) | typedef typename internal::visitor_evaluator<Derived> ThisEvaluator;
function namespace (line 132) | namespace internal {
type typename (line 163) | typedef typename Derived::Scalar Scalar;
function EIGEN_DEVICE_FUNC (line 164) | EIGEN_DEVICE_FUNC
type typename (line 179) | typedef typename Derived::Scalar Scalar;
function EIGEN_DEVICE_FUNC (line 180) | EIGEN_DEVICE_FUNC
type typename (line 195) | typedef typename Derived::Scalar Scalar;
function EIGEN_DEVICE_FUNC (line 196) | EIGEN_DEVICE_FUNC
type typename (line 223) | typedef typename Derived::Scalar Scalar;
function EIGEN_DEVICE_FUNC (line 224) | EIGEN_DEVICE_FUNC
type typename (line 239) | typedef typename Derived::Scalar Scalar;
function EIGEN_DEVICE_FUNC (line 240) | EIGEN_DEVICE_FUNC
type typename (line 255) | typedef typename Derived::Scalar Scalar;
function EIGEN_DEVICE_FUNC (line 256) | EIGEN_DEVICE_FUNC
function typename (line 291) | typename internal::traits<Derived>::Scalar
function typename (line 316) | typename internal::traits<Derived>::Scalar
function typename (line 342) | typename internal::traits<Derived>::Scalar
function typename (line 367) | typename internal::traits<Derived>::Scalar
FILE: Obfuscation/include/Eigen/src/Core/arch/AVX/Complex.h
function namespace (line 13) | namespace Eigen {
function Packet4cf (line 145) | Packet4cf preverse(const Packet4cf& a) {
type Packet2cd (line 187) | struct Packet2cd
type packet_traits (line 195) | struct packet_traits
function default_packet_traits (line 195) | double> > : default_packet_traits
function Packet2cd (line 220) | struct unpacket_traits<Packet2cd> {
function Packet2cd (line 235) | Packet2cd pnegate(const Packet2cd& a) { return Packet2cd(pnegate(a.v)); }
function Packet2cd (line 236) | Packet2cd pconj(const Packet2cd& a)
function Packet2cd (line 253) | Packet2cd pcmp_eq(const Packet2cd& a, const Packet2cd& b) {
function Packet2cd (line 303) | Packet2cd preverse(const Packet2cd& a) {
FILE: Obfuscation/include/Eigen/src/Core/arch/AVX/MathFunctions.h
function namespace (line 17) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/AVX/PacketMath.h
function namespace (line 13) | namespace Eigen {
function Packet8f (line 247) | Packet8f pzero(const Packet8f& /*a*/) { return _mm256_setzero_ps(); }
function Packet4d (line 248) | Packet4d pzero(const Packet4d& /*a*/) { return _mm256_setzero_pd(); }
function Packet8i (line 249) | Packet8i pzero(const Packet8i& /*a*/) { return _mm256_setzero_si256(); }
function Packet8f (line 252) | Packet8f peven_mask(const Packet8f& /*a*/) { return _mm256_castsi256_ps(...
function Packet8i (line 253) | Packet8i peven_mask(const Packet8i& /*a*/) { return _mm256_set_epi32(0, ...
function Packet4d (line 254) | Packet4d peven_mask(const Packet4d& /*a*/) { return _mm256_castsi256_pd(...
function Packet8f (line 286) | Packet8f pnegate(const Packet8f& a)
function Packet4d (line 290) | Packet4d pnegate(const Packet4d& a)
function Packet8f (line 295) | Packet8f pconj(const Packet8f& a) { return a; }
function Packet4d (line 296) | Packet4d pconj(const Packet4d& a) { return a; }
function Packet8i (line 297) | Packet8i pconj(const Packet8i& a) { return a; }
function Packet8h (line 936) | struct unpacket_traits<Packet8h> { typedef Eigen::half type; enum {size=...
function EIGEN_STRONG_INLINE (line 988) | EIGEN_STRONG_INLINE Packet8f half2float(const Packet8h& a) {
function EIGEN_STRONG_INLINE (line 1007) | EIGEN_STRONG_INLINE Packet8h float2half(const Packet8f& a) {
function EIGEN_STRONG_INLINE (line 1260) | EIGEN_STRONG_INLINE Packet8f Bf16ToF32(const Packet8bf& a) {
function EIGEN_STRONG_INLINE (line 1274) | EIGEN_STRONG_INLINE Packet8bf F32ToBf16(const Packet8f& a) {
FILE: Obfuscation/include/Eigen/src/Core/arch/AVX/TypeCasting.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/AVX512/Complex.h
function namespace (line 13) | namespace Eigen {
function Packet8cf (line 130) | Packet8cf preverse(const Packet8cf& a) {
type Packet4cd (line 173) | struct Packet4cd
type packet_traits (line 180) | struct packet_traits
function default_packet_traits (line 180) | double> > : default_packet_traits
function Packet4cd (line 204) | struct unpacket_traits<Packet4cd> {
function Packet4cd (line 219) | Packet4cd pnegate(const Packet4cd& a) { return Packet4cd(pnegate(a.v)); }
function Packet4cd (line 220) | Packet4cd pconj(const Packet4cd& a)
function Packet4cd (line 244) | Packet4cd pcmp_eq(const Packet4cd& a, const Packet4cd& b) {
function Packet4cd (line 296) | Packet4cd preverse(const Packet4cd& a) {
type conj_helper (line 312) | struct conj_helper
function EIGEN_STRONG_INLINE (line 314) | EIGEN_STRONG_INLINE Packet4cd pmadd(const Packet4cd& x, const Packet4cd&...
function EIGEN_STRONG_INLINE (line 317) | EIGEN_STRONG_INLINE Packet4cd pmul(const Packet4cd& a, const Packet4cd& ...
type conj_helper (line 323) | struct conj_helper
function EIGEN_STRONG_INLINE (line 325) | EIGEN_STRONG_INLINE Packet4cd pmadd(const Packet4cd& x, const Packet4cd&...
function EIGEN_STRONG_INLINE (line 328) | EIGEN_STRONG_INLINE Packet4cd pmul(const Packet4cd& a, const Packet4cd& ...
type conj_helper (line 334) | struct conj_helper
function EIGEN_STRONG_INLINE (line 336) | EIGEN_STRONG_INLINE Packet4cd pmadd(const Packet4cd& x, const Packet4cd&...
function EIGEN_STRONG_INLINE (line 339) | EIGEN_STRONG_INLINE Packet4cd pmul(const Packet4cd& a, const Packet4cd& ...
FILE: Obfuscation/include/Eigen/src/Core/arch/AVX512/MathFunctions.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/AVX512/PacketMath.h
function namespace (line 13) | namespace Eigen {
function Packet16f (line 219) | Packet16f pzero(const Packet16f& /*a*/) { return _mm512_setzero_ps(); }
function Packet8d (line 220) | Packet8d pzero(const Packet8d& /*a*/) { return _mm512_setzero_pd(); }
function Packet16i (line 221) | Packet16i pzero(const Packet16i& /*a*/) { return _mm512_setzero_si512(); }
function Packet16f (line 223) | Packet16f peven_mask(const Packet16f& /*a*/) {
function Packet16i (line 227) | Packet16i peven_mask(const Packet16i& /*a*/) {
function Packet8d (line 231) | Packet8d peven_mask(const Packet8d& /*a*/) {
function Packet16f (line 291) | Packet16f pnegate(const Packet16f& a) {
function Packet8d (line 295) | Packet8d pnegate(const Packet8d& a) {
function Packet16f (line 300) | Packet16f pconj(const Packet16f& a) {
function Packet8d (line 304) | Packet8d pconj(const Packet8d& a) {
function Packet16i (line 308) | Packet16i pconj(const Packet16i& a) {
function Packet16f (line 341) | Packet16f pmadd(const Packet16f& a, const Packet16f& b,
function Packet8d (line 346) | Packet8d pmadd(const Packet8d& a, const Packet8d& b,
function Packet16f (line 353) | inline Packet16f pselect(const Packet16f& mask,
function Packet8d (line 362) | inline Packet8d pselect(const Packet8d& mask,
function Packet8f (line 432) | Packet8f extract256(Packet16f x) { return _mm512_extractf32x8_ps(x,I_); }
function Packet2d (line 433) | Packet2d extract128(Packet8d x) { return _mm512_extractf64x2_pd(x,I_); }
function EIGEN_STRONG_INLINE (line 434) | EIGEN_STRONG_INLINE Packet16f cat256(Packet8f a, Packet8f b) { return _m...
function Packet8f (line 437) | Packet8f extract256(Packet16f x) {
function Packet2d (line 442) | Packet2d extract128(Packet8d x) {
function EIGEN_STRONG_INLINE (line 446) | EIGEN_STRONG_INLINE Packet16f cat256(Packet8f a, Packet8f b) {
function EIGEN_STRONG_INLINE (line 454) | EIGEN_STRONG_INLINE __m256i Pack32To16(Packet16f rf) {
function Packet16f (line 472) | Packet16f pcmp_eq(const Packet16f& a, const Packet16f& b) {
function Packet16f (line 477) | Packet16f pcmp_le(const Packet16f& a, const Packet16f& b) {
function Packet16f (line 483) | Packet16f pcmp_lt(const Packet16f& a, const Packet16f& b) {
function Packet16f (line 489) | Packet16f pcmp_lt_or_nan(const Packet16f& a, const Packet16f& b) {
function Packet16i (line 495) | Packet16i pcmp_eq(const Packet16i& a, const Packet16i& b) {
function Packet8d (line 502) | Packet8d pcmp_eq(const Packet8d& a, const Packet8d& b) {
function Packet8d (line 508) | Packet8d pcmp_le(const Packet8d& a, const Packet8d& b) {
function Packet8d (line 514) | Packet8d pcmp_lt(const Packet8d& a, const Packet8d& b) {
function Packet8d (line 520) | Packet8d pcmp_lt_or_nan(const Packet8d& a, const Packet8d& b) {
function Packet16i (line 666) | Packet16i parithmetic_shift_right(Packet16i a) {
function Packet16i (line 670) | Packet16i plogical_shift_right(Packet16i a) {
function Packet16i (line 674) | Packet16i plogical_shift_left(Packet16i a) {
function Packet16f (line 875) | Packet16f preverse(const Packet16f& a)
function Packet8d (line 880) | Packet8d preverse(const Packet8d& a)
function Packet16f (line 885) | Packet16f pabs(const Packet16f& a)
function Packet8d (line 891) | Packet8d pabs(const Packet8d& a) {
function Packet8d (line 905) | Packet8d pfrexp_generic_get_biased_exponent(const Packet8d& a) {
function predux_any (line 1095) | bool predux_any(const Packet16f& x)
function Packet16f (line 1356) | Packet16f pblend(const Selector<16>& /*ifPacket*/,
function Packet8d (line 1363) | Packet8d pblend(const Selector<8>& ifPacket,
function Packet16h (line 1419) | Packet16h
function EIGEN_STRONG_INLINE (line 1428) | EIGEN_STRONG_INLINE Packet16f half2float(const Packet16h& a) {
function EIGEN_STRONG_INLINE (line 1456) | EIGEN_STRONG_INLINE Packet16h float2half(const Packet16f& a) {
function Packet16h (line 1485) | Packet16h ptrue(const Packet16h& a) {
function Packet16h (line 1490) | Packet16h pabs(const Packet16h& a) {
function Packet16h (line 1512) | Packet16h por(const Packet16h& a,const Packet16h& b) {
function Packet16h (line 1517) | Packet16h pxor(const Packet16h& a,const Packet16h& b) {
function Packet16h (line 1520) | Packet16h pand(const Packet16h& a,const Packet16h& b) {
function Packet16h (line 1523) | Packet16h pandnot(const Packet16h& a,const Packet16h& b) {
function Packet16h (line 1527) | Packet16h pselect(const Packet16h& mask, const Packet16h& a, const Packe...
function Packet16h (line 1547) | Packet16h pcmp_eq(const Packet16h& a,const Packet16h& b) {
function Packet16h (line 1553) | Packet16h pcmp_le(const Packet16h& a,const Packet16h& b) {
function Packet16h (line 1557) | Packet16h pcmp_lt(const Packet16h& a,const Packet16h& b) {
function Packet16h (line 1561) | Packet16h pcmp_lt_or_nan(const Packet16h& a,const Packet16h& b) {
function Packet16h (line 1565) | Packet16h pconj(const Packet16h& a) { return a; }
function Packet16h (line 1567) | Packet16h pnegate(const Packet16h& a) {
function Packet16h (line 1629) | Packet16h preverse(const Packet16h& a)
function Packet16bf (line 1840) | struct is_arithmetic<Packet16bf> { enum { value = true }; }
function default_packet_traits (line 1843) | struct packet_traits<bfloat16> : default_packet_traits {
function Packet16bf (line 1875) | struct unpacket_traits<Packet16bf>
function Packet16bf (line 1930) | Packet16bf
function EIGEN_STRONG_INLINE (line 1940) | EIGEN_STRONG_INLINE Packet16f Bf16ToF32(const Packet16bf& a) {
function EIGEN_STRONG_INLINE (line 1945) | EIGEN_STRONG_INLINE Packet16bf F32ToBf16(const Packet16f& a) {
function Packet16bf (line 1980) | Packet16bf ptrue(const Packet16bf& a) {
function Packet16bf (line 1985) | Packet16bf por(const Packet16bf& a, const Packet16bf& b) {
function Packet16bf (line 1990) | Packet16bf pxor(const Packet16bf& a, const Packet16bf& b) {
function Packet16bf (line 1995) | Packet16bf pand(const Packet16bf& a, const Packet16bf& b) {
function Packet16bf (line 2000) | Packet16bf pandnot(const Packet16bf& a,
function Packet16bf (line 2006) | Packet16bf pselect(const Packet16bf& mask,
function Packet16bf (line 2032) | Packet16bf pcmp_eq(const Packet16bf& a,
function Packet16bf (line 2038) | Packet16bf pcmp_le(const Packet16bf& a,
function Packet16bf (line 2044) | Packet16bf pcmp_lt(const Packet16bf& a,
function Packet16bf (line 2050) | Packet16bf pcmp_lt_or_nan(const Packet16bf& a,
function Packet16bf (line 2056) | Packet16bf pnegate(const Packet16bf& a) {
function Packet16bf (line 2062) | Packet16bf pconj(const Packet16bf& a) {
function Packet16bf (line 2067) | Packet16bf pabs(const Packet16bf& a) {
function Packet16bf (line 2141) | Packet16bf preverse(const Packet16bf& a) {
FILE: Obfuscation/include/Eigen/src/Core/arch/AVX512/TypeCasting.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/AltiVec/Complex.h
function namespace (line 14) | namespace Eigen {
function Packet2cf (line 166) | Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate(a.v)); }
function Packet2cf (line 167) | Packet2cf pconj(const Packet2cf& a) { return Packet2cf(pxor<Packet4f>(a....
function Packet2cf (line 184) | Packet2cf preverse(const Packet2cf& a)
function Packet2cf (line 231) | Packet2cf pcmp_eq(const Packet2cf& a, const Packet2cf& b) {
function Packet2cf (line 237) | Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacke...
type Packet1cd (line 251) | struct Packet1cd
type packet_traits (line 303) | struct packet_traits
function default_packet_traits (line 303) | double> > : default_packet_traits
function Packet1cd (line 327) | struct unpacket_traits<Packet1cd> { typedef std::complex<double> type; e...
function Packet1cd (line 348) | Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2...
function Packet1cd (line 349) | Packet1cd pconj(const Packet1cd& a) { return Packet1cd(pxor(a.v, reinter...
function Packet1cd (line 368) | Packet1cd preverse(const Packet1cd& a) { return a; }
function EIGEN_STRONG_INLINE (line 384) | EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
function Packet1cd (line 396) | Packet1cd pcmp_eq(const Packet1cd& a, const Packet1cd& b) {
FILE: Obfuscation/include/Eigen/src/Core/arch/AltiVec/MathFunctions.h
function namespace (line 15) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h
function namespace (line 46) | namespace Eigen {
function storeBlock (line 410) | void storeBlock(Scalar* to, PacketBlock<Packet,4>& block)
function storeBlock (line 420) | void storeBlock(Scalar* to, PacketBlock<Packet,2>& block)
function EIGEN_STRONG_INLINE (line 430) | EIGEN_STRONG_INLINE void operator()(std::complex<Scalar>* blockA, const ...
function EIGEN_STRONG_INLINE (line 573) | EIGEN_STRONG_INLINE void operator()(Scalar* blockA, const DataMapper& lh...
function loadPacketRemaining (line 1035) | void loadPacketRemaining(const Scalar* lhs, Packet &lhsV, Index remainin...
function loadPacketRemaining (line 1088) | void loadPacketRemaining(const Scalar* lhs_ptr, const Scalar* lhs_ptr_im...
function Packet (line 1114) | Packet ploadLhs(const Scalar* lhs)
function Packet (line 1253) | Packet bmask(const int remaining_rows)
function pbroadcast4_old (line 1285) | void pbroadcast4_old(const __UNPACK_TYPE__(Packet)* a, Packet& a0, Packe...
function MICRO_EXTRA_COL (line 1305) | void MICRO_EXTRA_COL(
function gemm_extra_col (line 1320) | void gemm_extra_col(
function MICRO_EXTRA_ROW (line 1369) | void MICRO_EXTRA_ROW(
function gemm_unrolled_col (line 1634) | void gemm_unrolled_col(
type typename (line 2635) | typedef typename quad_traits<float>::rhstype RhsPacket;
type Packet2cf (line 2672) | typedef Packet2cf Packetc;
type Packet4f (line 2673) | typedef Packet4f RhsPacket;
type Packet2cf (line 2711) | typedef Packet2cf Packetc;
type Packet4f (line 2712) | typedef Packet4f RhsPacket;
type Packet2cf (line 2749) | typedef Packet2cf Packetc;
type Packet4f (line 2750) | typedef Packet4f RhsPacket;
type typename (line 2787) | typedef typename quad_traits<double>::rhstype RhsPacket;
type Packet1cd (line 2824) | typedef Packet1cd Packetc;
type quad_traits (line 2825) | typedef quad_traits<double>::rhstype RhsPacket;
type Packet1cd (line 2862) | typedef Packet1cd Packetc;
type quad_traits (line 2863) | typedef quad_traits<double>::rhstype RhsPacket;
type Packet1cd (line 2900) | typedef Packet1cd Packetc;
type quad_traits (line 2901) | typedef quad_traits<double>::rhstype RhsPacket;
FILE: Obfuscation/include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h
function namespace (line 8) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h
function namespace (line 22) | namespace Eigen {
function ploadRhsMMA (line 126) | void ploadRhsMMA(const Scalar* rhs, Packet& rhsV)
function ploadRhsMMA (line 151) | void ploadRhsMMA(const float*, __vector_pair&)
FILE: Obfuscation/include/Eigen/src/Core/arch/AltiVec/PacketMath.h
function namespace (line 13) | namespace Eigen {
function pstore_common (line 479) | void pstore_common(__UNPACK_TYPE__(Packet)* to, const Packet& from){
function Packet (line 527) | Packet pset1_size4(const __UNPACK_TYPE__(Packet)& from)
function Packet (line 534) | Packet pset1_size8(const __UNPACK_TYPE__(Packet)& from)
function Packet (line 541) | Packet pset1_size16(const __UNPACK_TYPE__(Packet)& from)
function pbroadcast4_common (line 579) | void
function Packet (line 603) | inline Packet pgather_common(const __UNPACK_TYPE__(Packet)* from, Index ...
function Packet (line 623) | inline Packet pgather_size8(const __UNPACK_TYPE__(Packet)* from, Index s...
function Packet (line 652) | inline Packet pgather_size16(const __UNPACK_TYPE__(Packet)* from, Index ...
function pscatter_size4 (line 685) | void pscatter_size4(__UNPACK_TYPE__(Packet)* to, const Packet& from, Ind...
function pscatter_size8 (line 705) | inline void pscatter_size8(__UNPACK_TYPE__(Packet)* to, const Packet& fr...
function pscatter_size16 (line 735) | void pscatter_size16(__UNPACK_TYPE__(Packet)* to, const Packet& from, In...
function Packet4f (line 789) | Packet4f pnegate(const Packet4f& a) { return p4f_ZERO - a; }
function Packet4i (line 790) | Packet4i pnegate(const Packet4i& a) { return p4i_ZERO - a; }
function Packet4f (line 792) | Packet4f pconj(const Packet4f& a) { return a; }
function Packet4i (line 793) | Packet4i pconj(const Packet4i& a) { return a; }
function Packet (line 997) | Packet ploaddup_common(const __UNPACK_TYPE__(Packet)* from)
function pstoreu_common (line 1066) | void pstoreu_common(__UNPACK_TYPE__(Packet)* to, const Packet& from)
function pfirst_common (line 1123) | __UNPACK_TYPE__(Packet) pfirst_common(const Packet& a) {
function a (line 1129) | short int pfirst<Packet8s>(const Packet8s& a) {
function a (line 1133) | unsigned short int pfirst<Packet8us>(const Packet8us& a) {
function a (line 1137) | signed char pfirst<Packet16c>(const Packet16c& a)
function a (line 1142) | unsigned char pfirst<Packet16uc>(const Packet16uc& a)
function Packet4f (line 1147) | Packet4f preverse(const Packet4f& a)
function Packet4i (line 1151) | Packet4i preverse(const Packet4i& a)
function Packet8s (line 1155) | Packet8s preverse(const Packet8s& a)
function Packet8us (line 1159) | Packet8us preverse(const Packet8us& a)
function Packet16c (line 1163) | Packet16c preverse(const Packet16c& a)
function Packet16uc (line 1167) | Packet16uc preverse(const Packet16uc& a)
function Packet8bf (line 1171) | Packet8bf preverse(const Packet8bf& a)
function Packet4f (line 1176) | Packet4f pabs(const Packet4f& a) { return vec_abs(a); }
function Packet4i (line 1177) | Packet4i pabs(const Packet4i& a) { return vec_abs(a); }
function Packet8s (line 1178) | Packet8s pabs(const Packet8s& a) { return vec_abs(a); }
function Packet8us (line 1179) | Packet8us pabs(const Packet8us& a) { return a; }
function Packet16c (line 1180) | Packet16c pabs(const Packet16c& a) { return vec_abs(a); }
function Packet16uc (line 1181) | Packet16uc pabs(const Packet16uc& a) { return a; }
function Packet8bf (line 1182) | Packet8bf pabs(const Packet8bf& a) {
function Packet4i (line 1187) | Packet4i parithmetic_shift_right(const Packet4i& a)
function Packet4i (line 1189) | Packet4i plogical_shift_right(const Packet4i& a)
function Packet4i (line 1191) | Packet4i plogical_shift_left(const Packet4i& a)
function Packet4f (line 1193) | Packet4f plogical_shift_left(const Packet4f& a)
function Packet4f (line 1200) | Packet4f plogical_shift_right(const Packet4f& a)
function Packet4ui (line 1207) | Packet4ui plogical_shift_right(const Packet4ui& a)
function Packet4ui (line 1213) | Packet4ui plogical_shift_left(const Packet4ui& a)
function Packet8us (line 1219) | Packet8us plogical_shift_left(const Packet8us& a)
function Packet8us (line 1224) | Packet8us plogical_shift_right(const Packet8us& a)
function EIGEN_STRONG_INLINE (line 1230) | EIGEN_STRONG_INLINE Packet4f Bf16ToF32Even(const Packet8bf& bf){
function EIGEN_STRONG_INLINE (line 1234) | EIGEN_STRONG_INLINE Packet4f Bf16ToF32Odd(const Packet8bf& bf){
function EIGEN_STRONG_INLINE (line 1244) | EIGEN_STRONG_INLINE Packet8bf F32ToBf16Bool(Packet4f even, Packet4f odd) {
function EIGEN_STRONG_INLINE (line 1252) | EIGEN_STRONG_INLINE Packet8bf F32ToBf16(Packet4f p4f){
function EIGEN_STRONG_INLINE (line 1292) | EIGEN_STRONG_INLINE Packet8bf F32ToBf16(Packet4f even, Packet4f odd){
function Packet8bf (line 1396) | Packet8bf pmadd(const Packet8bf& a, const Packet8bf& b, const Packet8bf&...
function Packet8bf (line 1416) | Packet8bf pcmp_lt(const Packet8bf& a, const Packet8bf& b) {
function Packet8bf (line 1419) | Packet8bf pcmp_lt_or_nan(const Packet8bf& a, const Packet8bf& b) {
function Packet8bf (line 1422) | Packet8bf pcmp_le(const Packet8bf& a, const Packet8bf& b) {
function Packet8bf (line 1425) | Packet8bf pcmp_eq(const Packet8bf& a, const Packet8bf& b) {
function bfloat16 (line 1429) | bfloat16 pfirst(const Packet8bf& a) {
function predux_size8 (line 1473) | __UNPACK_TYPE__(Packet) predux_size8(const Packet& a)
function a (line 1489) | short int predux<Packet8s>(const Packet8s& a)
function a (line 1494) | unsigned short int predux<Packet8us>(const Packet8us& a)
function predux_size16 (line 1499) | __UNPACK_TYPE__(Packet) predux_size16(const Packet& a)
function a (line 1521) | signed char predux<Packet16c>(const Packet16c& a)
function a (line 1526) | unsigned char predux<Packet16uc>(const Packet16uc& a)
function predux_mul (line 1547) | short int predux_mul<Packet8s>(const Packet8s& a)
function predux_mul (line 1558) | unsigned short int predux_mul<Packet8us>(const Packet8us& a)
function predux_mul (line 1578) | signed char predux_mul<Packet16c>(const Packet16c& a)
function a (line 1590) | unsigned char predux_mul<Packet16uc>(const Packet16uc& a)
function predux_min4 (line 1604) | __UNPACK_TYPE__(Packet) predux_min4(const Packet& a)
function predux_min (line 1631) | short int predux_min<Packet8s>(const Packet8s& a)
function predux_min (line 1646) | unsigned short int predux_min<Packet8us>(const Packet8us& a)
function predux_min (line 1661) | signed char predux_min<Packet16c>(const Packet16c& a)
function a (line 1673) | unsigned char predux_min<Packet16uc>(const Packet16uc& a)
function predux_max4 (line 1685) | __UNPACK_TYPE__(Packet) predux_max4(const Packet& a)
function predux_max (line 1711) | short int predux_max<Packet8s>(const Packet8s& a)
function predux_max (line 1726) | unsigned short int predux_max<Packet8us>(const Packet8us& a)
function predux_max (line 1741) | signed char predux_max<Packet16c>(const Packet16c& a)
function a (line 1753) | unsigned char predux_max<Packet16uc>(const Packet16uc& a)
function predux_any (line 1765) | bool predux_any(const Packet4f& x)
function ptranpose_common (line 1770) | inline void
function Packet (line 2101) | Packet pblend4(const Selector<4>& ifPacket, const Packet& thenPacket, co...
function Packet4i (line 2107) | Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket,...
function Packet4f (line 2111) | Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket,...
function Packet8s (line 2115) | Packet8s pblend(const Selector<8>& ifPacket, const Packet8s& thenPacket,...
function Packet8us (line 2123) | Packet8us pblend(const Selector<8>& ifPacket, const Packet8us& thenPacke...
function Packet8bf (line 2130) | Packet8bf pblend(const Selector<8>& ifPacket, const Packet8bf& thenPacke...
function Packet16c (line 2134) | Packet16c pblend(const Selector<16>& ifPacket, const Packet16c& thenPack...
function Packet16uc (line 2144) | Packet16uc pblend(const Selector<16>& ifPacket, const Packet16uc& thenPa...
type type_casting_traits (line 2155) | struct type_casting_traits
type type_casting_traits (line 2164) | struct type_casting_traits
type type_casting_traits (line 2173) | struct type_casting_traits
type type_casting_traits (line 2182) | struct type_casting_traits
function bfloat16 (line 2182) | int, bfloat16> {
type __vector (line 2256) | typedef __vector double Packet2d;
type Packet2ul (line 2257) | typedef __vector unsigned long long Packet2ul;
type Packet2l (line 2258) | typedef __vector long long Packet2l;
type Packet2ul (line 2260) | typedef Packet2ul Packet2bl;
type __vector (line 2262) | typedef __vector __bool
function default_packet_traits (line 2285) | struct packet_traits<double> : default_packet_traits
function Packet2d (line 2317) | struct unpacket_traits<Packet2d> { typedef double type; enum {size=2, al...
function Packet2d (line 2396) | Packet2d pnegate(const Packet2d& a) { return p2d_ZERO - a; }
function Packet2d (line 2398) | Packet2d pconj(const Packet2d& a) { return a; }
function Packet2d (line 2404) | Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) ...
function Packet2d (line 2422) | Packet2d pcmp_le(const Packet2d& a, const Packet2d& b) { return reinterp...
function Packet2d (line 2423) | Packet2d pcmp_lt(const Packet2d& a, const Packet2d& b) { return reinterp...
function Packet2d (line 2424) | Packet2d pcmp_eq(const Packet2d& a, const Packet2d& b) { return reinterp...
function Packet2d (line 2425) | Packet2d pcmp_lt_or_nan(const Packet2d& a, const Packet2d& b) {
function Packet2d (line 2486) | Packet2d preverse(const Packet2d& a)
function Packet2d (line 2490) | Packet2d pabs(const Packet2d& a) { return vec_abs(a); }
function Packet2l (line 2531) | Packet2l plogical_shift_left(const Packet2l& a) {
function Packet2l (line 2537) | Packet2l plogical_shift_right(const Packet2l& a) {
function EIGEN_ALWAYS_INLINE (line 2546) | EIGEN_ALWAYS_INLINE Packet4i shift_even_left(const Packet4i& a) {
function EIGEN_ALWAYS_INLINE (line 2559) | EIGEN_ALWAYS_INLINE Packet4i shift_odd_right(const Packet4i& a) {
function Packet2l (line 2575) | Packet2l run(const Packet2l& a) {
function EIGEN_STRONG_INLINE (line 2589) | static EIGEN_STRONG_INLINE Packet2l run(const Packet2l& a) {
function Packet2l (line 2598) | Packet2l plogical_shift_left(const Packet2l& a) {
function Packet2l (line 2607) | Packet2l run(const Packet2l& a) {
function EIGEN_STRONG_INLINE (line 2621) | static EIGEN_STRONG_INLINE Packet2l run(const Packet2l& a) {
function Packet2l (line 2630) | Packet2l plogical_shift_right(const Packet2l& a) {
function Packet2d (line 2655) | Packet2d pfrexp_generic_get_biased_exponent(const Packet2d& a) {
function Packet2d (line 2699) | Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket,...
FILE: Obfuscation/include/Eigen/src/Core/arch/CUDA/Complex.h
function namespace (line 46) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/Default/BFloat16.h
function namespace (line 26) | namespace Eigen {
function namespace (line 88) | namespace std {
function namespace (line 138) | namespace Eigen {
function namespace (line 602) | namespace internal {
function bfloat16 (line 621) | struct NumTraits<Eigen::bfloat16>
function namespace (line 654) | namespace Eigen {
function namespace (line 689) | namespace std {
FILE: Obfuscation/include/Eigen/src/Core/arch/Default/ConjHelper.h
function namespace (line 41) | namespace Eigen {
function Packet (line 107) | Packet pmadd(const Packet& x, const Packet& y, const Packet& c) const
function Packet (line 110) | Packet pmul(const Packet& x, const Packet& y) const
FILE: Obfuscation/include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h
function namespace (line 19) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/Default/Half.h
type half (line 62) | struct half
function namespace (line 64) | namespace half_impl {
type half (line 142) | struct half
type half_impl (line 150) | typedef half_impl::__half_raw __half_raw;
type half_impl (line 159) | typedef half_impl::__half_raw __half_raw;
function EIGEN_DEVICE_FUNC (line 163) | EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR half() {}
function half_base (line 165) | half(const __half_raw& h) : half_impl::half_base(h) {}
function half_base (line 169) | half(const __half& h) : half_impl::half_base(h) {}
function half_base (line 172) | half(const __half& h) : half_impl::half_base(h) {}
function EIGEN_CONSTEXPR (line 178) | EIGEN_CONSTEXPR half(bool b)
function EIGEN_DEVICE_FUNC (line 181) | EIGEN_DEVICE_FUNC half(T val)
function explicit (line 183) | explicit EIGEN_DEVICE_FUNC half(float f)
function EIGEN_DEVICE_FUNC (line 189) | EIGEN_DEVICE_FUNC half(std::complex<RealScalar> c)
function EIGEN_DEVICE_FUNC (line 197) | EIGEN_DEVICE_FUNC operator __half() const {
function namespace (line 257) | namespace Eigen {
function namespace (line 827) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/Default/TypeCasting.h
function namespace (line 14) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/GPU/MathFunctions.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/GPU/PacketMath.h
function namespace (line 13) | namespace Eigen {
type ulonglong2 (line 500) | typedef ulonglong2 Packet4h2;
type unpacket_traits (line 501) | struct unpacket_traits
type Packet4h2 (line 509) | typedef Packet4h2 type;
type Packet4h2 (line 510) | typedef Packet4h2 half;
function half2 (line 531) | half2 combine_half(const __half& a, const __half& b) {
function __half (line 540) | __half get_half2_low(const half2& a) {
function __half (line 548) | __half get_half2_high(const half2& a) {
function half2 (line 583) | half2 pload(const Eigen::half* from) {
function half2 (line 587) | half2 ploadu(const Eigen::half* from) {
function half2 (line 591) | half2 ploaddup(const Eigen::half* from) {
function pstore (line 595) | void pstore(Eigen::half* to,
function pstoreu (line 600) | void pstoreu(Eigen::half* to,
function half2 (line 607) | half2 ploadt_ro_aligned(
function half2 (line 617) | half2 ploadt_ro_unaligned(
function half2 (line 626) | half2 pgather(const Eigen::half* from,
function pscatter (line 631) | void pscatter(
function half2 (line 641) | half2 pabs(const half2& a) {
function half2 (line 649) | half2 ptrue(const half2& /*a*/) {
function half2 (line 654) | half2 pzero(const half2& /*a*/) {
function ptranspose (line 659) | void
function half2 (line 669) | half2 plset(const Eigen::half& a) {
function half2 (line 678) | half2 pselect(const half2& mask,
function half2 (line 688) | half2 pcmp_eq(const half2& a,
function half2 (line 701) | half2 pcmp_lt(const half2& a,
function half2 (line 714) | half2 pand(const half2& a,
function half2 (line 725) | half2 por(const half2& a,
function half2 (line 736) | half2 pxor(const half2& a,
function half2 (line 747) | half2 pandnot(const half2& a,
function half2 (line 758) | half2 padd(const half2& a,
function half2 (line 773) | half2 psub(const half2& a,
function half2 (line 788) | half2 pnegate(const half2& a) {
function half2 (line 798) | half2 pconj(const half2& a) { return a; }
function half2 (line 800) | half2 pmul(const half2& a,
function half2 (line 815) | half2 pmadd(const half2& a,
function half2 (line 833) | half2 pdiv(const half2& a,
function half2 (line 848) | half2 pmin(const half2& a,
function half2 (line 859) | half2 pmax(const half2& a,
function half2 (line 914) | half2 plog1p(const half2& a) {
function half2 (line 922) | half2 pexpm1(const half2& a) {
function half2 (line 934) | half2 plog(const half2& a) {
function half2 (line 939) | half2 pexp(const half2& a) {
function half2 (line 944) | half2 psqrt(const half2& a) {
function half2 (line 949) | half2 prsqrt(const half2& a) {
function half2 (line 955) | half2 plog(const half2& a) {
function half2 (line 963) | half2 pexp(const half2& a) {
function half2 (line 971) | half2 psqrt(const half2& a) {
function half2 (line 979) | half2 prsqrt(const half2& a) {
function ptranspose_double (line 1120) | void ptranspose_double(
function ptranspose_half2 (line 1141) | void ptranspose_half2(
function ptranspose_half (line 1153) | void
function ptranspose (line 1163) | void
FILE: Obfuscation/include/Eigen/src/Core/arch/GPU/TypeCasting.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/MSA/Complex.h
function namespace (line 18) | namespace Eigen {
type packet_traits (line 104) | struct packet_traits
function default_packet_traits (line 104) | float> > : default_packet_traits {
function Packet2cf (line 128) | struct unpacket_traits<Packet2cf> {
function Packet2cf (line 159) | Packet2cf pnegate(const Packet2cf& a) {
function Packet2cf (line 166) | Packet2cf pconj(const Packet2cf& a) {
function Packet2cf (line 278) | Packet2cf preverse(const Packet2cf& a) {
function Packet2cf (line 333) | Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacket,
type Packet1cd (line 341) | struct Packet1cd {
function explicit (line 344) | explicit Packet1cd(const std::complex<double>& a) {
function EIGEN_STRONG_INLINE (line 348) | EIGEN_STRONG_INLINE explicit Packet1cd(const Packet2d& a) : v(a) {
function EIGEN_STRONG_INLINE (line 350) | EIGEN_STRONG_INLINE Packet1cd(const Packet1cd& a) : v(a.v) {
function EIGEN_STRONG_INLINE (line 356) | EIGEN_STRONG_INLINE Packet1cd conjugate(void) const {
type packet_traits (line 419) | struct packet_traits
function default_packet_traits (line 419) | double> > : default_packet_traits {
function Packet1cd (line 442) | struct unpacket_traits<Packet1cd> {
function Packet1cd (line 484) | Packet1cd pnegate(const Packet1cd& a) {
function Packet1cd (line 491) | Packet1cd pconj(const Packet1cd& a) {
function Packet1cd (line 591) | Packet1cd preverse(const Packet1cd& a) {
function EIGEN_STRONG_INLINE (line 620) | EIGEN_STRONG_INLINE Packet1cd pcplxflip /*<Packet1cd>*/ (const Packet1cd...
FILE: Obfuscation/include/Eigen/src/Core/arch/MSA/MathFunctions.h
function namespace (line 29) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/MSA/PacketMath.h
function namespace (line 19) | namespace Eigen {
function Packet4f (line 204) | Packet4f pnegate(const Packet4f& a) {
function Packet4i (line 211) | Packet4i pnegate(const Packet4i& a) {
function Packet4f (line 218) | Packet4f pconj(const Packet4f& a) {
function Packet4i (line 225) | Packet4i pconj(const Packet4i& a) {
function Packet4f (line 260) | Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c) {
function Packet4i (line 267) | Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) {
function EIGEN_DEBUG_ALIGNED_LOAD (line 384) | EIGEN_DEBUG_ALIGNED_LOAD return (Packet4f)__builtin_msa_ld_w(const_cast<...
function EIGEN_DEBUG_UNALIGNED_LOAD (line 398) | EIGEN_DEBUG_UNALIGNED_LOAD return (Packet4f)__builtin_msa_ld_w(const_cas...
function Packet4f (line 537) | Packet4f preverse(const Packet4f& a) {
function Packet4i (line 544) | Packet4i preverse(const Packet4i& a) {
function Packet4f (line 551) | Packet4f pabs(const Packet4f& a) {
function Packet4i (line 558) | Packet4i pabs(const Packet4i& a) {
function Packet4f (line 723) | Packet4f psqrt(const Packet4f& a) {
function Packet4f (line 730) | Packet4f prsqrt(const Packet4f& a) {
function Packet4f (line 801) | Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket,
function Packet4i (line 810) | Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket,
type v2f64 (line 820) | typedef v2f64 Packet2d;
type v2i64 (line 821) | typedef v2i64 Packet2l;
type v2u64 (line 822) | typedef v2u64 Packet2ul;
function default_packet_traits (line 844) | struct packet_traits<double> : default_packet_traits {
function Packet2d (line 865) | struct unpacket_traits<Packet2d> {
function Packet2d (line 902) | Packet2d pnegate(const Packet2d& a) {
function Packet2d (line 909) | Packet2d pconj(const Packet2d& a) {
function Packet2d (line 930) | Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) {
function EIGEN_DEBUG_UNALIGNED_LOAD (line 1007) | EIGEN_DEBUG_UNALIGNED_LOAD return (Packet2d)__builtin_msa_ld_d(const_cas...
function Packet2d (line 1068) | Packet2d preverse(const Packet2d& a) {
function Packet2d (line 1075) | Packet2d pabs(const Packet2d& a) {
function Packet2d (line 1130) | Packet2d psqrt(const Packet2d& a) {
function Packet2d (line 1137) | Packet2d prsqrt(const Packet2d& a) {
function Packet2d (line 1222) | Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket,
FILE: Obfuscation/include/Eigen/src/Core/arch/NEON/Complex.h
function namespace (line 14) | namespace Eigen {
function Packet1cf (line 290) | Packet1cf preverse(const Packet1cf& a) { return a; }
function Packet2cf (line 291) | Packet2cf preverse(const Packet2cf& a)
type Packet1cd (line 400) | struct Packet1cd
type packet_traits (line 407) | struct packet_traits
function default_packet_traits (line 407) | double> > : default_packet_traits
function Packet1cd (line 431) | struct unpacket_traits<Packet1cd>
function Packet1cd (line 464) | Packet1cd pnegate(const Packet1cd& a)
function Packet1cd (line 467) | Packet1cd pconj(const Packet1cd& a)
function Packet1cd (line 490) | Packet1cd pcmp_eq(const Packet1cd& a, const Packet1cd& b)
function Packet1cd (line 546) | Packet1cd preverse(const Packet1cd& a) { return a; }
function EIGEN_STRONG_INLINE (line 564) | EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
FILE: Obfuscation/include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h
function namespace (line 1) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/NEON/MathFunctions.h
function namespace (line 11) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/NEON/PacketMath.h
function namespace (line 15) | namespace Eigen {
function Packet2f (line 874) | Packet2f pnegate(const Packet2f& a) { return vneg_f32(a); }
function Packet4f (line 875) | Packet4f pnegate(const Packet4f& a) { return vnegq_f32(a); }
function Packet4c (line 876) | Packet4c pnegate(const Packet4c& a)
function Packet8c (line 878) | Packet8c pnegate(const Packet8c& a) { return vneg_s8(a); }
function Packet16c (line 879) | Packet16c pnegate(const Packet16c& a) { return vnegq_s8(a); }
function Packet4s (line 880) | Packet4s pnegate(const Packet4s& a) { return vneg_s16(a); }
function Packet8s (line 881) | Packet8s pnegate(const Packet8s& a) { return vnegq_s16(a); }
function Packet2i (line 882) | Packet2i pnegate(const Packet2i& a) { return vneg_s32(a); }
function Packet4i (line 883) | Packet4i pnegate(const Packet4i& a) { return vnegq_s32(a); }
function Packet2l (line 884) | Packet2l pnegate(const Packet2l& a) {
function Packet2f (line 894) | Packet2f pconj(const Packet2f& a) { return a; }
function Packet4f (line 895) | Packet4f pconj(const Packet4f& a) { return a; }
function Packet4c (line 896) | Packet4c pconj(const Packet4c& a) { return a; }
function Packet8c (line 897) | Packet8c pconj(const Packet8c& a) { return a; }
function Packet16c (line 898) | Packet16c pconj(const Packet16c& a) { return a; }
function Packet4uc (line 899) | Packet4uc pconj(const Packet4uc& a) { return a; }
function Packet8uc (line 900) | Packet8uc pconj(const Packet8uc& a) { return a; }
function Packet16uc (line 901) | Packet16uc pconj(const Packet16uc& a) { return a; }
function Packet4s (line 902) | Packet4s pconj(const Packet4s& a) { return a; }
function Packet8s (line 903) | Packet8s pconj(const Packet8s& a) { return a; }
function Packet4us (line 904) | Packet4us pconj(const Packet4us& a) { return a; }
function Packet8us (line 905) | Packet8us pconj(const Packet8us& a) { return a; }
function Packet2i (line 906) | Packet2i pconj(const Packet2i& a) { return a; }
function Packet4i (line 907) | Packet4i pconj(const Packet4i& a) { return a; }
function Packet2ui (line 908) | Packet2ui pconj(const Packet2ui& a) { return a; }
function Packet4ui (line 909) | Packet4ui pconj(const Packet4ui& a) { return a; }
function Packet2l (line 910) | Packet2l pconj(const Packet2l& a) { return a; }
function Packet2ul (line 911) | Packet2ul pconj(const Packet2ul& a) { return a; }
function Packet2f (line 2298) | Packet2f preverse(const Packet2f& a) { return vrev64_f32(a); }
function Packet4f (line 2299) | Packet4f preverse(const Packet4f& a)
function Packet4c (line 2304) | Packet4c preverse(const Packet4c& a)
function Packet8c (line 2306) | Packet8c preverse(const Packet8c& a) { return vrev64_s8(a); }
function Packet16c (line 2307) | Packet16c preverse(const Packet16c& a)
function Packet4uc (line 2312) | Packet4uc preverse(const Packet4uc& a)
function Packet8uc (line 2314) | Packet8uc preverse(const Packet8uc& a) { return vrev64_u8(a); }
function Packet16uc (line 2315) | Packet16uc preverse(const Packet16uc& a)
function Packet4s (line 2320) | Packet4s preverse(const Packet4s& a) { return vrev64_s16(a); }
function Packet8s (line 2321) | Packet8s preverse(const Packet8s& a)
function Packet4us (line 2326) | Packet4us preverse(const Packet4us& a) { return vrev64_u16(a); }
function Packet8us (line 2327) | Packet8us preverse(const Packet8us& a)
function Packet2i (line 2332) | Packet2i preverse(const Packet2i& a) { return vrev64_s32(a); }
function Packet4i (line 2333) | Packet4i preverse(const Packet4i& a)
function Packet2ui (line 2338) | Packet2ui preverse(const Packet2ui& a) { return vrev64_u32(a); }
function Packet4ui (line 2339) | Packet4ui preverse(const Packet4ui& a)
function Packet2l (line 2344) | Packet2l preverse(const Packet2l& a)
function Packet2ul (line 2346) | Packet2ul preverse(const Packet2ul& a)
function Packet2f (line 2349) | Packet2f pabs(const Packet2f& a) { return vabs_f32(a); }
function Packet4f (line 2350) | Packet4f pabs(const Packet4f& a) { return vabsq_f32(a); }
function Packet8c (line 2353) | Packet8c pabs(const Packet8c& a) { return vabs_s8(a); }
function Packet16c (line 2354) | Packet16c pabs(const Packet16c& a) { return vabsq_s8(a); }
function Packet4uc (line 2355) | Packet4uc pabs(const Packet4uc& a) { return a; }
function Packet8uc (line 2356) | Packet8uc pabs(const Packet8uc& a) { return a; }
function Packet16uc (line 2357) | Packet16uc pabs(const Packet16uc& a) { return a; }
function Packet4s (line 2358) | Packet4s pabs(const Packet4s& a) { return vabs_s16(a); }
function Packet8s (line 2359) | Packet8s pabs(const Packet8s& a) { return vabsq_s16(a); }
function Packet4us (line 2360) | Packet4us pabs(const Packet4us& a) { return a; }
function Packet8us (line 2361) | Packet8us pabs(const Packet8us& a) { return a; }
function Packet2i (line 2362) | Packet2i pabs(const Packet2i& a) { return vabs_s32(a); }
function Packet4i (line 2363) | Packet4i pabs(const Packet4i& a) { return vabsq_s32(a); }
function Packet2ui (line 2364) | Packet2ui pabs(const Packet2ui& a) { return a; }
function Packet4ui (line 2365) | Packet4ui pabs(const Packet4ui& a) { return a; }
function Packet2l (line 2366) | Packet2l pabs(const Packet2l& a) {
function Packet2ul (line 2375) | Packet2ul pabs(const Packet2ul& a) { return a; }
function predux_any (line 2766) | bool predux_any(const Packet4f& x)
function namespace (line 2774) | namespace detail {
function ptranspose (line 2927) | void ptranspose(PacketBlock<Packet2f, 2>& kernel) {
function ptranspose (line 2930) | void ptranspose(PacketBlock<Packet4f, 4>& kernel) {
function ptranspose (line 2934) | void ptranspose(PacketBlock<Packet4c, 4>& kernel)
function ptranspose (line 2947) | void ptranspose(PacketBlock<Packet8c, 8>& kernel) {
function ptranspose (line 2950) | void ptranspose(PacketBlock<Packet8c, 4>& kernel) {
function ptranspose (line 2953) | void ptranspose(PacketBlock<Packet16c, 16>& kernel) {
function ptranspose (line 2956) | void ptranspose(PacketBlock<Packet16c, 8>& kernel) {
function ptranspose (line 2959) | void ptranspose(PacketBlock<Packet16c, 4>& kernel) {
function ptranspose (line 2963) | void ptranspose(PacketBlock<Packet4uc, 4>& kernel)
function ptranspose (line 2976) | void ptranspose(PacketBlock<Packet8uc, 8>& kernel) {
function ptranspose (line 2979) | void ptranspose(PacketBlock<Packet8uc, 4>& kernel) {
function ptranspose (line 2982) | void ptranspose(PacketBlock<Packet16uc, 16>& kernel) {
function ptranspose (line 2985) | void ptranspose(PacketBlock<Packet16uc, 8>& kernel) {
function ptranspose (line 2988) | void ptranspose(PacketBlock<Packet16uc, 4>& kernel) {
function ptranspose (line 2992) | void ptranspose(PacketBlock<Packet4s, 4>& kernel) {
function ptranspose (line 2995) | void ptranspose(PacketBlock<Packet8s, 8>& kernel) {
function ptranspose (line 2998) | void ptranspose(PacketBlock<Packet8s, 4>& kernel) {
function ptranspose (line 3002) | void ptranspose(PacketBlock<Packet4us, 4>& kernel) {
function ptranspose (line 3005) | void ptranspose(PacketBlock<Packet8us, 8>& kernel) {
function ptranspose (line 3008) | void ptranspose(PacketBlock<Packet8us, 4>& kernel) {
function ptranspose (line 3012) | void ptranspose(PacketBlock<Packet2i, 2>& kernel) {
function ptranspose (line 3015) | void ptranspose(PacketBlock<Packet4i, 4>& kernel) {
function ptranspose (line 3018) | void ptranspose(PacketBlock<Packet2ui, 2>& kernel) {
function ptranspose (line 3021) | void ptranspose(PacketBlock<Packet4ui, 4>& kernel) {
function ptranspose (line 3025) | void
function ptranspose (line 3042) | void
function Packet4f (line 3115) | Packet4f print(const Packet4f& a) {
function Packet2f (line 3129) | Packet2f print(const Packet2f& a) {
function Packet4uc (line 3191) | Packet4uc psqrt(const Packet4uc& a) {
function Packet8uc (line 3204) | Packet8uc psqrt(const Packet8uc& a) {
function Packet16uc (line 3216) | Packet16uc psqrt(const Packet16uc& a) {
function Packet4us (line 3228) | Packet4us psqrt(const Packet4us& a) {
function Packet8us (line 3240) | Packet8us psqrt(const Packet8us& a) {
function Packet2ui (line 3252) | Packet2ui psqrt(const Packet2ui& a) {
function Packet4ui (line 3264) | Packet4ui psqrt(const Packet4ui& a) {
function Packet4f (line 3276) | Packet4f prsqrt(const Packet4f& a) {
function Packet2f (line 3286) | Packet2f prsqrt(const Packet2f& a) {
function Packet4f (line 3298) | Packet4f psqrt(const Packet4f& _x){return vsqrtq_f32(_x);}
function Packet2f (line 3299) | Packet2f psqrt(const Packet2f& _x){return vsqrt_f32(_x); }
function Packet4f (line 3301) | Packet4f psqrt(const Packet4f& a) {
function Packet2f (line 3306) | Packet2f psqrt(const Packet2f& a) {
type eigen_packet_wrapper (line 3317) | typedef eigen_packet_wrapper<uint16x4_t, 19> Packet4bf;
function Packet4bf (line 3319) | struct is_arithmetic<Packet4bf> { enum { value = true }; }
function default_packet_traits (line 3321) | struct packet_traits<bfloat16> : default_packet_traits
function Packet4bf (line 3364) | struct unpacket_traits<Packet4bf>
function namespace (line 3378) | namespace detail {
function EIGEN_STRONG_INLINE (line 3387) | EIGEN_STRONG_INLINE Packet4bf F32ToBf16(const Packet4f& p)
function EIGEN_STRONG_INLINE (line 3414) | EIGEN_STRONG_INLINE Packet4f Bf16ToF32(const Packet4bf& p)
function EIGEN_STRONG_INLINE (line 3419) | EIGEN_STRONG_INLINE Packet4bf F32MaskToBf16Mask(const Packet4f& p) {
function Packet4bf (line 3456) | Packet4bf pabs(const Packet4bf& a) {
function Packet4bf (line 3499) | Packet4bf por(const Packet4bf& a,const Packet4bf& b) {
function Packet4bf (line 3503) | Packet4bf pxor(const Packet4bf& a,const Packet4bf& b) {
function Packet4bf (line 3507) | Packet4bf pand(const Packet4bf& a,const Packet4bf& b) {
function Packet4bf (line 3511) | Packet4bf pandnot(const Packet4bf& a,const Packet4bf& b) {
function Packet4bf (line 3536) | Packet4bf pconj(const Packet4bf& a) { return a; }
function ptranspose (line 3591) | void ptranspose(PacketBlock<Packet4bf, 4>& kernel)
type float64x2_t (line 3649) | typedef float64x2_t Packet2d;
type float64x1_t (line 3650) | typedef float64x1_t Packet1d;
function EIGEN_STRONG_INLINE (line 3655) | EIGEN_STRONG_INLINE Packet2d shuffle(const Packet2d& m, const Packet2d& ...
function EIGEN_STRONG_INLINE (line 3663) | EIGEN_STRONG_INLINE Packet2d vec2d_swizzle2(const Packet2d& a, const Pac...
function EIGEN_STRONG_INLINE (line 3667) | EIGEN_STRONG_INLINE Packet2d vec2d_unpacklo(const Packet2d& a,const Pack...
function EIGEN_STRONG_INLINE (line 3671) | EIGEN_STRONG_INLINE Packet2d vec2d_unpackhi(const Packet2d& a,const Pack...
function default_packet_traits (line 3678) | struct packet_traits<double> : default_packet_traits
function Packet2d (line 3721) | struct unpacket_traits<Packet2d>
function Packet2d (line 3754) | Packet2d pnegate(const Packet2d& a) { return vnegq_f64(a); }
function Packet2d (line 3756) | Packet2d pconj(const Packet2d& a) { return a; }
function Packet2d (line 3764) | Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c)
function Packet2d (line 3767) | Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c)
function Packet2d (line 3800) | Packet2d pcmp_le(const Packet2d& a, const Packet2d& b)
function Packet2d (line 3803) | Packet2d pcmp_lt(const Packet2d& a, const Packet2d& b)
function Packet2d (line 3806) | Packet2d pcmp_lt_or_nan(const Packet2d& a, const Packet2d& b)
function Packet2d (line 3809) | Packet2d pcmp_eq(const Packet2d& a, const Packet2d& b)
function Packet2d (line 3844) | Packet2d preverse(const Packet2d& a)
function Packet2d (line 3847) | Packet2d pabs(const Packet2d& a) { return vabsq_f64(a); }
function ptranspose (line 3877) | void
function Packet2d (line 3908) | Packet2d prsqrt(const Packet2d& a) {
function Packet2d (line 3919) | Packet2d psqrt(const Packet2d& _x){ return vsqrtq_f64(_x); }
type float16x4_t (line 3925) | typedef float16x4_t Packet4hf;
type float16x8_t (line 3926) | typedef float16x8_t Packet8hf;
function default_packet_traits (line 3929) | struct packet_traits<Eigen::half> : default_packet_traits {
function Packet4hf (line 3973) | struct unpacket_traits<Packet4hf> {
function Packet8hf (line 3986) | struct unpacket_traits<Packet8hf> {
function Packet8hf (line 4048) | Packet8hf pnegate(const Packet8hf& a) {
function Packet4hf (line 4053) | Packet4hf pnegate(const Packet4hf& a) {
function Packet8hf (line 4058) | Packet8hf pconj(const Packet8hf& a) {
function Packet4hf (line 4063) | Packet4hf pconj(const Packet4hf& a) {
function Packet8hf (line 4088) | Packet8hf pmadd(const Packet8hf& a, const Packet8hf& b, const Packet8hf&...
function Packet4hf (line 4093) | Packet4hf pmadd(const Packet4hf& a, const Packet4hf& b, const Packet4hf&...
function Packet8hf (line 4298) | Packet8hf pinsertfirst(const Packet8hf& a, Eigen::half b) { return vsetq...
function Packet4hf (line 4300) | Packet4hf pinsertfirst(const Packet4hf& a, Eigen::half b) { return vset_...
function Packet8hf (line 4312) | Packet8hf pinsertlast(const Packet8hf& a, Eigen::half b) { return vsetq_...
function Packet4hf (line 4314) | Packet4hf pinsertlast(const Packet4hf& a, Eigen::half b) { return vset_l...
function Packet8hf (line 4403) | Packet8hf preverse(const Packet8hf& a) {
function ptranspose (line 4527) | void ptranspose(PacketBlock<Packet8hf, 4>& kernel)
function ptranspose (line 4541) | void ptranspose(PacketBlock<Packet4hf, 4>& kernel) {
function ptranspose (line 4552) | void ptranspose(PacketBlock<Packet8hf, 8>& kernel) {
FILE: Obfuscation/include/Eigen/src/Core/arch/NEON/TypeCasting.h
function namespace (line 14) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/SSE/Complex.h
function namespace (line 13) | namespace Eigen {
function Packet2cf (line 156) | Packet2cf preverse(const Packet2cf& a) { return Packet2cf(_mm_castpd_ps(...
function EIGEN_STRONG_INLINE (line 168) | EIGEN_STRONG_INLINE Packet2cf pcplxflip/* <Packet2cf> */(const Packet2cf...
type Packet1cd (line 186) | struct Packet1cd
type packet_traits (line 196) | struct packet_traits
function default_packet_traits (line 196) | double> > : default_packet_traits
function Packet1cd (line 221) | struct unpacket_traits<Packet1cd> {
function Packet1cd (line 236) | Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2...
function Packet1cd (line 237) | Packet1cd pconj(const Packet1cd& a)
function Packet1cd (line 286) | Packet1cd preverse(const Packet1cd& a) { return a; }
function EIGEN_STRONG_INLINE (line 308) | EIGEN_STRONG_INLINE Packet1cd pcplxflip/* <Packet1cd> */(const Packet1cd...
function Packet2cf (line 323) | Packet2cf pcmp_eq(const Packet2cf& a, const Packet2cf& b)
function Packet1cd (line 329) | Packet1cd pcmp_eq(const Packet1cd& a, const Packet1cd& b)
function Packet2cf (line 335) | Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacke...
FILE: Obfuscation/include/Eigen/src/Core/arch/SSE/MathFunctions.h
function namespace (line 18) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/SSE/PacketMath.h
function namespace (line 13) | namespace Eigen {
function Packet4f (line 266) | Packet4f peven_mask(const Packet4f& /*a*/) { return _mm_castsi128_ps(_mm...
function Packet4i (line 267) | Packet4i peven_mask(const Packet4i& /*a*/) { return _mm_set_epi32(0, -1,...
function Packet2d (line 268) | Packet2d peven_mask(const Packet2d& /*a*/) { return _mm_castsi128_pd(_mm...
function Packet4f (line 270) | Packet4f pzero(const Packet4f& /*a*/) { return _mm_setzero_ps(); }
function Packet2d (line 271) | Packet2d pzero(const Packet2d& /*a*/) { return _mm_setzero_pd(); }
function Packet4i (line 272) | Packet4i pzero(const Packet4i& /*a*/) { return _mm_setzero_si128(); }
function Packet4f (line 322) | Packet4f pnegate(const Packet4f& a)
function Packet2d (line 327) | Packet2d pnegate(const Packet2d& a)
function Packet4i (line 332) | Packet4i pnegate(const Packet4i& a)
function Packet16b (line 337) | Packet16b pnegate(const Packet16b& a)
function Packet4f (line 342) | Packet4f pconj(const Packet4f& a) { return a; }
function Packet2d (line 343) | Packet2d pconj(const Packet2d& a) { return a; }
function Packet4i (line 344) | Packet4i pconj(const Packet4i& a) { return a; }
function Packet4i (line 370) | Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) ...
function Packet4f (line 372) | Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c) ...
function Packet2d (line 373) | Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) ...
function Packet4f (line 377) | inline Packet4f pselect(const Packet4f& mask, const Packet4f& a, const P...
function Packet4i (line 381) | inline Packet4i pselect(const Packet4i& mask, const Packet4i& a, const P...
function Packet2d (line 385) | inline Packet2d pselect(const Packet2d& mask, const Packet2d& a, const P...
function Packet16b (line 387) | inline Packet16b pselect(const Packet16b& mask, const Packet16b& a, cons...
function Packet16b (line 391) | inline Packet16b pselect(const Packet16b& mask, const Packet16b& a, cons...
function Packet4f (line 431) | Packet4f pcmp_le(const Packet4f& a, const Packet4f& b) { return _mm_cmpl...
function Packet4f (line 432) | Packet4f pcmp_lt(const Packet4f& a, const Packet4f& b) { return _mm_cmpl...
function Packet4f (line 433) | Packet4f pcmp_lt_or_nan(const Packet4f& a, const Packet4f& b) { return _...
function Packet4f (line 434) | Packet4f pcmp_eq(const Packet4f& a, const Packet4f& b) { return _mm_cmpe...
function Packet2d (line 436) | Packet2d pcmp_le(const Packet2d& a, const Packet2d& b) { return _mm_cmpl...
function Packet2d (line 437) | Packet2d pcmp_lt(const Packet2d& a, const Packet2d& b) { return _mm_cmpl...
function Packet2d (line 438) | Packet2d pcmp_lt_or_nan(const Packet2d& a, const Packet2d& b) { return _...
function Packet2d (line 439) | Packet2d pcmp_eq(const Packet2d& a, const Packet2d& b) { return _mm_cmpe...
function Packet4i (line 441) | Packet4i pcmp_lt(const Packet4i& a, const Packet4i& b) { return _mm_cmpl...
function Packet4i (line 442) | Packet4i pcmp_eq(const Packet4i& a, const Packet4i& b) { return _mm_cmpe...
function Packet16b (line 443) | Packet16b pcmp_eq(const Packet16b& a, const Packet16b& b) { return _mm_c...
function Packet4i (line 444) | Packet4i pcmp_le(const Packet4i& a, const Packet4i& b) { return por(pcmp...
function Packet (line 546) | Packet pminmax_propagate_numbers(const Packet& a, const Packet& b, Op op) {
function Packet (line 555) | Packet pminmax_propagate_nan(const Packet& a, const Packet& b, Op op) {
function Packet4i (line 597) | Packet4i parithmetic_shift_right(const Packet4i& a) { return _mm_srai_ep...
function Packet4i (line 598) | Packet4i plogical_shift_right (const Packet4i& a) { return _mm_srli_ep...
function Packet4i (line 599) | Packet4i plogical_shift_left (const Packet4i& a) { return _mm_slli_ep...
function Packet4f (line 601) | Packet4f pabs(const Packet4f& a)
function Packet2d (line 606) | Packet2d pabs(const Packet2d& a)
function Packet4i (line 611) | Packet4i pabs(const Packet4i& a)
function Packet4f (line 646) | Packet4f print(const Packet4f& a) {
function Packet2d (line 660) | Packet2d print(const Packet2d& a) {
function Index (line 827) | Index stride)
function EIGEN_STRONG_INLINE (line 979) | EIGEN_STRONG_INLINE void punpackp(Packet4f* vecs)
function pmadd (line 1275) | float pmadd(const float& a, const float& b, const float& c) {
function pmadd (line 1278) | double pmadd(const double& a, const double& b, const double& c) {
type Packet4h (line 1289) | typedef struct {
function Packet4h (line 1294) | struct is_arithmetic<Packet4h> { enum { value = true }; }
function default_packet_traits (line 1297) | struct packet_traits<Eigen::half> : default_packet_traits {
function Packet4h (line 1326) | struct unpacket_traits<Packet4h> { typedef Eigen::half type; enum {size=...
function Packet4h (line 1338) | Packet4h pconj(const Packet4h& a) { return a; }
function __m128 (line 1497) | static inline __m128 _mm_castpd_ps (__m128d x) { return reinterpret_c...
function __m128i (line 1498) | static inline __m128i _mm_castpd_si128(__m128d x) { return reinterpret_c...
function __m128d (line 1499) | static inline __m128d _mm_castps_pd (__m128 x) { return reinterpret_c...
function __m128i (line 1500) | static inline __m128i _mm_castps_si128(__m128 x) { return reinterpret_c...
function __m128 (line 1501) | static inline __m128 _mm_castsi128_ps(__m128i x) { return reinterpret_c...
function __m128d (line 1502) | static inline __m128d _mm_castsi128_pd(__m128i x) { return reinterpret_c...
FILE: Obfuscation/include/Eigen/src/Core/arch/SSE/TypeCasting.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/SVE/MathFunctions.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/SVE/PacketMath.h
function namespace (line 13) | namespace Eigen
function PacketXi (line 108) | PacketXi pnegate(const PacketXi& a)
function PacketXi (line 114) | PacketXi pconj(const PacketXi& a)
function PacketXi (line 132) | PacketXi pmadd(const PacketXi& a, const PacketXi& b, const PacketXi& c)
function PacketXi (line 204) | PacketXi parithmetic_shift_right(PacketXi a)
function PacketXi (line 210) | PacketXi plogical_shift_right(PacketXi a)
function PacketXi (line 216) | PacketXi plogical_shift_left(PacketXi a)
function PacketXi (line 286) | PacketXi preverse(const PacketXi& a)
function PacketXi (line 292) | PacketXi pabs(const PacketXi& a)
function ptranspose (line 351) | inline void ptranspose(PacketBlock<PacketXi, N>& kernel) {
type svfloat32_t (line 367) | typedef svfloat32_t PacketXf __attribute__((arm_sve_vector_bits(EIGEN_AR...
function default_packet_traits (line 370) | struct packet_traits<float> : default_packet_traits {
function PacketXf (line 409) | struct unpacket_traits<PacketXf> {
function PacketXf (line 456) | PacketXf pnegate(const PacketXf& a)
function PacketXf (line 462) | PacketXf pconj(const PacketXf& a)
function PacketXf (line 480) | PacketXf pmadd(const PacketXf& a, const PacketXf& b, const PacketXf& c)
function PacketXf (line 652) | PacketXf preverse(const PacketXf& a)
function PacketXf (line 658) | PacketXf pabs(const PacketXf& a)
function ptranspose (line 727) | inline void ptranspose(PacketBlock<PacketXf, N>& kernel)
FILE: Obfuscation/include/Eigen/src/Core/arch/SVE/TypeCasting.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/SYCL/InteropHeaders.h
function namespace (line 24) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/SYCL/MathFunctions.h
function namespace (line 23) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/SYCL/PacketMath.h
function namespace (line 24) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h
function namespace (line 36) | namespace Eigen {
function clear (line 323) | inline void clear() {
function virtual_pointer_t (line 331) | inline virtual_pointer_t add_pointer(const buffer_t &b) {
function virtual_pointer_t (line 338) | inline virtual_pointer_t add_pointer(buffer_t &&b) {
function fuse_forward (line 348) | void fuse_forward(typename pointerMap_t::iterator &node) {
function fuse_backward (line 370) | void fuse_backward(typename pointerMap_t::iterator &node) {
function pMapNode_t (line 431) | pMapNode_t p{b, bufSize, false};
type T (line 549) | typedef T scalar_t;
type scalar_t (line 550) | typedef scalar_t &ref_t;
type typename (line 551) | typedef typename cl::sycl::global_ptr<scalar_t>::pointer_t ptr_t;
type cl (line 554) | typedef cl::sycl::accessor<scalar_t, 1, AcMd, global_access, is_place_ho...
type RangeAccess (line 557) | typedef RangeAccess<AcMd, T> self_t;
function i (line 598) | nullptr_t i) {
function set_offset (line 633) | void set_offset(std::ptrdiff_t offset) {
function ref_t (line 637) | ref_t operator*() const {
function ref_t (line 641) | ref_t operator*() {
function ref_t (line 647) | ref_t operator[](int x) {
function ref_t (line 651) | ref_t operator[](int x) const {
function scalar_t (line 655) | scalar_t *get_virtual_pointer() const {
function bind (line 673) | void bind(
type RangeAccess (line 686) | typedef RangeAccess<AcMd, T> Base;
FILE: Obfuscation/include/Eigen/src/Core/arch/SYCL/TypeCasting.h
function namespace (line 24) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/ZVector/Complex.h
function namespace (line 14) | namespace Eigen {
function Packet1cd (line 119) | Packet1cd pnegate(const Packet1cd& a) { return Packet1cd(pnegate(Packet2...
function Packet1cd (line 120) | Packet1cd pconj(const Packet1cd& a) { return Packet1cd((Packet2d)vec_xor...
function Packet1cd (line 143) | Packet1cd pcmp_eq(const Packet1cd& a, const Packet1cd& b) {
function Packet1cd (line 159) | Packet1cd preverse(const Packet1cd& a) { return a; }
function EIGEN_STRONG_INLINE (line 178) | EIGEN_STRONG_INLINE Packet1cd pcplxflip/*<Packet1cd>*/(const Packet1cd& x)
function Packet2cf (line 243) | Packet2cf pnegate(const Packet2cf& a) { return Packet2cf(pnegate(Packet4...
function Packet2cf (line 257) | Packet2cf pcmp_eq(const Packet2cf& a, const Packet2cf& b) {
function Packet2cf (line 267) | Packet2cf pconj(const Packet2cf& a)
function Packet2cf (line 283) | Packet2cf preverse(const Packet2cf& a)
function EIGEN_STRONG_INLINE (line 318) | EIGEN_STRONG_INLINE Packet2cf pcplxflip/*<Packet2cf>*/(const Packet2cf& x)
function Packet2cf (line 333) | Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacke...
function Packet2cf (line 340) | Packet2cf pcmp_eq(const Packet2cf& a, const Packet2cf& b) {
function Packet2cf (line 345) | Packet2cf pconj(const Packet2cf& a) { return Packet2cf(pxor<Packet4f>(a....
function Packet2cf (line 368) | Packet2cf preverse(const Packet2cf& a)
function Packet2cf (line 415) | Packet2cf pblend(const Selector<2>& ifPacket, const Packet2cf& thenPacke...
FILE: Obfuscation/include/Eigen/src/Core/arch/ZVector/MathFunctions.h
function namespace (line 19) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/arch/ZVector/PacketMath.h
function namespace (line 13) | namespace Eigen {
function Packet4i (line 407) | Packet4i pnegate(const Packet4i& a) { return (-a); }
function Packet2d (line 408) | Packet2d pnegate(const Packet2d& a) { return (-a); }
function Packet4i (line 410) | Packet4i pconj(const Packet4i& a) { return a; }
function Packet2d (line 411) | Packet2d pconj(const Packet2d& a) { return a; }
function Packet4i (line 413) | Packet4i pmadd(const Packet4i& a, const Packet4i& b, const Packet4i& c) ...
function Packet2d (line 414) | Packet2d pmadd(const Packet2d& a, const Packet2d& b, const Packet2d& c) ...
function Packet4i (line 466) | Packet4i preverse(const Packet4i& a)
function Packet2d (line 471) | Packet2d preverse(const Packet2d& a)
function Packet4i (line 560) | Packet4i pblend(const Selector<4>& ifPacket, const Packet4i& thenPacket,...
function Packet2d (line 567) | Packet2d pblend(const Selector<2>& ifPacket, const Packet2d& thenPacket,...
function Packet4f (line 579) | Packet4f vec_splat_packet4f(const Packet4f& from)
function Packet4f (line 692) | Packet4f pnegate(const Packet4f& a)
function Packet4f (line 700) | Packet4f pmadd(const Packet4f& a, const Packet4f& b, const Packet4f& c)
function Packet4f (line 790) | Packet4f preverse(const Packet4f& a)
function Packet4f (line 874) | Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket,...
function Packet4f (line 989) | Packet4f preverse(const Packet4f& a)
function Packet4f (line 1043) | Packet4f pblend(const Selector<4>& ifPacket, const Packet4f& thenPacket,...
FILE: Obfuscation/include/Eigen/src/Core/functors/AssignmentFunctors.h
function namespace (line 13) | namespace Eigen {
function assignCoeff (line 70) | void assignCoeff(DstScalar& a, const SrcScalar& b) const { a -= b; }
function assignPacket (line 73) | void assignPacket(DstScalar* a, const Packet& b) const
function assignCoeff (line 92) | void assignCoeff(DstScalar& a, const SrcScalar& b) const { a *= b; }
function assignPacket (line 95) | void assignPacket(DstScalar* a, const Packet& b) const
function assignCoeff (line 113) | void assignCoeff(DstScalar& a, const SrcScalar& b) const { a /= b; }
function assignPacket (line 116) | void assignPacket(DstScalar* a, const Packet& b) const
function assignCoeff (line 145) | void assignCoeff(Scalar& a, const Scalar& b) const
FILE: Obfuscation/include/Eigen/src/Core/functors/BinaryFunctors.h
function namespace (line 13) | namespace Eigen {
function const (line 98) | bool>::operator() (const bool& a, const bool& b) const { return a && b; }
type typename (line 114) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_conj_pr...
function EIGEN_STRONG_INLINE (line 117) | EIGEN_STRONG_INLINE result_type operator() (const LhsScalar& a, const Rh...
function EIGEN_STRONG_INLINE (line 121) | EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const
type typename (line 140) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_min_op>...
function EIGEN_STRONG_INLINE (line 142) | EIGEN_STRONG_INLINE result_type operator() (const LhsScalar& a, const Rh...
function EIGEN_STRONG_INLINE (line 146) | EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const
type typename (line 173) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_max_op>...
function EIGEN_STRONG_INLINE (line 175) | EIGEN_STRONG_INLINE result_type operator() (const LhsScalar& a, const Rh...
function EIGEN_STRONG_INLINE (line 179) | EIGEN_STRONG_INLINE Packet packetOp(const Packet& a, const Packet& b) const
function const (line 223) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a=...
function const (line 230) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a<b;}
function const (line 237) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a<...
function const (line 244) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a>b;}
function const (line 251) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a>...
function const (line 258) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return !(...
function const (line 265) | bool operator()(const LhsScalar& a, const RhsScalar& b) const {return a!...
function Scalar (line 278) | const Scalar operator() (const Scalar &x, const Scalar &y) const
type typename (line 306) | typedef typename ScalarBinaryOpTraits<Scalar,Exponent,scalar_pow_op>::Re...
type Scalar (line 311) | typedef Scalar LhsScalar;
type Exponent (line 312) | typedef Exponent RhsScalar;
function EIGEN_DEVICE_FUNC (line 317) | EIGEN_DEVICE_FUNC
function Packet (line 321) | const Packet packetOp(const Packet& a, const Packet& b) const
type typename (line 351) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_differe...
function result_type (line 359) | const result_type operator() (const LhsScalar& a, const RhsScalar& b) co...
function Packet (line 361) | const Packet packetOp(const Packet& a, const Packet& b) const
type typename (line 380) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_quotien...
function result_type (line 388) | const result_type operator() (const LhsScalar& a, const RhsScalar& b) co...
function Packet (line 390) | const Packet packetOp(const Packet& a, const Packet& b) const
type scalar_boolean_and_op (line 409) | struct scalar_boolean_and_op {
function EIGEN_STRONG_INLINE (line 413) | EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet&...
function scalar_boolean_and_op (line 416) | struct functor_traits<scalar_boolean_and_op> {
type scalar_boolean_or_op (line 428) | struct scalar_boolean_or_op {
function EIGEN_STRONG_INLINE (line 432) | EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet&...
function scalar_boolean_or_op (line 435) | struct functor_traits<scalar_boolean_or_op> {
type scalar_boolean_xor_op (line 447) | struct scalar_boolean_xor_op {
function EIGEN_STRONG_INLINE (line 451) | EIGEN_STRONG_INLINE const Packet packetOp(const Packet& a, const Packet&...
function scalar_boolean_xor_op (line 454) | struct functor_traits<scalar_boolean_xor_op> {
type typename (line 469) | typedef typename ScalarBinaryOpTraits<LhsScalar,RhsScalar,scalar_absolut...
function result_type (line 477) | const result_type operator() (const LhsScalar& a, const RhsScalar& b) const
function Packet (line 480) | const Packet packetOp(const Packet& a, const Packet& b) const
type typename (line 501) | typedef typename BinaryOp::first_argument_type first_argument_type;
type typename (line 502) | typedef typename BinaryOp::second_argument_type second_argument_type;
type typename (line 503) | typedef typename BinaryOp::result_type result_type;
function EIGEN_DEVICE_FUNC (line 505) | EIGEN_DEVICE_FUNC explicit bind1st_op(const first_argument_type &val) : ...
function result_type (line 507) | const result_type operator() (const second_argument_type& b) const { ret...
function Packet (line 510) | const Packet packetOp(const Packet& b) const
type typename (line 520) | typedef typename BinaryOp::first_argument_type first_argument_type;
type typename (line 521) | typedef typename BinaryOp::second_argument_type second_argument_type;
type typename (line 522) | typedef typename BinaryOp::result_type result_type;
function EIGEN_DEVICE_FUNC (line 524) | EIGEN_DEVICE_FUNC explicit bind2nd_op(const second_argument_type &val) :...
function result_type (line 526) | const result_type operator() (const first_argument_type& a) const { retu...
function Packet (line 529) | const Packet packetOp(const Packet& a) const
FILE: Obfuscation/include/Eigen/src/Core/functors/NullaryFunctors.h
function namespace (line 13) | namespace Eigen {
function Scalar (line 102) | const Scalar operator() (IndexType i) const
function EIGEN_DEVICE_FUNC (line 132) | EIGEN_DEVICE_FUNC linspaced_op(const Scalar& low, const Scalar& high, In...
function Scalar (line 137) | const Scalar operator() (IndexType i) const { return impl(i); }
function EIGEN_STRONG_INLINE (line 140) | EIGEN_STRONG_INLINE const Packet packetOp(IndexType i) const { return im...
FILE: Obfuscation/include/Eigen/src/Core/functors/StlFunctors.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/functors/TernaryFunctors.h
function namespace (line 13) | namespace Eigen {
FILE: Obfuscation/include/Eigen/src/Core/functors/UnaryFunctors.h
function namespace (line 13) | namespace Eigen {
function EIGEN_STRONG_INLINE (line 178) | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const
function Packet (line 181) | const Packet packetOp(const Packet& a) const
function EIGEN_STRONG_INLINE (line 197) | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const
function Packet (line 200) | const Packet packetOp(const Packet& a) const
function result_type (line 217) | result_type operator() (const Scalar& a) const { return numext::real(a); }
function result_type (line 233) | result_type operator() (const Scalar& a) const { return numext::imag(a); }
function Scalar (line 279) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 281) | inline Packet packetOp(const Packet& a) const { return internal::pexp(a); }
function Scalar (line 319) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 321) | inline Packet packetOp(const Packet& a) const { return internal::pexpm1(...
function Scalar (line 339) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 341) | inline Packet packetOp(const Packet& a) const { return internal::plog(a); }
function Scalar (line 370) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 372) | inline Packet packetOp(const Packet& a) const { return internal::plog1p(...
function Scalar (line 390) | inline const Scalar operator() (const Scalar& a) const { EIGEN_USING_STD...
function Packet (line 392) | inline Packet packetOp(const Packet& a) const { return internal::plog10(...
function Scalar (line 406) | inline const Scalar operator() (const Scalar& a) const { return Scalar(E...
function Packet (line 408) | inline Packet packetOp(const Packet& a) const { return internal::plog2(a...
function Scalar (line 420) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 422) | inline Packet packetOp(const Packet& a) const { return internal::psqrt(a...
function bool (line 442) | struct scalar_sqrt_op<bool> {
type functor_traits (line 449) | struct functor_traits
function Scalar (line 459) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 461) | inline Packet packetOp(const Packet& a) const { return internal::prsqrt(...
function Scalar (line 478) | inline Scalar operator() (const Scalar& a) const { return numext::cos(a); }
function Packet (line 480) | inline Packet packetOp(const Packet& a) const { return internal::pcos(a); }
function Scalar (line 497) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 499) | inline Packet packetOp(const Packet& a) const { return internal::psin(a); }
function Scalar (line 517) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 519) | inline Packet packetOp(const Packet& a) const { return internal::ptan(a); }
function Scalar (line 536) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 538) | inline Packet packetOp(const Packet& a) const { return internal::pacos(a...
function Scalar (line 555) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 557) | inline Packet packetOp(const Packet& a) const { return internal::pasin(a...
function Scalar (line 575) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 577) | inline Packet packetOp(const Packet& a) const { return internal::patan(a...
function Scalar (line 595) | inline const Scalar operator()(const Scalar& a) const { return numext::t...
function Packet (line 597) | inline Packet packetOp(const Packet& x) const { return ptanh(x); }
function Scalar (line 633) | inline const Scalar operator()(const Scalar& a) const { return numext::a...
function Scalar (line 648) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 650) | inline Packet packetOp(const Packet& a) const { return internal::psinh(a...
function Scalar (line 669) | inline const Scalar operator()(const Scalar& a) const { return numext::a...
function Scalar (line 684) | inline const Scalar operator() (const Scalar& a) const { return numext::...
function Packet (line 686) | inline Packet packetOp(const Packet& a) const { return internal::pcosh(a...
function Scalar (line 705) | inline const Scalar operator()(const Scalar& a) const { return numext::a...
function Scalar (line 721) | inline Scalar operator() (const Scalar& a) const { return Scalar(1)/a; }
function Packet (line 723) | inline const Packet packetOp(const Packet& a) const
function Scalar (line 741) | inline Scalar operator() (const Scalar& a) const { return a*a; }
function Packet (line 743) | inline const Packet packetOp(const Packet& a) const
function bool (line 752) | struct scalar_square_op<bool> {
type functor_traits (line 760) | struct functor_traits
function Scalar (line 770) | inline Scalar operator() (const Scalar& a) const { return a*a*a; }
function Packet (line 772) | inline const Packet packetOp(const Packet& a) const
function bool (line 781) | struct scalar_cube_op<bool> {
type functor_traits (line 789) | struct functor_traits
function EIGEN_STRONG_INLINE (line 798) | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { re...
function Packet (line 800) | inline Packet packetOp(const Packet& a) const { return internal::pround(...
function EIGEN_STRONG_INLINE (line 817) | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { re...
function Packet (line 819) | inline Packet packetOp(const Packet& a) const { return internal::pfloor(...
function EIGEN_STRONG_INLINE (line 836) | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { re...
function Packet (line 838) | inline Packet packetOp(const Packet& a) const { return internal::print(a...
function EIGEN_STRONG_INLINE (line 855) | EIGEN_STRONG_INLINE const Scalar operator() (const Scalar& a) const { re...
function Packet (line 857) | inline Packet packetOp(const Packet& a) const { return internal::pceil(a...
function result_type (line 875) | result_type operator() (const Scalar& a) const {
function result_type (line 899) | result_type operator() (const Scalar& a) const {
function result_type (line 923) | result_type operator() (const Scalar& a) const {
function const (line 947) | bool operator() (const bool& a) const { return !a; }
function EIGEN_DEVICE_FUNC (line 965) | EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const
function EIGEN_DEVICE_FUNC (line 977) | EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const
function EIGEN_DEVICE_FUNC (line 989) | EIGEN_DEVICE_FUNC inline const Scalar operator() (const Scalar& a) const
function EIGEN_STRONG_INLINE (line 1020) | EIGEN_STRONG_INLINE T operator()(const T& x) const {
function EIGEN_STRONG_INLINE (line 1024) | EIGEN_STRONG_INLINE
function float (line 1044) | struct scalar_logistic_op<float> {
FILE: Obfuscation/include/Eigen/src/Core/products/GeneralBlockPanelKernel.h
function namespace (line 14) | namespace Eigen {
function Packet (line 364) | const Packet& get(const FixedInt<0>&) const { return B_0; }
function Packet (line 365) | const Packet& get(const FixedInt<1>&) const { return B1; }
function Packet (line 366) | const Packet& get(const FixedInt<2>&) const { return B2; }
function Packet (line 367) | const Packet& get(const FixedInt<3>&) const { return B3; }
type T3 (line 371) | typedef T3 type;
type _RhsScalar (line 422) | typedef _RhsScalar RhsScalar;
type typename (line 423) | typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ...
type typename (line 460) | typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type Lh...
type typename (line 461) | typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type Rh...
type typename (line 462) | typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type Re...
type LhsPacket (line 463) | typedef LhsPacket LhsPacket4Packing;
type QuadPacket (line 465) | typedef QuadPacket<RhsPacket> RhsPacketx4;
type ResPacket (line 466) | typedef ResPacket AccPacket;
function loadRhs (line 474) | void loadRhs(const RhsScalar* b, RhsPacketType& dest) const
function EIGEN_STRONG_INLINE (line 479) | EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) ...
function updateRhs (line 485) | void updateRhs(const RhsScalar* b, RhsPacketType& dest) const
function EIGEN_STRONG_INLINE (line 490) | EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const
function EIGEN_STRONG_INLINE (line 494) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest...
function loadLhs (line 500) | void loadLhs(const LhsScalar* a, LhsPacketType& dest) const
function loadLhsUnaligned (line 506) | void loadLhsUnaligned(const LhsScalar* a, LhsPacketType& dest) const
function madd (line 512) | void madd(const LhsPacketType& a, const RhsPacketType& b, AccPacketType&...
function madd (line 528) | void madd(const LhsPacketType& a, const RhsPacketx4& b, AccPacketType& c...
function EIGEN_STRONG_INLINE (line 533) | EIGEN_STRONG_INLINE void acc(const AccPacket& c, const ResPacket& alpha,...
function acc (line 539) | void acc(const ResPacketHalf& c, const ResPacketHalf& alpha, ResPacketHa...
type std (line 550) | typedef std::complex<RealScalar> LhsScalar;
type RealScalar (line 551) | typedef RealScalar RhsScalar;
type typename (line 552) | typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ...
type typename (line 579) | typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type Lh...
type typename (line 580) | typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type Rh...
type typename (line 581) | typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type Re...
type LhsPacket (line 582) | typedef LhsPacket LhsPacket4Packing;
type QuadPacket (line 584) | typedef QuadPacket<RhsPacket> RhsPacketx4;
type ResPacket (line 586) | typedef ResPacket AccPacket;
function loadRhs (line 594) | void loadRhs(const RhsScalar* b, RhsPacketType& dest) const
function EIGEN_STRONG_INLINE (line 599) | EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) ...
function updateRhs (line 605) | void updateRhs(const RhsScalar* b, RhsPacketType& dest) const
function EIGEN_STRONG_INLINE (line 610) | EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const
function EIGEN_STRONG_INLINE (line 613) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest...
function EIGEN_STRONG_INLINE (line 618) | EIGEN_STRONG_INLINE void loadRhsQuad_impl(const RhsScalar* b, RhsPacket&...
function EIGEN_STRONG_INLINE (line 626) | EIGEN_STRONG_INLINE void loadRhsQuad_impl(const RhsScalar* b, RhsPacket&...
function EIGEN_STRONG_INLINE (line 632) | EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
function loadLhsUnaligned (line 638) | void loadLhsUnaligned(const LhsScalar* a, LhsPacketType& dest) const
function madd (line 644) | void madd(const LhsPacketType& a, const RhsPacketType& b, AccPacketType&...
function madd_impl (line 650) | void madd_impl(const LhsPacketType& a, const RhsPacketType& b, AccPacket...
function EIGEN_STRONG_INLINE (line 660) | EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& ...
function madd (line 666) | void madd(const LhsPacketType& a, const RhsPacketx4& b, AccPacketType& c...
function acc (line 672) | void acc(const AccPacketType& c, const ResPacketType& alpha, ResPacketTy...
type std (line 716) | typedef std::complex<typename
type typename (line 717) | typedef typename packet_traits<Cplx>::type CplxPacket;
type DoublePacket (line 746) | typedef DoublePacket<typename
type std (line 762) | typedef std::complex<RealScalar> LhsScalar;
type std (line 763) | typedef std::complex<RealScalar> RhsScalar;
type std (line 764) | typedef std::complex<RealScalar> ResScalar;
type DoublePacket (line 790) | typedef DoublePacket<RealPacket> DoublePacketType;
type typename (line 792) | typedef typename conditional<Vectorizable,ScalarPacket,Scalar>::type Lhs...
type typename (line 793) | typedef typename conditional<Vectorizable,RealPacket, Scalar>::type Lhs...
type typename (line 794) | typedef typename conditional<Vectorizable,DoublePacketType,Scalar>::type...
type typename (line 795) | typedef typename conditional<Vectorizable,ScalarPacket,Scalar>::type Res...
type typename (line 796) | typedef typename conditional<Vectorizable,DoublePacketType,Scalar>::type...
type QuadPacket (line 799) | typedef QuadPacket<RhsPacket> RhsPacketx4;
function EIGEN_STRONG_INLINE (line 810) | EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, ScalarPacket& dest)...
function loadRhs (line 817) | void loadRhs(const RhsScalar* b, DoublePacket<RealPacketType>& dest) const
function EIGEN_STRONG_INLINE (line 823) | EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) ...
function EIGEN_STRONG_INLINE (line 832) | EIGEN_STRONG_INLINE void updateRhs(const RhsScalar* b, ScalarPacket& des...
function updateRhs (line 839) | void updateRhs(const RhsScalar* b, DoublePacket<RealPacketType>& dest) c...
function EIGEN_STRONG_INLINE (line 844) | EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const {}
function EIGEN_STRONG_INLINE (line 846) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, ResPacket& dest...
function EIGEN_STRONG_INLINE (line 850) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, DoublePacketTyp...
function EIGEN_STRONG_INLINE (line 856) | EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
function loadLhsUnaligned (line 862) | void loadLhsUnaligned(const LhsScalar* a, LhsPacketType& dest) const
function acc (line 891) | void acc(const DoublePacket<RealPacketType>& c, const ResPacketType& alp...
type RealScalar (line 928) | typedef RealScalar LhsScalar;
type Scalar (line 929) | typedef Scalar RhsScalar;
type Scalar (line 930) | typedef Scalar ResScalar;
type typename (line 961) | typedef typename conditional<Vectorizable,_LhsPacket,LhsScalar>::type Lh...
type typename (line 962) | typedef typename conditional<Vectorizable,_RhsPacket,RhsScalar>::type Rh...
type typename (line 963) | typedef typename conditional<Vectorizable,_ResPacket,ResScalar>::type Re...
type LhsPacket (line 964) | typedef LhsPacket LhsPacket4Packing;
type QuadPacket (line 965) | typedef QuadPacket<RhsPacket> RhsPacketx4;
type ResPacket (line 966) | typedef ResPacket AccPacket;
function loadRhs (line 974) | void loadRhs(const RhsScalar* b, RhsPacketType& dest) const
function EIGEN_STRONG_INLINE (line 979) | EIGEN_STRONG_INLINE void loadRhs(const RhsScalar* b, RhsPacketx4& dest) ...
function updateRhs (line 985) | void updateRhs(const RhsScalar* b, RhsPacketType& dest) const
function EIGEN_STRONG_INLINE (line 990) | EIGEN_STRONG_INLINE void updateRhs(const RhsScalar*, RhsPacketx4&) const
function EIGEN_STRONG_INLINE (line 993) | EIGEN_STRONG_INLINE void loadLhs(const LhsScalar* a, LhsPacket& dest) const
function EIGEN_STRONG_INLINE (line 998) | EIGEN_STRONG_INLINE void loadRhsQuad(const RhsScalar* b, RhsPacket& dest...
function loadLhsUnaligned (line 1004) | void loadLhsUnaligned(const LhsScalar* a, LhsPacketType& dest) const
function madd (line 1010) | void madd(const LhsPacketType& a, const RhsPacketType& b, AccPacketType&...
function madd_impl (line 1016) | void madd_impl(const LhsPacketType& a, const RhsPacketType& b, AccPacket...
function EIGEN_STRONG_INLINE (line 1027) | EIGEN_STRONG_INLINE void madd_impl(const LhsScalar& a, const RhsScalar& ...
function madd (line 1033) | void madd(const LhsPacketType& a, const RhsPacketx4& b, AccPacketType& c...
function acc (line 1039) | void acc(const AccPacketType& c, const ResPacketType& alpha, ResPacketTy...
type gebp_traits (line 1059) | typedef gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs,Archit...
type gebp_traits (line 1060) | typedef gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs,Archit...
type gebp_traits (line 1061) | typedef gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs,Archit...
type typename (line 1063) | typedef typename Traits::ResScalar ResScalar;
type typename (line 1064) | typedef typename Traits::LhsPacket LhsPacket;
type typename (line 1065) | typedef typename Traits::RhsPacket RhsPacket;
type typename (line 1066) | typedef typename Traits::ResPacket ResPacket;
type typename (line 1067) | typedef typename Traits::AccPacket AccPacket;
type typename (line 1068) | typedef typename Traits::RhsPacketx4 RhsPacketx4;
type typename (line 1070) | typedef typename RhsPanelHelper<RhsPacket, RhsPacketx4, 15>::type RhsPan...
type gebp_traits (line 1072) | typedef gebp_traits<RhsScalar,LhsScalar,ConjugateRhs,ConjugateLhs,Archit...
type typename (line 1074) | typedef typename SwappedTraits::ResScalar SResScalar;
type typename (line 1075) | typedef typename SwappedTraits::LhsPacket SLhsPacket;
type typename (line 1076) | typedef typename SwappedTraits::RhsPacket SRhsPacket;
type typename (line 1077) | typedef typename SwappedTraits::ResPacket SResPacket;
type typename (line 1078) | typedef typename SwappedTraits::AccPacket SAccPacket;
type typename (line 1080) | typedef typename HalfTraits::LhsPacket LhsPacketHalf;
type typename (line 1081) | typedef typename HalfTraits::RhsPacket RhsPacketHalf;
type typename (line 1082) | typedef typename HalfTraits::ResPacket ResPacketHalf;
type typename (line 1083) | typedef typename HalfTraits::AccPacket AccPacketHalf;
type typename (line 1085) | typedef typename QuarterTraits::LhsPacket LhsPacketQuarter;
type typename (line 1086) | typedef typename QuarterTraits::RhsPacket RhsPacketQuarter;
type typename (line 1087) | typedef typename QuarterTraits::ResPacket ResPacketQuarter;
type typename (line 1088) | typedef typename QuarterTraits::AccPacket AccPacketQuarter;
type typename (line 1090) | typedef typename DataMapper::LinearMapper LinearMapper;
type gebp_traits (line 1113) | typedef gebp_traits<LhsScalar,RhsScalar,ConjugateLhs,ConjugateRhs,Archit...
type gebp_traits (line 1114) | typedef gebp_traits<RhsScalar,LhsScalar,ConjugateRhs,ConjugateLhs,Archit...
type typename (line 1116) | typedef typename Traits::ResScalar ResScalar;
type typename (line 1117) | typedef typename SwappedTraits::LhsPacket SLhsPacket;
type typename (line 1118) | typedef typename SwappedTraits::RhsPacket SRhsPacket;
type typename (line 1119) | typedef typename SwappedTraits::ResPacket SResPacket;
type typename (line 1120) | typedef typename SwappedTraits::AccPacket SAccPacket;
function EIGEN_STRONG_INLINE (line 1122) | EIGEN_STRONG_INLINE void operator()(const DataMapper& res, SwappedTraits...
type gebp_traits (line 1143) | typedef gebp_traits<RhsScalar,LhsScalar,ConjugateRhs,ConjugateLhs,Archit...
type typename (line 1145) | typedef typename Traits::ResScalar ResScalar;
type typename (line 1146) | typedef typename SwappedTraits::LhsPacket SLhsPacket;
type typename (line 1147) | typedef typename SwappedTraits::RhsPacket SRhsPacket;
type typename (line 1148) | typedef typename SwappedTraits::ResPacket SResPacket;
type typename (line 1149) | typedef typename SwappedTraits::AccPacket SAccPacket;
function EIGEN_STRONG_INLINE (line 1151) | EIGEN_STRONG_INLINE void operator()(const DataMapper& res, SwappedTraits...
type typename (line 1192) | typedef typename GEBPTraits::RhsPacketx4 RhsPacketx4;
function EIGEN_STRONG_INLINE (line 1194) | EIGEN_STRONG_INLINE void peeled_kc_onestep(Index K, const LhsScalar* blA...
function EIGEN_STRONG_INLINE (line 1210) | EIGEN_STRONG_INLINE void operator()(
type typename (line 1977) | typedef typename conditional<SwappedTraits::LhsProgress>=8,typename
type typename (line 1978) | typedef typename conditional<SwappedTraits::LhsProgress>=8,typename
type typename (line 1979) | typedef typename conditional<SwappedTraits::LhsProgress>=8,typename
type typename (line 1980) | typedef typename conditional<SwappedTraits::LhsProgress>=8,typename
type typename (line 2100) | typedef typename unpacket_traits<typename unpacket_traits<Packet>::half>...
type typename (line 2256) | typedef typename unpacket_traits<typename unpacket_traits<Packet>::half>...
type typename (line 2380) | typedef typename DataMapper::LinearMapper LinearMapper;
type typename (line 2504) | typedef typename unpacket_traits<Packet>::half HalfPacket;
type typename (line 2505) | typedef typename unpacket_traits<typename unpacket_traits<Packet>::half>...
type typename (line 2506) | typedef typename DataMapper::LinearMapper LinearMapper;
function l1CacheSize (line 2607) | inline std::ptrdiff_t l1CacheSize()
function l2CacheSize (line 2616) | inline std::ptrdiff_t l2CacheSize()
function l3CacheSize (line 2626) | inline std::ptrdiff_t l3CacheSize()
function setCpuCacheSizes (line 2638) | inline void setCpuCacheSizes(std::ptrdiff_t l1, std::ptrdiff_t l2, std::...
FILE: Obfuscation/include/Eigen/src/Core/products/GeneralMatrixMatrix.h
function namespace (line 13) | namespace Eigen {
type typename (line 60) | typedef typename ScalarBinaryOpTraits<LhsScalar, RhsScalar>::ReturnType ...
type const_blas_data_mapper (line 70) | typedef const_blas_data_mapper<RhsScalar, Index, RhsStorageOrder> RhsMap...
type blas_data_mapper (line 71) | typedef blas_data_mapper<typename
function initParallelSession (line 219) | void initParallelSession(Index num_threads) const
type typename (line 237) | typedef typename Gemm::Traits Traits;
type _LhsScalar (line 253) | typedef _LhsScalar LhsScalar;
type _RhsScalar (line 254) | typedef _RhsScalar RhsScalar;
function LhsScalar (line 274) | inline LhsScalar* blockA() { return m_blockA; }
function RhsScalar (line 275) | inline RhsScalar* blockB() { return m_blockB; }
type typename (line 289) | typedef typename conditional<Transpose,_RhsScalar,_LhsScalar>::type LhsS...
type typename (line 290) | typedef typename conditional<Transpose,_LhsScalar,_RhsScalar>::type RhsS...
type gebp_traits (line 291) | typedef gebp_traits<LhsScalar,RhsScalar> Traits;
function initParallel (line 321) | void initParallel(Index, Index, Index, Index)
function allocateA (line 324) | inline void allocateA() {}
function allocateB (line 325) | inline void allocateB() {}
function allocateAll (line 326) | inline void allocateAll() {}
type typename (line 338) | typedef typename conditional<Transpose,_RhsScalar,_LhsScalar>::type LhsS...
type typename (line 339) | typedef typename conditional<Transpose,_LhsScalar,_RhsScalar>::type RhsS...
type gebp_traits (line 340) | typedef gebp_traits<LhsScalar,RhsScalar> Traits;
function initParallel (line 367) | void initParallel(Index rows, Index cols, Index depth, Index num_threads)
function allocateA (line 380) | void allocateA()
function allocateB (line 386) | void allocateB()
function allocateAll (line 392) | void allocateAll()
function namespace (line 407) | namespace internal {
FILE: Obfuscation/include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h
function namespace (line 13) | namespace Eigen {
type gebp_traits (line 141) | typedef gebp_traits<LhsScalar,RhsScalar,ConjLhs,ConjRhs> Traits;
type typename (
Condensed preview — 383 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (6,690K chars).
[
{
"path": ".gitignore",
"chars": 188,
"preview": "build\n.vscode\nDemo/*.ll\nllvm-pass-tutorial-dev\nSsagePass-master\nobfuscator-AutoRegistration\n*.cmake\n*/CMakeFiles\n*/CMake"
},
{
"path": "Demo/help.txt",
"chars": 86460,
"preview": "OVERVIEW: clang LLVM compiler\n\nUSAGE: clang-14 [options] file...\n\nOPTIONS:\n -### Print (but do not r"
},
{
"path": "Demo/main.cpp",
"chars": 438,
"preview": "// 本测试主要适配arm64方向\n#include <stdlib.h>\n#include <stdio.h>\n\nstatic int aaa = 88;\n\nint add(int a, int b) __attribute((__ann"
},
{
"path": "Demo/symbols_obf.yaml",
"chars": 113,
"preview": "function: { source: _Z3addii, target: dfffff} # 函数替换\nglobal variable: { source: _ZL3aaa, transform: ccccc} # 变量替换"
},
{
"path": "Obfuscation/CMakeLists.txt",
"chars": 2264,
"preview": "# 参考官方文档:https://llvm.org/docs/CMake.html#developing-llvm-passes-out-of-source\n# 参考文献资料:https://github.com/LeadroyaL/llv"
},
{
"path": "Obfuscation/include/BogusControlFlow.h",
"chars": 1705,
"preview": "#ifndef _BOGUSCONTROLFLOW_H_\n#define _BOGUSCONTROLFLOW_H_\n// LLVM libs\n#include \"llvm/Pass.h\"\n#include \"llvm/IR/Module.h"
},
{
"path": "Obfuscation/include/CryptoUtils.h",
"chars": 3789,
"preview": "//===- CryptoUtils.h - Cryptographically Secure Pseudo-Random Generator ---===//\n//\n// The LLVM Comp"
},
{
"path": "Obfuscation/include/Eigen/Cholesky",
"chars": 1161,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/CholmodSupport",
"chars": 1900,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/Core",
"chars": 12799,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "Obfuscation/include/Eigen/Dense",
"chars": 122,
"preview": "#include \"Core\"\n#include \"LU\"\n#include \"Cholesky\"\n#include \"QR\"\n#include \"SVD\"\n#include \"Geometry\"\n#include \"Eigenvalues"
},
{
"path": "Obfuscation/include/Eigen/Eigen",
"chars": 35,
"preview": "#include \"Dense\"\n#include \"Sparse\"\n"
},
{
"path": "Obfuscation/include/Eigen/Eigenvalues",
"chars": 1777,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/Geometry",
"chars": 1940,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/Householder",
"chars": 829,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/IterativeLinearSolvers",
"chars": 2083,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/Jacobi",
"chars": 894,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/KLUSupport",
"chars": 1389,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/LU",
"chars": 1268,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/MetisSupport",
"chars": 991,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/OrderingMethods",
"chars": 2451,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/PaStiXSupport",
"chars": 1751,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/PardisoSupport",
"chars": 1116,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/QR",
"chars": 1272,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/QtAlignedMalloc",
"chars": 900,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/SPQRSupport",
"chars": 1162,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/SVD",
"chars": 1584,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/Sparse",
"chars": 888,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/SparseCholesky",
"chars": 1235,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2013 G"
},
{
"path": "Obfuscation/include/Eigen/SparseCore",
"chars": 2240,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/SparseLU",
"chars": 1812,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2012 Désiré"
},
{
"path": "Obfuscation/include/Eigen/SparseQR",
"chars": 1195,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/StdDeque",
"chars": 797,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "Obfuscation/include/Eigen/StdList",
"chars": 726,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Hauke "
},
{
"path": "Obfuscation/include/Eigen/StdVector",
"chars": 803,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "Obfuscation/include/Eigen/SuperLUSupport",
"chars": 2243,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/UmfPackSupport",
"chars": 1382,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/src/Cholesky/LDLT.h",
"chars": 24934,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2011 G"
},
{
"path": "Obfuscation/include/Eigen/src/Cholesky/LLT.h",
"chars": 18760,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Cholesky/LLT_LAPACKE.h",
"chars": 3974,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "Obfuscation/include/Eigen/src/CholmodSupport/CholmodSupport.h",
"chars": 25441,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/ArithmeticSequence.h",
"chars": 19214,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2017 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Array.h",
"chars": 16782,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/ArrayBase.h",
"chars": 8217,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/ArrayWrapper.h",
"chars": 7018,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2010 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Assign.h",
"chars": 2738,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007 Michae"
},
{
"path": "Obfuscation/include/Eigen/src/Core/AssignEvaluator.h",
"chars": 41673,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2011 Benoit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Assign_MKL.h",
"chars": 12488,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n Copyright (C) 2015 Gael Guennebaud <gael.guennebaud@inr"
},
{
"path": "Obfuscation/include/Eigen/src/Core/BandMatrix.h",
"chars": 14075,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Block.h",
"chars": 18648,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/BooleanRedux.h",
"chars": 4429,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/CommaInitializer.h",
"chars": 5981,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/ConditionEstimator.h",
"chars": 6990,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2016 Rasmus"
},
{
"path": "Obfuscation/include/Eigen/src/Core/CoreEvaluators.h",
"chars": 63841,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2011 Benoit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/CoreIterators.h",
"chars": 4745,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2014 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/CwiseBinaryOp.h",
"chars": 7909,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2014 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/CwiseNullaryOp.h",
"chars": 36282,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/CwiseTernaryOp.h",
"chars": 8256,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2014 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/CwiseUnaryOp.h",
"chars": 3937,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2014 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/CwiseUnaryView.h",
"chars": 5551,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2010 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/DenseBase.h",
"chars": 31529,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007-2010 B"
},
{
"path": "Obfuscation/include/Eigen/src/Core/DenseCoeffsBase.h",
"chars": 24484,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2010 B"
},
{
"path": "Obfuscation/include/Eigen/src/Core/DenseStorage.h",
"chars": 25360,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Diagonal.h",
"chars": 9870,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007-2009 B"
},
{
"path": "Obfuscation/include/Eigen/src/Core/DiagonalMatrix.h",
"chars": 14670,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/DiagonalProduct.h",
"chars": 988,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Dot.h",
"chars": 11654,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2008, "
},
{
"path": "Obfuscation/include/Eigen/src/Core/EigenBase.h",
"chars": 5841,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Benoit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/ForceAlignedAccess.h",
"chars": 4909,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2010 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Fuzzy.h",
"chars": 5759,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2008 B"
},
{
"path": "Obfuscation/include/Eigen/src/Core/GeneralProduct.h",
"chars": 21679,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2008 B"
},
{
"path": "Obfuscation/include/Eigen/src/Core/GenericPacketMath.h",
"chars": 38812,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/GlobalFunctions.h",
"chars": 11543,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010-2016 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/IO.h",
"chars": 8238,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2008 B"
},
{
"path": "Obfuscation/include/Eigen/src/Core/IndexedView.h",
"chars": 9620,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2017 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Inverse.h",
"chars": 3503,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014-2019 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Map.h",
"chars": 7256,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007-2010 B"
},
{
"path": "Obfuscation/include/Eigen/src/Core/MapBase.h",
"chars": 11281,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007-2010 B"
},
{
"path": "Obfuscation/include/Eigen/src/Core/MathFunctions.h",
"chars": 60784,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2010 B"
},
{
"path": "Obfuscation/include/Eigen/src/Core/MathFunctionsImpl.h",
"chars": 7156,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014 Pedro "
},
{
"path": "Obfuscation/include/Eigen/src/Core/Matrix.h",
"chars": 24343,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2010 B"
},
{
"path": "Obfuscation/include/Eigen/src/Core/MatrixBase.h",
"chars": 23856,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2009 B"
},
{
"path": "Obfuscation/include/Eigen/src/Core/NestByValue.h",
"chars": 2520,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/NoAlias.h",
"chars": 3620,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/NumTraits.h",
"chars": 12884,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2010 B"
},
{
"path": "Obfuscation/include/Eigen/src/Core/PartialReduxEvaluator.h",
"chars": 9207,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2011-2018 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/PermutationMatrix.h",
"chars": 20748,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Benoit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/PlainObjectBase.h",
"chars": 49193,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2009 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Product.h",
"chars": 7336,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2011 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/ProductEvaluators.h",
"chars": 53832,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2008 B"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Random.h",
"chars": 7756,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Redux.h",
"chars": 19195,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Ref.h",
"chars": 17821,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2012 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Replicate.h",
"chars": 5656,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2010 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Reshaped.h",
"chars": 17033,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2017 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/ReturnByValue.h",
"chars": 4284,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2010 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Reverse.h",
"chars": 7522,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2008 B"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Select.h",
"chars": 6143,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/SelfAdjointView.h",
"chars": 14999,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/SelfCwiseBinaryOp.h",
"chars": 1697,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2010 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Solve.h",
"chars": 6837,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/SolveTriangular.h",
"chars": 9368,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2009 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/SolverBase.h",
"chars": 6170,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2015 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/StableNorm.h",
"chars": 8700,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/StlIterators.h",
"chars": 21641,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2018 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Stride.h",
"chars": 4212,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010 Benoit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Swap.h",
"chars": 2765,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2008 B"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Transpose.h",
"chars": 17606,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2006-2008 B"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Transpositions.h",
"chars": 13567,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010-2011 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/TriangularMatrix.h",
"chars": 38277,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Benoit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/VectorBlock.h",
"chars": 3488,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/VectorwiseOp.h",
"chars": 35168,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2019 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/Visitor.h",
"chars": 11997,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/AVX/Complex.h",
"chars": 15223,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014 Benoit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/AVX/MathFunctions.h",
"chars": 8102,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014 Pedro "
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/AVX/PacketMath.h",
"chars": 64608,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014 Benoit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/AVX/TypeCasting.h",
"chars": 2564,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2015 Benoit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/AVX512/Complex.h",
"chars": 17160,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2018 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/AVX512/MathFunctions.h",
"chars": 13344,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2016 Pedro "
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/AVX512/PacketMath.h",
"chars": 87891,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2016 Benoit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/AVX512/TypeCasting.h",
"chars": 2134,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2019 Rasmus"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/AltiVec/Complex.h",
"chars": 16540,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/AltiVec/MathFunctions.h",
"chars": 2323,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007 Julien"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/AltiVec/MatrixProduct.h",
"chars": 119355,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2020 Everto"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/AltiVec/MatrixProductCommon.h",
"chars": 9490,
"preview": "//#define EIGEN_POWER_USE_PREFETCH // Use prefetching in gemm routines\n#ifdef EIGEN_POWER_USE_PREFETCH\n#define EIGEN_PO"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/AltiVec/MatrixProductMMA.h",
"chars": 24820,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2020 Everto"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/AltiVec/PacketMath.h",
"chars": 102394,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2016 K"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/CUDA/Complex.h",
"chars": 17317,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014 Benoit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/Default/BFloat16.h",
"chars": 26895,
"preview": "/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"Lic"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/Default/ConjHelper.h",
"chars": 5251,
"preview": "\n// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2017 Gael "
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/Default/GenericPacketMathFunctions.h",
"chars": 67664,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007 Julien"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/Default/GenericPacketMathFunctionsFwd.h",
"chars": 3770,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2019 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/Default/Half.h",
"chars": 35526,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/Default/Settings.h",
"chars": 1746,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/Default/TypeCasting.h",
"chars": 3746,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2016 Benoit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/GPU/MathFunctions.h",
"chars": 2695,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014 Benoit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/GPU/PacketMath.h",
"chars": 57039,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2014 Benoit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/GPU/TypeCasting.h",
"chars": 2256,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2016 Benoit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/HIP/hcc/math_constants.h",
"chars": 691,
"preview": "/*\n * math_constants.h - \n * HIP equivalent of the CUDA header of the same name\n */\n\n#ifndef __MATH_CONSTANTS_H__\n#defi"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/MSA/Complex.h",
"chars": 17541,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2018 Wave C"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/MSA/MathFunctions.h",
"chars": 16159,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007 Julien"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/MSA/PacketMath.h",
"chars": 33615,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2018 Wave C"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/NEON/Complex.h",
"chars": 22503,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/NEON/GeneralBlockPanelKernel.h",
"chars": 6815,
"preview": "namespace Eigen {\nnamespace internal {\n \n#if EIGEN_ARCH_ARM && EIGEN_COMP_CLANG\n\n// Clang seems to excessively spill re"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/NEON/MathFunctions.h",
"chars": 3083,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// This Source Code Form is "
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/NEON/PacketMath.h",
"chars": 189525,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2009 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/NEON/TypeCasting.h",
"chars": 51286,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2018 Rasmus"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/SSE/Complex.h",
"chars": 14251,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/SSE/MathFunctions.h",
"chars": 6765,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007 Julien"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/SSE/PacketMath.h",
"chars": 64465,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2009 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/SSE/TypeCasting.h",
"chars": 3650,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2015 Benoit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/SVE/MathFunctions.h",
"chars": 1194,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2020, Arm L"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/SVE/PacketMath.h",
"chars": 21200,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2020, Arm L"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/SVE/TypeCasting.h",
"chars": 1351,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2020, Arm L"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/SYCL/InteropHeaders.h",
"chars": 7428,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Mehdi Goli Codeplay So"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/SYCL/MathFunctions.h",
"chars": 12539,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Mehdi Goli Codeplay So"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/SYCL/PacketMath.h",
"chars": 27786,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Mehdi Goli Codeplay So"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/SYCL/SyclMemoryModel.h",
"chars": 21856,
"preview": "/***************************************************************************\n * Copyright (C) 2017 Codeplay Software Li"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/SYCL/TypeCasting.h",
"chars": 2626,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Mehdi Goli Codeplay So"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/ZVector/Complex.h",
"chars": 16728,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/ZVector/MathFunctions.h",
"chars": 8024,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007 Julien"
},
{
"path": "Obfuscation/include/Eigen/src/Core/arch/ZVector/PacketMath.h",
"chars": 36894,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2016 Konsta"
},
{
"path": "Obfuscation/include/Eigen/src/Core/functors/AssignmentFunctors.h",
"chars": 6686,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/functors/BinaryFunctors.h",
"chars": 20921,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/functors/NullaryFunctors.h",
"chars": 8334,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2016 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/functors/StlFunctors.h",
"chars": 4998,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/functors/TernaryFunctors.h",
"chars": 607,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2016 Eugene"
},
{
"path": "Obfuscation/include/Eigen/src/Core/functors/UnaryFunctors.h",
"chars": 40146,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2016 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/GeneralBlockPanelKernel.h",
"chars": 108444,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2009 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/GeneralMatrixMatrix.h",
"chars": 20104,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2009 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular.h",
"chars": 15948,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2010 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/GeneralMatrixMatrixTriangular_BLAS.h",
"chars": 6936,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/GeneralMatrixMatrix_BLAS.h",
"chars": 5106,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/GeneralMatrixVector.h",
"chars": 21724,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2016 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/GeneralMatrixVector_BLAS.h",
"chars": 6368,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/Parallelizer.h",
"chars": 5582,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2010 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/SelfadjointMatrixMatrix.h",
"chars": 21354,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/SelfadjointMatrixMatrix_BLAS.h",
"chars": 11570,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/SelfadjointMatrixVector.h",
"chars": 9958,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2009 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/SelfadjointMatrixVector_BLAS.h",
"chars": 5209,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/SelfadjointProduct.h",
"chars": 6164,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/SelfadjointRank2Update.h",
"chars": 4126,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/TriangularMatrixMatrix.h",
"chars": 20987,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/TriangularMatrixMatrix_BLAS.h",
"chars": 13867,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/TriangularMatrixVector.h",
"chars": 14722,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/TriangularMatrixVector_BLAS.h",
"chars": 10571,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/TriangularSolverMatrix.h",
"chars": 14678,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/TriangularSolverMatrix_BLAS.h",
"chars": 6707,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/products/TriangularSolverVector.h",
"chars": 5882,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2010 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/util/BlasUtil.h",
"chars": 23156,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009-2010 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/util/ConfigureVectorization.h",
"chars": 19876,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2018 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/util/Constants.h",
"chars": 21931,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2015 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/util/DisableStupidWarnings.h",
"chars": 4892,
"preview": "#ifndef EIGEN_WARNINGS_DISABLED\n#define EIGEN_WARNINGS_DISABLED\n\n#ifdef _MSC_VER\n // 4100 - unreferenced formal paramet"
},
{
"path": "Obfuscation/include/Eigen/src/Core/util/ForwardDeclarations.h",
"chars": 15555,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2007-2010 B"
},
{
"path": "Obfuscation/include/Eigen/src/Core/util/IndexedViewHelper.h",
"chars": 6696,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2017 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/util/IntegralConstant.h",
"chars": 10949,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2017 Gael G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/util/MKL_support.h",
"chars": 4268,
"preview": "/*\n Copyright (c) 2011, Intel Corporation. All rights reserved.\n\n Redistribution and use in source and binary forms, wit"
},
{
"path": "Obfuscation/include/Eigen/src/Core/util/Macros.h",
"chars": 52909,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2015 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/util/Memory.h",
"chars": 46661,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2015 G"
},
{
"path": "Obfuscation/include/Eigen/src/Core/util/Meta.h",
"chars": 29336,
"preview": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2008-2015 G"
}
]
// ... and 183 more files (download for full content)
About this extraction
This page contains the full source code of the SsageParuders/SsagePass GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 383 files (6.2 MB), approximately 1.6M tokens, and a symbol index with 3868 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.