lpsolver 0.1.0 → 0.2.1

data/ext/lpsolver-highs/build/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).
+*/

data/ext/lpsolver-highs/build/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.
+*/

data/ext/lpsolver-highs/build/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().
+*/

data/ext/lpsolver-highs/build/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.
+*/

data/ext/lpsolver-highs/build/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().
+*/

data/ext/lpsolver-highs/build/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.
+*/

data/ext/lpsolver-highs/build/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().
+*/

data/ext/lpsolver-highs/build/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().
+*/

data/ext/lpsolver-highs/build/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().
+*/

data/ext/lpsolver-highs/build/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().
+*/

data/ext/lpsolver-highs/build/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
+*/

data/ext/lpsolver-highs/build/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.
+*/