casadi 3.6.5__cp312-none-manylinux2014_i686.whl → 3.6.7__cp312-none-manylinux2014_i686.whl

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.
+*/

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

@@ -0,0 +1,34 @@
+lu_int basiclu_obj_factorize
+(
+    struct basiclu_object *obj,
+    const lu_int *Bbegin,
+    const lu_int *Bend,
+    const lu_int *Bi,
+    const double *Bx
+);
+
+/*
+Purpose:
+
+    Call basiclu_factorize() on a BASICLU object.
+
+Return:
+
+    BASICLU_ERROR_invalid_object
+
+        obj is NULL or initialized to a null object.
+
+    BASICLU_ERROR_out_of_memory
+
+        reallocation failed because of insufficient memory.
+
+    Other return codes are passed through from basiclu_factorize().
+
+Arguments:
+
+    struct basiclu_object *obj
+
+        Pointer to an initialized BASICLU object.
+
+    The other arguments are passed through to basiclu_factorize().
+*/

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

@@ -0,0 +1,19 @@
+void basiclu_obj_free
+(
+    struct basiclu_object *obj
+);
+
+/*
+Purpose:
+
+    Free memory allocated from a BASICLU object. The object must have been
+    initialized before by basiclu_obj_initialize(). Subsequent calls to
+    basiclu_obj_free() will do nothing.
+
+Arguments:
+
+    struct basiclu_object *obj
+
+        Pointer to the object which memory is to be freed. When obj is NULL,
+        then the routine does nothing.
+*/

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

@@ -0,0 +1,34 @@
+lu_int basiclu_obj_get_factors
+(
+    struct basiclu_object *obj,
+    lu_int rowperm[],
+    lu_int colperm[],
+    lu_int Lcolptr[],
+    lu_int Lrowidx[],
+    double Lvalue[],
+    lu_int Ucolptr[],
+    lu_int Urowidx[],
+    double Uvalue[]
+);
+
+/*
+Purpose:
+
+    Call basiclu_get_factors() on a BASICLU object.
+
+Return:
+
+    BASICLU_ERROR_invalid_object
+
+        obj is NULL or initialized to a null object.
+
+    Other return codes are passed through from basiclu_get_factors().
+
+Arguments:
+
+    struct basiclu_object *obj
+
+        Pointer to an initialized BASICLU object.
+
+    The other arguments are passed through to basiclu_get_factors().
+*/

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

@@ -0,0 +1,46 @@
+lu_int basiclu_obj_initialize
+(
+    struct basiclu_object *obj,
+    lu_int m
+);
+
+/*
+Purpose:
+
+    Initialize a BASICLU object. When m is positive, then *obj is initialized to
+    process matrices of dimension m. When m is zero, then *obj is initialized to
+    a "null" object, which cannot be used for factorization, but can be passed
+    to basiclu_obj_free().
+
+    This routine must be called once before passing obj to any other
+    basiclu_obj_ routine. When obj is initialized to a null object, then the
+    routine can be called again to reinitialize obj.
+
+Return:
+
+    BASICLU_OK
+
+        *obj successfully initialized.
+
+    BASICLU_ERROR_argument_missing
+
+        obj is NULL.
+
+    BASICLU_ERROR_invalid_argument
+
+        m is negative.
+
+    BASICLU_ERROR_out_of_memory
+
+        insufficient memory to initialize object.
+
+Arguments:
+
+    struct basiclu_object *obj
+
+        Pointer to the object to be initialized.
+
+    lu_int m
+
+        The dimension of matrices which can be processed, or 0.
+*/

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

@@ -0,0 +1,29 @@
+lu_int basiclu_obj_solve_dense
+(
+    struct basiclu_object *obj,
+    const double rhs[],
+    double lhs[],
+    char trans
+);
+
+/*
+Purpose:
+
+    Call basiclu_solve_dense() on a BASICLU object.
+
+Return:
+
+    BASICLU_ERROR_invalid_object
+
+        obj is NULL or initialized to a null object.
+
+    Other return codes are passed through from basiclu_solve_dense().
+
+Arguments:
+
+    struct basiclu_object *obj
+
+        Pointer to an initialized BASICLU object.
+
+    The other arguments are passed through to basiclu_solve_dense().
+*/

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

@@ -0,0 +1,42 @@
+lu_int basiclu_obj_solve_for_update
+(
+    struct basiclu_object *obj,
+    lu_int nzrhs,
+    const lu_int irhs[],
+    const double xrhs[],
+    char trans,
+    lu_int want_solution
+);
+
+/*
+Purpose:
+
+    Call basiclu_solve_for_update() on a BASICLU object. On success, if the
+    solution was requested, it is provided in obj->lhs and the nonzero pattern
+    is stored in obj->ilhs[0..obj->nzlhs-1].
+
+Return:
+
+    BASICLU_ERROR_invalid_object
+
+        obj is NULL or initialized to a null object.
+
+    BASICLU_ERROR_out_of_memory
+
+        reallocation failed because of insufficient memory.
+
+    Other return codes are passed through from basiclu_solve_for_update().
+
+Arguments:
+
+    struct basiclu_object *obj
+
+        Pointer to an initialized BASICLU object.
+
+    lu_int want_solution
+
+        Nonzero to compute the solution to the linear system,
+        zero to only prepare the update.
+
+    The other arguments are passed through to basiclu_solve_for_update().
+*/

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

@@ -0,0 +1,32 @@
+lu_int basiclu_obj_solve_sparse
+(
+    struct basiclu_object *obj,
+    lu_int nzrhs,
+    const lu_int irhs[],
+    const double xrhs[],
+    char trans
+);
+
+/*
+Purpose:
+
+    Call basiclu_solve_sparse() on a BASICLU object. On success, the solution
+    is provided in obj->lhs and the nonzero pattern is stored in
+    obj->ilhs[0..obj->nzlhs-1].
+
+Return:
+
+    BASICLU_ERROR_invalid_object
+
+        obj is NULL or initialized to a null object.
+
+    Other return codes are passed through from basiclu_solve_sparse().
+
+Arguments:
+
+    struct basiclu_object *obj
+
+        Pointer to an initialized BASICLU object.
+
+    The other arguments are passed through to basiclu_solve_sparse().
+*/

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

@@ -0,0 +1,31 @@
+lu_int basiclu_obj_update
+(
+    struct basiclu_object *obj,
+    double xtbl
+);
+
+/*
+Purpose:
+
+    Call basiclu_update() on a BASICLU object.
+
+Return:
+
+    BASICLU_ERROR_invalid_object
+
+        obj is NULL or initialized to a null object.
+
+    BASICLU_ERROR_out_of_memory
+
+        reallocation failed because of insufficient memory.
+
+    Other return codes are passed through from basiclu_update().
+
+Arguments:
+
+    struct basiclu_object *obj
+
+        Pointer to an initialized BASICLU object.
+
+    The other arguments are passed through to basiclu_update().
+*/

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

@@ -0,0 +1,30 @@
+struct basiclu_object
+{
+    lu_int *istore;
+    double *xstore;
+    lu_int *Li, *Ui, *Wi;
+    double *Lx, *Ux, *Wx;
+    double *lhs;
+    lu_int *ilhs;
+    lu_int nzlhs;
+    double realloc_factor;
+};
+
+/*
+A variable of type struct basiclu_object must be defined in user code. Its
+members are set and maintained by basiclu_obj_* routines. User code should only
+access the following members:
+
+    xstore (read/write)
+
+        set parameters and get info values
+
+    lhs, ilhs, nzlhs (read only)
+
+        holds solution after solve_sparse() and solve_for_update()
+
+    realloc_factor (read/write)
+
+        Arrays are reallocated for max(realloc_factor, 1.0) times the
+        required size. Default: 1.5
+*/

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

@@ -0,0 +1,75 @@
+lu_int basiclu_solve_dense
+(
+    lu_int istore[],
+    double xstore[],
+    lu_int Li[],
+    double Lx[],
+    lu_int Ui[],
+    double Ux[],
+    lu_int Wi[],
+    double Wx[],
+    const double rhs[],
+    double lhs[],
+    char trans
+);
+
+/*
+Purpose:
+
+    Given the factorization computed by basiclu_factorize() or basiclu_update()
+    and the dense right-hand side, rhs, solve a linear system for the solution
+    lhs.
+
+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().
+
+    const double rhs[m]
+
+        The right-hand side vector.
+
+    double lhs[m]
+
+        Uninitialized on entry. On return lhs holds the solution to the linear
+        system.
+
+        lhs and rhs are allowed to overlap. To overwrite rhs with the solution
+        pass pointers to the same array.
+
+    char trans
+
+        Defines which system to solve. 't' or 'T' for the transposed system, any
+        other character for the forward system.
+
+Info:
+
+    xstore[BASICLU_STATUS]: status code.
+
+        BASICLU_OK
+
+            The linear system has been successfully solved.
+
+        BASICLU_ERROR_argument_missing
+
+            One or more of the pointer/array arguments are NULL.
+
+        BASICLU_ERROR_invalid_call
+
+            The factorization is invalid.
+*/

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

@@ -0,0 +1,169 @@
+lu_int basiclu_solve_for_update
+(
+    lu_int istore[],
+    double xstore[],
+    lu_int Li[],
+    double Lx[],
+    lu_int Ui[],
+    double Ux[],
+    lu_int Wi[],
+    double Wx[],
+    lu_int nzrhs,
+    const lu_int irhs[],
+    const double xrhs[],
+    lu_int *p_nzlhs,
+    lu_int ilhs[],
+    double lhs[],
+    char trans
+);
+
+/*
+Purpose:
+
+    Given the factorization computed by basiclu_factorize() or basiclu_update(),
+    solve a linear system in preparation to update the factorization.
+
+    When the forward system is solved, then the right-hand side is the column
+    to be inserted into the factorized matrix. When the transposed system is
+    solved, then the right-hand side is a unit vector with entry 1 in position
+    of the column to be replaced in the factorized matrix.
+
+    For BASICLU to prepare the update, it is sufficient to compute only a
+    partial solution. If the left-hand side is not requested by the user (see
+    below), then only one triangular solve is done. If the left-hand side is
+    requested, then a second triangular solve is required.
+
+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().
+
+    lu_int nzrhs
+    const lu_int irhs[nzrhs]
+    const double xrhs[nzrhs]
+
+        The right-hand side vector in compressed format.
+
+        When the forward system is solved, irhs[0..nzrhs-1] are the indices of
+        nonzeros and xrhs[0..nzrhs-1] the corresponding values. irhs must not
+        contain duplicates.
+        
+        When the transposed system is solved, the right-hand side is a unit
+        vector with entry 1 in position irhs[0]. nzrhs, xrhs and elements of
+        irhs other than irhs[0] are not accessed. xrhs can be NULL.
+
+    lu_int *p_nzlhs
+    lu_int ilhs[m]
+    lu_int lhs[m]
+
+        If any of p_nzlhs, ilhs or lhs is NULL, then the solution to the linear
+        system is not requested. In this case only the update is prepared.
+
+        Otherwise:
+
+        *p_nzlhs is uninitialized on entry. On return *p_nzlhs holds
+        the number of nonzeros in the solution.
+        The contents of ilhs is uninitialized on entry. On return
+        ilhs[0..*p_nzlhs-1] holds the indices of nonzeros in the solution.
+        The contents of lhs must be initialized to zero on entry. On return
+        the solution is  scattered into lhs.
+
+    char trans
+
+        Defines which system to solve. 't' or 'T' for the transposed system,
+        any other character for the forward system.
+
+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_SPARSE_THRESHOLD]
+
+        Defines which method is used for solving a triangular system. A
+        triangular solve can be done either by the two phase method of Gilbert
+        and Peierls ("sparse solve") or by a sequential pass through the vector
+        ("sequential solve").
+
+        When the solution to the linear system is requested, then two triangular
+        systems are solved. The first triangular solve is done sparse. The
+        second triangular solve is done sparse if its right-hand side has not
+        more than m * xstore[BASICLU_SPARSE_THRESHOLD] nonzeros. Otherwise the
+        sequential solve is used.
+
+        When the solution to the linear system is not requested, then this
+        parameter has no effect.
+
+        Default: 0.05
+
+    xstore[BASICLU_DROP_TOLERANCE]
+
+        Nonzeros which magnitude is less than or equal to the drop tolerance
+        are removed after each triangular solve. Default: 1e-20
+
+Info:
+
+    xstore[BASICLU_STATUS]: status code.
+
+        BASICLU_OK
+
+            The updated has been successfully prepared and, if requested, the
+            solution to the linear system has been computed.
+
+        BASICLU_ERROR_argument_missing
+
+            One or more of the mandatory pointer/array arguments are NULL.
+
+        BASICLU_ERROR_invalid_call
+
+            The factorization is invalid.
+
+        BASICLU_ERROR_maximum_updates
+
+            There have already been m Forrest-Tomlin updates, see
+            xstore[BASICLU_NFORREST]. The factorization cannot be updated any
+            more and must be recomputed by basiclu_factorize().
+            The solution to the linear system has not been computed.
+
+        BASICLU_ERROR_invalid_argument
+
+            The right-hand side is invalid (forward system: nzrhs < 0 or
+            nzrhs > m or one or more indices out of range; backward system:
+            irhs[0] out of range).
+
+        BASICLU_REALLOCATE
+
+            The solve was aborted because of insufficient memory in Li,Lx or
+            Ui,Ux to store data for basiclu_update(). The number of additional
+            elements required is given by
+
+                xstore[BASICLU_ADD_MEMORYL] >= 0
+                xstore[BASICLU_ADD_MEMORYU] >= 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 for further updates
+            (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
+
+            basiclu_solve_for_update() will start from scratch in the next call.
+*/