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

casadi/include/include/osqp/types.h

@@ -1,326 +0,0 @@
-#ifndef OSQP_TYPES_H
-# define OSQP_TYPES_H
-
-# ifdef __cplusplus
-extern "C" {
-# endif // ifdef __cplusplus
-
-# include "glob_opts.h"
-# include "constants.h"
-
-
-/******************
-* Internal types *
-******************/
-
-/**
- *  Matrix in compressed-column form.
- *  The structure is used internally to store matrices in the triplet form as well,
- *  but the API requires that the matrices are in the CSC format.
- */
-typedef struct {
-  c_int    nzmax; ///< maximum number of entries
-  c_int    m;     ///< number of rows
-  c_int    n;     ///< number of columns
-  c_int   *p;     ///< column pointers (size n+1); col indices (size nzmax) start from 0 when using triplet format (direct KKT matrix formation)
-  c_int   *i;     ///< row indices, size nzmax starting from 0
-  c_float *x;     ///< numerical values, size nzmax
-  c_int    nz;    ///< number of entries in triplet matrix, -1 for csc
-} csc;
-
-/**
- * Linear system solver structure (sublevel objects initialize it differently)
- */
-
-typedef struct linsys_solver LinSysSolver;
-
-/**
- * OSQP Timer for statistics
- */
-typedef struct OSQP_TIMER OSQPTimer;
-
-/**
- * Problem scaling matrices stored as vectors
- */
-typedef struct {
-  c_float  c;    ///< cost function scaling
-  c_float *D;    ///< primal variable scaling
-  c_float *E;    ///< dual variable scaling
-  c_float  cinv; ///< cost function rescaling
-  c_float *Dinv; ///< primal variable rescaling
-  c_float *Einv; ///< dual variable rescaling
-} OSQPScaling;
-
-/**
- * Solution structure
- */
-typedef struct {
-  c_float *x; ///< primal solution
-  c_float *y; ///< Lagrange multiplier associated to \f$l <= Ax <= u\f$
-} OSQPSolution;
-
-
-/**
- * Solver return information
- */
-typedef struct {
-  c_int iter;          ///< number of iterations taken
-  char  status[32];    ///< status string, e.g. 'solved'
-  c_int status_val;    ///< status as c_int, defined in constants.h
-
-# ifndef EMBEDDED
-  c_int status_polish; ///< polish status: successful (1), unperformed (0), (-1) unsuccessful
-# endif // ifndef EMBEDDED
-
-  c_float obj_val;     ///< primal objective
-  c_float pri_res;     ///< norm of primal residual
-  c_float dua_res;     ///< norm of dual residual
-
-# ifdef PROFILING
-  c_float setup_time;  ///< time taken for setup phase (seconds)
-  c_float solve_time;  ///< time taken for solve phase (seconds)
-  c_float update_time; ///< time taken for update phase (seconds)
-  c_float polish_time; ///< time taken for polish phase (seconds)
-  c_float run_time;    ///< total time  (seconds)
-# endif // ifdef PROFILING
-
-# if EMBEDDED != 1
-  c_int   rho_updates;  ///< number of rho updates
-  c_float rho_estimate; ///< best rho estimate so far from residuals
-# endif // if EMBEDDED != 1
-} OSQPInfo;
-
-
-# ifndef EMBEDDED
-
-/**
- * Polish structure
- */
-typedef struct {
-  csc *Ared;          ///< active rows of A
-  ///<    Ared = vstack[Alow, Aupp]
-  c_int    n_low;     ///< number of lower-active rows
-  c_int    n_upp;     ///< number of upper-active rows
-  c_int   *A_to_Alow; ///< Maps indices in A to indices in Alow
-  c_int   *A_to_Aupp; ///< Maps indices in A to indices in Aupp
-  c_int   *Alow_to_A; ///< Maps indices in Alow to indices in A
-  c_int   *Aupp_to_A; ///< Maps indices in Aupp to indices in A
-  c_float *x;         ///< optimal x-solution obtained by polish
-  c_float *z;         ///< optimal z-solution obtained by polish
-  c_float *y;         ///< optimal y-solution obtained by polish
-  c_float  obj_val;   ///< objective value at polished solution
-  c_float  pri_res;   ///< primal residual at polished solution
-  c_float  dua_res;   ///< dual residual at polished solution
-} OSQPPolish;
-# endif // ifndef EMBEDDED
-
-
-/**********************************
-* Main structures and Data Types *
-**********************************/
-
-/**
- * Data structure
- */
-typedef struct {
-  c_int    n; ///< number of variables n
-  c_int    m; ///< number of constraints m
-  csc     *P; ///< the upper triangular part of the quadratic cost matrix P in csc format (size n x n).
-  csc     *A; ///< linear constraints matrix A in csc format (size m x n)
-  c_float *q; ///< dense array for linear part of cost function (size n)
-  c_float *l; ///< dense array for lower bound (size m)
-  c_float *u; ///< dense array for upper bound (size m)
-} OSQPData;
-
-
-/**
- * Settings struct
- */
-typedef struct {
-  c_float rho;                    ///< ADMM step rho
-  c_float sigma;                  ///< ADMM step sigma
-  c_int   scaling;                ///< heuristic data scaling iterations; if 0, then disabled.
-
-# if EMBEDDED != 1
-  c_int   adaptive_rho;           ///< boolean, is rho step size adaptive?
-  c_int   adaptive_rho_interval;  ///< number of iterations between rho adaptations; if 0, then it is automatic
-  c_float adaptive_rho_tolerance; ///< tolerance X for adapting rho. The new rho has to be X times larger or 1/X times smaller than the current one to trigger a new factorization.
-#  ifdef PROFILING
-  c_float adaptive_rho_fraction;  ///< interval for adapting rho (fraction of the setup time)
-#  endif // Profiling
-# endif // EMBEDDED != 1
-
-  c_int                   max_iter;      ///< maximum number of iterations
-  c_float                 eps_abs;       ///< absolute convergence tolerance
-  c_float                 eps_rel;       ///< relative convergence tolerance
-  c_float                 eps_prim_inf;  ///< primal infeasibility tolerance
-  c_float                 eps_dual_inf;  ///< dual infeasibility tolerance
-  c_float                 alpha;         ///< relaxation parameter
-  enum linsys_solver_type linsys_solver; ///< linear system solver to use
-
-# ifndef EMBEDDED
-  c_float delta;                         ///< regularization parameter for polishing
-  c_int   polish;                        ///< boolean, polish ADMM solution
-  c_int   polish_refine_iter;            ///< number of iterative refinement steps in polishing
-
-  c_int verbose;                         ///< boolean, write out progress
-# endif // ifndef EMBEDDED
-
-  c_int scaled_termination;              ///< boolean, use scaled termination criteria
-  c_int check_termination;               ///< integer, check termination interval; if 0, then termination checking is disabled
-  c_int warm_start;                      ///< boolean, warm start
-
-# ifdef PROFILING
-  c_float time_limit;                    ///< maximum number of seconds allowed to solve the problem; if 0, then disabled
-# endif // ifdef PROFILING
-} OSQPSettings;
-
-
-/**
- * OSQP Workspace
- */
-typedef struct {
-  /// Problem data to work on (possibly scaled)
-  OSQPData *data;
-
-  /// Linear System solver structure
-  LinSysSolver *linsys_solver;
-
-# ifndef EMBEDDED
-  /// Polish structure
-  OSQPPolish *pol;
-# endif // ifndef EMBEDDED
-
-  /**
-   * @name Vector used to store a vectorized rho parameter
-   * @{
-   */
-  c_float *rho_vec;     ///< vector of rho values
-  c_float *rho_inv_vec; ///< vector of inv rho values
-
-  /** @} */
-
-# if EMBEDDED != 1
-  c_int *constr_type; ///< Type of constraints: loose (-1), equality (1), inequality (0)
-# endif // if EMBEDDED != 1
-
-  /**
-   * @name Iterates
-   * @{
-   */
-  c_float *x;        ///< Iterate x
-  c_float *y;        ///< Iterate y
-  c_float *z;        ///< Iterate z
-  c_float *xz_tilde; ///< Iterate xz_tilde
-
-  c_float *x_prev;   ///< Previous x
-
-  /**< NB: Used also as workspace vector for dual residual */
-  c_float *z_prev;   ///< Previous z
-
-  /**< NB: Used also as workspace vector for primal residual */
-
-  /**
-   * @name Primal and dual residuals workspace variables
-   *
-   * Needed for residuals computation, tolerances computation,
-   * approximate tolerances computation and adapting rho
-   * @{
-   */
-  c_float *Ax;  ///< scaled A * x
-  c_float *Px;  ///< scaled P * x
-  c_float *Aty; ///< scaled A' * y
-
-  /** @} */
-
-  /**
-   * @name Primal infeasibility variables
-   * @{
-   */
-  c_float *delta_y;   ///< difference between consecutive dual iterates
-  c_float *Atdelta_y; ///< A' * delta_y
-
-  /** @} */
-
-  /**
-   * @name Dual infeasibility variables
-   * @{
-   */
-  c_float *delta_x;  ///< difference between consecutive primal iterates
-  c_float *Pdelta_x; ///< P * delta_x
-  c_float *Adelta_x; ///< A * delta_x
-
-  /** @} */
-
-  /**
-   * @name Temporary vectors used in scaling
-   * @{
-   */
-
-  c_float *D_temp;   ///< temporary primal variable scaling vectors
-  c_float *D_temp_A; ///< temporary primal variable scaling vectors storing norms of A columns
-  c_float *E_temp;   ///< temporary constraints scaling vectors storing norms of A' columns
-
-
-  /** @} */
-
-  OSQPSettings *settings; ///< problem settings
-  OSQPScaling  *scaling;  ///< scaling vectors
-  OSQPSolution *solution; ///< problem solution
-  OSQPInfo     *info;     ///< solver information
-
-# ifdef PROFILING
-  OSQPTimer *timer;       ///< timer object
-
-  /// flag indicating whether the solve function has been run before
-  c_int first_run;
-
-  /// flag indicating whether the update_time should be cleared
-  c_int clear_update_time;
-
-  /// flag indicating that osqp_update_rho is called from osqp_solve function
-  c_int rho_update_from_solve;
-# endif // ifdef PROFILING
-
-# ifdef PRINTING
-  c_int summary_printed; ///< Has last summary been printed? (true/false)
-# endif // ifdef PRINTING
-
-} OSQPWorkspace;
-
-
-/**
- * Define linsys_solver prototype structure
- *
- * NB: The details are defined when the linear solver is initialized depending
- *      on the choice
- */
-struct linsys_solver {
-  enum linsys_solver_type type;                 ///< linear system solver type functions
-  c_int (*solve)(LinSysSolver *self,
-                 c_float      *b);              ///< solve linear system
-
-# ifndef EMBEDDED
-  void (*free)(LinSysSolver *self);             ///< free linear system solver (only in desktop version)
-# endif // ifndef EMBEDDED
-
-# if EMBEDDED != 1
-  c_int (*update_matrices)(LinSysSolver *s,
-                           const csc *P,            ///< update matrices P
-                           const csc *A);           //   and A in the solver
-
-  c_int (*update_rho_vec)(LinSysSolver  *s,
-                          const c_float *rho_vec);  ///< Update rho_vec
-# endif // if EMBEDDED != 1
-
-# ifndef EMBEDDED
-  c_int nthreads; ///< number of threads active
-# endif // ifndef EMBEDDED
-};
-
-
-# ifdef __cplusplus
-}
-# endif // ifdef __cplusplus
-
-#endif // ifndef OSQP_TYPES_H

casadi/include/include/osqp/util.h

@@ -1,222 +0,0 @@
-#ifndef UTIL_H
-# define UTIL_H
-
-# ifdef __cplusplus
-extern "C" {
-# endif // ifdef __cplusplus
-
-# include "types.h"
-# include "constants.h"
-
-/******************
-* Versioning     *
-******************/
-
-/**
- * Return OSQP version
- * @return  OSQP version
- */
-const char* osqp_version(void);
-
-
-/**********************
-* Utility Functions  *
-**********************/
-
-# ifndef EMBEDDED
-
-/**
- * Copy settings creating a new settings structure (uses MALLOC)
- * @param  settings Settings to be copied
- * @return          New settings structure
- */
-OSQPSettings* copy_settings(const OSQPSettings *settings);
-
-# endif // #ifndef EMBEDDED
-
-/**
- * Custom string copy to avoid string.h library
- * @param dest   destination string
- * @param source source string
- */
-void c_strcpy(char       dest[],
-              const char source[]);
-
-
-# ifdef PRINTING
-
-/**
- * Print Header before running the algorithm
- * @param work     osqp workspace
- */
-void print_setup_header(const OSQPWorkspace *work);
-
-/**
- * Print header with data to be displayed per iteration
- */
-void print_header(void);
-
-/**
- * Print iteration summary
- * @param work current workspace
- */
-void print_summary(OSQPWorkspace *work);
-
-/**
- * Print information after polish
- * @param work current workspace
- */
-void print_polish(OSQPWorkspace *work);
-
-/**
- * Print footer when algorithm terminates
- * @param info   info structure
- * @param polish is polish enabled?
- */
-void print_footer(OSQPInfo *info,
-                  c_int     polish);
-
-
-# endif // ifdef PRINTING
-
-
-/*********************************
-* Timer Structs and Functions * *
-*********************************/
-
-/*! \cond PRIVATE */
-
-# ifdef PROFILING
-
-// Windows
-#  ifdef IS_WINDOWS
-
-  // Some R packages clash with elements
-  // of the windows.h header, so use a
-  // slimmer version for conflict avoidance
-# ifdef R_LANG
-#define NOGDI
-# endif
-
-#   include <windows.h>
-
-struct OSQP_TIMER {
-  LARGE_INTEGER tic;
-  LARGE_INTEGER toc;
-  LARGE_INTEGER freq;
-};
-
-// Mac
-#  elif defined IS_MAC
-
-#   include <mach/mach_time.h>
-
-/* Use MAC OSX  mach_time for timing */
-struct OSQP_TIMER {
-  uint64_t                  tic;
-  uint64_t                  toc;
-  mach_timebase_info_data_t tinfo;
-};
-
-// Linux
-#  else // ifdef IS_WINDOWS
-
-/* Use POSIX clock_gettime() for timing on non-Windows machines */
-#   include <time.h>
-#   include <sys/time.h>
-
-
-struct OSQP_TIMER {
-  struct timespec tic;
-  struct timespec toc;
-};
-
-#  endif // ifdef IS_WINDOWS
-
-/*! \endcond */
-
-/**
- * Timer Methods
- */
-
-/**
- * Start timer
- * @param t Timer object
- */
-void    osqp_tic(OSQPTimer *t);
-
-/**
- * Report time
- * @param  t Timer object
- * @return   Reported time
- */
-c_float osqp_toc(OSQPTimer *t);
-
-# endif /* END #ifdef PROFILING */
-
-
-/* ================================= DEBUG FUNCTIONS ======================= */
-
-/*! \cond PRIVATE */
-
-
-# ifndef EMBEDDED
-
-/* Compare CSC matrices */
-c_int is_eq_csc(csc    *A,
-                csc    *B,
-                c_float tol);
-
-/* Convert sparse CSC to dense */
-c_float* csc_to_dns(csc *M);
-
-# endif // #ifndef EMBEDDED
-
-
-# ifdef PRINTING
-#  include <stdio.h>
-
-
-/* Print a csc sparse matrix */
-void print_csc_matrix(csc        *M,
-                      const char *name);
-
-/* Dump csc sparse matrix to file */
-void dump_csc_matrix(csc        *M,
-                     const char *file_name);
-
-/* Print a triplet format sparse matrix */
-void print_trip_matrix(csc        *M,
-                       const char *name);
-
-/* Print a dense matrix */
-void print_dns_matrix(c_float    *M,
-                      c_int       m,
-                      c_int       n,
-                      const char *name);
-
-/* Print vector  */
-void print_vec(c_float    *v,
-               c_int       n,
-               const char *name);
-
-/* Dump vector to file */
-void dump_vec(c_float    *v,
-              c_int       len,
-              const char *file_name);
-
-// Print int array
-void print_vec_int(c_int      *x,
-                   c_int       n,
-                   const char *name);
-
-# endif // ifdef PRINTING
-
-/*! \endcond */
-
-
-# ifdef __cplusplus
-}
-# endif // ifdef __cplusplus
-
-#endif // ifndef UTIL_H