├── .gitattributes ├── .gitignore ├── AndroidManifest.xml ├── README.md ├── gen └── com │ └── cllin │ └── matrixcomputation │ ├── BuildConfig.java │ ├── R.java │ └── computation │ └── ScriptC_multiplication.java ├── ic_launcher-web.png ├── jni ├── Android.mk ├── Application.mk ├── Eigen │ ├── CMakeLists.txt │ ├── Cholesky │ ├── Core │ ├── Dense │ ├── Eigen │ ├── Eigenvalues │ ├── Geometry │ ├── Householder │ ├── Jacobi │ ├── LU │ ├── QR │ ├── SVD │ └── src │ │ ├── CMakeLists.txt │ │ ├── Cholesky │ │ ├── CMakeLists.txt │ │ ├── LDLT.h │ │ ├── LLT.h │ │ └── LLT_MKL.h │ │ ├── Core │ │ ├── Array.h │ │ ├── ArrayBase.h │ │ ├── ArrayWrapper.h │ │ ├── Assign.h │ │ ├── Assign_MKL.h │ │ ├── BandMatrix.h │ │ ├── Block.h │ │ ├── BooleanRedux.h │ │ ├── CMakeLists.txt │ │ ├── CommaInitializer.h │ │ ├── CwiseBinaryOp.h │ │ ├── CwiseNullaryOp.h │ │ ├── CwiseUnaryOp.h │ │ ├── CwiseUnaryView.h │ │ ├── DenseBase.h │ │ ├── DenseCoeffsBase.h │ │ ├── DenseStorage.h │ │ ├── Diagonal.h │ │ ├── DiagonalMatrix.h │ │ ├── DiagonalProduct.h │ │ ├── Dot.h │ │ ├── EigenBase.h │ │ ├── Flagged.h │ │ ├── ForceAlignedAccess.h │ │ ├── Functors.h │ │ ├── Fuzzy.h │ │ ├── GeneralProduct.h │ │ ├── GenericPacketMath.h │ │ ├── GlobalFunctions.h │ │ ├── IO.h │ │ ├── Map.h │ │ ├── MapBase.h │ │ ├── MathFunctions.h │ │ ├── Matrix.h │ │ ├── MatrixBase.h │ │ ├── NestByValue.h │ │ ├── NoAlias.h │ │ ├── NumTraits.h │ │ ├── PermutationMatrix.h │ │ ├── PlainObjectBase.h │ │ ├── Product.h │ │ ├── ProductBase.h │ │ ├── Random.h │ │ ├── Redux.h │ │ ├── Replicate.h │ │ ├── ReturnByValue.h │ │ ├── Reverse.h │ │ ├── Select.h │ │ ├── SelfAdjointView.h │ │ ├── SelfCwiseBinaryOp.h │ │ ├── SolveTriangular.h │ │ ├── StableNorm.h │ │ ├── Stride.h │ │ ├── Swap.h │ │ ├── Transpose.h │ │ ├── Transpositions.h │ │ ├── TriangularMatrix.h │ │ ├── VectorBlock.h │ │ ├── VectorwiseOp.h │ │ ├── Visitor.h │ │ ├── arch │ │ │ ├── AltiVec │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── Complex.h │ │ │ │ └── PacketMath.h │ │ │ ├── CMakeLists.txt │ │ │ ├── Default │ │ │ │ ├── CMakeLists.txt │ │ │ │ └── Settings.h │ │ │ ├── NEON │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── Complex.h │ │ │ │ └── PacketMath.h │ │ │ └── SSE │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── Complex.h │ │ │ │ ├── MathFunctions.h │ │ │ │ └── PacketMath.h │ │ ├── products │ │ │ ├── CMakeLists.txt │ │ │ ├── CoeffBasedProduct.h │ │ │ ├── GeneralBlockPanelKernel.h │ │ │ ├── GeneralMatrixMatrix.h │ │ │ ├── GeneralMatrixMatrixTriangular.h │ │ │ ├── GeneralMatrixMatrixTriangular_MKL.h │ │ │ ├── GeneralMatrixMatrix_MKL.h │ │ │ ├── GeneralMatrixVector.h │ │ │ ├── GeneralMatrixVector_MKL.h │ │ │ ├── Parallelizer.h │ │ │ ├── SelfadjointMatrixMatrix.h │ │ │ ├── SelfadjointMatrixMatrix_MKL.h │ │ │ ├── SelfadjointMatrixVector.h │ │ │ ├── SelfadjointMatrixVector_MKL.h │ │ │ ├── SelfadjointProduct.h │ │ │ ├── SelfadjointRank2Update.h │ │ │ ├── TriangularMatrixMatrix.h │ │ │ ├── TriangularMatrixMatrix_MKL.h │ │ │ ├── TriangularMatrixVector.h │ │ │ ├── TriangularMatrixVector_MKL.h │ │ │ ├── TriangularSolverMatrix.h │ │ │ ├── TriangularSolverMatrix_MKL.h │ │ │ └── TriangularSolverVector.h │ │ └── util │ │ │ ├── BlasUtil.h │ │ │ ├── CMakeLists.txt │ │ │ ├── Constants.h │ │ │ ├── DisableStupidWarnings.h │ │ │ ├── ForwardDeclarations.h │ │ │ ├── MKL_support.h │ │ │ ├── Macros.h │ │ │ ├── Memory.h │ │ │ ├── Meta.h │ │ │ ├── NonMPL2.h │ │ │ ├── ReenableStupidWarnings.h │ │ │ ├── StaticAssert.h │ │ │ └── XprHelper.h │ │ ├── Eigenvalues │ │ ├── CMakeLists.txt │ │ ├── ComplexEigenSolver.h │ │ ├── ComplexSchur.h │ │ ├── ComplexSchur_MKL.h │ │ ├── EigenSolver.h │ │ ├── GeneralizedSelfAdjointEigenSolver.h │ │ ├── HessenbergDecomposition.h │ │ ├── MatrixBaseEigenvalues.h │ │ ├── RealSchur.h │ │ ├── RealSchur_MKL.h │ │ ├── SelfAdjointEigenSolver.h │ │ ├── SelfAdjointEigenSolver_MKL.h │ │ └── Tridiagonalization.h │ │ ├── Geometry │ │ ├── AlignedBox.h │ │ ├── AngleAxis.h │ │ ├── CMakeLists.txt │ │ ├── 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 │ │ │ ├── CMakeLists.txt │ │ │ └── Geometry_SSE.h │ │ ├── Householder │ │ ├── BlockHouseholder.h │ │ ├── CMakeLists.txt │ │ ├── Householder.h │ │ └── HouseholderSequence.h │ │ ├── Jacobi │ │ ├── CMakeLists.txt │ │ └── Jacobi.h │ │ ├── LU │ │ ├── CMakeLists.txt │ │ ├── Determinant.h │ │ ├── FullPivLU.h │ │ ├── Inverse.h │ │ ├── PartialPivLU.h │ │ ├── PartialPivLU_MKL.h │ │ └── arch │ │ │ ├── CMakeLists.txt │ │ │ └── Inverse_SSE.h │ │ ├── QR │ │ ├── CMakeLists.txt │ │ ├── ColPivHouseholderQR.h │ │ ├── ColPivHouseholderQR_MKL.h │ │ ├── FullPivHouseholderQR.h │ │ ├── HouseholderQR.h │ │ └── HouseholderQR_MKL.h │ │ ├── SVD │ │ ├── CMakeLists.txt │ │ ├── JacobiSVD.h │ │ ├── JacobiSVD_MKL.h │ │ └── UpperBidiagonalization.h │ │ ├── misc │ │ ├── CMakeLists.txt │ │ ├── Image.h │ │ ├── Kernel.h │ │ ├── Solve.h │ │ ├── SparseSolve.h │ │ └── blas.h │ │ └── plugins │ │ ├── ArrayCwiseBinaryOps.h │ │ ├── ArrayCwiseUnaryOps.h │ │ ├── BlockMethods.h │ │ ├── CMakeLists.txt │ │ ├── CommonCwiseBinaryOps.h │ │ ├── CommonCwiseUnaryOps.h │ │ ├── MatrixCwiseBinaryOps.h │ │ └── MatrixCwiseUnaryOps.h ├── MatrixFromEigen.cpp └── MatrixFromNative.cpp ├── libs ├── android-support-v4.jar ├── armeabi │ ├── libmatrixfromeigen.so │ ├── libmatrixfromnative.so │ └── libopencv_core.a └── opencvlibrary-2.4.6.jar ├── proguard-project.txt ├── project.properties ├── res ├── drawable-hdpi │ └── ic_launcher.png ├── drawable-mdpi │ └── ic_launcher.png ├── drawable-xhdpi │ └── ic_launcher.png ├── drawable-xxhdpi │ └── ic_launcher.png ├── layout │ ├── activity_benchmark.xml │ ├── checkbox_implementations.xml │ ├── checkbox_matixsizes.xml │ └── separator.xml ├── menu │ └── main.xml ├── values-sw600dp │ └── dimens.xml ├── values-sw720dp-land │ └── dimens.xml ├── values-v11 │ └── styles.xml ├── values-v14 │ └── styles.xml └── values │ ├── dimens.xml │ ├── strings.xml │ └── styles.xml └── src └── com └── cllin └── matrixcomputation ├── activity ├── BenchmarkActivity.java └── BenchmarkApplication.java ├── benchmark └── MatrixComputationBenchmark.java ├── computation ├── EigenMatrixComputation.java ├── JavaMatrixComputation.java ├── MatrixComputation.java ├── OpenCVMatrixComputation.java ├── RenderScriptComputation.java ├── SuperMatrixComputation.java └── multiplication.rs ├── data ├── BenchmarkResult.java └── Script.java ├── runnable └── BenchmarkRunnable.java └── utility ├── MatrixFactory.java ├── RecordWriter.java └── TimeRecorder.java /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | 4 | # Custom for Visual Studio 5 | *.cs diff=csharp 6 | *.sln merge=union 7 | *.csproj merge=union 8 | *.vbproj merge=union 9 | *.fsproj merge=union 10 | *.dbproj merge=union 11 | 12 | # Standard to msysgit 13 | *.doc diff=astextplain 14 | *.DOC diff=astextplain 15 | *.docx diff=astextplain 16 | *.DOCX diff=astextplain 17 | *.dot diff=astextplain 18 | *.DOT diff=astextplain 19 | *.pdf diff=astextplain 20 | *.PDF diff=astextplain 21 | *.rtf diff=astextplain 22 | *.RTF diff=astextplain 23 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | ################# 2 | ## Eclipse 3 | ################# 4 | 5 | *.pydevproject 6 | .project 7 | .metadata 8 | bin/ 9 | tmp/ 10 | *.tmp 11 | *.bak 12 | *.swp 13 | *~.nib 14 | local.properties 15 | .classpath 16 | .settings/ 17 | .loadpath 18 | 19 | # External tool builders 20 | .externalToolBuilders/ 21 | 22 | # Locally stored "Eclipse launch configurations" 23 | *.launch 24 | 25 | # CDT-specific 26 | .cproject 27 | 28 | # PDT-specific 29 | .buildpath 30 | 31 | 32 | ################# 33 | ## Visual Studio 34 | ################# 35 | 36 | ## Ignore Visual Studio temporary files, build results, and 37 | ## files generated by popular Visual Studio add-ons. 38 | 39 | # User-specific files 40 | *.suo 41 | *.user 42 | *.sln.docstates 43 | 44 | # Build results 45 | 46 | [Dd]ebug/ 47 | [Rr]elease/ 48 | x64/ 49 | build/ 50 | [Bb]in/ 51 | [Oo]bj/ 52 | 53 | # MSTest test Results 54 | [Tt]est[Rr]esult*/ 55 | [Bb]uild[Ll]og.* 56 | 57 | *_i.c 58 | *_p.c 59 | *.ilk 60 | *.meta 61 | *.obj 62 | *.pch 63 | *.pdb 64 | *.pgc 65 | *.pgd 66 | *.rsp 67 | *.sbr 68 | *.tlb 69 | *.tli 70 | *.tlh 71 | *.tmp 72 | *.tmp_proj 73 | *.log 74 | *.vspscc 75 | *.vssscc 76 | .builds 77 | *.pidb 78 | *.log 79 | *.scc 80 | 81 | # Visual C++ cache files 82 | ipch/ 83 | *.aps 84 | *.ncb 85 | *.opensdf 86 | *.sdf 87 | *.cachefile 88 | 89 | # Visual Studio profiler 90 | *.psess 91 | *.vsp 92 | *.vspx 93 | 94 | # Guidance Automation Toolkit 95 | *.gpState 96 | 97 | # ReSharper is a .NET coding add-in 98 | _ReSharper*/ 99 | *.[Rr]e[Ss]harper 100 | 101 | # TeamCity is a build add-in 102 | _TeamCity* 103 | 104 | # DotCover is a Code Coverage Tool 105 | *.dotCover 106 | 107 | # NCrunch 108 | *.ncrunch* 109 | .*crunch*.local.xml 110 | 111 | # Installshield output folder 112 | [Ee]xpress/ 113 | 114 | # DocProject is a documentation generator add-in 115 | DocProject/buildhelp/ 116 | DocProject/Help/*.HxT 117 | DocProject/Help/*.HxC 118 | DocProject/Help/*.hhc 119 | DocProject/Help/*.hhk 120 | DocProject/Help/*.hhp 121 | DocProject/Help/Html2 122 | DocProject/Help/html 123 | 124 | # Click-Once directory 125 | publish/ 126 | 127 | # Publish Web Output 128 | *.Publish.xml 129 | *.pubxml 130 | 131 | # NuGet Packages Directory 132 | ## TODO: If you have NuGet Package Restore enabled, uncomment the next line 133 | #packages/ 134 | 135 | # Windows Azure Build Output 136 | csx 137 | *.build.csdef 138 | 139 | # Windows Store app package directory 140 | AppPackages/ 141 | 142 | # Others 143 | sql/ 144 | *.Cache 145 | ClientBin/ 146 | [Ss]tyle[Cc]op.* 147 | ~$* 148 | *~ 149 | *.dbmdl 150 | *.[Pp]ublish.xml 151 | *.pfx 152 | *.publishsettings 153 | 154 | # RIA/Silverlight projects 155 | Generated_Code/ 156 | 157 | # Backup & report files from converting an old project file to a newer 158 | # Visual Studio version. Backup files are not needed, because we have git ;-) 159 | _UpgradeReport_Files/ 160 | Backup*/ 161 | UpgradeLog*.XML 162 | UpgradeLog*.htm 163 | 164 | # SQL Server files 165 | App_Data/*.mdf 166 | App_Data/*.ldf 167 | 168 | ############# 169 | ## Windows detritus 170 | ############# 171 | 172 | # Windows image file caches 173 | Thumbs.db 174 | ehthumbs.db 175 | 176 | # Folder config file 177 | Desktop.ini 178 | 179 | # Recycle Bin used on file shares 180 | $RECYCLE.BIN/ 181 | 182 | # Mac crap 183 | .DS_Store 184 | 185 | 186 | ############# 187 | ## Python 188 | ############# 189 | 190 | *.py[co] 191 | 192 | # Packages 193 | *.egg 194 | *.egg-info 195 | dist/ 196 | build/ 197 | eggs/ 198 | parts/ 199 | var/ 200 | sdist/ 201 | develop-eggs/ 202 | .installed.cfg 203 | 204 | # Installer logs 205 | pip-log.txt 206 | 207 | # Unit test / coverage reports 208 | .coverage 209 | .tox 210 | 211 | #Translations 212 | *.mo 213 | 214 | #Mr Developer 215 | .mr.developer.cfg 216 | -------------------------------------------------------------------------------- /AndroidManifest.xml: -------------------------------------------------------------------------------- 1 | 2 | 6 | 7 | 10 | 11 | 12 | 13 | 14 | 15 | 21 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # MatrixComputation 2 | 3 | *The project performs a benchmark test for matrices computation in Java, C++, Eigen, OpenCV, RenderScript on Android platform* 4 | 5 | *The purpose of this application is not to compare the performance of algorithms performing matrix multiplication. All computations are implemented in naive way* 6 | 7 | ====== 8 | ### CONTENT 9 | 1. [Application Manifest] (#1) 10 | 2. [Java] (#2) 11 | 3. [C++] (#3) 12 | 4. [OpenCV] (#4) 13 | 5. [Eigen] (#5) 14 | 6. [RenderScript] (#6) 15 | 7. [Contacts] (#7) 16 | 17 | ====== 18 | ### APPLICATION MANIFEST 19 | - Target SDK Version: 19 20 | - Minimum SDK Version: 16 21 | - Uses Permission 22 | - android.permission.READ_EXTERNAL_STORAGE 23 | - android.permission.WRITE_EXTERNAL_STORAGE 24 | - android.permission.READ_LOGS 25 | 26 | 27 | ### Java 28 | This is the simplest way to perform matrices computation on Android devices. Yet, the performance is the worst among all approaches demonstrated in this application. 29 | 30 | ### C++ 31 | This approach is faster than Java. Note that [Java Native Interface](http://docs.oracle.com/javase/7/docs/technotes/guides/jni/) is needed in order to run native code in Android applications. 32 | 33 | ### OpenCV 34 | [OpenCV](http://opencv.org/) is common library for mathematic computations. Details and tutorial about [OpenCV on Android] (http://opencv.org/platforms/android.html) can be found [here] (http://docs.opencv.org/doc/tutorials/introduction/android_binary_package/O4A_SDK.html). 35 | ***NOTE*** *OpenCV is not available in release 1.2* 36 | 37 | ### Eigen 38 | [Eigen] (http://eigen.tuxfamily.org/index.php?title=Main_Page) is another choice for computation. Eigen usually outperform OpenCV on Android devices. 39 | 40 | ### RenderScript 41 | [RenderScript] (http://developer.android.com/guide/topics/renderscript/compute.html) is a framework for running computationally intensive tasks at high performance on Android, usually used for image processing on Android devices. It accelerates the computation by running on GPUs. Please note that RenderScript is device-dependent. Version problem limits the compatibility of RenderScript. 42 | 43 | ====== 44 | ### Contacts 45 | Ching-Lun Lin, 46 | clallenlin@sv.cmu.edu, 2014 47 | -------------------------------------------------------------------------------- /gen/com/cllin/matrixcomputation/BuildConfig.java: -------------------------------------------------------------------------------- 1 | /** Automatically generated file. DO NOT MODIFY */ 2 | package com.cllin.matrixcomputation; 3 | 4 | public final class BuildConfig { 5 | public final static boolean DEBUG = true; 6 | } -------------------------------------------------------------------------------- /ic_launcher-web.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cllin/MatrixComputation/ad9fb0f956883905458e1c3a5112db615d34a2ca/ic_launcher-web.png -------------------------------------------------------------------------------- /jni/Android.mk: -------------------------------------------------------------------------------- 1 | LOCAL_PATH := $(call my-dir) 2 | 3 | # Build a shared library from MatrixFromNative.cpp 4 | include $(CLEAR_VARS) 5 | LOCAL_MODULE := matrixfromnative 6 | LOCAL_SRC_FILES := MatrixFromNative.cpp 7 | LOCAL_LDLIBS := -L$(SYSROOT)/usr/lib -llog 8 | include $(BUILD_SHARED_LIBRARY) 9 | 10 | # Eigen 11 | include $(CLEAR_VARS) 12 | LOCAL_MODULE := matrixfromeigen 13 | LOCAL_SRC_FILES := MatrixFromEigen.cpp 14 | LOCAL_LDLIBS := -L$(SYSROOT)/usr/lib -llog 15 | include $(BUILD_SHARED_LIBRARY) 16 | 17 | # RenderScript 18 | LOCAL_PATH := $(call my-dir) 19 | include $(CLEAR_VARS) 20 | LOCAL_MODULE_TAGS := optional 21 | LOCAL_SRC_FILES := $(call all-java-files-under, src) $(call all-renderscript-files-under, src) 22 | LOCAL_PACKAGE_NAME := MatrixMultiplicationRS 23 | include $(BUILD_PACKAGE) -------------------------------------------------------------------------------- /jni/Application.mk: -------------------------------------------------------------------------------- 1 | APP_STL := stlport_static -------------------------------------------------------------------------------- /jni/Eigen/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | include(RegexUtils) 2 | test_escape_string_as_regex() 3 | 4 | file(GLOB Eigen_directory_files "*") 5 | 6 | escape_string_as_regex(ESCAPED_CMAKE_CURRENT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}") 7 | 8 | foreach(f ${Eigen_directory_files}) 9 | if(NOT f MATCHES "\\.txt" AND NOT f MATCHES "${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/[.].+" AND NOT f MATCHES "${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/src") 10 | list(APPEND Eigen_directory_files_to_install ${f}) 11 | endif() 12 | endforeach(f ${Eigen_directory_files}) 13 | 14 | install(FILES 15 | ${Eigen_directory_files_to_install} 16 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen COMPONENT Devel 17 | ) 18 | 19 | add_subdirectory(src) 20 | -------------------------------------------------------------------------------- /jni/Eigen/Cholesky: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_CHOLESKY_MODULE_H 2 | #define EIGEN_CHOLESKY_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** \defgroup Cholesky_Module Cholesky module 9 | * 10 | * 11 | * 12 | * This module provides two variants of the Cholesky decomposition for selfadjoint (hermitian) matrices. 13 | * Those decompositions are accessible via the following MatrixBase methods: 14 | * - MatrixBase::llt(), 15 | * - MatrixBase::ldlt() 16 | * 17 | * \code 18 | * #include 19 | * \endcode 20 | */ 21 | 22 | #include "src/misc/Solve.h" 23 | #include "src/Cholesky/LLT.h" 24 | #include "src/Cholesky/LDLT.h" 25 | #ifdef EIGEN_USE_LAPACKE 26 | #include "src/Cholesky/LLT_MKL.h" 27 | #endif 28 | 29 | #include "src/Core/util/ReenableStupidWarnings.h" 30 | 31 | #endif // EIGEN_CHOLESKY_MODULE_H 32 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 33 | -------------------------------------------------------------------------------- /jni/Eigen/Dense: -------------------------------------------------------------------------------- 1 | #include "Core" 2 | #include "LU" 3 | #include "Cholesky" 4 | #include "QR" 5 | #include "SVD" 6 | #include "Geometry" 7 | #include "Eigenvalues" -------------------------------------------------------------------------------- /jni/Eigen/Eigen: -------------------------------------------------------------------------------- 1 | #include "Dense" 2 | //#include "Sparse" 3 | -------------------------------------------------------------------------------- /jni/Eigen/Eigenvalues: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_EIGENVALUES_MODULE_H 2 | #define EIGEN_EIGENVALUES_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include "Cholesky" 9 | #include "Jacobi" 10 | #include "Householder" 11 | #include "LU" 12 | #include "Geometry" 13 | 14 | /** \defgroup Eigenvalues_Module Eigenvalues module 15 | * 16 | * 17 | * 18 | * This module mainly provides various eigenvalue solvers. 19 | * This module also provides some MatrixBase methods, including: 20 | * - MatrixBase::eigenvalues(), 21 | * - MatrixBase::operatorNorm() 22 | * 23 | * \code 24 | * #include 25 | * \endcode 26 | */ 27 | 28 | #include "src/Eigenvalues/Tridiagonalization.h" 29 | #include "src/Eigenvalues/RealSchur.h" 30 | #include "src/Eigenvalues/EigenSolver.h" 31 | #include "src/Eigenvalues/SelfAdjointEigenSolver.h" 32 | #include "src/Eigenvalues/GeneralizedSelfAdjointEigenSolver.h" 33 | #include "src/Eigenvalues/HessenbergDecomposition.h" 34 | #include "src/Eigenvalues/ComplexSchur.h" 35 | #include "src/Eigenvalues/ComplexEigenSolver.h" 36 | #include "src/Eigenvalues/MatrixBaseEigenvalues.h" 37 | #ifdef EIGEN_USE_LAPACKE 38 | #include "src/Eigenvalues/RealSchur_MKL.h" 39 | #include "src/Eigenvalues/ComplexSchur_MKL.h" 40 | #include "src/Eigenvalues/SelfAdjointEigenSolver_MKL.h" 41 | #endif 42 | 43 | #include "src/Core/util/ReenableStupidWarnings.h" 44 | 45 | #endif // EIGEN_EIGENVALUES_MODULE_H 46 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 47 | -------------------------------------------------------------------------------- /jni/Eigen/Geometry: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_GEOMETRY_MODULE_H 2 | #define EIGEN_GEOMETRY_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include "SVD" 9 | #include "LU" 10 | #include 11 | 12 | #ifndef M_PI 13 | #define M_PI 3.14159265358979323846 14 | #endif 15 | 16 | /** \defgroup Geometry_Module Geometry module 17 | * 18 | * 19 | * 20 | * This module provides support for: 21 | * - fixed-size homogeneous transformations 22 | * - translation, scaling, 2D and 3D rotations 23 | * - quaternions 24 | * - \ref MatrixBase::cross() "cross product" 25 | * - \ref MatrixBase::unitOrthogonal() "orthognal vector generation" 26 | * - some linear components: parametrized-lines and hyperplanes 27 | * 28 | * \code 29 | * #include 30 | * \endcode 31 | */ 32 | 33 | #include "src/Geometry/OrthoMethods.h" 34 | #include "src/Geometry/EulerAngles.h" 35 | 36 | #if EIGEN2_SUPPORT_STAGE > STAGE20_RESOLVE_API_CONFLICTS 37 | #include "src/Geometry/Homogeneous.h" 38 | #include "src/Geometry/RotationBase.h" 39 | #include "src/Geometry/Rotation2D.h" 40 | #include "src/Geometry/Quaternion.h" 41 | #include "src/Geometry/AngleAxis.h" 42 | #include "src/Geometry/Transform.h" 43 | #include "src/Geometry/Translation.h" 44 | #include "src/Geometry/Scaling.h" 45 | #include "src/Geometry/Hyperplane.h" 46 | #include "src/Geometry/ParametrizedLine.h" 47 | #include "src/Geometry/AlignedBox.h" 48 | #include "src/Geometry/Umeyama.h" 49 | 50 | #if defined EIGEN_VECTORIZE_SSE 51 | #include "src/Geometry/arch/Geometry_SSE.h" 52 | #endif 53 | #endif 54 | 55 | #ifdef EIGEN2_SUPPORT 56 | #include "src/Eigen2Support/Geometry/All.h" 57 | #endif 58 | 59 | #include "src/Core/util/ReenableStupidWarnings.h" 60 | 61 | #endif // EIGEN_GEOMETRY_MODULE_H 62 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 63 | 64 | -------------------------------------------------------------------------------- /jni/Eigen/Householder: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_HOUSEHOLDER_MODULE_H 2 | #define EIGEN_HOUSEHOLDER_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** \defgroup Householder_Module Householder module 9 | * This module provides Householder transformations. 10 | * 11 | * \code 12 | * #include 13 | * \endcode 14 | */ 15 | 16 | #include "src/Householder/Householder.h" 17 | #include "src/Householder/HouseholderSequence.h" 18 | #include "src/Householder/BlockHouseholder.h" 19 | 20 | #include "src/Core/util/ReenableStupidWarnings.h" 21 | 22 | #endif // EIGEN_HOUSEHOLDER_MODULE_H 23 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 24 | -------------------------------------------------------------------------------- /jni/Eigen/Jacobi: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_JACOBI_MODULE_H 2 | #define EIGEN_JACOBI_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** \defgroup Jacobi_Module Jacobi module 9 | * This module provides Jacobi and Givens rotations. 10 | * 11 | * \code 12 | * #include 13 | * \endcode 14 | * 15 | * In addition to listed classes, it defines the two following MatrixBase methods to apply a Jacobi or Givens rotation: 16 | * - MatrixBase::applyOnTheLeft() 17 | * - MatrixBase::applyOnTheRight(). 18 | */ 19 | 20 | #include "src/Jacobi/Jacobi.h" 21 | 22 | #include "src/Core/util/ReenableStupidWarnings.h" 23 | 24 | #endif // EIGEN_JACOBI_MODULE_H 25 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 26 | 27 | -------------------------------------------------------------------------------- /jni/Eigen/LU: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_LU_MODULE_H 2 | #define EIGEN_LU_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | /** \defgroup LU_Module LU module 9 | * This module includes %LU decomposition and related notions such as matrix inversion and determinant. 10 | * This module defines the following MatrixBase methods: 11 | * - MatrixBase::inverse() 12 | * - MatrixBase::determinant() 13 | * 14 | * \code 15 | * #include 16 | * \endcode 17 | */ 18 | 19 | #include "src/misc/Solve.h" 20 | #include "src/misc/Kernel.h" 21 | #include "src/misc/Image.h" 22 | #include "src/LU/FullPivLU.h" 23 | #include "src/LU/PartialPivLU.h" 24 | #ifdef EIGEN_USE_LAPACKE 25 | #include "src/LU/PartialPivLU_MKL.h" 26 | #endif 27 | #include "src/LU/Determinant.h" 28 | #include "src/LU/Inverse.h" 29 | 30 | #if defined EIGEN_VECTORIZE_SSE 31 | #include "src/LU/arch/Inverse_SSE.h" 32 | #endif 33 | 34 | #ifdef EIGEN2_SUPPORT 35 | #include "src/Eigen2Support/LU.h" 36 | #endif 37 | 38 | #include "src/Core/util/ReenableStupidWarnings.h" 39 | 40 | #endif // EIGEN_LU_MODULE_H 41 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 42 | -------------------------------------------------------------------------------- /jni/Eigen/QR: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_QR_MODULE_H 2 | #define EIGEN_QR_MODULE_H 3 | 4 | #include "Core" 5 | 6 | #include "src/Core/util/DisableStupidWarnings.h" 7 | 8 | #include "Cholesky" 9 | #include "Jacobi" 10 | #include "Householder" 11 | 12 | /** \defgroup QR_Module QR module 13 | * 14 | * 15 | * 16 | * This module provides various QR decompositions 17 | * This module also provides some MatrixBase methods, including: 18 | * - MatrixBase::qr(), 19 | * 20 | * \code 21 | * #include 22 | * \endcode 23 | */ 24 | 25 | #include "src/misc/Solve.h" 26 | #include "src/QR/HouseholderQR.h" 27 | #include "src/QR/FullPivHouseholderQR.h" 28 | #include "src/QR/ColPivHouseholderQR.h" 29 | #ifdef EIGEN_USE_LAPACKE 30 | #include "src/QR/HouseholderQR_MKL.h" 31 | #include "src/QR/ColPivHouseholderQR_MKL.h" 32 | #endif 33 | 34 | #ifdef EIGEN2_SUPPORT 35 | #include "src/Eigen2Support/QR.h" 36 | #endif 37 | 38 | #include "src/Core/util/ReenableStupidWarnings.h" 39 | 40 | #ifdef EIGEN2_SUPPORT 41 | #include "Eigenvalues" 42 | #endif 43 | 44 | #endif // EIGEN_QR_MODULE_H 45 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 46 | -------------------------------------------------------------------------------- /jni/Eigen/SVD: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_SVD_MODULE_H 2 | #define EIGEN_SVD_MODULE_H 3 | 4 | #include "QR" 5 | #include "Householder" 6 | #include "Jacobi" 7 | 8 | #include "src/Core/util/DisableStupidWarnings.h" 9 | 10 | /** \defgroup SVD_Module SVD module 11 | * 12 | * 13 | * 14 | * This module provides SVD decomposition for matrices (both real and complex). 15 | * This decomposition is accessible via the following MatrixBase method: 16 | * - MatrixBase::jacobiSvd() 17 | * 18 | * \code 19 | * #include 20 | * \endcode 21 | */ 22 | 23 | #include "src/misc/Solve.h" 24 | #include "src/SVD/JacobiSVD.h" 25 | #if defined(EIGEN_USE_LAPACKE) && !defined(EIGEN_USE_LAPACKE_STRICT) 26 | #include "src/SVD/JacobiSVD_MKL.h" 27 | #endif 28 | #include "src/SVD/UpperBidiagonalization.h" 29 | 30 | #ifdef EIGEN2_SUPPORT 31 | #include "src/Eigen2Support/SVD.h" 32 | #endif 33 | 34 | #include "src/Core/util/ReenableStupidWarnings.h" 35 | 36 | #endif // EIGEN_SVD_MODULE_H 37 | /* vim: set filetype=cpp et sw=2 ts=2 ai: */ 38 | -------------------------------------------------------------------------------- /jni/Eigen/src/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | file(GLOB Eigen_src_subdirectories "*") 2 | escape_string_as_regex(ESCAPED_CMAKE_CURRENT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}") 3 | foreach(f ${Eigen_src_subdirectories}) 4 | if(NOT f MATCHES "\\.txt" AND NOT f MATCHES "${ESCAPED_CMAKE_CURRENT_SOURCE_DIR}/[.].+" ) 5 | add_subdirectory(${f}) 6 | endif() 7 | endforeach() 8 | -------------------------------------------------------------------------------- /jni/Eigen/src/Cholesky/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Cholesky_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Cholesky_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Cholesky COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /jni/Eigen/src/Cholesky/LLT_MKL.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2011, Intel Corporation. All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without modification, 5 | are permitted provided that the following conditions are met: 6 | 7 | * Redistributions of source code must retain the above copyright notice, this 8 | list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above copyright notice, 10 | this list of conditions and the following disclaimer in the documentation 11 | and/or other materials provided with the distribution. 12 | * Neither the name of Intel Corporation nor the names of its contributors may 13 | be used to endorse or promote products derived from this software without 14 | specific prior written permission. 15 | 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 20 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 23 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 | 27 | ******************************************************************************** 28 | * Content : Eigen bindings to Intel(R) MKL 29 | * LLt decomposition based on LAPACKE_?potrf function. 30 | ******************************************************************************** 31 | */ 32 | 33 | #ifndef EIGEN_LLT_MKL_H 34 | #define EIGEN_LLT_MKL_H 35 | 36 | #include "Eigen/src/Core/util/MKL_support.h" 37 | #include 38 | 39 | namespace Eigen { 40 | 41 | namespace internal { 42 | 43 | template struct mkl_llt; 44 | 45 | #define EIGEN_MKL_LLT(EIGTYPE, MKLTYPE, MKLPREFIX) \ 46 | template<> struct mkl_llt \ 47 | { \ 48 | template \ 49 | static inline typename MatrixType::Index potrf(MatrixType& m, char uplo) \ 50 | { \ 51 | lapack_int matrix_order; \ 52 | lapack_int size, lda, info, StorageOrder; \ 53 | EIGTYPE* a; \ 54 | eigen_assert(m.rows()==m.cols()); \ 55 | /* Set up parameters for ?potrf */ \ 56 | size = m.rows(); \ 57 | StorageOrder = MatrixType::Flags&RowMajorBit?RowMajor:ColMajor; \ 58 | matrix_order = StorageOrder==RowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; \ 59 | a = &(m.coeffRef(0,0)); \ 60 | lda = m.outerStride(); \ 61 | \ 62 | info = LAPACKE_##MKLPREFIX##potrf( matrix_order, uplo, size, (MKLTYPE*)a, lda ); \ 63 | info = (info==0) ? Success : NumericalIssue; \ 64 | return info; \ 65 | } \ 66 | }; \ 67 | template<> struct llt_inplace \ 68 | { \ 69 | template \ 70 | static typename MatrixType::Index blocked(MatrixType& m) \ 71 | { \ 72 | return mkl_llt::potrf(m, 'L'); \ 73 | } \ 74 | template \ 75 | static typename MatrixType::Index rankUpdate(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma) \ 76 | { return Eigen::internal::llt_rank_update_lower(mat, vec, sigma); } \ 77 | }; \ 78 | template<> struct llt_inplace \ 79 | { \ 80 | template \ 81 | static typename MatrixType::Index blocked(MatrixType& m) \ 82 | { \ 83 | return mkl_llt::potrf(m, 'U'); \ 84 | } \ 85 | template \ 86 | static typename MatrixType::Index rankUpdate(MatrixType& mat, const VectorType& vec, const typename MatrixType::RealScalar& sigma) \ 87 | { \ 88 | Transpose matt(mat); \ 89 | return llt_inplace::rankUpdate(matt, vec.conjugate(), sigma); \ 90 | } \ 91 | }; 92 | 93 | EIGEN_MKL_LLT(double, double, d) 94 | EIGEN_MKL_LLT(float, float, s) 95 | EIGEN_MKL_LLT(dcomplex, MKL_Complex16, z) 96 | EIGEN_MKL_LLT(scomplex, MKL_Complex8, c) 97 | 98 | } // end namespace internal 99 | 100 | } // end namespace Eigen 101 | 102 | #endif // EIGEN_LLT_MKL_H 103 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/BooleanRedux.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008 Gael Guennebaud 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_ALLANDANY_H 11 | #define EIGEN_ALLANDANY_H 12 | 13 | namespace Eigen { 14 | 15 | namespace internal { 16 | 17 | template 18 | struct all_unroller 19 | { 20 | enum { 21 | col = (UnrollCount-1) / Derived::RowsAtCompileTime, 22 | row = (UnrollCount-1) % Derived::RowsAtCompileTime 23 | }; 24 | 25 | static inline bool run(const Derived &mat) 26 | { 27 | return all_unroller::run(mat) && mat.coeff(row, col); 28 | } 29 | }; 30 | 31 | template 32 | struct all_unroller 33 | { 34 | static inline bool run(const Derived &mat) { return mat.coeff(0, 0); } 35 | }; 36 | 37 | template 38 | struct all_unroller 39 | { 40 | static inline bool run(const Derived &) { return false; } 41 | }; 42 | 43 | template 44 | struct any_unroller 45 | { 46 | enum { 47 | col = (UnrollCount-1) / Derived::RowsAtCompileTime, 48 | row = (UnrollCount-1) % Derived::RowsAtCompileTime 49 | }; 50 | 51 | static inline bool run(const Derived &mat) 52 | { 53 | return any_unroller::run(mat) || mat.coeff(row, col); 54 | } 55 | }; 56 | 57 | template 58 | struct any_unroller 59 | { 60 | static inline bool run(const Derived &mat) { return mat.coeff(0, 0); } 61 | }; 62 | 63 | template 64 | struct any_unroller 65 | { 66 | static inline bool run(const Derived &) { return false; } 67 | }; 68 | 69 | } // end namespace internal 70 | 71 | /** \returns true if all coefficients are true 72 | * 73 | * Example: \include MatrixBase_all.cpp 74 | * Output: \verbinclude MatrixBase_all.out 75 | * 76 | * \sa any(), Cwise::operator<() 77 | */ 78 | template 79 | inline bool DenseBase::all() const 80 | { 81 | enum { 82 | unroll = SizeAtCompileTime != Dynamic 83 | && CoeffReadCost != Dynamic 84 | && NumTraits::AddCost != Dynamic 85 | && SizeAtCompileTime * (CoeffReadCost + NumTraits::AddCost) <= EIGEN_UNROLLING_LIMIT 86 | }; 87 | if(unroll) 88 | return internal::all_unroller::run(derived()); 91 | else 92 | { 93 | for(Index j = 0; j < cols(); ++j) 94 | for(Index i = 0; i < rows(); ++i) 95 | if (!coeff(i, j)) return false; 96 | return true; 97 | } 98 | } 99 | 100 | /** \returns true if at least one coefficient is true 101 | * 102 | * \sa all() 103 | */ 104 | template 105 | inline bool DenseBase::any() const 106 | { 107 | enum { 108 | unroll = SizeAtCompileTime != Dynamic 109 | && CoeffReadCost != Dynamic 110 | && NumTraits::AddCost != Dynamic 111 | && SizeAtCompileTime * (CoeffReadCost + NumTraits::AddCost) <= EIGEN_UNROLLING_LIMIT 112 | }; 113 | if(unroll) 114 | return internal::any_unroller::run(derived()); 117 | else 118 | { 119 | for(Index j = 0; j < cols(); ++j) 120 | for(Index i = 0; i < rows(); ++i) 121 | if (coeff(i, j)) return true; 122 | return false; 123 | } 124 | } 125 | 126 | /** \returns the number of coefficients which evaluate to true 127 | * 128 | * \sa all(), any() 129 | */ 130 | template 131 | inline typename DenseBase::Index DenseBase::count() const 132 | { 133 | return derived().template cast().template cast().sum(); 134 | } 135 | 136 | } // end namespace Eigen 137 | 138 | #endif // EIGEN_ALLANDANY_H 139 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core COMPONENT Devel 6 | ) 7 | 8 | ADD_SUBDIRECTORY(products) 9 | ADD_SUBDIRECTORY(util) 10 | ADD_SUBDIRECTORY(arch) 11 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/CommaInitializer.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008 Gael Guennebaud 5 | // Copyright (C) 2006-2008 Benoit Jacob 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | #ifndef EIGEN_COMMAINITIALIZER_H 12 | #define EIGEN_COMMAINITIALIZER_H 13 | 14 | namespace Eigen { 15 | 16 | /** \class CommaInitializer 17 | * \ingroup Core_Module 18 | * 19 | * \brief Helper class used by the comma initializer operator 20 | * 21 | * This class is internally used to implement the comma initializer feature. It is 22 | * the return type of MatrixBase::operator<<, and most of the time this is the only 23 | * way it is used. 24 | * 25 | * \sa \ref MatrixBaseCommaInitRef "MatrixBase::operator<<", CommaInitializer::finished() 26 | */ 27 | template 28 | struct CommaInitializer 29 | { 30 | typedef typename XprType::Scalar Scalar; 31 | typedef typename XprType::Index Index; 32 | 33 | inline CommaInitializer(XprType& xpr, const Scalar& s) 34 | : m_xpr(xpr), m_row(0), m_col(1), m_currentBlockRows(1) 35 | { 36 | m_xpr.coeffRef(0,0) = s; 37 | } 38 | 39 | template 40 | inline CommaInitializer(XprType& xpr, const DenseBase& other) 41 | : m_xpr(xpr), m_row(0), m_col(other.cols()), m_currentBlockRows(other.rows()) 42 | { 43 | m_xpr.block(0, 0, other.rows(), other.cols()) = other; 44 | } 45 | 46 | /* inserts a scalar value in the target matrix */ 47 | CommaInitializer& operator,(const Scalar& s) 48 | { 49 | if (m_col==m_xpr.cols()) 50 | { 51 | m_row+=m_currentBlockRows; 52 | m_col = 0; 53 | m_currentBlockRows = 1; 54 | eigen_assert(m_row 66 | CommaInitializer& operator,(const DenseBase& other) 67 | { 68 | if(other.cols()==0 || other.rows()==0) 69 | return *this; 70 | if (m_col==m_xpr.cols()) 71 | { 72 | m_row+=m_currentBlockRows; 73 | m_col = 0; 74 | m_currentBlockRows = other.rows(); 75 | eigen_assert(m_row+m_currentBlockRows<=m_xpr.rows() 76 | && "Too many rows passed to comma initializer (operator<<)"); 77 | } 78 | eigen_assert(m_col 84 | (m_row, m_col) = other; 85 | else 86 | m_xpr.block(m_row, m_col, other.rows(), other.cols()) = other; 87 | m_col += other.cols(); 88 | return *this; 89 | } 90 | 91 | inline ~CommaInitializer() 92 | { 93 | eigen_assert((m_row+m_currentBlockRows) == m_xpr.rows() 94 | && m_col == m_xpr.cols() 95 | && "Too few coefficients passed to comma initializer (operator<<)"); 96 | } 97 | 98 | /** \returns the built matrix once all its coefficients have been set. 99 | * Calling finished is 100% optional. Its purpose is to write expressions 100 | * like this: 101 | * \code 102 | * quaternion.fromRotationMatrix((Matrix3f() << axis0, axis1, axis2).finished()); 103 | * \endcode 104 | */ 105 | inline XprType& finished() { return m_xpr; } 106 | 107 | XprType& m_xpr; // target expression 108 | Index m_row; // current row id 109 | Index m_col; // current col id 110 | Index m_currentBlockRows; // current block height 111 | }; 112 | 113 | /** \anchor MatrixBaseCommaInitRef 114 | * Convenient operator to set the coefficients of a matrix. 115 | * 116 | * The coefficients must be provided in a row major order and exactly match 117 | * the size of the matrix. Otherwise an assertion is raised. 118 | * 119 | * Example: \include MatrixBase_set.cpp 120 | * Output: \verbinclude MatrixBase_set.out 121 | * 122 | * \sa CommaInitializer::finished(), class CommaInitializer 123 | */ 124 | template 125 | inline CommaInitializer DenseBase::operator<< (const Scalar& s) 126 | { 127 | return CommaInitializer(*static_cast(this), s); 128 | } 129 | 130 | /** \sa operator<<(const Scalar&) */ 131 | template 132 | template 133 | inline CommaInitializer 134 | DenseBase::operator<<(const DenseBase& other) 135 | { 136 | return CommaInitializer(*static_cast(this), other); 137 | } 138 | 139 | } // end namespace Eigen 140 | 141 | #endif // EIGEN_COMMAINITIALIZER_H 142 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/CwiseUnaryOp.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008-2010 Gael Guennebaud 5 | // Copyright (C) 2006-2008 Benoit Jacob 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | #ifndef EIGEN_CWISE_UNARY_OP_H 12 | #define EIGEN_CWISE_UNARY_OP_H 13 | 14 | namespace Eigen { 15 | 16 | /** \class CwiseUnaryOp 17 | * \ingroup Core_Module 18 | * 19 | * \brief Generic expression where a coefficient-wise unary operator is applied to an expression 20 | * 21 | * \param UnaryOp template functor implementing the operator 22 | * \param XprType the type of the expression to which we are applying the unary operator 23 | * 24 | * This class represents an expression where a unary operator is applied to an expression. 25 | * It is the return type of all operations taking exactly 1 input expression, regardless of the 26 | * presence of other inputs such as scalars. For example, the operator* in the expression 3*matrix 27 | * is considered unary, because only the right-hand side is an expression, and its 28 | * return type is a specialization of CwiseUnaryOp. 29 | * 30 | * Most of the time, this is the only way that it is used, so you typically don't have to name 31 | * CwiseUnaryOp types explicitly. 32 | * 33 | * \sa MatrixBase::unaryExpr(const CustomUnaryOp &) const, class CwiseBinaryOp, class CwiseNullaryOp 34 | */ 35 | 36 | namespace internal { 37 | template 38 | struct traits > 39 | : traits 40 | { 41 | typedef typename result_of< 42 | UnaryOp(typename XprType::Scalar) 43 | >::type Scalar; 44 | typedef typename XprType::Nested XprTypeNested; 45 | typedef typename remove_reference::type _XprTypeNested; 46 | enum { 47 | Flags = _XprTypeNested::Flags & ( 48 | HereditaryBits | LinearAccessBit | AlignedBit 49 | | (functor_traits::PacketAccess ? PacketAccessBit : 0)), 50 | CoeffReadCost = _XprTypeNested::CoeffReadCost + functor_traits::Cost 51 | }; 52 | }; 53 | } 54 | 55 | template 56 | class CwiseUnaryOpImpl; 57 | 58 | template 59 | class CwiseUnaryOp : internal::no_assignment_operator, 60 | public CwiseUnaryOpImpl::StorageKind> 61 | { 62 | public: 63 | 64 | typedef typename CwiseUnaryOpImpl::StorageKind>::Base Base; 65 | EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryOp) 66 | 67 | inline CwiseUnaryOp(const XprType& xpr, const UnaryOp& func = UnaryOp()) 68 | : m_xpr(xpr), m_functor(func) {} 69 | 70 | EIGEN_STRONG_INLINE Index rows() const { return m_xpr.rows(); } 71 | EIGEN_STRONG_INLINE Index cols() const { return m_xpr.cols(); } 72 | 73 | /** \returns the functor representing the unary operation */ 74 | const UnaryOp& functor() const { return m_functor; } 75 | 76 | /** \returns the nested expression */ 77 | const typename internal::remove_all::type& 78 | nestedExpression() const { return m_xpr; } 79 | 80 | /** \returns the nested expression */ 81 | typename internal::remove_all::type& 82 | nestedExpression() { return m_xpr.const_cast_derived(); } 83 | 84 | protected: 85 | typename XprType::Nested m_xpr; 86 | const UnaryOp m_functor; 87 | }; 88 | 89 | // This is the generic implementation for dense storage. 90 | // It can be used for any expression types implementing the dense concept. 91 | template 92 | class CwiseUnaryOpImpl 93 | : public internal::dense_xpr_base >::type 94 | { 95 | public: 96 | 97 | typedef CwiseUnaryOp Derived; 98 | typedef typename internal::dense_xpr_base >::type Base; 99 | EIGEN_DENSE_PUBLIC_INTERFACE(Derived) 100 | 101 | EIGEN_STRONG_INLINE const Scalar coeff(Index row, Index col) const 102 | { 103 | return derived().functor()(derived().nestedExpression().coeff(row, col)); 104 | } 105 | 106 | template 107 | EIGEN_STRONG_INLINE PacketScalar packet(Index row, Index col) const 108 | { 109 | return derived().functor().packetOp(derived().nestedExpression().template packet(row, col)); 110 | } 111 | 112 | EIGEN_STRONG_INLINE const Scalar coeff(Index index) const 113 | { 114 | return derived().functor()(derived().nestedExpression().coeff(index)); 115 | } 116 | 117 | template 118 | EIGEN_STRONG_INLINE PacketScalar packet(Index index) const 119 | { 120 | return derived().functor().packetOp(derived().nestedExpression().template packet(index)); 121 | } 122 | }; 123 | 124 | } // end namespace Eigen 125 | 126 | #endif // EIGEN_CWISE_UNARY_OP_H 127 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/Flagged.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008 Benoit Jacob 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_FLAGGED_H 11 | #define EIGEN_FLAGGED_H 12 | 13 | namespace Eigen { 14 | 15 | /** \class Flagged 16 | * \ingroup Core_Module 17 | * 18 | * \brief Expression with modified flags 19 | * 20 | * \param ExpressionType the type of the object of which we are modifying the flags 21 | * \param Added the flags added to the expression 22 | * \param Removed the flags removed from the expression (has priority over Added). 23 | * 24 | * This class represents an expression whose flags have been modified. 25 | * It is the return type of MatrixBase::flagged() 26 | * and most of the time this is the only way it is used. 27 | * 28 | * \sa MatrixBase::flagged() 29 | */ 30 | 31 | namespace internal { 32 | template 33 | struct traits > : traits 34 | { 35 | enum { Flags = (ExpressionType::Flags | Added) & ~Removed }; 36 | }; 37 | } 38 | 39 | template class Flagged 40 | : public MatrixBase > 41 | { 42 | public: 43 | 44 | typedef MatrixBase Base; 45 | 46 | EIGEN_DENSE_PUBLIC_INTERFACE(Flagged) 47 | typedef typename internal::conditional::ret, 48 | ExpressionType, const ExpressionType&>::type ExpressionTypeNested; 49 | typedef typename ExpressionType::InnerIterator InnerIterator; 50 | 51 | inline Flagged(const ExpressionType& matrix) : m_matrix(matrix) {} 52 | 53 | inline Index rows() const { return m_matrix.rows(); } 54 | inline Index cols() const { return m_matrix.cols(); } 55 | inline Index outerStride() const { return m_matrix.outerStride(); } 56 | inline Index innerStride() const { return m_matrix.innerStride(); } 57 | 58 | inline CoeffReturnType coeff(Index row, Index col) const 59 | { 60 | return m_matrix.coeff(row, col); 61 | } 62 | 63 | inline CoeffReturnType coeff(Index index) const 64 | { 65 | return m_matrix.coeff(index); 66 | } 67 | 68 | inline const Scalar& coeffRef(Index row, Index col) const 69 | { 70 | return m_matrix.const_cast_derived().coeffRef(row, col); 71 | } 72 | 73 | inline const Scalar& coeffRef(Index index) const 74 | { 75 | return m_matrix.const_cast_derived().coeffRef(index); 76 | } 77 | 78 | inline Scalar& coeffRef(Index row, Index col) 79 | { 80 | return m_matrix.const_cast_derived().coeffRef(row, col); 81 | } 82 | 83 | inline Scalar& coeffRef(Index index) 84 | { 85 | return m_matrix.const_cast_derived().coeffRef(index); 86 | } 87 | 88 | template 89 | inline const PacketScalar packet(Index row, Index col) const 90 | { 91 | return m_matrix.template packet(row, col); 92 | } 93 | 94 | template 95 | inline void writePacket(Index row, Index col, const PacketScalar& x) 96 | { 97 | m_matrix.const_cast_derived().template writePacket(row, col, x); 98 | } 99 | 100 | template 101 | inline const PacketScalar packet(Index index) const 102 | { 103 | return m_matrix.template packet(index); 104 | } 105 | 106 | template 107 | inline void writePacket(Index index, const PacketScalar& x) 108 | { 109 | m_matrix.const_cast_derived().template writePacket(index, x); 110 | } 111 | 112 | const ExpressionType& _expression() const { return m_matrix; } 113 | 114 | template 115 | typename ExpressionType::PlainObject solveTriangular(const MatrixBase& other) const; 116 | 117 | template 118 | void solveTriangularInPlace(const MatrixBase& other) const; 119 | 120 | protected: 121 | ExpressionTypeNested m_matrix; 122 | }; 123 | 124 | /** \returns an expression of *this with added and removed flags 125 | * 126 | * This is mostly for internal use. 127 | * 128 | * \sa class Flagged 129 | */ 130 | template 131 | template 132 | inline const Flagged 133 | DenseBase::flagged() const 134 | { 135 | return derived(); 136 | } 137 | 138 | } // end namespace Eigen 139 | 140 | #endif // EIGEN_FLAGGED_H 141 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/ForceAlignedAccess.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009-2010 Gael Guennebaud 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_FORCEALIGNEDACCESS_H 11 | #define EIGEN_FORCEALIGNEDACCESS_H 12 | 13 | namespace Eigen { 14 | 15 | /** \class ForceAlignedAccess 16 | * \ingroup Core_Module 17 | * 18 | * \brief Enforce aligned packet loads and stores regardless of what is requested 19 | * 20 | * \param ExpressionType the type of the object of which we are forcing aligned packet access 21 | * 22 | * This class is the return type of MatrixBase::forceAlignedAccess() 23 | * and most of the time this is the only way it is used. 24 | * 25 | * \sa MatrixBase::forceAlignedAccess() 26 | */ 27 | 28 | namespace internal { 29 | template 30 | struct traits > : public traits 31 | {}; 32 | } 33 | 34 | template class ForceAlignedAccess 35 | : public internal::dense_xpr_base< ForceAlignedAccess >::type 36 | { 37 | public: 38 | 39 | typedef typename internal::dense_xpr_base::type Base; 40 | EIGEN_DENSE_PUBLIC_INTERFACE(ForceAlignedAccess) 41 | 42 | inline ForceAlignedAccess(const ExpressionType& matrix) : m_expression(matrix) {} 43 | 44 | inline Index rows() const { return m_expression.rows(); } 45 | inline Index cols() const { return m_expression.cols(); } 46 | inline Index outerStride() const { return m_expression.outerStride(); } 47 | inline Index innerStride() const { return m_expression.innerStride(); } 48 | 49 | inline const CoeffReturnType coeff(Index row, Index col) const 50 | { 51 | return m_expression.coeff(row, col); 52 | } 53 | 54 | inline Scalar& coeffRef(Index row, Index col) 55 | { 56 | return m_expression.const_cast_derived().coeffRef(row, col); 57 | } 58 | 59 | inline const CoeffReturnType coeff(Index index) const 60 | { 61 | return m_expression.coeff(index); 62 | } 63 | 64 | inline Scalar& coeffRef(Index index) 65 | { 66 | return m_expression.const_cast_derived().coeffRef(index); 67 | } 68 | 69 | template 70 | inline const PacketScalar packet(Index row, Index col) const 71 | { 72 | return m_expression.template packet(row, col); 73 | } 74 | 75 | template 76 | inline void writePacket(Index row, Index col, const PacketScalar& x) 77 | { 78 | m_expression.const_cast_derived().template writePacket(row, col, x); 79 | } 80 | 81 | template 82 | inline const PacketScalar packet(Index index) const 83 | { 84 | return m_expression.template packet(index); 85 | } 86 | 87 | template 88 | inline void writePacket(Index index, const PacketScalar& x) 89 | { 90 | m_expression.const_cast_derived().template writePacket(index, x); 91 | } 92 | 93 | operator const ExpressionType&() const { return m_expression; } 94 | 95 | protected: 96 | const ExpressionType& m_expression; 97 | 98 | private: 99 | ForceAlignedAccess& operator=(const ForceAlignedAccess&); 100 | }; 101 | 102 | /** \returns an expression of *this with forced aligned access 103 | * \sa forceAlignedAccessIf(),class ForceAlignedAccess 104 | */ 105 | template 106 | inline const ForceAlignedAccess 107 | MatrixBase::forceAlignedAccess() const 108 | { 109 | return ForceAlignedAccess(derived()); 110 | } 111 | 112 | /** \returns an expression of *this with forced aligned access 113 | * \sa forceAlignedAccessIf(), class ForceAlignedAccess 114 | */ 115 | template 116 | inline ForceAlignedAccess 117 | MatrixBase::forceAlignedAccess() 118 | { 119 | return ForceAlignedAccess(derived()); 120 | } 121 | 122 | /** \returns an expression of *this with forced aligned access if \a Enable is true. 123 | * \sa forceAlignedAccess(), class ForceAlignedAccess 124 | */ 125 | template 126 | template 127 | inline typename internal::add_const_on_value_type,Derived&>::type>::type 128 | MatrixBase::forceAlignedAccessIf() const 129 | { 130 | return derived(); 131 | } 132 | 133 | /** \returns an expression of *this with forced aligned access if \a Enable is true. 134 | * \sa forceAlignedAccess(), class ForceAlignedAccess 135 | */ 136 | template 137 | template 138 | inline typename internal::conditional,Derived&>::type 139 | MatrixBase::forceAlignedAccessIf() 140 | { 141 | return derived(); 142 | } 143 | 144 | } // end namespace Eigen 145 | 146 | #endif // EIGEN_FORCEALIGNEDACCESS_H 147 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/GlobalFunctions.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2010 Gael Guennebaud 5 | // Copyright (C) 2010 Benoit Jacob 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | #ifndef EIGEN_GLOBAL_FUNCTIONS_H 12 | #define EIGEN_GLOBAL_FUNCTIONS_H 13 | 14 | #define EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(NAME,FUNCTOR) \ 15 | template \ 16 | inline const Eigen::CwiseUnaryOp, const Derived> \ 17 | NAME(const Eigen::ArrayBase& x) { \ 18 | return x.derived(); \ 19 | } 20 | 21 | #define EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(NAME,FUNCTOR) \ 22 | \ 23 | template \ 24 | struct NAME##_retval > \ 25 | { \ 26 | typedef const Eigen::CwiseUnaryOp, const Derived> type; \ 27 | }; \ 28 | template \ 29 | struct NAME##_impl > \ 30 | { \ 31 | static inline typename NAME##_retval >::type run(const Eigen::ArrayBase& x) \ 32 | { \ 33 | return x.derived(); \ 34 | } \ 35 | }; 36 | 37 | 38 | namespace std 39 | { 40 | EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(real,scalar_real_op) 41 | EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(imag,scalar_imag_op) 42 | EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(sin,scalar_sin_op) 43 | EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(cos,scalar_cos_op) 44 | EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(asin,scalar_asin_op) 45 | EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(acos,scalar_acos_op) 46 | EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(tan,scalar_tan_op) 47 | EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(exp,scalar_exp_op) 48 | EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(log,scalar_log_op) 49 | EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(abs,scalar_abs_op) 50 | EIGEN_ARRAY_DECLARE_GLOBAL_STD_UNARY(sqrt,scalar_sqrt_op) 51 | 52 | template 53 | inline const Eigen::CwiseUnaryOp, const Derived> 54 | pow(const Eigen::ArrayBase& x, const typename Derived::Scalar& exponent) { 55 | return x.derived().pow(exponent); 56 | } 57 | 58 | template 59 | inline const Eigen::CwiseBinaryOp, const Derived, const Derived> 60 | pow(const Eigen::ArrayBase& x, const Eigen::ArrayBase& exponents) 61 | { 62 | return Eigen::CwiseBinaryOp, const Derived, const Derived>( 63 | x.derived(), 64 | exponents.derived() 65 | ); 66 | } 67 | } 68 | 69 | namespace Eigen 70 | { 71 | /** 72 | * \brief Component-wise division of a scalar by array elements. 73 | **/ 74 | template 75 | inline const Eigen::CwiseUnaryOp, const Derived> 76 | operator/(typename Derived::Scalar s, const Eigen::ArrayBase& a) 77 | { 78 | return Eigen::CwiseUnaryOp, const Derived>( 79 | a.derived(), 80 | Eigen::internal::scalar_inverse_mult_op(s) 81 | ); 82 | } 83 | 84 | namespace internal 85 | { 86 | EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(real,scalar_real_op) 87 | EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(imag,scalar_imag_op) 88 | EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(sin,scalar_sin_op) 89 | EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(cos,scalar_cos_op) 90 | EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(asin,scalar_asin_op) 91 | EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(acos,scalar_acos_op) 92 | EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(tan,scalar_tan_op) 93 | EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(exp,scalar_exp_op) 94 | EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(log,scalar_log_op) 95 | EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(abs,scalar_abs_op) 96 | EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(abs2,scalar_abs2_op) 97 | EIGEN_ARRAY_DECLARE_GLOBAL_EIGEN_UNARY(sqrt,scalar_sqrt_op) 98 | } 99 | } 100 | 101 | // TODO: cleanly disable those functions that are not supported on Array (internal::real_ref, internal::random, internal::isApprox...) 102 | 103 | #endif // EIGEN_GLOBAL_FUNCTIONS_H 104 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/NestByValue.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008 Gael Guennebaud 5 | // Copyright (C) 2006-2008 Benoit Jacob 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | #ifndef EIGEN_NESTBYVALUE_H 12 | #define EIGEN_NESTBYVALUE_H 13 | 14 | namespace Eigen { 15 | 16 | /** \class NestByValue 17 | * \ingroup Core_Module 18 | * 19 | * \brief Expression which must be nested by value 20 | * 21 | * \param ExpressionType the type of the object of which we are requiring nesting-by-value 22 | * 23 | * This class is the return type of MatrixBase::nestByValue() 24 | * and most of the time this is the only way it is used. 25 | * 26 | * \sa MatrixBase::nestByValue() 27 | */ 28 | 29 | namespace internal { 30 | template 31 | struct traits > : public traits 32 | {}; 33 | } 34 | 35 | template class NestByValue 36 | : public internal::dense_xpr_base< NestByValue >::type 37 | { 38 | public: 39 | 40 | typedef typename internal::dense_xpr_base::type Base; 41 | EIGEN_DENSE_PUBLIC_INTERFACE(NestByValue) 42 | 43 | inline NestByValue(const ExpressionType& matrix) : m_expression(matrix) {} 44 | 45 | inline Index rows() const { return m_expression.rows(); } 46 | inline Index cols() const { return m_expression.cols(); } 47 | inline Index outerStride() const { return m_expression.outerStride(); } 48 | inline Index innerStride() const { return m_expression.innerStride(); } 49 | 50 | inline const CoeffReturnType coeff(Index row, Index col) const 51 | { 52 | return m_expression.coeff(row, col); 53 | } 54 | 55 | inline Scalar& coeffRef(Index row, Index col) 56 | { 57 | return m_expression.const_cast_derived().coeffRef(row, col); 58 | } 59 | 60 | inline const CoeffReturnType coeff(Index index) const 61 | { 62 | return m_expression.coeff(index); 63 | } 64 | 65 | inline Scalar& coeffRef(Index index) 66 | { 67 | return m_expression.const_cast_derived().coeffRef(index); 68 | } 69 | 70 | template 71 | inline const PacketScalar packet(Index row, Index col) const 72 | { 73 | return m_expression.template packet(row, col); 74 | } 75 | 76 | template 77 | inline void writePacket(Index row, Index col, const PacketScalar& x) 78 | { 79 | m_expression.const_cast_derived().template writePacket(row, col, x); 80 | } 81 | 82 | template 83 | inline const PacketScalar packet(Index index) const 84 | { 85 | return m_expression.template packet(index); 86 | } 87 | 88 | template 89 | inline void writePacket(Index index, const PacketScalar& x) 90 | { 91 | m_expression.const_cast_derived().template writePacket(index, x); 92 | } 93 | 94 | operator const ExpressionType&() const { return m_expression; } 95 | 96 | protected: 97 | const ExpressionType m_expression; 98 | }; 99 | 100 | /** \returns an expression of the temporary version of *this. 101 | */ 102 | template 103 | inline const NestByValue 104 | DenseBase::nestByValue() const 105 | { 106 | return NestByValue(derived()); 107 | } 108 | 109 | } // end namespace Eigen 110 | 111 | #endif // EIGEN_NESTBYVALUE_H 112 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/NoAlias.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009 Gael Guennebaud 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_NOALIAS_H 11 | #define EIGEN_NOALIAS_H 12 | 13 | namespace Eigen { 14 | 15 | /** \class NoAlias 16 | * \ingroup Core_Module 17 | * 18 | * \brief Pseudo expression providing an operator = assuming no aliasing 19 | * 20 | * \param ExpressionType the type of the object on which to do the lazy assignment 21 | * 22 | * This class represents an expression with special assignment operators 23 | * assuming no aliasing between the target expression and the source expression. 24 | * More precisely it alloas to bypass the EvalBeforeAssignBit flag of the source expression. 25 | * It is the return type of MatrixBase::noalias() 26 | * and most of the time this is the only way it is used. 27 | * 28 | * \sa MatrixBase::noalias() 29 | */ 30 | template class StorageBase> 31 | class NoAlias 32 | { 33 | typedef typename ExpressionType::Scalar Scalar; 34 | public: 35 | NoAlias(ExpressionType& expression) : m_expression(expression) {} 36 | 37 | /** Behaves like MatrixBase::lazyAssign(other) 38 | * \sa MatrixBase::lazyAssign() */ 39 | template 40 | EIGEN_STRONG_INLINE ExpressionType& operator=(const StorageBase& other) 41 | { return internal::assign_selector::run(m_expression,other.derived()); } 42 | 43 | /** \sa MatrixBase::operator+= */ 44 | template 45 | EIGEN_STRONG_INLINE ExpressionType& operator+=(const StorageBase& other) 46 | { 47 | typedef SelfCwiseBinaryOp, ExpressionType, OtherDerived> SelfAdder; 48 | SelfAdder tmp(m_expression); 49 | typedef typename internal::nested::type OtherDerivedNested; 50 | typedef typename internal::remove_all::type _OtherDerivedNested; 51 | internal::assign_selector::run(tmp,OtherDerivedNested(other.derived())); 52 | return m_expression; 53 | } 54 | 55 | /** \sa MatrixBase::operator-= */ 56 | template 57 | EIGEN_STRONG_INLINE ExpressionType& operator-=(const StorageBase& other) 58 | { 59 | typedef SelfCwiseBinaryOp, ExpressionType, OtherDerived> SelfAdder; 60 | SelfAdder tmp(m_expression); 61 | typedef typename internal::nested::type OtherDerivedNested; 62 | typedef typename internal::remove_all::type _OtherDerivedNested; 63 | internal::assign_selector::run(tmp,OtherDerivedNested(other.derived())); 64 | return m_expression; 65 | } 66 | 67 | #ifndef EIGEN_PARSED_BY_DOXYGEN 68 | template 69 | EIGEN_STRONG_INLINE ExpressionType& operator+=(const ProductBase& other) 70 | { other.derived().addTo(m_expression); return m_expression; } 71 | 72 | template 73 | EIGEN_STRONG_INLINE ExpressionType& operator-=(const ProductBase& other) 74 | { other.derived().subTo(m_expression); return m_expression; } 75 | 76 | template 77 | EIGEN_STRONG_INLINE ExpressionType& operator+=(const CoeffBasedProduct& other) 78 | { return m_expression.derived() += CoeffBasedProduct(other.lhs(), other.rhs()); } 79 | 80 | template 81 | EIGEN_STRONG_INLINE ExpressionType& operator-=(const CoeffBasedProduct& other) 82 | { return m_expression.derived() -= CoeffBasedProduct(other.lhs(), other.rhs()); } 83 | #endif 84 | 85 | protected: 86 | ExpressionType& m_expression; 87 | }; 88 | 89 | /** \returns a pseudo expression of \c *this with an operator= assuming 90 | * no aliasing between \c *this and the source expression. 91 | * 92 | * More precisely, noalias() allows to bypass the EvalBeforeAssignBit flag. 93 | * Currently, even though several expressions may alias, only product 94 | * expressions have this flag. Therefore, noalias() is only usefull when 95 | * the source expression contains a matrix product. 96 | * 97 | * Here are some examples where noalias is usefull: 98 | * \code 99 | * D.noalias() = A * B; 100 | * D.noalias() += A.transpose() * B; 101 | * D.noalias() -= 2 * A * B.adjoint(); 102 | * \endcode 103 | * 104 | * On the other hand the following example will lead to a \b wrong result: 105 | * \code 106 | * A.noalias() = A * B; 107 | * \endcode 108 | * because the result matrix A is also an operand of the matrix product. Therefore, 109 | * there is no alternative than evaluating A * B in a temporary, that is the default 110 | * behavior when you write: 111 | * \code 112 | * A = A * B; 113 | * \endcode 114 | * 115 | * \sa class NoAlias 116 | */ 117 | template 118 | NoAlias MatrixBase::noalias() 119 | { 120 | return derived(); 121 | } 122 | 123 | } // end namespace Eigen 124 | 125 | #endif // EIGEN_NOALIAS_H 126 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/Product.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008-2011 Gael Guennebaud 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla Public 7 | // License, v. 2.0. If a copy of the MPL was not distributed with this 8 | // file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_PRODUCT_H 11 | #define EIGEN_PRODUCT_H 12 | 13 | template class Product; 14 | template class ProductImpl; 15 | 16 | /** \class Product 17 | * \ingroup Core_Module 18 | * 19 | * \brief Expression of the product of two arbitrary matrices or vectors 20 | * 21 | * \param Lhs the type of the left-hand side expression 22 | * \param Rhs the type of the right-hand side expression 23 | * 24 | * This class represents an expression of the product of two arbitrary matrices. 25 | * 26 | */ 27 | 28 | namespace internal { 29 | template 30 | struct traits > 31 | { 32 | typedef MatrixXpr XprKind; 33 | typedef typename remove_all::type LhsCleaned; 34 | typedef typename remove_all::type RhsCleaned; 35 | typedef typename scalar_product_traits::Scalar, typename traits::Scalar>::ReturnType Scalar; 36 | typedef typename promote_storage_type::StorageKind, 37 | typename traits::StorageKind>::ret StorageKind; 38 | typedef typename promote_index_type::Index, 39 | typename traits::Index>::type Index; 40 | enum { 41 | RowsAtCompileTime = LhsCleaned::RowsAtCompileTime, 42 | ColsAtCompileTime = RhsCleaned::ColsAtCompileTime, 43 | MaxRowsAtCompileTime = LhsCleaned::MaxRowsAtCompileTime, 44 | MaxColsAtCompileTime = RhsCleaned::MaxColsAtCompileTime, 45 | Flags = (MaxRowsAtCompileTime==1 ? RowMajorBit : 0), // TODO should be no storage order 46 | CoeffReadCost = 0 // TODO CoeffReadCost should not be part of the expression traits 47 | }; 48 | }; 49 | } // end namespace internal 50 | 51 | 52 | template 53 | class Product : public ProductImpl::StorageKind, 54 | typename internal::traits::StorageKind>::ret> 55 | { 56 | public: 57 | 58 | typedef typename ProductImpl< 59 | Lhs, Rhs, 60 | typename internal::promote_storage_type::ret>::Base Base; 62 | EIGEN_GENERIC_PUBLIC_INTERFACE(Product) 63 | 64 | typedef typename Lhs::Nested LhsNested; 65 | typedef typename Rhs::Nested RhsNested; 66 | typedef typename internal::remove_all::type LhsNestedCleaned; 67 | typedef typename internal::remove_all::type RhsNestedCleaned; 68 | 69 | Product(const Lhs& lhs, const Rhs& rhs) : m_lhs(lhs), m_rhs(rhs) 70 | { 71 | eigen_assert(lhs.cols() == rhs.rows() 72 | && "invalid matrix product" 73 | && "if you wanted a coeff-wise or a dot product use the respective explicit functions"); 74 | } 75 | 76 | inline Index rows() const { return m_lhs.rows(); } 77 | inline Index cols() const { return m_rhs.cols(); } 78 | 79 | const LhsNestedCleaned& lhs() const { return m_lhs; } 80 | const RhsNestedCleaned& rhs() const { return m_rhs; } 81 | 82 | protected: 83 | 84 | const LhsNested m_lhs; 85 | const RhsNested m_rhs; 86 | }; 87 | 88 | template 89 | class ProductImpl : public internal::dense_xpr_base >::type 90 | { 91 | typedef Product Derived; 92 | public: 93 | 94 | typedef typename internal::dense_xpr_base >::type Base; 95 | EIGEN_DENSE_PUBLIC_INTERFACE(Derived) 96 | }; 97 | 98 | #endif // EIGEN_PRODUCT_H 99 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/ReturnByValue.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009-2010 Gael Guennebaud 5 | // Copyright (C) 2009-2010 Benoit Jacob 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | #ifndef EIGEN_RETURNBYVALUE_H 12 | #define EIGEN_RETURNBYVALUE_H 13 | 14 | namespace Eigen { 15 | 16 | /** \class ReturnByValue 17 | * \ingroup Core_Module 18 | * 19 | */ 20 | 21 | namespace internal { 22 | 23 | template 24 | struct traits > 25 | : public traits::ReturnType> 26 | { 27 | enum { 28 | // We're disabling the DirectAccess because e.g. the constructor of 29 | // the Block-with-DirectAccess expression requires to have a coeffRef method. 30 | // Also, we don't want to have to implement the stride stuff. 31 | Flags = (traits::ReturnType>::Flags 32 | | EvalBeforeNestingBit) & ~DirectAccessBit 33 | }; 34 | }; 35 | 36 | /* The ReturnByValue object doesn't even have a coeff() method. 37 | * So the only way that nesting it in an expression can work, is by evaluating it into a plain matrix. 38 | * So internal::nested always gives the plain return matrix type. 39 | * 40 | * FIXME: I don't understand why we need this specialization: isn't this taken care of by the EvalBeforeNestingBit ?? 41 | */ 42 | template 43 | struct nested, n, PlainObject> 44 | { 45 | typedef typename traits::ReturnType type; 46 | }; 47 | 48 | } // end namespace internal 49 | 50 | template class ReturnByValue 51 | : public internal::dense_xpr_base< ReturnByValue >::type 52 | { 53 | public: 54 | typedef typename internal::traits::ReturnType ReturnType; 55 | 56 | typedef typename internal::dense_xpr_base::type Base; 57 | EIGEN_DENSE_PUBLIC_INTERFACE(ReturnByValue) 58 | 59 | template 60 | inline void evalTo(Dest& dst) const 61 | { static_cast(this)->evalTo(dst); } 62 | inline Index rows() const { return static_cast(this)->rows(); } 63 | inline Index cols() const { return static_cast(this)->cols(); } 64 | 65 | #ifndef EIGEN_PARSED_BY_DOXYGEN 66 | #define Unusable YOU_ARE_TRYING_TO_ACCESS_A_SINGLE_COEFFICIENT_IN_A_SPECIAL_EXPRESSION_WHERE_THAT_IS_NOT_ALLOWED_BECAUSE_THAT_WOULD_BE_INEFFICIENT 67 | class Unusable{ 68 | Unusable(const Unusable&) {} 69 | Unusable& operator=(const Unusable&) {return *this;} 70 | }; 71 | const Unusable& coeff(Index) const { return *reinterpret_cast(this); } 72 | const Unusable& coeff(Index,Index) const { return *reinterpret_cast(this); } 73 | Unusable& coeffRef(Index) { return *reinterpret_cast(this); } 74 | Unusable& coeffRef(Index,Index) { return *reinterpret_cast(this); } 75 | #endif 76 | }; 77 | 78 | template 79 | template 80 | Derived& DenseBase::operator=(const ReturnByValue& other) 81 | { 82 | other.evalTo(derived()); 83 | return derived(); 84 | } 85 | 86 | } // end namespace Eigen 87 | 88 | #endif // EIGEN_RETURNBYVALUE_H 89 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/Stride.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2010 Benoit Jacob 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_STRIDE_H 11 | #define EIGEN_STRIDE_H 12 | 13 | namespace Eigen { 14 | 15 | /** \class Stride 16 | * \ingroup Core_Module 17 | * 18 | * \brief Holds strides information for Map 19 | * 20 | * This class holds the strides information for mapping arrays with strides with class Map. 21 | * 22 | * It holds two values: the inner stride and the outer stride. 23 | * 24 | * The inner stride is the pointer increment between two consecutive entries within a given row of a 25 | * row-major matrix or within a given column of a column-major matrix. 26 | * 27 | * The outer stride is the pointer increment between two consecutive rows of a row-major matrix or 28 | * between two consecutive columns of a column-major matrix. 29 | * 30 | * These two values can be passed either at compile-time as template parameters, or at runtime as 31 | * arguments to the constructor. 32 | * 33 | * Indeed, this class takes two template parameters: 34 | * \param _OuterStrideAtCompileTime the outer stride, or Dynamic if you want to specify it at runtime. 35 | * \param _InnerStrideAtCompileTime the inner stride, or Dynamic if you want to specify it at runtime. 36 | * 37 | * Here is an example: 38 | * \include Map_general_stride.cpp 39 | * Output: \verbinclude Map_general_stride.out 40 | * 41 | * \sa class InnerStride, class OuterStride, \ref TopicStorageOrders 42 | */ 43 | template 44 | class Stride 45 | { 46 | public: 47 | typedef DenseIndex Index; 48 | enum { 49 | InnerStrideAtCompileTime = _InnerStrideAtCompileTime, 50 | OuterStrideAtCompileTime = _OuterStrideAtCompileTime 51 | }; 52 | 53 | /** Default constructor, for use when strides are fixed at compile time */ 54 | Stride() 55 | : m_outer(OuterStrideAtCompileTime), m_inner(InnerStrideAtCompileTime) 56 | { 57 | eigen_assert(InnerStrideAtCompileTime != Dynamic && OuterStrideAtCompileTime != Dynamic); 58 | } 59 | 60 | /** Constructor allowing to pass the strides at runtime */ 61 | Stride(Index outerStride, Index innerStride) 62 | : m_outer(outerStride), m_inner(innerStride) 63 | { 64 | eigen_assert(innerStride>=0 && outerStride>=0); 65 | } 66 | 67 | /** Copy constructor */ 68 | Stride(const Stride& other) 69 | : m_outer(other.outer()), m_inner(other.inner()) 70 | {} 71 | 72 | /** \returns the outer stride */ 73 | inline Index outer() const { return m_outer.value(); } 74 | /** \returns the inner stride */ 75 | inline Index inner() const { return m_inner.value(); } 76 | 77 | protected: 78 | internal::variable_if_dynamic m_outer; 79 | internal::variable_if_dynamic m_inner; 80 | }; 81 | 82 | /** \brief Convenience specialization of Stride to specify only an inner stride 83 | * See class Map for some examples */ 84 | template 85 | class InnerStride : public Stride<0, Value> 86 | { 87 | typedef Stride<0, Value> Base; 88 | public: 89 | typedef DenseIndex Index; 90 | InnerStride() : Base() {} 91 | InnerStride(Index v) : Base(0, v) {} 92 | }; 93 | 94 | /** \brief Convenience specialization of Stride to specify only an outer stride 95 | * See class Map for some examples */ 96 | template 97 | class OuterStride : public Stride 98 | { 99 | typedef Stride Base; 100 | public: 101 | typedef DenseIndex Index; 102 | OuterStride() : Base() {} 103 | OuterStride(Index v) : Base(v,0) {} 104 | }; 105 | 106 | } // end namespace Eigen 107 | 108 | #endif // EIGEN_STRIDE_H 109 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/Swap.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2006-2008 Benoit Jacob 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_SWAP_H 11 | #define EIGEN_SWAP_H 12 | 13 | namespace Eigen { 14 | 15 | /** \class SwapWrapper 16 | * \ingroup Core_Module 17 | * 18 | * \internal 19 | * 20 | * \brief Internal helper class for swapping two expressions 21 | */ 22 | namespace internal { 23 | template 24 | struct traits > : traits {}; 25 | } 26 | 27 | template class SwapWrapper 28 | : public internal::dense_xpr_base >::type 29 | { 30 | public: 31 | 32 | typedef typename internal::dense_xpr_base::type Base; 33 | EIGEN_DENSE_PUBLIC_INTERFACE(SwapWrapper) 34 | typedef typename internal::packet_traits::type Packet; 35 | 36 | inline SwapWrapper(ExpressionType& xpr) : m_expression(xpr) {} 37 | 38 | inline Index rows() const { return m_expression.rows(); } 39 | inline Index cols() const { return m_expression.cols(); } 40 | inline Index outerStride() const { return m_expression.outerStride(); } 41 | inline Index innerStride() const { return m_expression.innerStride(); } 42 | 43 | typedef typename internal::conditional< 44 | internal::is_lvalue::value, 45 | Scalar, 46 | const Scalar 47 | >::type ScalarWithConstIfNotLvalue; 48 | 49 | inline ScalarWithConstIfNotLvalue* data() { return m_expression.data(); } 50 | inline const Scalar* data() const { return m_expression.data(); } 51 | 52 | inline Scalar& coeffRef(Index row, Index col) 53 | { 54 | return m_expression.const_cast_derived().coeffRef(row, col); 55 | } 56 | 57 | inline Scalar& coeffRef(Index index) 58 | { 59 | return m_expression.const_cast_derived().coeffRef(index); 60 | } 61 | 62 | inline Scalar& coeffRef(Index row, Index col) const 63 | { 64 | return m_expression.coeffRef(row, col); 65 | } 66 | 67 | inline Scalar& coeffRef(Index index) const 68 | { 69 | return m_expression.coeffRef(index); 70 | } 71 | 72 | template 73 | void copyCoeff(Index row, Index col, const DenseBase& other) 74 | { 75 | OtherDerived& _other = other.const_cast_derived(); 76 | eigen_internal_assert(row >= 0 && row < rows() 77 | && col >= 0 && col < cols()); 78 | Scalar tmp = m_expression.coeff(row, col); 79 | m_expression.coeffRef(row, col) = _other.coeff(row, col); 80 | _other.coeffRef(row, col) = tmp; 81 | } 82 | 83 | template 84 | void copyCoeff(Index index, const DenseBase& other) 85 | { 86 | OtherDerived& _other = other.const_cast_derived(); 87 | eigen_internal_assert(index >= 0 && index < m_expression.size()); 88 | Scalar tmp = m_expression.coeff(index); 89 | m_expression.coeffRef(index) = _other.coeff(index); 90 | _other.coeffRef(index) = tmp; 91 | } 92 | 93 | template 94 | void copyPacket(Index row, Index col, const DenseBase& other) 95 | { 96 | OtherDerived& _other = other.const_cast_derived(); 97 | eigen_internal_assert(row >= 0 && row < rows() 98 | && col >= 0 && col < cols()); 99 | Packet tmp = m_expression.template packet(row, col); 100 | m_expression.template writePacket(row, col, 101 | _other.template packet(row, col) 102 | ); 103 | _other.template writePacket(row, col, tmp); 104 | } 105 | 106 | template 107 | void copyPacket(Index index, const DenseBase& other) 108 | { 109 | OtherDerived& _other = other.const_cast_derived(); 110 | eigen_internal_assert(index >= 0 && index < m_expression.size()); 111 | Packet tmp = m_expression.template packet(index); 112 | m_expression.template writePacket(index, 113 | _other.template packet(index) 114 | ); 115 | _other.template writePacket(index, tmp); 116 | } 117 | 118 | ExpressionType& expression() const { return m_expression; } 119 | 120 | protected: 121 | ExpressionType& m_expression; 122 | }; 123 | 124 | } // end namespace Eigen 125 | 126 | #endif // EIGEN_SWAP_H 127 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/arch/AltiVec/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_arch_AltiVec_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_arch_AltiVec_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/AltiVec COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/arch/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | ADD_SUBDIRECTORY(SSE) 2 | ADD_SUBDIRECTORY(AltiVec) 3 | ADD_SUBDIRECTORY(NEON) 4 | ADD_SUBDIRECTORY(Default) 5 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/arch/Default/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_arch_Default_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_arch_Default_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/Default COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/arch/Default/Settings.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008-2010 Gael Guennebaud 5 | // Copyright (C) 2006-2008 Benoit Jacob 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | 12 | /* All the parameters defined in this file can be specialized in the 13 | * architecture specific files, and/or by the user. 14 | * More to come... */ 15 | 16 | #ifndef EIGEN_DEFAULT_SETTINGS_H 17 | #define EIGEN_DEFAULT_SETTINGS_H 18 | 19 | /** Defines the maximal loop size to enable meta unrolling of loops. 20 | * Note that the value here is expressed in Eigen's own notion of "number of FLOPS", 21 | * it does not correspond to the number of iterations or the number of instructions 22 | */ 23 | #ifndef EIGEN_UNROLLING_LIMIT 24 | #define EIGEN_UNROLLING_LIMIT 100 25 | #endif 26 | 27 | /** Defines the threshold between a "small" and a "large" matrix. 28 | * This threshold is mainly used to select the proper product implementation. 29 | */ 30 | #ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 31 | #define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8 32 | #endif 33 | 34 | /** Defines the maximal width of the blocks used in the triangular product and solver 35 | * for vectors (level 2 blas xTRMV and xTRSV). The default is 8. 36 | */ 37 | #ifndef EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH 38 | #define EIGEN_TUNE_TRIANGULAR_PANEL_WIDTH 8 39 | #endif 40 | 41 | 42 | /** Defines the default number of registers available for that architecture. 43 | * Currently it must be 8 or 16. Other values will fail. 44 | */ 45 | #ifndef EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 46 | #define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS 8 47 | #endif 48 | 49 | #endif // EIGEN_DEFAULT_SETTINGS_H 50 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/arch/NEON/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_arch_NEON_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_arch_NEON_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/NEON COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/arch/SSE/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_arch_SSE_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_arch_SSE_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/arch/SSE COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/products/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_Product_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_Product_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/products COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/products/GeneralMatrixMatrix_MKL.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2011, Intel Corporation. All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without modification, 5 | are permitted provided that the following conditions are met: 6 | 7 | * Redistributions of source code must retain the above copyright notice, this 8 | list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above copyright notice, 10 | this list of conditions and the following disclaimer in the documentation 11 | and/or other materials provided with the distribution. 12 | * Neither the name of Intel Corporation nor the names of its contributors may 13 | be used to endorse or promote products derived from this software without 14 | specific prior written permission. 15 | 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 20 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 23 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 | 27 | ******************************************************************************** 28 | * Content : Eigen bindings to Intel(R) MKL 29 | * General matrix-matrix product functionality based on ?GEMM. 30 | ******************************************************************************** 31 | */ 32 | 33 | #ifndef EIGEN_GENERAL_MATRIX_MATRIX_MKL_H 34 | #define EIGEN_GENERAL_MATRIX_MATRIX_MKL_H 35 | 36 | namespace Eigen { 37 | 38 | namespace internal { 39 | 40 | /********************************************************************** 41 | * This file implements general matrix-matrix multiplication using BLAS 42 | * gemm function via partial specialization of 43 | * general_matrix_matrix_product::run(..) method for float, double, 44 | * std::complex and std::complex types 45 | **********************************************************************/ 46 | 47 | // gemm specialization 48 | 49 | #define GEMM_SPECIALIZATION(EIGTYPE, EIGPREFIX, MKLTYPE, MKLPREFIX) \ 50 | template< \ 51 | typename Index, \ 52 | int LhsStorageOrder, bool ConjugateLhs, \ 53 | int RhsStorageOrder, bool ConjugateRhs> \ 54 | struct general_matrix_matrix_product \ 55 | { \ 56 | static void run(Index rows, Index cols, Index depth, \ 57 | const EIGTYPE* _lhs, Index lhsStride, \ 58 | const EIGTYPE* _rhs, Index rhsStride, \ 59 | EIGTYPE* res, Index resStride, \ 60 | EIGTYPE alpha, \ 61 | level3_blocking& /*blocking*/, \ 62 | GemmParallelInfo* /*info = 0*/) \ 63 | { \ 64 | using std::conj; \ 65 | \ 66 | char transa, transb; \ 67 | MKL_INT m, n, k, lda, ldb, ldc; \ 68 | const EIGTYPE *a, *b; \ 69 | MKLTYPE alpha_, beta_; \ 70 | MatrixX##EIGPREFIX a_tmp, b_tmp; \ 71 | EIGTYPE myone(1);\ 72 | \ 73 | /* Set transpose options */ \ 74 | transa = (LhsStorageOrder==RowMajor) ? ((ConjugateLhs) ? 'C' : 'T') : 'N'; \ 75 | transb = (RhsStorageOrder==RowMajor) ? ((ConjugateRhs) ? 'C' : 'T') : 'N'; \ 76 | \ 77 | /* Set m, n, k */ \ 78 | m = (MKL_INT)rows; \ 79 | n = (MKL_INT)cols; \ 80 | k = (MKL_INT)depth; \ 81 | \ 82 | /* Set alpha_ & beta_ */ \ 83 | assign_scalar_eig2mkl(alpha_, alpha); \ 84 | assign_scalar_eig2mkl(beta_, myone); \ 85 | \ 86 | /* Set lda, ldb, ldc */ \ 87 | lda = (MKL_INT)lhsStride; \ 88 | ldb = (MKL_INT)rhsStride; \ 89 | ldc = (MKL_INT)resStride; \ 90 | \ 91 | /* Set a, b, c */ \ 92 | if ((LhsStorageOrder==ColMajor) && (ConjugateLhs)) { \ 93 | Map > lhs(_lhs,m,k,OuterStride<>(lhsStride)); \ 94 | a_tmp = lhs.conjugate(); \ 95 | a = a_tmp.data(); \ 96 | lda = a_tmp.outerStride(); \ 97 | } else a = _lhs; \ 98 | \ 99 | if ((RhsStorageOrder==ColMajor) && (ConjugateRhs)) { \ 100 | Map > rhs(_rhs,k,n,OuterStride<>(rhsStride)); \ 101 | b_tmp = rhs.conjugate(); \ 102 | b = b_tmp.data(); \ 103 | ldb = b_tmp.outerStride(); \ 104 | } else b = _rhs; \ 105 | \ 106 | MKLPREFIX##gemm(&transa, &transb, &m, &n, &k, &alpha_, (const MKLTYPE*)a, &lda, (const MKLTYPE*)b, &ldb, &beta_, (MKLTYPE*)res, &ldc); \ 107 | }}; 108 | 109 | GEMM_SPECIALIZATION(double, d, double, d) 110 | GEMM_SPECIALIZATION(float, f, float, s) 111 | GEMM_SPECIALIZATION(dcomplex, cd, MKL_Complex16, z) 112 | GEMM_SPECIALIZATION(scomplex, cf, MKL_Complex8, c) 113 | 114 | } // end namespase internal 115 | 116 | } // end namespace Eigen 117 | 118 | #endif // EIGEN_GENERAL_MATRIX_MATRIX_MKL_H 119 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/products/Parallelizer.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2010 Gael Guennebaud 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_PARALLELIZER_H 11 | #define EIGEN_PARALLELIZER_H 12 | 13 | namespace Eigen { 14 | 15 | namespace internal { 16 | 17 | /** \internal */ 18 | inline void manage_multi_threading(Action action, int* v) 19 | { 20 | static EIGEN_UNUSED int m_maxThreads = -1; 21 | 22 | if(action==SetAction) 23 | { 24 | eigen_internal_assert(v!=0); 25 | m_maxThreads = *v; 26 | } 27 | else if(action==GetAction) 28 | { 29 | eigen_internal_assert(v!=0); 30 | #ifdef EIGEN_HAS_OPENMP 31 | if(m_maxThreads>0) 32 | *v = m_maxThreads; 33 | else 34 | *v = omp_get_max_threads(); 35 | #else 36 | *v = 1; 37 | #endif 38 | } 39 | else 40 | { 41 | eigen_internal_assert(false); 42 | } 43 | } 44 | 45 | } 46 | 47 | /** Must be call first when calling Eigen from multiple threads */ 48 | inline void initParallel() 49 | { 50 | int nbt; 51 | internal::manage_multi_threading(GetAction, &nbt); 52 | std::ptrdiff_t l1, l2; 53 | internal::manage_caching_sizes(GetAction, &l1, &l2); 54 | } 55 | 56 | /** \returns the max number of threads reserved for Eigen 57 | * \sa setNbThreads */ 58 | inline int nbThreads() 59 | { 60 | int ret; 61 | internal::manage_multi_threading(GetAction, &ret); 62 | return ret; 63 | } 64 | 65 | /** Sets the max number of threads reserved for Eigen 66 | * \sa nbThreads */ 67 | inline void setNbThreads(int v) 68 | { 69 | internal::manage_multi_threading(SetAction, &v); 70 | } 71 | 72 | namespace internal { 73 | 74 | template struct GemmParallelInfo 75 | { 76 | GemmParallelInfo() : sync(-1), users(0), rhs_start(0), rhs_length(0) {} 77 | 78 | int volatile sync; 79 | int volatile users; 80 | 81 | Index rhs_start; 82 | Index rhs_length; 83 | }; 84 | 85 | template 86 | void parallelize_gemm(const Functor& func, Index rows, Index cols, bool transpose) 87 | { 88 | // TODO when EIGEN_USE_BLAS is defined, 89 | // we should still enable OMP for other scalar types 90 | #if !(defined (EIGEN_HAS_OPENMP)) || defined (EIGEN_USE_BLAS) 91 | // FIXME the transpose variable is only needed to properly split 92 | // the matrix product when multithreading is enabled. This is a temporary 93 | // fix to support row-major destination matrices. This whole 94 | // parallelizer mechanism has to be redisigned anyway. 95 | EIGEN_UNUSED_VARIABLE(transpose); 96 | func(0,rows, 0,cols); 97 | #else 98 | 99 | // Dynamically check whether we should enable or disable OpenMP. 100 | // The conditions are: 101 | // - the max number of threads we can create is greater than 1 102 | // - we are not already in a parallel code 103 | // - the sizes are large enough 104 | 105 | // 1- are we already in a parallel session? 106 | // FIXME omp_get_num_threads()>1 only works for openmp, what if the user does not use openmp? 107 | if((!Condition) || (omp_get_num_threads()>1)) 108 | return func(0,rows, 0,cols); 109 | 110 | Index size = transpose ? cols : rows; 111 | 112 | // 2- compute the maximal number of threads from the size of the product: 113 | // FIXME this has to be fine tuned 114 | Index max_threads = std::max(1,size / 32); 115 | 116 | // 3 - compute the number of threads we are going to use 117 | Index threads = std::min(nbThreads(), max_threads); 118 | 119 | if(threads==1) 120 | return func(0,rows, 0,cols); 121 | 122 | Eigen::initParallel(); 123 | func.initParallelSession(); 124 | 125 | if(transpose) 126 | std::swap(rows,cols); 127 | 128 | Index blockCols = (cols / threads) & ~Index(0x3); 129 | Index blockRows = (rows / threads) & ~Index(0x7); 130 | 131 | GemmParallelInfo* info = new GemmParallelInfo[threads]; 132 | 133 | #pragma omp parallel for schedule(static,1) num_threads(threads) 134 | for(Index i=0; i 47 | struct selfadjoint_matrix_vector_product_symv : 48 | selfadjoint_matrix_vector_product {}; 49 | 50 | #define EIGEN_MKL_SYMV_SPECIALIZE(Scalar) \ 51 | template \ 52 | struct selfadjoint_matrix_vector_product { \ 53 | static EIGEN_DONT_INLINE void run( \ 54 | Index size, const Scalar* lhs, Index lhsStride, \ 55 | const Scalar* _rhs, Index rhsIncr, Scalar* res, Scalar alpha) { \ 56 | enum {\ 57 | IsColMajor = StorageOrder==ColMajor \ 58 | }; \ 59 | if (IsColMajor == ConjugateLhs) {\ 60 | selfadjoint_matrix_vector_product::run( \ 61 | size, lhs, lhsStride, _rhs, rhsIncr, res, alpha); \ 62 | } else {\ 63 | selfadjoint_matrix_vector_product_symv::run( \ 64 | size, lhs, lhsStride, _rhs, rhsIncr, res, alpha); \ 65 | }\ 66 | } \ 67 | }; \ 68 | 69 | EIGEN_MKL_SYMV_SPECIALIZE(double) 70 | EIGEN_MKL_SYMV_SPECIALIZE(float) 71 | EIGEN_MKL_SYMV_SPECIALIZE(dcomplex) 72 | EIGEN_MKL_SYMV_SPECIALIZE(scomplex) 73 | 74 | #define EIGEN_MKL_SYMV_SPECIALIZATION(EIGTYPE,MKLTYPE,MKLFUNC) \ 75 | template \ 76 | struct selfadjoint_matrix_vector_product_symv \ 77 | { \ 78 | typedef Matrix SYMVVector;\ 79 | \ 80 | static EIGEN_DONT_INLINE void run( \ 81 | Index size, const EIGTYPE* lhs, Index lhsStride, \ 82 | const EIGTYPE* _rhs, Index rhsIncr, EIGTYPE* res, EIGTYPE alpha) \ 83 | { \ 84 | enum {\ 85 | IsRowMajor = StorageOrder==RowMajor ? 1 : 0, \ 86 | IsLower = UpLo == Lower ? 1 : 0 \ 87 | }; \ 88 | MKL_INT n=size, lda=lhsStride, incx=rhsIncr, incy=1; \ 89 | MKLTYPE alpha_, beta_; \ 90 | const EIGTYPE *x_ptr, myone(1); \ 91 | char uplo=(IsRowMajor) ? (IsLower ? 'U' : 'L') : (IsLower ? 'L' : 'U'); \ 92 | assign_scalar_eig2mkl(alpha_, alpha); \ 93 | assign_scalar_eig2mkl(beta_, myone); \ 94 | SYMVVector x_tmp; \ 95 | if (ConjugateRhs) { \ 96 | Map > map_x(_rhs,size,1,InnerStride<>(incx)); \ 97 | x_tmp=map_x.conjugate(); \ 98 | x_ptr=x_tmp.data(); \ 99 | incx=1; \ 100 | } else x_ptr=_rhs; \ 101 | MKLFUNC(&uplo, &n, &alpha_, (const MKLTYPE*)lhs, &lda, (const MKLTYPE*)x_ptr, &incx, &beta_, (MKLTYPE*)res, &incy); \ 102 | }\ 103 | }; 104 | 105 | EIGEN_MKL_SYMV_SPECIALIZATION(double, double, dsymv) 106 | EIGEN_MKL_SYMV_SPECIALIZATION(float, float, ssymv) 107 | EIGEN_MKL_SYMV_SPECIALIZATION(dcomplex, MKL_Complex16, zhemv) 108 | EIGEN_MKL_SYMV_SPECIALIZATION(scomplex, MKL_Complex8, chemv) 109 | 110 | } // end namespace internal 111 | 112 | } // end namespace Eigen 113 | 114 | #endif // EIGEN_SELFADJOINT_MATRIX_VECTOR_MKL_H 115 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/products/SelfadjointRank2Update.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009 Gael Guennebaud 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_SELFADJOINTRANK2UPTADE_H 11 | #define EIGEN_SELFADJOINTRANK2UPTADE_H 12 | 13 | namespace Eigen { 14 | 15 | namespace internal { 16 | 17 | /* Optimized selfadjoint matrix += alpha * uv' + conj(alpha)*vu' 18 | * It corresponds to the Level2 syr2 BLAS routine 19 | */ 20 | 21 | template 22 | struct selfadjoint_rank2_update_selector; 23 | 24 | template 25 | struct selfadjoint_rank2_update_selector 26 | { 27 | static void run(Scalar* mat, Index stride, const UType& u, const VType& v, Scalar alpha) 28 | { 29 | const Index size = u.size(); 30 | for (Index i=0; i >(mat+stride*i+i, size-i) += 33 | (conj(alpha) * conj(u.coeff(i))) * v.tail(size-i) 34 | + (alpha * conj(v.coeff(i))) * u.tail(size-i); 35 | } 36 | } 37 | }; 38 | 39 | template 40 | struct selfadjoint_rank2_update_selector 41 | { 42 | static void run(Scalar* mat, Index stride, const UType& u, const VType& v, Scalar alpha) 43 | { 44 | const Index size = u.size(); 45 | for (Index i=0; i >(mat+stride*i, i+1) += 47 | (conj(alpha) * conj(u.coeff(i))) * v.head(i+1) 48 | + (alpha * conj(v.coeff(i))) * u.head(i+1); 49 | } 50 | }; 51 | 52 | template struct conj_expr_if 53 | : conditional::Scalar>,T> > {}; 55 | 56 | } // end namespace internal 57 | 58 | template 59 | template 60 | SelfAdjointView& SelfAdjointView 61 | ::rankUpdate(const MatrixBase& u, const MatrixBase& v, Scalar alpha) 62 | { 63 | typedef internal::blas_traits UBlasTraits; 64 | typedef typename UBlasTraits::DirectLinearAccessType ActualUType; 65 | typedef typename internal::remove_all::type _ActualUType; 66 | typename internal::add_const_on_value_type::type actualU = UBlasTraits::extract(u.derived()); 67 | 68 | typedef internal::blas_traits VBlasTraits; 69 | typedef typename VBlasTraits::DirectLinearAccessType ActualVType; 70 | typedef typename internal::remove_all::type _ActualVType; 71 | typename internal::add_const_on_value_type::type actualV = VBlasTraits::extract(v.derived()); 72 | 73 | // If MatrixType is row major, then we use the routine for lower triangular in the upper triangular case and 74 | // vice versa, and take the complex conjugate of all coefficients and vector entries. 75 | 76 | enum { IsRowMajor = (internal::traits::Flags&RowMajorBit) ? 1 : 0 }; 77 | Scalar actualAlpha = alpha * UBlasTraits::extractScalarFactor(u.derived()) 78 | * internal::conj(VBlasTraits::extractScalarFactor(v.derived())); 79 | if (IsRowMajor) 80 | actualAlpha = internal::conj(actualAlpha); 81 | 82 | internal::selfadjoint_rank2_update_selector::type>::type, 84 | typename internal::remove_all::type>::type, 85 | (IsRowMajor ? int(UpLo==Upper ? Lower : Upper) : UpLo)> 86 | ::run(_expression().const_cast_derived().data(),_expression().outerStride(),actualU,actualV,actualAlpha); 87 | 88 | return *this; 89 | } 90 | 91 | } // end namespace Eigen 92 | 93 | #endif // EIGEN_SELFADJOINTRANK2UPTADE_H 94 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/util/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Core_util_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Core_util_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/util COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/util/DisableStupidWarnings.h: -------------------------------------------------------------------------------- 1 | #ifndef EIGEN_WARNINGS_DISABLED 2 | #define EIGEN_WARNINGS_DISABLED 3 | 4 | #ifdef _MSC_VER 5 | // 4100 - unreferenced formal parameter (occurred e.g. in aligned_allocator::destroy(pointer p)) 6 | // 4101 - unreferenced local variable 7 | // 4127 - conditional expression is constant 8 | // 4181 - qualifier applied to reference type ignored 9 | // 4211 - nonstandard extension used : redefined extern to static 10 | // 4244 - 'argument' : conversion from 'type1' to 'type2', possible loss of data 11 | // 4273 - QtAlignedMalloc, inconsistent DLL linkage 12 | // 4324 - structure was padded due to declspec(align()) 13 | // 4512 - assignment operator could not be generated 14 | // 4522 - 'class' : multiple assignment operators specified 15 | // 4700 - uninitialized local variable 'xyz' used 16 | // 4717 - 'function' : recursive on all control paths, function will cause runtime stack overflow 17 | #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS 18 | #pragma warning( push ) 19 | #endif 20 | #pragma warning( disable : 4100 4101 4127 4181 4211 4244 4273 4324 4512 4522 4700 4717 ) 21 | #elif defined __INTEL_COMPILER 22 | // 2196 - routine is both "inline" and "noinline" ("noinline" assumed) 23 | // ICC 12 generates this warning even without any inline keyword, when defining class methods 'inline' i.e. inside of class body 24 | // typedef that may be a reference type. 25 | // 279 - controlling expression is constant 26 | // ICC 12 generates this warning on assert(constant_expression_depending_on_template_params) and frankly this is a legitimate use case. 27 | #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS 28 | #pragma warning push 29 | #endif 30 | #pragma warning disable 2196 279 31 | #elif defined __clang__ 32 | // -Wconstant-logical-operand - warning: use of logical && with constant operand; switch to bitwise & or remove constant 33 | // this is really a stupid warning as it warns on compile-time expressions involving enums 34 | #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS 35 | #pragma clang diagnostic push 36 | #endif 37 | #pragma clang diagnostic ignored "-Wconstant-logical-operand" 38 | #endif 39 | 40 | #endif // not EIGEN_WARNINGS_DISABLED 41 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/util/MKL_support.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2011, Intel Corporation. All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without modification, 5 | are permitted provided that the following conditions are met: 6 | 7 | * Redistributions of source code must retain the above copyright notice, this 8 | list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above copyright notice, 10 | this list of conditions and the following disclaimer in the documentation 11 | and/or other materials provided with the distribution. 12 | * Neither the name of Intel Corporation nor the names of its contributors may 13 | be used to endorse or promote products derived from this software without 14 | specific prior written permission. 15 | 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 20 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 23 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 | 27 | ******************************************************************************** 28 | * Content : Eigen bindings to Intel(R) MKL 29 | * Include file with common MKL declarations 30 | ******************************************************************************** 31 | */ 32 | 33 | #ifndef EIGEN_MKL_SUPPORT_H 34 | #define EIGEN_MKL_SUPPORT_H 35 | 36 | #ifdef EIGEN_USE_MKL_ALL 37 | #ifndef EIGEN_USE_BLAS 38 | #define EIGEN_USE_BLAS 39 | #endif 40 | #ifndef EIGEN_USE_LAPACKE 41 | #define EIGEN_USE_LAPACKE 42 | #endif 43 | #ifndef EIGEN_USE_MKL_VML 44 | #define EIGEN_USE_MKL_VML 45 | #endif 46 | #endif 47 | 48 | #ifdef EIGEN_USE_LAPACKE_STRICT 49 | #define EIGEN_USE_LAPACKE 50 | #endif 51 | 52 | #if defined(EIGEN_USE_BLAS) || defined(EIGEN_USE_LAPACKE) || defined(EIGEN_USE_MKL_VML) 53 | #define EIGEN_USE_MKL 54 | #endif 55 | 56 | #if defined EIGEN_USE_MKL 57 | 58 | #include 59 | #include 60 | #define EIGEN_MKL_VML_THRESHOLD 128 61 | 62 | namespace Eigen { 63 | 64 | typedef std::complex dcomplex; 65 | typedef std::complex scomplex; 66 | 67 | namespace internal { 68 | 69 | template 70 | static inline void assign_scalar_eig2mkl(MKLType& mklScalar, const EigenType& eigenScalar) { 71 | mklScalar=eigenScalar; 72 | } 73 | 74 | template 75 | static inline void assign_conj_scalar_eig2mkl(MKLType& mklScalar, const EigenType& eigenScalar) { 76 | mklScalar=eigenScalar; 77 | } 78 | 79 | template <> 80 | inline void assign_scalar_eig2mkl(MKL_Complex16& mklScalar, const dcomplex& eigenScalar) { 81 | mklScalar.real=eigenScalar.real(); 82 | mklScalar.imag=eigenScalar.imag(); 83 | } 84 | 85 | template <> 86 | inline void assign_scalar_eig2mkl(MKL_Complex8& mklScalar, const scomplex& eigenScalar) { 87 | mklScalar.real=eigenScalar.real(); 88 | mklScalar.imag=eigenScalar.imag(); 89 | } 90 | 91 | template <> 92 | inline void assign_conj_scalar_eig2mkl(MKL_Complex16& mklScalar, const dcomplex& eigenScalar) { 93 | mklScalar.real=eigenScalar.real(); 94 | mklScalar.imag=-eigenScalar.imag(); 95 | } 96 | 97 | template <> 98 | inline void assign_conj_scalar_eig2mkl(MKL_Complex8& mklScalar, const scomplex& eigenScalar) { 99 | mklScalar.real=eigenScalar.real(); 100 | mklScalar.imag=-eigenScalar.imag(); 101 | } 102 | 103 | } // end namespace internal 104 | 105 | } // end namespace Eigen 106 | 107 | #endif 108 | 109 | #endif // EIGEN_MKL_SUPPORT_H 110 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/util/NonMPL2.h: -------------------------------------------------------------------------------- 1 | #ifdef EIGEN_MPL2_ONLY 2 | #error Including non-MPL2 code in EIGEN_MPL2_ONLY mode 3 | #endif 4 | -------------------------------------------------------------------------------- /jni/Eigen/src/Core/util/ReenableStupidWarnings.h: -------------------------------------------------------------------------------- 1 | #ifdef EIGEN_WARNINGS_DISABLED 2 | #undef EIGEN_WARNINGS_DISABLED 3 | 4 | #ifndef EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS 5 | #ifdef _MSC_VER 6 | #pragma warning( pop ) 7 | #elif defined __INTEL_COMPILER 8 | #pragma warning pop 9 | #elif defined __clang__ 10 | #pragma clang diagnostic pop 11 | #endif 12 | #endif 13 | 14 | #endif // EIGEN_WARNINGS_DISABLED 15 | -------------------------------------------------------------------------------- /jni/Eigen/src/Eigenvalues/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_EIGENVALUES_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_EIGENVALUES_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Eigenvalues COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /jni/Eigen/src/Eigenvalues/ComplexSchur_MKL.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2011, Intel Corporation. All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without modification, 5 | are permitted provided that the following conditions are met: 6 | 7 | * Redistributions of source code must retain the above copyright notice, this 8 | list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above copyright notice, 10 | this list of conditions and the following disclaimer in the documentation 11 | and/or other materials provided with the distribution. 12 | * Neither the name of Intel Corporation nor the names of its contributors may 13 | be used to endorse or promote products derived from this software without 14 | specific prior written permission. 15 | 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 20 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 23 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 | 27 | ******************************************************************************** 28 | * Content : Eigen bindings to Intel(R) MKL 29 | * Complex Schur needed to complex unsymmetrical eigenvalues/eigenvectors. 30 | ******************************************************************************** 31 | */ 32 | 33 | #ifndef EIGEN_COMPLEX_SCHUR_MKL_H 34 | #define EIGEN_COMPLEX_SCHUR_MKL_H 35 | 36 | #include "Eigen/src/Core/util/MKL_support.h" 37 | 38 | namespace Eigen { 39 | 40 | /** \internal Specialization for the data types supported by MKL */ 41 | 42 | #define EIGEN_MKL_SCHUR_COMPLEX(EIGTYPE, MKLTYPE, MKLPREFIX, MKLPREFIX_U, EIGCOLROW, MKLCOLROW) \ 43 | template<> inline \ 44 | ComplexSchur >& \ 45 | ComplexSchur >::compute(const Matrix& matrix, bool computeU) \ 46 | { \ 47 | typedef Matrix MatrixType; \ 48 | typedef MatrixType::Scalar Scalar; \ 49 | typedef MatrixType::RealScalar RealScalar; \ 50 | typedef std::complex ComplexScalar; \ 51 | \ 52 | assert(matrix.cols() == matrix.rows()); \ 53 | \ 54 | m_matUisUptodate = false; \ 55 | if(matrix.cols() == 1) \ 56 | { \ 57 | m_matT = matrix.cast(); \ 58 | if(computeU) m_matU = ComplexMatrixType::Identity(1,1); \ 59 | m_info = Success; \ 60 | m_isInitialized = true; \ 61 | m_matUisUptodate = computeU; \ 62 | return *this; \ 63 | } \ 64 | lapack_int n = matrix.cols(), sdim, info; \ 65 | lapack_int lda = matrix.outerStride(); \ 66 | lapack_int matrix_order = MKLCOLROW; \ 67 | char jobvs, sort='N'; \ 68 | LAPACK_##MKLPREFIX_U##_SELECT1 select = 0; \ 69 | jobvs = (computeU) ? 'V' : 'N'; \ 70 | m_matU.resize(n, n); \ 71 | lapack_int ldvs = m_matU.outerStride(); \ 72 | m_matT = matrix; \ 73 | Matrix w; \ 74 | w.resize(n, 1);\ 75 | info = LAPACKE_##MKLPREFIX##gees( matrix_order, jobvs, sort, select, n, (MKLTYPE*)m_matT.data(), lda, &sdim, (MKLTYPE*)w.data(), (MKLTYPE*)m_matU.data(), ldvs ); \ 76 | if(info == 0) \ 77 | m_info = Success; \ 78 | else \ 79 | m_info = NoConvergence; \ 80 | \ 81 | m_isInitialized = true; \ 82 | m_matUisUptodate = computeU; \ 83 | return *this; \ 84 | \ 85 | } 86 | 87 | EIGEN_MKL_SCHUR_COMPLEX(dcomplex, MKL_Complex16, z, Z, ColMajor, LAPACK_COL_MAJOR) 88 | EIGEN_MKL_SCHUR_COMPLEX(scomplex, MKL_Complex8, c, C, ColMajor, LAPACK_COL_MAJOR) 89 | EIGEN_MKL_SCHUR_COMPLEX(dcomplex, MKL_Complex16, z, Z, RowMajor, LAPACK_ROW_MAJOR) 90 | EIGEN_MKL_SCHUR_COMPLEX(scomplex, MKL_Complex8, c, C, RowMajor, LAPACK_ROW_MAJOR) 91 | 92 | } // end namespace Eigen 93 | 94 | #endif // EIGEN_COMPLEX_SCHUR_MKL_H 95 | -------------------------------------------------------------------------------- /jni/Eigen/src/Eigenvalues/RealSchur_MKL.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2011, Intel Corporation. All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without modification, 5 | are permitted provided that the following conditions are met: 6 | 7 | * Redistributions of source code must retain the above copyright notice, this 8 | list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above copyright notice, 10 | this list of conditions and the following disclaimer in the documentation 11 | and/or other materials provided with the distribution. 12 | * Neither the name of Intel Corporation nor the names of its contributors may 13 | be used to endorse or promote products derived from this software without 14 | specific prior written permission. 15 | 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 20 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 23 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 | 27 | ******************************************************************************** 28 | * Content : Eigen bindings to Intel(R) MKL 29 | * Real Schur needed to real unsymmetrical eigenvalues/eigenvectors. 30 | ******************************************************************************** 31 | */ 32 | 33 | #ifndef EIGEN_REAL_SCHUR_MKL_H 34 | #define EIGEN_REAL_SCHUR_MKL_H 35 | 36 | #include "Eigen/src/Core/util/MKL_support.h" 37 | 38 | namespace Eigen { 39 | 40 | /** \internal Specialization for the data types supported by MKL */ 41 | 42 | #define EIGEN_MKL_SCHUR_REAL(EIGTYPE, MKLTYPE, MKLPREFIX, MKLPREFIX_U, EIGCOLROW, MKLCOLROW) \ 43 | template<> inline \ 44 | RealSchur >& \ 45 | RealSchur >::compute(const Matrix& matrix, bool computeU) \ 46 | { \ 47 | typedef Matrix MatrixType; \ 48 | typedef MatrixType::Scalar Scalar; \ 49 | typedef MatrixType::RealScalar RealScalar; \ 50 | \ 51 | assert(matrix.cols() == matrix.rows()); \ 52 | \ 53 | lapack_int n = matrix.cols(), sdim, info; \ 54 | lapack_int lda = matrix.outerStride(); \ 55 | lapack_int matrix_order = MKLCOLROW; \ 56 | char jobvs, sort='N'; \ 57 | LAPACK_##MKLPREFIX_U##_SELECT2 select = 0; \ 58 | jobvs = (computeU) ? 'V' : 'N'; \ 59 | m_matU.resize(n, n); \ 60 | lapack_int ldvs = m_matU.outerStride(); \ 61 | m_matT = matrix; \ 62 | Matrix wr, wi; \ 63 | wr.resize(n, 1); wi.resize(n, 1); \ 64 | info = LAPACKE_##MKLPREFIX##gees( matrix_order, jobvs, sort, select, n, (MKLTYPE*)m_matT.data(), lda, &sdim, (MKLTYPE*)wr.data(), (MKLTYPE*)wi.data(), (MKLTYPE*)m_matU.data(), ldvs ); \ 65 | if(info == 0) \ 66 | m_info = Success; \ 67 | else \ 68 | m_info = NoConvergence; \ 69 | \ 70 | m_isInitialized = true; \ 71 | m_matUisUptodate = computeU; \ 72 | return *this; \ 73 | \ 74 | } 75 | 76 | EIGEN_MKL_SCHUR_REAL(double, double, d, D, ColMajor, LAPACK_COL_MAJOR) 77 | EIGEN_MKL_SCHUR_REAL(float, float, s, S, ColMajor, LAPACK_COL_MAJOR) 78 | EIGEN_MKL_SCHUR_REAL(double, double, d, D, RowMajor, LAPACK_ROW_MAJOR) 79 | EIGEN_MKL_SCHUR_REAL(float, float, s, S, RowMajor, LAPACK_ROW_MAJOR) 80 | 81 | } // end namespace Eigen 82 | 83 | #endif // EIGEN_REAL_SCHUR_MKL_H 84 | -------------------------------------------------------------------------------- /jni/Eigen/src/Eigenvalues/SelfAdjointEigenSolver_MKL.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2011, Intel Corporation. All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without modification, 5 | are permitted provided that the following conditions are met: 6 | 7 | * Redistributions of source code must retain the above copyright notice, this 8 | list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above copyright notice, 10 | this list of conditions and the following disclaimer in the documentation 11 | and/or other materials provided with the distribution. 12 | * Neither the name of Intel Corporation nor the names of its contributors may 13 | be used to endorse or promote products derived from this software without 14 | specific prior written permission. 15 | 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 20 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 23 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 | 27 | ******************************************************************************** 28 | * Content : Eigen bindings to Intel(R) MKL 29 | * Self-adjoint eigenvalues/eigenvectors. 30 | ******************************************************************************** 31 | */ 32 | 33 | #ifndef EIGEN_SAEIGENSOLVER_MKL_H 34 | #define EIGEN_SAEIGENSOLVER_MKL_H 35 | 36 | #include "Eigen/src/Core/util/MKL_support.h" 37 | 38 | namespace Eigen { 39 | 40 | /** \internal Specialization for the data types supported by MKL */ 41 | 42 | #define EIGEN_MKL_EIG_SELFADJ(EIGTYPE, MKLTYPE, MKLRTYPE, MKLNAME, EIGCOLROW, MKLCOLROW ) \ 43 | template<> inline \ 44 | SelfAdjointEigenSolver >& \ 45 | SelfAdjointEigenSolver >::compute(const Matrix& matrix, int options) \ 46 | { \ 47 | eigen_assert(matrix.cols() == matrix.rows()); \ 48 | eigen_assert((options&~(EigVecMask|GenEigMask))==0 \ 49 | && (options&EigVecMask)!=EigVecMask \ 50 | && "invalid option parameter"); \ 51 | bool computeEigenvectors = (options&ComputeEigenvectors)==ComputeEigenvectors; \ 52 | lapack_int n = matrix.cols(), lda, matrix_order, info; \ 53 | m_eivalues.resize(n,1); \ 54 | m_subdiag.resize(n-1); \ 55 | m_eivec = matrix; \ 56 | \ 57 | if(n==1) \ 58 | { \ 59 | m_eivalues.coeffRef(0,0) = internal::real(matrix.coeff(0,0)); \ 60 | if(computeEigenvectors) m_eivec.setOnes(n,n); \ 61 | m_info = Success; \ 62 | m_isInitialized = true; \ 63 | m_eigenvectorsOk = computeEigenvectors; \ 64 | return *this; \ 65 | } \ 66 | \ 67 | lda = matrix.outerStride(); \ 68 | matrix_order=MKLCOLROW; \ 69 | char jobz, uplo='L'/*, range='A'*/; \ 70 | jobz = computeEigenvectors ? 'V' : 'N'; \ 71 | \ 72 | info = LAPACKE_##MKLNAME( matrix_order, jobz, uplo, n, (MKLTYPE*)m_eivec.data(), lda, (MKLRTYPE*)m_eivalues.data() ); \ 73 | m_info = (info==0) ? Success : NoConvergence; \ 74 | m_isInitialized = true; \ 75 | m_eigenvectorsOk = computeEigenvectors; \ 76 | return *this; \ 77 | } 78 | 79 | 80 | EIGEN_MKL_EIG_SELFADJ(double, double, double, dsyev, ColMajor, LAPACK_COL_MAJOR) 81 | EIGEN_MKL_EIG_SELFADJ(float, float, float, ssyev, ColMajor, LAPACK_COL_MAJOR) 82 | EIGEN_MKL_EIG_SELFADJ(dcomplex, MKL_Complex16, double, zheev, ColMajor, LAPACK_COL_MAJOR) 83 | EIGEN_MKL_EIG_SELFADJ(scomplex, MKL_Complex8, float, cheev, ColMajor, LAPACK_COL_MAJOR) 84 | 85 | EIGEN_MKL_EIG_SELFADJ(double, double, double, dsyev, RowMajor, LAPACK_ROW_MAJOR) 86 | EIGEN_MKL_EIG_SELFADJ(float, float, float, ssyev, RowMajor, LAPACK_ROW_MAJOR) 87 | EIGEN_MKL_EIG_SELFADJ(dcomplex, MKL_Complex16, double, zheev, RowMajor, LAPACK_ROW_MAJOR) 88 | EIGEN_MKL_EIG_SELFADJ(scomplex, MKL_Complex8, float, cheev, RowMajor, LAPACK_ROW_MAJOR) 89 | 90 | } // end namespace Eigen 91 | 92 | #endif // EIGEN_SAEIGENSOLVER_H 93 | -------------------------------------------------------------------------------- /jni/Eigen/src/Geometry/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Geometry_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Geometry_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Geometry COMPONENT Devel 6 | ) 7 | 8 | ADD_SUBDIRECTORY(arch) 9 | -------------------------------------------------------------------------------- /jni/Eigen/src/Geometry/EulerAngles.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008 Gael Guennebaud 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_EULERANGLES_H 11 | #define EIGEN_EULERANGLES_H 12 | 13 | namespace Eigen { 14 | 15 | /** \geometry_module \ingroup Geometry_Module 16 | * 17 | * 18 | * \returns the Euler-angles of the rotation matrix \c *this using the convention defined by the triplet (\a a0,\a a1,\a a2) 19 | * 20 | * Each of the three parameters \a a0,\a a1,\a a2 represents the respective rotation axis as an integer in {0,1,2}. 21 | * For instance, in: 22 | * \code Vector3f ea = mat.eulerAngles(2, 0, 2); \endcode 23 | * "2" represents the z axis and "0" the x axis, etc. The returned angles are such that 24 | * we have the following equality: 25 | * \code 26 | * mat == AngleAxisf(ea[0], Vector3f::UnitZ()) 27 | * * AngleAxisf(ea[1], Vector3f::UnitX()) 28 | * * AngleAxisf(ea[2], Vector3f::UnitZ()); \endcode 29 | * This corresponds to the right-multiply conventions (with right hand side frames). 30 | */ 31 | template 32 | inline Matrix::Scalar,3,1> 33 | MatrixBase::eulerAngles(Index a0, Index a1, Index a2) const 34 | { 35 | /* Implemented from Graphics Gems IV */ 36 | EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(Derived,3,3) 37 | 38 | Matrix res; 39 | typedef Matrix Vector2; 40 | const Scalar epsilon = NumTraits::dummy_precision(); 41 | 42 | const Index odd = ((a0+1)%3 == a1) ? 0 : 1; 43 | const Index i = a0; 44 | const Index j = (a0 + 1 + odd)%3; 45 | const Index k = (a0 + 2 - odd)%3; 46 | 47 | if (a0==a2) 48 | { 49 | Scalar s = Vector2(coeff(j,i) , coeff(k,i)).norm(); 50 | res[1] = internal::atan2(s, coeff(i,i)); 51 | if (s > epsilon) 52 | { 53 | res[0] = internal::atan2(coeff(j,i), coeff(k,i)); 54 | res[2] = internal::atan2(coeff(i,j),-coeff(i,k)); 55 | } 56 | else 57 | { 58 | res[0] = Scalar(0); 59 | res[2] = (coeff(i,i)>0?1:-1)*internal::atan2(-coeff(k,j), coeff(j,j)); 60 | } 61 | } 62 | else 63 | { 64 | Scalar c = Vector2(coeff(i,i) , coeff(i,j)).norm(); 65 | res[1] = internal::atan2(-coeff(i,k), c); 66 | if (c > epsilon) 67 | { 68 | res[0] = internal::atan2(coeff(j,k), coeff(k,k)); 69 | res[2] = internal::atan2(coeff(i,j), coeff(i,i)); 70 | } 71 | else 72 | { 73 | res[0] = Scalar(0); 74 | res[2] = (coeff(i,k)>0?1:-1)*internal::atan2(-coeff(k,j), coeff(j,j)); 75 | } 76 | } 77 | if (!odd) 78 | res = -res; 79 | return res; 80 | } 81 | 82 | } // end namespace Eigen 83 | 84 | #endif // EIGEN_EULERANGLES_H 85 | -------------------------------------------------------------------------------- /jni/Eigen/src/Geometry/arch/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Geometry_arch_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Geometry_arch_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Geometry/arch COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /jni/Eigen/src/Geometry/arch/Geometry_SSE.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009 Rohit Garg 5 | // Copyright (C) 2009-2010 Gael Guennebaud 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | #ifndef EIGEN_GEOMETRY_SSE_H 12 | #define EIGEN_GEOMETRY_SSE_H 13 | 14 | namespace Eigen { 15 | 16 | namespace internal { 17 | 18 | template 19 | struct quat_product 20 | { 21 | static inline Quaternion run(const QuaternionBase& _a, const QuaternionBase& _b) 22 | { 23 | const __m128 mask = _mm_castsi128_ps(_mm_setr_epi32(0,0,0,0x80000000)); 24 | Quaternion res; 25 | __m128 a = _a.coeffs().template packet(0); 26 | __m128 b = _b.coeffs().template packet(0); 27 | __m128 flip1 = _mm_xor_ps(_mm_mul_ps(vec4f_swizzle1(a,1,2,0,2), 28 | vec4f_swizzle1(b,2,0,1,2)),mask); 29 | __m128 flip2 = _mm_xor_ps(_mm_mul_ps(vec4f_swizzle1(a,3,3,3,1), 30 | vec4f_swizzle1(b,0,1,2,1)),mask); 31 | pstore(&res.x(), 32 | _mm_add_ps(_mm_sub_ps(_mm_mul_ps(a,vec4f_swizzle1(b,3,3,3,3)), 33 | _mm_mul_ps(vec4f_swizzle1(a,2,0,1,0), 34 | vec4f_swizzle1(b,1,2,0,0))), 35 | _mm_add_ps(flip1,flip2))); 36 | return res; 37 | } 38 | }; 39 | 40 | template 41 | struct cross3_impl 42 | { 43 | static inline typename plain_matrix_type::type 44 | run(const VectorLhs& lhs, const VectorRhs& rhs) 45 | { 46 | __m128 a = lhs.template packet(0); 47 | __m128 b = rhs.template packet(0); 48 | __m128 mul1=_mm_mul_ps(vec4f_swizzle1(a,1,2,0,3),vec4f_swizzle1(b,2,0,1,3)); 49 | __m128 mul2=_mm_mul_ps(vec4f_swizzle1(a,2,0,1,3),vec4f_swizzle1(b,1,2,0,3)); 50 | typename plain_matrix_type::type res; 51 | pstore(&res.x(),_mm_sub_ps(mul1,mul2)); 52 | return res; 53 | } 54 | }; 55 | 56 | 57 | 58 | 59 | template 60 | struct quat_product 61 | { 62 | static inline Quaternion run(const QuaternionBase& _a, const QuaternionBase& _b) 63 | { 64 | const Packet2d mask = _mm_castsi128_pd(_mm_set_epi32(0x0,0x0,0x80000000,0x0)); 65 | 66 | Quaternion res; 67 | 68 | const double* a = _a.coeffs().data(); 69 | Packet2d b_xy = _b.coeffs().template packet(0); 70 | Packet2d b_zw = _b.coeffs().template packet(2); 71 | Packet2d a_xx = pset1(a[0]); 72 | Packet2d a_yy = pset1(a[1]); 73 | Packet2d a_zz = pset1(a[2]); 74 | Packet2d a_ww = pset1(a[3]); 75 | 76 | // two temporaries: 77 | Packet2d t1, t2; 78 | 79 | /* 80 | * t1 = ww*xy + yy*zw 81 | * t2 = zz*xy - xx*zw 82 | * res.xy = t1 +/- swap(t2) 83 | */ 84 | t1 = padd(pmul(a_ww, b_xy), pmul(a_yy, b_zw)); 85 | t2 = psub(pmul(a_zz, b_xy), pmul(a_xx, b_zw)); 86 | #ifdef EIGEN_VECTORIZE_SSE3 87 | EIGEN_UNUSED_VARIABLE(mask) 88 | pstore(&res.x(), _mm_addsub_pd(t1, preverse(t2))); 89 | #else 90 | pstore(&res.x(), padd(t1, pxor(mask,preverse(t2)))); 91 | #endif 92 | 93 | /* 94 | * t1 = ww*zw - yy*xy 95 | * t2 = zz*zw + xx*xy 96 | * res.zw = t1 -/+ swap(t2) = swap( swap(t1) +/- t2) 97 | */ 98 | t1 = psub(pmul(a_ww, b_zw), pmul(a_yy, b_xy)); 99 | t2 = padd(pmul(a_zz, b_zw), pmul(a_xx, b_xy)); 100 | #ifdef EIGEN_VECTORIZE_SSE3 101 | EIGEN_UNUSED_VARIABLE(mask) 102 | pstore(&res.z(), preverse(_mm_addsub_pd(preverse(t1), t2))); 103 | #else 104 | pstore(&res.z(), psub(t1, pxor(mask,preverse(t2)))); 105 | #endif 106 | 107 | return res; 108 | } 109 | }; 110 | 111 | } // end namespace internal 112 | 113 | } // end namespace Eigen 114 | 115 | #endif // EIGEN_GEOMETRY_SSE_H 116 | -------------------------------------------------------------------------------- /jni/Eigen/src/Householder/BlockHouseholder.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2010 Vincent Lejeune 5 | // Copyright (C) 2010 Gael Guennebaud 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | #ifndef EIGEN_BLOCK_HOUSEHOLDER_H 12 | #define EIGEN_BLOCK_HOUSEHOLDER_H 13 | 14 | // This file contains some helper function to deal with block householder reflectors 15 | 16 | namespace Eigen { 17 | 18 | namespace internal { 19 | 20 | /** \internal */ 21 | template 22 | void make_block_householder_triangular_factor(TriangularFactorType& triFactor, const VectorsType& vectors, const CoeffsType& hCoeffs) 23 | { 24 | typedef typename TriangularFactorType::Index Index; 25 | typedef typename VectorsType::Scalar Scalar; 26 | const Index nbVecs = vectors.cols(); 27 | eigen_assert(triFactor.rows() == nbVecs && triFactor.cols() == nbVecs && vectors.rows()>=nbVecs); 28 | 29 | for(Index i = 0; i < nbVecs; i++) 30 | { 31 | Index rs = vectors.rows() - i; 32 | Scalar Vii = vectors(i,i); 33 | vectors.const_cast_derived().coeffRef(i,i) = Scalar(1); 34 | triFactor.col(i).head(i).noalias() = -hCoeffs(i) * vectors.block(i, 0, rs, i).adjoint() 35 | * vectors.col(i).tail(rs); 36 | vectors.const_cast_derived().coeffRef(i, i) = Vii; 37 | // FIXME add .noalias() once the triangular product can work inplace 38 | triFactor.col(i).head(i) = triFactor.block(0,0,i,i).template triangularView() 39 | * triFactor.col(i).head(i); 40 | triFactor(i,i) = hCoeffs(i); 41 | } 42 | } 43 | 44 | /** \internal */ 45 | template 46 | void apply_block_householder_on_the_left(MatrixType& mat, const VectorsType& vectors, const CoeffsType& hCoeffs) 47 | { 48 | typedef typename MatrixType::Index Index; 49 | enum { TFactorSize = MatrixType::ColsAtCompileTime }; 50 | Index nbVecs = vectors.cols(); 51 | Matrix T(nbVecs,nbVecs); 52 | make_block_householder_triangular_factor(T, vectors, hCoeffs); 53 | 54 | const TriangularView& V(vectors); 55 | 56 | // A -= V T V^* A 57 | Matrix tmp = V.adjoint() * mat; 59 | // FIXME add .noalias() once the triangular product can work inplace 60 | tmp = T.template triangularView().adjoint() * tmp; 61 | mat.noalias() -= V * tmp; 62 | } 63 | 64 | } // end namespace internal 65 | 66 | } // end namespace Eigen 67 | 68 | #endif // EIGEN_BLOCK_HOUSEHOLDER_H 69 | -------------------------------------------------------------------------------- /jni/Eigen/src/Householder/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Householder_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Householder_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Householder COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /jni/Eigen/src/Jacobi/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_Jacobi_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_Jacobi_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Jacobi COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /jni/Eigen/src/LU/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_LU_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_LU_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/LU COMPONENT Devel 6 | ) 7 | 8 | ADD_SUBDIRECTORY(arch) 9 | -------------------------------------------------------------------------------- /jni/Eigen/src/LU/Determinant.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008 Benoit Jacob 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_DETERMINANT_H 11 | #define EIGEN_DETERMINANT_H 12 | 13 | namespace Eigen { 14 | 15 | namespace internal { 16 | 17 | template 18 | inline const typename Derived::Scalar bruteforce_det3_helper 19 | (const MatrixBase& matrix, int a, int b, int c) 20 | { 21 | return matrix.coeff(0,a) 22 | * (matrix.coeff(1,b) * matrix.coeff(2,c) - matrix.coeff(1,c) * matrix.coeff(2,b)); 23 | } 24 | 25 | template 26 | const typename Derived::Scalar bruteforce_det4_helper 27 | (const MatrixBase& matrix, int j, int k, int m, int n) 28 | { 29 | return (matrix.coeff(j,0) * matrix.coeff(k,1) - matrix.coeff(k,0) * matrix.coeff(j,1)) 30 | * (matrix.coeff(m,2) * matrix.coeff(n,3) - matrix.coeff(n,2) * matrix.coeff(m,3)); 31 | } 32 | 33 | template struct determinant_impl 36 | { 37 | static inline typename traits::Scalar run(const Derived& m) 38 | { 39 | if(Derived::ColsAtCompileTime==Dynamic && m.rows()==0) 40 | return typename traits::Scalar(1); 41 | return m.partialPivLu().determinant(); 42 | } 43 | }; 44 | 45 | template struct determinant_impl 46 | { 47 | static inline typename traits::Scalar run(const Derived& m) 48 | { 49 | return m.coeff(0,0); 50 | } 51 | }; 52 | 53 | template struct determinant_impl 54 | { 55 | static inline typename traits::Scalar run(const Derived& m) 56 | { 57 | return m.coeff(0,0) * m.coeff(1,1) - m.coeff(1,0) * m.coeff(0,1); 58 | } 59 | }; 60 | 61 | template struct determinant_impl 62 | { 63 | static inline typename traits::Scalar run(const Derived& m) 64 | { 65 | return bruteforce_det3_helper(m,0,1,2) 66 | - bruteforce_det3_helper(m,1,0,2) 67 | + bruteforce_det3_helper(m,2,0,1); 68 | } 69 | }; 70 | 71 | template struct determinant_impl 72 | { 73 | static typename traits::Scalar run(const Derived& m) 74 | { 75 | // trick by Martin Costabel to compute 4x4 det with only 30 muls 76 | return bruteforce_det4_helper(m,0,1,2,3) 77 | - bruteforce_det4_helper(m,0,2,1,3) 78 | + bruteforce_det4_helper(m,0,3,1,2) 79 | + bruteforce_det4_helper(m,1,2,0,3) 80 | - bruteforce_det4_helper(m,1,3,0,2) 81 | + bruteforce_det4_helper(m,2,3,0,1); 82 | } 83 | }; 84 | 85 | } // end namespace internal 86 | 87 | /** \lu_module 88 | * 89 | * \returns the determinant of this matrix 90 | */ 91 | template 92 | inline typename internal::traits::Scalar MatrixBase::determinant() const 93 | { 94 | assert(rows() == cols()); 95 | typedef typename internal::nested::type Nested; 96 | return internal::determinant_impl::type>::run(derived()); 97 | } 98 | 99 | } // end namespace Eigen 100 | 101 | #endif // EIGEN_DETERMINANT_H 102 | -------------------------------------------------------------------------------- /jni/Eigen/src/LU/PartialPivLU_MKL.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2011, Intel Corporation. All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without modification, 5 | are permitted provided that the following conditions are met: 6 | 7 | * Redistributions of source code must retain the above copyright notice, this 8 | list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above copyright notice, 10 | this list of conditions and the following disclaimer in the documentation 11 | and/or other materials provided with the distribution. 12 | * Neither the name of Intel Corporation nor the names of its contributors may 13 | be used to endorse or promote products derived from this software without 14 | specific prior written permission. 15 | 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 20 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 23 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 | 27 | ******************************************************************************** 28 | * Content : Eigen bindings to Intel(R) MKL 29 | * LU decomposition with partial pivoting based on LAPACKE_?getrf function. 30 | ******************************************************************************** 31 | */ 32 | 33 | #ifndef EIGEN_PARTIALLU_LAPACK_H 34 | #define EIGEN_PARTIALLU_LAPACK_H 35 | 36 | #include "Eigen/src/Core/util/MKL_support.h" 37 | 38 | namespace Eigen { 39 | 40 | namespace internal { 41 | 42 | /** \internal Specialization for the data types supported by MKL */ 43 | 44 | #define EIGEN_MKL_LU_PARTPIV(EIGTYPE, MKLTYPE, MKLPREFIX) \ 45 | template \ 46 | struct partial_lu_impl \ 47 | { \ 48 | /* \internal performs the LU decomposition in-place of the matrix represented */ \ 49 | static lapack_int blocked_lu(lapack_int rows, lapack_int cols, EIGTYPE* lu_data, lapack_int luStride, lapack_int* row_transpositions, lapack_int& nb_transpositions, lapack_int maxBlockSize=256) \ 50 | { \ 51 | EIGEN_UNUSED_VARIABLE(maxBlockSize);\ 52 | lapack_int matrix_order, first_zero_pivot; \ 53 | lapack_int m, n, lda, *ipiv, info; \ 54 | EIGTYPE* a; \ 55 | /* Set up parameters for ?getrf */ \ 56 | matrix_order = StorageOrder==RowMajor ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; \ 57 | lda = luStride; \ 58 | a = lu_data; \ 59 | ipiv = row_transpositions; \ 60 | m = rows; \ 61 | n = cols; \ 62 | nb_transpositions = 0; \ 63 | \ 64 | info = LAPACKE_##MKLPREFIX##getrf( matrix_order, m, n, (MKLTYPE*)a, lda, ipiv ); \ 65 | \ 66 | for(int i=0;i= 0); \ 69 | /* something should be done with nb_transpositions */ \ 70 | \ 71 | first_zero_pivot = info; \ 72 | return first_zero_pivot; \ 73 | } \ 74 | }; 75 | 76 | EIGEN_MKL_LU_PARTPIV(double, double, d) 77 | EIGEN_MKL_LU_PARTPIV(float, float, s) 78 | EIGEN_MKL_LU_PARTPIV(dcomplex, MKL_Complex16, z) 79 | EIGEN_MKL_LU_PARTPIV(scomplex, MKL_Complex8, c) 80 | 81 | } // end namespace internal 82 | 83 | } // end namespace Eigen 84 | 85 | #endif // EIGEN_PARTIALLU_LAPACK_H 86 | -------------------------------------------------------------------------------- /jni/Eigen/src/LU/arch/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_LU_arch_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_LU_arch_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/LU/arch COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /jni/Eigen/src/QR/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_QR_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_QR_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/QR COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /jni/Eigen/src/QR/ColPivHouseholderQR_MKL.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2011, Intel Corporation. All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without modification, 5 | are permitted provided that the following conditions are met: 6 | 7 | * Redistributions of source code must retain the above copyright notice, this 8 | list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above copyright notice, 10 | this list of conditions and the following disclaimer in the documentation 11 | and/or other materials provided with the distribution. 12 | * Neither the name of Intel Corporation nor the names of its contributors may 13 | be used to endorse or promote products derived from this software without 14 | specific prior written permission. 15 | 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 20 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 23 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 | 27 | ******************************************************************************** 28 | * Content : Eigen bindings to Intel(R) MKL 29 | * Householder QR decomposition of a matrix with column pivoting based on 30 | * LAPACKE_?geqp3 function. 31 | ******************************************************************************** 32 | */ 33 | 34 | #ifndef EIGEN_COLPIVOTINGHOUSEHOLDERQR_MKL_H 35 | #define EIGEN_COLPIVOTINGHOUSEHOLDERQR_MKL_H 36 | 37 | #include "Eigen/src/Core/util/MKL_support.h" 38 | 39 | namespace Eigen { 40 | 41 | /** \internal Specialization for the data types supported by MKL */ 42 | 43 | #define EIGEN_MKL_QR_COLPIV(EIGTYPE, MKLTYPE, MKLPREFIX, EIGCOLROW, MKLCOLROW) \ 44 | template<> inline \ 45 | ColPivHouseholderQR >& \ 46 | ColPivHouseholderQR >::compute( \ 47 | const Matrix& matrix) \ 48 | \ 49 | { \ 50 | typedef Matrix MatrixType; \ 51 | typedef MatrixType::Scalar Scalar; \ 52 | typedef MatrixType::RealScalar RealScalar; \ 53 | Index rows = matrix.rows();\ 54 | Index cols = matrix.cols();\ 55 | Index size = matrix.diagonalSize();\ 56 | \ 57 | m_qr = matrix;\ 58 | m_hCoeffs.resize(size);\ 59 | \ 60 | m_colsTranspositions.resize(cols);\ 61 | /*Index number_of_transpositions = 0;*/ \ 62 | \ 63 | m_nonzero_pivots = 0; \ 64 | m_maxpivot = RealScalar(0);\ 65 | m_colsPermutation.resize(cols); \ 66 | m_colsPermutation.indices().setZero(); \ 67 | \ 68 | lapack_int lda = m_qr.outerStride(), i; \ 69 | lapack_int matrix_order = MKLCOLROW; \ 70 | LAPACKE_##MKLPREFIX##geqp3( matrix_order, rows, cols, (MKLTYPE*)m_qr.data(), lda, (lapack_int*)m_colsPermutation.indices().data(), (MKLTYPE*)m_hCoeffs.data()); \ 71 | m_isInitialized = true; \ 72 | m_maxpivot=m_qr.diagonal().cwiseAbs().maxCoeff(); \ 73 | m_hCoeffs.adjointInPlace(); \ 74 | RealScalar premultiplied_threshold = internal::abs(m_maxpivot) * threshold(); \ 75 | lapack_int *perm = m_colsPermutation.indices().data(); \ 76 | for(i=0;i premultiplied_threshold);\ 78 | } \ 79 | for(i=0;i \ 47 | void householder_qr_inplace_blocked(MatrixQR& mat, HCoeffs& hCoeffs, \ 48 | typename MatrixQR::Index maxBlockSize=32, \ 49 | EIGTYPE* tempData = 0) \ 50 | { \ 51 | lapack_int m = mat.rows(); \ 52 | lapack_int n = mat.cols(); \ 53 | lapack_int lda = mat.outerStride(); \ 54 | lapack_int matrix_order = (MatrixQR::IsRowMajor) ? LAPACK_ROW_MAJOR : LAPACK_COL_MAJOR; \ 55 | LAPACKE_##MKLPREFIX##geqrf( matrix_order, m, n, (MKLTYPE*)mat.data(), lda, (MKLTYPE*)hCoeffs.data()); \ 56 | hCoeffs.adjointInPlace(); \ 57 | \ 58 | } 59 | 60 | EIGEN_MKL_QR_NOPIV(double, double, d) 61 | EIGEN_MKL_QR_NOPIV(float, float, s) 62 | EIGEN_MKL_QR_NOPIV(dcomplex, MKL_Complex16, z) 63 | EIGEN_MKL_QR_NOPIV(scomplex, MKL_Complex8, c) 64 | 65 | } // end namespace internal 66 | 67 | } // end namespace Eigen 68 | 69 | #endif // EIGEN_QR_MKL_H 70 | -------------------------------------------------------------------------------- /jni/Eigen/src/SVD/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_SVD_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_SVD_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/SVD COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /jni/Eigen/src/SVD/JacobiSVD_MKL.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2011, Intel Corporation. All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without modification, 5 | are permitted provided that the following conditions are met: 6 | 7 | * Redistributions of source code must retain the above copyright notice, this 8 | list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above copyright notice, 10 | this list of conditions and the following disclaimer in the documentation 11 | and/or other materials provided with the distribution. 12 | * Neither the name of Intel Corporation nor the names of its contributors may 13 | be used to endorse or promote products derived from this software without 14 | specific prior written permission. 15 | 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 17 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR 20 | ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 21 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 23 | ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 | 27 | ******************************************************************************** 28 | * Content : Eigen bindings to Intel(R) MKL 29 | * Singular Value Decomposition - SVD. 30 | ******************************************************************************** 31 | */ 32 | 33 | #ifndef EIGEN_JACOBISVD_MKL_H 34 | #define EIGEN_JACOBISVD_MKL_H 35 | 36 | #include "Eigen/src/Core/util/MKL_support.h" 37 | 38 | namespace Eigen { 39 | 40 | /** \internal Specialization for the data types supported by MKL */ 41 | 42 | #define EIGEN_MKL_SVD(EIGTYPE, MKLTYPE, MKLRTYPE, MKLPREFIX, EIGCOLROW, MKLCOLROW) \ 43 | template<> inline \ 44 | JacobiSVD, ColPivHouseholderQRPreconditioner>& \ 45 | JacobiSVD, ColPivHouseholderQRPreconditioner>::compute(const Matrix& matrix, unsigned int computationOptions) \ 46 | { \ 47 | typedef Matrix MatrixType; \ 48 | typedef MatrixType::Scalar Scalar; \ 49 | typedef MatrixType::RealScalar RealScalar; \ 50 | allocate(matrix.rows(), matrix.cols(), computationOptions); \ 51 | \ 52 | /*const RealScalar precision = RealScalar(2) * NumTraits::epsilon();*/ \ 53 | m_nonzeroSingularValues = m_diagSize; \ 54 | \ 55 | lapack_int lda = matrix.outerStride(), ldu, ldvt; \ 56 | lapack_int matrix_order = MKLCOLROW; \ 57 | char jobu, jobvt; \ 58 | MKLTYPE *u, *vt, dummy; \ 59 | jobu = (m_computeFullU) ? 'A' : (m_computeThinU) ? 'S' : 'N'; \ 60 | jobvt = (m_computeFullV) ? 'A' : (m_computeThinV) ? 'S' : 'N'; \ 61 | if (computeU()) { \ 62 | ldu = m_matrixU.outerStride(); \ 63 | u = (MKLTYPE*)m_matrixU.data(); \ 64 | } else { ldu=1; u=&dummy; }\ 65 | MatrixType localV; \ 66 | ldvt = (m_computeFullV) ? m_cols : (m_computeThinV) ? m_diagSize : 1; \ 67 | if (computeV()) { \ 68 | localV.resize(ldvt, m_cols); \ 69 | vt = (MKLTYPE*)localV.data(); \ 70 | } else { ldvt=1; vt=&dummy; }\ 71 | Matrix superb; superb.resize(m_diagSize, 1); \ 72 | MatrixType m_temp; m_temp = matrix; \ 73 | LAPACKE_##MKLPREFIX##gesvd( matrix_order, jobu, jobvt, m_rows, m_cols, (MKLTYPE*)m_temp.data(), lda, (MKLRTYPE*)m_singularValues.data(), u, ldu, vt, ldvt, superb.data()); \ 74 | if (computeV()) m_matrixV = localV.adjoint(); \ 75 | /* for(int i=0;i 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_MISC_IMAGE_H 11 | #define EIGEN_MISC_IMAGE_H 12 | 13 | namespace Eigen { 14 | 15 | namespace internal { 16 | 17 | /** \class image_retval_base 18 | * 19 | */ 20 | template 21 | struct traits > 22 | { 23 | typedef typename DecompositionType::MatrixType MatrixType; 24 | typedef Matrix< 25 | typename MatrixType::Scalar, 26 | MatrixType::RowsAtCompileTime, // the image is a subspace of the destination space, whose 27 | // dimension is the number of rows of the original matrix 28 | Dynamic, // we don't know at compile time the dimension of the image (the rank) 29 | MatrixType::Options, 30 | MatrixType::MaxRowsAtCompileTime, // the image matrix will consist of columns from the original matrix, 31 | MatrixType::MaxColsAtCompileTime // so it has the same number of rows and at most as many columns. 32 | > ReturnType; 33 | }; 34 | 35 | template struct image_retval_base 36 | : public ReturnByValue > 37 | { 38 | typedef _DecompositionType DecompositionType; 39 | typedef typename DecompositionType::MatrixType MatrixType; 40 | typedef ReturnByValue Base; 41 | typedef typename Base::Index Index; 42 | 43 | image_retval_base(const DecompositionType& dec, const MatrixType& originalMatrix) 44 | : m_dec(dec), m_rank(dec.rank()), 45 | m_cols(m_rank == 0 ? 1 : m_rank), 46 | m_originalMatrix(originalMatrix) 47 | {} 48 | 49 | inline Index rows() const { return m_dec.rows(); } 50 | inline Index cols() const { return m_cols; } 51 | inline Index rank() const { return m_rank; } 52 | inline const DecompositionType& dec() const { return m_dec; } 53 | inline const MatrixType& originalMatrix() const { return m_originalMatrix; } 54 | 55 | template inline void evalTo(Dest& dst) const 56 | { 57 | static_cast*>(this)->evalTo(dst); 58 | } 59 | 60 | protected: 61 | const DecompositionType& m_dec; 62 | Index m_rank, m_cols; 63 | const MatrixType& m_originalMatrix; 64 | }; 65 | 66 | } // end namespace internal 67 | 68 | #define EIGEN_MAKE_IMAGE_HELPERS(DecompositionType) \ 69 | typedef typename DecompositionType::MatrixType MatrixType; \ 70 | typedef typename MatrixType::Scalar Scalar; \ 71 | typedef typename MatrixType::RealScalar RealScalar; \ 72 | typedef typename MatrixType::Index Index; \ 73 | typedef Eigen::internal::image_retval_base Base; \ 74 | using Base::dec; \ 75 | using Base::originalMatrix; \ 76 | using Base::rank; \ 77 | using Base::rows; \ 78 | using Base::cols; \ 79 | image_retval(const DecompositionType& dec, const MatrixType& originalMatrix) \ 80 | : Base(dec, originalMatrix) {} 81 | 82 | } // end namespace Eigen 83 | 84 | #endif // EIGEN_MISC_IMAGE_H 85 | -------------------------------------------------------------------------------- /jni/Eigen/src/misc/Kernel.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009 Benoit Jacob 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_MISC_KERNEL_H 11 | #define EIGEN_MISC_KERNEL_H 12 | 13 | namespace Eigen { 14 | 15 | namespace internal { 16 | 17 | /** \class kernel_retval_base 18 | * 19 | */ 20 | template 21 | struct traits > 22 | { 23 | typedef typename DecompositionType::MatrixType MatrixType; 24 | typedef Matrix< 25 | typename MatrixType::Scalar, 26 | MatrixType::ColsAtCompileTime, // the number of rows in the "kernel matrix" 27 | // is the number of cols of the original matrix 28 | // so that the product "matrix * kernel = zero" makes sense 29 | Dynamic, // we don't know at compile-time the dimension of the kernel 30 | MatrixType::Options, 31 | MatrixType::MaxColsAtCompileTime, // see explanation for 2nd template parameter 32 | MatrixType::MaxColsAtCompileTime // the kernel is a subspace of the domain space, 33 | // whose dimension is the number of columns of the original matrix 34 | > ReturnType; 35 | }; 36 | 37 | template struct kernel_retval_base 38 | : public ReturnByValue > 39 | { 40 | typedef _DecompositionType DecompositionType; 41 | typedef ReturnByValue Base; 42 | typedef typename Base::Index Index; 43 | 44 | kernel_retval_base(const DecompositionType& dec) 45 | : m_dec(dec), 46 | m_rank(dec.rank()), 47 | m_cols(m_rank==dec.cols() ? 1 : dec.cols() - m_rank) 48 | {} 49 | 50 | inline Index rows() const { return m_dec.cols(); } 51 | inline Index cols() const { return m_cols; } 52 | inline Index rank() const { return m_rank; } 53 | inline const DecompositionType& dec() const { return m_dec; } 54 | 55 | template inline void evalTo(Dest& dst) const 56 | { 57 | static_cast*>(this)->evalTo(dst); 58 | } 59 | 60 | protected: 61 | const DecompositionType& m_dec; 62 | Index m_rank, m_cols; 63 | }; 64 | 65 | } // end namespace internal 66 | 67 | #define EIGEN_MAKE_KERNEL_HELPERS(DecompositionType) \ 68 | typedef typename DecompositionType::MatrixType MatrixType; \ 69 | typedef typename MatrixType::Scalar Scalar; \ 70 | typedef typename MatrixType::RealScalar RealScalar; \ 71 | typedef typename MatrixType::Index Index; \ 72 | typedef Eigen::internal::kernel_retval_base Base; \ 73 | using Base::dec; \ 74 | using Base::rank; \ 75 | using Base::rows; \ 76 | using Base::cols; \ 77 | kernel_retval(const DecompositionType& dec) : Base(dec) {} 78 | 79 | } // end namespace Eigen 80 | 81 | #endif // EIGEN_MISC_KERNEL_H 82 | -------------------------------------------------------------------------------- /jni/Eigen/src/misc/Solve.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2009 Benoit Jacob 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_MISC_SOLVE_H 11 | #define EIGEN_MISC_SOLVE_H 12 | 13 | namespace Eigen { 14 | 15 | namespace internal { 16 | 17 | /** \class solve_retval_base 18 | * 19 | */ 20 | template 21 | struct traits > 22 | { 23 | typedef typename DecompositionType::MatrixType MatrixType; 24 | typedef Matrix ReturnType; 30 | }; 31 | 32 | template struct solve_retval_base 33 | : public ReturnByValue > 34 | { 35 | typedef typename remove_all::type RhsNestedCleaned; 36 | typedef _DecompositionType DecompositionType; 37 | typedef ReturnByValue Base; 38 | typedef typename Base::Index Index; 39 | 40 | solve_retval_base(const DecompositionType& dec, const Rhs& rhs) 41 | : m_dec(dec), m_rhs(rhs) 42 | {} 43 | 44 | inline Index rows() const { return m_dec.cols(); } 45 | inline Index cols() const { return m_rhs.cols(); } 46 | inline const DecompositionType& dec() const { return m_dec; } 47 | inline const RhsNestedCleaned& rhs() const { return m_rhs; } 48 | 49 | template inline void evalTo(Dest& dst) const 50 | { 51 | static_cast*>(this)->evalTo(dst); 52 | } 53 | 54 | protected: 55 | const DecompositionType& m_dec; 56 | typename Rhs::Nested m_rhs; 57 | }; 58 | 59 | } // end namespace internal 60 | 61 | #define EIGEN_MAKE_SOLVE_HELPERS(DecompositionType,Rhs) \ 62 | typedef typename DecompositionType::MatrixType MatrixType; \ 63 | typedef typename MatrixType::Scalar Scalar; \ 64 | typedef typename MatrixType::RealScalar RealScalar; \ 65 | typedef typename MatrixType::Index Index; \ 66 | typedef Eigen::internal::solve_retval_base Base; \ 67 | using Base::dec; \ 68 | using Base::rhs; \ 69 | using Base::rows; \ 70 | using Base::cols; \ 71 | solve_retval(const DecompositionType& dec, const Rhs& rhs) \ 72 | : Base(dec, rhs) {} 73 | 74 | } // end namespace Eigen 75 | 76 | #endif // EIGEN_MISC_SOLVE_H 77 | -------------------------------------------------------------------------------- /jni/Eigen/src/misc/SparseSolve.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2010 Gael Guennebaud 5 | // 6 | // This Source Code Form is subject to the terms of the Mozilla 7 | // Public License v. 2.0. If a copy of the MPL was not distributed 8 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 9 | 10 | #ifndef EIGEN_SPARSE_SOLVE_H 11 | #define EIGEN_SPARSE_SOLVE_H 12 | 13 | namespace Eigen { 14 | 15 | namespace internal { 16 | 17 | template struct sparse_solve_retval_base; 18 | template struct sparse_solve_retval; 19 | 20 | template 21 | struct traits > 22 | { 23 | typedef typename DecompositionType::MatrixType MatrixType; 24 | typedef SparseMatrix ReturnType; 25 | }; 26 | 27 | template struct sparse_solve_retval_base 28 | : public ReturnByValue > 29 | { 30 | typedef typename remove_all::type RhsNestedCleaned; 31 | typedef _DecompositionType DecompositionType; 32 | typedef ReturnByValue Base; 33 | typedef typename Base::Index Index; 34 | 35 | sparse_solve_retval_base(const DecompositionType& dec, const Rhs& rhs) 36 | : m_dec(dec), m_rhs(rhs) 37 | {} 38 | 39 | inline Index rows() const { return m_dec.cols(); } 40 | inline Index cols() const { return m_rhs.cols(); } 41 | inline const DecompositionType& dec() const { return m_dec; } 42 | inline const RhsNestedCleaned& rhs() const { return m_rhs; } 43 | 44 | template inline void evalTo(Dest& dst) const 45 | { 46 | static_cast*>(this)->evalTo(dst); 47 | } 48 | 49 | protected: 50 | const DecompositionType& m_dec; 51 | typename Rhs::Nested m_rhs; 52 | }; 53 | 54 | #define EIGEN_MAKE_SPARSE_SOLVE_HELPERS(DecompositionType,Rhs) \ 55 | typedef typename DecompositionType::MatrixType MatrixType; \ 56 | typedef typename MatrixType::Scalar Scalar; \ 57 | typedef typename MatrixType::RealScalar RealScalar; \ 58 | typedef typename MatrixType::Index Index; \ 59 | typedef Eigen::internal::sparse_solve_retval_base Base; \ 60 | using Base::dec; \ 61 | using Base::rhs; \ 62 | using Base::rows; \ 63 | using Base::cols; \ 64 | sparse_solve_retval(const DecompositionType& dec, const Rhs& rhs) \ 65 | : Base(dec, rhs) {} 66 | 67 | 68 | 69 | template struct solve_retval_with_guess; 70 | 71 | template 72 | struct traits > 73 | { 74 | typedef typename DecompositionType::MatrixType MatrixType; 75 | typedef Matrix ReturnType; 81 | }; 82 | 83 | template struct solve_retval_with_guess 84 | : public ReturnByValue > 85 | { 86 | typedef typename DecompositionType::Index Index; 87 | 88 | solve_retval_with_guess(const DecompositionType& dec, const Rhs& rhs, const Guess& guess) 89 | : m_dec(dec), m_rhs(rhs), m_guess(guess) 90 | {} 91 | 92 | inline Index rows() const { return m_dec.cols(); } 93 | inline Index cols() const { return m_rhs.cols(); } 94 | 95 | template inline void evalTo(Dest& dst) const 96 | { 97 | dst = m_guess; 98 | m_dec._solveWithGuess(m_rhs,dst); 99 | } 100 | 101 | protected: 102 | const DecompositionType& m_dec; 103 | const typename Rhs::Nested m_rhs; 104 | const typename Guess::Nested m_guess; 105 | }; 106 | 107 | } // namepsace internal 108 | 109 | } // end namespace Eigen 110 | 111 | #endif // EIGEN_SPARSE_SOLVE_H 112 | -------------------------------------------------------------------------------- /jni/Eigen/src/plugins/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | FILE(GLOB Eigen_plugins_SRCS "*.h") 2 | 3 | INSTALL(FILES 4 | ${Eigen_plugins_SRCS} 5 | DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/plugins COMPONENT Devel 6 | ) 7 | -------------------------------------------------------------------------------- /jni/Eigen/src/plugins/CommonCwiseBinaryOps.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008-2009 Gael Guennebaud 5 | // Copyright (C) 2006-2008 Benoit Jacob 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | // This file is a base class plugin containing common coefficient wise functions. 12 | 13 | /** \returns an expression of the difference of \c *this and \a other 14 | * 15 | * \note If you want to substract a given scalar from all coefficients, see Cwise::operator-(). 16 | * 17 | * \sa class CwiseBinaryOp, operator-=() 18 | */ 19 | EIGEN_MAKE_CWISE_BINARY_OP(operator-,internal::scalar_difference_op) 20 | 21 | /** \returns an expression of the sum of \c *this and \a other 22 | * 23 | * \note If you want to add a given scalar to all coefficients, see Cwise::operator+(). 24 | * 25 | * \sa class CwiseBinaryOp, operator+=() 26 | */ 27 | EIGEN_MAKE_CWISE_BINARY_OP(operator+,internal::scalar_sum_op) 28 | 29 | /** \returns an expression of a custom coefficient-wise operator \a func of *this and \a other 30 | * 31 | * The template parameter \a CustomBinaryOp is the type of the functor 32 | * of the custom operator (see class CwiseBinaryOp for an example) 33 | * 34 | * Here is an example illustrating the use of custom functors: 35 | * \include class_CwiseBinaryOp.cpp 36 | * Output: \verbinclude class_CwiseBinaryOp.out 37 | * 38 | * \sa class CwiseBinaryOp, operator+(), operator-(), cwiseProduct() 39 | */ 40 | template 41 | EIGEN_STRONG_INLINE const CwiseBinaryOp 42 | binaryExpr(const EIGEN_CURRENT_STORAGE_BASE_CLASS &other, const CustomBinaryOp& func = CustomBinaryOp()) const 43 | { 44 | return CwiseBinaryOp(derived(), other.derived(), func); 45 | } 46 | 47 | -------------------------------------------------------------------------------- /jni/Eigen/src/plugins/MatrixCwiseUnaryOps.h: -------------------------------------------------------------------------------- 1 | // This file is part of Eigen, a lightweight C++ template library 2 | // for linear algebra. 3 | // 4 | // Copyright (C) 2008-2009 Gael Guennebaud 5 | // Copyright (C) 2006-2008 Benoit Jacob 6 | // 7 | // This Source Code Form is subject to the terms of the Mozilla 8 | // Public License v. 2.0. If a copy of the MPL was not distributed 9 | // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 | 11 | // This file is a base class plugin containing matrix specifics coefficient wise functions. 12 | 13 | /** \returns an expression of the coefficient-wise absolute value of \c *this 14 | * 15 | * Example: \include MatrixBase_cwiseAbs.cpp 16 | * Output: \verbinclude MatrixBase_cwiseAbs.out 17 | * 18 | * \sa cwiseAbs2() 19 | */ 20 | EIGEN_STRONG_INLINE const CwiseUnaryOp, const Derived> 21 | cwiseAbs() const { return derived(); } 22 | 23 | /** \returns an expression of the coefficient-wise squared absolute value of \c *this 24 | * 25 | * Example: \include MatrixBase_cwiseAbs2.cpp 26 | * Output: \verbinclude MatrixBase_cwiseAbs2.out 27 | * 28 | * \sa cwiseAbs() 29 | */ 30 | EIGEN_STRONG_INLINE const CwiseUnaryOp, const Derived> 31 | cwiseAbs2() const { return derived(); } 32 | 33 | /** \returns an expression of the coefficient-wise square root of *this. 34 | * 35 | * Example: \include MatrixBase_cwiseSqrt.cpp 36 | * Output: \verbinclude MatrixBase_cwiseSqrt.out 37 | * 38 | * \sa cwisePow(), cwiseSquare() 39 | */ 40 | inline const CwiseUnaryOp, const Derived> 41 | cwiseSqrt() const { return derived(); } 42 | 43 | /** \returns an expression of the coefficient-wise inverse of *this. 44 | * 45 | * Example: \include MatrixBase_cwiseInverse.cpp 46 | * Output: \verbinclude MatrixBase_cwiseInverse.out 47 | * 48 | * \sa cwiseProduct() 49 | */ 50 | inline const CwiseUnaryOp, const Derived> 51 | cwiseInverse() const { return derived(); } 52 | 53 | /** \returns an expression of the coefficient-wise == operator of \c *this and a scalar \a s 54 | * 55 | * \warning this performs an exact comparison, which is generally a bad idea with floating-point types. 56 | * In order to check for equality between two vectors or matrices with floating-point coefficients, it is 57 | * generally a far better idea to use a fuzzy comparison as provided by isApprox() and 58 | * isMuchSmallerThan(). 59 | * 60 | * \sa cwiseEqual(const MatrixBase &) const 61 | */ 62 | inline const CwiseUnaryOp >, const Derived> 63 | cwiseEqual(const Scalar& s) const 64 | { 65 | return CwiseUnaryOp >,const Derived> 66 | (derived(), std::bind1st(std::equal_to(), s)); 67 | } 68 | -------------------------------------------------------------------------------- /jni/MatrixFromEigen.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | #define MSG_TAG "MatrixComputationFromEigen" 10 | #define LOGD(...) __android_log_print(ANDROID_LOG_INFO, MSG_TAG, __VA_ARGS__) 11 | 12 | using namespace Eigen; 13 | 14 | extern "C" { 15 | 16 | JNIEXPORT jobjectArray JNICALL 17 | Java_com_cllin_matrixcomputation_computation_EigenMatrixComputation_matrixComputationByEigen 18 | (JNIEnv* env, jobject obj, jobjectArray a, jobjectArray b){ 19 | // Timer 20 | clock_t t; 21 | t = clock(); 22 | 23 | int row; 24 | int col; 25 | int dim; 26 | 27 | // Load float matrices 28 | int len1 = env->GetArrayLength(a); 29 | jfloatArray array1D= (jfloatArray)env->GetObjectArrayElement(a, 0); 30 | int len2 = env->GetArrayLength(array1D); 31 | row = len1; 32 | 33 | MatrixXf m1 = MatrixXf::Zero(len1, len2); 34 | for(int i = 0; i < len1; i++){ 35 | jfloatArray onearray1D = (jfloatArray)env->GetObjectArrayElement(a, i); 36 | jfloat* element = env->GetFloatArrayElements(onearray1D, 0); 37 | // localA[i] = new float[len2]; 38 | for(int j = 0; j < len2; j++) { 39 | m1(i, j) = element[j]; 40 | // m1(i, j) = 1; 41 | // localA[i][j] = element[j]; 42 | } 43 | env->ReleaseFloatArrayElements(onearray1D, element, 0); 44 | env->DeleteLocalRef(onearray1D); 45 | } 46 | 47 | len1 = env->GetArrayLength(b); 48 | array1D= (jfloatArray)env->GetObjectArrayElement(b, 0); 49 | len2 = env->GetArrayLength(array1D); 50 | col = len2; 51 | dim = len1; 52 | 53 | MatrixXf m2 = MatrixXf::Zero(len1, len2); 54 | for(int i = 0; i < len1; i++){ 55 | jfloatArray onearray1D = (jfloatArray)env->GetObjectArrayElement(b, i); 56 | jfloat* element = env->GetFloatArrayElements(onearray1D, 0); 57 | for(int j = 0; j < len2; j++) { 58 | m2(i, j) = element[j]; 59 | } 60 | env->ReleaseFloatArrayElements(onearray1D, element, 0); 61 | env->DeleteLocalRef(onearray1D); 62 | } 63 | 64 | __android_log_print(ANDROID_LOG_VERBOSE, MSG_TAG, "Load Time= %f (ms)\n", (float)(clock() - t)/CLOCKS_PER_SEC * 1000); 65 | t = clock(); 66 | 67 | // ****** 68 | MatrixXf result = m1 * m2; 69 | __android_log_print(ANDROID_LOG_VERBOSE, MSG_TAG, "Computation Time= %f (ms)\n", (float)(clock() - t)/CLOCKS_PER_SEC * 1000); 70 | t = clock(); 71 | // ****** 72 | 73 | // XXX 74 | // There should be some better way to return the result 75 | float** tmp = new float*[row]; 76 | jclass floatArrayClass = env->FindClass("[F"); 77 | jobjectArray returnedResult = env->NewObjectArray((jsize)row, floatArrayClass, NULL); 78 | for(int i = 0; i < row; i++){ 79 | tmp[i] = new float[col]; 80 | for(int j = 0; j < col; j++){ 81 | tmp[i][j] = result(i,j); 82 | } 83 | jfloatArray floatArray = env->NewFloatArray(col); 84 | env->SetFloatArrayRegion(floatArray, (jsize)0, (jsize)col, (jfloat*)tmp[i]); 85 | env->SetObjectArrayElement(returnedResult, (jsize)i, floatArray); 86 | env->DeleteLocalRef(floatArray); 87 | } 88 | 89 | free(tmp); 90 | 91 | __android_log_print(ANDROID_LOG_VERBOSE, MSG_TAG, "Preparation of Returned Value= %f (ms)\n", (float)(clock() - t)/CLOCKS_PER_SEC * 1000); 92 | return returnedResult; 93 | } 94 | } 95 | -------------------------------------------------------------------------------- /jni/MatrixFromNative.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #define MSG_TAG "MatrixComputationInNative" 7 | 8 | extern "C" { 9 | JNIEXPORT jobjectArray JNICALL 10 | Java_com_cllin_matrixcomputation_benchmark_MatrixComputationBenchmark_matrixComputationByNative 11 | (JNIEnv* env, jobject obj, jobjectArray a, jobjectArray b){ 12 | // Timer 13 | clock_t t; 14 | t = clock(); 15 | 16 | int row; 17 | int col; 18 | int dim; 19 | 20 | // Load float matrices 21 | int len1 = env->GetArrayLength(a); 22 | jfloatArray array1D= (jfloatArray)env->GetObjectArrayElement(a, 0); 23 | int len2 = env->GetArrayLength(array1D); 24 | row = len1; 25 | 26 | 27 | float** localA; 28 | localA = new float*[len1]; 29 | for(int i = 0; i < len1; i++){ 30 | jfloatArray onearray1D = (jfloatArray)env->GetObjectArrayElement(a, i); 31 | jfloat* element = env->GetFloatArrayElements(onearray1D, 0); 32 | localA[i] = new float[len2]; 33 | for(int j = 0; j < len2; j++) { 34 | localA[i][j] = element[j]; 35 | } 36 | env->ReleaseFloatArrayElements(onearray1D, element, 0); 37 | env->DeleteLocalRef(onearray1D); 38 | } 39 | 40 | len1 = env->GetArrayLength(b); 41 | array1D= (jfloatArray)env->GetObjectArrayElement(b, 0); 42 | len2 = env->GetArrayLength(array1D); 43 | col = len2; 44 | dim = len1; 45 | 46 | float** localB; 47 | localB = new float*[len1]; 48 | for(int i = 0; i < len1; i++){ 49 | jfloatArray onearray1D = (jfloatArray)env->GetObjectArrayElement(b, i); 50 | jfloat* element = env->GetFloatArrayElements(onearray1D, 0); 51 | localB[i] = new float[len2]; 52 | for(int j = 0; j < len2; j++) { 53 | localB[i][j] = element[j]; 54 | } 55 | env->ReleaseFloatArrayElements(onearray1D, element, 0); 56 | env->DeleteLocalRef(onearray1D); 57 | } 58 | 59 | // __android_log_print(ANDROID_LOG_VERBOSE, MSG_TAG, "Load Time= %f (ms)\n", (float)(clock() - t)/CLOCKS_PER_SEC * 1000); 60 | t = clock(); 61 | 62 | // Computation 63 | float** result; 64 | 65 | result = new float*[row]; 66 | for(int i = 0; i < row; i++){ 67 | result[i] = new float[col]; 68 | for(int j = 0; j < col; j++){ 69 | result[i][j] = 0; 70 | for(int k = 0; k < dim; k++){ 71 | result[i][j] += localA[i][k] * localB[k][j]; 72 | } 73 | } 74 | } 75 | 76 | jclass floatArrayClass = env->FindClass("[F"); 77 | jobjectArray returnedResult = env->NewObjectArray((jsize)row, floatArrayClass, NULL); 78 | for(int i = 0; i < row; i++){ 79 | jfloatArray floatArray = env->NewFloatArray(col); 80 | env->SetFloatArrayRegion(floatArray, (jsize)0, (jsize)col, (jfloat*)result[i]); 81 | env->SetObjectArrayElement(returnedResult, (jsize)i, floatArray); 82 | env->DeleteLocalRef(floatArray); 83 | } 84 | 85 | env->DeleteLocalRef(array1D); 86 | 87 | free(localA); 88 | free(localB); 89 | free(result); 90 | 91 | // __android_log_print(ANDROID_LOG_VERBOSE, MSG_TAG, "Computation Time= %f (ms)\n", (float)(clock() - t)/CLOCKS_PER_SEC * 1000); 92 | 93 | return returnedResult; 94 | } 95 | } 96 | -------------------------------------------------------------------------------- /libs/android-support-v4.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cllin/MatrixComputation/ad9fb0f956883905458e1c3a5112db615d34a2ca/libs/android-support-v4.jar -------------------------------------------------------------------------------- /libs/armeabi/libmatrixfromeigen.so: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cllin/MatrixComputation/ad9fb0f956883905458e1c3a5112db615d34a2ca/libs/armeabi/libmatrixfromeigen.so -------------------------------------------------------------------------------- /libs/armeabi/libmatrixfromnative.so: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cllin/MatrixComputation/ad9fb0f956883905458e1c3a5112db615d34a2ca/libs/armeabi/libmatrixfromnative.so -------------------------------------------------------------------------------- /libs/armeabi/libopencv_core.a: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cllin/MatrixComputation/ad9fb0f956883905458e1c3a5112db615d34a2ca/libs/armeabi/libopencv_core.a -------------------------------------------------------------------------------- /libs/opencvlibrary-2.4.6.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cllin/MatrixComputation/ad9fb0f956883905458e1c3a5112db615d34a2ca/libs/opencvlibrary-2.4.6.jar -------------------------------------------------------------------------------- /proguard-project.txt: -------------------------------------------------------------------------------- 1 | # To enable ProGuard in your project, edit project.properties 2 | # to define the proguard.config property as described in that file. 3 | # 4 | # Add project specific ProGuard rules here. 5 | # By default, the flags in this file are appended to flags specified 6 | # in ${sdk.dir}/tools/proguard/proguard-android.txt 7 | # You can edit the include path and order by changing the ProGuard 8 | # include property in project.properties. 9 | # 10 | # For more details, see 11 | # http://developer.android.com/guide/developing/tools/proguard.html 12 | 13 | # Add any project specific keep options here: 14 | 15 | # If your project uses WebView with JS, uncomment the following 16 | # and specify the fully qualified class name to the JavaScript interface 17 | # class: 18 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview { 19 | # public *; 20 | #} 21 | -------------------------------------------------------------------------------- /project.properties: -------------------------------------------------------------------------------- 1 | # This file is automatically generated by Android Tools. 2 | # Do not modify this file -- YOUR CHANGES WILL BE ERASED! 3 | # 4 | # This file must be checked in Version Control Systems. 5 | # 6 | # To customize properties used by the Ant build system edit 7 | # "ant.properties", and override values to adapt the script to your 8 | # project structure. 9 | # 10 | # To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home): 11 | #proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt 12 | 13 | # Project target. 14 | target=android-19 -------------------------------------------------------------------------------- /res/drawable-hdpi/ic_launcher.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cllin/MatrixComputation/ad9fb0f956883905458e1c3a5112db615d34a2ca/res/drawable-hdpi/ic_launcher.png -------------------------------------------------------------------------------- /res/drawable-mdpi/ic_launcher.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cllin/MatrixComputation/ad9fb0f956883905458e1c3a5112db615d34a2ca/res/drawable-mdpi/ic_launcher.png -------------------------------------------------------------------------------- /res/drawable-xhdpi/ic_launcher.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cllin/MatrixComputation/ad9fb0f956883905458e1c3a5112db615d34a2ca/res/drawable-xhdpi/ic_launcher.png -------------------------------------------------------------------------------- /res/drawable-xxhdpi/ic_launcher.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cllin/MatrixComputation/ad9fb0f956883905458e1c3a5112db615d34a2ca/res/drawable-xxhdpi/ic_launcher.png -------------------------------------------------------------------------------- /res/layout/activity_benchmark.xml: -------------------------------------------------------------------------------- 1 | 7 | 14 | 20 | 21 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 |