casadi 3.6.4__cp37-none-win_amd64.whl → 3.6.6__cp37-none-win_amd64.whl

casadi/include/highs/ipm/basiclu/basiclu_update.h

@@ -0,0 +1,125 @@
+lu_int basiclu_update
+(
+    lu_int istore[],
+    double xstore[],
+    lu_int Li[],
+    double Lx[],
+    lu_int Ui[],
+    double Ux[],
+    lu_int Wi[],
+    double Wx[],
+    double xtbl
+);
+
+/*
+Purpose:
+
+    Update the factorization to replace one column of the factorized matrix.
+    A call to basiclu_update() must be preceded by calls to
+    basiclu_solve_for_update() to provide the column to be inserted and the
+    index of the column to be replaced.
+
+    The column to be inserted is defined as the right-hand side in the last call
+    to basiclu_solve_for_update() in which the forward system was solved.
+
+    The index of the column to be replaced is defined by the unit vector in the
+    last call to basiclu_solve_for_update() in which the transposed system was
+    solved.
+
+Return:
+
+    BASICLU_ERROR_invalid_store if istore, xstore do not hold a BASICLU
+    instance. In this case xstore[BASICLU_STATUS] is not set.
+
+    Otherwise return the status code. See xstore[BASICLU_STATUS] below.
+
+Arguments:
+
+    lu_int istore[]
+    double xstore[]
+    lu_int Li[]
+    double Lx[]
+    lu_int Ui[]
+    double Ux[]
+    lu_int Wi[]
+    double Wx[]
+
+        Factorization computed by basiclu_factorize() or basiclu_update().
+
+    double xtbl
+
+        This is an optional argument to monitor numerical stability. xtbl can be
+        either of
+
+        (a) element j0 of the solution to the forward system computed by
+            basiclu_solve_for_update(), where j0 is the column to be replaced;
+
+        (b) the dot product of the incoming column and the solution to the
+            transposed system computed by basiclu_solve_for_update().
+
+        In either case xstore[BASICLU_PIVOT_ERROR] (see below) has a defined
+        value. If monitoring stability is not desired, xtbl can be any value.
+
+Parameters:
+
+    xstore[BASICLU_MEMORYL]: length of Li and Lx
+    xstore[BASICLU_MEMORYU]: length of Ui and Ux
+    xstore[BASICLU_MEMORYW]: length of Wi and Wx
+
+    xstore[BASICLU_DROP_TOLERANCE]
+
+        Nonzeros which magnitude is less than or equal to the drop tolerance
+        are removed from the row eta matrix. Default: 1e-20
+
+Info:
+
+    xstore[BASICLU_STATUS]: status code.
+
+        BASICLU_OK
+
+            The update has successfully completed.
+
+        BASICLU_ERROR_argument_missing
+
+            One or more of the pointer/array arguments are NULL.
+
+        BASICLU_ERROR_invalid_call
+
+            The factorization is invalid or the update was not prepared by two
+            calls to basiclu_solve_for_update().
+
+        BASICLU_REALLOCATE
+
+            Insufficient memory in Wi,Wx. The number of additional elements
+            required is given by
+
+                xstore[BASICLU_ADD_MEMORYW] > 0
+
+            The user must reallocate Wi,Wx. It is recommended to reallocate for
+            the requested number of additional elements plus some extra space
+            for further updates (e.g. 0.5 times the current array length). The
+            new array length must be provided in
+
+                xstore[BASICLU_MEMORYW]: length of Wi and Wx
+
+            basiclu_update will start from scratch in the next call.
+
+        BASICLU_ERROR_singular_update
+
+            The updated factorization would be (numerically) singular. No update
+            has been computed and the old factorization is still valid.
+
+    xstore[BASICLU_PIVOT_ERROR]
+
+        When xtbl was given (see above), then xstore[BASICLU_PIVOT_ERROR] is a
+        measure for numerical stability. It is the difference between two
+        computations of the new pivot element relative to the new pivot element.
+        A value larger than 1e-10 indicates numerical instability and suggests
+        refactorization (and possibly tightening the pivot tolerance).
+
+    xstore[BASICLU_MAX_ETA]
+
+        The maximum entry (in absolute value) in the eta vectors from the
+        Forrest-Tomlin update. A large value, say > 1e6, indicates that pivoting
+        on diagonal element was unstable and refactorization might be necessary.
+*/

casadi/include/highs/ipm/basiclu/lu_def.h

@@ -0,0 +1,39 @@
+#ifndef _LU_DEF_H
+#define _LU_DEF_H
+
+/* -------------------------------------------------------------------------- */
+/* ANSI standard include files */
+/* -------------------------------------------------------------------------- */
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+#include <stdint.h>
+#include <assert.h>
+
+#include "ipm/basiclu/basiclu.h"
+
+#define BASICLU_HASH 7743090    /* hash in istore[0], xstore[0] */
+
+enum { NO_TASK, SINGLETONS, SETUP_BUMP, FACTORIZE_BUMP, BUILD_FACTORS };
+
+/* -------------------------------------------------------------------------- */
+/* standard macros and inlines */
+/* -------------------------------------------------------------------------- */
+
+#define MAX(a,b) ((a)>=(b) ? (a):(b))
+#define MIN(a,b) ((a)<=(b) ? (a):(b))
+
+static inline void lu_iswap(lu_int *x, lu_int i, lu_int j)
+{
+    lu_int t = x[i]; x[i] = x[j]; x[j] = t;
+}
+
+static inline void lu_fswap(double *x, lu_int i, lu_int j)
+{
+    double t = x[i]; x[i] = x[j]; x[j] = t;
+}
+
+#endif

casadi/include/highs/ipm/basiclu/lu_file.h

@@ -0,0 +1,21 @@
+#ifndef _LU_FILE_H
+#define _LU_FILE_H
+
+void lu_file_empty(
+    lu_int nlines, lu_int *begin, lu_int *end, lu_int *next, lu_int *prev,
+    lu_int fmem);
+
+void lu_file_reappend(
+    lu_int line, lu_int nlines, lu_int *begin, lu_int *end, lu_int *next,
+    lu_int *prev, lu_int *index, double *value, lu_int extra_space);
+
+lu_int lu_file_compress(
+    lu_int nlines, lu_int *begin, lu_int *end, const lu_int *next,
+    lu_int *index, double *value, double stretch, lu_int pad);
+
+lu_int lu_file_diff(
+    lu_int nrow, const lu_int *begin_row, const lu_int *end_row,
+    const lu_int *begin_col, const lu_int *end_col, const lu_int *index,
+    const double *value);
+
+#endif

casadi/include/highs/ipm/basiclu/lu_internal.h

@@ -0,0 +1,220 @@
+#ifndef _LU_INTERNAL_H
+#define _LU_INTERNAL_H
+
+#include "ipm/basiclu/lu_def.h"
+
+/* -------------------------------------------------------------------------- */
+/* struct lu */
+/* -------------------------------------------------------------------------- */
+
+/*
+    This data structure provides access to istore, xstore.
+
+    lu_* routines do not access istore, xstore directly. Instead, they operate
+    on a struct lu object. Scalar quantities stored in istore, xstore are copied
+    to a struct lu object by lu_load() and copied back by lu_save(). Subarrays
+    of istore, xstore and the user arrays Li, Lx, Ui, Ux, Wi, Wx are aliased by
+    pointers in struct lu.
+*/
+
+struct lu
+{
+    /* user parameters, not modified */
+    lu_int Lmem;
+    lu_int Umem;
+    lu_int Wmem;
+    double droptol;
+    double abstol;
+    double reltol;
+    lu_int nzbias;
+    lu_int maxsearch;
+    lu_int pad;
+    double stretch;
+    double compress_thres;
+    double sparse_thres;
+    lu_int search_rows;
+
+    /* user readable */
+    lu_int m;
+    lu_int addmemL;
+    lu_int addmemU;
+    lu_int addmemW;
+
+    lu_int nupdate;
+    lu_int nforrest;
+    lu_int nfactorize;
+    lu_int nupdate_total;
+    lu_int nforrest_total;
+    lu_int nsymperm_total;
+    lu_int Lnz;                  /* nz in L excluding diagonal */
+    lu_int Unz;                  /* nz in U excluding diagonal */
+    lu_int Rnz;                  /* nz in update etas excluding diagonal */
+    double min_pivot;
+    double max_pivot;
+    double max_eta;
+    double update_cost_numer;
+    double update_cost_denom;
+    double time_factorize;
+    double time_solve;
+    double time_update;
+    double time_factorize_total;
+    double time_solve_total;
+    double time_update_total;
+    lu_int Lflops;
+    lu_int Uflops;
+    lu_int Rflops;
+    double condestL;
+    double condestU;
+    double normL;
+    double normU;
+    double normestLinv;
+    double normestUinv;
+    double onenorm;             /* 1-norm and inf-norm of matrix after fresh  */
+    double infnorm;             /* factorization with dependent cols replaced */
+    double residual_test;       /* computed by lu_residual_test() */
+
+    lu_int matrix_nz;           /* nz in basis matrix when factorized */
+    lu_int rank;                /* rank of basis matrix when factorized */
+    lu_int bump_size;
+    lu_int bump_nz;
+    lu_int nsearch_pivot;       /* # rows/cols searched for pivot */
+    lu_int nexpand;             /* # rows/cols expanded in factorize */
+    lu_int ngarbage;            /* # garbage collections in factorize */
+    lu_int factor_flops;        /* # flops in factorize */
+    double time_singletons;
+    double time_search_pivot;
+    double time_elim_pivot;
+
+    double pivot_error;         /* error estimate for pivot in last update */
+
+    /* private */
+    lu_int task;                /* the part of factorization in progress */
+    lu_int pivot_row;           /* chosen pivot row */
+    lu_int pivot_col;           /* chosen pivot column */
+    lu_int ftran_for_update;    /* >= 0 if FTRAN prepared for update */
+    lu_int btran_for_update;    /* >= 0 if BTRAN prepared for update */
+    lu_int marker;              /* see @marked, below */
+    lu_int pivotlen;            /* length of @pivotcol, @pivotrow; <= 2*m */
+    lu_int rankdef;             /* # columns removed from active submatrix
+                                   because maximum was 0 or < abstol */
+    lu_int min_colnz;           /* colcount lists 1..min_colnz-1 are empty */
+    lu_int min_rownz;           /* rowcount lists 1..min_rownz-1 are empty */
+
+    /* aliases to user arrays */
+    lu_int *Lindex, *Uindex, *Windex;
+    double *Lvalue, *Uvalue, *Wvalue;
+
+    /*
+     * pointers into istore
+     *
+     * When two declaration lists are on one line, then the arrays from the
+     * second list share memory with the array from the first list. The arrays
+     * from the first lists are used during factorization, the arrays from the
+     * second lists are used during solves/updates.
+     */
+
+    /* documented in lu_singletons.c, lu_setup_bump.c, lu_build_factors.c */
+    lu_int *colcount_flink;     lu_int *pivotcol;
+    lu_int *colcount_blink;     lu_int *pivotrow;
+    lu_int *rowcount_flink;     lu_int *Rbegin, *eta_row;
+    lu_int *rowcount_blink;     lu_int *iwork1;
+    lu_int *Wbegin;             lu_int *Lbegin;    /* + Wbegin reused */
+    lu_int *Wend;               lu_int *Ltbegin;   /* + Wend   reused */
+    lu_int *Wflink;             lu_int *Ltbegin_p; /* + Wflink reused */
+    lu_int *Wblink;             lu_int *p;         /* + Wblink reused */
+    lu_int *pinv;               lu_int *pmap;
+    lu_int *qinv;               lu_int *qmap;
+    lu_int *Lbegin_p;           /* Lbegin_p reused */
+    lu_int *Ubegin;             /* Ubegin   reused */
+
+    lu_int *iwork0;             lu_int *marked;
+    /* iwork0: size m workspace, zeroed */
+    /* marked: size m workspace, 0 <= marked[i] <= @marker */
+
+    /* pointers into xstore */
+    double *work0;              /* size m workspace, zeroed */
+    double *work1;              /* size m workspace, uninitialized */
+    double *col_pivot;          /* pivot elements by column index */
+    double *row_pivot;          /* pivot elements by row index */
+};
+
+
+/* -------------------------------------------------------------------------- */
+/* Internal function prototypes */
+/* -------------------------------------------------------------------------- */
+
+lu_int lu_load(
+    struct lu *this, lu_int *istore, double *xstore, lu_int *Li, double *Lx,
+    lu_int *Ui, double *Ux, lu_int *Wi, double *Wx);
+
+lu_int lu_save(
+    const struct lu *this, lu_int *istore, double *xstore, lu_int status);
+
+void lu_reset(struct lu *this);
+
+void lu_initialize(lu_int m, lu_int *istore, double *xstore);
+
+lu_int lu_factorize_bump (struct lu *this);
+
+lu_int lu_build_factors(struct lu *this);
+
+void lu_garbage_perm(struct lu *this);
+
+lu_int lu_markowitz(struct lu *this);
+
+lu_int lu_pivot(struct lu *this);
+
+lu_int lu_setup_bump(
+    struct lu *this, const lu_int *Bbegin, const lu_int *Bend, const lu_int *Bi,
+    const double *Bx);
+
+lu_int lu_singletons(
+    struct lu *this, const lu_int *Bbegin, const lu_int *Bend, const lu_int *Bi,
+    const double *Bx);
+
+void lu_solve_dense(
+    struct lu *this, const double *rhs, double *lhs, char trans);
+
+lu_int lu_solve_for_update(
+    struct lu *this, const lu_int nrhs, const lu_int *irhs, const double *xrhs,
+    lu_int *nlhs, lu_int *ilhs, double *xlhs, char trans);
+
+void lu_solve_sparse(
+    struct lu *this, const lu_int nrhs, const lu_int *irhs, const double *xrhs,
+    lu_int *nlhs, lu_int *ilhs, double *xlhs, char trans);
+
+lu_int lu_dfs(
+    lu_int i, const lu_int *begin, const lu_int *end, const lu_int *index,
+    lu_int top, lu_int *xi, lu_int *pstack, lu_int *marked, const lu_int M);
+
+lu_int lu_solve_symbolic(
+    const lu_int m, const lu_int *begin, const lu_int *end, const lu_int *index,
+    const lu_int nrhs, const lu_int *irhs, lu_int *ilhs, lu_int *pstack,
+    lu_int *marked, const lu_int M);
+
+lu_int lu_solve_triangular(
+    const lu_int nz_symb, const lu_int *pattern_symb, const lu_int *begin,
+    const lu_int *end, const lu_int *index, const double *value,
+    const double *pivot, const double droptol, double *lhs, lu_int *pattern,
+    lu_int *flops);
+
+lu_int lu_update(struct lu *this, double xtbl);
+
+double lu_condest(
+    lu_int m, const lu_int *Ubegin, const lu_int *Ui, const double *Ux,
+    const double *pivot, const lu_int *perm, int upper, double *work,
+    double *norm, double *norminv);
+
+double lu_normest(
+    lu_int m, const lu_int *Ubegin, const lu_int *Ui, const double *Ux,
+    const double *pivot, const lu_int *perm, int upper, double *work);
+
+void lu_matrix_norm(
+    struct lu *this, const lu_int *Bbegin, const lu_int *Bend, const lu_int *Bi,
+    const double *Bx);
+
+void lu_residual_test(
+    struct lu *this, const lu_int *Bbegin, const lu_int *Bend, const lu_int *Bi,
+    const double *Bx);
+
+#endif

casadi/include/highs/ipm/basiclu/lu_list.h

@@ -0,0 +1,168 @@
+/*
+ * lu_list.h
+ *
+ * Copyright (C) 2016-2018  ERGO-Code
+ *
+ * Implementation of doubly linked lists (see [1] section 5.5)
+ *
+ * Maintain nelem elements in nlist doubly linked lists. Each element can belong
+ * to zero or one list at a time.
+ *
+ * The implementation uses arrays
+ *
+ *  flink[0..nelem+nlist-1],
+ *  blink[0..nelem+nlist-1].
+ *
+ * In each array, the leading nelem entries store links, the trailing nlist
+ * entries store heads. That is, for 0 <= i < nelem and 0 <= j < nlist:
+ *
+ *  flink[i]        next element in the list containing element i
+ *  blink[i]        previous element in the list containing element i
+ *  flink[nelem+j]  first element in list j
+ *  blink[nelem+j]  last element in list j
+ *
+ * The forward link of the last element in a list points to its flink-head. The
+ * backward link of the first element in a list points to its blink-head. For
+ * empty lists the heads point to themselves. When an element is not in any list
+ * its links point to itself.
+ *
+ * Optionally the quantity min_list >= 1 can be updated such that lists
+ * 1..min_list-1 are empty. Notice that list 0 is not covered by min_list.
+ *
+ * [1] Istvan Maros, Computational Techniques of the Simplex Method
+ *
+ * Methods:
+ *
+ *  lu_list_init
+ *  lu_list_add
+ *  lu_list_remove
+ *  lu_list_move
+ *  lu_list_swap
+ *
+ * The methods are defined in this header file as static inline. This header
+ * file must be included after lu_def.h so that lu_int is defined.
+ *
+ */
+
+/* ==========================================================================
+ * lu_list_init
+ *
+ * Initialize all lists to empty.
+ * ========================================================================== */
+
+static inline void lu_list_init(
+    lu_int *flink, lu_int *blink, lu_int nelem, lu_int nlist, lu_int *min_list)
+{
+    lu_int i;
+    for (i = 0; i < nelem+nlist; i++) flink[i] = blink[i] = i;
+    if (min_list)
+        *min_list = MAX(1, nlist);
+}
+
+
+/* ==========================================================================
+ * lu_list_add
+ *
+ * Add element @elem to list @list. @elem must not be in any list already.
+ * If list > 0 and min_list != NULL, update *min_list = min(*min_list, list).
+ * ========================================================================== */
+
+static inline void lu_list_add(
+    lu_int elem, lu_int list, lu_int *flink, lu_int *blink, lu_int nelem,
+    lu_int *min_list)
+{
+    lu_int temp;
+    assert(flink[elem] == elem);
+    assert(blink[elem] == elem);
+    /* append elem to the end of list */
+    temp = blink[nelem+list];
+    blink[nelem+list] = elem;
+    blink[elem] = temp;
+    flink[temp] = elem;
+    flink[elem] = nelem+list;
+    if (list > 0 && min_list && list < *min_list)
+        *min_list = list;
+}
+
+
+/* ==========================================================================
+ * lu_list_remove
+ *
+ * Remove element @elem from its list. If @elem was not in a list before,
+ * then do nothing.
+ * ========================================================================== */
+
+static inline void lu_list_remove(
+    lu_int *flink, lu_int *blink, lu_int elem)
+{
+    flink[blink[elem]] = flink[elem];
+    blink[flink[elem]] = blink[elem];
+    flink[elem] = elem;
+    blink[elem] = elem;
+}
+
+
+/* ==========================================================================
+ * lu_list_move
+ *
+ * Remove element @elem from its list (if in a list) and add it to list @list.
+ * ========================================================================== */
+
+static inline void lu_list_move(
+    lu_int elem, lu_int list, lu_int *flink, lu_int *blink, lu_int nelem,
+    lu_int *min_list)
+{
+    lu_list_remove(flink, blink, elem);
+    lu_list_add(elem, list, flink, blink, nelem, min_list);
+}
+
+
+/* ==========================================================================
+ * lu_list_swap
+ *
+ * Swap elements @e1 and @e2, which both must be in a list. If @e1 and @e2
+ * are in the same list, then their positions are swapped. If they are in
+ * different lists, then each is moved to the other's list.
+ * ========================================================================== */
+
+static inline void lu_list_swap(
+    lu_int *flink, lu_int *blink, const lu_int e1, const lu_int e2)
+{
+    const lu_int e1next = flink[e1];
+    const lu_int e2next = flink[e2];
+    const lu_int e1prev = blink[e1];
+    const lu_int e2prev = blink[e2];
+
+    assert(e1next != e1);       /* must be in a list */
+    assert(e2next != e2);
+
+    if (e1next == e2)
+    {
+        flink[e2] = e1;
+        blink[e1] = e2;
+        flink[e1prev] = e2;
+        blink[e2] = e1prev;
+        flink[e1] = e2next;
+        blink[e2next] = e1;
+    }
+    else if (e2next == e1)
+    {
+        flink[e1] = e2;
+        blink[e2] = e1;
+        flink[e2] = e1next;
+        blink[e1next] = e2;
+        flink[e2prev] = e1;
+        blink[e1] = e2prev;
+    }
+    else
+    {
+        flink[e2] = e1next;
+        blink[e1next] = e2;
+        flink[e2prev] = e1;
+        blink[e1] = e2prev;
+        flink[e1prev] = e2;
+        blink[e2] = e1prev;
+        flink[e1] = e2next;
+        blink[e2next] = e1;
+    }
+}

casadi/include/highs/ipm/ipx/basiclu_kernel.h

@@ -0,0 +1,20 @@
+#ifndef IPX_BASICLU_KERNEL_H_
+#define IPX_BASICLU_KERNEL_H_
+
+#include "ipm/ipx/lu_factorization.h"
+
+namespace ipx {
+
+class BasicLuKernel : public LuFactorization {
+private:
+    void _Factorize(Int dim, const Int* Bbegin, const Int* Bend,
+                    const Int* Bi, const double* Bx, double pivottol,
+                    bool strict_abs_pivottol,
+                    SparseMatrix* L, SparseMatrix* U,
+                    std::vector<Int>* rowperm, std::vector<Int>* colperm,
+                    std::vector<Int>* dependent_cols) override;
+};
+
+}  // namespace ipx
+
+#endif  // IPX_BASICLU_KERNEL_H_

casadi/include/highs/ipm/ipx/basiclu_wrapper.h

@@ -0,0 +1,47 @@
+#ifndef IPX_BASICLU_WRAPPER_H_
+#define IPX_BASICLU_WRAPPER_H_
+
+#include "ipm/ipx/control.h"
+#include "ipm/ipx/lu_update.h"
+
+namespace ipx {
+
+class BasicLu : public LuUpdate {
+public:
+    BasicLu(const Control& control, Int dim);
+    ~BasicLu() = default;
+
+private:
+    Int _Factorize(const Int* Bbegin, const Int* Bend, const Int* Bi,
+                   const double* Bx, bool strict_abs_pivottol) override;
+    void _GetFactors(SparseMatrix* L, SparseMatrix* U, Int* rowperm,
+                     Int* colperm, std::vector<Int>* dependent_cols) override;
+    void _SolveDense(const Vector& rhs, Vector& lhs, char trans) override;
+    void _FtranForUpdate(Int nz, const Int* bi, const double* bx) override;
+    void _FtranForUpdate(Int nz, const Int* bi, const double* bx,
+                         IndexedVector& lhs) override;
+    void _BtranForUpdate(Int j) override;
+    void _BtranForUpdate(Int j, IndexedVector& lhs) override;
+    Int _Update(double pivot) override;
+    bool _NeedFreshFactorization() override;
+    double _fill_factor() const override;
+    double _pivottol() const override;
+    void _pivottol(double new_pivottol) override;
+
+    // Reallocates (Li,Lx), (Ui,Ux) and/or (Wi,Wx) as requested by BASICLU.
+    void Reallocate();
+
+    // When memory is reallocated, allocate for kReallocFactor*required amount.
+    static constexpr double kReallocFactor = 1.5;
+
+    const Control& control_;
+    std::vector<Int> istore_;
+    std::vector<double> xstore_;
+    std::vector<Int> Li_, Ui_, Wi_;
+    std::vector<double> Lx_, Ux_, Wx_;
+    double fill_factor_;
+};
+
+}  // namespace ipx
+
+#endif  // IPX_BASICLU_WRAPPER_H_