casadi 3.7.2__cp314-none-manylinux2014_i686.whl

casadi/include/superscs/linSys.h

@@ -0,0 +1,205 @@
+/*
+ * 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 LINSYS_H_GUARD
+#define LINSYS_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    /* 
+     * YOUR LINEAR SYSTEM SOLVER MUST IMPLEMENT THESE METHODS AND scs_private_data
+     * STRUCT 
+     */
+
+    /* 
+     * private data structs (that you define) containing any necessary data to solve
+     * linear system, etc. 
+     */
+
+    /* 
+     * this defines the matrix A, only the linear system solver interacts with this
+     * struct 
+     */
+
+    /**
+     * Structure supporting sparse matrices in CSC format.
+     * 
+     * \sa \ref page_sparse_matrices "Sparse matrices documentation"
+     */
+    typedef struct scs_a_data_matrix ScsAMatrix;
+
+    /** 
+     * Stores the necessary private workspace, only the linear system solver
+     * interacts with this struct 
+     */
+    typedef struct scs_private_data ScsPrivWorkspace;
+
+    /** 
+     * initialize scs_linsys_priv_workspace structure and perform any necessary preprocessing 
+     */
+    ScsPrivWorkspace *scs_init_priv(
+            const ScsAMatrix *A,
+            const ScsSettings *stgs);
+
+    /** 
+     * Solves <code>[d->RHO_X * I  A' ; A  -I] x = b</code> for <code>x</code>, 
+     * stores result in <code>b</code>, <code>s</code> contains
+     * warm-start, <code>iter</code> is current scs iteration count 
+     * 
+     * @param A sparse matrix A
+     * @param stgs user-specified settings
+     * @param p private structure
+     * @param b right hand side
+     * @param s initial guess
+     * @param iter 
+     * 
+     * @return on success, returns 0
+     */
+    scs_int scs_solve_lin_sys(
+            const ScsAMatrix *A,
+            const ScsSettings *stgs,
+            ScsPrivWorkspace *p,
+            scs_float *b,
+            const scs_float *s,
+            scs_int iter);
+    /** 
+     * Frees scs_linsys_priv_workspace structure and allocated memory in it.
+     */
+    void scs_free_priv(ScsPrivWorkspace *p);
+
+    /** 
+     * Performs <code>y += A'*x</code>
+     */
+    void scs_accum_by_a_trans(
+            const ScsAMatrix *A,
+            ScsPrivWorkspace *p,
+            const scs_float *x,
+            scs_float *y);
+
+    /** 
+     * Performs <code>y += A*x</code>
+     */
+    void scs_accum_by_a(
+            const ScsAMatrix *A,
+            ScsPrivWorkspace *p,
+            const scs_float *x,
+            scs_float *y);
+
+    /** 
+     * Returns negative num if input data is invalid 
+     */
+    scs_int scs_validate_linsys(
+            const ScsAMatrix *A);
+
+    /** 
+     * Returns string describing method, can return null, if not null free will be
+     * called on output 
+     */
+    char *scs_get_linsys_method(
+            const ScsAMatrix *A,
+            const ScsSettings *stgs);
+
+    /** 
+     * Returns string containing summary information about linear system solves, can
+     * return null, if not null free will be called on output 
+     */
+    char *scs_get_linsys_summary(
+            ScsPrivWorkspace *p,
+            const ScsInfo *info);
+
+    /* Normalization routines, used if d->NORMALIZE is true */
+    /** 
+     * normalizes A matrix, sets <code>w->E</code> and <code>w->D</code> 
+     * diagonal scaling matrices,<code>Anew = d->SCALE * (D^-1)*A*(E^-1)</code> 
+     * (different to paper which is <code>D*A*E</code>) D and E must be all 
+     * positive entries, D must satisfy cone boundaries must set 
+     * (<code>w->meanNormRowA</code> = mean of norms of rows of normalized A) 
+     * THEN scale resulting <code>A</code> by <code>d->SCALE</code>.
+     */
+    void scs_normalize_a(
+            ScsAMatrix *A,
+            const ScsSettings *stgs,
+            const ScsCone *k,
+            ScsScaling *scal);
+
+    /** 
+     * unnormalizes \c A matrix, unnormalizes by <code>w->D</code> and <code>w->E</code> 
+     * and <code>d->SCALE</code>.
+     */
+    void scs_unnormalize_a(
+            ScsAMatrix *A,
+            const ScsSettings *stgs,
+            const ScsScaling *scal);
+
+    /** 
+     * Frees the memory allocated in ScsAMatrix.
+     */
+    void scs_free_a_matrix(ScsAMatrix *A);
+    
+    /**
+     * Whether the solution of the linear system is based on 
+     * an indirect method.
+     * 
+     * @return \c 1 if indirect, \c 0 otherwise
+     */
+    scs_int scs_linsys_is_indirect(void);
+    
+    /**
+     * Total number of CG iterations if an indirect method is used,
+     * \c -1 otherwise
+     * 
+     * @param priv private workspace structure
+     * @return total CG iterations
+     */
+    scs_int scs_linsys_total_cg_iters(ScsPrivWorkspace *priv);
+    
+    /**
+     * Returns the total solve time for the linear system (in \c ms).
+     * 
+     * @param priv private workspace structure
+     * @return solve time in \c ms
+     */
+    scs_float scs_linsys_total_solve_time_ms(ScsPrivWorkspace *priv);
+
+#ifdef COPYAMATRIX
+
+    /** 
+     * copies <code>A</code> (instead of in-place normalization), returns 
+     * <code>0</code> for failure, allocates memory for <code>dstp</code>.
+     */
+    scs_int scs_copy_a_matrix(
+            ScsAMatrix **dstp,
+            const ScsAMatrix *src);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

casadi/include/superscs/linsys/amatrix.h

@@ -0,0 +1,77 @@
+/*
+ * 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 AMATRIX_H_GUARD
+#define AMATRIX_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* this struct defines the data matrix A */
+    
+    /**
+     * \brief The sparse matrix A of the conic optimization problem.
+     * 
+     * The data are stored in \ref page_sparse_matrices "CSC format".
+     * 
+     * \sa \ref page_sparse_matrices "Sparse matrices documentation"
+     */
+struct scs_a_data_matrix {
+    /* A is supplied in column compressed format */
+    /**
+     * \brief Values of \c A
+     */
+    scs_float *x; /* A values, size: NNZ A */
+    /**
+     * \brief The row-index of the matrix (\f$J\f$). 
+     * 
+     * An array of length equal to the number of nonzero elements of \c A.
+     */
+    scs_int *i;
+    /**
+     * \brief  Array of column pointers of A in \ref page_sparse_matrices "CSC format"
+     * (\f$I\f$).
+     * 
+     * The length of <code>A->p</code> is equal to <code>A->n + 1</code>.
+     * 
+     */
+    scs_int *p;
+    /**
+     * \brief  Number of rows (\f$m\f$).
+     */
+    scs_int m;
+    /**
+     * \brief  Number of columns (\f$n\f$).
+     */
+    scs_int n; 
+};
+
+#ifdef __cplusplus
+}
+#endif
+#endif

casadi/include/superscs/linsys/common.h

@@ -0,0 +1,49 @@
+/*
+ * 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 COMMON_H_GUARD
+#define COMMON_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "scs.h"
+#include "amatrix.h"
+
+void scs_accum_by_a_trans__(scs_int n, scs_float *Ax, scs_int *Ai, scs_int *Ap,
+                    const scs_float *x, scs_float *y);
+void scs_accum_by_a__(scs_int n, scs_float *Ax, scs_int *Ai, scs_int *Ap,
+               const scs_float *x, scs_float *y);
+
+void scs_print_a_matrix(const ScsAMatrix *A);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

casadi/include/superscs/normalize.h

@@ -0,0 +1,138 @@
+/*
+ * 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_NORMALIZE_H_GUARD
+#define SCS_NORMALIZE_H_GUARD
+
+#include "scs.h"
+
+
+#define MIN_SCALE (1e-3)
+#define MAX_SCALE (1e3)
+
+void scs_normalize_bc(ScsWork *w) {
+    scs_int i;
+    scs_float nm, *D = w->scal->D, *E = w->scal->E, *b = w->b, *c = w->c;
+    /* scale b */
+    for (i = 0; i < w->m; ++i) {
+        b[i] /= D[i];
+    }
+    nm = scs_norm(b, w->m);
+    w->sc_b = w->scal->meanNormColA / MAX(nm, MIN_SCALE);
+    /* scale c */
+    for (i = 0; i < w->n; ++i) {
+        c[i] /= E[i];
+    }
+    nm = scs_norm(c, w->n);
+    w->sc_c = w->scal->meanNormRowA / MAX(nm, MIN_SCALE);
+    scs_scale_array(b, w->sc_b * w->stgs->scale, w->m);
+    scs_scale_array(c, w->sc_c * w->stgs->scale, w->n);
+}
+
+/* TENTATIVELY REMOVE THIS FUNCTION 
+void scs_calculate_scaled_residuals(ScsWork *w, struct scs_residuals *r) {
+    scs_float *D = w->scal->D;
+    scs_float *E = w->scal->E;
+    scs_float *u = w->u;
+    scs_float *u_t = w->u_t;
+    scs_float *u_prev = w->u_prev;
+    scs_float tmp;
+    scs_int i, n = w->n, m = w->m;
+
+    r->res_pri = 0;
+    for (i = 0; i < n; ++i) {
+        tmp = (u[i] - u_t[i]) / (E[i] * w->sc_b);
+        r->res_pri += tmp * tmp;
+    }
+    for (i = 0; i < m; ++i) {
+        tmp = (u[i + n] - u_t[i + n]) / (D[i] * w->sc_c);
+        r->res_pri += tmp * tmp;
+    }
+    tmp = u[n + m] - u_t[n + m];
+    r->res_pri += tmp * tmp;
+    r->res_pri = sqrt(r->res_pri);
+
+    r->res_dual = 0;
+    for (i = 0; i < n; ++i) {
+        tmp = (u[i] - u_prev[i]) * E[i] / w->sc_b;
+        r->res_dual += tmp * tmp;
+    }
+    for (i = 0; i < m; ++i) {
+        tmp = (u[i + n] - u_prev[i + n]) * D[i] / w->sc_c;
+        r->res_dual += tmp * tmp;
+    }
+    tmp = u[n + m] - u_t[n + m];
+    r->res_dual += tmp * tmp;
+    r->res_dual = sqrt(r->res_dual);
+}
+*/
+
+void scs_normalize_warm_start(ScsWork *w) {
+    scs_int i;
+    scs_float *D;
+    scs_float *E;
+    scs_float *x;
+    scs_float *y;
+
+    D = w->scal->D;
+    E = w->scal->E;
+    if (!w->stgs->do_super_scs) {
+        scs_float *s;
+        x = w->u;
+        y = &(w->u[w->n]);
+        s = &(w->u[w->n]);
+        for (i = 0; i < w->m; ++i) {
+            s[i] /= (D[i] / (w->sc_b * w->stgs->scale));
+        }
+    } else {
+        x = w->u_t;
+        y = &(w->u_t[w->n]);
+    }
+    for (i = 0; i < w->n; ++i) {
+        x[i] *= (E[i] * w->sc_b);
+    }
+    for (i = 0; i < w->m; ++i) {
+        y[i] *= (D[i] * w->sc_c);
+    }
+}
+
+void scs_unnormalize_sol(ScsWork *w, ScsSolution *sol) {
+    scs_int i;
+    scs_float *D = w->scal->D;
+    scs_float *E = w->scal->E;
+    for (i = 0; i < w->n; ++i) {
+        sol->x[i] /= (E[i] * w->sc_b);
+    }
+    for (i = 0; i < w->m; ++i) {
+        sol->y[i] /= (D[i] * w->sc_c);
+    }
+    for (i = 0; i < w->m; ++i) {
+        sol->s[i] *= D[i] / (w->sc_b * w->stgs->scale);
+    }
+}
+
+#endif