casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/sleqp/sparse/pub_vec.h

@@ -0,0 +1,336 @@
+#ifndef SLEQP_PUB_VEC_H
+#define SLEQP_PUB_VEC_H
+
+/**
+ * @file pub_vec.h
+ * @brief Definition of vectors.
+ **/
+
+#include "sleqp/export.h"
+#include "sleqp/pub_types.h"
+
+/**
+ * A sparse vector data structure. Indices
+ * are stored in an ascending fashion.
+ **/
+typedef struct SleqpVec
+{
+  double* data;
+  int* indices;
+
+  int dim;
+  int nnz;
+  int nnz_max;
+
+} SleqpVec;
+
+/**
+ * Creates a new vector. Data and indices are set to
+ * have size of nnz_max.
+ *
+ * @param[in]  vec     A pointer to the vector to be created
+ * @param[in]  dim     The desired dimension of the vector
+ * @param[in]  nnz_max The desired amount of nonzeros of the vector
+ *
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_create(SleqpVec** vec, int dim, int nnz_max);
+
+/**
+ * Creates a new vector without allocating memory
+ * for non-zero entries
+ *
+ * @param[in]  vec     A pointer to the vector to be created
+ * @param[in]  dim     The desired dimension of the vector
+ *
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_create_empty(SleqpVec** vec, int dim);
+
+/**
+ * Creates a new vector, allocating memory sufficient
+ * for `dim` non-zero entries
+ *
+ * @param[in]  vec     A pointer to the vector to be created
+ * @param[in]  dim     The desired dimension of the vector
+ *
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_create_full(SleqpVec** vec, int dim);
+
+/**
+ * Pushes a new entry on top of a vector. The new
+ * entry is assumed to have a larger index than the existing ones.
+ *
+ * @param[in,out] vec    A pointer to the vector
+ * @param[in]     idx    The index of the new entry
+ * @param[in]     value  The value of the new entry
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_push(SleqpVec* vec, int idx, double value);
+
+/**
+ * Creates the entries of a vector from a dense
+ * vector. The vector will reserve an appropriate
+ * number of entries, the dimension will be changed to
+ * match that of the dense vector.
+ *
+ * @param[in,out] vec         A pointer to the vector
+ * @param[in]     values      A vector of values
+ * @param[in]     dim         The dimension of the values input
+ * @param[in]     zero_eps    The numerical tolerance
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_set_from_raw(SleqpVec* vec,
+                       const double* values,
+                       int dim,
+                       double zero_eps);
+
+/**
+ * Fills the given vector with the given value
+ * by setting all of its element to have that precise value
+ *
+ * @param[in,out] vec         A pointer to the vector
+ * @param[in]     value       The given value
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_fill(SleqpVec* vec, double value);
+
+/**
+ * Writes the content of this vector into an array. The
+ * array is assumed to have a size of at least the dimension
+ * of the given vector
+ *
+ * @param[in] vec     A pointer to the vector
+ * @param[in] values  A pointer to the output array
+ *
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_to_raw(const SleqpVec* vec, double* values);
+
+/**
+ * Copies one vector to another
+ *
+ * @param[in] source     A pointer to the copy source
+ * @param[out] target    A pointer to the copy target
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_copy(const SleqpVec* source, SleqpVec* target);
+
+/**
+ * Clears the given vector, discarding all entries while
+ * keeping the dimension constant
+ *
+ * @param[in,out] vec     A pointer to the vector
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_clear(SleqpVec* vec);
+
+/**
+ * Reserves space for additional nonzeros
+ *
+ * @param[in,out] vec     A pointer to the vector
+ * @param[in]     nnz_max The number of nonzeros
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_reserve(SleqpVec* vec, int nnz);
+
+/**
+ * Resizes the vector to the given dimension, discarding
+ * entries if necessary
+ *
+ * @param[in,out] vec     A pointer to the vector
+ * @param[in]     dim     The new dimension
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_resize(SleqpVec* vec, int dim);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_concat(const SleqpVec* first,
+                 const SleqpVec* second,
+                 SleqpVec* result);
+
+/**
+ * Returns whether all entries of the given vector are equal
+ * up to the given tolerance
+ *
+ * @param[in]  first     A pointer to the first vector
+ * @param[in]  second    A pointer to the second vector
+ * @param[in]  eps       The desred tolerance
+ *
+ * @sa sleqp_is_eq(double x, double y, double eps)
+ **/
+SLEQP_EXPORT bool
+sleqp_vec_eq(const SleqpVec* first, const SleqpVec* second, double eps);
+
+/**
+ * Computes the dot product of two vectors
+ *
+ * @param[in]  first     A pointer to the first vector
+ * @param[in]  second    A pointer to the second vector
+ * @param[out] product   A pointer to the result
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_dot(const SleqpVec* first, const SleqpVec* second, double* product);
+
+/**
+ * Scales the vector by a factor
+ *
+ * @param[in,out] vector   A pointer to the vector
+ * @param[in]     factor   The factor
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_scale(SleqpVec* vector, const double factor);
+
+/**
+ * Computes the sum of two vectors
+ *
+ * @param[in]  first         A pointer to the first vector
+ * @param[in]  second        A pointer to the second vector
+ * @param[out] result        A pointer to the result
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_add(const SleqpVec* first,
+              const SleqpVec* second,
+              const double eps,
+              SleqpVec* result);
+
+/**
+ * Computes the weighted sum of two vectors
+ *
+ * @param[in]  first         A pointer to the first vector
+ * @param[in]  second        A pointer to the second vector
+ * @param[in]  first_factor  A factor for the first vector
+ * @param[in]  second_factor A factor for the second vector
+ * @param[out] result        A pointer to the result
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_add_scaled(const SleqpVec* first,
+                     const SleqpVec* second,
+                     const double first_factor,
+                     const double second_factor,
+                     const double eps,
+                     SleqpVec* result);
+
+/**
+ * Fills all entries of the vector with the specified value
+ *
+ * @param[in,out] vector   A pointer to the vector
+ * @param[in]      value   The value
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_fill(SleqpVec* vec, double value);
+
+/**
+ * Returns the 2-norm of the given vector
+ *
+ * @param[in] vector   A pointer to the vector
+ **/
+SLEQP_EXPORT double
+sleqp_vec_norm(const SleqpVec* vec);
+
+/**
+ * Returns the 1-norm of the given vector
+ *
+ * @param[in] vector   A pointer to the vector
+ **/
+SLEQP_EXPORT double
+sleqp_vec_one_norm(const SleqpVec* vec);
+
+/**
+ * Returns the squared 2-norm of the given vector
+ *
+ * @param[in] vector   A pointer to the vector
+ **/
+SLEQP_EXPORT double
+sleqp_vec_norm_sq(const SleqpVec* vec);
+
+/**
+ * Returns the oo-norm of the given vector
+ *
+ * @param[in] vector   A pointer to the vector
+ **/
+SLEQP_EXPORT double
+sleqp_vec_inf_norm(const SleqpVec* vec);
+
+/**
+ * Returns a pointer to the entry of the given vector at
+ * the given index, or `NULL` if the entry is not present.
+ *
+ * @param[in] vector   A pointer to the vector
+ * @param[in] index    The desired index
+ **/
+SLEQP_EXPORT double*
+sleqp_vec_at(const SleqpVec* vec, int index);
+
+/**
+ * Returns the value of the given vector at the given index
+ *
+ * @param[in] vector   A pointer to the vector
+ * @param[in] index    The desired index
+ **/
+SLEQP_EXPORT double
+sleqp_vec_value_at(const SleqpVec* vec, int index);
+
+/**
+ * Returns whether this vector is boxed, i.e., \f$ lb \leq x \leq ub \f$
+ * for all components.
+ *
+ * @param[in] x    A pointer to the vector
+ * @param[in] lb   A pointer to the lower bound vector
+ * @param[in] ub   A pointer to the upper bound vector
+ *
+ SLEQP_EXPORT * @sa sleqp_vec_clip
+**/
+SLEQP_EXPORT bool
+sleqp_vec_is_boxed(const SleqpVec* x, const SleqpVec* lb, const SleqpVec* ub);
+
+/**
+ * Clips this vector to the specified lower and upper bounds, storing
+ * the result in the pointer to a new vector, which will be boxed
+ * w.r.t. `lb` and `ub`
+ *
+ * @param[in]  x     A pointer to the vector
+ * @param[in]  lb    A pointer to the lower bound vector
+ * @param[in]  ub    A pointer to the upper bound vector
+ * @param[out] xclip A pointer to the clipped vector
+ *
+ SLEQP_EXPORT * @sa sleqp_vec_is_boxed
+**/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_clip(const SleqpVec* x,
+               const SleqpVec* lb,
+               const SleqpVec* ub,
+               const double eps,
+               SleqpVec* xclip);
+
+/**
+ * Prints this vector to the given file
+ *
+ * @param[in]  vec     A pointer to the vector
+ * @param[in]  output  A pointer to an output `FILE*`
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_fprintf(const SleqpVec* vec, FILE* output);
+
+/**
+ * Returns whether the given vector is *valid*, i.e., whether
+ * - `nnz` non-negative and less than or equal to `nnz_max`
+ * - all indices are non-negative and less than or equal to `dim`
+ * - the entries are ordered according to their indices
+ *
+ **/
+SLEQP_EXPORT bool
+sleqp_vec_is_valid(const SleqpVec* vec);
+
+/**
+ * Returns whether the entries of the given vector are finite with respect to
+ *  \ref sleqp_is_finite(double)
+ **/
+SLEQP_EXPORT bool
+sleqp_vec_is_finite(const SleqpVec* vec);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_vec_free(SleqpVec** vec);
+
+#endif /* SLEQP_PUB_VEC_H */

casadi/include/sleqp.h

@@ -0,0 +1,38 @@
+#ifndef SLEQP_H
+#define SLEQP_H
+
+/**
+ * @file sleqp.h
+ * @brief SLEQP callable library.
+ **/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "sleqp/defs.h"
+#include "sleqp/export.h"
+
+#include "sleqp/pub_cmp.h"
+#include "sleqp/pub_dyn.h"
+#include "sleqp/pub_error.h"
+#include "sleqp/pub_func.h"
+#include "sleqp/pub_hess_struct.h"
+#include "sleqp/pub_iterate.h"
+#include "sleqp/pub_log.h"
+#include "sleqp/pub_lsq.h"
+#include "sleqp/pub_mem.h"
+#include "sleqp/pub_problem.h"
+#include "sleqp/pub_scale.h"
+#include "sleqp/pub_settings.h"
+#include "sleqp/pub_solver.h"
+#include "sleqp/pub_types.h"
+#include "sleqp/pub_working_set.h"
+#include "sleqp/sparse/pub_mat.h"
+#include "sleqp/sparse/pub_vec.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SLEQP_H */

casadi/include/superscs/cones.h

@@ -0,0 +1,185 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2017 Pantelis Sopasakis (https://alphaville.github.io),
+ *                    Krina Menounou (https://www.linkedin.com/in/krinamenounou), 
+ *                    Panagiotis Patrinos (http://homes.esat.kuleuven.be/~ppatrino)
+ * Copyright (c) 2012 Brendan O'Donoghue (bodonoghue85@gmail.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * 
+ */
+#ifndef SCS_CONES_H_GUARD
+#define SCS_CONES_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "glbopts.h"
+#include "scs_blas.h"
+
+    /* NB: rows of data matrix A must be specified in this exact order */
+
+    /** 
+     * \brief Cone structure 
+     *
+     * This structure represents a Cartesian product of cones as explained in 
+     * detail in \ref page_cones "this documentation page".
+     * 
+     * \sa \ref page_cones "Cones documentation"
+     */
+    struct scs_cone {
+        /**
+         * \brief Number of linear equality constraints \f$(n_{\mathrm{f}})\f$
+         * 
+         * The corresponding cone is the zero-cone 
+         * \f$\mathcal{K}^{f}_{n_f} = \{0_{n_f}\}\f$
+         */
+        scs_int f;
+        /** 
+         * \brief Dimension of LP cone \f$(n_{\mathrm{l}})\f$
+         * 
+         * This is used to specify element-wise inequalities.
+         *
+         * The corresponding cone is the positive orthant
+         * \f$\mathcal{K}^{l}_{n_l} = \{x\in\mathbb{R}^{n_l}: x_i \geq 0, 
+         * \forall i\}\f$
+         */
+        scs_int l;
+        /** 
+         * \brief Array of SOC constraints 
+         * \f$(n_{\mathrm{q},1},\ldots, n_{\mathrm{q},N_{\mathrm{q}}})\f$.
+         * 
+         * This is the Cartesian product of \f$N_{so}\f$ cones with 
+         * dimensions \f$n_{so_1},\ldots, n_{so,N_{so}}\f$.
+         * 
+         * This array contains the dimensions \f$(n_{so_1},\ldots, n_{so,N_{so}})\f$.
+         * 
+         * The length of this array is specified in #qsize.
+         * 
+         * \sa \ref #qsize "number of second-order cones"
+         * 
+         */
+        scs_int *RESTRICT q;
+        /** 
+         * \brief Length of SOC array, i.e., number of second-order cones 
+         * \f$(N_{\mathrm{q}})\f$
+         * 
+         * \sa \ref #q "array of second-order cones"
+         */
+        scs_int qsize; 
+        /** 
+         * \brief array of PSD constraints \f$(k_1,\ldots, k_{N_{\mathrm{s}}})\f$
+         * 
+         * Array of dimensions of PSD constraints.
+         * 
+         * \sa \ref #ssize "number of PSD cones"
+         */
+        scs_int *RESTRICT s; 
+        /**
+         * \brief length of PSD array \f$(N_{\mathrm{s}})\f$
+         * 
+         * \sa \ref #s "array of positive semidefinite cones"
+         */
+        scs_int ssize; 
+        /**
+         * \brief Number of primal exponential cone triples \f$(n_{\mathrm{ep}})\f$
+         * 
+         * \sa \ref #ed "dual exponential cone"
+         */
+        scs_int ep; 
+        /**
+         * \brief number of dual exponential cone triples \f$(n_{\mathrm{de}})\f$
+         * 
+         * \sa \ref #ep "primal exponential cone"
+         */
+        scs_int ed; 
+        /** 
+         * \brief Array of power cone params \f$(\alpha_1,\ldots,\alpha_{N_{\mathrm{p}}})\f$.
+         * 
+         * \note Cone parameters must be in \f$[-1, 1]\f$. 
+         * \note Negative values are interpreted as specifying the dual cone 
+         */
+        scs_float * p; 
+        /** 
+         * \brief Number of (primal and dual) power cone tuples \f$(N_{\mathrm{p}})\f$.
+         *  
+         */
+        scs_int psize; 
+    };
+
+    /** private data to help cone projection step */
+
+    /** \brief Workspace for cones */
+    typedef struct scs_cone_work {
+#ifdef LAPACK_LIB_FOUND
+        /* workspace for eigenvector decompositions: */
+        scs_float * RESTRICT Xs;
+        scs_float * RESTRICT Z;
+        scs_float * RESTRICT e;
+        scs_float * RESTRICT work;
+        blasint * RESTRICT iwork, lwork, liwork;
+#endif
+        scs_float total_cone_time;
+    } ScsConeWork;
+
+    /**
+     * boundaries will contain array of indices of rows of A corresponding to
+     * cone boundaries, boundaries[0] is starting index for cones of size larger
+     * than 1
+     * 
+     * @return returns length of boundaries array, boundaries malloc-ed here so 
+     * should be freed
+     */
+    scs_int scs_get_cone_boundaries(
+            const ScsCone * RESTRICT k,
+            scs_int ** RESTRICT boundaries);
+
+    ScsConeWork *scs_init_conework(const ScsCone * RESTRICT k);
+
+    char *scs_get_cone_header(const ScsCone *k);
+
+    scs_int scs_validate_cones(
+            const ScsData * RESTRICT d,
+            const ScsCone * RESTRICT k);
+
+    /** 
+     * pass in iter to control how accurate the cone projection
+     * with iteration, set iter < 0 for exact projection, warm_start contains guess
+     * of solution, can be SCS_NULL
+     */
+    scs_int scs_project_dual_cone(
+            scs_float * RESTRICT x,
+            const ScsCone * RESTRICT k,
+            ScsConeWork * RESTRICT c,
+            const scs_float * RESTRICT warm_start,
+            scs_int iter);
+
+    void scs_finish_cone(
+            ScsConeWork * RESTRICT coneWork);
+
+    char *scs_get_cone_summary(
+            const ScsInfo * RESTRICT info,
+            ScsConeWork * RESTRICT c);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

casadi/include/superscs/constants.h

@@ -0,0 +1,144 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2017 Pantelis Sopasakis (https://alphaville.github.io),
+ *                    Krina Menounou (https://www.linkedin.com/in/krinamenounou), 
+ *                    Panagiotis Patrinos (http://homes.esat.kuleuven.be/~ppatrino)
+ * Copyright (c) 2012 Brendan O'Donoghue (bodonoghue85@gmail.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * 
+ */
+#ifndef SCS_CONSTANTS_H_GUARD
+#define SCS_CONSTANTS_H_GUARD
+
+#include "glbopts.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    /* SCS VERSION NUMBER ----------------------------------------------    */
+    /* string literals automatically null-terminated */
+    /**
+     * Version of SCS
+     */
+#define SCS_VERSION                                                            \
+    ("1.3.3") 
+
+
+    /* SCS returns one of the following integers:                           */
+    
+    /**
+     * Potentially infeasible (inaccurate solution)
+     */
+#define SCS_INFEASIBLE_INACCURATE (-7)
+    /**
+     * Potentially unbounded (inaccurate solution)
+     */
+#define SCS_UNBOUNDED_INACCURATE (-6)
+    /**
+     * Solver interrupted by \c SIGINT.
+     */
+#define SCS_SIGINT (-5)
+    /**
+     * SCS solver failed
+     */
+#define SCS_FAILED (-4)
+    /**
+     * indeterminate solution
+     */
+#define SCS_INDETERMINATE (-3)
+    /**
+     *  primal infeasible, dual unbounded   
+     */
+#define SCS_INFEASIBLE (-2) 
+    /**
+     *  primal unbounded, dual infeasible   
+     */
+#define SCS_UNBOUNDED (-1)  
+    /**
+     *  This status code never returned, used as placeholder 
+     */
+#define SCS_UNFINISHED (0)  
+    /**
+     * Problem successfully solved within the prescribed tolerance.
+     */
+#define SCS_SOLVED (1)
+    /**
+     * Problem seems to be feasible; suboptimal solution found.
+     */
+#define SCS_SOLVED_INACCURATE (2)
+
+    /* DEFAULT SOLVER PARAMETERS AND SETTINGS --------------------------    */
+    
+    /**
+     * Default maximum allowed runtime for (Super)SCS.
+     */
+#define SCS_MAX_TIME_MILLISECONDS (300000.)
+    /**
+     * Default maximum number of iterations.
+     */
+#define SCS_MAX_ITERS_DEFAULT (10000)
+#define SCS_EPS_DEFAULT (1E-3)
+#define SCS_ALPHA_DEFAULT (1.5)
+#define SCS_RHO_X_DEFAULT (0.001)
+#define SCS_SCALE_DEFAULT (1.0)
+#define SCS_CG_RATE_DEFAULT (2.0)
+#define SCS_VERBOSE_DEFAULT (1)
+#define SCS_NORMALIZE_DEFAULT (1)
+#define SCS_DO_RECORD_PROGRESS_DEFAULT (0)
+#define SCS_WARM_START_DEFAULT (0)
+
+    /* Parameters for Superscs*/
+#define SCS_DO_SUPERSCS_DEFAULT (1)
+#define SCS_K0_DEFAULT (0)
+#define SCS_K1_DEFAULT (1)
+#define SCS_K2_DEFAULT (1)    
+#define SCS_NOMINAL_DEFAULT (1)
+#define SCS_C_BL_DEFAULT (0.999)
+#define SCS_C1_DEFAULT (1.0-1E-4)
+#define SCS_SSE_DEFAULT (1.0-1E-3) 
+
+    /* Line-search defaults */
+#define SCS_LS_DEFAULT  (10)
+#define SCS_BETA_DEFAULT (0.5)
+#define SCS_SIGMA_DEFAULT (1E-2)
+
+    /* Direction Defaults */
+#define SCS_DIRECTION_DEFAULT (anderson_acceleration)
+#define SCS_TRULE_DEFAULT (3)
+#define SCS_THETABAR_DEFAULT (1E-1)
+#define SCS_ALPHAC_DEFAULT (1E-2) 
+#define SCS_MEMORY_DEFAULT (5)
+#define SCS_SC_INIT_DEFAULT (0)
+#define SCS_BROYDEN_ISCS_SCALE_DEFAULT (1)
+#define SCS_OVERRIDE_STREAMS_DEFAULT (0)
+    
+    /* Other */
+#define SCS_OUT_STREAM_DEFAULT (stdout)
+    /**
+     * Default value for \ref ScsSettings#previous_max_iters "previous number of maximum iterations".
+     */
+#define SCS_PMAXITER_DEFAULT (-1)
+#ifdef __cplusplus
+}
+#endif
+#endif