casadi 3.6.4__cp38-none-manylinux2014_aarch64.whl → 3.6.6__cp38-none-manylinux2014_aarch64.whl

casadi/include/include/eigen3/unsupported/Eigen/NumericalDiff

@@ -1,56 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2009 Thomas Capricelli <orzel@freehackers.org>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_NUMERICALDIFF_MODULE
-#define EIGEN_NUMERICALDIFF_MODULE
-
-#include "../../Eigen/Core"
-
-namespace Eigen {
-
-/**
-  * \defgroup NumericalDiff_Module Numerical differentiation module
-  *
-  * \code
-  * #include <unsupported/Eigen/NumericalDiff>
-  * \endcode
-  *
-  * See http://en.wikipedia.org/wiki/Numerical_differentiation
-  *
-  * Warning : this should NOT be confused with automatic differentiation, which
-  * is a different method and has its own module in Eigen : \ref
-  * AutoDiff_Module.
-  *
-  * Currently only "Forward" and "Central" schemes are implemented. Those
-  * are basic methods, and there exist some more elaborated way of
-  * computing such approximates. They are implemented using both
-  * proprietary and free software, and usually requires linking to an
-  * external library. It is very easy for you to write a functor
-  * using such software, and the purpose is quite orthogonal to what we
-  * want to achieve with Eigen.
-  *
-  * This is why we will not provide wrappers for every great numerical
-  * differentiation software that exist, but should rather stick with those
-  * basic ones, that still are useful for testing.
-  *
-  * Also, the \ref NonLinearOptimization_Module needs this in order to
-  * provide full features compatibility with the original (c)minpack
-  * package.
-  *
-  */
-}
-
-//@{
-
-#include "src/NumericalDiff/NumericalDiff.h"
-
-//@}
-
-
-#endif // EIGEN_NUMERICALDIFF_MODULE

casadi/include/include/eigen3/unsupported/Eigen/OpenGLSupport

@@ -1,322 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_OPENGL_MODULE
-#define EIGEN_OPENGL_MODULE
-
-#include "../../Eigen/Geometry"
-
-#if defined(__APPLE_CC__)
-  #include <OpenGL/gl.h>
-#else
-  #include <GL/gl.h>
-#endif
-
-namespace Eigen {
-
-/**
-  * \defgroup OpenGLSUpport_Module OpenGL Support module
-  *
-  * This module provides wrapper functions for a couple of OpenGL functions
-  * which simplify the way to pass Eigen's object to openGL.
-  * Here is an example:
-  * 
-  * \code
-  * // You need to add path_to_eigen/unsupported to your include path.
-  * #include <Eigen/OpenGLSupport>
-  * // ...
-  * Vector3f x, y;
-  * Matrix3f rot;
-  * 
-  * glVertex(y + x * rot);
-  * 
-  * Quaternion q;
-  * glRotate(q);
-  * 
-  * // ...
-  * \endcode
-  *
-  */
-//@{
-
-#define EIGEN_GL_FUNC_DECLARATION(FUNC)                                                                             \
-namespace internal {                                                                                                \
-  template< typename XprType,                                                                                       \
-            typename Scalar = typename XprType::Scalar,                                                             \
-            int Rows = XprType::RowsAtCompileTime,                                                                  \
-            int Cols = XprType::ColsAtCompileTime,                                                                  \
-            bool IsGLCompatible = bool(internal::evaluator<XprType>::Flags&LinearAccessBit)                         \
-                              && bool(XprType::Flags&DirectAccessBit)                                               \
-                              && (XprType::IsVectorAtCompileTime || (XprType::Flags&RowMajorBit)==0)>               \
-  struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl);                                                                      \
-                                                                                                                    \
-  template<typename XprType, typename Scalar, int Rows, int Cols>                                                   \
-  struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType,Scalar,Rows,Cols,false> {                                     \
-    inline static void run(const XprType& p) {                                                                      \
-      EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<typename plain_matrix_type_column_major<XprType>::type>::run(p); }       \
-  };                                                                                                                \
-}                                                                                                                   \
-                                                                                                                    \
-template<typename Derived> inline void FUNC(const Eigen::DenseBase<Derived>& p) {                                   \
-  EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl)<Derived>::run(p.derived());                                        \
-}
-
-
-#define EIGEN_GL_FUNC_SPECIALIZATION_MAT(FUNC,SCALAR,ROWS,COLS,SUFFIX)                                              \
-namespace internal {                                                                                                \
-  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, ROWS, COLS, true> {      \
-    inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); }                                            \
-  };                                                                                                                \
-}
-
-  
-#define EIGEN_GL_FUNC_SPECIALIZATION_VEC(FUNC,SCALAR,SIZE,SUFFIX)                                                   \
-namespace internal {                                                                                                \
-  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, SIZE, 1, true> {         \
-    inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); }                                            \
-  };                                                                                                                \
-  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, 1, SIZE, true> {         \
-    inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); }                                            \
-  };                                                                                                                \
-}
-
-  
-EIGEN_GL_FUNC_DECLARATION       (glVertex)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,int,    2,2iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,short,  2,2sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,float,  2,2fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,double, 2,2dv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,int,    3,3iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,short,  3,3sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,float,  3,3fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,double, 3,3dv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,int,    4,4iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,short,  4,4sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,float,  4,4fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,double, 4,4dv)
-
-EIGEN_GL_FUNC_DECLARATION       (glTexCoord)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,int,    2,2iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,short,  2,2sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,float,  2,2fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,double, 2,2dv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,int,    3,3iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,short,  3,3sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,float,  3,3fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,double, 3,3dv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,int,    4,4iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,short,  4,4sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,float,  4,4fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,double, 4,4dv)
-
-EIGEN_GL_FUNC_DECLARATION       (glColor)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,int,    2,2iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,short,  2,2sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,float,  2,2fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,double, 2,2dv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,int,    3,3iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,short,  3,3sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,float,  3,3fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,double, 3,3dv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,int,    4,4iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,short,  4,4sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,float,  4,4fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,double, 4,4dv)
-
-EIGEN_GL_FUNC_DECLARATION       (glNormal)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal,int,    3,3iv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal,short,  3,3sv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal,float,  3,3fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal,double, 3,3dv)
-
-inline void glScale2fv(const float*  v) { glScalef(v[0], v[1], 1.f);  }
-inline void glScale2dv(const double* v) { glScaled(v[0], v[1], 1.0);  }
-inline void glScale3fv(const float*  v) { glScalef(v[0], v[1], v[2]); }
-inline void glScale3dv(const double* v) { glScaled(v[0], v[1], v[2]); }
-
-EIGEN_GL_FUNC_DECLARATION       (glScale)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale,float,  2,2fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale,double, 2,2dv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale,float,  3,3fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale,double, 3,3dv)
-
-template<typename Scalar> void glScale(const UniformScaling<Scalar>& s)  { glScale(Matrix<Scalar,3,1>::Constant(s.factor())); }
-
-inline void glTranslate2fv(const float*  v) { glTranslatef(v[0], v[1], 0.f);  }
-inline void glTranslate2dv(const double* v) { glTranslated(v[0], v[1], 0.0);  }
-inline void glTranslate3fv(const float*  v) { glTranslatef(v[0], v[1], v[2]); }
-inline void glTranslate3dv(const double* v) { glTranslated(v[0], v[1], v[2]); }
-
-EIGEN_GL_FUNC_DECLARATION       (glTranslate)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate,float,  2,2fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate,double, 2,2dv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate,float,  3,3fv)
-EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate,double, 3,3dv)
-
-template<typename Scalar> void glTranslate(const Translation<Scalar,2>& t)  { glTranslate(t.vector()); }
-template<typename Scalar> void glTranslate(const Translation<Scalar,3>& t)  { glTranslate(t.vector()); }
-
-EIGEN_GL_FUNC_DECLARATION       (glMultMatrix)
-EIGEN_GL_FUNC_SPECIALIZATION_MAT(glMultMatrix,float,  4,4,f)
-EIGEN_GL_FUNC_SPECIALIZATION_MAT(glMultMatrix,double, 4,4,d)
-
-template<typename Scalar> void glMultMatrix(const Transform<Scalar,3,Affine>& t)        { glMultMatrix(t.matrix()); }
-template<typename Scalar> void glMultMatrix(const Transform<Scalar,3,Projective>& t)    { glMultMatrix(t.matrix()); }
-template<typename Scalar> void glMultMatrix(const Transform<Scalar,3,AffineCompact>& t) { glMultMatrix(Transform<Scalar,3,Affine>(t).matrix()); }
-
-EIGEN_GL_FUNC_DECLARATION       (glLoadMatrix)
-EIGEN_GL_FUNC_SPECIALIZATION_MAT(glLoadMatrix,float,  4,4,f)
-EIGEN_GL_FUNC_SPECIALIZATION_MAT(glLoadMatrix,double, 4,4,d)
-
-template<typename Scalar> void glLoadMatrix(const Transform<Scalar,3,Affine>& t)        { glLoadMatrix(t.matrix()); }
-template<typename Scalar> void glLoadMatrix(const Transform<Scalar,3,Projective>& t)    { glLoadMatrix(t.matrix()); }
-template<typename Scalar> void glLoadMatrix(const Transform<Scalar,3,AffineCompact>& t) { glLoadMatrix(Transform<Scalar,3,Affine>(t).matrix()); }
-
-inline void glRotate(const Rotation2D<float>& rot)
-{
-  glRotatef(rot.angle()*180.f/float(EIGEN_PI), 0.f, 0.f, 1.f);
-}
-inline void glRotate(const Rotation2D<double>& rot)
-{
-  glRotated(rot.angle()*180.0/double(EIGEN_PI), 0.0, 0.0, 1.0);
-}
-
-template<typename Derived> void glRotate(const RotationBase<Derived,3>& rot)
-{  
-  Transform<typename Derived::Scalar,3,Projective> tr(rot);
-  glMultMatrix(tr.matrix());
-}
-
-#define EIGEN_GL_MAKE_CONST_const const
-#define EIGEN_GL_MAKE_CONST__ 
-#define EIGEN_GL_EVAL(X) X
-
-#define EIGEN_GL_FUNC1_DECLARATION(FUNC,ARG1,CONST)                                                                             \
-namespace internal {                                                                                                            \
-  template< typename XprType,                                                                                                   \
-            typename Scalar = typename XprType::Scalar,                                                                         \
-            int Rows = XprType::RowsAtCompileTime,                                                                              \
-            int Cols = XprType::ColsAtCompileTime,                                                                              \
-            bool IsGLCompatible = bool(internal::evaluator<XprType>::Flags&LinearAccessBit)                                     \
-                              && bool(XprType::Flags&DirectAccessBit)                                                           \
-                              && (XprType::IsVectorAtCompileTime || (XprType::Flags&RowMajorBit)==0)>                           \
-  struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl);                                                                                  \
-                                                                                                                                \
-  template<typename XprType, typename Scalar, int Rows, int Cols>                                                               \
-  struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType,Scalar,Rows,Cols,false> {                                                 \
-    inline static void run(ARG1 a,EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) {                                      \
-      EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<typename plain_matrix_type_column_major<XprType>::type>::run(a,p); }                 \
-  };                                                                                                                            \
-}                                                                                                                               \
-                                                                                                                                \
-template<typename Derived> inline void FUNC(ARG1 a,EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) Eigen::DenseBase<Derived>& p) {   \
-  EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl)<Derived>::run(a,p.derived());                                                  \
-}
-
-
-#define EIGEN_GL_FUNC1_SPECIALIZATION_MAT(FUNC,ARG1,CONST,SCALAR,ROWS,COLS,SUFFIX)                                              \
-namespace internal {                                                                                                            \
-  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, ROWS, COLS, true> {                  \
-    inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { FUNC##SUFFIX(a,p.data()); }         \
-  }; \
-}
-
-  
-#define EIGEN_GL_FUNC1_SPECIALIZATION_VEC(FUNC,ARG1,CONST,SCALAR,SIZE,SUFFIX)                                                   \
-namespace internal {                                                                                                            \
-  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, SIZE, 1, true> {                     \
-    inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { FUNC##SUFFIX(a,p.data()); }         \
-  };                                                                                                                            \
-  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, 1, SIZE, true> {                     \
-    inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { FUNC##SUFFIX(a,p.data()); }         \
-  };                                                                                                                            \
-}
-
-EIGEN_GL_FUNC1_DECLARATION       (glGet,GLenum,_)
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glGet,GLenum,_,float,  4,4,Floatv)
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glGet,GLenum,_,double, 4,4,Doublev)
-
-// glUniform API
-
-#ifdef GL_VERSION_2_0
-
-inline void glUniform2fv_ei  (GLint loc, const float* v)         { glUniform2fv(loc,1,v); }
-inline void glUniform2iv_ei  (GLint loc, const int* v)           { glUniform2iv(loc,1,v); }
-
-inline void glUniform3fv_ei  (GLint loc, const float* v)         { glUniform3fv(loc,1,v); }
-inline void glUniform3iv_ei  (GLint loc, const int* v)           { glUniform3iv(loc,1,v); }
-
-inline void glUniform4fv_ei  (GLint loc, const float* v)         { glUniform4fv(loc,1,v); }
-inline void glUniform4iv_ei  (GLint loc, const int* v)           { glUniform4iv(loc,1,v); }
-
-inline void glUniformMatrix2fv_ei  (GLint loc, const float* v)         { glUniformMatrix2fv(loc,1,false,v); }
-inline void glUniformMatrix3fv_ei  (GLint loc, const float* v)         { glUniformMatrix3fv(loc,1,false,v); }
-inline void glUniformMatrix4fv_ei  (GLint loc, const float* v)         { glUniformMatrix4fv(loc,1,false,v); }
-
-
-EIGEN_GL_FUNC1_DECLARATION       (glUniform,GLint,const)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,float,        2,2fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,int,          2,2iv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,float,        3,3fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,int,          3,3iv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,float,        4,4fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,int,          4,4iv_ei)
-
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float,        2,2,Matrix2fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float,        3,3,Matrix3fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float,        4,4,Matrix4fv_ei)
-
-#endif
-
-#ifdef GL_VERSION_2_1
-
-inline void glUniformMatrix2x3fv_ei(GLint loc, const float* v)         { glUniformMatrix2x3fv(loc,1,false,v); }
-inline void glUniformMatrix3x2fv_ei(GLint loc, const float* v)         { glUniformMatrix3x2fv(loc,1,false,v); }
-inline void glUniformMatrix2x4fv_ei(GLint loc, const float* v)         { glUniformMatrix2x4fv(loc,1,false,v); }
-inline void glUniformMatrix4x2fv_ei(GLint loc, const float* v)         { glUniformMatrix4x2fv(loc,1,false,v); }
-inline void glUniformMatrix3x4fv_ei(GLint loc, const float* v)         { glUniformMatrix3x4fv(loc,1,false,v); }
-inline void glUniformMatrix4x3fv_ei(GLint loc, const float* v)         { glUniformMatrix4x3fv(loc,1,false,v); }
-
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float,        2,3,Matrix2x3fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float,        3,2,Matrix3x2fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float,        2,4,Matrix2x4fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float,        4,2,Matrix4x2fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float,        3,4,Matrix3x4fv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float,        4,3,Matrix4x3fv_ei)
-
-#endif
-
-#ifdef GL_VERSION_3_0
-
-inline void glUniform2uiv_ei (GLint loc, const unsigned int* v)  { glUniform2uiv(loc,1,v); }
-inline void glUniform3uiv_ei (GLint loc, const unsigned int* v)  { glUniform3uiv(loc,1,v); }
-inline void glUniform4uiv_ei (GLint loc, const unsigned int* v)  { glUniform4uiv(loc,1,v); }
-
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,unsigned int, 2,2uiv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,unsigned int, 3,3uiv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,unsigned int, 4,4uiv_ei)
-
-#endif
-
-#ifdef GL_ARB_gpu_shader_fp64
-inline void glUniform2dv_ei  (GLint loc, const double* v)        { glUniform2dv(loc,1,v); }
-inline void glUniform3dv_ei  (GLint loc, const double* v)        { glUniform3dv(loc,1,v); }
-inline void glUniform4dv_ei  (GLint loc, const double* v)        { glUniform4dv(loc,1,v); }
-
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,double,       2,2dv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,double,       3,3dv_ei)
-EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,double,       4,4dv_ei)
-#endif
-
-
-//@}
-
-}
-
-#endif // EIGEN_OPENGL_MODULE

casadi/include/include/eigen3/unsupported/Eigen/Polynomials

@@ -1,137 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_POLYNOMIALS_MODULE_H
-#define EIGEN_POLYNOMIALS_MODULE_H
-
-#include "../../Eigen/Core"
-
-#include "../../Eigen/Eigenvalues"
-
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.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
-
-/**
-  * \defgroup Polynomials_Module Polynomials module
-  * \brief This module provides a QR based polynomial solver.
-	*
-  * To use this module, add
-  * \code
-  * #include <unsupported/Eigen/Polynomials>
-  * \endcode
-	* at the start of your source file.
-  */
-
-#include "src/Polynomials/PolynomialUtils.h"
-#include "src/Polynomials/Companion.h"
-#include "src/Polynomials/PolynomialSolver.h"
-
-/**
-	\page polynomials Polynomials defines functions for dealing with polynomials
-	and a QR based polynomial solver.
-	\ingroup Polynomials_Module
-
-	The remainder of the page documents first the functions for evaluating, computing
-	polynomials, computing estimates about polynomials and next the QR based polynomial
-	solver.
-
-	\section polynomialUtils convenient functions to deal with polynomials
-	\subsection roots_to_monicPolynomial
-	The function
-	\code
-	void roots_to_monicPolynomial( const RootVector& rv, Polynomial& poly )
-	\endcode
-	computes the coefficients \f$ a_i \f$ of
-
-	\f$ p(x) = a_0 + a_{1}x + ... + a_{n-1}x^{n-1} + x^n \f$
-
-	where \f$ p \f$ is known through its roots i.e. \f$ p(x) = (x-r_1)(x-r_2)...(x-r_n) \f$.
-
-	\subsection poly_eval
-	The function
-	\code
-	T poly_eval( const Polynomials& poly, const T& x )
-	\endcode
-	evaluates a polynomial at a given point using stabilized H&ouml;rner method.
-
-	The following code: first computes the coefficients in the monomial basis of the monic polynomial that has the provided roots;
-	then, it evaluates the computed polynomial, using a stabilized H&ouml;rner method.
-
-	\include PolynomialUtils1.cpp
-  Output: \verbinclude PolynomialUtils1.out
-
-	\subsection Cauchy bounds
-	The function
-	\code
-	Real cauchy_max_bound( const Polynomial& poly )
-	\endcode
-	provides a maximum bound (the Cauchy one: \f$C(p)\f$) for the absolute value of a root of the given polynomial i.e.
-	\f$ \forall r_i \f$ root of \f$ p(x) = \sum_{k=0}^d a_k x^k \f$,
-	\f$ |r_i| \le C(p) = \sum_{k=0}^{d} \left | \frac{a_k}{a_d} \right | \f$
-	The leading coefficient \f$ p \f$: should be non zero \f$a_d \neq 0\f$.
-
-
-	The function
-	\code
-	Real cauchy_min_bound( const Polynomial& poly )
-	\endcode
-	provides a minimum bound (the Cauchy one: \f$c(p)\f$) for the absolute value of a non zero root of the given polynomial i.e.
-	\f$ \forall r_i \neq 0 \f$ root of \f$ p(x) = \sum_{k=0}^d a_k x^k \f$,
-	\f$ |r_i| \ge c(p) = \left( \sum_{k=0}^{d} \left | \frac{a_k}{a_0} \right | \right)^{-1} \f$
-
-
-
-
-	\section QR polynomial solver class
-	Computes the complex roots of a polynomial by computing the eigenvalues of the associated companion matrix with the QR algorithm.
-	
-	The roots of \f$ p(x) = a_0 + a_1 x + a_2 x^2 + a_{3} x^3 + x^4 \f$ are the eigenvalues of
-	\f$
-	\left [
-	\begin{array}{cccc}
-	0 & 0 &  0 & a_0 \\
-	1 & 0 &  0 & a_1 \\
-	0 & 1 &  0 & a_2 \\
-	0 & 0 &  1 & a_3
-	\end{array} \right ]
-	\f$
-
-	However, the QR algorithm is not guaranteed to converge when there are several eigenvalues with same modulus.
-
-	Therefore the current polynomial solver is guaranteed to provide a correct result only when the complex roots \f$r_1,r_2,...,r_d\f$ have distinct moduli i.e.
-	
-	\f$ \forall i,j \in [1;d],~ \| r_i \| \neq \| r_j \| \f$.
-
-	With 32bit (float) floating types this problem shows up frequently.
-  However, almost always, correct accuracy is reached even in these cases for 64bit
-  (double) floating types and small polynomial degree (<20).
-
-	\include PolynomialSolver1.cpp
-	
-	In the above example:
-	
-	-# a simple use of the polynomial solver is shown;
-	-# the accuracy problem with the QR algorithm is presented: a polynomial with almost conjugate roots is provided to the solver.
-	Those roots have almost same module therefore the QR algorithm failed to converge: the accuracy
-	of the last root is bad;
-	-# a simple way to circumvent the problem is shown: use doubles instead of floats.
-
-  Output: \verbinclude PolynomialSolver1.out
-*/
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif // EIGEN_POLYNOMIALS_MODULE_H

casadi/include/include/eigen3/unsupported/Eigen/Skyline

@@ -1,39 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_SKYLINE_MODULE_H
-#define EIGEN_SKYLINE_MODULE_H
-
-
-#include "../../Eigen/Core"
-
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-#include <map>
-#include <cstdlib>
-#include <cstring>
-#include <algorithm>
-
-/**
- *  \defgroup Skyline_Module Skyline module
- *
- *
- *
- *
- */
-
-#include "src/Skyline/SkylineUtil.h"
-#include "src/Skyline/SkylineMatrixBase.h"
-#include "src/Skyline/SkylineStorage.h"
-#include "src/Skyline/SkylineMatrix.h"
-#include "src/Skyline/SkylineInplaceLU.h"
-#include "src/Skyline/SkylineProduct.h"
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif // EIGEN_SKYLINE_MODULE_H

casadi/include/include/eigen3/unsupported/Eigen/SparseExtra

@@ -1,54 +0,0 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra.
-//
-// Copyright (C) 2008-2009 Gael Guennebaud <g.gael@free.fr>
-//
-// This Source Code Form is subject to the terms of the Mozilla
-// Public License v. 2.0. If a copy of the MPL was not distributed
-// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-#ifndef EIGEN_SPARSE_EXTRA_MODULE_H
-#define EIGEN_SPARSE_EXTRA_MODULE_H
-
-#include "../../Eigen/Sparse"
-
-#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
-
-#include <vector>
-#include <map>
-#include <cstdlib>
-#include <cstring>
-#include <algorithm>
-#include <fstream>
-#include <sstream>
-
-#ifdef EIGEN_GOOGLEHASH_SUPPORT
-  #include <google/dense_hash_map>
-  #include <google/sparse_hash_map>
-#endif
-
-/**
-  * \defgroup SparseExtra_Module SparseExtra module
-  *
-  * This module contains some experimental features extending the sparse module.
-  *
-  * \code
-  * #include <Eigen/SparseExtra>
-  * \endcode
-  */
-
-
-#include "src/SparseExtra/DynamicSparseMatrix.h"
-#include "src/SparseExtra/BlockOfDynamicSparseMatrix.h"
-#include "src/SparseExtra/RandomSetter.h"
-
-#include "src/SparseExtra/MarketIO.h"
-
-#if !defined(_WIN32)
-#include <dirent.h>
-#include "src/SparseExtra/MatrixMarketIterator.h"
-#endif
-
-#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
-
-#endif // EIGEN_SPARSE_EXTRA_MODULE_H