lpsolver 0.1.0 → 0.2.1

data/ext/lpsolver-highs/highs/ipm/basiclu/basiclu_get_factors.c

@@ -0,0 +1,148 @@
+/*
+ * basiclu_get_factors.c
+ *
+ * Copyright (C) 2016-2018  ERGO-Code
+ *
+ */
+
+#include "ipm/basiclu/lu_internal.h"
+
+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_[]
+)
+{
+    struct lu this;
+    lu_int m, status;
+
+    status = lu_load(&this, istore, xstore, Li, Lx, Ui, Ux, Wi, Wx);
+    if (status != BASICLU_OK)
+        return status;
+    if (this.nupdate != 0)
+    {
+        status = BASICLU_ERROR_invalid_call;
+        return lu_save(&this, istore, xstore, status);
+    }
+    m = this.m;
+
+    if (rowperm)
+        memcpy(rowperm, this.pivotrow, m*sizeof(lu_int));
+    if (colperm)
+        memcpy(colperm, this.pivotcol, m*sizeof(lu_int));
+
+    if (Lcolptr && Lrowidx && Lvalue_)
+    {
+        const lu_int *Lbegin_p  = this.Lbegin_p;
+        const lu_int *Ltbegin_p = this.Ltbegin_p;
+        const lu_int *Lindex    = this.Lindex;
+        const double *Lvalue    = this.Lvalue;
+        const lu_int *p         = this.p;
+        lu_int *colptr          = this.iwork1; /* size m workspace */
+        lu_int i, k, put, pos;
+
+        /*
+         * L[:,k] will hold the elimination factors from the k-th pivot step.
+         * First set the column pointers and store the unit diagonal elements
+         * at the front of each column. Then scatter each row of L' into the
+         * columnwise L so that the row indices become sorted.
+         */
+        put = 0;
+        for (k = 0; k < m; k++)
+        {
+            Lcolptr[k] = put;
+            Lrowidx[put] = k;
+            Lvalue_[put++] = 1.0;
+            colptr[p[k]] = put; /* next free position in column */
+            put += Lbegin_p[k+1] - Lbegin_p[k] - 1;
+            /* subtract 1 because internal storage uses (-1) terminators */
+        }
+        Lcolptr[m] = put;
+        assert(put == this.Lnz+m);
+
+        for (k = 0; k < m; k++)
+        {
+            for (pos = Ltbegin_p[k]; (i = Lindex[pos]) >= 0; pos++)
+            {
+                put = colptr[i]++;
+                Lrowidx[put] = k;
+                Lvalue_[put] = Lvalue[pos];
+            }
+        }
+
+        #ifndef NDEBUG
+        for (k = 0; k < m; k++)
+        {
+            assert(colptr[p[k]] == Lcolptr[k+1]);
+        }
+        #endif
+    }
+
+    if (Ucolptr && Urowidx && Uvalue_)
+    {
+        const lu_int *Wbegin    = this.Wbegin;
+        const lu_int *Wend      = this.Wend;
+        const lu_int *Windex    = this.Windex;
+        const double *Wvalue    = this.Wvalue;
+        const double *col_pivot = this.col_pivot;
+        const lu_int *pivotcol  = this.pivotcol;
+        lu_int *colptr          = this.iwork1; /* size m workspace */
+        lu_int j, k, put, pos;
+
+        /*
+         * U[:,k] will hold the column of B from the k-th pivot step.
+         * First set the column pointers and store the pivot element at the end
+         * of each column. Then scatter each row of U' into the columnwise U so
+         * that the row indices become sorted.
+         */
+        memset(colptr, 0, m*sizeof(lu_int)); /* column counts */
+        for (j = 0; j < m; j++)
+        {
+            for (pos = Wbegin[j]; pos < Wend[j]; pos++)
+                colptr[Windex[pos]]++;
+        }
+        put = 0;
+        for (k = 0; k < m; k++) /* set column pointers */
+        {
+            j = pivotcol[k];
+            Ucolptr[k] = put;
+            put += colptr[j];
+            colptr[j] = Ucolptr[k]; /* next free position in column */
+            Urowidx[put] = k;
+            Uvalue_[put++] = col_pivot[j];
+        }
+        Ucolptr[m] = put;
+        assert(put == this.Unz+m);
+        for (k = 0; k < m; k++) /* scatter row k */
+        {
+            j = pivotcol[k];
+            for (pos = Wbegin[j]; pos < Wend[j]; pos++)
+            {
+                put = colptr[Windex[pos]]++;
+                Urowidx[put] = k;
+                Uvalue_[put] = Wvalue[pos];
+            }
+        }
+
+        #ifndef NDEBUG
+        for (k = 0; k < m; k++) assert(colptr[pivotcol[k]] == Ucolptr[k+1]-1);
+        for (k = 0; k < m; k++) assert(Urowidx[Ucolptr[k+1]-1] == k);
+        #endif
+    }
+
+    return BASICLU_OK;
+}

data/ext/lpsolver-highs/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/highs/ipm/basiclu/basiclu_initialize.c

@@ -0,0 +1,24 @@
+/*
+ * basiclu_initialize.c
+ *
+ * Copyright (C) 2016-2018  ERGO-Code
+ *
+ */
+
+#include "ipm/basiclu/lu_internal.h"
+
+lu_int basiclu_initialize
+(
+    lu_int m,
+    lu_int istore[],
+    double xstore[]
+)
+{
+    if (!istore || !xstore)
+        return BASICLU_ERROR_argument_missing;
+    if (m <= 0)
+        return BASICLU_ERROR_invalid_argument;
+
+    lu_initialize(m, istore, xstore);
+    return BASICLU_OK;
+}

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