casadi 3.6.4__cp35-none-manylinux2010_x86_64.whl → 3.6.6__cp35-none-manylinux2010_x86_64.whl

casadi/include/include/osqp/glob_opts.h

@@ -1,167 +0,0 @@
-#ifndef GLOB_OPTS_H
-# define GLOB_OPTS_H
-
-# ifdef __cplusplus
-extern "C" {
-# endif /* ifdef __cplusplus */
-
-/*
-   Define OSQP compiler flags
- */
-
-// cmake generated compiler flags
-#include "osqp_configure.h"
-
-/* DATA CUSTOMIZATIONS (depending on memory manager)-----------------------   */
-
-// We do not need memory allocation functions if EMBEDDED is enabled
-# ifndef EMBEDDED
-
-/* define custom printfs and memory allocation (e.g. matlab/python) */
-#  ifdef MATLAB
-    #   include "mex.h"
-static void* c_calloc(size_t num, size_t size) {
-  void *m = mxCalloc(num, size);
-  mexMakeMemoryPersistent(m);
-  return m;
-}
-
-static void* c_malloc(size_t size) {
-  void *m = mxMalloc(size);
-  mexMakeMemoryPersistent(m);
-  return m;
-}
-
-static void* c_realloc(void *ptr, size_t size) {
-  void *m = mxRealloc(ptr, size);
-  mexMakeMemoryPersistent(m);
-  return m;
-}
-    #   define c_free mxFree
-#  elif defined PYTHON
-// Define memory allocation for python. Note that in Python 2 memory manager
-// Calloc is not implemented
-#   include <Python.h>
-#   if PY_MAJOR_VERSION >= 3
-// https://docs.python.org/3/c-api/memory.html
-// The following function sets are wrappers to the system allocator. These functions are thread-safe, the GIL does not need to be held.
-// The default raw memory allocator uses the following functions: malloc(), calloc(), realloc() and free(); call malloc(1) (or calloc(1, 1)) when requesting zero bytes.
-#    define c_malloc PyMem_RawMalloc
-#    define c_calloc PyMem_RawCalloc
-#    define c_free PyMem_RawFree
-#    define c_realloc PyMem_RawRealloc
-#   else  /* if PY_MAJOR_VERSION >= 3 */
-#   define c_malloc PyMem_Malloc
-#   define c_free PyMem_Free
-#   define c_realloc PyMem_Realloc
-static void* c_calloc(size_t num, size_t size) {
-	void *m = PyMem_Malloc(num * size);
-	memset(m, 0, num * size);
-	return m;
-}
-#   endif /* if PY_MAJOR_VERSION >= 3 */
-
-# elif !defined OSQP_CUSTOM_MEMORY
-/* If no custom memory allocator defined, use
- * standard linux functions. Custom memory allocator definitions
- * appear in the osqp_configure.h generated file. */
-    #  include <stdlib.h>
-    #  define c_malloc  malloc
-    #  define c_calloc  calloc
-    #  define c_free    free
-    #  define c_realloc realloc
-#  endif /* ifdef MATLAB */
-
-# endif // end ifndef EMBEDDED
-
-
-/* Use customized number representation -----------------------------------   */
-# ifdef DLONG            // long integers
-typedef long long c_int; /* for indices */
-# else // standard integers
-typedef int c_int;       /* for indices */
-# endif /* ifdef DLONG */
-
-
-# ifndef DFLOAT         // Doubles
-typedef double c_float; /* for numerical values  */
-# else                  // Floats
-typedef float c_float;  /* for numerical values  */
-# endif /* ifndef DFLOAT */
-
-
-/* Use customized operations */
-
-# ifndef c_absval
-#  define c_absval(x) (((x) < 0) ? -(x) : (x))
-# endif /* ifndef c_absval */
-
-# ifndef c_max
-#  define c_max(a, b) (((a) > (b)) ? (a) : (b))
-# endif /* ifndef c_max */
-
-# ifndef c_min
-#  define c_min(a, b) (((a) < (b)) ? (a) : (b))
-# endif /* ifndef c_min */
-
-// Round x to the nearest multiple of N
-# ifndef c_roundmultiple
-#  define c_roundmultiple(x, N) ((x) + .5 * (N)-c_fmod((x) + .5 * (N), (N)))
-# endif /* ifndef c_roundmultiple */
-
-
-/* Use customized functions -----------------------------------------------   */
-
-# if EMBEDDED != 1
-
-#  include <math.h>
-#  ifndef DFLOAT // Doubles
-#   define c_sqrt sqrt
-#   define c_fmod fmod
-#  else          // Floats
-#   define c_sqrt sqrtf
-#   define c_fmod fmodf
-#  endif /* ifndef DFLOAT */
-
-# endif // end EMBEDDED
-
-# ifdef PRINTING
-#  include <stdio.h>
-#  include <string.h>
-
-/* informational print function */
-#  ifdef MATLAB
-#   define c_print mexPrintf
-#  elif defined PYTHON
-#   include <Python.h>
-# define c_print(...)                              \
-  {                                                  \
-    PyGILState_STATE gilstate = PyGILState_Ensure(); \
-    PySys_WriteStdout(__VA_ARGS__);                  \
-    PyGILState_Release(gilstate);                    \
-  }
-#  elif defined R_LANG
-#   include <R_ext/Print.h>
-#   define c_print Rprintf
-#  else  /* ifdef MATLAB */
-#   define c_print printf
-#  endif /* c_print configuration */
-
-/* error printing function */
-#  ifdef R_LANG
-    /* Some CRAN builds complain about __VA_ARGS__, so just print */
-    /* out the error messages on R without the __FUNCTION__ trace */
-#   define c_eprint Rprintf
-#  else
-#   define c_eprint(...) c_print("ERROR in %s: ", __FUNCTION__); \
-            c_print(__VA_ARGS__); c_print("\n");
-#  endif /* c_eprint configuration */
-
-# endif  /* PRINTING */
-
-
-# ifdef __cplusplus
-}
-# endif /* ifdef __cplusplus */
-
-#endif /* ifndef GLOB_OPTS_H */

casadi/include/include/osqp/lin_alg.h

@@ -1,216 +0,0 @@
-#ifndef LIN_ALG_H
-# define LIN_ALG_H
-
-
-# ifdef __cplusplus
-extern "C" {
-# endif // ifdef __cplusplus
-
-# include "types.h"
-
-
-/* VECTOR FUNCTIONS ----------------------------------------------------------*/
-
-# ifndef EMBEDDED
-
-/* copy vector a into output (Uses MALLOC)*/
-c_float* vec_copy(c_float *a,
-                  c_int    n);
-# endif // ifndef EMBEDDED
-
-/* copy vector a into preallocated vector b */
-void prea_vec_copy(const c_float *a,
-                   c_float       *b,
-                   c_int          n);
-
-/* copy integer vector a into preallocated vector b */
-void prea_int_vec_copy(const c_int *a,
-                       c_int       *b,
-                       c_int        n);
-
-/* set float vector to scalar */
-void vec_set_scalar(c_float *a,
-                    c_float  sc,
-                    c_int    n);
-
-/* set integer vector to scalar */
-void int_vec_set_scalar(c_int *a,
-                        c_int  sc,
-                        c_int  n);
-
-/* add scalar to vector*/
-void vec_add_scalar(c_float *a,
-                    c_float  sc,
-                    c_int    n);
-
-/* multiply scalar to vector */
-void vec_mult_scalar(c_float *a,
-                     c_float  sc,
-                     c_int    n);
-
-/* c = a + sc*b */
-void vec_add_scaled(c_float       *c,
-                    const c_float *a,
-                    const c_float *b,
-                    c_int          n,
-                    c_float        sc);
-
-/* ||v||_inf */
-c_float vec_norm_inf(const c_float *v,
-                     c_int          l);
-
-/* ||Sv||_inf */
-c_float vec_scaled_norm_inf(const c_float *S,
-                            const c_float *v,
-                            c_int          l);
-
-/* ||a - b||_inf */
-c_float vec_norm_inf_diff(const c_float *a,
-                          const c_float *b,
-                          c_int          l);
-
-/* mean of vector elements */
-c_float vec_mean(const c_float *a,
-                 c_int          n);
-
-# if EMBEDDED != 1
-
-/* Vector elementwise reciprocal b = 1./a (needed for scaling)*/
-void vec_ew_recipr(const c_float *a,
-                   c_float       *b,
-                   c_int          n);
-# endif // if EMBEDDED != 1
-
-/* Inner product a'b */
-c_float vec_prod(const c_float *a,
-                 const c_float *b,
-                 c_int          n);
-
-/* Elementwise product a.*b stored in c*/
-void vec_ew_prod(const c_float *a,
-                 const c_float *b,
-                 c_float       *c,
-                 c_int          n);
-
-# if EMBEDDED != 1
-
-/* Elementwise sqrt of the vector elements */
-void vec_ew_sqrt(c_float *a,
-                 c_int    n);
-
-/* Elementwise max between each vector component and max_val */
-void vec_ew_max(c_float *a,
-                c_int    n,
-                c_float  max_val);
-
-/* Elementwise min between each vector component and max_val */
-void vec_ew_min(c_float *a,
-                c_int    n,
-                c_float  min_val);
-
-/* Elementwise maximum between vectors c = max(a, b) */
-void vec_ew_max_vec(const c_float *a,
-                    const c_float *b,
-                    c_float       *c,
-                    c_int          n);
-
-/* Elementwise minimum between vectors c = min(a, b) */
-void vec_ew_min_vec(const c_float *a,
-                    const c_float *b,
-                    c_float       *c,
-                    c_int          n);
-
-# endif // if EMBEDDED != 1
-
-
-/* MATRIX FUNCTIONS ----------------------------------------------------------*/
-
-/* multiply scalar to matrix */
-void mat_mult_scalar(csc    *A,
-                     c_float sc);
-
-/* Premultiply matrix A by diagonal matrix with diagonal d,
-   i.e. scale the rows of A by d
- */
-void mat_premult_diag(csc           *A,
-                      const c_float *d);
-
-/* Premultiply matrix A by diagonal matrix with diagonal d,
-   i.e. scale the columns of A by d
- */
-void mat_postmult_diag(csc           *A,
-                       const c_float *d);
-
-
-/* Matrix-vector multiplication
- *    y  =  A*x  (if plus_eq == 0)
- *    y +=  A*x  (if plus_eq == 1)
- *    y -=  A*x  (if plus_eq == -1)
- */
-void mat_vec(const csc     *A,
-             const c_float *x,
-             c_float       *y,
-             c_int          plus_eq);
-
-
-/* Matrix-transpose-vector multiplication
- *    y  =  A'*x  (if plus_eq == 0)
- *    y +=  A'*x  (if plus_eq == 1)
- *    y -=  A'*x  (if plus_eq == -1)
- * If skip_diag == 1, then diagonal elements of A are assumed to be zero.
- */
-void mat_tpose_vec(const csc     *A,
-                   const c_float *x,
-                   c_float       *y,
-                   c_int          plus_eq,
-                   c_int          skip_diag);
-
-
-# if EMBEDDED != 1
-
-/**
- * Infinity norm of each matrix column
- * @param M	Input matrix
- * @param E     Vector of infinity norms
- *
- */
-void mat_inf_norm_cols(const csc *M,
-                       c_float   *E);
-
-/**
- * Infinity norm of each matrix row
- * @param M	Input matrix
- * @param E     Vector of infinity norms
- *
- */
-void mat_inf_norm_rows(const csc *M,
-                       c_float   *E);
-
-/**
- * Infinity norm of each matrix column
- * Matrix M is symmetric upper-triangular
- *
- * @param M	Input matrix (symmetric, upper-triangular)
- * @param E     Vector of infinity norms
- *
- */
-void mat_inf_norm_cols_sym_triu(const csc *M,
-                                c_float   *E);
-
-# endif // EMBEDDED != 1
-
-/**
- * Compute quadratic form f(x) = 1/2 x' P x
- * @param  P quadratic matrix in CSC form (only upper triangular)
- * @param  x argument float vector
- * @return   quadratic form value
- */
-c_float quad_form(const csc     *P,
-                  const c_float *x);
-
-
-# ifdef __cplusplus
-}
-# endif // ifdef __cplusplus
-
-#endif // ifndef LIN_ALG_H

casadi/include/include/osqp/lin_sys.h

@@ -1,54 +0,0 @@
-#ifndef LIN_SYS_H
-# define LIN_SYS_H
-
-/* KKT linear system definition and solution */
-
-# ifdef __cplusplus
-extern "C" {
-# endif // ifdef __cplusplus
-
-# include "types.h"
-
-/**
- * Load linear system solver shared library
- * @param	linsys_solver  Linear system solver
- * @return Zero on success, nonzero on failure.
- */
-c_int load_linsys_solver(enum linsys_solver_type linsys_solver);
-
-
-/**
- * Unload linear system solver shared library
- * @param	linsys_solver  Linear system solver
- * @return Zero on success, nonzero on failure.
- */
-c_int unload_linsys_solver(enum linsys_solver_type linsys_solver);
-
-
-// NB: Only the upper triangular part of P is stuffed!
-
-/**
- * Initialize linear system solver structure
- * @param   s             Pointer to linear system solver structure
- * @param   P             Cost function matrix
- * @param	A             Constraint matrix
- * @param	sigma         Algorithm parameter
- * @param	rho_vec       Algorithm parameter
- * @param	linsys_solver Linear system solver
- * @param	polish        0/1 depending whether we are allocating for
- *polishing or not
- * @return                Exitflag for error (0 if no errors)
- */
-c_int init_linsys_solver(LinSysSolver          **s,
-                         const csc              *P,
-                         const csc              *A,
-                         c_float                 sigma,
-                         const c_float          *rho_vec,
-                         enum linsys_solver_type linsys_solver,
-                         c_int                   polish);
-
-# ifdef __cplusplus
-}
-# endif // ifdef __cplusplus
-
-#endif // ifndef LIN_SYS_H