casadi 3.7.2__cp314-none-manylinux2014_i686.whl

casadi/include/highs/ipm/IpxWrapper.h

@@ -0,0 +1,70 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file ipm/IpxWrapper.h
+ * @brief
+ */
+#ifndef IPM_IPX_WRAPPER_H_
+#define IPM_IPX_WRAPPER_H_
+
+#include <algorithm>
+#include <cassert>
+
+#include "ipm/IpxSolution.h"
+#include "ipm/ipx/ipx_status.h"
+#include "ipm/ipx/lp_solver.h"
+#include "lp_data/HighsSolution.h"
+
+HighsStatus solveLpIpx(HighsLpSolverObject& solver_object);
+
+HighsStatus solveLpIpx(const HighsOptions& options, HighsTimer& timer,
+                       const HighsLp& lp, HighsBasis& highs_basis,
+                       HighsSolution& highs_solution,
+                       HighsModelStatus& model_status, HighsInfo& highs_info,
+                       HighsCallback& callback);
+
+void fillInIpxData(const HighsLp& lp, ipx::Int& num_col, ipx::Int& num_row,
+                   double& offset, std::vector<double>& obj,
+                   std::vector<double>& col_lb, std::vector<double>& col_ub,
+                   std::vector<ipx::Int>& Ap, std::vector<ipx::Int>& Ai,
+                   std::vector<double>& Ax, std::vector<double>& rhs,
+                   std::vector<char>& constraint_type);
+
+HighsStatus reportIpxSolveStatus(const HighsOptions& options,
+                                 const ipx::Int solve_status,
+                                 const ipx::Int error_flag);
+
+HighsStatus reportIpxIpmCrossoverStatus(const HighsOptions& options,
+                                        const ipx::Int status,
+                                        const bool ipm_status);
+
+bool ipxStatusError(const bool status_error, const HighsOptions& options,
+                    std::string message, const int value = -1);
+
+bool illegalIpxSolvedStatus(const ipx::Info& ipx_info,
+                            const HighsOptions& options);
+
+bool illegalIpxStoppedIpmStatus(const ipx::Info& ipx_info,
+                                const HighsOptions& options);
+
+bool illegalIpxStoppedCrossoverStatus(const ipx::Info& ipx_info,
+                                      const HighsOptions& options);
+
+void reportIpmNoProgress(const HighsOptions& options,
+                         const ipx::Info& ipx_info);
+
+void getHighsNonVertexSolution(const HighsOptions& options, const HighsLp& lp,
+                               const ipx::Int num_col, const ipx::Int num_row,
+                               const std::vector<double>& rhs,
+                               const std::vector<char>& constraint_type,
+                               const ipx::LpSolver& lps,
+                               const HighsModelStatus model_status,
+                               HighsSolution& highs_solution);
+
+void reportSolveData(const HighsLogOptions& log_options,
+                     const ipx::Info& ipx_info);
+#endif

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

@@ -0,0 +1,161 @@
+#ifndef _BASICLU_H
+#define _BASICLU_H
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+/*
+ * BASICLU integer type
+ *
+ * All integers in BASICLU code are of type lu_int, which must be a signed
+ * integer type. It is required that all integer values arising in the
+ * computation can be stored in double variables and converted back to lu_int
+ * without altering their value.
+ *
+ * LU_INT_MAX must be the maximum value of a variable of type lu_int.
+ *
+ * The default is 64 bit integers to make the code easily callable from Julia.
+ * int64_t is optional in the C99 standard, but available on most systems.
+ *
+ */
+#include <limits.h>
+#include <stdint.h>
+#include "HConfig.h"
+  
+#ifdef HIGHSINT64
+typedef int64_t lu_int;
+#define LU_INT_MAX INT64_MAX
+#else
+typedef int lu_int;
+#define LU_INT_MAX INT_MAX
+#endif
+/* #include <limits.h> */
+/* typedef long lu_int; */
+/* #define LU_INT_MAX LONG_MAX */
+
+/* size of istore */
+#define BASICLU_SIZE_ISTORE_1 1024
+#define BASICLU_SIZE_ISTORE_M 21
+
+/* size of xstore */
+#define BASICLU_SIZE_XSTORE_1 1024
+#define BASICLU_SIZE_XSTORE_M 4
+
+/* ------------ */
+/* status codes */
+/* ------------ */
+
+#define BASICLU_OK 0
+#define BASICLU_REALLOCATE 1
+#define BASICLU_WARNING_singular_matrix 2
+#define BASICLU_ERROR_invalid_store (-1)
+#define BASICLU_ERROR_invalid_call (-2)
+#define BASICLU_ERROR_argument_missing (-3)
+#define BASICLU_ERROR_invalid_argument (-4)
+#define BASICLU_ERROR_maximum_updates (-5)
+#define BASICLU_ERROR_singular_update (-6)
+
+#define BASICLU_ERROR_invalid_object (-8)
+#define BASICLU_ERROR_out_of_memory (-9)
+
+/* ------------------------ */
+/* public entries in xstore */
+/* ------------------------ */
+
+/* user parameters */
+#define BASICLU_MEMORYL 1
+#define BASICLU_MEMORYU 2
+#define BASICLU_MEMORYW 3
+#define BASICLU_DROP_TOLERANCE 4
+#define BASICLU_ABS_PIVOT_TOLERANCE 5
+#define BASICLU_REL_PIVOT_TOLERANCE 6
+#define BASICLU_BIAS_NONZEROS 7
+#define BASICLU_MAXN_SEARCH_PIVOT 8
+#define BASICLU_PAD 9
+#define BASICLU_STRETCH 10
+#define BASICLU_COMPRESSION_THRESHOLD 11
+#define BASICLU_SPARSE_THRESHOLD 12
+#define BASICLU_REMOVE_COLUMNS 13
+#define BASICLU_SEARCH_ROWS 14
+
+/* user readable */
+#define BASICLU_DIM 64
+#define BASICLU_STATUS 65
+#define BASICLU_ADD_MEMORYL 66
+#define BASICLU_ADD_MEMORYU 67
+#define BASICLU_ADD_MEMORYW 68
+
+#define BASICLU_NUPDATE 70
+#define BASICLU_NFORREST 71
+#define BASICLU_NFACTORIZE 72
+#define BASICLU_NUPDATE_TOTAL 73
+#define BASICLU_NFORREST_TOTAL 74
+#define BASICLU_NSYMPERM_TOTAL 75
+#define BASICLU_LNZ 76
+#define BASICLU_UNZ 77
+#define BASICLU_RNZ 78
+#define BASICLU_MIN_PIVOT 79
+#define BASICLU_MAX_PIVOT 80
+#define BASICLU_UPDATE_COST 81
+#define BASICLU_TIME_FACTORIZE 82
+#define BASICLU_TIME_SOLVE 83
+#define BASICLU_TIME_UPDATE 84
+#define BASICLU_TIME_FACTORIZE_TOTAL 85
+#define BASICLU_TIME_SOLVE_TOTAL 86
+#define BASICLU_TIME_UPDATE_TOTAL 87
+#define BASICLU_LFLOPS 88
+#define BASICLU_UFLOPS 89
+#define BASICLU_RFLOPS 90
+#define BASICLU_CONDEST_L 91
+#define BASICLU_CONDEST_U 92
+#define BASICLU_MAX_ETA 93
+#define BASICLU_NORM_L 94
+#define BASICLU_NORM_U 95
+#define BASICLU_NORMEST_LINV 96
+#define BASICLU_NORMEST_UINV 97
+#define BASICLU_MATRIX_ONENORM 98
+#define BASICLU_MATRIX_INFNORM 99
+#define BASICLU_RESIDUAL_TEST 111
+
+#define BASICLU_MATRIX_NZ 100
+#define BASICLU_RANK 101
+#define BASICLU_BUMP_SIZE 102
+#define BASICLU_BUMP_NZ 103
+#define BASICLU_NSEARCH_PIVOT 104
+#define BASICLU_NEXPAND 105
+#define BASICLU_NGARBAGE 106
+#define BASICLU_FACTOR_FLOPS 107
+#define BASICLU_TIME_SINGLETONS 108
+#define BASICLU_TIME_SEARCH_PIVOT 109
+#define BASICLU_TIME_ELIM_PIVOT 110
+
+#define BASICLU_PIVOT_ERROR 120
+
+/* ----------------------- */
+/* user callable functions */
+/* ----------------------- */
+
+#include "ipm/basiclu/basiclu_initialize.h"
+#include "ipm/basiclu/basiclu_factorize.h"
+#include "ipm/basiclu/basiclu_get_factors.h"
+#include "ipm/basiclu/basiclu_solve_dense.h"
+#include "ipm/basiclu/basiclu_solve_sparse.h"
+#include "ipm/basiclu/basiclu_solve_for_update.h"
+#include "ipm/basiclu/basiclu_update.h"
+
+#include "ipm/basiclu/basiclu_object.h"
+#include "ipm/basiclu/basiclu_obj_initialize.h"
+#include "ipm/basiclu/basiclu_obj_factorize.h"
+#include "ipm/basiclu/basiclu_obj_get_factors.h"
+#include "ipm/basiclu/basiclu_obj_solve_dense.h"
+#include "ipm/basiclu/basiclu_obj_solve_sparse.h"
+#include "ipm/basiclu/basiclu_obj_solve_for_update.h"
+#include "ipm/basiclu/basiclu_obj_update.h"
+#include "ipm/basiclu/basiclu_obj_free.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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

@@ -0,0 +1,247 @@
+lu_int basiclu_factorize
+(
+    lu_int istore[],
+    double xstore[],
+    lu_int Li[],
+    double Lx[],
+    lu_int Ui[],
+    double Ux[],
+    lu_int Wi[],
+    double Wx[],
+    const lu_int Bbegin[],
+    const lu_int Bend[],
+    const lu_int Bi[],
+    const double Bx[],
+    lu_int c0ntinue
+);
+
+/*
+Purpose:
+
+    Factorize the matrix B into its LU factors. Choose pivot elements by a
+    Markowitz criterion subject to columnwise threshold pivoting (the pivot may
+    not be smaller than a factor of the largest entry in its column).
+
+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[]
+
+        BASICLU instance. The instance determines the dimension of matrix B
+        (stored in xstore[BASICLU_DIM]).
+
+    lu_int Li[]
+    double Lx[]
+    lu_int Ui[]
+    double Ux[]
+    lu_int Wi[]
+    double Wx[]
+
+        Arrays used for workspace during the factorization and to store the
+        final factors. They must be allocated by the user and their length
+        must be provided as 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
+
+        When the allocated length is insufficient to complete the factorization,
+        basiclu_factorize() returns to the caller for reallocation (see
+        xstore[BASICLU_STATUS] below). A successful factorization requires at
+        least nnz(B) length for each of the arrays.
+
+    const lu_int Bbegin[]
+    const lu_int Bend[]
+    const lu_int Bi[]
+    const double Bx[]
+
+        Matrix B in packed column form. Bi and Bx are arrays of row indices
+        and nonzero values. Column j of matrix B contains elements
+
+            Bi[Bbegin[j] .. Bend[j]-1], Bx[Bbegin[j] .. Bend[j]-1].
+
+        The columns must not contain duplicate row indices. The arrays Bbegin
+        and Bend may overlap, so that it is valid to pass Bp, Bp+1 for a matrix
+        stored in compressed column form (Bp, Bi, Bx).
+
+    lu_int c0ntinue
+
+        zero to start a new factorization; nonzero to continue a factorization
+        after reallocation.
+
+Parameters:
+
+    xstore[BASICLU_DROP_TOLERANCE]
+
+        Nonzeros which magnitude is less than or equal to the drop tolerance can
+        be removed after each pivot step. They are guaranteed removed at the end
+        of the factorization. Default: 1e-20
+
+    xstore[BASICLU_ABS_PIVOT_TOLERANCE]
+
+        A pivot element must be nonzero and in absolute value must be greater
+        than or equal to xstore[BASICLU_ABS_PIVOT_TOLERANCE]. Default: 1e-14
+
+    xstore[BASICLU_REL_PIVOT_TOLERANCE]
+
+        A pivot element must be (in absolute value) greater than or equal to
+        xstore[BASICLU_REL_PIVOT_TOLERANCE] times the largest entry in its
+        column. A value greater than or equal to 1.0 is treated as 1.0 and
+        enforces partial pivoting. Default: 0.1
+
+    xstore[BASICLU_BIAS_NONZEROS]
+
+        When this value is greater than or equal to zero, the pivot choice
+        attempts to keep L sparse, putting entries into U when possible.
+        When this value is less than zero, the pivot choice attempts to keep U
+        sparse, putting entries into L when possible. Default: 1
+
+    xstore[BASICLU_MAXN_SEARCH_PIVOT]
+
+        The Markowitz search is terminated after searching
+        xstore[BASICLU_MAXN_SERACH_PIVOT] rows or columns if a numerically
+        stable pivot element has been found. Default: 3
+
+    xstore[BASICLU_SEARCH_ROWS]
+
+        If xstore[BASICLU_SEARCH_ROWS] is zero, then the Markowitz search only
+        scans columns. If nonzero, then both columns and rows are searched in
+        increasing order of number of entries. Default: 1
+
+    xstore[BASICLU_PAD]
+    xstore[BASICLU_STRETCH]
+
+        When a row or column cannot be updated by the pivot operation in place,
+        it is appended to the end of the workspace. For a row or column with nz
+        elements, xstore[BASICLU_PAD] + nz * xstore[BASICLU_STRETCH] elements
+        extra space are added for later fill-in.
+        Default: xstore[BASICLU_PAD] = 4, xstore[BASICLU_STRETCH] = 0.3
+
+    xstore[BASICLU_REMOVE_COLUMNS]
+
+        This parameter is present for compatibility to previous versions but has
+        no effect. If during factorization the maximum entry of a column of the
+        active submatrix becomes zero or less than
+        xstore[BASICLU_ABS_PIVOT_TOLERANCE], then that column is immediately
+        removed without choosing a pivot.
+
+Info:
+
+    xstore[BASICLU_STATUS]: status code.
+
+        BASICLU_OK
+
+            The factorization has successfully completed.
+
+        BASICLU_WARNING_singular_matrix
+
+            The factorization did xstore[BASICLU_RANK] < xstore[BASICLU_DIM]
+            pivot steps. The remaining elements in the active submatrix are zero
+            or less than xstore[BASICLU_ABS_PIVOT_TOLERANCE]. The factors have
+            been augmented by unit columns to form a square matrix. See
+            basiclu_get_factors() on how to get the indices of linearly
+            dependent columns.
+
+        BASICLU_ERROR_argument_missing
+
+            One or more of the pointer/array arguments are NULL.
+
+        BASICLU_ERROR_invalid_call
+
+            c0ntinue is nonzero, but the factorization was not started before.
+
+        BASICLU_ERROR_invalid_argument
+
+            The matrix is invalid (a column has a negative number of entries,
+            a row index is out of range, or a column has duplicate entries).
+
+        BASICLU_REALLOCATE
+
+            Factorization requires more memory in Li,Lx and/or Ui,Ux and/or
+            Wi,Wx. The number of additional elements in each of the array pairs
+            required for the next pivot operation is given by:
+
+                xstore[BASICLU_ADD_MEMORYL] >= 0
+                xstore[BASICLU_ADD_MEMORYU] >= 0
+                xstore[BASICLU_ADD_MEMORYW] >= 0
+
+            The user must reallocate the arrays for which additional memory is
+            required. It is recommended to reallocate for the requested number
+            of additional elements plus some extra space (e.g. 0.5 times the
+            current array length). The new array lengths must be provided in
+
+                xstore[BASICLU_MEMORYL]: length of Li and Lx
+                xstore[BASICLU_MEMORYU]: length of Ui and Ux
+                xstore[BASICLU_MEMORYW]: length of Wi and Wx
+
+            basiclu_factorize() can be called again with c0ntinue not equal to
+            zero to continue the factorization.
+
+    xstore[BASICLU_MATRIX_NZ] number of nonzeros in B
+
+    xstore[BASICLU_MATRIX_ONENORM]
+    xstore[BASICLU_MATRIX_INFNORM] 1-norm and inf-norm of the input matrix
+                                   after replacing dependent columns by unit
+                                   columns.
+
+    xstore[BASICLU_RANK] number of pivot steps performed
+
+    xstore[BASICLU_BUMP_SIZE] dimension of matrix after removing singletons
+
+    xstore[BASICLU_BUMP_NZ] # nonzeros in matrix after removing singletons
+
+    xstore[BASICLU_NSEARCH_PIVOT] total # columns/rows searched for pivots
+
+    xstore[BASICLU_NEXPAND] # columns/rows which had to be appended to the end
+                            of the workspace for the rank-1 update
+
+    xstore[BASICLU_NGARBAGE] # garbage collections
+
+    xstore[BASICLU_FACTOR_FLOPS] # floating point operations performed,
+                                 counting multiply-add as one flop
+
+    xstore[BASICLU_TIME_SINGLETONS] wall clock time for removing the initial
+                                    triangular factors
+
+    xstore[BASICLU_TIME_SEARCH_PIVOT] wall clock time for Markowitz search
+
+    xstore[BASIClU_TIME_ELIM_PIVOT] wall clock time for pivot elimination
+
+    xstore[BASICLU_RESIDUAL_TEST]
+
+            An estimate for numerical stability of the factorization.
+            xstore[BASICLU_RESIDUAL_TEST] is the maximum of the scaled residuals
+
+              ||b-Bx|| / (||b|| + ||B||*||x||)
+
+            and
+
+              ||c-B'y|| / (||c|| + ||B'||*||y||),
+
+            where x=B\b and y=B'\c are computed from the LU factors, b and c
+            have components +/-1 that are chosen to make x respectively y large,
+            and ||.|| is the 1-norm. Here B is the input matrix after replacing
+            dependent columns by unit columns.
+
+            If xstore[BASICLU_RESIDUAL_TEST] > 1e-12, say, the factorization is
+            numerically unstable. (This is independent of the condition number
+            of B.) In this case tightening the relative pivot tolerance and
+            refactorizing is appropriate.
+
+    xstore[BASICLU_NORM_L]
+    xstore[BASICLU_NORM_U] 1-norm of L and U.
+
+    xstore[BASICLU_NORMEST_LINV]
+    xstore[BASICLU_NORMEST_UINV] Estimated 1-norm of L^{-1} and U^{-1},
+                                 computed by the LINPACK algorithm.
+
+    xstore[BASICLU_CONDEST_L]
+    xstore[BASICLU_CONDEST_U] Estimated 1-norm condition number of L and U.
+*/

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

@@ -0,0 +1,108 @@
+lu_int basiclu_get_factors
+(
+    lu_int istore[],
+    double xstore[],
+    lu_int Li[],
+    double Lx[],
+    lu_int Ui[],
+    double Ux[],
+    lu_int Wi[],
+    double Wx[],
+    lu_int rowperm[],
+    lu_int colperm[],
+    lu_int Lcolptr[],
+    lu_int Lrowidx[],
+    double Lvalue[],
+    lu_int Ucolptr[],
+    lu_int Urowidx[],
+    double Uvalue[]
+);
+
+/*
+Purpose:
+
+    Extract the row and column permutation and the LU factors. This routine can
+    be used only after basiclu_factorize() has completed and before a call to
+    basiclu_update(). At that point the factorized form of matrix B is
+
+        B[rowperm,colperm] = L*U,
+
+    where L is unit lower triangular and U is upper triangular. If the
+    factorization was singular (rank < m), then columns colperm[rank..m-1]
+    of B have been replaced by unit columns with entry 1 in position
+    rowperm[rank..m-1].
+
+    basiclu_get_factors() is intended when the user needs direct access to the
+    matrix factors. It is not required to solve linear systems with the factors
+    (see basiclu_solve_dense() and basiclu_solve_sparse() instead).
+
+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[]
+
+        The BASICLU instance after basiclu_factorize() has completed.
+
+    lu_int rowperm[m]
+
+        Returns the row permutation. If the row permutation is not required,
+        then NULL can be passed (this is not an error).
+
+    lu_int colperm[m]
+
+        Returns the column permutation. If the column permutation is not
+        required, then NULL can be passed (this is not an error).
+
+    lu_int Lcolptr[m+1]
+    lu_int Lrowidx[m+Lnz]
+    double Lvalue[m+Lnz], where Lnz = xstore[BASICLU_LNZ]
+
+        If all three arguments are not NULL, then they are filled with L in
+        compressed column form. The indices in each column are sorted with the
+        unit diagonal element at the front.
+
+        If any of the three arguments is NULL, then L is not returned
+        (this is not an error).
+
+    lu_int Ucolptr[m+1]
+    lu_int Urowidx[m+Unz]
+    double Uvalue[m+Unz], where Unz = xstore[BASICLU_UNZ]
+
+        If all three arguments are not NULL, then they are filled with U in
+        compressed column form. The indices in each column are sorted with the
+        diagonal element at the end.
+
+        If any of the three arguments is NULL, then U is not returned
+        (this is not an error).
+
+Info:
+
+    xstore[BASICLU_STATUS]: status code.
+
+        BASICLU_OK
+
+            The requested quantities have been returned successfully.
+
+        BASICLU_ERROR_argument_missing
+
+            One or more of the mandatory pointer/array arguments are NULL.
+
+        BASICLU_ERROR_invalid_call
+
+            The BASICLU instance does not hold a fresh factorization (either
+            basiclu_factorize() has not completed or basiclu_update() has been
+            called in the meanwhile).
+*/

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

@@ -0,0 +1,119 @@
+lu_int basiclu_initialize
+(
+    lu_int m,
+    lu_int istore[],
+    double xstore[]
+);
+
+/*
+Purpose:
+
+    Initialize istore, xstore to a BASICLU instance. Set parameters to defaults
+    and reset counters. The initialization fixes the dimension of matrices
+    which can be processed by this instance.
+
+    This routine must be called once before passing istore, xstore to any other
+    basiclu_ routine.
+
+Return:
+
+    BASICLU_OK
+
+        m, istore, xstore were valid arguments. Only in this case are istore,
+        xstore initialized.
+
+    BASICLU_ERROR_argument_missing
+
+        istore or xstore is NULL.
+
+    BASICLU_ERROR_invalid_argument
+
+        m is less than or equal to zero.
+
+Arguments:
+
+    lu_int m
+
+        The dimension of matrices which can be processed. m > 0.
+
+    lu_int istore[]
+    double xstore[]
+
+        Fixed size arrays. These must be allocated by the user as follows:
+
+          length of istore: BASICLU_SIZE_ISTORE_1 + BASICLU_SIZE_ISTORE_M * m
+          length of xstore: BASICLU_SIZE_XSTORE_1 + BASICLU_SIZE_XSTORE_M * m
+
+Info:
+
+    After initialization, the following entries of xstore are maintained
+    throughout by all basiclu_ routines:
+
+    xstore[BASICLU_DIM] Matrix dimension (constant).
+
+    xstore[BASICLU_NUPDATE] Number of updates since last factorization. This is
+                            the sum of Forrest-Tomlin updates and permutation
+                            updates.
+
+    xstore[BASICLU_NFORREST] Number of Forrest-Tomlin updates since last
+                             factorization. The upper limit on Forrest-Tomlin
+                             updates before refactorization is m, but that is
+                             far too much for performance reasons and numerical
+                             stability.
+
+    xstore[BASICLU_NFACTORIZE] Number of factorizations since initialization.
+
+    xstore[BASICLU_NUPDATE_TOTAL] Number of updates since initialization.
+
+    xstore[BASICLU_NFORREST_TOTAL] Number of Forrest-Tomlin updates since
+                                   initialization.
+
+    xstore[BASICLU_NSYMPERM_TOTAL] Number of symmetric permutation updates since
+                                   initialization. A permutation update is
+                                   "symmetric" if the row and column
+                                   permutation can be updated symmetrically.
+
+    xstore[BASICLU_LNZ] Number of nonzeros in L excluding diagonal elements
+                        (not changed by updates).
+
+    xstore[BASICLU_UNZ] Number of nonzeros in U excluding diagonal elements
+                        (changed by updates).
+
+    xstore[BASICLU_RNZ] Number of nonzeros in update ETA vectors excluding
+                        diagonal elements (zero after factorization, increased
+                        by Forrest-Tomlin updates).
+
+    xstore[BASICLU_MIN_PIVOT]
+    xstore[BASICLU_MAX_PIVOT] After factorization these are the smallest and
+                              largest pivot element. xstore[BASICLU_MIN_PIVOT]
+                              is replaced when a smaller pivot occurs in an
+                              update. xstore[BASICLU_MAX_PIVOT] is replaced when
+                              a larger pivot occurs in an update.
+
+    xstore[BASICLU_UPDATE_COST] Deterministic measure of solve/update cost
+                                compared to cost of last factorization. This
+                                value is zero after factorization and
+                                monotonically increases with solves/updates.
+                                When xstore[BASICLU_UPDATE_COST] > 1.0, then
+                                a refactorization is good for performance.
+
+    xstore[BASICLU_TIME_FACTORIZE] Wall clock time for last factorization.
+
+    xstore[BASICLU_TIME_SOLVE] Wall clock time for all calls to
+                               basiclu_solve_sparse and basiclu_solve_for_update
+                               since last factorization.
+
+    xstore[BASICLU_TIME_UPDATE] Wall clock time for all calls to basiclu_update
+                                since last factorization.
+
+    xstore[BASICLU_TIME_FACTORIZE_TOTAL]
+    xstore[BASICLU_TIME_SOLVE_TOTAL]
+    xstore[BASICLU_TIME_UPDATE_TOTAL] Analogous to above, but summing up all
+                                      calls since initialization.
+
+    xstore[BASICLU_LFLOPS]
+    xstore[BASICLU_UFLOPS]
+    xstore[BASICLU_RFLOPS] Number of flops for operations with L, U and update
+                           ETA vectors in calls to basiclu_solve_sparse and
+                           basiclu_solve_for_update since last factorization.
+*/