casadi 3.6.3__cp35-none-win_amd64.whl → 3.6.5__cp35-none-win_amd64.whl

casadi/include/openblas/openblas_config.h

@@ -0,0 +1,140 @@
+#ifndef OPENBLAS_CONFIG_H
+#define OPENBLAS_CONFIG_H
+#define OPENBLAS_OS_WINNT	1
+#define OPENBLAS_ARCH_X86_64	1
+#define OPENBLAS_C_GCC	1
+#define OPENBLAS___64BIT__	1
+#define OPENBLAS_FUNDERSCORE	
+#define OPENBLAS_BUNDERSCORE _
+#define OPENBLAS_NEEDBUNDERSCORE 1
+#define OPENBLAS_NEED2UNDERSCORES 0
+#define OPENBLAS_CORE2
+#define OPENBLAS_CORE_CORE2
+#define OPENBLAS_CHAR_CORENAME "CORE2"
+#define OPENBLAS_L1_DATA_SIZE	32768
+#define OPENBLAS_L1_DATA_LINESIZE	64
+#define OPENBLAS_L2_SIZE	1048576
+#define OPENBLAS_L2_LINESIZE	64
+#define OPENBLAS_DTB_DEFAULT_ENTRIES	256
+#define OPENBLAS_DTB_SIZE	4096
+#define OPENBLAS_HAVE_CMOV
+#define OPENBLAS_HAVE_MMX
+#define OPENBLAS_HAVE_SSE
+#define OPENBLAS_HAVE_SSE2
+#define OPENBLAS_HAVE_SSE3
+#define OPENBLAS_HAVE_SSSE3
+#define OPENBLAS_SLOCAL_BUFFER_SIZE	16384
+#define OPENBLAS_DLOCAL_BUFFER_SIZE	16384
+#define OPENBLAS_CLOCAL_BUFFER_SIZE	16384
+#define OPENBLAS_ZLOCAL_BUFFER_SIZE	16384
+#define OPENBLAS_NUM_CORES	16
+#define OPENBLAS_GEMM_MULTITHREAD_THRESHOLD	4
+#define OPENBLAS_VERSION "OpenBLAS 0.3.21"
+/*This is only for "make install" target.*/
+
+#if defined(OPENBLAS_OS_WINNT) || defined(OPENBLAS_OS_CYGWIN_NT) || defined(OPENBLAS_OS_INTERIX)
+#define OPENBLAS_WINDOWS_ABI
+#define OPENBLAS_OS_WINDOWS
+
+#ifdef DOUBLE
+#define DOUBLE_DEFINED DOUBLE
+#undef  DOUBLE
+#endif
+#endif
+
+#ifdef OPENBLAS_NEEDBUNDERSCORE
+#define BLASFUNC(FUNC) FUNC##_
+#else
+#define BLASFUNC(FUNC) FUNC
+#endif
+
+#ifdef OPENBLAS_QUAD_PRECISION
+typedef struct {
+  unsigned long x[2];
+}  xdouble;
+#elif defined OPENBLAS_EXPRECISION
+#define xdouble long double
+#else
+#define xdouble double
+#endif
+
+#if defined(OPENBLAS_OS_WINDOWS) && defined(OPENBLAS___64BIT__)
+typedef long long BLASLONG;
+typedef unsigned long long BLASULONG;
+#else
+typedef long BLASLONG;
+typedef unsigned long BLASULONG;
+#endif
+
+#ifndef BFLOAT16
+#include <stdint.h>
+typedef uint16_t bfloat16;
+#endif
+
+#ifdef OPENBLAS_USE64BITINT
+typedef BLASLONG blasint;
+#else
+typedef int blasint;
+#endif
+
+#if defined(XDOUBLE) || defined(DOUBLE)
+#define FLOATRET	FLOAT
+#else
+#ifdef NEED_F2CCONV
+#define FLOATRET	double
+#else
+#define FLOATRET	float
+#endif
+#endif
+
+/* Inclusion of a standard header file is needed for definition of __STDC_*
+   predefined macros with some compilers (e.g. GCC 4.7 on Linux).  This occurs
+   as a side effect of including either <features.h> or <stdc-predef.h>. */
+#include <stdio.h>
+
+/* C99 supports complex floating numbers natively, which GCC also offers as an
+   extension since version 3.0.  If neither are available, use a compatible
+   structure as fallback (see Clause 6.2.5.13 of the C99 standard). */
+#if ((defined(__STDC_IEC_559_COMPLEX__) || __STDC_VERSION__ >= 199901L || \
+      (__GNUC__ >= 3 && !defined(__cplusplus))) && !(defined(FORCE_OPENBLAS_COMPLEX_STRUCT))) && !defined(_MSC_VER)
+  #define OPENBLAS_COMPLEX_C99
+#ifndef __cplusplus
+  #include <complex.h>
+#endif
+  typedef float _Complex openblas_complex_float;
+  typedef double _Complex openblas_complex_double;
+  typedef xdouble _Complex openblas_complex_xdouble;
+  #define openblas_make_complex_float(real, imag)    ((real) + ((imag) * _Complex_I))
+  #define openblas_make_complex_double(real, imag)   ((real) + ((imag) * _Complex_I))
+  #define openblas_make_complex_xdouble(real, imag)  ((real) + ((imag) * _Complex_I))
+  #define openblas_complex_float_real(z)             (creal(z))
+  #define openblas_complex_float_imag(z)             (cimag(z))
+  #define openblas_complex_double_real(z)            (creal(z))
+  #define openblas_complex_double_imag(z)            (cimag(z))
+  #define openblas_complex_xdouble_real(z)           (creal(z))
+  #define openblas_complex_xdouble_imag(z)           (cimag(z))
+#else
+  #define OPENBLAS_COMPLEX_STRUCT
+  typedef struct { float real, imag; } openblas_complex_float;
+  typedef struct { double real, imag; } openblas_complex_double;
+  typedef struct { xdouble real, imag; } openblas_complex_xdouble;
+  #define openblas_make_complex_float(real, imag)    {(real), (imag)}
+  #define openblas_make_complex_double(real, imag)   {(real), (imag)}
+  #define openblas_make_complex_xdouble(real, imag)  {(real), (imag)}
+  #define openblas_complex_float_real(z)             ((z).real)
+  #define openblas_complex_float_imag(z)             ((z).imag)
+  #define openblas_complex_double_real(z)            ((z).real)
+  #define openblas_complex_double_imag(z)            ((z).imag)
+  #define openblas_complex_xdouble_real(z)           ((z).real)
+  #define openblas_complex_xdouble_imag(z)           ((z).imag)
+#endif
+
+/* Inclusion of Linux-specific header is needed for definition of cpu_set_t. */
+#ifdef OPENBLAS_OS_LINUX
+#ifndef _GNU_SOURCE
+ #define _GNU_SOURCE
+#endif
+#include <sched.h>
+#endif
+
+#endif /* OPENBLAS_CONFIG_H */

casadi/include/qdldl/qdldl.h

@@ -0,0 +1,169 @@
+#ifndef QDLDL_H
+#define QDLDL_H
+
+// Include qdldl type options
+#include "qdldl_types.h"
+
+# ifdef __cplusplus
+extern "C" {
+# endif // ifdef __cplusplus
+
+/**
+  * Compute the elimination tree for a quasidefinite matrix
+  * in compressed sparse column form, where the input matrix is
+  * assumed to contain data for the upper triangular part of A only,
+  * and there are no duplicate indices.
+  *
+  * Returns an elimination tree for the factorization A = LDL^T and a
+  * count of the nonzeros in each column of L that are strictly below the
+  * diagonal.
+  *
+  * Does not use MALLOC.  It is assumed that the arrays work, Lnz, and
+  * etree will be allocated with a number of elements equal to n.
+  *
+  * The data in (n,Ap,Ai) are from a square matrix A in CSC format, and
+  * should include the upper triangular part of A only.
+  *
+  * This function is only intended for factorisation of QD matrices specified
+  * by their upper triangular part.  An error is returned if any column has
+  * data below the diagonal or s completely empty.
+  *
+  * For matrices with a non-empty column but a zero on the corresponding diagonal,
+  * this function will *not* return an error, as it may still be possible to factor
+  * such a matrix in LDL form.   No promises are made in this case though...
+  *
+  * @param  n      number of columns in CSC matrix A (assumed square)
+  * @param  Ap     column pointers (size n+1) for columns of A
+  * @param  Ai     row indices of A.  Has Ap[n] elements
+  * @param  work   work vector (size n) (no meaning on return)
+  * @param  Lnz    count of nonzeros in each column of L (size n) below diagonal
+  * @param  etree  elimination tree (size n)
+  * @return total  sum of Lnz (i.e. total nonzeros in L below diagonal).
+  *                Returns -1 if the input is not triu or has an empty column.
+  *                Returns -2 if the return value overflows QDLDL_int.
+  *
+*/
+ QDLDL_int QDLDL_etree(const QDLDL_int   n,
+                       const QDLDL_int* Ap,
+                       const QDLDL_int* Ai,
+                       QDLDL_int* work,
+                       QDLDL_int* Lnz,
+                       QDLDL_int* etree);
+
+
+/**
+  * Compute an LDL decomposition for a quasidefinite matrix
+  * in compressed sparse column form, where the input matrix is
+  * assumed to contain data for the upper triangular part of A only,
+  * and there are no duplicate indices.
+  *
+  * Returns factors L, D and Dinv = 1./D.
+  *
+  * Does not use MALLOC.  It is assumed that L will be a compressed
+  * sparse column matrix with data (n,Lp,Li,Lx)  with sufficient space
+  * allocated, with a number of nonzeros equal to the count given
+  * as a return value by QDLDL_etree
+  *
+  * @param  n      number of columns in L and A (both square)
+  * @param  Ap     column pointers (size n+1) for columns of A (not modified)
+  * @param  Ai     row indices of A.  Has Ap[n] elements (not modified)
+  * @param  Ax     data of A.  Has Ap[n] elements (not modified)
+  * @param  Lp     column pointers (size n+1) for columns of L
+  * @param  Li     row indices of L.  Has Lp[n] elements
+  * @param  Lx     data of L.  Has Lp[n] elements
+  * @param  D      vectorized factor D.  Length is n
+  * @param  Dinv   reciprocal of D.  Length is n
+  * @param  Lnz    count of nonzeros in each column of L below diagonal,
+  *                as given by QDLDL_etree (not modified)
+  * @param  etree  elimination tree as as given by QDLDL_etree (not modified)
+  * @param  bwork  working array of bools. Length is n
+  * @param  iwork  working array of integers. Length is 3*n
+  * @param  fwork  working array of floats. Length is n
+  * @return        Returns a count of the number of positive elements
+  *                in D.  Returns -1 and exits immediately if any element
+  *                of D evaluates exactly to zero (matrix is not quasidefinite
+  *                or otherwise LDL factorisable)
+  *
+*/
+QDLDL_int QDLDL_factor(const QDLDL_int    n,
+                  const QDLDL_int*   Ap,
+                  const QDLDL_int*   Ai,
+                  const QDLDL_float* Ax,
+                  QDLDL_int*   Lp,
+                  QDLDL_int*   Li,
+                  QDLDL_float* Lx,
+                  QDLDL_float* D,
+                  QDLDL_float* Dinv,
+                  const QDLDL_int* Lnz,
+                  const QDLDL_int* etree,
+                  QDLDL_bool* bwork,
+                  QDLDL_int* iwork,
+                  QDLDL_float* fwork);
+
+
+/**
+  * Solves LDL'x = b
+  *
+  * It is assumed that L will be a compressed
+  * sparse column matrix with data (n,Lp,Li,Lx).
+  *
+  * @param  n      number of columns in L
+  * @param  Lp     column pointers (size n+1) for columns of L
+  * @param  Li     row indices of L.  Has Lp[n] elements
+  * @param  Lx     data of L.  Has Lp[n] elements
+  * @param  Dinv   reciprocal of D.  Length is n
+  * @param  x      initialized to b.  Equal to x on return
+  *
+*/
+void QDLDL_solve(const QDLDL_int    n,
+                 const QDLDL_int*   Lp,
+                 const QDLDL_int*   Li,
+                 const QDLDL_float* Lx,
+                 const QDLDL_float* Dinv,
+                 QDLDL_float* x);
+
+
+/**
+ * Solves (L+I)x = b
+ *
+ * It is assumed that L will be a compressed
+ * sparse column matrix with data (n,Lp,Li,Lx).
+ *
+ * @param  n      number of columns in L
+ * @param  Lp     column pointers (size n+1) for columns of L
+ * @param  Li     row indices of L.  Has Lp[n] elements
+ * @param  Lx     data of L.  Has Lp[n] elements
+ * @param  x      initialized to b.  Equal to x on return
+ *
+*/
+void QDLDL_Lsolve(const QDLDL_int    n,
+                  const QDLDL_int*   Lp,
+                  const QDLDL_int*   Li,
+                  const QDLDL_float* Lx,
+                  QDLDL_float* x);
+
+
+/**
+ * Solves (L+I)'x = b
+ *
+ * It is assumed that L will be a compressed
+ * sparse column matrix with data (n,Lp,Li,Lx).
+ *
+ * @param  n      number of columns in L
+ * @param  Lp     column pointers (size n+1) for columns of L
+ * @param  Li     row indices of L.  Has Lp[n] elements
+ * @param  Lx     data of L.  Has Lp[n] elements
+ * @param  x      initialized to b.  Equal to x on return
+ *
+*/
+void QDLDL_Ltsolve(const QDLDL_int    n,
+                   const QDLDL_int*   Lp,
+                   const QDLDL_int*   Li,
+                   const QDLDL_float* Lx,
+                   QDLDL_float* x);
+
+# ifdef __cplusplus
+}
+# endif // ifdef __cplusplus
+
+#endif // ifndef QDLDL_H

casadi/include/qdldl/qdldl_types.h

@@ -0,0 +1,23 @@
+#ifndef QDLDL_TYPES_H
+# define QDLDL_TYPES_H
+
+# ifdef __cplusplus
+extern "C" {
+# endif /* ifdef __cplusplus */
+
+#include <limits.h> //for the QDLDL_INT_TYPE_MAX
+
+// QDLDL integer and float types
+
+typedef long long    QDLDL_int;   /* for indices */
+typedef double  QDLDL_float; /* for numerical values  */
+typedef unsigned char   QDLDL_bool;  /* for boolean values  */
+
+//Maximum value of the signed type QDLDL_int.
+#define QDLDL_INT_MAX LLONG_MAX
+
+# ifdef __cplusplus
+}
+# endif /* ifdef __cplusplus */
+
+#endif /* ifndef QDLDL_TYPES_H */

casadi/include/s_blas.h

@@ -0,0 +1,78 @@
+/**************************************************************************************************
+*                                                                                                 *
+* This file is part of BLASFEO.                                                                   *
+*                                                                                                 *
+* BLASFEO -- BLAS For Embedded Optimization.                                                      *
+* Copyright (C) 2019 by Gianluca Frison.                                                          *
+* Developed at IMTEK (University of Freiburg) under the supervision of Moritz Diehl.              *
+* All rights reserved.                                                                            *
+*                                                                                                 *
+* The 2-Clause BSD License                                                                        *
+*                                                                                                 *
+* Redistribution and use in source and binary forms, with or without                              *
+* modification, are permitted provided that the following conditions are met:                     *
+*                                                                                                 *
+* 1. Redistributions of source code must retain the above copyright notice, this                  *
+*    list of conditions and the following disclaimer.                                             *
+* 2. Redistributions in binary form must reproduce the above copyright notice,                    *
+*    this list of conditions and the following disclaimer in the documentation                    *
+*    and/or other materials provided with the distribution.                                       *
+*                                                                                                 *
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND                 *
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED                   *
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE                          *
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR                 *
+* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES                  *
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;                    *
+* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND                     *
+* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT                      *
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS                   *
+* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                                    *
+*                                                                                                 *
+* Author: Gianluca Frison, gianluca.frison (at) imtek.uni-freiburg.de                             *
+*                                                                                                 *
+**************************************************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+// headers to reference BLAS and LAPACK routines employed in BLASFEO WR
+
+// level 1
+float sdot_(int *m, float *x, int *incx, float *y, int *incy);
+void scopy_(int *m, float *x, int *incx, float *y, int *incy);
+void saxpy_(int *m, float *alpha, float *x, int *incx, float *y, int *incy);
+void sscal_(int *m, float *alpha, float *x, int *incx);
+void srot_(int *m, float *x, int *incx, float *y, int *incy, float *c, float *s);
+void srotg_(float *a, float *b, float *c, float *s);
+
+// level 2
+void sgemv_(char *ta, int *m, int *n, float *alpha, float *A, int *lda, float *x, int *incx, float *beta, float *y, int *incy);
+void ssymv_(char *uplo, int *m, float *alpha, float *A, int *lda, float *x, int *incx, float *beta, float *y, int *incy);
+void strmv_(char *uplo, char *trans, char *diag, int *n, float *A, int *lda, float *x, int *incx);
+void strsv_(char *uplo, char *trans, char *diag, int *n, float *A, int *lda, float *x, int *incx);
+void sger_(int *m, int *n, float *alpha, float *x, int *incx, float *y, int *incy, float *A, int *lda);
+
+// level 3
+void sgemm_(char *ta, char *tb, int *m, int *n, int *k, float *alpha, float *A, int *lda, float *B, int *ldb, float *beta, float *C, int *ldc);
+void ssyrk_(char *uplo, char *trans, int *n, int *k, float *alpha, float *A, int *lda, float *beta, float *C, int *ldc);
+void strmm_(char *side, char *uplo, char *transa, char *diag, int *m, int *n, float *alpha, float *A, int *lda, float *B, int *ldb);
+void strsm_(char *side, char *uplo, char *transa, char *diag, int *m, int *n, float *alpha, float *A, int *lda, float *B, int *ldb);
+void ssyr2k_(char *uplo, char *trans, int *n, int *k, float *alpha, float *A, int *lda, float *B, int *ldb, float *beta, float *C, int *ldc);
+
+// lapack
+void spotrf_(char *uplo, int *m, float *A, int *lda, int *info);
+void sgetrf_(int *m, int *n, float *A, int *lda, int *ipiv, int *info);
+void sgeqrf_(int *m, int *n, float *A, int *lda, float *tau, float *work, int *lwork, int *info);
+void sgeqr2_(int *m, int *n, float *A, int *lda, float *tau, float *work, int *info);
+void sgelqf_(int *m, int *n, float *A, int *lda, float *tau, float *work, int *lwork, int *info);
+void sorglq_(int *m, int *n, int *k, float *A, int *lda, float *tau, float *work, int *lwork, int *info);
+
+
+
+#ifdef __cplusplus
+}
+#endif

casadi/include/s_blas_64.h

@@ -0,0 +1,73 @@
+/**************************************************************************************************
+*                                                                                                 *
+* This file is part of BLASFEO.                                                                   *
+*                                                                                                 *
+* BLASFEO -- BLAS For Embedded Optimization.                                                      *
+* Copyright (C) 2019 by Gianluca Frison.                                                          *
+* Developed at IMTEK (University of Freiburg) under the supervision of Moritz Diehl.              *
+* All rights reserved.                                                                            *
+*                                                                                                 *
+* The 2-Clause BSD License                                                                        *
+*                                                                                                 *
+* Redistribution and use in source and binary forms, with or without                              *
+* modification, are permitted provided that the following conditions are met:                     *
+*                                                                                                 *
+* 1. Redistributions of source code must retain the above copyright notice, this                  *
+*    list of conditions and the following disclaimer.                                             *
+* 2. Redistributions in binary form must reproduce the above copyright notice,                    *
+*    this list of conditions and the following disclaimer in the documentation                    *
+*    and/or other materials provided with the distribution.                                       *
+*                                                                                                 *
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND                 *
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED                   *
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE                          *
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR                 *
+* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES                  *
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;                    *
+* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND                     *
+* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT                      *
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS                   *
+* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                                    *
+*                                                                                                 *
+* Author: Gianluca Frison, gianluca.frison (at) imtek.uni-freiburg.de                             *
+*                                                                                                 *
+**************************************************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+// headers to reference BLAS and LAPACK routines employed in BLASFEO WR
+
+// level 1
+float sdot_(long long *m, float *x, long long *incx, float *y, long long *incy);
+void scopy_(long long *m, float *x, long long *incx, float *y, long long *incy);
+void saxpy_(long long *m, float *alpha, float *x, long long *incx, float *y, long long *incy);
+void sscal_(long long *m, float *alpha, float *x, long long *incx);
+
+// level 2
+void sgemv_(char *ta, long long *m, long long *n, float *alpha, float *A, long long *lda, float *x, long long *incx, float *beta, float *y, long long *incy);
+void ssymv_(char *uplo, long long *m, float *alpha, float *A, long long *lda, float *x, long long *incx, float *beta, float *y, long long *incy);
+void strmv_(char *uplo, char *trans, char *diag, long long *n, float *A, long long *lda, float *x, long long *incx);
+void strsv_(char *uplo, char *trans, char *diag, long long *n, float *A, long long *lda, float *x, long long *incx);
+void sger_(long long *m, long long *n, float *alpha, float *x, long long *incx, float *y, long long *incy, float *A, long long *lda);
+
+// level 3
+void sgemm_(char *ta, char *tb, long long *m, long long *n, long long *k, float *alpha, float *A, long long *lda, float *B, long long *ldb, float *beta, float *C, long long *ldc);
+void ssyrk_(char *uplo, char *trans, long long *n, long long *k, float *alpha, float *A, long long *lda, float *beta, float *C, long long *ldc);
+void strmm_(char *side, char *uplo, char *transa, char *diag, long long *m, long long *n, float *alpha, float *A, long long *lda, float *B, long long *ldb);
+void strsm_(char *side, char *uplo, char *transa, char *diag, long long *m, long long *n, float *alpha, float *A, long long *lda, float *B, long long *ldb);
+
+// lapack
+void spotrf_(char *uplo, long long *m, float *A, long long *lda, long long *info);
+void sgetrf_(long long *m, long long *n, float *A, long long *lda, long long *ipiv, long long *info);
+void sgeqrf_(long long *m, long long *n, float *A, long long *lda, float *tau, float *work, long long *lwork, long long *info);
+void sgeqr2_(long long *m, long long *n, float *A, long long *lda, float *tau, float *work, long long *info);
+
+
+
+#ifdef __cplusplus
+}
+#endif

casadi/include/sleqp/defs.h

@@ -0,0 +1,58 @@
+#ifndef SLEQP_DEFS_H
+#define SLEQP_DEFS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  typedef enum
+  {
+    SLEQP_SOLVER_GUROBI, SLEQP_SOLVER_HIGHS, SLEQP_SOLVER_SOPLEX
+  } SLEQP_LP_SOLVERS;
+
+#define SLEQP_VERSION "1.0.1"
+
+/* #undef SLEQP_DEBUG */
+#define SLEQP_FORMAT_CODES
+/* #undef SLEQP_ENABLE_NUM_ASSERTS */
+#define SLEQP_HAVE_ATTRIBUTE_WARN_UNUSED_RESULT
+#define SLEQP_HAVE_ATTRIBUTE_NODISCARD
+#define SLEQP_HAVE_ATTRIBUTE_FORMAT
+/* #undef SLEQP_HAVE_QR_FACT */
+
+#ifdef SLEQP_HAVE_ATTRIBUTE_FORMAT
+#define SLEQP_FORMAT_PRINTF(index, first)                                      \
+  __attribute__((__format__(__printf__, index, first)))
+#else
+#define SLEQP_FORMAT_PRINTF(index, first)
+#endif
+
+#define SLEQP_VERSION_MAJOR 1
+#define SLEQP_VERSION_MINOR 0
+#define SLEQP_VERSION_PATCH 1
+
+#define SLEQP_TRLIB_VERSION "0.4"
+
+#define SLEQP_GIT_BRANCH "HEAD"
+#define SLEQP_GIT_COMMIT_HASH "e9a4553"
+
+#define SLEQP_LONG_VERSION "1.0.1 [HEAD-e9a4553]"
+
+#define SLEQP_LP_SOLVER SLEQP_LP_SOLVER_HIGHS
+#define SLEQP_LP_SOLVER_NAME "HiGHS"
+#define SLEQP_LP_SOLVER_VERSION "1.6.0"
+
+#define SLEQP_LP_SOLVER_HIGHS_NAME "HiGHS"
+#define SLEQP_LP_SOLVER_HIGHS_VERSION "1.6.0"
+
+#define SLEQP_FACT_NAME "MUMPS"
+#define SLEQP_FACT_VERSION "5.4.1"
+
+#define SLEQP_FACT_MUMPS_NAME "MUMPS"
+#define SLEQP_FACT_MUMPS_VERSION "5.4.1"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SLEQP_DEFS_H */

casadi/include/sleqp/export.h

@@ -0,0 +1,42 @@
+
+#ifndef SLEQP_EXPORT_H
+#define SLEQP_EXPORT_H
+
+#ifdef SLEQP_STATIC_DEFINE
+#  define SLEQP_EXPORT
+#  define SLEQP_NO_EXPORT
+#else
+#  ifndef SLEQP_EXPORT
+#    ifdef sleqp_EXPORTS
+        /* We are building this library */
+#      define SLEQP_EXPORT __declspec(dllexport)
+#    else
+        /* We are using this library */
+#      define SLEQP_EXPORT __declspec(dllimport)
+#    endif
+#  endif
+
+#  ifndef SLEQP_NO_EXPORT
+#    define SLEQP_NO_EXPORT 
+#  endif
+#endif
+
+#ifndef SLEQP_DEPRECATED
+#  define SLEQP_DEPRECATED __attribute__ ((__deprecated__))
+#endif
+
+#ifndef SLEQP_DEPRECATED_EXPORT
+#  define SLEQP_DEPRECATED_EXPORT SLEQP_EXPORT SLEQP_DEPRECATED
+#endif
+
+#ifndef SLEQP_DEPRECATED_NO_EXPORT
+#  define SLEQP_DEPRECATED_NO_EXPORT SLEQP_NO_EXPORT SLEQP_DEPRECATED
+#endif
+
+#if 0 /* DEFINE_NO_DEPRECATED */
+#  ifndef SLEQP_NO_DEPRECATED
+#    define SLEQP_NO_DEPRECATED
+#  endif
+#endif
+
+#endif /* SLEQP_EXPORT_H */

casadi/include/sleqp/pub_cmp.h

@@ -0,0 +1,18 @@
+#ifndef SLEQP_PUB_CMP_H
+#define SLEQP_PUB_CMP_H
+
+/**
+ * @file pub_cmp.h
+ * @brief Definition of numerical comparison functions.
+ **/
+
+#include "sleqp/export.h"
+#include "sleqp/pub_types.h"
+
+SLEQP_EXPORT double
+sleqp_infinity();
+
+SLEQP_EXPORT bool
+sleqp_is_finite(double value);
+
+#endif /* SLEQP_PUB_CMP_H */