Merge of itasc branch. Project files, scons and cmake should be working. Makefile...
authorBenoit Bolsee <benoit.bolsee@online.be>
Thu, 24 Sep 2009 21:22:24 +0000 (21:22 +0000)
committerBenoit Bolsee <benoit.bolsee@online.be>
Thu, 24 Sep 2009 21:22:24 +0000 (21:22 +0000)
386 files changed:
1  2 
extern/Eigen2/Eigen/Array
extern/Eigen2/Eigen/Cholesky
extern/Eigen2/Eigen/Core
extern/Eigen2/Eigen/Dense
extern/Eigen2/Eigen/Eigen
extern/Eigen2/Eigen/Geometry
extern/Eigen2/Eigen/LU
extern/Eigen2/Eigen/LeastSquares
extern/Eigen2/Eigen/NewStdVector
extern/Eigen2/Eigen/QR
extern/Eigen2/Eigen/QtAlignedMalloc
extern/Eigen2/Eigen/SVD
extern/Eigen2/Eigen/Sparse
extern/Eigen2/Eigen/StdVector
extern/Eigen2/Eigen/src/Array/BooleanRedux.h
extern/Eigen2/Eigen/src/Array/CwiseOperators.h
extern/Eigen2/Eigen/src/Array/Functors.h
extern/Eigen2/Eigen/src/Array/Norms.h
extern/Eigen2/Eigen/src/Array/PartialRedux.h
extern/Eigen2/Eigen/src/Array/Random.h
extern/Eigen2/Eigen/src/Array/Select.h
extern/Eigen2/Eigen/src/Cholesky/CholeskyInstantiations.cpp
extern/Eigen2/Eigen/src/Cholesky/LDLT.h
extern/Eigen2/Eigen/src/Cholesky/LLT.h
extern/Eigen2/Eigen/src/Core/Assign.h
extern/Eigen2/Eigen/src/Core/Block.h
extern/Eigen2/Eigen/src/Core/CacheFriendlyProduct.h
extern/Eigen2/Eigen/src/Core/Coeffs.h
extern/Eigen2/Eigen/src/Core/CommaInitializer.h
extern/Eigen2/Eigen/src/Core/CoreInstantiations.cpp
extern/Eigen2/Eigen/src/Core/Cwise.h
extern/Eigen2/Eigen/src/Core/CwiseBinaryOp.h
extern/Eigen2/Eigen/src/Core/CwiseNullaryOp.h
extern/Eigen2/Eigen/src/Core/CwiseUnaryOp.h
extern/Eigen2/Eigen/src/Core/DiagonalCoeffs.h
extern/Eigen2/Eigen/src/Core/DiagonalMatrix.h
extern/Eigen2/Eigen/src/Core/DiagonalProduct.h
extern/Eigen2/Eigen/src/Core/Dot.h
extern/Eigen2/Eigen/src/Core/Flagged.h
extern/Eigen2/Eigen/src/Core/Functors.h
extern/Eigen2/Eigen/src/Core/Fuzzy.h
extern/Eigen2/Eigen/src/Core/GenericPacketMath.h
extern/Eigen2/Eigen/src/Core/IO.h
extern/Eigen2/Eigen/src/Core/Map.h
extern/Eigen2/Eigen/src/Core/MapBase.h
extern/Eigen2/Eigen/src/Core/MathFunctions.h
extern/Eigen2/Eigen/src/Core/Matrix.h
extern/Eigen2/Eigen/src/Core/MatrixBase.h
extern/Eigen2/Eigen/src/Core/MatrixStorage.h
extern/Eigen2/Eigen/src/Core/Minor.h
extern/Eigen2/Eigen/src/Core/NestByValue.h
extern/Eigen2/Eigen/src/Core/NumTraits.h
extern/Eigen2/Eigen/src/Core/Part.h
extern/Eigen2/Eigen/src/Core/Product.h
extern/Eigen2/Eigen/src/Core/Redux.h
extern/Eigen2/Eigen/src/Core/SolveTriangular.h
extern/Eigen2/Eigen/src/Core/Sum.h
extern/Eigen2/Eigen/src/Core/Swap.h
extern/Eigen2/Eigen/src/Core/Transpose.h
extern/Eigen2/Eigen/src/Core/Visitor.h
extern/Eigen2/Eigen/src/Core/arch/AltiVec/PacketMath.h
extern/Eigen2/Eigen/src/Core/arch/SSE/PacketMath.h
extern/Eigen2/Eigen/src/Core/util/Constants.h
extern/Eigen2/Eigen/src/Core/util/DisableMSVCWarnings.h
extern/Eigen2/Eigen/src/Core/util/EnableMSVCWarnings.h
extern/Eigen2/Eigen/src/Core/util/ForwardDeclarations.h
extern/Eigen2/Eigen/src/Core/util/Macros.h
extern/Eigen2/Eigen/src/Core/util/Memory.h
extern/Eigen2/Eigen/src/Core/util/Meta.h
extern/Eigen2/Eigen/src/Core/util/StaticAssert.h
extern/Eigen2/Eigen/src/Core/util/XprHelper.h
extern/Eigen2/Eigen/src/Geometry/AlignedBox.h
extern/Eigen2/Eigen/src/Geometry/AngleAxis.h
extern/Eigen2/Eigen/src/Geometry/EulerAngles.h
extern/Eigen2/Eigen/src/Geometry/Hyperplane.h
extern/Eigen2/Eigen/src/Geometry/OrthoMethods.h
extern/Eigen2/Eigen/src/Geometry/ParametrizedLine.h
extern/Eigen2/Eigen/src/Geometry/Quaternion.h
extern/Eigen2/Eigen/src/Geometry/Rotation2D.h
extern/Eigen2/Eigen/src/Geometry/RotationBase.h
extern/Eigen2/Eigen/src/Geometry/Scaling.h
extern/Eigen2/Eigen/src/Geometry/Transform.h
extern/Eigen2/Eigen/src/Geometry/Translation.h
extern/Eigen2/Eigen/src/LU/Determinant.h
extern/Eigen2/Eigen/src/LU/Inverse.h
extern/Eigen2/Eigen/src/LU/LU.h
extern/Eigen2/Eigen/src/LeastSquares/LeastSquares.h
extern/Eigen2/Eigen/src/QR/EigenSolver.h
extern/Eigen2/Eigen/src/QR/HessenbergDecomposition.h
extern/Eigen2/Eigen/src/QR/QR.h
extern/Eigen2/Eigen/src/QR/QrInstantiations.cpp
extern/Eigen2/Eigen/src/QR/SelfAdjointEigenSolver.h
extern/Eigen2/Eigen/src/QR/Tridiagonalization.h
extern/Eigen2/Eigen/src/SVD/SVD.h
extern/Eigen2/Eigen/src/Sparse/AmbiVector.h
extern/Eigen2/Eigen/src/Sparse/CholmodSupport.h
extern/Eigen2/Eigen/src/Sparse/CompressedStorage.h
extern/Eigen2/Eigen/src/Sparse/CoreIterators.h
extern/Eigen2/Eigen/src/Sparse/DynamicSparseMatrix.h
extern/Eigen2/Eigen/src/Sparse/MappedSparseMatrix.h
extern/Eigen2/Eigen/src/Sparse/RandomSetter.h
extern/Eigen2/Eigen/src/Sparse/SparseAssign.h
extern/Eigen2/Eigen/src/Sparse/SparseBlock.h
extern/Eigen2/Eigen/src/Sparse/SparseCwise.h
extern/Eigen2/Eigen/src/Sparse/SparseCwiseBinaryOp.h
extern/Eigen2/Eigen/src/Sparse/SparseCwiseUnaryOp.h
extern/Eigen2/Eigen/src/Sparse/SparseDiagonalProduct.h
extern/Eigen2/Eigen/src/Sparse/SparseDot.h
extern/Eigen2/Eigen/src/Sparse/SparseFlagged.h
extern/Eigen2/Eigen/src/Sparse/SparseFuzzy.h
extern/Eigen2/Eigen/src/Sparse/SparseLDLT.h
extern/Eigen2/Eigen/src/Sparse/SparseLLT.h
extern/Eigen2/Eigen/src/Sparse/SparseLU.h
extern/Eigen2/Eigen/src/Sparse/SparseMatrix.h
extern/Eigen2/Eigen/src/Sparse/SparseMatrixBase.h
extern/Eigen2/Eigen/src/Sparse/SparseProduct.h
extern/Eigen2/Eigen/src/Sparse/SparseRedux.h
extern/Eigen2/Eigen/src/Sparse/SparseTranspose.h
extern/Eigen2/Eigen/src/Sparse/SparseUtil.h
extern/Eigen2/Eigen/src/Sparse/SparseVector.h
extern/Eigen2/Eigen/src/Sparse/SuperLUSupport.h
extern/Eigen2/Eigen/src/Sparse/TaucsSupport.h
extern/Eigen2/Eigen/src/Sparse/TriangularSolver.h
extern/Eigen2/Eigen/src/Sparse/UmfPackSupport.h
extern/Eigen2/eigen-update.sh
extern/glew/make/msvc_9_0/glew.vcproj
intern/CMakeLists.txt
intern/Makefile
intern/SConscript
intern/audaspace/make/msvc_9_0/audaspace.vcproj
intern/boolop/make/msvc_9_0/boolop.vcproj
intern/bsp/make/msvc_9_0/bsplib.vcproj
intern/container/make/msvc_9_0/container.vcproj
intern/decimation/make/msvc_9_0/decimation.vcproj
intern/elbeem/make/msvc_9_0/elbeem.vcproj
intern/ghost/intern/GHOST_System.cpp
intern/ghost/make/msvc_9_0/ghost.vcproj
intern/guardedalloc/make/msvc_9_0/guardedalloc.vcproj
intern/iksolver/make/msvc_9_0/iksolver.vcproj
intern/itasc/Armature.cpp
intern/itasc/Armature.hpp
intern/itasc/CMakeLists.txt
intern/itasc/Cache.cpp
intern/itasc/Cache.hpp
intern/itasc/ConstraintSet.cpp
intern/itasc/ConstraintSet.hpp
intern/itasc/ControlledObject.cpp
intern/itasc/ControlledObject.hpp
intern/itasc/CopyPose.cpp
intern/itasc/CopyPose.hpp
intern/itasc/Distance.cpp
intern/itasc/Distance.hpp
intern/itasc/FixedObject.cpp
intern/itasc/FixedObject.hpp
intern/itasc/Makefile
intern/itasc/MovingFrame.cpp
intern/itasc/MovingFrame.hpp
intern/itasc/Object.hpp
intern/itasc/SConscript
intern/itasc/Scene.cpp
intern/itasc/Scene.hpp
intern/itasc/Solver.hpp
intern/itasc/UncontrolledObject.cpp
intern/itasc/UncontrolledObject.hpp
intern/itasc/WDLSSolver.cpp
intern/itasc/WDLSSolver.hpp
intern/itasc/WSDLSSolver.cpp
intern/itasc/WSDLSSolver.hpp
intern/itasc/WorldObject.cpp
intern/itasc/WorldObject.hpp
intern/itasc/eigen_types.cpp
intern/itasc/eigen_types.hpp
intern/itasc/kdl/Makefile
intern/itasc/kdl/chain.cpp
intern/itasc/kdl/chain.hpp
intern/itasc/kdl/chainfksolver.hpp
intern/itasc/kdl/chainfksolverpos_recursive.cpp
intern/itasc/kdl/chainfksolverpos_recursive.hpp
intern/itasc/kdl/chainjnttojacsolver.cpp
intern/itasc/kdl/chainjnttojacsolver.hpp
intern/itasc/kdl/frameacc.cpp
intern/itasc/kdl/frameacc.hpp
intern/itasc/kdl/frameacc.inl
intern/itasc/kdl/frames.cpp
intern/itasc/kdl/frames.hpp
intern/itasc/kdl/frames.inl
intern/itasc/kdl/frames_io.cpp
intern/itasc/kdl/frames_io.hpp
intern/itasc/kdl/framevel.cpp
intern/itasc/kdl/framevel.hpp
intern/itasc/kdl/framevel.inl
intern/itasc/kdl/inertia.cpp
intern/itasc/kdl/inertia.hpp
intern/itasc/kdl/jacobian.cpp
intern/itasc/kdl/jacobian.hpp
intern/itasc/kdl/jntarray.cpp
intern/itasc/kdl/jntarray.hpp
intern/itasc/kdl/jntarrayacc.cpp
intern/itasc/kdl/jntarrayacc.hpp
intern/itasc/kdl/jntarrayvel.cpp
intern/itasc/kdl/jntarrayvel.hpp
intern/itasc/kdl/joint.cpp
intern/itasc/kdl/joint.hpp
intern/itasc/kdl/kinfam_io.cpp
intern/itasc/kdl/kinfam_io.hpp
intern/itasc/kdl/segment.cpp
intern/itasc/kdl/segment.hpp
intern/itasc/kdl/tree.cpp
intern/itasc/kdl/tree.hpp
intern/itasc/kdl/treefksolver.hpp
intern/itasc/kdl/treefksolverpos_recursive.cpp
intern/itasc/kdl/treefksolverpos_recursive.hpp
intern/itasc/kdl/treejnttojacsolver.cpp
intern/itasc/kdl/treejnttojacsolver.hpp
intern/itasc/kdl/utilities/Makefile
intern/itasc/kdl/utilities/error.h
intern/itasc/kdl/utilities/error_stack.cpp
intern/itasc/kdl/utilities/error_stack.h
intern/itasc/kdl/utilities/kdl-config.h
intern/itasc/kdl/utilities/rall1d.h
intern/itasc/kdl/utilities/rall2d.h
intern/itasc/kdl/utilities/svd_eigen_HH.hpp
intern/itasc/kdl/utilities/traits.h
intern/itasc/kdl/utilities/utility.cpp
intern/itasc/kdl/utilities/utility.h
intern/itasc/kdl/utilities/utility_io.cpp
intern/itasc/kdl/utilities/utility_io.h
intern/itasc/make/msvc_9_0/itasc.vcproj
intern/itasc/ublas_types.hpp
intern/memutil/make/msvc_9_0/memutil.vcproj
intern/moto/make/msvc_9_0/moto.vcproj
intern/smoke/intern/WTURBULENCE.cpp
intern/smoke/make/msvc_9_0/smoke.vcproj
intern/string/make/msvc_9_0/string.vcproj
projectfiles_vc9/blender/BLO_readblenfile/BLO_readblenfile.vcproj
projectfiles_vc9/blender/BPY_python/BPY_python.vcproj
projectfiles_vc9/blender/avi/BL_avi.vcproj
projectfiles_vc9/blender/blender.sln
projectfiles_vc9/blender/blender.vcproj
projectfiles_vc9/blender/blenfont/BLF_blenfont.vcproj
projectfiles_vc9/blender/blenkernel/BKE_blenkernel.vcproj
projectfiles_vc9/blender/blenlib/BLI_blenlib.vcproj
projectfiles_vc9/blender/blenpluginapi/blenpluginapi/blenpluginapi.vcproj
projectfiles_vc9/blender/editors/ED_editors.vcproj
projectfiles_vc9/blender/gpu/BL_gpu.vcproj
projectfiles_vc9/blender/ikplugin/BIK_ikplugin.vcproj
projectfiles_vc9/blender/imbuf/BL_imbuf.vcproj
projectfiles_vc9/blender/loader/BLO_loader.vcproj
projectfiles_vc9/blender/makesdna/DNA_makesdna.vcproj
projectfiles_vc9/blender/makesrna/RNA_makesrna.vcproj
projectfiles_vc9/blender/makesrna/RNA_rna.vcproj
projectfiles_vc9/blender/nodes/nodes.vcproj
projectfiles_vc9/blender/render/BRE_render.vcproj
projectfiles_vc9/gameengine/blenderhook/KX_blenderhook.vcproj
projectfiles_vc9/gameengine/converter/KX_converter.vcproj
projectfiles_vc9/gameengine/expression/EXP_expressions.vcproj
projectfiles_vc9/gameengine/gamelogic/SCA_GameLogic.vcproj
projectfiles_vc9/gameengine/gameplayer/axctl/GP_axctl.vcproj
projectfiles_vc9/gameengine/gameplayer/common/GP_common.vcproj
projectfiles_vc9/gameengine/gameplayer/ghost/GP_ghost.vcproj
projectfiles_vc9/gameengine/ketsji/KX_ketsji.vcproj
projectfiles_vc9/gameengine/ketsji/network/KX_network.vcproj
projectfiles_vc9/gameengine/network/loopbacknetwork/NG_loopbacknetwork.vcproj
projectfiles_vc9/gameengine/network/network/NG_network.vcproj
projectfiles_vc9/gameengine/physics/PHY_Physics/PHY_Bullet/PHY_Bullet.vcproj
projectfiles_vc9/gameengine/physics/PHY_Physics/PHY_Dummy/PHY_Dummy.vcproj
projectfiles_vc9/gameengine/physics/PHY_Physics/PHY_Ode/PHY_Ode.vcproj
projectfiles_vc9/gameengine/physics/PHY_Physics/PHY_Physics.vcproj
projectfiles_vc9/gameengine/rasterizer/RAS_rasterizer.vcproj
projectfiles_vc9/gameengine/rasterizer/openglrasterizer/RAS_openglrasterizer.vcproj
projectfiles_vc9/gameengine/scenegraph/SG_SceneGraph.vcproj
projectfiles_vc9/gameengine/videotexture/TEX_Video.vcproj
projectfiles_vc9/kernel/gen_messaging/gen_messaging.vcproj
projectfiles_vc9/kernel/system/SYS_system.vcproj
release/ui/buttons_data_bone.py
release/ui/buttons_object_constraint.py
source/blender/CMakeLists.txt
source/blender/Makefile
source/blender/SConscript
source/blender/blenkernel/BKE_action.h
source/blender/blenkernel/BKE_armature.h
source/blender/blenkernel/BKE_constraint.h
source/blender/blenkernel/CMakeLists.txt
source/blender/blenkernel/SConscript
source/blender/blenkernel/intern/Makefile
source/blender/blenkernel/intern/action.c
source/blender/blenkernel/intern/armature.c
source/blender/blenkernel/intern/constraint.c
source/blender/blenkernel/intern/pointcache.c
source/blender/blenkernel/intern/sca.c
source/blender/blenlib/BLI_ghash.h
source/blender/blenloader/intern/readfile.c
source/blender/blenloader/intern/writefile.c
source/blender/editors/CMakeLists.txt
source/blender/editors/armature/editarmature.c
source/blender/editors/armature/poseobject.c
source/blender/editors/include/ED_object.h
source/blender/editors/interface/interface_templates.c
source/blender/editors/object/Makefile
source/blender/editors/object/SConscript
source/blender/editors/object/object_constraint.c
source/blender/editors/space_logic/logic_window.c
source/blender/ikplugin/BIK_api.h
source/blender/ikplugin/CMakeLists.txt
source/blender/ikplugin/Makefile
source/blender/ikplugin/SConscript
source/blender/ikplugin/intern/Makefile
source/blender/ikplugin/intern/ikplugin_api.c
source/blender/ikplugin/intern/ikplugin_api.h
source/blender/ikplugin/intern/iksolver_plugin.c
source/blender/ikplugin/intern/iksolver_plugin.h
source/blender/ikplugin/intern/itasc_plugin.cpp
source/blender/ikplugin/intern/itasc_plugin.h
source/blender/makesdna/DNA_action_types.h
source/blender/makesdna/DNA_actuator_types.h
source/blender/makesdna/DNA_constraint_types.h
source/blender/makesdna/DNA_sensor_types.h
source/blender/makesrna/RNA_access.h
source/blender/makesrna/SConscript
source/blender/makesrna/intern/CMakeLists.txt
source/blender/makesrna/intern/Makefile
source/blender/makesrna/intern/SConscript
source/blender/makesrna/intern/rna_actuator.c
source/blender/makesrna/intern/rna_constraint.c
source/blender/makesrna/intern/rna_pose.c
source/blender/makesrna/intern/rna_sensor.c
source/gameengine/Converter/BL_ActionActuator.cpp
source/gameengine/Converter/BL_ActionActuator.h
source/gameengine/Converter/BL_ArmatureActuator.cpp
source/gameengine/Converter/BL_ArmatureActuator.h
source/gameengine/Converter/BL_ArmatureChannel.cpp
source/gameengine/Converter/BL_ArmatureChannel.h
source/gameengine/Converter/BL_ArmatureConstraint.cpp
source/gameengine/Converter/BL_ArmatureConstraint.h
source/gameengine/Converter/BL_ArmatureObject.cpp
source/gameengine/Converter/BL_ArmatureObject.h
source/gameengine/Converter/BL_BlenderDataConversion.cpp
source/gameengine/Converter/BL_ShapeActionActuator.h
source/gameengine/Converter/CMakeLists.txt
source/gameengine/Converter/KX_ConvertActuators.cpp
source/gameengine/Converter/KX_ConvertSensors.cpp
source/gameengine/Converter/Makefile
source/gameengine/Converter/SConscript
source/gameengine/Expressions/CMakeLists.txt
source/gameengine/Expressions/PyObjectPlus.cpp
source/gameengine/Expressions/PyObjectPlus.h
source/gameengine/Expressions/SConscript
source/gameengine/GameLogic/SCA_2DFilterActuator.cpp
source/gameengine/GameLogic/SCA_BasicEventManager.cpp
source/gameengine/GameLogic/SCA_BasicEventManager.h
source/gameengine/GameLogic/SCA_EventManager.h
source/gameengine/GameLogic/SCA_IActuator.cpp
source/gameengine/GameLogic/SCA_IActuator.h
source/gameengine/GameLogic/SCA_IObject.cpp
source/gameengine/GameLogic/SCA_IObject.h
source/gameengine/GameLogic/SCA_PropertyActuator.cpp
source/gameengine/GameLogic/SCA_RandomActuator.cpp
source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageActuator.cpp
source/gameengine/Ketsji/KX_ArmatureSensor.cpp
source/gameengine/Ketsji/KX_ArmatureSensor.h
source/gameengine/Ketsji/KX_CameraActuator.cpp
source/gameengine/Ketsji/KX_ConstraintActuator.cpp
source/gameengine/Ketsji/KX_GameActuator.cpp
source/gameengine/Ketsji/KX_GameObject.cpp
source/gameengine/Ketsji/KX_GameObject.h
source/gameengine/Ketsji/KX_IpoActuator.cpp
source/gameengine/Ketsji/KX_KetsjiEngine.cpp
source/gameengine/Ketsji/KX_KetsjiEngine.h
source/gameengine/Ketsji/KX_ObjectActuator.cpp
source/gameengine/Ketsji/KX_ParentActuator.cpp
source/gameengine/Ketsji/KX_PythonInit.cpp
source/gameengine/Ketsji/KX_PythonInitTypes.cpp
source/gameengine/Ketsji/KX_PythonSeq.cpp
source/gameengine/Ketsji/KX_PythonSeq.h
source/gameengine/Ketsji/KX_SCA_AddObjectActuator.cpp
source/gameengine/Ketsji/KX_SCA_DynamicActuator.cpp
source/gameengine/Ketsji/KX_SCA_EndObjectActuator.cpp
source/gameengine/Ketsji/KX_SCA_ReplaceMeshActuator.cpp
source/gameengine/Ketsji/KX_Scene.cpp
source/gameengine/Ketsji/KX_SceneActuator.cpp
source/gameengine/Ketsji/KX_SoundActuator.cpp
source/gameengine/Ketsji/KX_StateActuator.cpp
source/gameengine/Ketsji/KX_TrackToActuator.cpp
source/gameengine/Ketsji/KX_VisibilityActuator.cpp
source/gameengine/PyDoc/GameTypes.py
source/gameengine/SceneGraph/SG_DList.h

index 0000000,0000000..c847f95
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,39 @@@
++#ifndef EIGEN_ARRAY_MODULE_H
++#define EIGEN_ARRAY_MODULE_H
++
++#include "Core"
++
++#include "src/Core/util/DisableMSVCWarnings.h"
++
++namespace Eigen {
++
++/** \defgroup Array_Module Array module
++  * This module provides several handy features to manipulate matrices as simple array of values.
++  * In addition to listed classes, it defines various methods of the Cwise interface
++  * (accessible from MatrixBase::cwise()), including:
++  *  - matrix-scalar sum,
++  *  - coeff-wise comparison operators,
++  *  - sin, cos, sqrt, pow, exp, log, square, cube, inverse (reciprocal).
++  *
++  * This module also provides various MatrixBase methods, including:
++  *  - \ref MatrixBase::all() "all", \ref MatrixBase::any() "any",
++  *  - \ref MatrixBase::Random() "random matrix initialization"
++  *
++  * \code
++  * #include <Eigen/Array>
++  * \endcode
++  */
++
++#include "src/Array/CwiseOperators.h"
++#include "src/Array/Functors.h"
++#include "src/Array/BooleanRedux.h"
++#include "src/Array/Select.h"
++#include "src/Array/PartialRedux.h"
++#include "src/Array/Random.h"
++#include "src/Array/Norms.h"
++
++} // namespace Eigen
++
++#include "src/Core/util/EnableMSVCWarnings.h"
++
++#endif // EIGEN_ARRAY_MODULE_H
index 0000000,0000000..f1806f7
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,65 @@@
++#ifndef EIGEN_CHOLESKY_MODULE_H
++#define EIGEN_CHOLESKY_MODULE_H
++
++#include "Core"
++
++#include "src/Core/util/DisableMSVCWarnings.h"
++
++// Note that EIGEN_HIDE_HEAVY_CODE has to be defined per module
++#if (defined EIGEN_EXTERN_INSTANTIATIONS) && (EIGEN_EXTERN_INSTANTIATIONS>=2)
++  #ifndef EIGEN_HIDE_HEAVY_CODE
++  #define EIGEN_HIDE_HEAVY_CODE
++  #endif
++#elif defined EIGEN_HIDE_HEAVY_CODE
++  #undef EIGEN_HIDE_HEAVY_CODE
++#endif
++
++namespace Eigen {
++
++/** \defgroup Cholesky_Module Cholesky module
++  *
++  * \nonstableyet
++  *
++  * This module provides two variants of the Cholesky decomposition for selfadjoint (hermitian) matrices.
++  * Those decompositions are accessible via the following MatrixBase methods:
++  *  - MatrixBase::llt(),
++  *  - MatrixBase::ldlt()
++  *
++  * \code
++  * #include <Eigen/Cholesky>
++  * \endcode
++  */
++
++#include "src/Array/CwiseOperators.h"
++#include "src/Array/Functors.h"
++#include "src/Cholesky/LLT.h"
++#include "src/Cholesky/LDLT.h"
++
++} // namespace Eigen
++
++#define EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(MATRIXTYPE,PREFIX) \
++  PREFIX template class LLT<MATRIXTYPE>; \
++  PREFIX template class LDLT<MATRIXTYPE>
++
++#define EIGEN_CHOLESKY_MODULE_INSTANTIATE(PREFIX) \
++  EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(Matrix2f,PREFIX); \
++  EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(Matrix2d,PREFIX); \
++  EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(Matrix3f,PREFIX); \
++  EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(Matrix3d,PREFIX); \
++  EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(Matrix4f,PREFIX); \
++  EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(Matrix4d,PREFIX); \
++  EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(MatrixXf,PREFIX); \
++  EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(MatrixXd,PREFIX); \
++  EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(MatrixXcf,PREFIX); \
++  EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(MatrixXcd,PREFIX)
++
++#ifdef EIGEN_EXTERN_INSTANTIATIONS
++
++namespace Eigen {
++  EIGEN_CHOLESKY_MODULE_INSTANTIATE(extern);
++} // namespace Eigen
++#endif
++
++#include "src/Core/util/EnableMSVCWarnings.h"
++
++#endif // EIGEN_CHOLESKY_MODULE_H
index 0000000,0000000..f5e315a
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,154 @@@
++#ifndef EIGEN_CORE_H
++#define EIGEN_CORE_H
++
++// first thing Eigen does: prevent MSVC from committing suicide
++#include "src/Core/util/DisableMSVCWarnings.h"
++
++#ifdef _MSC_VER
++  #include <malloc.h> // for _aligned_malloc -- need it regardless of whether vectorization is enabled
++  #if (_MSC_VER >= 1500) // 2008 or later
++    // Remember that usage of defined() in a #define is undefined by the standard.
++    // a user reported that in 64-bit mode, MSVC doesn't care to define _M_IX86_FP.
++    #if (defined(_M_IX86_FP) && (_M_IX86_FP >= 2)) || defined(_M_X64)
++      #define EIGEN_SSE2_ON_MSVC_2008_OR_LATER
++    #endif   
++  #endif
++#endif
++
++#ifdef __GNUC__
++  #define EIGEN_GNUC_AT_LEAST(x,y) ((__GNUC__>=x && __GNUC_MINOR__>=y) || __GNUC__>x)
++#else
++  #define EIGEN_GNUC_AT_LEAST(x,y) 0
++#endif
++
++// Remember that usage of defined() in a #define is undefined by the standard
++#if (defined __SSE2__) && ( (!defined __GNUC__) || EIGEN_GNUC_AT_LEAST(4,2) )
++  #define EIGEN_SSE2_BUT_NOT_OLD_GCC
++#endif
++
++#ifndef EIGEN_DONT_VECTORIZE
++  #if defined (EIGEN_SSE2_BUT_NOT_OLD_GCC) || defined(EIGEN_SSE2_ON_MSVC_2008_OR_LATER)
++    #define EIGEN_VECTORIZE
++    #define EIGEN_VECTORIZE_SSE
++    #include <emmintrin.h>
++    #include <xmmintrin.h>
++    #ifdef __SSE3__
++      #include <pmmintrin.h>
++    #endif
++    #ifdef __SSSE3__
++      #include <tmmintrin.h>
++    #endif
++  #elif defined __ALTIVEC__
++    #define EIGEN_VECTORIZE
++    #define EIGEN_VECTORIZE_ALTIVEC
++    #include <altivec.h>
++    // We need to #undef all these ugly tokens defined in <altivec.h>
++    // => use __vector instead of vector
++    #undef bool
++    #undef vector
++    #undef pixel
++  #endif
++#endif
++
++#include <cstdlib>
++#include <cmath>
++#include <complex>
++#include <cassert>
++#include <functional>
++#include <iostream>
++#include <cstring>
++#include <string>
++#include <limits>
++
++#if (defined(_CPPUNWIND) || defined(__EXCEPTIONS)) && !defined(EIGEN_NO_EXCEPTIONS)
++  #define EIGEN_EXCEPTIONS
++#endif
++
++#ifdef EIGEN_EXCEPTIONS
++  #include <new>
++#endif
++
++// this needs to be done after all possible windows C header includes and before any Eigen source includes
++// (system C++ includes are supposed to be able to deal with this already):
++// windows.h defines min and max macros which would make Eigen fail to compile.
++#if defined(min) || defined(max)
++#error The preprocessor symbols 'min' or 'max' are defined. If you are compiling on Windows, do #define NOMINMAX to prevent windows.h from defining these symbols.
++#endif
++
++namespace Eigen {
++
++/** \defgroup Core_Module Core module
++  * This is the main module of Eigen providing dense matrix and vector support
++  * (both fixed and dynamic size) with all the features corresponding to a BLAS library
++  * and much more...
++  *
++  * \code
++  * #include <Eigen/Core>
++  * \endcode
++  */
++
++#include "src/Core/util/Macros.h"
++#include "src/Core/util/Constants.h"
++#include "src/Core/util/ForwardDeclarations.h"
++#include "src/Core/util/Meta.h"
++#include "src/Core/util/XprHelper.h"
++#include "src/Core/util/StaticAssert.h"
++#include "src/Core/util/Memory.h"
++
++#include "src/Core/NumTraits.h"
++#include "src/Core/MathFunctions.h"
++#include "src/Core/GenericPacketMath.h"
++
++#if defined EIGEN_VECTORIZE_SSE
++  #include "src/Core/arch/SSE/PacketMath.h"
++#elif defined EIGEN_VECTORIZE_ALTIVEC
++  #include "src/Core/arch/AltiVec/PacketMath.h"
++#endif
++
++#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
++#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 16
++#endif
++
++#include "src/Core/Functors.h"
++#include "src/Core/MatrixBase.h"
++#include "src/Core/Coeffs.h"
++
++#ifndef EIGEN_PARSED_BY_DOXYGEN // work around Doxygen bug triggered by Assign.h r814874
++                                // at least confirmed with Doxygen 1.5.5 and 1.5.6
++  #include "src/Core/Assign.h"
++#endif
++
++#include "src/Core/MatrixStorage.h"
++#include "src/Core/NestByValue.h"
++#include "src/Core/Flagged.h"
++#include "src/Core/Matrix.h"
++#include "src/Core/Cwise.h"
++#include "src/Core/CwiseBinaryOp.h"
++#include "src/Core/CwiseUnaryOp.h"
++#include "src/Core/CwiseNullaryOp.h"
++#include "src/Core/Dot.h"
++#include "src/Core/Product.h"
++#include "src/Core/DiagonalProduct.h"
++#include "src/Core/SolveTriangular.h"
++#include "src/Core/MapBase.h"
++#include "src/Core/Map.h"
++#include "src/Core/Block.h"
++#include "src/Core/Minor.h"
++#include "src/Core/Transpose.h"
++#include "src/Core/DiagonalMatrix.h"
++#include "src/Core/DiagonalCoeffs.h"
++#include "src/Core/Sum.h"
++#include "src/Core/Redux.h"
++#include "src/Core/Visitor.h"
++#include "src/Core/Fuzzy.h"
++#include "src/Core/IO.h"
++#include "src/Core/Swap.h"
++#include "src/Core/CommaInitializer.h"
++#include "src/Core/Part.h"
++#include "src/Core/CacheFriendlyProduct.h"
++
++} // namespace Eigen
++
++#include "src/Core/util/EnableMSVCWarnings.h"
++
++#endif // EIGEN_CORE_H
index 0000000,0000000..9655edc
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,8 @@@
++#include "Core"
++#include "Array"
++#include "LU"
++#include "Cholesky"
++#include "QR"
++#include "SVD"
++#include "Geometry"
++#include "LeastSquares"
index 0000000,0000000..654c8dc
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,2 @@@
++#include "Dense"
++#include "Sparse"
index 0000000,0000000..617b25e
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,51 @@@
++#ifndef EIGEN_GEOMETRY_MODULE_H
++#define EIGEN_GEOMETRY_MODULE_H
++
++#include "Core"
++
++#include "src/Core/util/DisableMSVCWarnings.h"
++
++#include "Array"
++#include <limits>
++
++#ifndef M_PI
++#define M_PI 3.14159265358979323846
++#endif
++
++namespace Eigen {
++
++/** \defgroup Geometry_Module Geometry module
++  *
++  * \nonstableyet
++  *
++  * This module provides support for:
++  *  - fixed-size homogeneous transformations
++  *  - translation, scaling, 2D and 3D rotations
++  *  - quaternions
++  *  - \ref MatrixBase::cross() "cross product"
++  *  - \ref MatrixBase::unitOrthogonal() "orthognal vector generation"
++  *  - some linear components: parametrized-lines and hyperplanes
++  *
++  * \code
++  * #include <Eigen/Geometry>
++  * \endcode
++  */
++
++#include "src/Geometry/OrthoMethods.h"
++#include "src/Geometry/RotationBase.h"
++#include "src/Geometry/Rotation2D.h"
++#include "src/Geometry/Quaternion.h"
++#include "src/Geometry/AngleAxis.h"
++#include "src/Geometry/EulerAngles.h"
++#include "src/Geometry/Transform.h"
++#include "src/Geometry/Translation.h"
++#include "src/Geometry/Scaling.h"
++#include "src/Geometry/Hyperplane.h"
++#include "src/Geometry/ParametrizedLine.h"
++#include "src/Geometry/AlignedBox.h"
++
++} // namespace Eigen
++
++#include "src/Core/util/EnableMSVCWarnings.h"
++
++#endif // EIGEN_GEOMETRY_MODULE_H
index 0000000,0000000..0ce6945
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,29 @@@
++#ifndef EIGEN_LU_MODULE_H
++#define EIGEN_LU_MODULE_H
++
++#include "Core"
++
++#include "src/Core/util/DisableMSVCWarnings.h"
++
++namespace Eigen {
++
++/** \defgroup LU_Module LU module
++  * This module includes %LU decomposition and related notions such as matrix inversion and determinant.
++  * This module defines the following MatrixBase methods:
++  *  - MatrixBase::inverse()
++  *  - MatrixBase::determinant()
++  *
++  * \code
++  * #include <Eigen/LU>
++  * \endcode
++  */
++
++#include "src/LU/LU.h"
++#include "src/LU/Determinant.h"
++#include "src/LU/Inverse.h"
++
++} // namespace Eigen
++
++#include "src/Core/util/EnableMSVCWarnings.h"
++
++#endif // EIGEN_LU_MODULE_H
index 0000000,0000000..573a13c
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,27 @@@
++#ifndef EIGEN_REGRESSION_MODULE_H
++#define EIGEN_REGRESSION_MODULE_H
++
++#include "Core"
++
++#include "src/Core/util/DisableMSVCWarnings.h"
++
++#include "QR"
++#include "Geometry"
++
++namespace Eigen {
++
++/** \defgroup LeastSquares_Module LeastSquares module
++  * This module provides linear regression and related features.
++  *
++  * \code
++  * #include <Eigen/LeastSquares>
++  * \endcode
++  */
++
++#include "src/LeastSquares/LeastSquares.h"
++
++} // namespace Eigen
++
++#include "src/Core/util/EnableMSVCWarnings.h"
++
++#endif // EIGEN_REGRESSION_MODULE_H
index 0000000,0000000..f37de5f
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,168 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra.
++//
++// Copyright (C) 2009 Gael Guennebaud <g.gael@free.fr>
++// Copyright (C) 2009 Hauke Heibel <hauke.heibel@googlemail.com>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifndef EIGEN_STDVECTOR_MODULE_H
++#define EIGEN_STDVECTOR_MODULE_H
++
++#include "Core"
++#include <vector>
++
++namespace Eigen {
++
++// This one is needed to prevent reimplementing the whole std::vector.
++template <class T>
++class aligned_allocator_indirection : public aligned_allocator<T>
++{
++public:
++  typedef size_t    size_type;
++  typedef ptrdiff_t difference_type;
++  typedef T*        pointer;
++  typedef const T*  const_pointer;
++  typedef T&        reference;
++  typedef const T&  const_reference;
++  typedef T         value_type;
++
++  template<class U>
++  struct rebind
++  {
++    typedef aligned_allocator_indirection<U> other;
++  };
++
++  aligned_allocator_indirection() throw() {}
++  aligned_allocator_indirection(const aligned_allocator_indirection& ) throw() : aligned_allocator<T>() {}
++  aligned_allocator_indirection(const aligned_allocator<T>& ) throw() {}
++  template<class U>
++  aligned_allocator_indirection(const aligned_allocator_indirection<U>& ) throw() {}
++  template<class U>
++  aligned_allocator_indirection(const aligned_allocator<U>& ) throw() {}
++  ~aligned_allocator_indirection() throw() {}
++};
++
++#ifdef _MSC_VER
++
++  // sometimes, MSVC detects, at compile time, that the argument x
++  // in std::vector::resize(size_t s,T x) won't be aligned and generate an error
++  // even if this function is never called. Whence this little wrapper.
++  #define EIGEN_WORKAROUND_MSVC_STD_VECTOR(T) Eigen::ei_workaround_msvc_std_vector<T>
++  template<typename T> struct ei_workaround_msvc_std_vector : public T
++  {
++    inline ei_workaround_msvc_std_vector() : T() {}
++    inline ei_workaround_msvc_std_vector(const T& other) : T(other) {}
++    inline operator T& () { return *static_cast<T*>(this); }
++    inline operator const T& () const { return *static_cast<const T*>(this); }
++    template<typename OtherT>
++    inline T& operator=(const OtherT& other)
++    { T::operator=(other); return *this; }
++    inline ei_workaround_msvc_std_vector& operator=(const ei_workaround_msvc_std_vector& other)
++    { T::operator=(other); return *this; }
++  };
++
++#else
++
++  #define EIGEN_WORKAROUND_MSVC_STD_VECTOR(T) T
++
++#endif
++
++}
++
++namespace std {
++
++#define EIGEN_STD_VECTOR_SPECIALIZATION_BODY \
++  public:  \
++    typedef T value_type; \
++    typedef typename vector_base::allocator_type allocator_type; \
++    typedef typename vector_base::size_type size_type;  \
++    typedef typename vector_base::iterator iterator;  \
++    typedef typename vector_base::const_iterator const_iterator;  \
++    explicit vector(const allocator_type& a = allocator_type()) : vector_base(a) {}  \
++    template<typename InputIterator> \
++    vector(InputIterator first, InputIterator last, const allocator_type& a = allocator_type()) \
++    : vector_base(first, last, a) {} \
++    vector(const vector& c) : vector_base(c) {}  \
++    explicit vector(size_type num, const value_type& val = value_type()) : vector_base(num, val) {} \
++    vector(iterator start, iterator end) : vector_base(start, end) {}  \
++    vector& operator=(const vector& x) {  \
++      vector_base::operator=(x);  \
++      return *this;  \
++    }
++
++template<typename T>
++class vector<T,Eigen::aligned_allocator<T> >
++  : public vector<EIGEN_WORKAROUND_MSVC_STD_VECTOR(T),
++                  Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STD_VECTOR(T)> >
++{
++  typedef vector<EIGEN_WORKAROUND_MSVC_STD_VECTOR(T),
++                 Eigen::aligned_allocator_indirection<EIGEN_WORKAROUND_MSVC_STD_VECTOR(T)> > vector_base;
++  EIGEN_STD_VECTOR_SPECIALIZATION_BODY
++
++  void resize(size_type new_size)
++  { resize(new_size, T()); }
++
++#if defined(_VECTOR_)
++  // workaround MSVC std::vector implementation
++  void resize(size_type new_size, const value_type& x)
++  {
++    if (vector_base::size() < new_size)
++      vector_base::_Insert_n(vector_base::end(), new_size - vector_base::size(), x);
++    else if (new_size < vector_base::size())
++      vector_base::erase(vector_base::begin() + new_size, vector_base::end());
++  }
++  void push_back(const value_type& x)
++  { vector_base::push_back(x); } 
++  using vector_base::insert;  
++  iterator insert(const_iterator position, const value_type& x)
++  { return vector_base::insert(position,x); }
++  void insert(const_iterator position, size_type new_size, const value_type& x)
++  { vector_base::insert(position, new_size, x); }
++#elif defined(_GLIBCXX_VECTOR) && EIGEN_GNUC_AT_LEAST(4,2)
++  // workaround GCC std::vector implementation
++  void resize(size_type new_size, const value_type& x)
++  {
++    if (new_size < vector_base::size())
++      vector_base::_M_erase_at_end(this->_M_impl._M_start + new_size);
++    else
++      vector_base::insert(vector_base::end(), new_size - vector_base::size(), x);
++  }
++#elif defined(_GLIBCXX_VECTOR) && (!EIGEN_GNUC_AT_LEAST(4,1))
++  // Note that before gcc-4.1 we already have: std::vector::resize(size_type,const T&),
++  // no no need to workaround !
++  using vector_base::resize;
++#else
++  // either GCC 4.1 or non-GCC
++  // default implementation which should always work.
++  void resize(size_type new_size, const value_type& x)
++  {
++    if (new_size < vector_base::size())
++      vector_base::erase(vector_base::begin() + new_size, vector_base::end());
++    else if (new_size > vector_base::size())
++      vector_base::insert(vector_base::end(), new_size - vector_base::size(), x);
++  }
++#endif
++
++};
++
++}
++
++#endif // EIGEN_STDVECTOR_MODULE_H
index 0000000,0000000..97907d1
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,73 @@@
++#ifndef EIGEN_QR_MODULE_H
++#define EIGEN_QR_MODULE_H
++
++#include "Core"
++
++#include "src/Core/util/DisableMSVCWarnings.h"
++
++#include "Cholesky"
++
++// Note that EIGEN_HIDE_HEAVY_CODE has to be defined per module
++#if (defined EIGEN_EXTERN_INSTANTIATIONS) && (EIGEN_EXTERN_INSTANTIATIONS>=2)
++  #ifndef EIGEN_HIDE_HEAVY_CODE
++  #define EIGEN_HIDE_HEAVY_CODE
++  #endif
++#elif defined EIGEN_HIDE_HEAVY_CODE
++  #undef EIGEN_HIDE_HEAVY_CODE
++#endif
++
++namespace Eigen {
++
++/** \defgroup QR_Module QR module
++  *
++  * \nonstableyet
++  *
++  * This module mainly provides QR decomposition and an eigen value solver.
++  * This module also provides some MatrixBase methods, including:
++  *  - MatrixBase::qr(),
++  *  - MatrixBase::eigenvalues(),
++  *  - MatrixBase::operatorNorm()
++  *
++  * \code
++  * #include <Eigen/QR>
++  * \endcode
++  */
++
++#include "src/QR/QR.h"
++#include "src/QR/Tridiagonalization.h"
++#include "src/QR/EigenSolver.h"
++#include "src/QR/SelfAdjointEigenSolver.h"
++#include "src/QR/HessenbergDecomposition.h"
++
++// declare all classes for a given matrix type
++#define EIGEN_QR_MODULE_INSTANTIATE_TYPE(MATRIXTYPE,PREFIX) \
++  PREFIX template class QR<MATRIXTYPE>; \
++  PREFIX template class Tridiagonalization<MATRIXTYPE>; \
++  PREFIX template class HessenbergDecomposition<MATRIXTYPE>; \
++  PREFIX template class SelfAdjointEigenSolver<MATRIXTYPE>
++
++// removed because it does not support complex yet
++//  PREFIX template class EigenSolver<MATRIXTYPE>
++
++// declare all class for all types
++#define EIGEN_QR_MODULE_INSTANTIATE(PREFIX) \
++  EIGEN_QR_MODULE_INSTANTIATE_TYPE(Matrix2f,PREFIX); \
++  EIGEN_QR_MODULE_INSTANTIATE_TYPE(Matrix2d,PREFIX); \
++  EIGEN_QR_MODULE_INSTANTIATE_TYPE(Matrix3f,PREFIX); \
++  EIGEN_QR_MODULE_INSTANTIATE_TYPE(Matrix3d,PREFIX); \
++  EIGEN_QR_MODULE_INSTANTIATE_TYPE(Matrix4f,PREFIX); \
++  EIGEN_QR_MODULE_INSTANTIATE_TYPE(Matrix4d,PREFIX); \
++  EIGEN_QR_MODULE_INSTANTIATE_TYPE(MatrixXf,PREFIX); \
++  EIGEN_QR_MODULE_INSTANTIATE_TYPE(MatrixXd,PREFIX); \
++  EIGEN_QR_MODULE_INSTANTIATE_TYPE(MatrixXcf,PREFIX); \
++  EIGEN_QR_MODULE_INSTANTIATE_TYPE(MatrixXcd,PREFIX)
++
++#ifdef EIGEN_EXTERN_INSTANTIATIONS
++  EIGEN_QR_MODULE_INSTANTIATE(extern);
++#endif // EIGEN_EXTERN_INSTANTIATIONS
++
++} // namespace Eigen
++
++#include "src/Core/util/EnableMSVCWarnings.h"
++
++#endif // EIGEN_QR_MODULE_H
index 0000000,0000000..fde2273
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,29 @@@
++
++#ifndef EIGEN_QTMALLOC_MODULE_H
++#define EIGEN_QTMALLOC_MODULE_H
++
++#include "Core"
++
++#if (!EIGEN_MALLOC_ALREADY_ALIGNED)
++
++inline void *qMalloc(size_t size)
++{
++  return Eigen::ei_aligned_malloc(size);
++}
++
++inline void qFree(void *ptr)
++{
++  Eigen::ei_aligned_free(ptr);
++}
++
++inline void *qRealloc(void *ptr, size_t size)
++{
++  void* newPtr = Eigen::ei_aligned_malloc(size);
++  memcpy(newPtr, ptr, size);
++  Eigen::ei_aligned_free(ptr);
++  return newPtr;
++}
++
++#endif
++
++#endif // EIGEN_QTMALLOC_MODULE_H
index 0000000,0000000..eef0556
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,29 @@@
++#ifndef EIGEN_SVD_MODULE_H
++#define EIGEN_SVD_MODULE_H
++
++#include "Core"
++
++#include "src/Core/util/DisableMSVCWarnings.h"
++
++namespace Eigen {
++
++/** \defgroup SVD_Module SVD module
++  *
++  * \nonstableyet
++  *
++  * This module provides SVD decomposition for (currently) real matrices.
++  * This decomposition is accessible via the following MatrixBase method:
++  *  - MatrixBase::svd()
++  *
++  * \code
++  * #include <Eigen/SVD>
++  * \endcode
++  */
++
++#include "src/SVD/SVD.h"
++
++} // namespace Eigen
++
++#include "src/Core/util/EnableMSVCWarnings.h"
++
++#endif // EIGEN_SVD_MODULE_H
index 0000000,0000000..536c284
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,132 @@@
++#ifndef EIGEN_SPARSE_MODULE_H
++#define EIGEN_SPARSE_MODULE_H
++
++#include "Core"
++
++#include "src/Core/util/DisableMSVCWarnings.h"
++
++#include <vector>
++#include <map>
++#include <cstdlib>
++#include <cstring>
++#include <algorithm>
++
++#ifdef EIGEN_GOOGLEHASH_SUPPORT
++  #include <google/dense_hash_map>
++#endif
++
++#ifdef EIGEN_CHOLMOD_SUPPORT
++  extern "C" {
++    #include "cholmod.h"
++  }
++#endif
++
++#ifdef EIGEN_TAUCS_SUPPORT
++  // taucs.h declares a lot of mess
++  #define isnan
++  #define finite
++  #define isinf
++  extern "C" {
++    #include "taucs.h"
++  }
++  #undef isnan
++  #undef finite
++  #undef isinf
++
++  #ifdef min
++    #undef min
++  #endif
++  #ifdef max
++    #undef max
++  #endif
++  #ifdef complex
++    #undef complex
++  #endif
++#endif
++
++#ifdef EIGEN_SUPERLU_SUPPORT
++  typedef int int_t;
++  #include "superlu/slu_Cnames.h"
++  #include "superlu/supermatrix.h"
++  #include "superlu/slu_util.h"
++
++  namespace SuperLU_S {
++  #include "superlu/slu_sdefs.h"
++  }
++  namespace SuperLU_D {
++  #include "superlu/slu_ddefs.h"
++  }
++  namespace SuperLU_C {
++  #include "superlu/slu_cdefs.h"
++  }
++  namespace SuperLU_Z {
++  #include "superlu/slu_zdefs.h"
++  }
++  namespace Eigen { struct SluMatrix; }
++#endif
++
++#ifdef EIGEN_UMFPACK_SUPPORT
++  #include "umfpack.h"
++#endif
++
++namespace Eigen {
++
++/** \defgroup Sparse_Module Sparse module
++  *
++  * \nonstableyet
++  *
++  * See the \ref TutorialSparse "Sparse tutorial"
++  *
++  * \code
++  * #include <Eigen/QR>
++  * \endcode
++  */
++
++#include "src/Sparse/SparseUtil.h"
++#include "src/Sparse/SparseMatrixBase.h"
++#include "src/Sparse/CompressedStorage.h"
++#include "src/Sparse/AmbiVector.h"
++#include "src/Sparse/RandomSetter.h"
++#include "src/Sparse/SparseBlock.h"
++#include "src/Sparse/SparseMatrix.h"
++#include "src/Sparse/DynamicSparseMatrix.h"
++#include "src/Sparse/MappedSparseMatrix.h"
++#include "src/Sparse/SparseVector.h"
++#include "src/Sparse/CoreIterators.h"
++#include "src/Sparse/SparseTranspose.h"
++#include "src/Sparse/SparseCwise.h"
++#include "src/Sparse/SparseCwiseUnaryOp.h"
++#include "src/Sparse/SparseCwiseBinaryOp.h"
++#include "src/Sparse/SparseDot.h"
++#include "src/Sparse/SparseAssign.h"
++#include "src/Sparse/SparseRedux.h"
++#include "src/Sparse/SparseFuzzy.h"
++#include "src/Sparse/SparseFlagged.h"
++#include "src/Sparse/SparseProduct.h"
++#include "src/Sparse/SparseDiagonalProduct.h"
++#include "src/Sparse/TriangularSolver.h"
++#include "src/Sparse/SparseLLT.h"
++#include "src/Sparse/SparseLDLT.h"
++#include "src/Sparse/SparseLU.h"
++
++#ifdef EIGEN_CHOLMOD_SUPPORT
++# include "src/Sparse/CholmodSupport.h"
++#endif
++
++#ifdef EIGEN_TAUCS_SUPPORT
++# include "src/Sparse/TaucsSupport.h"
++#endif
++
++#ifdef EIGEN_SUPERLU_SUPPORT
++# include "src/Sparse/SuperLUSupport.h"
++#endif
++
++#ifdef EIGEN_UMFPACK_SUPPORT
++# include "src/Sparse/UmfPackSupport.h"
++#endif
++
++} // namespace Eigen
++
++#include "src/Core/util/EnableMSVCWarnings.h"
++
++#endif // EIGEN_SPARSE_MODULE_H
index 0000000,0000000..c0744d6
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,147 @@@
++#ifdef EIGEN_USE_NEW_STDVECTOR
++#include "NewStdVector"
++#else
++
++#ifndef EIGEN_STDVECTOR_MODULE_H
++#define EIGEN_STDVECTOR_MODULE_H
++
++#if defined(_GLIBCXX_VECTOR) || defined(_VECTOR_)
++#error you must include <Eigen/StdVector> before <vector>. Also note that <Eigen/Sparse> includes <vector>, so it must be included after <Eigen/StdVector> too.
++#endif                                                    
++
++#ifndef EIGEN_GNUC_AT_LEAST
++#ifdef __GNUC__
++  #define EIGEN_GNUC_AT_LEAST(x,y) ((__GNUC__>=x && __GNUC_MINOR__>=y) || __GNUC__>x)
++#else
++  #define EIGEN_GNUC_AT_LEAST(x,y) 0
++#endif
++#endif
++
++#define vector std_vector
++#include <vector>        
++#undef vector
++
++namespace Eigen {
++
++template<typename T> class aligned_allocator;
++
++// meta programming to determine if a class has a given member
++struct ei_does_not_have_aligned_operator_new_marker_sizeof {int a[1];};
++struct ei_has_aligned_operator_new_marker_sizeof {int a[2];};
++
++template<typename ClassType>
++struct ei_has_aligned_operator_new {
++    template<typename T>
++    static ei_has_aligned_operator_new_marker_sizeof
++    test(T const *, typename T::ei_operator_new_marker_type const * = 0);
++    static ei_does_not_have_aligned_operator_new_marker_sizeof
++    test(...);
++
++    // note that the following indirection is needed for gcc-3.3
++    enum {ret =  sizeof(test(static_cast<ClassType*>(0))) 
++              == sizeof(ei_has_aligned_operator_new_marker_sizeof) };
++};
++
++#ifdef _MSC_VER
++  
++  // sometimes, MSVC detects, at compile time, that the argument x
++  // in std::vector::resize(size_t s,T x) won't be aligned and generate an error
++  // even if this function is never called. Whence this little wrapper.
++  #define _EIGEN_WORKAROUND_MSVC_STD_VECTOR(T) Eigen::ei_workaround_msvc_std_vector<T>
++  template<typename T> struct ei_workaround_msvc_std_vector : public T
++  {
++    inline ei_workaround_msvc_std_vector() : T() {}
++    inline ei_workaround_msvc_std_vector(const T& other) : T(other) {}
++    inline operator T& () { return *static_cast<T*>(this); }
++    inline operator const T& () const { return *static_cast<const T*>(this); }
++    template<typename OtherT>
++    inline T& operator=(const OtherT& other)
++    { T::operator=(other); return *this; }
++    inline ei_workaround_msvc_std_vector& operator=(const ei_workaround_msvc_std_vector& other)
++    { T::operator=(other); return *this; }
++  };
++
++#else
++
++  #define _EIGEN_WORKAROUND_MSVC_STD_VECTOR(T) T
++
++#endif
++
++}
++
++namespace std {
++
++#define EIGEN_STD_VECTOR_SPECIALIZATION_BODY \
++  public:  \
++    typedef T value_type; \
++    typedef typename vector_base::allocator_type allocator_type; \
++    typedef typename vector_base::size_type size_type;  \
++    typedef typename vector_base::iterator iterator;  \
++    explicit vector(const allocator_type& __a = allocator_type()) : vector_base(__a) {}  \
++    vector(const vector& c) : vector_base(c) {}  \
++    vector(size_type num, const value_type& val = value_type()) : vector_base(num, val) {} \
++    vector(iterator start, iterator end) : vector_base(start, end) {}  \
++    vector& operator=(const vector& __x) {  \
++      vector_base::operator=(__x);  \
++      return *this;  \
++    }
++
++template<typename T,
++         typename AllocT = std::allocator<T>,
++         bool HasAlignedNew = Eigen::ei_has_aligned_operator_new<T>::ret>
++class vector : public std::std_vector<T,AllocT>
++{
++  typedef std_vector<T, AllocT> vector_base;
++  EIGEN_STD_VECTOR_SPECIALIZATION_BODY
++};
++
++template<typename T,typename DummyAlloc>
++class vector<T,DummyAlloc,true>
++  : public std::std_vector<_EIGEN_WORKAROUND_MSVC_STD_VECTOR(T),
++                           Eigen::aligned_allocator<_EIGEN_WORKAROUND_MSVC_STD_VECTOR(T)> >          
++{
++  typedef std_vector<_EIGEN_WORKAROUND_MSVC_STD_VECTOR(T),
++                     Eigen::aligned_allocator<_EIGEN_WORKAROUND_MSVC_STD_VECTOR(T)> > vector_base;
++  EIGEN_STD_VECTOR_SPECIALIZATION_BODY
++
++  void resize(size_type __new_size)
++  { resize(__new_size, T()); }     
++
++  #if defined(_VECTOR_)
++  // workaround MSVC std::vector implementation
++  void resize(size_type __new_size, const value_type& __x)                 
++  {                                                              
++    if (vector_base::size() < __new_size)                                 
++      vector_base::_Insert_n(vector_base::end(), __new_size - vector_base::size(), __x);
++    else if (__new_size < vector_base::size())
++      vector_base::erase(vector_base::begin() + __new_size, vector_base::end());
++  }
++  #elif defined(_GLIBCXX_VECTOR) && EIGEN_GNUC_AT_LEAST(4,2)
++  // workaround GCC std::vector implementation
++  void resize(size_type __new_size, const value_type& __x)
++  {                                              
++    if (__new_size < vector_base::size())               
++      vector_base::_M_erase_at_end(this->_M_impl._M_start + __new_size);
++    else                       
++      vector_base::insert(vector_base::end(), __new_size - vector_base::size(), __x); 
++  }                                                              
++  #elif defined(_GLIBCXX_VECTOR) && EIGEN_GNUC_AT_LEAST(4,1)
++  void resize(size_type __new_size, const value_type& __x)
++  {
++    if (__new_size < vector_base::size())
++      vector_base::erase(vector_base::begin() + __new_size, vector_base::end());
++    else
++      vector_base::insert(vector_base::end(), __new_size - vector_base::size(), __x);
++  }
++  #else
++  // Before gcc-4.1 we already have: std::vector::resize(size_type,const T&),
++  // so no need for a workaround !
++  using vector_base::resize;
++  #endif  
++};
++
++}
++
++#endif // EIGEN_STDVECTOR_MODULE_H
++
++#endif // EIGEN_USE_NEW_STDVECTOR
index 0000000,0000000..4e82183
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,145 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra. Eigen itself is part of the KDE project.
++//
++// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifndef EIGEN_ALLANDANY_H
++#define EIGEN_ALLANDANY_H
++
++template<typename Derived, int UnrollCount>
++struct ei_all_unroller
++{
++  enum {
++    col = (UnrollCount-1) / Derived::RowsAtCompileTime,
++    row = (UnrollCount-1) % Derived::RowsAtCompileTime
++  };
++
++  inline static bool run(const Derived &mat)
++  {
++    return ei_all_unroller<Derived, UnrollCount-1>::run(mat) && mat.coeff(row, col);
++  }
++};
++
++template<typename Derived>
++struct ei_all_unroller<Derived, 1>
++{
++  inline static bool run(const Derived &mat) { return mat.coeff(0, 0); }
++};
++
++template<typename Derived>
++struct ei_all_unroller<Derived, Dynamic>
++{
++  inline static bool run(const Derived &) { return false; }
++};
++
++template<typename Derived, int UnrollCount>
++struct ei_any_unroller
++{
++  enum {
++    col = (UnrollCount-1) / Derived::RowsAtCompileTime,
++    row = (UnrollCount-1) % Derived::RowsAtCompileTime
++  };
++
++  inline static bool run(const Derived &mat)
++  {
++    return ei_any_unroller<Derived, UnrollCount-1>::run(mat) || mat.coeff(row, col);
++  }
++};
++
++template<typename Derived>
++struct ei_any_unroller<Derived, 1>
++{
++  inline static bool run(const Derived &mat) { return mat.coeff(0, 0); }
++};
++
++template<typename Derived>
++struct ei_any_unroller<Derived, Dynamic>
++{
++  inline static bool run(const Derived &) { return false; }
++};
++
++/** \array_module
++  * 
++  * \returns true if all coefficients are true
++  *
++  * \addexample CwiseAll \label How to check whether a point is inside a box (using operator< and all())
++  *
++  * Example: \include MatrixBase_all.cpp
++  * Output: \verbinclude MatrixBase_all.out
++  *
++  * \sa MatrixBase::any(), Cwise::operator<()
++  */
++template<typename Derived>
++inline bool MatrixBase<Derived>::all() const
++{
++  const bool unroll = SizeAtCompileTime * (CoeffReadCost + NumTraits<Scalar>::AddCost)
++                      <= EIGEN_UNROLLING_LIMIT;
++  if(unroll)
++    return ei_all_unroller<Derived,
++                           unroll ? int(SizeAtCompileTime) : Dynamic
++     >::run(derived());
++  else
++  {
++    for(int j = 0; j < cols(); ++j)
++      for(int i = 0; i < rows(); ++i)
++        if (!coeff(i, j)) return false;
++    return true;
++  }
++}
++
++/** \array_module
++  * 
++  * \returns true if at least one coefficient is true
++  *
++  * \sa MatrixBase::all()
++  */
++template<typename Derived>
++inline bool MatrixBase<Derived>::any() const
++{
++  const bool unroll = SizeAtCompileTime * (CoeffReadCost + NumTraits<Scalar>::AddCost)
++                      <= EIGEN_UNROLLING_LIMIT;
++  if(unroll)
++    return ei_any_unroller<Derived,
++                           unroll ? int(SizeAtCompileTime) : Dynamic
++           >::run(derived());
++  else
++  {
++    for(int j = 0; j < cols(); ++j)
++      for(int i = 0; i < rows(); ++i)
++        if (coeff(i, j)) return true;
++    return false;
++  }
++}
++
++/** \array_module
++  * 
++  * \returns the number of coefficients which evaluate to true
++  *
++  * \sa MatrixBase::all(), MatrixBase::any()
++  */
++template<typename Derived>
++inline int MatrixBase<Derived>::count() const
++{
++  return this->cast<bool>().cast<int>().sum();
++}
++
++#endif // EIGEN_ALLANDANY_H
index 0000000,0000000..4b6346d
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,453 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra. Eigen itself is part of the KDE project.
++//
++// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifndef EIGEN_ARRAY_CWISE_OPERATORS_H
++#define EIGEN_ARRAY_CWISE_OPERATORS_H
++
++// -- unary operators --
++
++/** \array_module
++  * 
++  * \returns an expression of the coefficient-wise square root of *this.
++  *
++  * Example: \include Cwise_sqrt.cpp
++  * Output: \verbinclude Cwise_sqrt.out
++  *
++  * \sa pow(), square()
++  */
++template<typename ExpressionType>
++inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_sqrt_op)
++Cwise<ExpressionType>::sqrt() const
++{
++  return _expression();
++}
++
++/** \array_module
++  * 
++  * \returns an expression of the coefficient-wise exponential of *this.
++  *
++  * Example: \include Cwise_exp.cpp
++  * Output: \verbinclude Cwise_exp.out
++  *
++  * \sa pow(), log(), sin(), cos()
++  */
++template<typename ExpressionType>
++inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_exp_op)
++Cwise<ExpressionType>::exp() const
++{
++  return _expression();
++}
++
++/** \array_module
++  * 
++  * \returns an expression of the coefficient-wise logarithm of *this.
++  *
++  * Example: \include Cwise_log.cpp
++  * Output: \verbinclude Cwise_log.out
++  *
++  * \sa exp()
++  */
++template<typename ExpressionType>
++inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_log_op)
++Cwise<ExpressionType>::log() const
++{
++  return _expression();
++}
++
++/** \array_module
++  * 
++  * \returns an expression of the coefficient-wise cosine of *this.
++  *
++  * Example: \include Cwise_cos.cpp
++  * Output: \verbinclude Cwise_cos.out
++  *
++  * \sa sin(), exp()
++  */
++template<typename ExpressionType>
++inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_cos_op)
++Cwise<ExpressionType>::cos() const
++{
++  return _expression();
++}
++
++
++/** \array_module
++  * 
++  * \returns an expression of the coefficient-wise sine of *this.
++  *
++  * Example: \include Cwise_sin.cpp
++  * Output: \verbinclude Cwise_sin.out
++  *
++  * \sa cos(), exp()
++  */
++template<typename ExpressionType>
++inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_sin_op)
++Cwise<ExpressionType>::sin() const
++{
++  return _expression();
++}
++
++
++/** \array_module
++  * 
++  * \returns an expression of the coefficient-wise power of *this to the given exponent.
++  *
++  * Example: \include Cwise_pow.cpp
++  * Output: \verbinclude Cwise_pow.out
++  *
++  * \sa exp(), log()
++  */
++template<typename ExpressionType>
++inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_pow_op)
++Cwise<ExpressionType>::pow(const Scalar& exponent) const
++{
++  return EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_pow_op)(_expression(), ei_scalar_pow_op<Scalar>(exponent));
++}
++
++
++/** \array_module
++  * 
++  * \returns an expression of the coefficient-wise inverse of *this.
++  *
++  * Example: \include Cwise_inverse.cpp
++  * Output: \verbinclude Cwise_inverse.out
++  *
++  * \sa operator/(), operator*()
++  */
++template<typename ExpressionType>
++inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_inverse_op)
++Cwise<ExpressionType>::inverse() const
++{
++  return _expression();
++}
++
++/** \array_module
++  *
++  * \returns an expression of the coefficient-wise square of *this.
++  *
++  * Example: \include Cwise_square.cpp
++  * Output: \verbinclude Cwise_square.out
++  *
++  * \sa operator/(), operator*(), abs2()
++  */
++template<typename ExpressionType>
++inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_square_op)
++Cwise<ExpressionType>::square() const
++{
++  return _expression();
++}
++
++/** \array_module
++  *
++  * \returns an expression of the coefficient-wise cube of *this.
++  *
++  * Example: \include Cwise_cube.cpp
++  * Output: \verbinclude Cwise_cube.out
++  *
++  * \sa square(), pow()
++  */
++template<typename ExpressionType>
++inline const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_cube_op)
++Cwise<ExpressionType>::cube() const
++{
++  return _expression();
++}
++
++
++// -- binary operators --
++
++/** \array_module
++  * 
++  * \returns an expression of the coefficient-wise \< operator of *this and \a other
++  *
++  * Example: \include Cwise_less.cpp
++  * Output: \verbinclude Cwise_less.out
++  *
++  * \sa MatrixBase::all(), MatrixBase::any(), operator>(), operator<=()
++  */
++template<typename ExpressionType>
++template<typename OtherDerived>
++inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::less)
++Cwise<ExpressionType>::operator<(const MatrixBase<OtherDerived> &other) const
++{
++  return EIGEN_CWISE_BINOP_RETURN_TYPE(std::less)(_expression(), other.derived());
++}
++
++/** \array_module
++  * 
++  * \returns an expression of the coefficient-wise \<= operator of *this and \a other
++  *
++  * Example: \include Cwise_less_equal.cpp
++  * Output: \verbinclude Cwise_less_equal.out
++  *
++  * \sa MatrixBase::all(), MatrixBase::any(), operator>=(), operator<()
++  */
++template<typename ExpressionType>
++template<typename OtherDerived>
++inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::less_equal)
++Cwise<ExpressionType>::operator<=(const MatrixBase<OtherDerived> &other) const
++{
++  return EIGEN_CWISE_BINOP_RETURN_TYPE(std::less_equal)(_expression(), other.derived());
++}
++
++/** \array_module
++  * 
++  * \returns an expression of the coefficient-wise \> operator of *this and \a other
++  *
++  * Example: \include Cwise_greater.cpp
++  * Output: \verbinclude Cwise_greater.out
++  *
++  * \sa MatrixBase::all(), MatrixBase::any(), operator>=(), operator<()
++  */
++template<typename ExpressionType>
++template<typename OtherDerived>
++inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater)
++Cwise<ExpressionType>::operator>(const MatrixBase<OtherDerived> &other) const
++{
++  return EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater)(_expression(), other.derived());
++}
++
++/** \array_module
++  * 
++  * \returns an expression of the coefficient-wise \>= operator of *this and \a other
++  *
++  * Example: \include Cwise_greater_equal.cpp
++  * Output: \verbinclude Cwise_greater_equal.out
++  *
++  * \sa MatrixBase::all(), MatrixBase::any(), operator>(), operator<=()
++  */
++template<typename ExpressionType>
++template<typename OtherDerived>
++inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater_equal)
++Cwise<ExpressionType>::operator>=(const MatrixBase<OtherDerived> &other) const
++{
++  return EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater_equal)(_expression(), other.derived());
++}
++
++/** \array_module
++  * 
++  * \returns an expression of the coefficient-wise == operator of *this and \a other
++  *
++  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
++  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
++  * generally a far better idea to use a fuzzy comparison as provided by MatrixBase::isApprox() and
++  * MatrixBase::isMuchSmallerThan().
++  *
++  * Example: \include Cwise_equal_equal.cpp
++  * Output: \verbinclude Cwise_equal_equal.out
++  *
++  * \sa MatrixBase::all(), MatrixBase::any(), MatrixBase::isApprox(), MatrixBase::isMuchSmallerThan()
++  */
++template<typename ExpressionType>
++template<typename OtherDerived>
++inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::equal_to)
++Cwise<ExpressionType>::operator==(const MatrixBase<OtherDerived> &other) const
++{
++  return EIGEN_CWISE_BINOP_RETURN_TYPE(std::equal_to)(_expression(), other.derived());
++}
++
++/** \array_module
++  * 
++  * \returns an expression of the coefficient-wise != operator of *this and \a other
++  *
++  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
++  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
++  * generally a far better idea to use a fuzzy comparison as provided by MatrixBase::isApprox() and
++  * MatrixBase::isMuchSmallerThan().
++  *
++  * Example: \include Cwise_not_equal.cpp
++  * Output: \verbinclude Cwise_not_equal.out
++  *
++  * \sa MatrixBase::all(), MatrixBase::any(), MatrixBase::isApprox(), MatrixBase::isMuchSmallerThan()
++  */
++template<typename ExpressionType>
++template<typename OtherDerived>
++inline const EIGEN_CWISE_BINOP_RETURN_TYPE(std::not_equal_to)
++Cwise<ExpressionType>::operator!=(const MatrixBase<OtherDerived> &other) const
++{
++  return EIGEN_CWISE_BINOP_RETURN_TYPE(std::not_equal_to)(_expression(), other.derived());
++}
++
++// comparisons to scalar value
++
++/** \array_module
++  * 
++  * \returns an expression of the coefficient-wise \< operator of *this and a scalar \a s
++  *
++  * \sa operator<(const MatrixBase<OtherDerived> &) const
++  */
++template<typename ExpressionType>
++inline const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::less)
++Cwise<ExpressionType>::operator<(Scalar s) const
++{
++  return EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::less)(_expression(),
++            typename ExpressionType::ConstantReturnType(_expression().rows(), _expression().cols(), s));
++}
++
++/** \array_module
++  * 
++  * \returns an expression of the coefficient-wise \<= operator of *this and a scalar \a s
++  *
++  * \sa operator<=(const MatrixBase<OtherDerived> &) const
++  */
++template<typename ExpressionType>
++inline const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::less_equal)
++Cwise<ExpressionType>::operator<=(Scalar s) const
++{
++  return EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::less_equal)(_expression(),
++            typename ExpressionType::ConstantReturnType(_expression().rows(), _expression().cols(), s));
++}
++
++/** \array_module
++  * 
++  * \returns an expression of the coefficient-wise \> operator of *this and a scalar \a s
++  *
++  * \sa operator>(const MatrixBase<OtherDerived> &) const
++  */
++template<typename ExpressionType>
++inline const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::greater)
++Cwise<ExpressionType>::operator>(Scalar s) const
++{
++  return EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::greater)(_expression(),
++            typename ExpressionType::ConstantReturnType(_expression().rows(), _expression().cols(), s));
++}
++
++/** \array_module
++  * 
++  * \returns an expression of the coefficient-wise \>= operator of *this and a scalar \a s
++  *
++  * \sa operator>=(const MatrixBase<OtherDerived> &) const
++  */
++template<typename ExpressionType>
++inline const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::greater_equal)
++Cwise<ExpressionType>::operator>=(Scalar s) const
++{
++  return EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::greater_equal)(_expression(),
++            typename ExpressionType::ConstantReturnType(_expression().rows(), _expression().cols(), s));
++}
++
++/** \array_module
++  * 
++  * \returns an expression of the coefficient-wise == operator of *this and a scalar \a s
++  *
++  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
++  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
++  * generally a far better idea to use a fuzzy comparison as provided by MatrixBase::isApprox() and
++  * MatrixBase::isMuchSmallerThan().
++  *
++  * \sa operator==(const MatrixBase<OtherDerived> &) const
++  */
++template<typename ExpressionType>
++inline const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::equal_to)
++Cwise<ExpressionType>::operator==(Scalar s) const
++{
++  return EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::equal_to)(_expression(),
++            typename ExpressionType::ConstantReturnType(_expression().rows(), _expression().cols(), s));
++}
++
++/** \array_module
++  * 
++  * \returns an expression of the coefficient-wise != operator of *this and a scalar \a s
++  *
++  * \warning this performs an exact comparison, which is generally a bad idea with floating-point types.
++  * In order to check for equality between two vectors or matrices with floating-point coefficients, it is
++  * generally a far better idea to use a fuzzy comparison as provided by MatrixBase::isApprox() and
++  * MatrixBase::isMuchSmallerThan().
++  *
++  * \sa operator!=(const MatrixBase<OtherDerived> &) const
++  */
++template<typename ExpressionType>
++inline const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::not_equal_to)
++Cwise<ExpressionType>::operator!=(Scalar s) const
++{
++  return EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::not_equal_to)(_expression(),
++            typename ExpressionType::ConstantReturnType(_expression().rows(), _expression().cols(), s));
++}
++
++// scalar addition
++
++/** \array_module
++  *
++  * \returns an expression of \c *this with each coeff incremented by the constant \a scalar
++  *
++  * Example: \include Cwise_plus.cpp
++  * Output: \verbinclude Cwise_plus.out
++  *
++  * \sa operator+=(), operator-()
++  */
++template<typename ExpressionType>
++inline const typename Cwise<ExpressionType>::ScalarAddReturnType
++Cwise<ExpressionType>::operator+(const Scalar& scalar) const
++{
++  return typename Cwise<ExpressionType>::ScalarAddReturnType(m_matrix, ei_scalar_add_op<Scalar>(scalar));
++}
++
++/** \array_module
++  *
++  * Adds the given \a scalar to each coeff of this expression.
++  *
++  * Example: \include Cwise_plus_equal.cpp
++  * Output: \verbinclude Cwise_plus_equal.out
++  *
++  * \sa operator+(), operator-=()
++  */
++template<typename ExpressionType>
++inline ExpressionType& Cwise<ExpressionType>::operator+=(const Scalar& scalar)
++{
++  return m_matrix.const_cast_derived() = *this + scalar;
++}
++
++/** \array_module
++  *
++  * \returns an expression of \c *this with each coeff decremented by the constant \a scalar
++  *
++  * Example: \include Cwise_minus.cpp
++  * Output: \verbinclude Cwise_minus.out
++  *
++  * \sa operator+(), operator-=()
++  */
++template<typename ExpressionType>
++inline const typename Cwise<ExpressionType>::ScalarAddReturnType
++Cwise<ExpressionType>::operator-(const Scalar& scalar) const
++{
++  return *this + (-scalar);
++}
++
++/** \array_module
++  *
++  * Substracts the given \a scalar from each coeff of this expression.
++  *
++  * Example: \include Cwise_minus_equal.cpp
++  * Output: \verbinclude Cwise_minus_equal.out
++  *
++  * \sa operator+=(), operator-()
++  */
++
++template<typename ExpressionType>
++inline ExpressionType& Cwise<ExpressionType>::operator-=(const Scalar& scalar)
++{
++  return m_matrix.const_cast_derived() = *this - scalar;
++}
++
++#endif // EIGEN_ARRAY_CWISE_OPERATORS_H
index 0000000,0000000..0aae7fd
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,305 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra. Eigen itself is part of the KDE project.
++//
++// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifndef EIGEN_ARRAY_FUNCTORS_H
++#define EIGEN_ARRAY_FUNCTORS_H
++
++/** \internal
++  * \array_module
++  *
++  * \brief Template functor to add a scalar to a fixed other one
++  *
++  * \sa class CwiseUnaryOp, Array::operator+
++  */
++/* If you wonder why doing the ei_pset1() in packetOp() is an optimization check ei_scalar_multiple_op */
++template<typename Scalar>
++struct ei_scalar_add_op {
++  typedef typename ei_packet_traits<Scalar>::type PacketScalar;
++  // FIXME default copy constructors seems bugged with std::complex<>
++  inline ei_scalar_add_op(const ei_scalar_add_op& other) : m_other(other.m_other) { }
++  inline ei_scalar_add_op(const Scalar& other) : m_other(other) { }
++  inline Scalar operator() (const Scalar& a) const { return a + m_other; }
++  inline const PacketScalar packetOp(const PacketScalar& a) const
++  { return ei_padd(a, ei_pset1(m_other)); }
++  const Scalar m_other;
++};
++template<typename Scalar>
++struct ei_functor_traits<ei_scalar_add_op<Scalar> >
++{ enum { Cost = NumTraits<Scalar>::AddCost, PacketAccess = ei_packet_traits<Scalar>::size>1 }; };
++
++/** \internal
++  *
++  * \array_module
++  *
++  * \brief Template functor to compute the square root of a scalar
++  *
++  * \sa class CwiseUnaryOp, Cwise::sqrt()
++  */
++template<typename Scalar> struct ei_scalar_sqrt_op EIGEN_EMPTY_STRUCT {
++  inline const Scalar operator() (const Scalar& a) const { return ei_sqrt(a); }
++};
++template<typename Scalar>
++struct ei_functor_traits<ei_scalar_sqrt_op<Scalar> >
++{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false }; };
++
++/** \internal
++  *
++  * \array_module
++  *
++  * \brief Template functor to compute the exponential of a scalar
++  *
++  * \sa class CwiseUnaryOp, Cwise::exp()
++  */
++template<typename Scalar> struct ei_scalar_exp_op EIGEN_EMPTY_STRUCT {
++  inline const Scalar operator() (const Scalar& a) const { return ei_exp(a); }
++};
++template<typename Scalar>
++struct ei_functor_traits<ei_scalar_exp_op<Scalar> >
++{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false }; };
++
++/** \internal
++  *
++  * \array_module
++  *
++  * \brief Template functor to compute the logarithm of a scalar
++  *
++  * \sa class CwiseUnaryOp, Cwise::log()
++  */
++template<typename Scalar> struct ei_scalar_log_op EIGEN_EMPTY_STRUCT {
++  inline const Scalar operator() (const Scalar& a) const { return ei_log(a); }
++};
++template<typename Scalar>
++struct ei_functor_traits<ei_scalar_log_op<Scalar> >
++{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false }; };
++
++/** \internal
++  *
++  * \array_module
++  *
++  * \brief Template functor to compute the cosine of a scalar
++  *
++  * \sa class CwiseUnaryOp, Cwise::cos()
++  */
++template<typename Scalar> struct ei_scalar_cos_op EIGEN_EMPTY_STRUCT {
++  inline const Scalar operator() (const Scalar& a) const { return ei_cos(a); }
++};
++template<typename Scalar>
++struct ei_functor_traits<ei_scalar_cos_op<Scalar> >
++{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false }; };
++
++/** \internal
++  *
++  * \array_module
++  *
++  * \brief Template functor to compute the sine of a scalar
++  *
++  * \sa class CwiseUnaryOp, Cwise::sin()
++  */
++template<typename Scalar> struct ei_scalar_sin_op EIGEN_EMPTY_STRUCT {
++  inline const Scalar operator() (const Scalar& a) const { return ei_sin(a); }
++};
++template<typename Scalar>
++struct ei_functor_traits<ei_scalar_sin_op<Scalar> >
++{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false }; };
++
++/** \internal
++  *
++  * \array_module
++  *
++  * \brief Template functor to raise a scalar to a power
++  *
++  * \sa class CwiseUnaryOp, Cwise::pow
++  */
++template<typename Scalar>
++struct ei_scalar_pow_op {
++  // FIXME default copy constructors seems bugged with std::complex<>
++  inline ei_scalar_pow_op(const ei_scalar_pow_op& other) : m_exponent(other.m_exponent) { }
++  inline ei_scalar_pow_op(const Scalar& exponent) : m_exponent(exponent) {}
++  inline Scalar operator() (const Scalar& a) const { return ei_pow(a, m_exponent); }
++  const Scalar m_exponent;
++};
++template<typename Scalar>
++struct ei_functor_traits<ei_scalar_pow_op<Scalar> >
++{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false }; };
++
++/** \internal
++  *
++  * \array_module
++  *
++  * \brief Template functor to compute the inverse of a scalar
++  *
++  * \sa class CwiseUnaryOp, Cwise::inverse()
++  */
++template<typename Scalar>
++struct ei_scalar_inverse_op {
++  inline Scalar operator() (const Scalar& a) const { return Scalar(1)/a; }
++  template<typename PacketScalar>
++  inline const PacketScalar packetOp(const PacketScalar& a) const
++  { return ei_pdiv(ei_pset1(Scalar(1)),a); }
++};
++template<typename Scalar>
++struct ei_functor_traits<ei_scalar_inverse_op<Scalar> >
++{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = int(ei_packet_traits<Scalar>::size)>1 }; };
++
++/** \internal
++  *
++  * \array_module
++  *
++  * \brief Template functor to compute the square of a scalar
++  *
++  * \sa class CwiseUnaryOp, Cwise::square()
++  */
++template<typename Scalar>
++struct ei_scalar_square_op {
++  inline Scalar operator() (const Scalar& a) const { return a*a; }
++  template<typename PacketScalar>
++  inline const PacketScalar packetOp(const PacketScalar& a) const
++  { return ei_pmul(a,a); }
++};
++template<typename Scalar>
++struct ei_functor_traits<ei_scalar_square_op<Scalar> >
++{ enum { Cost = NumTraits<Scalar>::MulCost, PacketAccess = int(ei_packet_traits<Scalar>::size)>1 }; };
++
++/** \internal
++  *
++  * \array_module
++  *
++  * \brief Template functor to compute the cube of a scalar
++  *
++  * \sa class CwiseUnaryOp, Cwise::cube()
++  */
++template<typename Scalar>
++struct ei_scalar_cube_op {
++  inline Scalar operator() (const Scalar& a) const { return a*a*a; }
++  template<typename PacketScalar>
++  inline const PacketScalar packetOp(const PacketScalar& a) const
++  { return ei_pmul(a,ei_pmul(a,a)); }
++};
++template<typename Scalar>
++struct ei_functor_traits<ei_scalar_cube_op<Scalar> >
++{ enum { Cost = 2*NumTraits<Scalar>::MulCost, PacketAccess = int(ei_packet_traits<Scalar>::size)>1 }; };
++
++// default ei_functor_traits for STL functors:
++
++template<typename T>
++struct ei_functor_traits<std::multiplies<T> >
++{ enum { Cost = NumTraits<T>::MulCost, PacketAccess = false }; };
++
++template<typename T>
++struct ei_functor_traits<std::divides<T> >
++{ enum { Cost = NumTraits<T>::MulCost, PacketAccess = false }; };
++
++template<typename T>
++struct ei_functor_traits<std::plus<T> >
++{ enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; };
++
++template<typename T>
++struct ei_functor_traits<std::minus<T> >
++{ enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; };
++
++template<typename T>
++struct ei_functor_traits<std::negate<T> >
++{ enum { Cost = NumTraits<T>::AddCost, PacketAccess = false }; };
++
++template<typename T>
++struct ei_functor_traits<std::logical_or<T> >
++{ enum { Cost = 1, PacketAccess = false }; };
++
++template<typename T>
++struct ei_functor_traits<std::logical_and<T> >
++{ enum { Cost = 1, PacketAccess = false }; };
++
++template<typename T>
++struct ei_functor_traits<std::logical_not<T> >
++{ enum { Cost = 1, PacketAccess = false }; };
++
++template<typename T>
++struct ei_functor_traits<std::greater<T> >
++{ enum { Cost = 1, PacketAccess = false }; };
++
++template<typename T>
++struct ei_functor_traits<std::less<T> >
++{ enum { Cost = 1, PacketAccess = false }; };
++
++template<typename T>
++struct ei_functor_traits<std::greater_equal<T> >
++{ enum { Cost = 1, PacketAccess = false }; };
++
++template<typename T>
++struct ei_functor_traits<std::less_equal<T> >
++{ enum { Cost = 1, PacketAccess = false }; };
++
++template<typename T>
++struct ei_functor_traits<std::equal_to<T> >
++{ enum { Cost = 1, PacketAccess = false }; };
++
++template<typename T>
++struct ei_functor_traits<std::not_equal_to<T> >
++{ enum { Cost = 1, PacketAccess = false }; };
++
++template<typename T>
++struct ei_functor_traits<std::binder2nd<T> >
++{ enum { Cost = ei_functor_traits<T>::Cost, PacketAccess = false }; };
++
++template<typename T>
++struct ei_functor_traits<std::binder1st<T> >
++{ enum { Cost = ei_functor_traits<T>::Cost, PacketAccess = false }; };
++
++template<typename T>
++struct ei_functor_traits<std::unary_negate<T> >
++{ enum { Cost = 1 + ei_functor_traits<T>::Cost, PacketAccess = false }; };
++
++template<typename T>
++struct ei_functor_traits<std::binary_negate<T> >
++{ enum { Cost = 1 + ei_functor_traits<T>::Cost, PacketAccess = false }; };
++
++#ifdef EIGEN_STDEXT_SUPPORT
++
++template<typename T0,typename T1>
++struct ei_functor_traits<std::project1st<T0,T1> >
++{ enum { Cost = 0, PacketAccess = false }; };
++
++template<typename T0,typename T1>
++struct ei_functor_traits<std::project2nd<T0,T1> >
++{ enum { Cost = 0, PacketAccess = false }; };
++
++template<typename T0,typename T1>
++struct ei_functor_traits<std::select2nd<std::pair<T0,T1> > >
++{ enum { Cost = 0, PacketAccess = false }; };
++
++template<typename T0,typename T1>
++struct ei_functor_traits<std::select1st<std::pair<T0,T1> > >
++{ enum { Cost = 0, PacketAccess = false }; };
++
++template<typename T0,typename T1>
++struct ei_functor_traits<std::unary_compose<T0,T1> >
++{ enum { Cost = ei_functor_traits<T0>::Cost + ei_functor_traits<T1>::Cost, PacketAccess = false }; };
++
++template<typename T0,typename T1,typename T2>
++struct ei_functor_traits<std::binary_compose<T0,T1,T2> >
++{ enum { Cost = ei_functor_traits<T0>::Cost + ei_functor_traits<T1>::Cost + ei_functor_traits<T2>::Cost, PacketAccess = false }; };
++
++#endif // EIGEN_STDEXT_SUPPORT
++
++#endif // EIGEN_ARRAY_FUNCTORS_H
index 0000000,0000000..6b92e6a
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,80 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra. Eigen itself is part of the KDE project.
++//
++// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifndef EIGEN_ARRAY_NORMS_H
++#define EIGEN_ARRAY_NORMS_H
++
++template<typename Derived, int p>
++struct ei_lpNorm_selector
++{
++  typedef typename NumTraits<typename ei_traits<Derived>::Scalar>::Real RealScalar;
++  inline static RealScalar run(const MatrixBase<Derived>& m)
++  {
++    return ei_pow(m.cwise().abs().cwise().pow(p).sum(), RealScalar(1)/p);
++  }
++};
++
++template<typename Derived>
++struct ei_lpNorm_selector<Derived, 1>
++{
++  inline static typename NumTraits<typename ei_traits<Derived>::Scalar>::Real run(const MatrixBase<Derived>& m)
++  {
++    return m.cwise().abs().sum();
++  }
++};
++
++template<typename Derived>
++struct ei_lpNorm_selector<Derived, 2>
++{
++  inline static typename NumTraits<typename ei_traits<Derived>::Scalar>::Real run(const MatrixBase<Derived>& m)
++  {
++    return m.norm();
++  }
++};
++
++template<typename Derived>
++struct ei_lpNorm_selector<Derived, Infinity>
++{
++  inline static typename NumTraits<typename ei_traits<Derived>::Scalar>::Real run(const MatrixBase<Derived>& m)
++  {
++    return m.cwise().abs().maxCoeff();
++  }
++};
++
++/** \array_module
++  * 
++  * \returns the \f$ \ell^p \f$ norm of *this, that is, returns the p-th root of the sum of the p-th powers of the absolute values
++  *          of the coefficients of *this. If \a p is the special value \a Eigen::Infinity, this function returns the \f$ \ell^p\infty \f$
++  *          norm, that is the maximum of the absolute values of the coefficients of *this.
++  *
++  * \sa norm()
++  */
++template<typename Derived>
++template<int p>
++inline typename NumTraits<typename ei_traits<Derived>::Scalar>::Real MatrixBase<Derived>::lpNorm() const
++{
++  return ei_lpNorm_selector<Derived, p>::run(*this);
++}
++
++#endif // EIGEN_ARRAY_NORMS_H
index 0000000,0000000..b1e8fd4
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,342 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra. Eigen itself is part of the KDE project.
++//
++// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
++// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifndef EIGEN_PARTIAL_REDUX_H
++#define EIGEN_PARTIAL_REDUX_H
++
++/** \array_module \ingroup Array
++  *
++  * \class PartialReduxExpr
++  *
++  * \brief Generic expression of a partially reduxed matrix
++  *
++  * \param MatrixType the type of the matrix we are applying the redux operation
++  * \param MemberOp type of the member functor
++  * \param Direction indicates the direction of the redux (Vertical or Horizontal)
++  *
++  * This class represents an expression of a partial redux operator of a matrix.
++  * It is the return type of PartialRedux functions,
++  * and most of the time this is the only way it is used.
++  *
++  * \sa class PartialRedux
++  */
++
++template< typename MatrixType, typename MemberOp, int Direction>
++class PartialReduxExpr;
++
++template<typename MatrixType, typename MemberOp, int Direction>
++struct ei_traits<PartialReduxExpr<MatrixType, MemberOp, Direction> >
++{
++  typedef typename MemberOp::result_type Scalar;
++  typedef typename MatrixType::Scalar InputScalar;
++  typedef typename ei_nested<MatrixType>::type MatrixTypeNested;
++  typedef typename ei_cleantype<MatrixTypeNested>::type _MatrixTypeNested;
++  enum {
++    RowsAtCompileTime = Direction==Vertical   ? 1 : MatrixType::RowsAtCompileTime,
++    ColsAtCompileTime = Direction==Horizontal ? 1 : MatrixType::ColsAtCompileTime,
++    MaxRowsAtCompileTime = Direction==Vertical   ? 1 : MatrixType::MaxRowsAtCompileTime,
++    MaxColsAtCompileTime = Direction==Horizontal ? 1 : MatrixType::MaxColsAtCompileTime,
++    Flags = (unsigned int)_MatrixTypeNested::Flags & HereditaryBits,
++    TraversalSize = Direction==Vertical ? RowsAtCompileTime : ColsAtCompileTime
++  };
++  #if EIGEN_GNUC_AT_LEAST(3,4)
++  typedef typename MemberOp::template Cost<InputScalar,int(TraversalSize)> CostOpType;
++  #else
++  typedef typename MemberOp::template Cost<InputScalar,TraversalSize> CostOpType;
++  #endif
++  enum {
++    CoeffReadCost = TraversalSize * ei_traits<_MatrixTypeNested>::CoeffReadCost + int(CostOpType::value)
++  };
++};
++
++template< typename MatrixType, typename MemberOp, int Direction>
++class PartialReduxExpr : ei_no_assignment_operator,
++  public MatrixBase<PartialReduxExpr<MatrixType, MemberOp, Direction> >
++{
++  public:
++
++    EIGEN_GENERIC_PUBLIC_INTERFACE(PartialReduxExpr)
++    typedef typename ei_traits<PartialReduxExpr>::MatrixTypeNested MatrixTypeNested;
++    typedef typename ei_traits<PartialReduxExpr>::_MatrixTypeNested _MatrixTypeNested;
++
++    PartialReduxExpr(const MatrixType& mat, const MemberOp& func = MemberOp())
++      : m_matrix(mat), m_functor(func) {}
++
++    int rows() const { return (Direction==Vertical   ? 1 : m_matrix.rows()); }
++    int cols() const { return (Direction==Horizontal ? 1 : m_matrix.cols()); }
++
++    const Scalar coeff(int i, int j) const
++    {
++      if (Direction==Vertical)
++        return m_functor(m_matrix.col(j));
++      else
++        return m_functor(m_matrix.row(i));
++    }
++
++  protected:
++    const MatrixTypeNested m_matrix;
++    const MemberOp m_functor;
++};
++
++#define EIGEN_MEMBER_FUNCTOR(MEMBER,COST)                           \
++  template <typename ResultType>                                    \
++  struct ei_member_##MEMBER EIGEN_EMPTY_STRUCT {                    \
++    typedef ResultType result_type;                                 \
++    template<typename Scalar, int Size> struct Cost                 \
++    { enum { value = COST }; };                                     \
++    template<typename Derived>                                      \
++    inline ResultType operator()(const MatrixBase<Derived>& mat) const     \
++    { return mat.MEMBER(); } \
++  }
++
++EIGEN_MEMBER_FUNCTOR(squaredNorm, Size * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost);
++EIGEN_MEMBER_FUNCTOR(norm, (Size+5) * NumTraits<Scalar>::MulCost + (Size-1)*NumTraits<Scalar>::AddCost);
++EIGEN_MEMBER_FUNCTOR(sum, (Size-1)*NumTraits<Scalar>::AddCost);
++EIGEN_MEMBER_FUNCTOR(minCoeff, (Size-1)*NumTraits<Scalar>::AddCost);
++EIGEN_MEMBER_FUNCTOR(maxCoeff, (Size-1)*NumTraits<Scalar>::AddCost);
++EIGEN_MEMBER_FUNCTOR(all, (Size-1)*NumTraits<Scalar>::AddCost);
++EIGEN_MEMBER_FUNCTOR(any, (Size-1)*NumTraits<Scalar>::AddCost);
++EIGEN_MEMBER_FUNCTOR(count, (Size-1)*NumTraits<Scalar>::AddCost);
++
++/** \internal */
++template <typename BinaryOp, typename Scalar>
++struct ei_member_redux {
++  typedef typename ei_result_of<
++                     BinaryOp(Scalar)
++                   >::type  result_type;
++  template<typename _Scalar, int Size> struct Cost
++  { enum { value = (Size-1) * ei_functor_traits<BinaryOp>::Cost }; };
++  ei_member_redux(const BinaryOp func) : m_functor(func) {}
++  template<typename Derived>
++  inline result_type operator()(const MatrixBase<Derived>& mat) const
++  { return mat.redux(m_functor); }
++  const BinaryOp m_functor;
++};
++
++/** \array_module \ingroup Array
++  *
++  * \class PartialRedux
++  *
++  * \brief Pseudo expression providing partial reduction operations
++  *
++  * \param ExpressionType the type of the object on which to do partial reductions
++  * \param Direction indicates the direction of the redux (Vertical or Horizontal)
++  *
++  * This class represents a pseudo expression with partial reduction features.
++  * It is the return type of MatrixBase::colwise() and MatrixBase::rowwise()
++  * and most of the time this is the only way it is used.
++  *
++  * Example: \include MatrixBase_colwise.cpp
++  * Output: \verbinclude MatrixBase_colwise.out
++  *
++  * \sa MatrixBase::colwise(), MatrixBase::rowwise(), class PartialReduxExpr
++  */
++template<typename ExpressionType, int Direction> class PartialRedux
++{
++  public:
++
++    typedef typename ei_traits<ExpressionType>::Scalar Scalar;
++    typedef typename ei_meta_if<ei_must_nest_by_value<ExpressionType>::ret,
++        ExpressionType, const ExpressionType&>::ret ExpressionTypeNested;
++
++    template<template<typename _Scalar> class Functor> struct ReturnType
++    {
++      typedef PartialReduxExpr<ExpressionType,
++                               Functor<typename ei_traits<ExpressionType>::Scalar>,
++                               Direction
++                              > Type;
++    };
++
++    template<typename BinaryOp> struct ReduxReturnType
++    {
++      typedef PartialReduxExpr<ExpressionType,
++                               ei_member_redux<BinaryOp,typename ei_traits<ExpressionType>::Scalar>,
++                               Direction
++                              > Type;
++    };
++
++    typedef typename ExpressionType::PlainMatrixType CrossReturnType;
++    
++    inline PartialRedux(const ExpressionType& matrix) : m_matrix(matrix) {}
++
++    /** \internal */
++    inline const ExpressionType& _expression() const { return m_matrix; }
++
++    template<typename BinaryOp>
++    const typename ReduxReturnType<BinaryOp>::Type
++    redux(const BinaryOp& func = BinaryOp()) const;
++
++    /** \returns a row (or column) vector expression of the smallest coefficient
++      * of each column (or row) of the referenced expression.
++      *
++      * Example: \include PartialRedux_minCoeff.cpp
++      * Output: \verbinclude PartialRedux_minCoeff.out
++      *
++      * \sa MatrixBase::minCoeff() */
++    const typename ReturnType<ei_member_minCoeff>::Type minCoeff() const
++    { return _expression(); }
++
++    /** \returns a row (or column) vector expression of the largest coefficient
++      * of each column (or row) of the referenced expression.
++      *
++      * Example: \include PartialRedux_maxCoeff.cpp
++      * Output: \verbinclude PartialRedux_maxCoeff.out
++      *
++      * \sa MatrixBase::maxCoeff() */
++    const typename ReturnType<ei_member_maxCoeff>::Type maxCoeff() const
++    { return _expression(); }
++
++    /** \returns a row (or column) vector expression of the squared norm
++      * of each column (or row) of the referenced expression.
++      *
++      * Example: \include PartialRedux_squaredNorm.cpp
++      * Output: \verbinclude PartialRedux_squaredNorm.out
++      *
++      * \sa MatrixBase::squaredNorm() */
++    const typename ReturnType<ei_member_squaredNorm>::Type squaredNorm() const
++    { return _expression(); }
++
++    /** \returns a row (or column) vector expression of the norm
++      * of each column (or row) of the referenced expression.
++      *
++      * Example: \include PartialRedux_norm.cpp
++      * Output: \verbinclude PartialRedux_norm.out
++      *
++      * \sa MatrixBase::norm() */
++    const typename ReturnType<ei_member_norm>::Type norm() const
++    { return _expression(); }
++
++    /** \returns a row (or column) vector expression of the sum
++      * of each column (or row) of the referenced expression.
++      *
++      * Example: \include PartialRedux_sum.cpp
++      * Output: \verbinclude PartialRedux_sum.out
++      *
++      * \sa MatrixBase::sum() */
++    const typename ReturnType<ei_member_sum>::Type sum() const
++    { return _expression(); }
++
++    /** \returns a row (or column) vector expression representing
++      * whether \b all coefficients of each respective column (or row) are \c true.
++      *
++      * \sa MatrixBase::all() */
++    const typename ReturnType<ei_member_all>::Type all() const
++    { return _expression(); }
++
++    /** \returns a row (or column) vector expression representing
++      * whether \b at \b least one coefficient of each respective column (or row) is \c true.
++      *
++      * \sa MatrixBase::any() */
++    const typename ReturnType<ei_member_any>::Type any() const
++    { return _expression(); }
++    
++    /** \returns a row (or column) vector expression representing
++      * the number of \c true coefficients of each respective column (or row).
++      *
++      * Example: \include PartialRedux_count.cpp
++      * Output: \verbinclude PartialRedux_count.out
++      *
++      * \sa MatrixBase::count() */
++    const PartialReduxExpr<ExpressionType, ei_member_count<int>, Direction> count() const
++    { return _expression(); }
++
++    /** \returns a 3x3 matrix expression of the cross product
++      * of each column or row of the referenced expression with the \a other vector.
++      *
++      * \geometry_module
++      *
++      * \sa MatrixBase::cross() */
++    template<typename OtherDerived>
++    const CrossReturnType cross(const MatrixBase<OtherDerived>& other) const
++    {
++      EIGEN_STATIC_ASSERT_MATRIX_SPECIFIC_SIZE(CrossReturnType,3,3)
++      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,3)
++      EIGEN_STATIC_ASSERT((ei_is_same_type<Scalar, typename OtherDerived::Scalar>::ret),
++        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
++
++      if(Direction==Vertical)
++        return (CrossReturnType()
++                                 << _expression().col(0).cross(other),
++                                    _expression().col(1).cross(other),
++                                    _expression().col(2).cross(other)).finished();
++      else
++        return (CrossReturnType() 
++                                 << _expression().row(0).cross(other),
++                                    _expression().row(1).cross(other),
++                                    _expression().row(2).cross(other)).finished();
++    }
++
++  protected:
++    ExpressionTypeNested m_matrix;
++};
++
++/** \array_module
++  *
++  * \returns a PartialRedux wrapper of *this providing additional partial reduction operations
++  *
++  * Example: \include MatrixBase_colwise.cpp
++  * Output: \verbinclude MatrixBase_colwise.out
++  *
++  * \sa rowwise(), class PartialRedux
++  */
++template<typename Derived>
++inline const PartialRedux<Derived,Vertical>
++MatrixBase<Derived>::colwise() const
++{
++  return derived();
++}
++
++/** \array_module
++  *
++  * \returns a PartialRedux wrapper of *this providing additional partial reduction operations
++  *
++  * Example: \include MatrixBase_rowwise.cpp
++  * Output: \verbinclude MatrixBase_rowwise.out
++  *
++  * \sa colwise(), class PartialRedux
++  */
++template<typename Derived>
++inline const PartialRedux<Derived,Horizontal>
++MatrixBase<Derived>::rowwise() const
++{
++  return derived();
++}
++
++/** \returns a row or column vector expression of \c *this reduxed by \a func
++  *
++  * The template parameter \a BinaryOp is the type of the functor
++  * of the custom redux operator. Note that func must be an associative operator.
++  *
++  * \sa class PartialRedux, MatrixBase::colwise(), MatrixBase::rowwise()
++  */
++template<typename ExpressionType, int Direction>
++template<typename BinaryOp>
++const typename PartialRedux<ExpressionType,Direction>::template ReduxReturnType<BinaryOp>::Type
++PartialRedux<ExpressionType,Direction>::redux(const BinaryOp& func) const
++{
++  return typename ReduxReturnType<BinaryOp>::Type(_expression(), func);
++}
++
++#endif // EIGEN_PARTIAL_REDUX_H
index 0000000,0000000..9185fe4
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,156 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra. Eigen itself is part of the KDE project.
++//
++// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifndef EIGEN_RANDOM_H
++#define EIGEN_RANDOM_H
++
++template<typename Scalar> struct ei_scalar_random_op EIGEN_EMPTY_STRUCT {
++  inline ei_scalar_random_op(void) {}
++  inline const Scalar operator() (int, int) const { return ei_random<Scalar>(); }
++};
++template<typename Scalar>
++struct ei_functor_traits<ei_scalar_random_op<Scalar> >
++{ enum { Cost = 5 * NumTraits<Scalar>::MulCost, PacketAccess = false, IsRepeatable = false }; };
++
++/** \array_module
++  * 
++  * \returns a random matrix (not an expression, the matrix is immediately evaluated).
++  *
++  * The parameters \a rows and \a cols are the number of rows and of columns of
++  * the returned matrix. Must be compatible with this MatrixBase type.
++  *
++  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
++  * it is redundant to pass \a rows and \a cols as arguments, so ei_random() should be used
++  * instead.
++  *
++  * \addexample RandomExample \label How to create a matrix with random coefficients
++  *
++  * Example: \include MatrixBase_random_int_int.cpp
++  * Output: \verbinclude MatrixBase_random_int_int.out
++  *
++  * \sa MatrixBase::setRandom(), MatrixBase::Random(int), MatrixBase::Random()
++  */
++template<typename Derived>
++inline const CwiseNullaryOp<ei_scalar_random_op<typename ei_traits<Derived>::Scalar>, Derived>
++MatrixBase<Derived>::Random(int rows, int cols)
++{
++  return NullaryExpr(rows, cols, ei_scalar_random_op<Scalar>());
++}
++
++/** \array_module
++  * 
++  * \returns a random vector (not an expression, the vector is immediately evaluated).
++  *
++  * The parameter \a size is the size of the returned vector.
++  * Must be compatible with this MatrixBase type.
++  *
++  * \only_for_vectors
++  *
++  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
++  * it is redundant to pass \a size as argument, so ei_random() should be used
++  * instead.
++  *
++  * Example: \include MatrixBase_random_int.cpp
++  * Output: \verbinclude MatrixBase_random_int.out
++  *
++  * \sa MatrixBase::setRandom(), MatrixBase::Random(int,int), MatrixBase::Random()
++  */
++template<typename Derived>
++inline const CwiseNullaryOp<ei_scalar_random_op<typename ei_traits<Derived>::Scalar>, Derived>
++MatrixBase<Derived>::Random(int size)
++{
++  return NullaryExpr(size, ei_scalar_random_op<Scalar>());
++}
++
++/** \array_module
++  * 
++  * \returns a fixed-size random matrix or vector
++  * (not an expression, the matrix is immediately evaluated).
++  *
++  * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
++  * need to use the variants taking size arguments.
++  *
++  * Example: \include MatrixBase_random.cpp
++  * Output: \verbinclude MatrixBase_random.out
++  *
++  * \sa MatrixBase::setRandom(), MatrixBase::Random(int,int), MatrixBase::Random(int)
++  */
++template<typename Derived>
++inline const CwiseNullaryOp<ei_scalar_random_op<typename ei_traits<Derived>::Scalar>, Derived>
++MatrixBase<Derived>::Random()
++{
++  return NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, ei_scalar_random_op<Scalar>());
++}
++
++/** \array_module
++  * 
++  * Sets all coefficients in this expression to random values.
++  *
++  * Example: \include MatrixBase_setRandom.cpp
++  * Output: \verbinclude MatrixBase_setRandom.out
++  *
++  * \sa class CwiseNullaryOp, setRandom(int), setRandom(int,int)
++  */
++template<typename Derived>
++inline Derived& MatrixBase<Derived>::setRandom()
++{
++  return *this = Random(rows(), cols());
++}
++
++/** Resizes to the given \a size, and sets all coefficients in this expression to random values.
++  *
++  * \only_for_vectors
++  *
++  * Example: \include Matrix_setRandom_int.cpp
++  * Output: \verbinclude Matrix_setRandom_int.out
++  *
++  * \sa MatrixBase::setRandom(), setRandom(int,int), class CwiseNullaryOp, MatrixBase::Random()
++  */
++template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
++EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>&
++Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setRandom(int size)
++{
++  resize(size);
++  return setRandom();
++}
++
++/** Resizes to the given size, and sets all coefficients in this expression to random values.
++  *
++  * \param rows the new number of rows
++  * \param cols the new number of columns
++  *
++  * Example: \include Matrix_setRandom_int_int.cpp
++  * Output: \verbinclude Matrix_setRandom_int_int.out
++  *
++  * \sa MatrixBase::setRandom(), setRandom(int), class CwiseNullaryOp, MatrixBase::Random()
++  */
++template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
++EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>&
++Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setRandom(int rows, int cols)
++{
++  resize(rows, cols);
++  return setRandom();
++}
++
++#endif // EIGEN_RANDOM_H
index 0000000,0000000..9dc3fb1
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,159 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra. Eigen itself is part of the KDE project.
++//
++// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifndef EIGEN_SELECT_H
++#define EIGEN_SELECT_H
++
++/** \array_module \ingroup Array
++  *
++  * \class Select
++  *
++  * \brief Expression of a coefficient wise version of the C++ ternary operator ?:
++  *
++  * \param ConditionMatrixType the type of the \em condition expression which must be a boolean matrix
++  * \param ThenMatrixType the type of the \em then expression
++  * \param ElseMatrixType the type of the \em else expression
++  *
++  * This class represents an expression of a coefficient wise version of the C++ ternary operator ?:.
++  * It is the return type of MatrixBase::select() and most of the time this is the only way it is used.
++  *
++  * \sa MatrixBase::select(const MatrixBase<ThenDerived>&, const MatrixBase<ElseDerived>&) const
++  */
++
++template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType>
++struct ei_traits<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >
++{
++  typedef typename ei_traits<ThenMatrixType>::Scalar Scalar;
++  typedef typename ConditionMatrixType::Nested ConditionMatrixNested;
++  typedef typename ThenMatrixType::Nested ThenMatrixNested;
++  typedef typename ElseMatrixType::Nested ElseMatrixNested;
++  enum {
++    RowsAtCompileTime = ConditionMatrixType::RowsAtCompileTime,
++    ColsAtCompileTime = ConditionMatrixType::ColsAtCompileTime,
++    MaxRowsAtCompileTime = ConditionMatrixType::MaxRowsAtCompileTime,
++    MaxColsAtCompileTime = ConditionMatrixType::MaxColsAtCompileTime,
++    Flags = (unsigned int)ThenMatrixType::Flags & ElseMatrixType::Flags & HereditaryBits,
++      CoeffReadCost = ei_traits<typename ei_cleantype<ConditionMatrixNested>::type>::CoeffReadCost
++      + EIGEN_ENUM_MAX(ei_traits<typename ei_cleantype<ThenMatrixNested>::type>::CoeffReadCost,
++                       ei_traits<typename ei_cleantype<ElseMatrixNested>::type>::CoeffReadCost)
++  };
++};
++
++template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType>
++class Select : ei_no_assignment_operator,
++  public MatrixBase<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> >
++{
++  public:
++
++    EIGEN_GENERIC_PUBLIC_INTERFACE(Select)
++
++    Select(const ConditionMatrixType& conditionMatrix,
++           const ThenMatrixType& thenMatrix,
++           const ElseMatrixType& elseMatrix)
++      : m_condition(conditionMatrix), m_then(thenMatrix), m_else(elseMatrix)
++    {
++      ei_assert(m_condition.rows() == m_then.rows() && m_condition.rows() == m_else.rows());
++      ei_assert(m_condition.cols() == m_then.cols() && m_condition.cols() == m_else.cols());
++    }
++
++    int rows() const { return m_condition.rows(); }
++    int cols() const { return m_condition.cols(); }
++
++    const Scalar coeff(int i, int j) const
++    {
++      if (m_condition.coeff(i,j))
++        return m_then.coeff(i,j);
++      else
++        return m_else.coeff(i,j);
++    }
++    
++    const Scalar coeff(int i) const
++    {
++      if (m_condition.coeff(i))
++        return m_then.coeff(i);
++      else
++        return m_else.coeff(i);
++    }
++
++  protected:
++    const typename ConditionMatrixType::Nested m_condition;
++    const typename ThenMatrixType::Nested m_then;
++    const typename ElseMatrixType::Nested m_else;
++};
++
++
++/** \array_module
++  *
++  * \returns a matrix where each coefficient (i,j) is equal to \a thenMatrix(i,j)
++  * if \c *this(i,j), and \a elseMatrix(i,j) otherwise.
++  *
++  * Example: \include MatrixBase_select.cpp
++  * Output: \verbinclude MatrixBase_select.out
++  *
++  * \sa class Select
++  */
++template<typename Derived>
++template<typename ThenDerived,typename ElseDerived>
++inline const Select<Derived,ThenDerived,ElseDerived>
++MatrixBase<Derived>::select(const MatrixBase<ThenDerived>& thenMatrix,
++                            const MatrixBase<ElseDerived>& elseMatrix) const
++{
++  return Select<Derived,ThenDerived,ElseDerived>(derived(), thenMatrix.derived(), elseMatrix.derived());
++}
++
++/** \array_module
++  *
++  * Version of MatrixBase::select(const MatrixBase&, const MatrixBase&) with
++  * the \em else expression being a scalar value.
++  *
++  * \sa MatrixBase::select(const MatrixBase<ThenDerived>&, const MatrixBase<ElseDerived>&) const, class Select
++  */
++template<typename Derived>
++template<typename ThenDerived>
++inline const Select<Derived,ThenDerived, NestByValue<typename ThenDerived::ConstantReturnType> >
++MatrixBase<Derived>::select(const MatrixBase<ThenDerived>& thenMatrix,
++                            typename ThenDerived::Scalar elseScalar) const
++{
++  return Select<Derived,ThenDerived,NestByValue<typename ThenDerived::ConstantReturnType> >(
++    derived(), thenMatrix.derived(), ThenDerived::Constant(rows(),cols(),elseScalar));
++}
++
++/** \array_module
++  *
++  * Version of MatrixBase::select(const MatrixBase&, const MatrixBase&) with
++  * the \em then expression being a scalar value.
++  *
++  * \sa MatrixBase::select(const MatrixBase<ThenDerived>&, const MatrixBase<ElseDerived>&) const, class Select
++  */
++template<typename Derived>
++template<typename ElseDerived>
++inline const Select<Derived, NestByValue<typename ElseDerived::ConstantReturnType>, ElseDerived >
++MatrixBase<Derived>::select(typename ElseDerived::Scalar thenScalar,
++                            const MatrixBase<ElseDerived>& elseMatrix) const
++{
++  return Select<Derived,NestByValue<typename ElseDerived::ConstantReturnType>,ElseDerived>(
++    derived(), ElseDerived::Constant(rows(),cols(),thenScalar), elseMatrix.derived());
++}
++
++#endif // EIGEN_SELECT_H
index 0000000,0000000..e7f40a2
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,35 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra. Eigen itself is part of the KDE project.
++//
++// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifndef EIGEN_EXTERN_INSTANTIATIONS
++#define EIGEN_EXTERN_INSTANTIATIONS
++#endif
++#include "../../Core"
++#undef EIGEN_EXTERN_INSTANTIATIONS
++
++#include "../../Cholesky"
++
++namespace Eigen {
++  EIGEN_CHOLESKY_MODULE_INSTANTIATE();
++}
index 0000000,0000000..205b78a
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,198 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra. Eigen itself is part of the KDE project.
++//
++// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifndef EIGEN_LDLT_H
++#define EIGEN_LDLT_H
++
++/** \ingroup cholesky_Module
++  *
++  * \class LDLT
++  *
++  * \brief Robust Cholesky decomposition of a matrix and associated features
++  *
++  * \param MatrixType the type of the matrix of which we are computing the LDL^T Cholesky decomposition
++  *
++  * This class performs a Cholesky decomposition without square root of a symmetric, positive definite
++  * matrix A such that A = L D L^* = U^* D U, where L is lower triangular with a unit diagonal
++  * and D is a diagonal matrix.
++  *
++  * Compared to a standard Cholesky decomposition, avoiding the square roots allows for faster and more
++  * stable computation.
++  *
++  * Note that during the decomposition, only the upper triangular part of A is considered. Therefore,
++  * the strict lower part does not have to store correct values.
++  *
++  * \sa MatrixBase::ldlt(), class LLT
++  */
++template<typename MatrixType> class LDLT
++{
++  public:
++
++    typedef typename MatrixType::Scalar Scalar;
++    typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
++    typedef Matrix<Scalar, MatrixType::ColsAtCompileTime, 1> VectorType;
++
++    LDLT(const MatrixType& matrix)
++      : m_matrix(matrix.rows(), matrix.cols())
++    {
++      compute(matrix);
++    }
++
++    /** \returns the lower triangular matrix L */
++    inline Part<MatrixType, UnitLowerTriangular> matrixL(void) const { return m_matrix; }
++
++    /** \returns the coefficients of the diagonal matrix D */
++    inline DiagonalCoeffs<MatrixType> vectorD(void) const { return m_matrix.diagonal(); }
++
++    /** \returns true if the matrix is positive definite */
++    inline bool isPositiveDefinite(void) const { return m_isPositiveDefinite; }
++
++    template<typename RhsDerived, typename ResultType>
++    bool solve(const MatrixBase<RhsDerived> &b, ResultType *result) const;
++
++    template<typename Derived>
++    bool solveInPlace(MatrixBase<Derived> &bAndX) const;
++
++    void compute(const MatrixType& matrix);
++
++  protected:
++    /** \internal
++      * Used to compute and store the cholesky decomposition A = L D L^* = U^* D U.
++      * The strict upper part is used during the decomposition, the strict lower
++      * part correspond to the coefficients of L (its diagonal is equal to 1 and
++      * is not stored), and the diagonal entries correspond to D.
++      */
++    MatrixType m_matrix;
++
++    bool m_isPositiveDefinite;
++};
++
++/** Compute / recompute the LLT decomposition A = L D L^* = U^* D U of \a matrix
++  */
++template<typename MatrixType>
++void LDLT<MatrixType>::compute(const MatrixType& a)
++{
++  assert(a.rows()==a.cols());
++  const int size = a.rows();
++  m_matrix.resize(size, size);
++  m_isPositiveDefinite = true;
++  const RealScalar eps = ei_sqrt(precision<Scalar>());
++
++  if (size<=1)
++  {
++    m_matrix = a;
++    return;
++  }
++
++  // Let's preallocate a temporay vector to evaluate the matrix-vector product into it.
++  // Unlike the standard LLT decomposition, here we cannot evaluate it to the destination
++  // matrix because it a sub-row which is not compatible suitable for efficient packet evaluation.
++  // (at least if we assume the matrix is col-major)
++  Matrix<Scalar,MatrixType::RowsAtCompileTime,1> _temporary(size);
++
++  // Note that, in this algorithm the rows of the strict upper part of m_matrix is used to store
++  // column vector, thus the strange .conjugate() and .transpose()...
++
++  m_matrix.row(0) = a.row(0).conjugate();
++  m_matrix.col(0).end(size-1) = m_matrix.row(0).end(size-1) / m_matrix.coeff(0,0);
++  for (int j = 1; j < size; ++j)
++  {
++    RealScalar tmp = ei_real(a.coeff(j,j) - (m_matrix.row(j).start(j) * m_matrix.col(j).start(j).conjugate()).coeff(0,0));
++    m_matrix.coeffRef(j,j) = tmp;
++
++    if (tmp < eps)
++    {
++      m_isPositiveDefinite = false;
++      return;
++    }
++
++    int endSize = size-j-1;
++    if (endSize>0)
++    {
++      _temporary.end(endSize) = ( m_matrix.block(j+1,0, endSize, j)
++                                  * m_matrix.col(j).start(j).conjugate() ).lazy();
++
++      m_matrix.row(j).end(endSize) = a.row(j).end(endSize).conjugate()
++                                   - _temporary.end(endSize).transpose();
++
++      m_matrix.col(j).end(endSize) = m_matrix.row(j).end(endSize) / tmp;
++    }
++  }
++}
++
++/** Computes the solution x of \f$ A x = b \f$ using the current decomposition of A.
++  * The result is stored in \a result
++  *
++  * \returns true in case of success, false otherwise.
++  *
++  * In other words, it computes \f$ b = A^{-1} b \f$ with
++  * \f$ {L^{*}}^{-1} D^{-1} L^{-1} b \f$ from right to left.
++  *
++  * \sa LDLT::solveInPlace(), MatrixBase::ldlt()
++  */
++template<typename MatrixType>
++template<typename RhsDerived, typename ResultType>
++bool LDLT<MatrixType>
++::solve(const MatrixBase<RhsDerived> &b, ResultType *result) const
++{
++  const int size = m_matrix.rows();
++  ei_assert(size==b.rows() && "LLT::solve(): invalid number of rows of the right hand side matrix b");
++  *result = b;
++  return solveInPlace(*result);
++}
++
++/** This is the \em in-place version of solve().
++  *
++  * \param bAndX represents both the right-hand side matrix b and result x.
++  *
++  * This version avoids a copy when the right hand side matrix b is not
++  * needed anymore.
++  *
++  * \sa LDLT::solve(), MatrixBase::ldlt()
++  */
++template<typename MatrixType>
++template<typename Derived>
++bool LDLT<MatrixType>::solveInPlace(MatrixBase<Derived> &bAndX) const
++{
++  const int size = m_matrix.rows();
++  ei_assert(size==bAndX.rows());
++  if (!m_isPositiveDefinite)
++    return false;
++  matrixL().solveTriangularInPlace(bAndX);
++  bAndX = (m_matrix.cwise().inverse().template part<Diagonal>() * bAndX).lazy();
++  m_matrix.adjoint().template part<UnitUpperTriangular>().solveTriangularInPlace(bAndX);
++  return true;
++}
++
++/** \cholesky_module
++  * \returns the Cholesky decomposition without square root of \c *this
++  */
++template<typename Derived>
++inline const LDLT<typename MatrixBase<Derived>::PlainMatrixType>
++MatrixBase<Derived>::ldlt() const
++{
++  return derived();
++}
++
++#endif // EIGEN_LDLT_H
index 0000000,0000000..42c959f
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,219 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra.
++//
++// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifndef EIGEN_LLT_H
++#define EIGEN_LLT_H
++
++/** \ingroup cholesky_Module
++  *
++  * \class LLT
++  *
++  * \brief Standard Cholesky decomposition (LL^T) of a matrix and associated features
++  *
++  * \param MatrixType the type of the matrix of which we are computing the LL^T Cholesky decomposition
++  *
++  * This class performs a LL^T Cholesky decomposition of a symmetric, positive definite
++  * matrix A such that A = LL^* = U^*U, where L is lower triangular.
++  *
++  * While the Cholesky decomposition is particularly useful to solve selfadjoint problems like  D^*D x = b,
++  * for that purpose, we recommend the Cholesky decomposition without square root which is more stable
++  * and even faster. Nevertheless, this standard Cholesky decomposition remains useful in many other
++  * situations like generalised eigen problems with hermitian matrices.
++  *
++  * Remember that Cholesky decompositions are not rank-revealing. This LLT decomposition is only stable on positive definite matrices,
++  * use LDLT instead for the semidefinite case. Also, do not use a Cholesky decomposition to determine whether a system of equations
++  * has a solution.
++  *
++  * \sa MatrixBase::llt(), class LDLT
++  */
++ /* HEY THIS DOX IS DISABLED BECAUSE THERE's A BUG EITHER HERE OR IN LDLT ABOUT THAT (OR BOTH)
++  * Note that during the decomposition, only the upper triangular part of A is considered. Therefore,
++  * the strict lower part does not have to store correct values.
++  */
++template<typename MatrixType> class LLT
++{
++  private:
++    typedef typename MatrixType::Scalar Scalar;
++    typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
++    typedef Matrix<Scalar, MatrixType::ColsAtCompileTime, 1> VectorType;
++
++    enum {
++      PacketSize = ei_packet_traits<Scalar>::size,
++      AlignmentMask = int(PacketSize)-1
++    };
++
++  public:
++
++    /** 
++    * \brief Default Constructor.
++    *
++    * The default constructor is useful in cases in which the user intends to
++    * perform decompositions via LLT::compute(const MatrixType&).
++    */
++    LLT() : m_matrix(), m_isInitialized(false) {}
++
++    LLT(const MatrixType& matrix)
++      : m_matrix(matrix.rows(), matrix.cols()),
++        m_isInitialized(false)
++    {
++      compute(matrix);
++    }
++
++    /** \returns the lower triangular matrix L */
++    inline Part<MatrixType, LowerTriangular> matrixL(void) const 
++    { 
++      ei_assert(m_isInitialized && "LLT is not initialized.");
++      return m_matrix; 
++    }
++    
++    /** \deprecated */
++    inline bool isPositiveDefinite(void) const { return m_isInitialized && m_isPositiveDefinite; }
++
++    template<typename RhsDerived, typename ResultType>
++    bool solve(const MatrixBase<RhsDerived> &b, ResultType *result) const;
++
++    template<typename Derived>
++    bool solveInPlace(MatrixBase<Derived> &bAndX) const;
++
++    void compute(const MatrixType& matrix);
++
++  protected:
++    /** \internal
++      * Used to compute and store L
++      * The strict upper part is not used and even not initialized.
++      */
++    MatrixType m_matrix;
++    bool m_isInitialized;
++    bool m_isPositiveDefinite;
++};
++
++/** Computes / recomputes the Cholesky decomposition A = LL^* = U^*U of \a matrix
++  */
++template<typename MatrixType>
++void LLT<MatrixType>::compute(const MatrixType& a)
++{
++  assert(a.rows()==a.cols());
++  m_isPositiveDefinite = true;
++  const int size = a.rows();
++  m_matrix.resize(size, size);
++  // The biggest overall is the point of reference to which further diagonals
++  // are compared; if any diagonal is negligible compared
++  // to the largest overall, the algorithm bails.  This cutoff is suggested
++  // in "Analysis of the Cholesky Decomposition of a Semi-definite Matrix" by
++  // Nicholas J. Higham. Also see "Accuracy and Stability of Numerical
++  // Algorithms" page 217, also by Higham.
++  const RealScalar cutoff = machine_epsilon<Scalar>() * size * a.diagonal().cwise().abs().maxCoeff();
++  RealScalar x;
++  x = ei_real(a.coeff(0,0));
++  m_matrix.coeffRef(0,0) = ei_sqrt(x);
++  if(size==1)
++  {
++    m_isInitialized = true;
++    return;
++  }
++  m_matrix.col(0).end(size-1) = a.row(0).end(size-1).adjoint() / ei_real(m_matrix.coeff(0,0));
++  for (int j = 1; j < size; ++j)
++  {
++    x = ei_real(a.coeff(j,j)) - m_matrix.row(j).start(j).squaredNorm();
++    if (x < cutoff)
++    {
++      m_isPositiveDefinite = false;
++      continue;
++    }
++
++    m_matrix.coeffRef(j,j) = x = ei_sqrt(x);
++
++    int endSize = size-j-1;
++    if (endSize>0) {
++      // Note that when all matrix columns have good alignment, then the following
++      // product is guaranteed to be optimal with respect to alignment.
++      m_matrix.col(j).end(endSize) =
++        (m_matrix.block(j+1, 0, endSize, j) * m_matrix.row(j).start(j).adjoint()).lazy();
++
++      // FIXME could use a.col instead of a.row
++      m_matrix.col(j).end(endSize) = (a.row(j).end(endSize).adjoint()
++        - m_matrix.col(j).end(endSize) ) / x;
++    }
++  }
++
++  m_isInitialized = true;
++}
++
++/** Computes the solution x of \f$ A x = b \f$ using the current decomposition of A.
++  * The result is stored in \a result
++  *
++  * \returns true always! If you need to check for existence of solutions, use another decomposition like LU, QR, or SVD.
++  *
++  * In other words, it computes \f$ b = A^{-1} b \f$ with
++  * \f$ {L^{*}}^{-1} L^{-1} b \f$ from right to left.
++  *
++  * Example: \include LLT_solve.cpp
++  * Output: \verbinclude LLT_solve.out
++  *
++  * \sa LLT::solveInPlace(), MatrixBase::llt()
++  */
++template<typename MatrixType>
++template<typename RhsDerived, typename ResultType>
++bool LLT<MatrixType>::solve(const MatrixBase<RhsDerived> &b, ResultType *result) const
++{
++  ei_assert(m_isInitialized && "LLT is not initialized.");
++  const int size = m_matrix.rows();
++  ei_assert(size==b.rows() && "LLT::solve(): invalid number of rows of the right hand side matrix b");
++  return solveInPlace((*result) = b);
++}
++
++/** This is the \em in-place version of solve().
++  *
++  * \param bAndX represents both the right-hand side matrix b and result x.
++  *
++  * \returns true always! If you need to check for existence of solutions, use another decomposition like LU, QR, or SVD.
++  *
++  * This version avoids a copy when the right hand side matrix b is not
++  * needed anymore.
++  *
++  * \sa LLT::solve(), MatrixBase::llt()
++  */
++template<typename MatrixType>
++template<typename Derived>
++bool LLT<MatrixType>::solveInPlace(MatrixBase<Derived> &bAndX) const
++{
++  ei_assert(m_isInitialized && "LLT is not initialized.");
++  const int size = m_matrix.rows();
++  ei_assert(size==bAndX.rows());
++  matrixL().solveTriangularInPlace(bAndX);
++  m_matrix.adjoint().template part<UpperTriangular>().solveTriangularInPlace(bAndX);
++  return true;
++}
++
++/** \cholesky_module
++  * \returns the LLT decomposition of \c *this
++  */
++template<typename Derived>
++inline const LLT<typename MatrixBase<Derived>::PlainMatrixType>
++MatrixBase<Derived>::llt() const
++{
++  return LLT<PlainMatrixType>(derived());
++}
++
++#endif // EIGEN_LLT_H
index 0000000,0000000..5720507
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,445 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra. Eigen itself is part of the KDE project.
++//
++// Copyright (C) 2007 Michael Olbrich <michael.olbrich@gmx.net>
++// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
++// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifndef EIGEN_ASSIGN_H
++#define EIGEN_ASSIGN_H
++
++/***************************************************************************
++* Part 1 : the logic deciding a strategy for vectorization and unrolling
++***************************************************************************/
++
++template <typename Derived, typename OtherDerived>
++struct ei_assign_traits
++{
++public:
++  enum {
++    DstIsAligned = Derived::Flags & AlignedBit,
++    SrcIsAligned = OtherDerived::Flags & AlignedBit,
++    SrcAlignment = DstIsAligned && SrcIsAligned ? Aligned : Unaligned
++  };
++
++private:
++  enum {
++    InnerSize = int(Derived::Flags)&RowMajorBit
++              ? Derived::ColsAtCompileTime
++              : Derived::RowsAtCompileTime,
++    InnerMaxSize = int(Derived::Flags)&RowMajorBit
++              ? Derived::MaxColsAtCompileTime
++              : Derived::MaxRowsAtCompileTime,
++    PacketSize = ei_packet_traits<typename Derived::Scalar>::size
++  };
++
++  enum {
++    MightVectorize = (int(Derived::Flags) & int(OtherDerived::Flags) & ActualPacketAccessBit)
++                  && ((int(Derived::Flags)&RowMajorBit)==(int(OtherDerived::Flags)&RowMajorBit)),
++    MayInnerVectorize  = MightVectorize && int(InnerSize)!=Dynamic && int(InnerSize)%int(PacketSize)==0
++                       && int(DstIsAligned) && int(SrcIsAligned),
++    MayLinearVectorize = MightVectorize && (int(Derived::Flags) & int(OtherDerived::Flags) & LinearAccessBit),
++    MaySliceVectorize  = MightVectorize && int(InnerMaxSize)>=3*PacketSize /* slice vectorization can be slow, so we only
++      want it if the slices are big, which is indicated by InnerMaxSize rather than InnerSize, think of the case
++      of a dynamic block in a fixed-size matrix */
++  };
++
++public:
++  enum {
++    Vectorization = int(MayInnerVectorize)  ? int(InnerVectorization)
++                  : int(MayLinearVectorize) ? int(LinearVectorization)
++                  : int(MaySliceVectorize)  ? int(SliceVectorization)
++                                            : int(NoVectorization)
++  };
++
++private:
++  enum {
++    UnrollingLimit      = EIGEN_UNROLLING_LIMIT * (int(Vectorization) == int(NoVectorization) ? 1 : int(PacketSize)),
++    MayUnrollCompletely = int(Derived::SizeAtCompileTime) * int(OtherDerived::CoeffReadCost) <= int(UnrollingLimit),
++    MayUnrollInner      = int(InnerSize * OtherDerived::CoeffReadCost) <= int(UnrollingLimit)
++  };
++
++public:
++  enum {
++    Unrolling = (int(Vectorization) == int(InnerVectorization) || int(Vectorization) == int(NoVectorization))
++              ? (
++                   int(MayUnrollCompletely) ? int(CompleteUnrolling)
++                 : int(MayUnrollInner)      ? int(InnerUnrolling)
++                                            : int(NoUnrolling)
++                )
++              : int(Vectorization) == int(LinearVectorization)
++              ? ( int(MayUnrollCompletely) && int(DstIsAligned) ? int(CompleteUnrolling) : int(NoUnrolling) )
++              : int(NoUnrolling)
++  };
++};
++
++/***************************************************************************
++* Part 2 : meta-unrollers
++***************************************************************************/
++
++/***********************
++*** No vectorization ***
++***********************/
++
++template<typename Derived1, typename Derived2, int Index, int Stop>
++struct ei_assign_novec_CompleteUnrolling
++{
++  enum {
++    row = int(Derived1::Flags)&RowMajorBit
++        ? Index / int(Derived1::ColsAtCompileTime)
++        : Index % Derived1::RowsAtCompileTime,
++    col = int(Derived1::Flags)&RowMajorBit
++        ? Index % int(Derived1::ColsAtCompileTime)
++        : Index / Derived1::RowsAtCompileTime
++  };
++
++  EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src)
++  {
++    dst.copyCoeff(row, col, src);
++    ei_assign_novec_CompleteUnrolling<Derived1, Derived2, Index+1, Stop>::run(dst, src);
++  }
++};
++
++template<typename Derived1, typename Derived2, int Stop>
++struct ei_assign_novec_CompleteUnrolling<Derived1, Derived2, Stop, Stop>
++{
++  EIGEN_STRONG_INLINE static void run(Derived1 &, const Derived2 &) {}
++};
++
++template<typename Derived1, typename Derived2, int Index, int Stop>
++struct ei_assign_novec_InnerUnrolling
++{
++  EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src, int row_or_col)
++  {
++    const bool rowMajor = int(Derived1::Flags)&RowMajorBit;
++    const int row = rowMajor ? row_or_col : Index;
++    const int col = rowMajor ? Index : row_or_col;
++    dst.copyCoeff(row, col, src);
++    ei_assign_novec_InnerUnrolling<Derived1, Derived2, Index+1, Stop>::run(dst, src, row_or_col);
++  }
++};
++
++template<typename Derived1, typename Derived2, int Stop>
++struct ei_assign_novec_InnerUnrolling<Derived1, Derived2, Stop, Stop>
++{
++  EIGEN_STRONG_INLINE static void run(Derived1 &, const Derived2 &, int) {}
++};
++
++/**************************
++*** Inner vectorization ***
++**************************/
++
++template<typename Derived1, typename Derived2, int Index, int Stop>
++struct ei_assign_innervec_CompleteUnrolling
++{
++  enum {
++    row = int(Derived1::Flags)&RowMajorBit
++        ? Index / int(Derived1::ColsAtCompileTime)
++        : Index % Derived1::RowsAtCompileTime,
++    col = int(Derived1::Flags)&RowMajorBit
++        ? Index % int(Derived1::ColsAtCompileTime)
++        : Index / Derived1::RowsAtCompileTime,
++    SrcAlignment = ei_assign_traits<Derived1,Derived2>::SrcAlignment
++  };
++
++  EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src)
++  {
++    dst.template copyPacket<Derived2, Aligned, SrcAlignment>(row, col, src);
++    ei_assign_innervec_CompleteUnrolling<Derived1, Derived2,
++      Index+ei_packet_traits<typename Derived1::Scalar>::size, Stop>::run(dst, src);
++  }
++};
++
++template<typename Derived1, typename Derived2, int Stop>
++struct ei_assign_innervec_CompleteUnrolling<Derived1, Derived2, Stop, Stop>
++{
++  EIGEN_STRONG_INLINE static void run(Derived1 &, const Derived2 &) {}
++};
++
++template<typename Derived1, typename Derived2, int Index, int Stop>
++struct ei_assign_innervec_InnerUnrolling
++{
++  EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src, int row_or_col)
++  {
++    const int row = int(Derived1::Flags)&RowMajorBit ? row_or_col : Index;
++    const int col = int(Derived1::Flags)&RowMajorBit ? Index : row_or_col;
++    dst.template copyPacket<Derived2, Aligned, Aligned>(row, col, src);
++    ei_assign_innervec_InnerUnrolling<Derived1, Derived2,
++      Index+ei_packet_traits<typename Derived1::Scalar>::size, Stop>::run(dst, src, row_or_col);
++  }
++};
++
++template<typename Derived1, typename Derived2, int Stop>
++struct ei_assign_innervec_InnerUnrolling<Derived1, Derived2, Stop, Stop>
++{
++  EIGEN_STRONG_INLINE static void run(Derived1 &, const Derived2 &, int) {}
++};
++
++/***************************************************************************
++* Part 3 : implementation of all cases
++***************************************************************************/
++
++template<typename Derived1, typename Derived2,
++         int Vectorization = ei_assign_traits<Derived1, Derived2>::Vectorization,
++         int Unrolling = ei_assign_traits<Derived1, Derived2>::Unrolling>
++struct ei_assign_impl;
++
++/***********************
++*** No vectorization ***
++***********************/
++
++template<typename Derived1, typename Derived2>
++struct ei_assign_impl<Derived1, Derived2, NoVectorization, NoUnrolling>
++{
++  inline static void run(Derived1 &dst, const Derived2 &src)
++  {
++    const int innerSize = dst.innerSize();
++    const int outerSize = dst.outerSize();
++    for(int j = 0; j < outerSize; ++j)
++      for(int i = 0; i < innerSize; ++i)
++      {
++        if(int(Derived1::Flags)&RowMajorBit)
++          dst.copyCoeff(j, i, src);
++        else
++          dst.copyCoeff(i, j, src);
++      }
++  }
++};
++
++template<typename Derived1, typename Derived2>
++struct ei_assign_impl<Derived1, Derived2, NoVectorization, CompleteUnrolling>
++{
++  EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src)
++  {
++    ei_assign_novec_CompleteUnrolling<Derived1, Derived2, 0, Derived1::SizeAtCompileTime>
++      ::run(dst, src);
++  }
++};
++
++template<typename Derived1, typename Derived2>
++struct ei_assign_impl<Derived1, Derived2, NoVectorization, InnerUnrolling>
++{
++  EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src)
++  {
++    const bool rowMajor = int(Derived1::Flags)&RowMajorBit;
++    const int innerSize = rowMajor ? Derived1::ColsAtCompileTime : Derived1::RowsAtCompileTime;
++    const int outerSize = dst.outerSize();
++    for(int j = 0; j < outerSize; ++j)
++      ei_assign_novec_InnerUnrolling<Derived1, Derived2, 0, innerSize>
++        ::run(dst, src, j);
++  }
++};
++
++/**************************
++*** Inner vectorization ***
++**************************/
++
++template<typename Derived1, typename Derived2>
++struct ei_assign_impl<Derived1, Derived2, InnerVectorization, NoUnrolling>
++{
++  inline static void run(Derived1 &dst, const Derived2 &src)
++  {
++    const int innerSize = dst.innerSize();
++    const int outerSize = dst.outerSize();
++    const int packetSize = ei_packet_traits<typename Derived1::Scalar>::size;
++    for(int j = 0; j < outerSize; ++j)
++      for(int i = 0; i < innerSize; i+=packetSize)
++      {
++        if(int(Derived1::Flags)&RowMajorBit)
++          dst.template copyPacket<Derived2, Aligned, Aligned>(j, i, src);
++        else
++          dst.template copyPacket<Derived2, Aligned, Aligned>(i, j, src);
++      }
++  }
++};
++
++template<typename Derived1, typename Derived2>
++struct ei_assign_impl<Derived1, Derived2, InnerVectorization, CompleteUnrolling>
++{
++  EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src)
++  {
++    ei_assign_innervec_CompleteUnrolling<Derived1, Derived2, 0, Derived1::SizeAtCompileTime>
++      ::run(dst, src);
++  }
++};
++
++template<typename Derived1, typename Derived2>
++struct ei_assign_impl<Derived1, Derived2, InnerVectorization, InnerUnrolling>
++{
++  EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src)
++  {
++    const bool rowMajor = int(Derived1::Flags)&RowMajorBit;
++    const int innerSize = rowMajor ? Derived1::ColsAtCompileTime : Derived1::RowsAtCompileTime;
++    const int outerSize = dst.outerSize();
++    for(int j = 0; j < outerSize; ++j)
++      ei_assign_innervec_InnerUnrolling<Derived1, Derived2, 0, innerSize>
++        ::run(dst, src, j);
++  }
++};
++
++/***************************
++*** Linear vectorization ***
++***************************/
++
++template<typename Derived1, typename Derived2>
++struct ei_assign_impl<Derived1, Derived2, LinearVectorization, NoUnrolling>
++{
++  inline static void run(Derived1 &dst, const Derived2 &src)
++  {
++    const int size = dst.size();
++    const int packetSize = ei_packet_traits<typename Derived1::Scalar>::size;
++    const int alignedStart = ei_assign_traits<Derived1,Derived2>::DstIsAligned ? 0
++                           : ei_alignmentOffset(&dst.coeffRef(0), size);
++    const int alignedEnd = alignedStart + ((size-alignedStart)/packetSize)*packetSize;
++
++    for(int index = 0; index < alignedStart; ++index)
++      dst.copyCoeff(index, src);
++
++    for(int index = alignedStart; index < alignedEnd; index += packetSize)
++    {
++      dst.template copyPacket<Derived2, Aligned, ei_assign_traits<Derived1,Derived2>::SrcAlignment>(index, src);
++    }
++
++    for(int index = alignedEnd; index < size; ++index)
++      dst.copyCoeff(index, src);
++  }
++};
++
++template<typename Derived1, typename Derived2>
++struct ei_assign_impl<Derived1, Derived2, LinearVectorization, CompleteUnrolling>
++{
++  EIGEN_STRONG_INLINE static void run(Derived1 &dst, const Derived2 &src)
++  {
++    const int size = Derived1::SizeAtCompileTime;
++    const int packetSize = ei_packet_traits<typename Derived1::Scalar>::size;
++    const int alignedSize = (size/packetSize)*packetSize;
++
++    ei_assign_innervec_CompleteUnrolling<Derived1, Derived2, 0, alignedSize>::run(dst, src);
++    ei_assign_novec_CompleteUnrolling<Derived1, Derived2, alignedSize, size>::run(dst, src);
++  }
++};
++
++/**************************
++*** Slice vectorization ***
++***************************/
++
++template<typename Derived1, typename Derived2>
++struct ei_assign_impl<Derived1, Derived2, SliceVectorization, NoUnrolling>
++{
++  inline static void run(Derived1 &dst, const Derived2 &src)
++  {
++    const int packetSize = ei_packet_traits<typename Derived1::Scalar>::size;
++    const int packetAlignedMask = packetSize - 1;
++    const int innerSize = dst.innerSize();
++    const int outerSize = dst.outerSize();
++    const int alignedStep = (packetSize - dst.stride() % packetSize) & packetAlignedMask;
++    int alignedStart = ei_assign_traits<Derived1,Derived2>::DstIsAligned ? 0
++                     : ei_alignmentOffset(&dst.coeffRef(0,0), innerSize);
++
++    for(int i = 0; i < outerSize; ++i)
++    {
++      const int alignedEnd = alignedStart + ((innerSize-alignedStart) & ~packetAlignedMask);
++
++      // do the non-vectorizable part of the assignment
++      for (int index = 0; index<alignedStart ; ++index)
++      {
++        if(Derived1::Flags&RowMajorBit)
++          dst.copyCoeff(i, index, src);
++        else
++          dst.copyCoeff(index, i, src);
++      }
++
++      // do the vectorizable part of the assignment
++      for (int index = alignedStart; index<alignedEnd; index+=packetSize)
++      {
++        if(Derived1::Flags&RowMajorBit)
++          dst.template copyPacket<Derived2, Aligned, Unaligned>(i, index, src);
++        else
++          dst.template copyPacket<Derived2, Aligned, Unaligned>(index, i, src);
++      }
++
++      // do the non-vectorizable part of the assignment
++      for (int index = alignedEnd; index<innerSize ; ++index)
++      {
++        if(Derived1::Flags&RowMajorBit)
++          dst.copyCoeff(i, index, src);
++        else
++          dst.copyCoeff(index, i, src);
++      }
++
++      alignedStart = std::min<int>((alignedStart+alignedStep)%packetSize, innerSize);
++    }
++  }
++};
++
++/***************************************************************************
++* Part 4 : implementation of MatrixBase methods
++***************************************************************************/
++
++template<typename Derived>
++template<typename OtherDerived>
++EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>
++  ::lazyAssign(const MatrixBase<OtherDerived>& other)
++{
++  EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Derived,OtherDerived)
++  EIGEN_STATIC_ASSERT((ei_is_same_type<typename Derived::Scalar, typename OtherDerived::Scalar>::ret),
++    YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
++  ei_assert(rows() == other.rows() && cols() == other.cols());
++  ei_assign_impl<Derived, OtherDerived>::run(derived(),other.derived());
++  return derived();
++}
++
++template<typename Derived, typename OtherDerived,
++         bool EvalBeforeAssigning = (int(OtherDerived::Flags) & EvalBeforeAssigningBit) != 0,
++         bool NeedToTranspose = Derived::IsVectorAtCompileTime
++                && OtherDerived::IsVectorAtCompileTime
++                && int(Derived::RowsAtCompileTime) == int(OtherDerived::ColsAtCompileTime)
++                && int(Derived::ColsAtCompileTime) == int(OtherDerived::RowsAtCompileTime)
++                && int(Derived::SizeAtCompileTime) != 1>
++struct ei_assign_selector;
++
++template<typename Derived, typename OtherDerived>
++struct ei_assign_selector<Derived,OtherDerived,false,false> {
++  EIGEN_STRONG_INLINE static Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.derived()); }
++};
++template<typename Derived, typename OtherDerived>
++struct ei_assign_selector<Derived,OtherDerived,true,false> {
++  EIGEN_STRONG_INLINE static Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.eval()); }
++};
++template<typename Derived, typename OtherDerived>
++struct ei_assign_selector<Derived,OtherDerived,false,true> {
++  EIGEN_STRONG_INLINE static Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.transpose()); }
++};
++template<typename Derived, typename OtherDerived>
++struct ei_assign_selector<Derived,OtherDerived,true,true> {
++  EIGEN_STRONG_INLINE static Derived& run(Derived& dst, const OtherDerived& other) { return dst.lazyAssign(other.transpose().eval()); }
++};
++
++template<typename Derived>
++template<typename OtherDerived>
++EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>
++  ::operator=(const MatrixBase<OtherDerived>& other)
++{
++  return ei_assign_selector<Derived,OtherDerived>::run(derived(), other.derived());
++}
++
++#endif // EIGEN_ASSIGN_H
index 0000000,0000000..7f422aa
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,752 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra. Eigen itself is part of the KDE project.
++//
++// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
++// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifndef EIGEN_BLOCK_H
++#define EIGEN_BLOCK_H
++
++/** \class Block
++  *
++  * \brief Expression of a fixed-size or dynamic-size block
++  *
++  * \param MatrixType the type of the object in which we are taking a block
++  * \param BlockRows the number of rows of the block we are taking at compile time (optional)
++  * \param BlockCols the number of columns of the block we are taking at compile time (optional)
++  * \param _PacketAccess allows to enforce aligned loads and stores if set to ForceAligned.
++  *                      The default is AsRequested. This parameter is internaly used by Eigen
++  *                      in expressions such as \code mat.block() += other; \endcode and most of
++  *                      the time this is the only way it is used.
++  * \param _DirectAccessStatus \internal used for partial specialization
++  *
++  * This class represents an expression of either a fixed-size or dynamic-size block. It is the return
++  * type of MatrixBase::block(int,int,int,int) and MatrixBase::block<int,int>(int,int) and
++  * most of the time this is the only way it is used.
++  *
++  * However, if you want to directly maniputate block expressions,
++  * for instance if you want to write a function returning such an expression, you
++  * will need to use this class.
++  *
++  * Here is an example illustrating the dynamic case:
++  * \include class_Block.cpp
++  * Output: \verbinclude class_Block.out
++  *
++  * \note Even though this expression has dynamic size, in the case where \a MatrixType
++  * has fixed size, this expression inherits a fixed maximal size which means that evaluating
++  * it does not cause a dynamic memory allocation.
++  *
++  * Here is an example illustrating the fixed-size case:
++  * \include class_FixedBlock.cpp
++  * Output: \verbinclude class_FixedBlock.out
++  *
++  * \sa MatrixBase::block(int,int,int,int), MatrixBase::block(int,int), class VectorBlock
++  */
++
++template<typename MatrixType, int BlockRows, int BlockCols, int _PacketAccess, int _DirectAccessStatus>
++struct ei_traits<Block<MatrixType, BlockRows, BlockCols, _PacketAccess, _DirectAccessStatus> >
++{
++  typedef typename ei_traits<MatrixType>::Scalar Scalar;
++  typedef typename ei_nested<MatrixType>::type MatrixTypeNested;
++  typedef typename ei_unref<MatrixTypeNested>::type _MatrixTypeNested;
++  enum{
++    RowsAtCompileTime = ei_traits<MatrixType>::RowsAtCompileTime == 1 ? 1 : BlockRows,
++    ColsAtCompileTime = ei_traits<MatrixType>::ColsAtCompileTime == 1 ? 1 : BlockCols,
++    MaxRowsAtCompileTime = RowsAtCompileTime == 1 ? 1
++      : (BlockRows==Dynamic ? int(ei_traits<MatrixType>::MaxRowsAtCompileTime) : BlockRows),
++    MaxColsAtCompileTime = ColsAtCompileTime == 1 ? 1
++      : (BlockCols==Dynamic ? int(ei_traits<MatrixType>::MaxColsAtCompileTime) : BlockCols),
++    RowMajor = int(ei_traits<MatrixType>::Flags)&RowMajorBit,
++    InnerSize = RowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
++    InnerMaxSize = RowMajor ? int(MaxColsAtCompileTime) : int(MaxRowsAtCompileTime),
++    MaskPacketAccessBit = (InnerMaxSize == Dynamic || (InnerSize >= ei_packet_traits<Scalar>::size))
++                        ? PacketAccessBit : 0,
++    FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1) ? LinearAccessBit : 0,
++    Flags = (ei_traits<MatrixType>::Flags & (HereditaryBits | MaskPacketAccessBit | DirectAccessBit)) | FlagsLinearAccessBit,
++    CoeffReadCost = ei_traits<MatrixType>::CoeffReadCost,
++    PacketAccess = _PacketAccess
++  };
++  typedef typename ei_meta_if<int(PacketAccess)==ForceAligned,
++                 Block<MatrixType, BlockRows, BlockCols, _PacketAccess, _DirectAccessStatus>&,
++                 Block<MatrixType, BlockRows, BlockCols, ForceAligned, _DirectAccessStatus> >::ret AlignedDerivedType;
++};
++
++template<typename MatrixType, int BlockRows, int BlockCols, int PacketAccess, int _DirectAccessStatus> class Block
++  : public MatrixBase<Block<MatrixType, BlockRows, BlockCols, PacketAccess, _DirectAccessStatus> >
++{
++  public:
++
++    EIGEN_GENERIC_PUBLIC_INTERFACE(Block)
++
++    class InnerIterator;
++
++    /** Column or Row constructor
++      */
++    inline Block(const MatrixType& matrix, int i)
++      : m_matrix(matrix),
++        // It is a row if and only if BlockRows==1 and BlockCols==MatrixType::ColsAtCompileTime,
++        // and it is a column if and only if BlockRows==MatrixType::RowsAtCompileTime and BlockCols==1,
++        // all other cases are invalid.
++        // The case a 1x1 matrix seems ambiguous, but the result is the same anyway.
++        m_startRow( (BlockRows==1) && (BlockCols==MatrixType::ColsAtCompileTime) ? i : 0),
++        m_startCol( (BlockRows==MatrixType::RowsAtCompileTime) && (BlockCols==1) ? i : 0),
++        m_blockRows(matrix.rows()), // if it is a row, then m_blockRows has a fixed-size of 1, so no pb to try to overwrite it
++        m_blockCols(matrix.cols())  // same for m_blockCols
++    {
++      ei_assert( (i>=0) && (
++          ((BlockRows==1) && (BlockCols==MatrixType::ColsAtCompileTime) && i<matrix.rows())
++        ||((BlockRows==MatrixType::RowsAtCompileTime) && (BlockCols==1) && i<matrix.cols())));
++    }
++
++    /** Fixed-size constructor
++      */
++    inline Block(const MatrixType& matrix, int startRow, int startCol)
++      : m_matrix(matrix), m_startRow(startRow), m_startCol(startCol),
++        m_blockRows(matrix.rows()), m_blockCols(matrix.cols())
++    {
++      EIGEN_STATIC_ASSERT(RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic,THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE)
++      ei_assert(startRow >= 0 && BlockRows >= 1 && startRow + BlockRows <= matrix.rows()
++          && startCol >= 0 && BlockCols >= 1 && startCol + BlockCols <= matrix.cols());
++    }
++
++    /** Dynamic-size constructor
++      */
++    inline Block(const MatrixType& matrix,
++          int startRow, int startCol,
++          int blockRows, int blockCols)
++      : m_matrix(matrix), m_startRow(startRow), m_startCol(startCol),
++                          m_blockRows(blockRows), m_blockCols(blockCols)
++    {
++      ei_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows)
++          && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==blockCols));
++      ei_assert(startRow >= 0 && blockRows >= 1 && startRow + blockRows <= matrix.rows()
++          && startCol >= 0 && blockCols >= 1 && startCol + blockCols <= matrix.cols());
++    }
++
++    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block)
++
++    inline int rows() const { return m_blockRows.value(); }
++    inline int cols() const { return m_blockCols.value(); }
++
++    inline Scalar& coeffRef(int row, int col)
++    {
++      return m_matrix.const_cast_derived()
++               .coeffRef(row + m_startRow.value(), col + m_startCol.value());
++    }
++
++    inline const Scalar coeff(int row, int col) const
++    {
++      return m_matrix.coeff(row + m_startRow.value(), col + m_startCol.value());
++    }
++
++    inline Scalar& coeffRef(int index)
++    {
++      return m_matrix.const_cast_derived()
++             .coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
++                       m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
++    }
++
++    inline const Scalar coeff(int index) const
++    {
++      return m_matrix
++             .coeff(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
++                    m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
++    }
++
++    template<int LoadMode>
++    inline PacketScalar packet(int row, int col) const
++    {
++      return m_matrix.template packet<Unaligned>
++              (row + m_startRow.value(), col + m_startCol.value());
++    }
++
++    template<int LoadMode>
++    inline void writePacket(int row, int col, const PacketScalar& x)
++    {
++      m_matrix.const_cast_derived().template writePacket<Unaligned>
++              (row + m_startRow.value(), col + m_startCol.value(), x);
++    }
++
++    template<int LoadMode>
++    inline PacketScalar packet(int index) const
++    {
++      return m_matrix.template packet<Unaligned>
++              (m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
++               m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
++    }
++
++    template<int LoadMode>
++    inline void writePacket(int index, const PacketScalar& x)
++    {
++      m_matrix.const_cast_derived().template writePacket<Unaligned>
++         (m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
++          m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0), x);
++    }
++
++  protected:
++
++    const typename MatrixType::Nested m_matrix;
++    const ei_int_if_dynamic<MatrixType::RowsAtCompileTime == 1 ? 0 : Dynamic> m_startRow;
++    const ei_int_if_dynamic<MatrixType::ColsAtCompileTime == 1 ? 0 : Dynamic> m_startCol;
++    const ei_int_if_dynamic<RowsAtCompileTime> m_blockRows;
++    const ei_int_if_dynamic<ColsAtCompileTime> m_blockCols;
++};
++
++/** \internal */
++template<typename MatrixType, int BlockRows, int BlockCols, int PacketAccess>
++class Block<MatrixType,BlockRows,BlockCols,PacketAccess,HasDirectAccess>
++  : public MapBase<Block<MatrixType, BlockRows, BlockCols,PacketAccess,HasDirectAccess> >
++{
++  public:
++
++    _EIGEN_GENERIC_PUBLIC_INTERFACE(Block, MapBase<Block>)
++
++    class InnerIterator;
++    typedef typename ei_traits<Block>::AlignedDerivedType AlignedDerivedType;
++    friend class Block<MatrixType,BlockRows,BlockCols,PacketAccess==AsRequested?ForceAligned:AsRequested,HasDirectAccess>;
++
++    EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block)
++
++    AlignedDerivedType _convertToForceAligned()
++    {
++      return Block<MatrixType,BlockRows,BlockCols,ForceAligned,HasDirectAccess>
++                    (m_matrix, Base::m_data, Base::m_rows.value(), Base::m_cols.value());
++    }
++
++    /** Column or Row constructor
++      */
++    inline Block(const MatrixType& matrix, int i)
++      : Base(&matrix.const_cast_derived().coeffRef(
++              (BlockRows==1) && (BlockCols==MatrixType::ColsAtCompileTime) ? i : 0,
++              (BlockRows==MatrixType::RowsAtCompileTime) && (BlockCols==1) ? i : 0),
++             BlockRows==1 ? 1 : matrix.rows(),
++             BlockCols==1 ? 1 : matrix.cols()),
++        m_matrix(matrix)
++    {
++      ei_assert( (i>=0) && (
++          ((BlockRows==1) && (BlockCols==MatrixType::ColsAtCompileTime) && i<matrix.rows())
++        ||((BlockRows==MatrixType::RowsAtCompileTime) && (BlockCols==1) && i<matrix.cols())));
++    }
++
++    /** Fixed-size constructor
++      */
++    inline Block(const MatrixType& matrix, int startRow, int startCol)
++      : Base(&matrix.const_cast_derived().coeffRef(startRow,startCol)), m_matrix(matrix)
++    {
++      ei_assert(startRow >= 0 && BlockRows >= 1 && startRow + BlockRows <= matrix.rows()
++             && startCol >= 0 && BlockCols >= 1 && startCol + BlockCols <= matrix.cols());
++    }
++
++    /** Dynamic-size constructor
++      */
++    inline Block(const MatrixType& matrix,
++          int startRow, int startCol,
++          int blockRows, int blockCols)
++      : Base(&matrix.const_cast_derived().coeffRef(startRow,startCol), blockRows, blockCols),
++        m_matrix(matrix)
++    {
++      ei_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows)
++             && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==blockCols));
++      ei_assert(startRow >= 0 && blockRows >= 1 && startRow + blockRows <= matrix.rows()
++             && startCol >= 0 && blockCols >= 1 && startCol + blockCols <= matrix.cols());
++    }
++
++    inline int stride(void) const { return m_matrix.stride(); }
++
++  protected:
++
++    /** \internal used by allowAligned() */
++    inline Block(const MatrixType& matrix, const Scalar* data, int blockRows, int blockCols)
++      : Base(data, blockRows, blockCols), m_matrix(matrix)
++    {}
++
++    const typename MatrixType::Nested m_matrix;
++};
++
++/** \returns a dynamic-size expression of a block in *this.
++  *
++  * \param startRow the first row in the block
++  * \param startCol the first column in the block
++  * \param blockRows the number of rows in the block
++  * \param blockCols the number of columns in the block
++  *
++  * \addexample BlockIntIntIntInt \label How to reference a sub-matrix (dynamic-size)
++  *
++  * Example: \include MatrixBase_block_int_int_int_int.cpp
++  * Output: \verbinclude MatrixBase_block_int_int_int_int.out
++  *
++  * \note Even though the returned expression has dynamic size, in the case
++  * when it is applied to a fixed-size matrix, it inherits a fixed maximal size,
++  * which means that evaluating it does not cause a dynamic memory allocation.
++  *
++  * \sa class Block, block(int,int)
++  */
++template<typename Derived>
++inline typename BlockReturnType<Derived>::Type MatrixBase<Derived>
++  ::block(int startRow, int startCol, int blockRows, int blockCols)
++{
++  return typename BlockReturnType<Derived>::Type(derived(), startRow, startCol, blockRows, blockCols);
++}
++
++/** This is the const version of block(int,int,int,int). */
++template<typename Derived>
++inline const typename BlockReturnType<Derived>::Type MatrixBase<Derived>
++  ::block(int startRow, int startCol, int blockRows, int blockCols) const
++{
++  return typename BlockReturnType<Derived>::Type(derived(), startRow, startCol, blockRows, blockCols);
++}
++
++/** \returns a dynamic-size expression of a segment (i.e. a vector block) in *this.
++  *
++  * \only_for_vectors
++  *
++  * \addexample SegmentIntInt \label How to reference a sub-vector (dynamic size)
++  *
++  * \param start the first coefficient in the segment
++  * \param size the number of coefficients in the segment
++  *
++  * Example: \include MatrixBase_segment_int_int.cpp
++  * Output: \verbinclude MatrixBase_segment_int_int.out
++  *
++  * \note Even though the returned expression has dynamic size, in the case
++  * when it is applied to a fixed-size vector, it inherits a fixed maximal size,
++  * which means that evaluating it does not cause a dynamic memory allocation.
++  *
++  * \sa class Block, segment(int)
++  */
++template<typename Derived>
++inline typename BlockReturnType<Derived>::SubVectorType MatrixBase<Derived>
++  ::segment(int start, int size)
++{
++  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
++  return typename BlockReturnType<Derived>::SubVectorType(derived(), RowsAtCompileTime == 1 ? 0 : start,
++                                   ColsAtCompileTime == 1 ? 0 : start,
++                                   RowsAtCompileTime == 1 ? 1 : size,
++                                   ColsAtCompileTime == 1 ? 1 : size);
++}
++
++/** This is the const version of segment(int,int).*/
++template<typename Derived>
++inline const typename BlockReturnType<Derived>::SubVectorType
++MatrixBase<Derived>::segment(int start, int size) const
++{
++  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
++  return typename BlockReturnType<Derived>::SubVectorType(derived(), RowsAtCompileTime == 1 ? 0 : start,
++                                   ColsAtCompileTime == 1 ? 0 : start,
++                                   RowsAtCompileTime == 1 ? 1 : size,
++                                   ColsAtCompileTime == 1 ? 1 : size);
++}
++
++/** \returns a dynamic-size expression of the first coefficients of *this.
++  *
++  * \only_for_vectors
++  *
++  * \param size the number of coefficients in the block
++  *
++  * \addexample BlockInt \label How to reference a sub-vector (fixed-size)
++  *
++  * Example: \include MatrixBase_start_int.cpp
++  * Output: \verbinclude MatrixBase_start_int.out
++  *
++  * \note Even though the returned expression has dynamic size, in the case
++  * when it is applied to a fixed-size vector, it inherits a fixed maximal size,
++  * which means that evaluating it does not cause a dynamic memory allocation.
++  *
++  * \sa class Block, block(int,int)
++  */
++template<typename Derived>
++inline typename BlockReturnType<Derived,Dynamic>::SubVectorType
++MatrixBase<Derived>::start(int size)
++{
++  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
++  return Block<Derived,
++               RowsAtCompileTime == 1 ? 1 : Dynamic,
++               ColsAtCompileTime == 1 ? 1 : Dynamic>
++              (derived(), 0, 0,
++               RowsAtCompileTime == 1 ? 1 : size,
++               ColsAtCompileTime == 1 ? 1 : size);
++}
++
++/** This is the const version of start(int).*/
++template<typename Derived>
++inline const typename BlockReturnType<Derived,Dynamic>::SubVectorType
++MatrixBase<Derived>::start(int size) const
++{
++  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
++  return Block<Derived,
++               RowsAtCompileTime == 1 ? 1 : Dynamic,
++               ColsAtCompileTime == 1 ? 1 : Dynamic>
++              (derived(), 0, 0,
++               RowsAtCompileTime == 1 ? 1 : size,
++               ColsAtCompileTime == 1 ? 1 : size);
++}
++
++/** \returns a dynamic-size expression of the last coefficients of *this.
++  *
++  * \only_for_vectors
++  *
++  * \param size the number of coefficients in the block
++  *
++  * \addexample BlockEnd \label How to reference the end of a vector (fixed-size)
++  *
++  * Example: \include MatrixBase_end_int.cpp
++  * Output: \verbinclude MatrixBase_end_int.out
++  *
++  * \note Even though the returned expression has dynamic size, in the case
++  * when it is applied to a fixed-size vector, it inherits a fixed maximal size,
++  * which means that evaluating it does not cause a dynamic memory allocation.
++  *
++  * \sa class Block, block(int,int)
++  */
++template<typename Derived>
++inline typename BlockReturnType<Derived,Dynamic>::SubVectorType
++MatrixBase<Derived>::end(int size)
++{
++  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
++  return Block<Derived,
++               RowsAtCompileTime == 1 ? 1 : Dynamic,
++               ColsAtCompileTime == 1 ? 1 : Dynamic>
++              (derived(),
++               RowsAtCompileTime == 1 ? 0 : rows() - size,
++               ColsAtCompileTime == 1 ? 0 : cols() - size,
++               RowsAtCompileTime == 1 ? 1 : size,
++               ColsAtCompileTime == 1 ? 1 : size);
++}
++
++/** This is the const version of end(int).*/
++template<typename Derived>
++inline const typename BlockReturnType<Derived,Dynamic>::SubVectorType
++MatrixBase<Derived>::end(int size) const
++{
++  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
++  return Block<Derived,
++               RowsAtCompileTime == 1 ? 1 : Dynamic,
++               ColsAtCompileTime == 1 ? 1 : Dynamic>
++              (derived(),
++               RowsAtCompileTime == 1 ? 0 : rows() - size,
++               ColsAtCompileTime == 1 ? 0 : cols() - size,
++               RowsAtCompileTime == 1 ? 1 : size,
++               ColsAtCompileTime == 1 ? 1 : size);
++}
++
++/** \returns a fixed-size expression of a segment (i.e. a vector block) in \c *this
++  *
++  * \only_for_vectors
++  *
++  * The template parameter \a Size is the number of coefficients in the block
++  *
++  * \param start the index of the first element of the sub-vector
++  *
++  * Example: \include MatrixBase_template_int_segment.cpp
++  * Output: \verbinclude MatrixBase_template_int_segment.out
++  *
++  * \sa class Block
++  */
++template<typename Derived>
++template<int Size>
++inline typename BlockReturnType<Derived,Size>::SubVectorType
++MatrixBase<Derived>::segment(int start)
++{
++  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
++  return Block<Derived,  (RowsAtCompileTime == 1 ? 1 : Size),
++                         (ColsAtCompileTime == 1 ? 1 : Size)>
++              (derived(), RowsAtCompileTime == 1 ? 0 : start,
++                          ColsAtCompileTime == 1 ? 0 : start);
++}
++
++/** This is the const version of segment<int>(int).*/
++template<typename Derived>
++template<int Size>
++inline const typename BlockReturnType<Derived,Size>::SubVectorType
++MatrixBase<Derived>::segment(int start) const
++{
++  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
++  return Block<Derived,  (RowsAtCompileTime == 1 ? 1 : Size),
++                         (ColsAtCompileTime == 1 ? 1 : Size)>
++              (derived(), RowsAtCompileTime == 1 ? 0 : start,
++                          ColsAtCompileTime == 1 ? 0 : start);
++}
++
++/** \returns a fixed-size expression of the first coefficients of *this.
++  *
++  * \only_for_vectors
++  *
++  * The template parameter \a Size is the number of coefficients in the block
++  *
++  * \addexample BlockStart \label How to reference the start of a vector (fixed-size)
++  *
++  * Example: \include MatrixBase_template_int_start.cpp
++  * Output: \verbinclude MatrixBase_template_int_start.out
++  *
++  * \sa class Block
++  */
++template<typename Derived>
++template<int Size>
++inline typename BlockReturnType<Derived,Size>::SubVectorType
++MatrixBase<Derived>::start()
++{
++  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
++  return Block<Derived, (RowsAtCompileTime == 1 ? 1 : Size),
++                        (ColsAtCompileTime == 1 ? 1 : Size)>(derived(), 0, 0);
++}
++
++/** This is the const version of start<int>().*/
++template<typename Derived>
++template<int Size>
++inline const typename BlockReturnType<Derived,Size>::SubVectorType
++MatrixBase<Derived>::start() const
++{
++  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
++  return Block<Derived, (RowsAtCompileTime == 1 ? 1 : Size),
++                        (ColsAtCompileTime == 1 ? 1 : Size)>(derived(), 0, 0);
++}
++
++/** \returns a fixed-size expression of the last coefficients of *this.
++  *
++  * \only_for_vectors
++  *
++  * The template parameter \a Size is the number of coefficients in the block
++  *
++  * Example: \include MatrixBase_template_int_end.cpp
++  * Output: \verbinclude MatrixBase_template_int_end.out
++  *
++  * \sa class Block
++  */
++template<typename Derived>
++template<int Size>
++inline typename BlockReturnType<Derived,Size>::SubVectorType
++MatrixBase<Derived>::end()
++{
++  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
++  return Block<Derived, RowsAtCompileTime == 1 ? 1 : Size,
++                        ColsAtCompileTime == 1 ? 1 : Size>
++           (derived(),
++            RowsAtCompileTime == 1 ? 0 : rows() - Size,
++            ColsAtCompileTime == 1 ? 0 : cols() - Size);
++}
++
++/** This is the const version of end<int>.*/
++template<typename Derived>
++template<int Size>
++inline const typename BlockReturnType<Derived,Size>::SubVectorType
++MatrixBase<Derived>::end() const
++{
++  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
++  return Block<Derived, RowsAtCompileTime == 1 ? 1 : Size,
++                        ColsAtCompileTime == 1 ? 1 : Size>
++           (derived(),
++            RowsAtCompileTime == 1 ? 0 : rows() - Size,
++            ColsAtCompileTime == 1 ? 0 : cols() - Size);
++}
++
++/** \returns a dynamic-size expression of a corner of *this.
++  *
++  * \param type the type of corner. Can be \a Eigen::TopLeft, \a Eigen::TopRight,
++  * \a Eigen::BottomLeft, \a Eigen::BottomRight.
++  * \param cRows the number of rows in the corner
++  * \param cCols the number of columns in the corner
++  *
++  * \addexample BlockCornerDynamicSize \label How to reference a sub-corner of a matrix
++  *
++  * Example: \include MatrixBase_corner_enum_int_int.cpp
++  * Output: \verbinclude MatrixBase_corner_enum_int_int.out
++  *
++  * \note Even though the returned expression has dynamic size, in the case
++  * when it is applied to a fixed-size matrix, it inherits a fixed maximal size,
++  * which means that evaluating it does not cause a dynamic memory allocation.
++  *
++  * \sa class Block, block(int,int,int,int)
++  */
++template<typename Derived>
++inline typename BlockReturnType<Derived>::Type MatrixBase<Derived>
++  ::corner(CornerType type, int cRows, int cCols)
++{
++  switch(type)
++  {
++    default:
++      ei_assert(false && "Bad corner type.");
++    case TopLeft:
++      return typename BlockReturnType<Derived>::Type(derived(), 0, 0, cRows, cCols);
++    case TopRight:
++      return typename BlockReturnType<Derived>::Type(derived(), 0, cols() - cCols, cRows, cCols);
++    case BottomLeft:
++      return typename BlockReturnType<Derived>::Type(derived(), rows() - cRows, 0, cRows, cCols);
++    case BottomRight:
++      return typename BlockReturnType<Derived>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
++  }
++}
++
++/** This is the const version of corner(CornerType, int, int).*/
++template<typename Derived>
++inline const typename BlockReturnType<Derived>::Type
++MatrixBase<Derived>::corner(CornerType type, int cRows, int cCols) const
++{
++  switch(type)
++  {
++    default:
++      ei_assert(false && "Bad corner type.");
++    case TopLeft:
++      return typename BlockReturnType<Derived>::Type(derived(), 0, 0, cRows, cCols);
++    case TopRight:
++      return typename BlockReturnType<Derived>::Type(derived(), 0, cols() - cCols, cRows, cCols);
++    case BottomLeft:
++      return typename BlockReturnType<Derived>::Type(derived(), rows() - cRows, 0, cRows, cCols);
++    case BottomRight:
++      return typename BlockReturnType<Derived>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
++  }
++}
++
++/** \returns a fixed-size expression of a corner of *this.
++  *
++  * \param type the type of corner. Can be \a Eigen::TopLeft, \a Eigen::TopRight,
++  * \a Eigen::BottomLeft, \a Eigen::BottomRight.
++  *
++  * The template parameters CRows and CCols arethe number of rows and columns in the corner.
++  *
++  * Example: \include MatrixBase_template_int_int_corner_enum.cpp
++  * Output: \verbinclude MatrixBase_template_int_int_corner_enum.out
++  *
++  * \sa class Block, block(int,int,int,int)
++  */
++template<typename Derived>
++template<int CRows, int CCols>
++inline typename BlockReturnType<Derived, CRows, CCols>::Type
++MatrixBase<Derived>::corner(CornerType type)
++{
++  switch(type)
++  {
++    default:
++      ei_assert(false && "Bad corner type.");
++    case TopLeft:
++      return Block<Derived, CRows, CCols>(derived(), 0, 0);
++    case TopRight:
++      return Block<Derived, CRows, CCols>(derived(), 0, cols() - CCols);
++    case BottomLeft:
++      return Block<Derived, CRows, CCols>(derived(), rows() - CRows, 0);
++    case BottomRight:
++      return Block<Derived, CRows, CCols>(derived(), rows() - CRows, cols() - CCols);
++  }
++}
++
++/** This is the const version of corner<int, int>(CornerType).*/
++template<typename Derived>
++template<int CRows, int CCols>
++inline const typename BlockReturnType<Derived, CRows, CCols>::Type
++MatrixBase<Derived>::corner(CornerType type) const
++{
++  switch(type)
++  {
++    default:
++      ei_assert(false && "Bad corner type.");
++    case TopLeft:
++      return Block<Derived, CRows, CCols>(derived(), 0, 0);
++    case TopRight:
++      return Block<Derived, CRows, CCols>(derived(), 0, cols() - CCols);
++    case BottomLeft:
++      return Block<Derived, CRows, CCols>(derived(), rows() - CRows, 0);
++    case BottomRight:
++      return Block<Derived, CRows, CCols>(derived(), rows() - CRows, cols() - CCols);
++  }
++}
++
++/** \returns a fixed-size expression of a block in *this.
++  *
++  * The template parameters \a BlockRows and \a BlockCols are the number of
++  * rows and columns in the block.
++  *
++  * \param startRow the first row in the block
++  * \param startCol the first column in the block
++  *
++  * \addexample BlockSubMatrixFixedSize \label How to reference a sub-matrix (fixed-size)
++  *
++  * Example: \include MatrixBase_block_int_int.cpp
++  * Output: \verbinclude MatrixBase_block_int_int.out
++  *
++  * \note since block is a templated member, the keyword template has to be used
++  * if the matrix type is also a template parameter: \code m.template block<3,3>(1,1); \endcode
++  *
++  * \sa class Block, block(int,int,int,int)
++  */
++template<typename Derived>
++template<int BlockRows, int BlockCols>
++inline typename BlockReturnType<Derived, BlockRows, BlockCols>::Type
++MatrixBase<Derived>::block(int startRow, int startCol)
++{
++  return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol);
++}
++
++/** This is the const version of block<>(int, int). */
++template<typename Derived>
++template<int BlockRows, int BlockCols>
++inline const typename BlockReturnType<Derived, BlockRows, BlockCols>::Type
++MatrixBase<Derived>::block(int startRow, int startCol) const
++{
++  return Block<Derived, BlockRows, BlockCols>(derived(), startRow, startCol);
++}
++
++/** \returns an expression of the \a i-th column of *this. Note that the numbering starts at 0.
++  *
++  * \addexample BlockColumn \label How to reference a single column of a matrix
++  *
++  * Example: \include MatrixBase_col.cpp
++  * Output: \verbinclude MatrixBase_col.out
++  *
++  * \sa row(), class Block */
++template<typename Derived>
++inline typename MatrixBase<Derived>::ColXpr
++MatrixBase<Derived>::col(int i)
++{
++  return ColXpr(derived(), i);
++}
++
++/** This is the const version of col(). */
++template<typename Derived>
++inline const typename MatrixBase<Derived>::ColXpr
++MatrixBase<Derived>::col(int i) const
++{
++  return ColXpr(derived(), i);
++}
++
++/** \returns an expression of the \a i-th row of *this. Note that the numbering starts at 0.
++  *
++  * \addexample BlockRow \label How to reference a single row of a matrix
++  *
++  * Example: \include MatrixBase_row.cpp
++  * Output: \verbinclude MatrixBase_row.out
++  *
++  * \sa col(), class Block */
++template<typename Derived>
++inline typename MatrixBase<Derived>::RowXpr
++MatrixBase<Derived>::row(int i)
++{
++  return RowXpr(derived(), i);
++}
++
++/** This is the const version of row(). */
++template<typename Derived>
++inline const typename MatrixBase<Derived>::RowXpr
++MatrixBase<Derived>::row(int i) const
++{
++  return RowXpr(derived(), i);
++}
++
++#endif // EIGEN_BLOCK_H
index 0000000,0000000..b1362b0
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,753 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra. Eigen itself is part of the KDE project.
++//
++// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifndef EIGEN_CACHE_FRIENDLY_PRODUCT_H
++#define EIGEN_CACHE_FRIENDLY_PRODUCT_H
++
++template <int L2MemorySize,typename Scalar>
++struct ei_L2_block_traits {
++  enum {width = 8 * ei_meta_sqrt<L2MemorySize/(64*sizeof(Scalar))>::ret };
++};
++
++#ifndef EIGEN_EXTERN_INSTANTIATIONS
++
++template<typename Scalar>
++static void ei_cache_friendly_product(
++  int _rows, int _cols, int depth,
++  bool _lhsRowMajor, const Scalar* _lhs, int _lhsStride,
++  bool _rhsRowMajor, const Scalar* _rhs, int _rhsStride,
++  bool resRowMajor, Scalar* res, int resStride)
++{
++  const Scalar* EIGEN_RESTRICT lhs;
++  const Scalar* EIGEN_RESTRICT rhs;
++  int lhsStride, rhsStride, rows, cols;
++  bool lhsRowMajor;
++
++  if (resRowMajor)
++  {
++    lhs = _rhs;
++    rhs = _lhs;
++    lhsStride = _rhsStride;
++    rhsStride = _lhsStride;
++    cols = _rows;
++    rows = _cols;
++    lhsRowMajor = !_rhsRowMajor;
++    ei_assert(_lhsRowMajor);
++  }
++  else
++  {
++    lhs = _lhs;
++    rhs = _rhs;
++    lhsStride = _lhsStride;
++    rhsStride = _rhsStride;
++    rows = _rows;
++    cols = _cols;
++    lhsRowMajor = _lhsRowMajor;
++    ei_assert(!_rhsRowMajor);
++  }
++
++  typedef typename ei_packet_traits<Scalar>::type PacketType;
++
++  enum {
++    PacketSize = sizeof(PacketType)/sizeof(Scalar),
++    #if (defined __i386__)
++    // i386 architecture provides only 8 xmm registers,
++    // so let's reduce the max number of rows processed at once.
++    MaxBlockRows = 4,
++    MaxBlockRows_ClampingMask = 0xFFFFFC,
++    #else
++    MaxBlockRows = 8,
++    MaxBlockRows_ClampingMask = 0xFFFFF8,
++    #endif
++    // maximal size of the blocks fitted in L2 cache
++    MaxL2BlockSize = ei_L2_block_traits<EIGEN_TUNE_FOR_CPU_CACHE_SIZE,Scalar>::width
++  };
++
++  const bool resIsAligned = (PacketSize==1) || (((resStride%PacketSize) == 0) && (size_t(res)%16==0));
++
++  const int remainingSize = depth % PacketSize;
++  const int size = depth - remainingSize; // third dimension of the product clamped to packet boundaries
++  const int l2BlockRows = MaxL2BlockSize > rows ? rows : MaxL2BlockSize;
++  const int l2BlockCols = MaxL2BlockSize > cols ? cols : MaxL2BlockSize;
++  const int l2BlockSize = MaxL2BlockSize > size ? size : MaxL2BlockSize;
++  const int l2BlockSizeAligned = (1 + std::max(l2BlockSize,l2BlockCols)/PacketSize)*PacketSize;
++  const bool needRhsCopy = (PacketSize>1) && ((rhsStride%PacketSize!=0) || (size_t(rhs)%16!=0));
++  Scalar* EIGEN_RESTRICT block = 0;
++  const int allocBlockSize = l2BlockRows*size;
++  block = ei_aligned_stack_new(Scalar, allocBlockSize);
++  Scalar* EIGEN_RESTRICT rhsCopy
++    = ei_aligned_stack_new(Scalar, l2BlockSizeAligned*l2BlockSizeAligned);
++
++  // loops on each L2 cache friendly blocks of the result
++  for(int l2i=0; l2i<rows; l2i+=l2BlockRows)
++  {
++    const int l2blockRowEnd = std::min(l2i+l2BlockRows, rows);
++    const int l2blockRowEndBW = l2blockRowEnd & MaxBlockRows_ClampingMask;    // end of the rows aligned to bw
++    const int l2blockRemainingRows = l2blockRowEnd - l2blockRowEndBW;         // number of remaining rows
++    //const int l2blockRowEndBWPlusOne = l2blockRowEndBW + (l2blockRemainingRows?0:MaxBlockRows);
++
++    // build a cache friendly blocky matrix
++    int count = 0;
++
++    // copy l2blocksize rows of m_lhs to blocks of ps x bw
++    for(int l2k=0; l2k<size; l2k+=l2BlockSize)
++    {
++      const int l2blockSizeEnd = std::min(l2k+l2BlockSize, size);
++
++      for (int i = l2i; i<l2blockRowEndBW/*PlusOne*/; i+=MaxBlockRows)
++      {
++        // TODO merge the "if l2blockRemainingRows" using something like:
++        // const int blockRows = std::min(i+MaxBlockRows, rows) - i;
++
++        for (int k=l2k; k<l2blockSizeEnd; k+=PacketSize)
++        {
++          // TODO write these loops using meta unrolling
++          // negligible for large matrices but useful for small ones
++          if (lhsRowMajor)
++          {
++            for (int w=0; w<MaxBlockRows; ++w)
++              for (int s=0; s<PacketSize; ++s)
++                block[count++] = lhs[(i+w)*lhsStride + (k+s)];
++          }
++          else
++          {
++            for (int w=0; w<MaxBlockRows; ++w)
++              for (int s=0; s<PacketSize; ++s)
++                block[count++] = lhs[(i+w) + (k+s)*lhsStride];
++          }
++        }
++      }
++      if (l2blockRemainingRows>0)
++      {
++        for (int k=l2k; k<l2blockSizeEnd; k+=PacketSize)
++        {
++          if (lhsRowMajor)
++          {
++            for (int w=0; w<l2blockRemainingRows; ++w)
++              for (int s=0; s<PacketSize; ++s)
++                block[count++] = lhs[(l2blockRowEndBW+w)*lhsStride + (k+s)];
++          }
++          else
++          {
++            for (int w=0; w<l2blockRemainingRows; ++w)
++              for (int s=0; s<PacketSize; ++s)
++                block[count++] = lhs[(l2blockRowEndBW+w) + (k+s)*lhsStride];
++          }
++        }
++      }
++    }
++
++    for(int l2j=0; l2j<cols; l2j+=l2BlockCols)
++    {
++      int l2blockColEnd = std::min(l2j+l2BlockCols, cols);
++
++      for(int l2k=0; l2k<size; l2k+=l2BlockSize)
++      {
++        // acumulate bw rows of lhs time a single column of rhs to a bw x 1 block of res
++        int l2blockSizeEnd = std::min(l2k+l2BlockSize, size);
++
++        // if not aligned, copy the rhs block
++        if (needRhsCopy)
++          for(int l1j=l2j; l1j<l2blockColEnd; l1j+=1)
++          {
++            ei_internal_assert(l2BlockSizeAligned*(l1j-l2j)+(l2blockSizeEnd-l2k) < l2BlockSizeAligned*l2BlockSizeAligned);
++            memcpy(rhsCopy+l2BlockSizeAligned*(l1j-l2j),&(rhs[l1j*rhsStride+l2k]),(l2blockSizeEnd-l2k)*sizeof(Scalar));
++          }
++
++        // for each bw x 1 result's block
++        for(int l1i=l2i; l1i<l2blockRowEndBW; l1i+=MaxBlockRows)
++        {
++          int offsetblock = l2k * (l2blockRowEnd-l2i) + (l1i-l2i)*(l2blockSizeEnd-l2k) - l2k*MaxBlockRows;
++          const Scalar* EIGEN_RESTRICT localB = &block[offsetblock];
++
++          for(int l1j=l2j; l1j<l2blockColEnd; l1j+=1)
++          {
++            const Scalar* EIGEN_RESTRICT rhsColumn;
++            if (needRhsCopy)
++              rhsColumn = &(rhsCopy[l2BlockSizeAligned*(l1j-l2j)-l2k]);
++            else
++              rhsColumn = &(rhs[l1j*rhsStride]);
++
++            PacketType dst[MaxBlockRows];
++            dst[3] = dst[2] = dst[1] = dst[0] = ei_pset1(Scalar(0.));
++            if (MaxBlockRows==8)
++              dst[7] = dst[6] = dst[5] = dst[4] = dst[0];
++
++            PacketType tmp;
++
++            for(int k=l2k; k<l2blockSizeEnd; k+=PacketSize)
++            {
++              tmp = ei_ploadu(&rhsColumn[k]);
++              PacketType A0, A1, A2, A3, A4, A5;
++              A0 = ei_pload(localB + k*MaxBlockRows);
++              A1 = ei_pload(localB + k*MaxBlockRows+1*PacketSize);
++              A2 = ei_pload(localB + k*MaxBlockRows+2*PacketSize);
++              A3 = ei_pload(localB + k*MaxBlockRows+3*PacketSize);
++              if (MaxBlockRows==8) A4 = ei_pload(localB + k*MaxBlockRows+4*PacketSize);
++              if (MaxBlockRows==8) A5 = ei_pload(localB + k*MaxBlockRows+5*PacketSize);
++              dst[0] = ei_pmadd(tmp, A0, dst[0]);
++              if (MaxBlockRows==8) A0 = ei_pload(localB + k*MaxBlockRows+6*PacketSize);
++              dst[1] = ei_pmadd(tmp, A1, dst[1]);
++              if (MaxBlockRows==8) A1 = ei_pload(localB + k*MaxBlockRows+7*PacketSize);
++              dst[2] = ei_pmadd(tmp, A2, dst[2]);
++              dst[3] = ei_pmadd(tmp, A3, dst[3]);
++              if (MaxBlockRows==8)
++              {
++                dst[4] = ei_pmadd(tmp, A4, dst[4]);
++                dst[5] = ei_pmadd(tmp, A5, dst[5]);
++                dst[6] = ei_pmadd(tmp, A0, dst[6]);
++                dst[7] = ei_pmadd(tmp, A1, dst[7]);
++              }
++            }
++
++            Scalar* EIGEN_RESTRICT localRes = &(res[l1i + l1j*resStride]);
++
++            if (PacketSize>1 && resIsAligned)
++            {
++              // the result is aligned: let's do packet reduction
++              ei_pstore(&(localRes[0]), ei_padd(ei_pload(&(localRes[0])), ei_preduxp(&dst[0])));
++              if (PacketSize==2)
++                ei_pstore(&(localRes[2]), ei_padd(ei_pload(&(localRes[2])), ei_preduxp(&(dst[2]))));
++              if (MaxBlockRows==8)
++              {
++                ei_pstore(&(localRes[4]), ei_padd(ei_pload(&(localRes[4])), ei_preduxp(&(dst[4]))));
++                if (PacketSize==2)
++                  ei_pstore(&(localRes[6]), ei_padd(ei_pload(&(localRes[6])), ei_preduxp(&(dst[6]))));
++              }
++            }
++            else
++            {
++              // not aligned => per coeff packet reduction
++              localRes[0] += ei_predux(dst[0]);
++              localRes[1] += ei_predux(dst[1]);
++              localRes[2] += ei_predux(dst[2]);
++              localRes[3] += ei_predux(dst[3]);
++              if (MaxBlockRows==8)
++              {
++                localRes[4] += ei_predux(dst[4]);
++                localRes[5] += ei_predux(dst[5]);
++                localRes[6] += ei_predux(dst[6]);
++                localRes[7] += ei_predux(dst[7]);
++              }
++            }
++          }
++        }
++        if (l2blockRemainingRows>0)
++        {
++          int offsetblock = l2k * (l2blockRowEnd-l2i) + (l2blockRowEndBW-l2i)*(l2blockSizeEnd-l2k) - l2k*l2blockRemainingRows;
++          const Scalar* localB = &block[offsetblock];
++
++          for(int l1j=l2j; l1j<l2blockColEnd; l1j+=1)
++          {
++            const Scalar* EIGEN_RESTRICT rhsColumn;
++            if (needRhsCopy)
++              rhsColumn = &(rhsCopy[l2BlockSizeAligned*(l1j-l2j)-l2k]);
++            else
++              rhsColumn = &(rhs[l1j*rhsStride]);
++
++            PacketType dst[MaxBlockRows];
++            dst[3] = dst[2] = dst[1] = dst[0] = ei_pset1(Scalar(0.));
++            if (MaxBlockRows==8)
++              dst[7] = dst[6] = dst[5] = dst[4] = dst[0];
++
++            // let's declare a few other temporary registers
++            PacketType tmp;
++
++            for(int k=l2k; k<l2blockSizeEnd; k+=PacketSize)
++            {
++              tmp = ei_pload(&rhsColumn[k]);
++
++                                           dst[0] = ei_pmadd(tmp, ei_pload(&(localB[k*l2blockRemainingRows             ])), dst[0]);
++              if (l2blockRemainingRows>=2) dst[1] = ei_pmadd(tmp, ei_pload(&(localB[k*l2blockRemainingRows+  PacketSize])), dst[1]);
++              if (l2blockRemainingRows>=3) dst[2] = ei_pmadd(tmp, ei_pload(&(localB[k*l2blockRemainingRows+2*PacketSize])), dst[2]);
++              if (l2blockRemainingRows>=4) dst[3] = ei_pmadd(tmp, ei_pload(&(localB[k*l2blockRemainingRows+3*PacketSize])), dst[3]);
++              if (MaxBlockRows==8)
++              {
++                if (l2blockRemainingRows>=5) dst[4] = ei_pmadd(tmp, ei_pload(&(localB[k*l2blockRemainingRows+4*PacketSize])), dst[4]);
++                if (l2blockRemainingRows>=6) dst[5] = ei_pmadd(tmp, ei_pload(&(localB[k*l2blockRemainingRows+5*PacketSize])), dst[5]);
++                if (l2blockRemainingRows>=7) dst[6] = ei_pmadd(tmp, ei_pload(&(localB[k*l2blockRemainingRows+6*PacketSize])), dst[6]);
++                if (l2blockRemainingRows>=8) dst[7] = ei_pmadd(tmp, ei_pload(&(localB[k*l2blockRemainingRows+7*PacketSize])), dst[7]);
++              }
++            }
++
++            Scalar* EIGEN_RESTRICT localRes = &(res[l2blockRowEndBW + l1j*resStride]);
++
++            // process the remaining rows once at a time
++                                         localRes[0] += ei_predux(dst[0]);
++            if (l2blockRemainingRows>=2) localRes[1] += ei_predux(dst[1]);
++            if (l2blockRemainingRows>=3) localRes[2] += ei_predux(dst[2]);
++            if (l2blockRemainingRows>=4) localRes[3] += ei_predux(dst[3]);
++            if (MaxBlockRows==8)
++            {
++              if (l2blockRemainingRows>=5) localRes[4] += ei_predux(dst[4]);
++              if (l2blockRemainingRows>=6) localRes[5] += ei_predux(dst[5]);
++              if (l2blockRemainingRows>=7) localRes[6] += ei_predux(dst[6]);
++              if (l2blockRemainingRows>=8) localRes[7] += ei_predux(dst[7]);
++            }
++
++          }
++        }
++      }
++    }
++  }
++  if (PacketSize>1 && remainingSize)
++  {
++    if (lhsRowMajor)
++    {
++      for (int j=0; j<cols; ++j)
++        for (int i=0; i<rows; ++i)
++        {
++          Scalar tmp = lhs[i*lhsStride+size] * rhs[j*rhsStride+size];
++          // FIXME this loop get vectorized by the compiler !
++          for (int k=1; k<remainingSize; ++k)
++            tmp += lhs[i*lhsStride+size+k] * rhs[j*rhsStride+size+k];
++          res[i+j*resStride] += tmp;
++        }
++    }
++    else
++    {
++      for (int j=0; j<cols; ++j)
++        for (int i=0; i<rows; ++i)
++        {
++          Scalar tmp = lhs[i+size*lhsStride] * rhs[j*rhsStride+size];
++          for (int k=1; k<remainingSize; ++k)
++            tmp += lhs[i+(size+k)*lhsStride] * rhs[j*rhsStride+size+k];
++          res[i+j*resStride] += tmp;
++        }
++    }
++  }
++
++  ei_aligned_stack_delete(Scalar, block, allocBlockSize);
++  ei_aligned_stack_delete(Scalar, rhsCopy, l2BlockSizeAligned*l2BlockSizeAligned);
++}
++
++#endif // EIGEN_EXTERN_INSTANTIATIONS
++
++/* Optimized col-major matrix * vector product:
++ * This algorithm processes 4 columns at onces that allows to both reduce
++ * the number of load/stores of the result by a factor 4 and to reduce
++ * the instruction dependency. Moreover, we know that all bands have the
++ * same alignment pattern.
++ * TODO: since rhs gets evaluated only once, no need to evaluate it
++ */
++template<typename Scalar, typename RhsType>
++static EIGEN_DONT_INLINE void ei_cache_friendly_product_colmajor_times_vector(
++  int size,
++  const Scalar* lhs, int lhsStride,
++  const RhsType& rhs,
++  Scalar* res)
++{
++  #ifdef _EIGEN_ACCUMULATE_PACKETS
++  #error _EIGEN_ACCUMULATE_PACKETS has already been defined
++  #endif
++  #define _EIGEN_ACCUMULATE_PACKETS(A0,A13,A2) \
++    ei_pstore(&res[j], \
++      ei_padd(ei_pload(&res[j]), \
++        ei_padd( \
++          ei_padd(ei_pmul(ptmp0,EIGEN_CAT(ei_ploa , A0)(&lhs0[j])), \
++                  ei_pmul(ptmp1,EIGEN_CAT(ei_ploa , A13)(&lhs1[j]))), \
++          ei_padd(ei_pmul(ptmp2,EIGEN_CAT(ei_ploa , A2)(&lhs2[j])), \
++                  ei_pmul(ptmp3,EIGEN_CAT(ei_ploa , A13)(&lhs3[j]))) )))
++
++  typedef typename ei_packet_traits<Scalar>::type Packet;
++  const int PacketSize = sizeof(Packet)/sizeof(Scalar);
++
++  enum { AllAligned = 0, EvenAligned, FirstAligned, NoneAligned };
++  const int columnsAtOnce = 4;
++  const int peels = 2;
++  const int PacketAlignedMask = PacketSize-1;
++  const int PeelAlignedMask = PacketSize*peels-1;
++
++  // How many coeffs of the result do we have to skip to be aligned.
++  // Here we assume data are at least aligned on the base scalar type that is mandatory anyway.
++  const int alignedStart = ei_alignmentOffset(res,size);
++  const int alignedSize = PacketSize>1 ? alignedStart + ((size-alignedStart) & ~PacketAlignedMask) : 0;
++  const int peeledSize  = peels>1 ? alignedStart + ((alignedSize-alignedStart) & ~PeelAlignedMask) : alignedStart;
++
++  const int alignmentStep = PacketSize>1 ? (PacketSize - lhsStride % PacketSize) & PacketAlignedMask : 0;
++  int alignmentPattern = alignmentStep==0 ? AllAligned
++                       : alignmentStep==(PacketSize/2) ? EvenAligned
++                       : FirstAligned;
++
++  // we cannot assume the first element is aligned because of sub-matrices
++  const int lhsAlignmentOffset = ei_alignmentOffset(lhs,size);
++
++  // find how many columns do we have to skip to be aligned with the result (if possible)
++  int skipColumns = 0;
++  if (PacketSize>1)
++  {
++    ei_internal_assert(size_t(lhs+lhsAlignmentOffset)%sizeof(Packet)==0 || size<PacketSize);
++
++    while (skipColumns<PacketSize &&
++           alignedStart != ((lhsAlignmentOffset + alignmentStep*skipColumns)%PacketSize))
++      ++skipColumns;
++    if (skipColumns==PacketSize)
++    {
++      // nothing can be aligned, no need to skip any column
++      alignmentPattern = NoneAligned;
++      skipColumns = 0;
++    }
++    else
++    {
++      skipColumns = std::min(skipColumns,rhs.size());
++      // note that the skiped columns are processed later.
++    }
++
++    ei_internal_assert((alignmentPattern==NoneAligned) || (size_t(lhs+alignedStart+lhsStride*skipColumns)%sizeof(Packet))==0);
++  }
++
++  int offset1 = (FirstAligned && alignmentStep==1?3:1);
++  int offset3 = (FirstAligned && alignmentStep==1?1:3);
++
++  int columnBound = ((rhs.size()-skipColumns)/columnsAtOnce)*columnsAtOnce + skipColumns;
++  for (int i=skipColumns; i<columnBound; i+=columnsAtOnce)
++  {
++    Packet ptmp0 = ei_pset1(rhs[i]),   ptmp1 = ei_pset1(rhs[i+offset1]),
++           ptmp2 = ei_pset1(rhs[i+2]), ptmp3 = ei_pset1(rhs[i+offset3]);
++
++    // this helps a lot generating better binary code
++    const Scalar *lhs0 = lhs + i*lhsStride, *lhs1 = lhs + (i+offset1)*lhsStride,
++                 *lhs2 = lhs + (i+2)*lhsStride, *lhs3 = lhs + (i+offset3)*lhsStride;
++
++    if (PacketSize>1)
++    {
++      /* explicit vectorization */
++      // process initial unaligned coeffs
++      for (int j=0; j<alignedStart; ++j)
++        res[j] += ei_pfirst(ptmp0)*lhs0[j] + ei_pfirst(ptmp1)*lhs1[j] + ei_pfirst(ptmp2)*lhs2[j] + ei_pfirst(ptmp3)*lhs3[j];
++
++      if (alignedSize>alignedStart)
++      {
++        switch(alignmentPattern)
++        {
++          case AllAligned:
++            for (int j = alignedStart; j<alignedSize; j+=PacketSize)
++              _EIGEN_ACCUMULATE_PACKETS(d,d,d);
++            break;
++          case EvenAligned:
++            for (int j = alignedStart; j<alignedSize; j+=PacketSize)
++              _EIGEN_ACCUMULATE_PACKETS(d,du,d);
++            break;
++          case FirstAligned:
++            if(peels>1)
++            {
++              Packet A00, A01, A02, A03, A10, A11, A12, A13;
++
++              A01 = ei_pload(&lhs1[alignedStart-1]);
++              A02 = ei_pload(&lhs2[alignedStart-2]);
++              A03 = ei_pload(&lhs3[alignedStart-3]);
++
++              for (int j = alignedStart; j<peeledSize; j+=peels*PacketSize)
++              {
++                A11 = ei_pload(&lhs1[j-1+PacketSize]);  ei_palign<1>(A01,A11);
++                A12 = ei_pload(&lhs2[j-2+PacketSize]);  ei_palign<2>(A02,A12);
++                A13 = ei_pload(&lhs3[j-3+PacketSize]);  ei_palign<3>(A03,A13);
++
++                A00 = ei_pload (&lhs0[j]);
++                A10 = ei_pload (&lhs0[j+PacketSize]);
++                A00 = ei_pmadd(ptmp0, A00, ei_pload(&res[j]));
++                A10 = ei_pmadd(ptmp0, A10, ei_pload(&res[j+PacketSize]));
++
++                A00 = ei_pmadd(ptmp1, A01, A00);
++                A01 = ei_pload(&lhs1[j-1+2*PacketSize]);  ei_palign<1>(A11,A01);
++                A00 = ei_pmadd(ptmp2, A02, A00);
++                A02 = ei_pload(&lhs2[j-2+2*PacketSize]);  ei_palign<2>(A12,A02);
++                A00 = ei_pmadd(ptmp3, A03, A00);
++                ei_pstore(&res[j],A00);
++                A03 = ei_pload(&lhs3[j-3+2*PacketSize]);  ei_palign<3>(A13,A03);
++                A10 = ei_pmadd(ptmp1, A11, A10);
++                A10 = ei_pmadd(ptmp2, A12, A10);
++                A10 = ei_pmadd(ptmp3, A13, A10);
++                ei_pstore(&res[j+PacketSize],A10);
++              }
++            }
++            for (int j = peeledSize; j<alignedSize; j+=PacketSize)
++              _EIGEN_ACCUMULATE_PACKETS(d,du,du);
++            break;
++          default:
++            for (int j = alignedStart; j<alignedSize; j+=PacketSize)
++              _EIGEN_ACCUMULATE_PACKETS(du,du,du);
++            break;
++        }
++      }
++    } // end explicit vectorization
++
++    /* process remaining coeffs (or all if there is no explicit vectorization) */
++    for (int j=alignedSize; j<size; ++j)
++      res[j] += ei_pfirst(ptmp0)*lhs0[j] + ei_pfirst(ptmp1)*lhs1[j] + ei_pfirst(ptmp2)*lhs2[j] + ei_pfirst(ptmp3)*lhs3[j];
++  }
++
++  // process remaining first and last columns (at most columnsAtOnce-1)
++  int end = rhs.size();
++  int start = columnBound;
++  do
++  {
++    for (int i=start; i<end; ++i)
++    {
++      Packet ptmp0 = ei_pset1(rhs[i]);
++      const Scalar* lhs0 = lhs + i*lhsStride;
++
++      if (PacketSize>1)
++      {
++        /* explicit vectorization */
++        // process first unaligned result's coeffs
++        for (int j=0; j<alignedStart; ++j)
++          res[j] += ei_pfirst(ptmp0) * lhs0[j];
++
++        // process aligned result's coeffs
++        if ((size_t(lhs0+alignedStart)%sizeof(Packet))==0)
++          for (int j = alignedStart;j<alignedSize;j+=PacketSize)
++            ei_pstore(&res[j], ei_pmadd(ptmp0,ei_pload(&lhs0[j]),ei_pload(&res[j])));
++        else
++          for (int j = alignedStart;j<alignedSize;j+=PacketSize)
++            ei_pstore(&res[j], ei_pmadd(ptmp0,ei_ploadu(&lhs0[j]),ei_pload(&res[j])));
++      }
++
++      // process remaining scalars (or all if no explicit vectorization)
++      for (int j=alignedSize; j<size; ++j)
++        res[j] += ei_pfirst(ptmp0) * lhs0[j];
++    }
++    if (skipColumns)
++    {
++      start = 0;
++      end = skipColumns;
++      skipColumns = 0;
++    }
++    else
++      break;
++  } while(PacketSize>1);
++  #undef _EIGEN_ACCUMULATE_PACKETS
++}
++
++// TODO add peeling to mask unaligned load/stores
++template<typename Scalar, typename ResType>
++static EIGEN_DONT_INLINE void ei_cache_friendly_product_rowmajor_times_vector(
++  const Scalar* lhs, int lhsStride,
++  const Scalar* rhs, int rhsSize,
++  ResType& res)
++{
++  #ifdef _EIGEN_ACCUMULATE_PACKETS
++  #error _EIGEN_ACCUMULATE_PACKETS has already been defined
++  #endif
++
++  #define _EIGEN_ACCUMULATE_PACKETS(A0,A13,A2) {\
++    Packet b = ei_pload(&rhs[j]); \
++    ptmp0 = ei_pmadd(b, EIGEN_CAT(ei_ploa,A0) (&lhs0[j]), ptmp0); \
++    ptmp1 = ei_pmadd(b, EIGEN_CAT(ei_ploa,A13)(&lhs1[j]), ptmp1); \
++    ptmp2 = ei_pmadd(b, EIGEN_CAT(ei_ploa,A2) (&lhs2[j]), ptmp2); \
++    ptmp3 = ei_pmadd(b, EIGEN_CAT(ei_ploa,A13)(&lhs3[j]), ptmp3); }
++
++  typedef typename ei_packet_traits<Scalar>::type Packet;
++  const int PacketSize = sizeof(Packet)/sizeof(Scalar);
++
++  enum { AllAligned=0, EvenAligned=1, FirstAligned=2, NoneAligned=3 };
++  const int rowsAtOnce = 4;
++  const int peels = 2;
++  const int PacketAlignedMask = PacketSize-1;
++  const int PeelAlignedMask = PacketSize*peels-1;
++  const int size = rhsSize;
++
++  // How many coeffs of the result do we have to skip to be aligned.
++  // Here we assume data are at least aligned on the base scalar type that is mandatory anyway.
++  const int alignedStart = ei_alignmentOffset(rhs, size);
++  const int alignedSize = PacketSize>1 ? alignedStart + ((size-alignedStart) & ~PacketAlignedMask) : 0;
++  const int peeledSize  = peels>1 ? alignedStart + ((alignedSize-alignedStart) & ~PeelAlignedMask) : alignedStart;
++
++  const int alignmentStep = PacketSize>1 ? (PacketSize - lhsStride % PacketSize) & PacketAlignedMask : 0;
++  int alignmentPattern = alignmentStep==0 ? AllAligned
++                       : alignmentStep==(PacketSize/2) ? EvenAligned
++                       : FirstAligned;
++
++  // we cannot assume the first element is aligned because of sub-matrices
++  const int lhsAlignmentOffset = ei_alignmentOffset(lhs,size);
++
++  // find how many rows do we have to skip to be aligned with rhs (if possible)
++  int skipRows = 0;
++  if (PacketSize>1)
++  {
++    ei_internal_assert(size_t(lhs+lhsAlignmentOffset)%sizeof(Packet)==0  || size<PacketSize);
++
++    while (skipRows<PacketSize &&
++           alignedStart != ((lhsAlignmentOffset + alignmentStep*skipRows)%PacketSize))
++      ++skipRows;
++    if (skipRows==PacketSize)
++    {
++      // nothing can be aligned, no need to skip any column
++      alignmentPattern = NoneAligned;
++      skipRows = 0;
++    }
++    else
++    {
++      skipRows = std::min(skipRows,res.size());
++      // note that the skiped columns are processed later.
++    }
++    ei_internal_assert((alignmentPattern==NoneAligned) || PacketSize==1
++      || (size_t(lhs+alignedStart+lhsStride*skipRows)%sizeof(Packet))==0);
++  }
++
++  int offset1 = (FirstAligned && alignmentStep==1?3:1);
++  int offset3 = (FirstAligned && alignmentStep==1?1:3);
++
++  int rowBound = ((res.size()-skipRows)/rowsAtOnce)*rowsAtOnce + skipRows;
++  for (int i=skipRows; i<rowBound; i+=rowsAtOnce)
++  {
++    Scalar tmp0 = Scalar(0), tmp1 = Scalar(0), tmp2 = Scalar(0), tmp3 = Scalar(0);
++
++    // this helps the compiler generating good binary code
++    const Scalar *lhs0 = lhs + i*lhsStride,     *lhs1 = lhs + (i+offset1)*lhsStride,
++                 *lhs2 = lhs + (i+2)*lhsStride, *lhs3 = lhs + (i+offset3)*lhsStride;
++
++    if (PacketSize>1)
++    {
++      /* explicit vectorization */
++      Packet ptmp0 = ei_pset1(Scalar(0)), ptmp1 = ei_pset1(Scalar(0)), ptmp2 = ei_pset1(Scalar(0)), ptmp3 = ei_pset1(Scalar(0));
++
++      // process initial unaligned coeffs
++      // FIXME this loop get vectorized by the compiler !
++      for (int j=0; j<alignedStart; ++j)
++      {
++        Scalar b = rhs[j];
++        tmp0 += b*lhs0[j]; tmp1 += b*lhs1[j]; tmp2 += b*lhs2[j]; tmp3 += b*lhs3[j];
++      }
++
++      if (alignedSize>alignedStart)
++      {
++        switch(alignmentPattern)
++        {
++          case AllAligned:
++            for (int j = alignedStart; j<alignedSize; j+=PacketSize)
++              _EIGEN_ACCUMULATE_PACKETS(d,d,d);
++            break;
++          case EvenAligned:
++            for (int j = alignedStart; j<alignedSize; j+=PacketSize)
++              _EIGEN_ACCUMULATE_PACKETS(d,du,d);
++            break;
++          case FirstAligned:
++            if (peels>1)
++            {
++              /* Here we proccess 4 rows with with two peeled iterations to hide
++               * tghe overhead of unaligned loads. Moreover unaligned loads are handled
++               * using special shift/move operations between the two aligned packets
++               * overlaping the desired unaligned packet. This is *much* more efficient
++               * than basic unaligned loads.
++               */
++              Packet A01, A02, A03, b, A11, A12, A13;
++              A01 = ei_pload(&lhs1[alignedStart-1]);
++              A02 = ei_pload(&lhs2[alignedStart-2]);
++              A03 = ei_pload(&lhs3[alignedStart-3]);
++
++              for (int j = alignedStart; j<peeledSize; j+=peels*PacketSize)
++              {
++                b = ei_pload(&rhs[j]);
++                A11 = ei_pload(&lhs1[j-1+PacketSize]);  ei_palign<1>(A01,A11);
++                A12 = ei_pload(&lhs2[j-2+PacketSize]);  ei_palign<2>(A02,A12);
++                A13 = ei_pload(&lhs3[j-3+PacketSize]);  ei_palign<3>(A03,A13);
++
++                ptmp0 = ei_pmadd(b, ei_pload (&lhs0[j]), ptmp0);
++                ptmp1 = ei_pmadd(b, A01, ptmp1);
++                A01 = ei_pload(&lhs1[j-1+2*PacketSize]);  ei_palign<1>(A11,A01);
++                ptmp2 = ei_pmadd(b, A02, ptmp2);
++                A02 = ei_pload(&lhs2[j-2+2*PacketSize]);  ei_palign<2>(A12,A02);
++                ptmp3 = ei_pmadd(b, A03, ptmp3);
++                A03 = ei_pload(&lhs3[j-3+2*PacketSize]);  ei_palign<3>(A13,A03);
++
++                b = ei_pload(&rhs[j+PacketSize]);
++                ptmp0 = ei_pmadd(b, ei_pload (&lhs0[j+PacketSize]), ptmp0);
++                ptmp1 = ei_pmadd(b, A11, ptmp1);
++                ptmp2 = ei_pmadd(b, A12, ptmp2);
++                ptmp3 = ei_pmadd(b, A13, ptmp3);
++              }
++            }
++            for (int j = peeledSize; j<alignedSize; j+=PacketSize)
++              _EIGEN_ACCUMULATE_PACKETS(d,du,du);
++            break;
++          default:
++            for (int j = alignedStart; j<alignedSize; j+=PacketSize)
++              _EIGEN_ACCUMULATE_PACKETS(du,du,du);
++            break;
++        }
++        tmp0 += ei_predux(ptmp0);
++        tmp1 += ei_predux(ptmp1);
++        tmp2 += ei_predux(ptmp2);
++        tmp3 += ei_predux(ptmp3);
++      }
++    } // end explicit vectorization
++
++    // process remaining coeffs (or all if no explicit vectorization)
++    // FIXME this loop get vectorized by the compiler !
++    for (int j=alignedSize; j<size; ++j)
++    {
++      Scalar b = rhs[j];
++      tmp0 += b*lhs0[j]; tmp1 += b*lhs1[j]; tmp2 += b*lhs2[j]; tmp3 += b*lhs3[j];
++    }
++    res[i] += tmp0; res[i+offset1] += tmp1; res[i+2] += tmp2; res[i+offset3] += tmp3;
++  }
++
++  // process remaining first and last rows (at most columnsAtOnce-1)
++  int end = res.size();
++  int start = rowBound;
++  do
++  {
++    for (int i=start; i<end; ++i)
++    {
++      Scalar tmp0 = Scalar(0);
++      Packet ptmp0 = ei_pset1(tmp0);
++      const Scalar* lhs0 = lhs + i*lhsStride;
++      // process first unaligned result's coeffs
++      // FIXME this loop get vectorized by the compiler !
++      for (int j=0; j<alignedStart; ++j)
++        tmp0 += rhs[j] * lhs0[j];
++
++      if (alignedSize>alignedStart)
++      {
++        // process aligned rhs coeffs
++        if ((size_t(lhs0+alignedStart)%sizeof(Packet))==0)
++          for (int j = alignedStart;j<alignedSize;j+=PacketSize)
++            ptmp0 = ei_pmadd(ei_pload(&rhs[j]), ei_pload(&lhs0[j]), ptmp0);
++        else
++          for (int j = alignedStart;j<alignedSize;j+=PacketSize)
++            ptmp0 = ei_pmadd(ei_pload(&rhs[j]), ei_ploadu(&lhs0[j]), ptmp0);
++        tmp0 += ei_predux(ptmp0);
++      }
++
++      // process remaining scalars
++      // FIXME this loop get vectorized by the compiler !
++      for (int j=alignedSize; j<size; ++j)
++        tmp0 += rhs[j] * lhs0[j];
++      res[i] += tmp0;
++    }
++    if (skipRows)
++    {
++      start = 0;
++      end = skipRows;
++      skipRows = 0;
++    }
++    else
++      break;
++  } while(PacketSize>1);
++
++  #undef _EIGEN_ACCUMULATE_PACKETS
++}
++
++#endif // EIGEN_CACHE_FRIENDLY_PRODUCT_H
index 0000000,0000000..23a8422
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,384 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra. Eigen itself is part of the KDE project.
++//
++// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifndef EIGEN_COEFFS_H
++#define EIGEN_COEFFS_H
++
++/** Short version: don't use this function, use
++  * \link operator()(int,int) const \endlink instead.
++  *
++  * Long version: this function is similar to
++  * \link operator()(int,int) const \endlink, but without the assertion.
++  * Use this for limiting the performance cost of debugging code when doing
++  * repeated coefficient access. Only use this when it is guaranteed that the
++  * parameters \a row and \a col are in range.
++  *
++  * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
++  * function equivalent to \link operator()(int,int) const \endlink.
++  *
++  * \sa operator()(int,int) const, coeffRef(int,int), coeff(int) const
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename ei_traits<Derived>::Scalar MatrixBase<Derived>
++  ::coeff(int row, int col) const
++{
++  ei_internal_assert(row >= 0 && row < rows()
++                     && col >= 0 && col < cols());
++  return derived().coeff(row, col);
++}
++
++/** \returns the coefficient at given the given row and column.
++  *
++  * \sa operator()(int,int), operator[](int) const
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename ei_traits<Derived>::Scalar MatrixBase<Derived>
++  ::operator()(int row, int col) const
++{
++  ei_assert(row >= 0 && row < rows()
++      && col >= 0 && col < cols());
++  return derived().coeff(row, col);
++}
++
++/** Short version: don't use this function, use
++  * \link operator()(int,int) \endlink instead.
++  *
++  * Long version: this function is similar to
++  * \link operator()(int,int) \endlink, but without the assertion.
++  * Use this for limiting the performance cost of debugging code when doing
++  * repeated coefficient access. Only use this when it is guaranteed that the
++  * parameters \a row and \a col are in range.
++  *
++  * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
++  * function equivalent to \link operator()(int,int) \endlink.
++  *
++  * \sa operator()(int,int), coeff(int, int) const, coeffRef(int)
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
++  ::coeffRef(int row, int col)
++{
++  ei_internal_assert(row >= 0 && row < rows()
++                     && col >= 0 && col < cols());
++  return derived().coeffRef(row, col);
++}
++
++/** \returns a reference to the coefficient at given the given row and column.
++  *
++  * \sa operator()(int,int) const, operator[](int)
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
++  ::operator()(int row, int col)
++{
++  ei_assert(row >= 0 && row < rows()
++      && col >= 0 && col < cols());
++  return derived().coeffRef(row, col);
++}
++
++/** Short version: don't use this function, use
++  * \link operator[](int) const \endlink instead.
++  *
++  * Long version: this function is similar to
++  * \link operator[](int) const \endlink, but without the assertion.
++  * Use this for limiting the performance cost of debugging code when doing
++  * repeated coefficient access. Only use this when it is guaranteed that the
++  * parameter \a index is in range.
++  *
++  * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
++  * function equivalent to \link operator[](int) const \endlink.
++  *
++  * \sa operator[](int) const, coeffRef(int), coeff(int,int) const
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename ei_traits<Derived>::Scalar MatrixBase<Derived>
++  ::coeff(int index) const
++{
++  ei_internal_assert(index >= 0 && index < size());
++  return derived().coeff(index);
++}
++
++/** \returns the coefficient at given index.
++  *
++  * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
++  *
++  * \sa operator[](int), operator()(int,int) const, x() const, y() const,
++  * z() const, w() const
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename ei_traits<Derived>::Scalar MatrixBase<Derived>
++  ::operator[](int index) const
++{
++  ei_assert(index >= 0 && index < size());
++  return derived().coeff(index);
++}
++
++/** \returns the coefficient at given index.
++  *
++  * This is synonymous to operator[](int) const.
++  *
++  * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
++  *
++  * \sa operator[](int), operator()(int,int) const, x() const, y() const,
++  * z() const, w() const
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename ei_traits<Derived>::Scalar MatrixBase<Derived>
++  ::operator()(int index) const
++{
++  ei_assert(index >= 0 && index < size());
++  return derived().coeff(index);
++}
++
++/** Short version: don't use this function, use
++  * \link operator[](int) \endlink instead.
++  *
++  * Long version: this function is similar to
++  * \link operator[](int) \endlink, but without the assertion.
++  * Use this for limiting the performance cost of debugging code when doing
++  * repeated coefficient access. Only use this when it is guaranteed that the
++  * parameters \a row and \a col are in range.
++  *
++  * If EIGEN_INTERNAL_DEBUGGING is defined, an assertion will be made, making this
++  * function equivalent to \link operator[](int) \endlink.
++  *
++  * \sa operator[](int), coeff(int) const, coeffRef(int,int)
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
++  ::coeffRef(int index)
++{
++  ei_internal_assert(index >= 0 && index < size());
++  return derived().coeffRef(index);
++}
++
++/** \returns a reference to the coefficient at given index.
++  *
++  * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
++  *
++  * \sa operator[](int) const, operator()(int,int), x(), y(), z(), w()
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
++  ::operator[](int index)
++{
++  ei_assert(index >= 0 && index < size());
++  return derived().coeffRef(index);
++}
++
++/** \returns a reference to the coefficient at given index.
++  *
++  * This is synonymous to operator[](int).
++  *
++  * This method is allowed only for vector expressions, and for matrix expressions having the LinearAccessBit.
++  *
++  * \sa operator[](int) const, operator()(int,int), x(), y(), z(), w()
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
++  ::operator()(int index)
++{
++  ei_assert(index >= 0 && index < size());
++  return derived().coeffRef(index);
++}
++
++/** equivalent to operator[](0).  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename ei_traits<Derived>::Scalar MatrixBase<Derived>
++  ::x() const { return (*this)[0]; }
++
++/** equivalent to operator[](1).  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename ei_traits<Derived>::Scalar MatrixBase<Derived>
++  ::y() const { return (*this)[1]; }
++
++/** equivalent to operator[](2).  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename ei_traits<Derived>::Scalar MatrixBase<Derived>
++  ::z() const { return (*this)[2]; }
++
++/** equivalent to operator[](3).  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename ei_traits<Derived>::Scalar MatrixBase<Derived>
++  ::w() const { return (*this)[3]; }
++
++/** equivalent to operator[](0).  */
++template<typename Derived>
++EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
++  ::x() { return (*this)[0]; }
++
++/** equivalent to operator[](1).  */
++template<typename Derived>
++EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
++  ::y() { return (*this)[1]; }
++
++/** equivalent to operator[](2).  */
++template<typename Derived>
++EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
++  ::z() { return (*this)[2]; }
++
++/** equivalent to operator[](3).  */
++template<typename Derived>
++EIGEN_STRONG_INLINE typename ei_traits<Derived>::Scalar& MatrixBase<Derived>
++  ::w() { return (*this)[3]; }
++
++/** \returns the packet of coefficients starting at the given row and column. It is your responsibility
++  * to ensure that a packet really starts there. This method is only available on expressions having the
++  * PacketAccessBit.
++  *
++  * The \a LoadMode parameter may have the value \a Aligned or \a Unaligned. Its effect is to select
++  * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets
++  * starting at an address which is a multiple of the packet size.
++  */
++template<typename Derived>
++template<int LoadMode>
++EIGEN_STRONG_INLINE typename ei_packet_traits<typename ei_traits<Derived>::Scalar>::type
++MatrixBase<Derived>::packet(int row, int col) const
++{
++  ei_internal_assert(row >= 0 && row < rows()
++                     && col >= 0 && col < cols());
++  return derived().template packet<LoadMode>(row,col);
++}
++
++/** Stores the given packet of coefficients, at the given row and column of this expression. It is your responsibility
++  * to ensure that a packet really starts there. This method is only available on expressions having the
++  * PacketAccessBit.
++  *
++  * The \a LoadMode parameter may have the value \a Aligned or \a Unaligned. Its effect is to select
++  * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets
++  * starting at an address which is a multiple of the packet size.
++  */
++template<typename Derived>
++template<int StoreMode>
++EIGEN_STRONG_INLINE void MatrixBase<Derived>::writePacket
++(int row, int col, const typename ei_packet_traits<typename ei_traits<Derived>::Scalar>::type& x)
++{
++  ei_internal_assert(row >= 0 && row < rows()
++                     && col >= 0 && col < cols());
++  derived().template writePacket<StoreMode>(row,col,x);
++}
++
++/** \returns the packet of coefficients starting at the given index. It is your responsibility
++  * to ensure that a packet really starts there. This method is only available on expressions having the
++  * PacketAccessBit and the LinearAccessBit.
++  *
++  * The \a LoadMode parameter may have the value \a Aligned or \a Unaligned. Its effect is to select
++  * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets
++  * starting at an address which is a multiple of the packet size.
++  */
++template<typename Derived>
++template<int LoadMode>
++EIGEN_STRONG_INLINE typename ei_packet_traits<typename ei_traits<Derived>::Scalar>::type
++MatrixBase<Derived>::packet(int index) const
++{
++  ei_internal_assert(index >= 0 && index < size());
++  return derived().template packet<LoadMode>(index);
++}
++
++/** Stores the given packet of coefficients, at the given index in this expression. It is your responsibility
++  * to ensure that a packet really starts there. This method is only available on expressions having the
++  * PacketAccessBit and the LinearAccessBit.
++  *
++  * The \a LoadMode parameter may have the value \a Aligned or \a Unaligned. Its effect is to select
++  * the appropriate vectorization instruction. Aligned access is faster, but is only possible for packets
++  * starting at an address which is a multiple of the packet size.
++  */
++template<typename Derived>
++template<int StoreMode>
++EIGEN_STRONG_INLINE void MatrixBase<Derived>::writePacket
++(int index, const typename ei_packet_traits<typename ei_traits<Derived>::Scalar>::type& x)
++{
++  ei_internal_assert(index >= 0 && index < size());
++  derived().template writePacket<StoreMode>(index,x);
++}
++
++#ifndef EIGEN_PARSED_BY_DOXYGEN
++
++/** \internal Copies the coefficient at position (row,col) of other into *this.
++  *
++  * This method is overridden in SwapWrapper, allowing swap() assignments to share 99% of their code
++  * with usual assignments.
++  *
++  * Outside of this internal usage, this method has probably no usefulness. It is hidden in the public API dox.
++  */
++template<typename Derived>
++template<typename OtherDerived>
++EIGEN_STRONG_INLINE void MatrixBase<Derived>::copyCoeff(int row, int col, const MatrixBase<OtherDerived>& other)
++{
++  ei_internal_assert(row >= 0 && row < rows()
++                     && col >= 0 && col < cols());
++  derived().coeffRef(row, col) = other.derived().coeff(row, col);
++}
++
++/** \internal Copies the coefficient at the given index of other into *this.
++  *
++  * This method is overridden in SwapWrapper, allowing swap() assignments to share 99% of their code
++  * with usual assignments.
++  *
++  * Outside of this internal usage, this method has probably no usefulness. It is hidden in the public API dox.
++  */
++template<typename Derived>
++template<typename OtherDerived>
++EIGEN_STRONG_INLINE void MatrixBase<Derived>::copyCoeff(int index, const MatrixBase<OtherDerived>& other)
++{
++  ei_internal_assert(index >= 0 && index < size());
++  derived().coeffRef(index) = other.derived().coeff(index);
++}
++
++/** \internal Copies the packet at position (row,col) of other into *this.
++  *
++  * This method is overridden in SwapWrapper, allowing swap() assignments to share 99% of their code
++  * with usual assignments.
++  *
++  * Outside of this internal usage, this method has probably no usefulness. It is hidden in the public API dox.
++  */
++template<typename Derived>
++template<typename OtherDerived, int StoreMode, int LoadMode>
++EIGEN_STRONG_INLINE void MatrixBase<Derived>::copyPacket(int row, int col, const MatrixBase<OtherDerived>& other)
++{
++  ei_internal_assert(row >= 0 && row < rows()
++                     && col >= 0 && col < cols());
++  derived().template writePacket<StoreMode>(row, col,
++    other.derived().template packet<LoadMode>(row, col));
++}
++
++/** \internal Copies the packet at the given index of other into *this.
++  *
++  * This method is overridden in SwapWrapper, allowing swap() assignments to share 99% of their code
++  * with usual assignments.
++  *
++  * Outside of this internal usage, this method has probably no usefulness. It is hidden in the public API dox.
++  */
++template<typename Derived>
++template<typename OtherDerived, int StoreMode, int LoadMode>
++EIGEN_STRONG_INLINE void MatrixBase<Derived>::copyPacket(int index, const MatrixBase<OtherDerived>& other)
++{
++  ei_internal_assert(index >= 0 && index < size());
++  derived().template writePacket<StoreMode>(index,
++    other.derived().template packet<LoadMode>(index));
++}
++
++#endif
++
++#endif // EIGEN_COEFFS_H
index 0000000,0000000..ed28e0c
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,149 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra. Eigen itself is part of the KDE project.
++//
++// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
++// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifndef EIGEN_COMMAINITIALIZER_H
++#define EIGEN_COMMAINITIALIZER_H
++
++/** \class CommaInitializer
++  *
++  * \brief Helper class used by the comma initializer operator
++  *
++  * This class is internally used to implement the comma initializer feature. It is
++  * the return type of MatrixBase::operator<<, and most of the time this is the only
++  * way it is used.
++  *
++  * \sa \ref MatrixBaseCommaInitRef "MatrixBase::operator<<", CommaInitializer::finished()
++  */
++template<typename MatrixType>
++struct CommaInitializer
++{
++  typedef typename ei_traits<MatrixType>::Scalar Scalar;
++  inline CommaInitializer(MatrixType& mat, const Scalar& s)
++    : m_matrix(mat), m_row(0), m_col(1), m_currentBlockRows(1)
++  {
++    m_matrix.coeffRef(0,0) = s;
++  }
++
++  template<typename OtherDerived>
++  inline CommaInitializer(MatrixType& mat, const MatrixBase<OtherDerived>& other)
++    : m_matrix(mat), m_row(0), m_col(other.cols()), m_currentBlockRows(other.rows())
++  {
++    m_matrix.block(0, 0, other.rows(), other.cols()) = other;
++  }
++
++  /* inserts a scalar value in the target matrix */
++  CommaInitializer& operator,(const Scalar& s)
++  {
++    if (m_col==m_matrix.cols())
++    {
++      m_row+=m_currentBlockRows;
++      m_col = 0;
++      m_currentBlockRows = 1;
++      ei_assert(m_row<m_matrix.rows()
++        && "Too many rows passed to comma initializer (operator<<)");
++    }
++    ei_assert(m_col<m_matrix.cols()
++      && "Too many coefficients passed to comma initializer (operator<<)");
++    ei_assert(m_currentBlockRows==1);
++    m_matrix.coeffRef(m_row, m_col++) = s;
++    return *this;
++  }
++
++  /* inserts a matrix expression in the target matrix */
++  template<typename OtherDerived>
++  CommaInitializer& operator,(const MatrixBase<OtherDerived>& other)
++  {
++    if (m_col==m_matrix.cols())
++    {
++      m_row+=m_currentBlockRows;
++      m_col = 0;
++      m_currentBlockRows = other.rows();
++      ei_assert(m_row+m_currentBlockRows<=m_matrix.rows()
++        && "Too many rows passed to comma initializer (operator<<)");
++    }
++    ei_assert(m_col<m_matrix.cols()
++      && "Too many coefficients passed to comma initializer (operator<<)");
++    ei_assert(m_currentBlockRows==other.rows());
++    if (OtherDerived::SizeAtCompileTime != Dynamic)
++      m_matrix.template block<OtherDerived::RowsAtCompileTime != Dynamic ? OtherDerived::RowsAtCompileTime : 1,
++                              OtherDerived::ColsAtCompileTime != Dynamic ? OtherDerived::ColsAtCompileTime : 1>
++                    (m_row, m_col) = other;
++    else
++      m_matrix.block(m_row, m_col, other.rows(), other.cols()) = other;
++    m_col += other.cols();
++    return *this;
++  }
++
++  inline ~CommaInitializer()
++  {
++    ei_assert((m_row+m_currentBlockRows) == m_matrix.rows()
++         && m_col == m_matrix.cols()
++         && "Too few coefficients passed to comma initializer (operator<<)");
++  }
++
++  /** \returns the built matrix once all its coefficients have been set.
++    * Calling finished is 100% optional. Its purpose is to write expressions
++    * like this:
++    * \code
++    * quaternion.fromRotationMatrix((Matrix3f() << axis0, axis1, axis2).finished());
++    * \endcode
++    */
++  inline MatrixType& finished() { return m_matrix; }
++
++  MatrixType& m_matrix;   // target matrix
++  int m_row;              // current row id
++  int m_col;              // current col id
++  int m_currentBlockRows; // current block height
++};
++
++/** \anchor MatrixBaseCommaInitRef
++  * Convenient operator to set the coefficients of a matrix.
++  *
++  * The coefficients must be provided in a row major order and exactly match
++  * the size of the matrix. Otherwise an assertion is raised.
++  *
++  * \addexample CommaInit \label How to easily set all the coefficients of a matrix
++  *
++  * Example: \include MatrixBase_set.cpp
++  * Output: \verbinclude MatrixBase_set.out
++  *
++  * \sa CommaInitializer::finished(), class CommaInitializer
++  */
++template<typename Derived>
++inline CommaInitializer<Derived> MatrixBase<Derived>::operator<< (const Scalar& s)
++{
++  return CommaInitializer<Derived>(*static_cast<Derived*>(this), s);
++}
++
++/** \sa operator<<(const Scalar&) */
++template<typename Derived>
++template<typename OtherDerived>
++inline CommaInitializer<Derived>
++MatrixBase<Derived>::operator<<(const MatrixBase<OtherDerived>& other)
++{
++  return CommaInitializer<Derived>(*static_cast<Derived *>(this), other);
++}
++
++#endif // EIGEN_COMMAINITIALIZER_H
index 0000000,0000000..56a9448
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,47 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra. Eigen itself is part of the KDE project.
++//
++// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifdef EIGEN_EXTERN_INSTANTIATIONS
++#undef EIGEN_EXTERN_INSTANTIATIONS
++#endif
++
++#include "../../Core"
++
++namespace Eigen
++{
++
++#define EIGEN_INSTANTIATE_PRODUCT(TYPE) \
++template static void ei_cache_friendly_product<TYPE>( \
++  int _rows, int _cols, int depth, \
++  bool _lhsRowMajor, const TYPE* _lhs, int _lhsStride, \
++  bool _rhsRowMajor, const TYPE* _rhs, int _rhsStride, \
++  bool resRowMajor, TYPE* res, int resStride)
++
++EIGEN_INSTANTIATE_PRODUCT(float);
++EIGEN_INSTANTIATE_PRODUCT(double);
++EIGEN_INSTANTIATE_PRODUCT(int);
++EIGEN_INSTANTIATE_PRODUCT(std::complex<float>);
++EIGEN_INSTANTIATE_PRODUCT(std::complex<double>);
++
++}
index 0000000,0000000..0e92dce
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,211 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra. Eigen itself is part of the KDE project.
++//
++// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
++// Copyright (C) 2008 Benoit Jacob <jacob.benoit.1@gmail.com>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifndef EIGEN_CWISE_H
++#define EIGEN_CWISE_H
++
++/** \internal
++  * convenient macro to defined the return type of a cwise binary operation */
++#define EIGEN_CWISE_BINOP_RETURN_TYPE(OP) \
++    CwiseBinaryOp<OP<typename ei_traits<ExpressionType>::Scalar>, ExpressionType, OtherDerived>
++
++#define EIGEN_CWISE_PRODUCT_RETURN_TYPE \
++    CwiseBinaryOp< \
++      ei_scalar_product_op< \
++        typename ei_scalar_product_traits< \
++          typename ei_traits<ExpressionType>::Scalar, \
++          typename ei_traits<OtherDerived>::Scalar \
++        >::ReturnType \
++      >, \
++      ExpressionType, \
++      OtherDerived \
++    >
++
++/** \internal
++  * convenient macro to defined the return type of a cwise unary operation */
++#define EIGEN_CWISE_UNOP_RETURN_TYPE(OP) \
++    CwiseUnaryOp<OP<typename ei_traits<ExpressionType>::Scalar>, ExpressionType>
++
++/** \internal
++  * convenient macro to defined the return type of a cwise comparison to a scalar */
++#define EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(OP) \
++    CwiseBinaryOp<OP<typename ei_traits<ExpressionType>::Scalar>, ExpressionType, \
++        NestByValue<typename ExpressionType::ConstantReturnType> >
++
++/** \class Cwise
++  *
++  * \brief Pseudo expression providing additional coefficient-wise operations
++  *
++  * \param ExpressionType the type of the object on which to do coefficient-wise operations
++  *
++  * This class represents an expression with additional coefficient-wise features.
++  * It is the return type of MatrixBase::cwise()
++  * and most of the time this is the only way it is used.
++  *
++  * Note that some methods are defined in the \ref Array module.
++  *
++  * Example: \include MatrixBase_cwise_const.cpp
++  * Output: \verbinclude MatrixBase_cwise_const.out
++  *
++  * \sa MatrixBase::cwise() const, MatrixBase::cwise()
++  */
++template<typename ExpressionType> class Cwise
++{
++  public:
++
++    typedef typename ei_traits<ExpressionType>::Scalar Scalar;
++    typedef typename ei_meta_if<ei_must_nest_by_value<ExpressionType>::ret,
++        ExpressionType, const ExpressionType&>::ret ExpressionTypeNested;
++    typedef CwiseUnaryOp<ei_scalar_add_op<Scalar>, ExpressionType> ScalarAddReturnType;
++
++    inline Cwise(const ExpressionType& matrix) : m_matrix(matrix) {}
++
++    /** \internal */
++    inline const ExpressionType& _expression() const { return m_matrix; }
++
++    template<typename OtherDerived>
++    const EIGEN_CWISE_PRODUCT_RETURN_TYPE
++    operator*(const MatrixBase<OtherDerived> &other) const;
++
++    template<typename OtherDerived>
++    const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_quotient_op)
++    operator/(const MatrixBase<OtherDerived> &other) const;
++
++    template<typename OtherDerived>
++    const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_min_op)
++    min(const MatrixBase<OtherDerived> &other) const;
++
++    template<typename OtherDerived>
++    const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_max_op)
++    max(const MatrixBase<OtherDerived> &other) const;
++
++    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_abs_op)      abs() const;
++    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_abs2_op)     abs2() const;
++    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_square_op)   square() const;
++    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_cube_op)     cube() const;
++    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_inverse_op)  inverse() const;
++    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_sqrt_op)     sqrt() const;
++    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_exp_op)      exp() const;
++    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_log_op)      log() const;
++    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_cos_op)      cos() const;
++    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_sin_op)      sin() const;
++    const EIGEN_CWISE_UNOP_RETURN_TYPE(ei_scalar_pow_op)      pow(const Scalar& exponent) const;
++
++    const ScalarAddReturnType
++    operator+(const Scalar& scalar) const;
++
++    /** \relates Cwise */
++    friend const ScalarAddReturnType
++    operator+(const Scalar& scalar, const Cwise& mat)
++    { return mat + scalar; }
++
++    ExpressionType& operator+=(const Scalar& scalar);
++
++    const ScalarAddReturnType
++    operator-(const Scalar& scalar) const;
++
++    ExpressionType& operator-=(const Scalar& scalar);
++
++    template<typename OtherDerived>
++    inline ExpressionType& operator*=(const MatrixBase<OtherDerived> &other);
++
++    template<typename OtherDerived>
++    inline ExpressionType& operator/=(const MatrixBase<OtherDerived> &other);
++
++    template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::less)
++    operator<(const MatrixBase<OtherDerived>& other) const;
++
++    template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::less_equal)
++    operator<=(const MatrixBase<OtherDerived>& other) const;
++
++    template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater)
++    operator>(const MatrixBase<OtherDerived>& other) const;
++
++    template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::greater_equal)
++    operator>=(const MatrixBase<OtherDerived>& other) const;
++
++    template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::equal_to)
++    operator==(const MatrixBase<OtherDerived>& other) const;
++
++    template<typename OtherDerived> const EIGEN_CWISE_BINOP_RETURN_TYPE(std::not_equal_to)
++    operator!=(const MatrixBase<OtherDerived>& other) const;
++
++    // comparisons to a scalar value
++    const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::less)
++    operator<(Scalar s) const;
++
++    const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::less_equal)
++    operator<=(Scalar s) const;
++
++    const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::greater)
++    operator>(Scalar s) const;
++
++    const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::greater_equal)
++    operator>=(Scalar s) const;
++
++    const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::equal_to)
++    operator==(Scalar s) const;
++
++    const EIGEN_CWISE_COMP_TO_SCALAR_RETURN_TYPE(std::not_equal_to)
++    operator!=(Scalar s) const;
++
++    // allow to extend Cwise outside Eigen
++    #ifdef EIGEN_CWISE_PLUGIN
++    #include EIGEN_CWISE_PLUGIN
++    #endif
++
++  protected:
++    ExpressionTypeNested m_matrix;
++};
++
++/** \returns a Cwise wrapper of *this providing additional coefficient-wise operations
++  *
++  * Example: \include MatrixBase_cwise_const.cpp
++  * Output: \verbinclude MatrixBase_cwise_const.out
++  *
++  * \sa class Cwise, cwise()
++  */
++template<typename Derived>
++inline const Cwise<Derived>
++MatrixBase<Derived>::cwise() const
++{
++  return derived();
++}
++
++/** \returns a Cwise wrapper of *this providing additional coefficient-wise operations
++  *
++  * Example: \include MatrixBase_cwise.cpp
++  * Output: \verbinclude MatrixBase_cwise.out
++  *
++  * \sa class Cwise, cwise() const
++  */
++template<typename Derived>
++inline Cwise<Derived>
++MatrixBase<Derived>::cwise()
++{
++  return derived();
++}
++
++#endif // EIGEN_CWISE_H
index 0000000,0000000..c4223e2
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,304 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra. Eigen itself is part of the KDE project.
++//
++// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
++// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifndef EIGEN_CWISE_BINARY_OP_H
++#define EIGEN_CWISE_BINARY_OP_H
++
++/** \class CwiseBinaryOp
++  *
++  * \brief Generic expression of a coefficient-wise operator between two matrices or vectors
++  *
++  * \param BinaryOp template functor implementing the operator
++  * \param Lhs the type of the left-hand side
++  * \param Rhs the type of the right-hand side
++  *
++  * This class represents an expression of a generic binary operator of two matrices or vectors.
++  * It is the return type of the operator+, operator-, and the Cwise methods, and most
++  * of the time this is the only way it is used.
++  *
++  * However, if you want to write a function returning such an expression, you
++  * will need to use this class.
++  *
++  * \sa MatrixBase::binaryExpr(const MatrixBase<OtherDerived> &,const CustomBinaryOp &) const, class CwiseUnaryOp, class CwiseNullaryOp
++  */
++template<typename BinaryOp, typename Lhs, typename Rhs>
++struct ei_traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
++{
++  // even though we require Lhs and Rhs to have the same scalar type (see CwiseBinaryOp constructor),
++  // we still want to handle the case when the result type is different.
++  typedef typename ei_result_of<
++                     BinaryOp(
++                       typename Lhs::Scalar,
++                       typename Rhs::Scalar
++                     )
++                   >::type Scalar;
++  typedef typename Lhs::Nested LhsNested;
++  typedef typename Rhs::Nested RhsNested;
++  typedef typename ei_unref<LhsNested>::type _LhsNested;
++  typedef typename ei_unref<RhsNested>::type _RhsNested;
++  enum {
++    LhsCoeffReadCost = _LhsNested::CoeffReadCost,
++    RhsCoeffReadCost = _RhsNested::CoeffReadCost,
++    LhsFlags = _LhsNested::Flags,
++    RhsFlags = _RhsNested::Flags,
++    RowsAtCompileTime = Lhs::RowsAtCompileTime,
++    ColsAtCompileTime = Lhs::ColsAtCompileTime,
++    MaxRowsAtCompileTime = Lhs::MaxRowsAtCompileTime,
++    MaxColsAtCompileTime = Lhs::MaxColsAtCompileTime,
++    Flags = (int(LhsFlags) | int(RhsFlags)) & (
++        HereditaryBits
++      | (int(LhsFlags) & int(RhsFlags) & (LinearAccessBit | AlignedBit))
++      | (ei_functor_traits<BinaryOp>::PacketAccess && ((int(LhsFlags) & RowMajorBit)==(int(RhsFlags) & RowMajorBit))
++        ? (int(LhsFlags) & int(RhsFlags) & PacketAccessBit) : 0)),
++    CoeffReadCost = LhsCoeffReadCost + RhsCoeffReadCost + ei_functor_traits<BinaryOp>::Cost
++  };
++};
++
++template<typename BinaryOp, typename Lhs, typename Rhs>
++class CwiseBinaryOp : ei_no_assignment_operator,
++  public MatrixBase<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
++{
++  public:
++
++    EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseBinaryOp)
++    typedef typename ei_traits<CwiseBinaryOp>::LhsNested LhsNested;
++    typedef typename ei_traits<CwiseBinaryOp>::RhsNested RhsNested;
++
++    EIGEN_STRONG_INLINE CwiseBinaryOp(const Lhs& lhs, const Rhs& rhs, const BinaryOp& func = BinaryOp())
++      : m_lhs(lhs), m_rhs(rhs), m_functor(func)
++    {
++      // we require Lhs and Rhs to have the same scalar type. Currently there is no example of a binary functor
++      // that would take two operands of different types. If there were such an example, then this check should be
++      // moved to the BinaryOp functors, on a per-case basis. This would however require a change in the BinaryOp functors, as
++      // currently they take only one typename Scalar template parameter.
++      // It is tempting to always allow mixing different types but remember that this is often impossible in the vectorized paths.
++      // So allowing mixing different types gives very unexpected errors when enabling vectorization, when the user tries to
++      // add together a float matrix and a double matrix.
++      EIGEN_STATIC_ASSERT((ei_functor_allows_mixing_real_and_complex<BinaryOp>::ret
++                           ? int(ei_is_same_type<typename Lhs::RealScalar, typename Rhs::RealScalar>::ret)
++                           : int(ei_is_same_type<typename Lhs::Scalar, typename Rhs::Scalar>::ret)),
++        YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
++      // require the sizes to match
++      EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(Lhs, Rhs)
++      ei_assert(lhs.rows() == rhs.rows() && lhs.cols() == rhs.cols());
++    }
++
++    EIGEN_STRONG_INLINE int rows() const { return m_lhs.rows(); }
++    EIGEN_STRONG_INLINE int cols() const { return m_lhs.cols(); }
++
++    EIGEN_STRONG_INLINE const Scalar coeff(int row, int col) const
++    {
++      return m_functor(m_lhs.coeff(row, col), m_rhs.coeff(row, col));
++    }
++
++    template<int LoadMode>
++    EIGEN_STRONG_INLINE PacketScalar packet(int row, int col) const
++    {
++      return m_functor.packetOp(m_lhs.template packet<LoadMode>(row, col), m_rhs.template packet<LoadMode>(row, col));
++    }
++
++    EIGEN_STRONG_INLINE const Scalar coeff(int index) const
++    {
++      return m_functor(m_lhs.coeff(index), m_rhs.coeff(index));
++    }
++
++    template<int LoadMode>
++    EIGEN_STRONG_INLINE PacketScalar packet(int index) const
++    {
++      return m_functor.packetOp(m_lhs.template packet<LoadMode>(index), m_rhs.template packet<LoadMode>(index));
++    }
++
++  protected:
++    const LhsNested m_lhs;
++    const RhsNested m_rhs;
++    const BinaryOp m_functor;
++};
++
++/**\returns an expression of the difference of \c *this and \a other
++  *
++  * \note If you want to substract a given scalar from all coefficients, see Cwise::operator-().
++  *
++  * \sa class CwiseBinaryOp, MatrixBase::operator-=(), Cwise::operator-()
++  */
++template<typename Derived>
++template<typename OtherDerived>
++EIGEN_STRONG_INLINE const CwiseBinaryOp<ei_scalar_difference_op<typename ei_traits<Derived>::Scalar>,
++                                 Derived, OtherDerived>
++MatrixBase<Derived>::operator-(const MatrixBase<OtherDerived> &other) const
++{
++  return CwiseBinaryOp<ei_scalar_difference_op<Scalar>,
++                       Derived, OtherDerived>(derived(), other.derived());
++}
++
++/** replaces \c *this by \c *this - \a other.
++  *
++  * \returns a reference to \c *this
++  */
++template<typename Derived>
++template<typename OtherDerived>
++EIGEN_STRONG_INLINE Derived &
++MatrixBase<Derived>::operator-=(const MatrixBase<OtherDerived> &other)
++{
++  return *this = *this - other;
++}
++
++/** \relates MatrixBase
++  *
++  * \returns an expression of the sum of \c *this and \a other
++  *
++  * \note If you want to add a given scalar to all coefficients, see Cwise::operator+().
++  *
++  * \sa class CwiseBinaryOp, MatrixBase::operator+=(), Cwise::operator+()
++  */
++template<typename Derived>
++template<typename OtherDerived>
++EIGEN_STRONG_INLINE const CwiseBinaryOp<ei_scalar_sum_op<typename ei_traits<Derived>::Scalar>, Derived, OtherDerived>
++MatrixBase<Derived>::operator+(const MatrixBase<OtherDerived> &other) const
++{
++  return CwiseBinaryOp<ei_scalar_sum_op<Scalar>, Derived, OtherDerived>(derived(), other.derived());
++}
++
++/** replaces \c *this by \c *this + \a other.
++  *
++  * \returns a reference to \c *this
++  */
++template<typename Derived>
++template<typename OtherDerived>
++EIGEN_STRONG_INLINE Derived &
++MatrixBase<Derived>::operator+=(const MatrixBase<OtherDerived>& other)
++{
++  return *this = *this + other;
++}
++
++/** \returns an expression of the Schur product (coefficient wise product) of *this and \a other
++  *
++  * Example: \include Cwise_product.cpp
++  * Output: \verbinclude Cwise_product.out
++  *
++  * \sa class CwiseBinaryOp, operator/(), square()
++  */
++template<typename ExpressionType>
++template<typename OtherDerived>
++EIGEN_STRONG_INLINE const EIGEN_CWISE_PRODUCT_RETURN_TYPE
++Cwise<ExpressionType>::operator*(const MatrixBase<OtherDerived> &other) const
++{
++  return EIGEN_CWISE_PRODUCT_RETURN_TYPE(_expression(), other.derived());
++}
++
++/** \returns an expression of the coefficient-wise quotient of *this and \a other
++  *
++  * Example: \include Cwise_quotient.cpp
++  * Output: \verbinclude Cwise_quotient.out
++  *
++  * \sa class CwiseBinaryOp, operator*(), inverse()
++  */
++template<typename ExpressionType>
++template<typename OtherDerived>
++EIGEN_STRONG_INLINE const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_quotient_op)
++Cwise<ExpressionType>::operator/(const MatrixBase<OtherDerived> &other) const
++{
++  return EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_quotient_op)(_expression(), other.derived());
++}
++
++/** Replaces this expression by its coefficient-wise product with \a other.
++  *
++  * Example: \include Cwise_times_equal.cpp
++  * Output: \verbinclude Cwise_times_equal.out
++  *
++  * \sa operator*(), operator/=()
++  */
++template<typename ExpressionType>
++template<typename OtherDerived>
++inline ExpressionType& Cwise<ExpressionType>::operator*=(const MatrixBase<OtherDerived> &other)
++{
++  return m_matrix.const_cast_derived() = *this * other;
++}
++
++/** Replaces this expression by its coefficient-wise quotient by \a other.
++  *
++  * Example: \include Cwise_slash_equal.cpp
++  * Output: \verbinclude Cwise_slash_equal.out
++  *
++  * \sa operator/(), operator*=()
++  */
++template<typename ExpressionType>
++template<typename OtherDerived>
++inline ExpressionType& Cwise<ExpressionType>::operator/=(const MatrixBase<OtherDerived> &other)
++{
++  return m_matrix.const_cast_derived() = *this / other;
++}
++
++/** \returns an expression of the coefficient-wise min of *this and \a other
++  *
++  * Example: \include Cwise_min.cpp
++  * Output: \verbinclude Cwise_min.out
++  *
++  * \sa class CwiseBinaryOp
++  */
++template<typename ExpressionType>
++template<typename OtherDerived>
++EIGEN_STRONG_INLINE const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_min_op)
++Cwise<ExpressionType>::min(const MatrixBase<OtherDerived> &other) const
++{
++  return EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_min_op)(_expression(), other.derived());
++}
++
++/** \returns an expression of the coefficient-wise max of *this and \a other
++  *
++  * Example: \include Cwise_max.cpp
++  * Output: \verbinclude Cwise_max.out
++  *
++  * \sa class CwiseBinaryOp
++  */
++template<typename ExpressionType>
++template<typename OtherDerived>
++EIGEN_STRONG_INLINE const EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_max_op)
++Cwise<ExpressionType>::max(const MatrixBase<OtherDerived> &other) const
++{
++  return EIGEN_CWISE_BINOP_RETURN_TYPE(ei_scalar_max_op)(_expression(), other.derived());
++}
++
++/** \returns an expression of a custom coefficient-wise operator \a func of *this and \a other
++  *
++  * The template parameter \a CustomBinaryOp is the type of the functor
++  * of the custom operator (see class CwiseBinaryOp for an example)
++  *
++  * \addexample CustomCwiseBinaryFunctors \label How to use custom coeff wise binary functors
++  *
++  * Here is an example illustrating the use of custom functors:
++  * \include class_CwiseBinaryOp.cpp
++  * Output: \verbinclude class_CwiseBinaryOp.out
++  *
++  * \sa class CwiseBinaryOp, MatrixBase::operator+, MatrixBase::operator-, Cwise::operator*, Cwise::operator/
++  */
++template<typename Derived>
++template<typename CustomBinaryOp, typename OtherDerived>
++EIGEN_STRONG_INLINE const CwiseBinaryOp<CustomBinaryOp, Derived, OtherDerived>
++MatrixBase<Derived>::binaryExpr(const MatrixBase<OtherDerived> &other, const CustomBinaryOp& func) const
++{
++  return CwiseBinaryOp<CustomBinaryOp, Derived, OtherDerived>(derived(), other.derived(), func);
++}
++
++#endif // EIGEN_CWISE_BINARY_OP_H
index 0000000,0000000..4ee5b58
new file mode 100644 (file)
--- /dev/null
--- /dev/null
@@@ -1,0 -1,0 +1,763 @@@
++// This file is part of Eigen, a lightweight C++ template library
++// for linear algebra. Eigen itself is part of the KDE project.
++//
++// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr>
++//
++// Eigen is free software; you can redistribute it and/or
++// modify it under the terms of the GNU Lesser General Public
++// License as published by the Free Software Foundation; either
++// version 3 of the License, or (at your option) any later version.
++//
++// Alternatively, you can redistribute it and/or
++// modify it under the terms of the GNU General Public License as
++// published by the Free Software Foundation; either version 2 of
++// the License, or (at your option) any later version.
++//
++// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
++// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
++// GNU General Public License for more details.
++//
++// You should have received a copy of the GNU Lesser General Public
++// License and a copy of the GNU General Public License along with
++// Eigen. If not, see <http://www.gnu.org/licenses/>.
++
++#ifndef EIGEN_CWISE_NULLARY_OP_H
++#define EIGEN_CWISE_NULLARY_OP_H
++
++/** \class CwiseNullaryOp
++  *
++  * \brief Generic expression of a matrix where all coefficients are defined by a functor
++  *
++  * \param NullaryOp template functor implementing the operator
++  *
++  * This class represents an expression of a generic nullary operator.
++  * It is the return type of the Ones(), Zero(), Constant(), Identity() and Random() functions,
++  * and most of the time this is the only way it is used.
++  *
++  * However, if you want to write a function returning such an expression, you
++  * will need to use this class.
++  *
++  * \sa class CwiseUnaryOp, class CwiseBinaryOp, MatrixBase::NullaryExpr()
++  */
++template<typename NullaryOp, typename MatrixType>
++struct ei_traits<CwiseNullaryOp<NullaryOp, MatrixType> > : ei_traits<MatrixType>
++{
++  enum {
++    Flags = (ei_traits<MatrixType>::Flags
++      & (  HereditaryBits
++         | (ei_functor_has_linear_access<NullaryOp>::ret ? LinearAccessBit : 0)
++         | (ei_functor_traits<NullaryOp>::PacketAccess ? PacketAccessBit : 0)))
++      | (ei_functor_traits<NullaryOp>::IsRepeatable ? 0 : EvalBeforeNestingBit),
++    CoeffReadCost = ei_functor_traits<NullaryOp>::Cost
++  };
++};
++
++template<typename NullaryOp, typename MatrixType>
++class CwiseNullaryOp : ei_no_assignment_operator,
++  public MatrixBase<CwiseNullaryOp<NullaryOp, MatrixType> >
++{
++  public:
++
++    EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseNullaryOp)
++
++    CwiseNullaryOp(int rows, int cols, const NullaryOp& func = NullaryOp())
++      : m_rows(rows), m_cols(cols), m_functor(func)
++    {
++      ei_assert(rows > 0
++          && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows)
++          && cols > 0
++          && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols));
++    }
++
++    EIGEN_STRONG_INLINE int rows() const { return m_rows.value(); }
++    EIGEN_STRONG_INLINE int cols() const { return m_cols.value(); }
++
++    EIGEN_STRONG_INLINE const Scalar coeff(int rows, int cols) const
++    {
++      return m_functor(rows, cols);
++    }
++
++    template<int LoadMode>
++    EIGEN_STRONG_INLINE PacketScalar packet(int, int) const
++    {
++      return m_functor.packetOp();
++    }
++
++    EIGEN_STRONG_INLINE const Scalar coeff(int index) const
++    {
++      if(RowsAtCompileTime == 1)
++        return m_functor(0, index);
++      else
++        return m_functor(index, 0);
++    }
++
++    template<int LoadMode>
++    EIGEN_STRONG_INLINE PacketScalar packet(int) const
++    {
++      return m_functor.packetOp();
++    }
++
++  protected:
++    const ei_int_if_dynamic<RowsAtCompileTime> m_rows;
++    const ei_int_if_dynamic<ColsAtCompileTime> m_cols;
++    const NullaryOp m_functor;
++};
++
++
++/** \returns an expression of a matrix defined by a custom functor \a func
++  *
++  * The parameters \a rows and \a cols are the number of rows and of columns of
++  * the returned matrix. Must be compatible with this MatrixBase type.
++  *
++  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
++  * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used
++  * instead.
++  *
++  * The template parameter \a CustomNullaryOp is the type of the functor.
++  *
++  * \sa class CwiseNullaryOp
++  */
++template<typename Derived>
++template<typename CustomNullaryOp>
++EIGEN_STRONG_INLINE const CwiseNullaryOp<CustomNullaryOp, Derived>
++MatrixBase<Derived>::NullaryExpr(int rows, int cols, const CustomNullaryOp& func)
++{
++  return CwiseNullaryOp<CustomNullaryOp, Derived>(rows, cols, func);
++}
++
++/** \returns an expression of a matrix defined by a custom functor \a func
++  *
++  * The parameter \a size is the size of the returned vector.
++  * Must be compatible with this MatrixBase type.
++  *
++  * \only_for_vectors
++  *
++  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
++  * it is redundant to pass \a size as argument, so Zero() should be used
++  * instead.
++  *
++  * The template parameter \a CustomNullaryOp is the type of the functor.
++  *
++  * \sa class CwiseNullaryOp
++  */
++template<typename Derived>
++template<typename CustomNullaryOp>
++EIGEN_STRONG_INLINE const CwiseNullaryOp<CustomNullaryOp, Derived>
++MatrixBase<Derived>::NullaryExpr(int size, const CustomNullaryOp& func)
++{
++  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
++  ei_assert(IsVectorAtCompileTime);
++  if(RowsAtCompileTime == 1) return CwiseNullaryOp<CustomNullaryOp, Derived>(1, size, func);
++  else return CwiseNullaryOp<CustomNullaryOp, Derived>(size, 1, func);
++}
++
++/** \returns an expression of a matrix defined by a custom functor \a func
++  *
++  * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
++  * need to use the variants taking size arguments.
++  *
++  * The template parameter \a CustomNullaryOp is the type of the functor.
++  *
++  * \sa class CwiseNullaryOp
++  */
++template<typename Derived>
++template<typename CustomNullaryOp>
++EIGEN_STRONG_INLINE const CwiseNullaryOp<CustomNullaryOp, Derived>
++MatrixBase<Derived>::NullaryExpr(const CustomNullaryOp& func)
++{
++  return CwiseNullaryOp<CustomNullaryOp, Derived>(RowsAtCompileTime, ColsAtCompileTime, func);
++}
++
++/** \returns an expression of a constant matrix of value \a value
++  *
++  * The parameters \a rows and \a cols are the number of rows and of columns of
++  * the returned matrix. Must be compatible with this MatrixBase type.
++  *
++  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
++  * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used
++  * instead.
++  *
++  * The template parameter \a CustomNullaryOp is the type of the functor.
++  *
++  * \sa class CwiseNullaryOp
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ConstantReturnType
++MatrixBase<Derived>::Constant(int rows, int cols, const Scalar& value)
++{
++  return NullaryExpr(rows, cols, ei_scalar_constant_op<Scalar>(value));
++}
++
++/** \returns an expression of a constant matrix of value \a value
++  *
++  * The parameter \a size is the size of the returned vector.
++  * Must be compatible with this MatrixBase type.
++  *
++  * \only_for_vectors
++  *
++  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
++  * it is redundant to pass \a size as argument, so Zero() should be used
++  * instead.
++  *
++  * The template parameter \a CustomNullaryOp is the type of the functor.
++  *
++  * \sa class CwiseNullaryOp
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ConstantReturnType
++MatrixBase<Derived>::Constant(int size, const Scalar& value)
++{
++  return NullaryExpr(size, ei_scalar_constant_op<Scalar>(value));
++}
++
++/** \returns an expression of a constant matrix of value \a value
++  *
++  * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
++  * need to use the variants taking size arguments.
++  *
++  * The template parameter \a CustomNullaryOp is the type of the functor.
++  *
++  * \sa class CwiseNullaryOp
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ConstantReturnType
++MatrixBase<Derived>::Constant(const Scalar& value)
++{
++  EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
++  return NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, ei_scalar_constant_op<Scalar>(value));
++}
++
++/** \returns true if all coefficients in this matrix are approximately equal to \a value, to within precision \a prec */
++template<typename Derived>
++bool MatrixBase<Derived>::isApproxToConstant
++(const Scalar& value, RealScalar prec) const
++{
++  for(int j = 0; j < cols(); ++j)
++    for(int i = 0; i < rows(); ++i)
++      if(!ei_isApprox(coeff(i, j), value, prec))
++        return false;
++  return true;
++}
++
++/** This is just an alias for isApproxToConstant().
++  *
++  * \returns true if all coefficients in this matrix are approximately equal to \a value, to within precision \a prec */
++template<typename Derived>
++bool MatrixBase<Derived>::isConstant
++(const Scalar& value, RealScalar prec) const
++{
++  return isApproxToConstant(value, prec);
++}
++
++/** Alias for setConstant(): sets all coefficients in this expression to \a value.
++  *
++  * \sa setConstant(), Constant(), class CwiseNullaryOp
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE void MatrixBase<Derived>::fill(const Scalar& value)
++{
++  setConstant(value);
++}
++
++/** Sets all coefficients in this expression to \a value.
++  *
++  * \sa fill(), setConstant(int,const Scalar&), setConstant(int,int,const Scalar&), setZero(), setOnes(), Constant(), class CwiseNullaryOp, setZero(), setOnes()
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setConstant(const Scalar& value)
++{
++  return derived() = Constant(rows(), cols(), value);
++}
++
++/** Resizes to the given \a size, and sets all coefficients in this expression to the given \a value.
++  *
++  * \only_for_vectors
++  *
++  * Example: \include Matrix_set_int.cpp
++  * Output: \verbinclude Matrix_setConstant_int.out
++  *
++  * \sa MatrixBase::setConstant(const Scalar&), setConstant(int,int,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
++  */
++template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
++EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>&
++Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setConstant(int size, const Scalar& value)
++{
++  resize(size);
++  return setConstant(value);
++}
++
++/** Resizes to the given size, and sets all coefficients in this expression to the given \a value.
++  *
++  * \param rows the new number of rows
++  * \param cols the new number of columns
++  *
++  * Example: \include Matrix_setConstant_int_int.cpp
++  * Output: \verbinclude Matrix_setConstant_int_int.out
++  *
++  * \sa MatrixBase::setConstant(const Scalar&), setConstant(int,const Scalar&), class CwiseNullaryOp, MatrixBase::Constant(const Scalar&)
++  */
++template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
++EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>&
++Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setConstant(int rows, int cols, const Scalar& value)
++{
++  resize(rows, cols);
++  return setConstant(value);
++}
++
++
++// zero:
++
++/** \returns an expression of a zero matrix.
++  *
++  * The parameters \a rows and \a cols are the number of rows and of columns of
++  * the returned matrix. Must be compatible with this MatrixBase type.
++  *
++  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
++  * it is redundant to pass \a rows and \a cols as arguments, so Zero() should be used
++  * instead.
++  *
++  * \addexample Zero \label How to take get a zero matrix
++  *
++  * Example: \include MatrixBase_zero_int_int.cpp
++  * Output: \verbinclude MatrixBase_zero_int_int.out
++  *
++  * \sa Zero(), Zero(int)
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ConstantReturnType
++MatrixBase<Derived>::Zero(int rows, int cols)
++{
++  return Constant(rows, cols, Scalar(0));
++}
++
++/** \returns an expression of a zero vector.
++  *
++  * The parameter \a size is the size of the returned vector.
++  * Must be compatible with this MatrixBase type.
++  *
++  * \only_for_vectors
++  *
++  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
++  * it is redundant to pass \a size as argument, so Zero() should be used
++  * instead.
++  *
++  * Example: \include MatrixBase_zero_int.cpp
++  * Output: \verbinclude MatrixBase_zero_int.out
++  *
++  * \sa Zero(), Zero(int,int)
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ConstantReturnType
++MatrixBase<Derived>::Zero(int size)
++{
++  return Constant(size, Scalar(0));
++}
++
++/** \returns an expression of a fixed-size zero matrix or vector.
++  *
++  * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
++  * need to use the variants taking size arguments.
++  *
++  * Example: \include MatrixBase_zero.cpp
++  * Output: \verbinclude MatrixBase_zero.out
++  *
++  * \sa Zero(int), Zero(int,int)
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ConstantReturnType
++MatrixBase<Derived>::Zero()
++{
++  return Constant(Scalar(0));
++}
++
++/** \returns true if *this is approximately equal to the zero matrix,
++  *          within the precision given by \a prec.
++  *
++  * Example: \include MatrixBase_isZero.cpp
++  * Output: \verbinclude MatrixBase_isZero.out
++  *
++  * \sa class CwiseNullaryOp, Zero()
++  */
++template<typename Derived>
++bool MatrixBase<Derived>::isZero(RealScalar prec) const
++{
++  for(int j = 0; j < cols(); ++j)
++    for(int i = 0; i < rows(); ++i)
++      if(!ei_isMuchSmallerThan(coeff(i, j), static_cast<Scalar>(1), prec))
++        return false;
++  return true;
++}
++
++/** Sets all coefficients in this expression to zero.
++  *
++  * Example: \include MatrixBase_setZero.cpp
++  * Output: \verbinclude MatrixBase_setZero.out
++  *
++  * \sa class CwiseNullaryOp, Zero()
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setZero()
++{
++  return setConstant(Scalar(0));
++}
++
++/** Resizes to the given \a size, and sets all coefficients in this expression to zero.
++  *
++  * \only_for_vectors
++  *
++  * Example: \include Matrix_setZero_int.cpp
++  * Output: \verbinclude Matrix_setZero_int.out
++  *
++  * \sa MatrixBase::setZero(), setZero(int,int), class CwiseNullaryOp, MatrixBase::Zero()
++  */
++template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
++EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>&
++Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setZero(int size)
++{
++  resize(size);
++  return setConstant(Scalar(0));
++}
++
++/** Resizes to the given size, and sets all coefficients in this expression to zero.
++  *
++  * \param rows the new number of rows
++  * \param cols the new number of columns
++  *
++  * Example: \include Matrix_setZero_int_int.cpp
++  * Output: \verbinclude Matrix_setZero_int_int.out
++  *
++  * \sa MatrixBase::setZero(), setZero(int), class CwiseNullaryOp, MatrixBase::Zero()
++  */
++template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
++EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>&
++Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setZero(int rows, int cols)
++{
++  resize(rows, cols);
++  return setConstant(Scalar(0));
++}
++
++// ones:
++
++/** \returns an expression of a matrix where all coefficients equal one.
++  *
++  * The parameters \a rows and \a cols are the number of rows and of columns of
++  * the returned matrix. Must be compatible with this MatrixBase type.
++  *
++  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
++  * it is redundant to pass \a rows and \a cols as arguments, so Ones() should be used
++  * instead.
++  *
++  * \addexample One \label How to get a matrix with all coefficients equal one
++  *
++  * Example: \include MatrixBase_ones_int_int.cpp
++  * Output: \verbinclude MatrixBase_ones_int_int.out
++  *
++  * \sa Ones(), Ones(int), isOnes(), class Ones
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ConstantReturnType
++MatrixBase<Derived>::Ones(int rows, int cols)
++{
++  return Constant(rows, cols, Scalar(1));
++}
++
++/** \returns an expression of a vector where all coefficients equal one.
++  *
++  * The parameter \a size is the size of the returned vector.
++  * Must be compatible with this MatrixBase type.
++  *
++  * \only_for_vectors
++  *
++  * This variant is meant to be used for dynamic-size vector types. For fixed-size types,
++  * it is redundant to pass \a size as argument, so Ones() should be used
++  * instead.
++  *
++  * Example: \include MatrixBase_ones_int.cpp
++  * Output: \verbinclude MatrixBase_ones_int.out
++  *
++  * \sa Ones(), Ones(int,int), isOnes(), class Ones
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ConstantReturnType
++MatrixBase<Derived>::Ones(int size)
++{
++  return Constant(size, Scalar(1));
++}
++
++/** \returns an expression of a fixed-size matrix or vector where all coefficients equal one.
++  *
++  * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
++  * need to use the variants taking size arguments.
++  *
++  * Example: \include MatrixBase_ones.cpp
++  * Output: \verbinclude MatrixBase_ones.out
++  *
++  * \sa Ones(int), Ones(int,int), isOnes(), class Ones
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::ConstantReturnType
++MatrixBase<Derived>::Ones()
++{
++  return Constant(Scalar(1));
++}
++
++/** \returns true if *this is approximately equal to the matrix where all coefficients
++  *          are equal to 1, within the precision given by \a prec.
++  *
++  * Example: \include MatrixBase_isOnes.cpp
++  * Output: \verbinclude MatrixBase_isOnes.out
++  *
++  * \sa class CwiseNullaryOp, Ones()
++  */
++template<typename Derived>
++bool MatrixBase<Derived>::isOnes
++(RealScalar prec) const
++{
++  return isApproxToConstant(Scalar(1), prec);
++}
++
++/** Sets all coefficients in this expression to one.
++  *
++  * Example: \include MatrixBase_setOnes.cpp
++  * Output: \verbinclude MatrixBase_setOnes.out
++  *
++  * \sa class CwiseNullaryOp, Ones()
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setOnes()
++{
++  return setConstant(Scalar(1));
++}
++
++/** Resizes to the given \a size, and sets all coefficients in this expression to one.
++  *
++  * \only_for_vectors
++  *
++  * Example: \include Matrix_setOnes_int.cpp
++  * Output: \verbinclude Matrix_setOnes_int.out
++  *
++  * \sa MatrixBase::setOnes(), setOnes(int,int), class CwiseNullaryOp, MatrixBase::Ones()
++  */
++template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
++EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>&
++Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setOnes(int size)
++{
++  resize(size);
++  return setConstant(Scalar(1));
++}
++
++/** Resizes to the given size, and sets all coefficients in this expression to one.
++  *
++  * \param rows the new number of rows
++  * \param cols the new number of columns
++  *
++  * Example: \include Matrix_setOnes_int_int.cpp
++  * Output: \verbinclude Matrix_setOnes_int_int.out
++  *
++  * \sa MatrixBase::setOnes(), setOnes(int), class CwiseNullaryOp, MatrixBase::Ones()
++  */
++template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
++EIGEN_STRONG_INLINE Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>&
++Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::setOnes(int rows, int cols)
++{
++  resize(rows, cols);
++  return setConstant(Scalar(1));
++}
++
++// Identity:
++
++/** \returns an expression of the identity matrix (not necessarily square).
++  *
++  * The parameters \a rows and \a cols are the number of rows and of columns of
++  * the returned matrix. Must be compatible with this MatrixBase type.
++  *
++  * This variant is meant to be used for dynamic-size matrix types. For fixed-size types,
++  * it is redundant to pass \a rows and \a cols as arguments, so Identity() should be used
++  * instead.
++  *
++  * \addexample Identity \label How to get an identity matrix
++  *
++  * Example: \include MatrixBase_identity_int_int.cpp
++  * Output: \verbinclude MatrixBase_identity_int_int.out
++  *
++  * \sa Identity(), setIdentity(), isIdentity()
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::IdentityReturnType
++MatrixBase<Derived>::Identity(int rows, int cols)
++{
++  return NullaryExpr(rows, cols, ei_scalar_identity_op<Scalar>());
++}
++
++/** \returns an expression of the identity matrix (not necessarily square).
++  *
++  * This variant is only for fixed-size MatrixBase types. For dynamic-size types, you
++  * need to use the variant taking size arguments.
++  *
++  * Example: \include MatrixBase_identity.cpp
++  * Output: \verbinclude MatrixBase_identity.out
++  *
++  * \sa Identity(int,int), setIdentity(), isIdentity()
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::IdentityReturnType
++MatrixBase<Derived>::Identity()
++{
++  EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived)
++  return NullaryExpr(RowsAtCompileTime, ColsAtCompileTime, ei_scalar_identity_op<Scalar>());
++}
++
++/** \returns true if *this is approximately equal to the identity matrix
++  *          (not necessarily square),
++  *          within the precision given by \a prec.
++  *
++  * Example: \include MatrixBase_isIdentity.cpp
++  * Output: \verbinclude MatrixBase_isIdentity.out
++  *
++  * \sa class CwiseNullaryOp, Identity(), Identity(int,int), setIdentity()
++  */
++template<typename Derived>
++bool MatrixBase<Derived>::isIdentity
++(RealScalar prec) const
++{
++  for(int j = 0; j < cols(); ++j)
++  {
++    for(int i = 0; i < rows(); ++i)
++    {
++      if(i == j)
++      {
++        if(!ei_isApprox(coeff(i, j), static_cast<Scalar>(1), prec))
++          return false;
++      }
++      else
++      {
++        if(!ei_isMuchSmallerThan(coeff(i, j), static_cast<RealScalar>(1), prec))
++          return false;
++      }
++    }
++  }
++  return true;
++}
++
++template<typename Derived, bool Big = (Derived::SizeAtCompileTime>=16)>
++struct ei_setIdentity_impl
++{
++  static EIGEN_STRONG_INLINE Derived& run(Derived& m)
++  {
++    return m = Derived::Identity(m.rows(), m.cols());
++  }
++};
++
++template<typename Derived>
++struct ei_setIdentity_impl<Derived, true>
++{
++  static EIGEN_STRONG_INLINE Derived& run(Derived& m)
++  {
++    m.setZero();
++    const int size = std::min(m.rows(), m.cols());
++    for(int i = 0; i < size; ++i) m.coeffRef(i,i) = typename Derived::Scalar(1);
++    return m;
++  }
++};
++
++/** Writes the identity expression (not necessarily square) into *this.
++  *
++  * Example: \include MatrixBase_setIdentity.cpp
++  * Output: \verbinclude MatrixBase_setIdentity.out
++  *
++  * \sa class CwiseNullaryOp, Identity(), Identity(int,int), isIdentity()
++  */
++template<typename Derived>
++EIGEN_STRONG_INLINE Derived& MatrixBase<Derived>::setIdentity()
++{
++  return ei_setIdentity_impl<Derived>::run(derived());
++}
++
++/** Resizes to the given size, and writes the id