casadi 3.6.5__cp39-none-win_amd64.whl → 3.6.6__cp39-none-win_amd64.whl

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

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

@@ -0,0 +1,112 @@
+lu_int basiclu_solve_sparse
+(
+    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()
+    and the sparse 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().
+
+    lu_int nzrhs
+    const lu_int irhs[nzrhs]
+    const double xrhs[nzrhs]
+
+        The right-hand side vector in compressed format. irhs[0..nzrhs-1] are
+        the indices of nonzeros and xrhs[0..nzrhs-1] the corresponding values.
+        irhs must not contain duplicates.
+
+    lu_int *p_nzlhs
+    lu_int ilhs[m]
+    lu_int lhs[m]
+
+        *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 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_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").
+
+        Solving B*x=b requires two triangular solves. 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.
+
+        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 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.
+
+        BASICLU_ERROR_invalid_argument
+
+            The right-hand side is invalid (nzrhs < 0 or nzrhs > m or one or
+            more indices out of range).
+*/