lpsolver 0.1.0 → 0.2.1

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

@@ -0,0 +1,141 @@
+/*
+ * lu_dfs.c
+ *
+ * Copyright (C) 2016-2018  ERGO-Code
+ *
+ * Depth first search in a graph
+ *
+ */
+
+#include "ipm/basiclu/lu_internal.h"
+
+static lu_int dfs_end(
+    lu_int i, const lu_int *begin, const lu_int *end, const lu_int *index,
+    lu_int top, lu_int *xi, lu_int *pstack, lu_int *marked, const lu_int M);
+
+static lu_int dfs(
+    lu_int i, const lu_int *begin, const lu_int *index,
+    lu_int top, lu_int *xi, lu_int *pstack, lu_int *marked, const lu_int M);
+
+
+/*
+ * lu_dfs() - compute reach(i) in a graph by depth first search
+ *
+ * @begin, @end, @index define the graph. When end is not NULL, then node j
+ * has neighbours index[begin[j]..end[j]-1]. When end is NULL, then the
+ * neighbour list is terminated by a negative index.
+ *
+ * On return xi[newtop..top-1] hold reach(i) in topological order; newtop is
+ * the function return value. Nodes that were already marked are excluded from
+ * the reach.
+ *
+ * @pstack is size m workspace (m the number of nodes in the graph); the
+ * contents of pstack is undefined on entry/return.
+ *
+ * @marked is size m array. Node j is marked iff marked[j] == M.
+ * On return nodes xi[newtop..top-1] are marked.
+ *
+ * If node i is marked on entry, the function does nothing.
+ *
+ */
+
+lu_int lu_dfs(
+    lu_int i, const lu_int *begin, const lu_int *end, const lu_int *index,
+    lu_int top, lu_int *xi, lu_int *pstack, lu_int *marked, const lu_int M)
+{
+    if (marked[i] == M)
+        return top;
+
+    return end ?
+        dfs_end(i, begin, end, index, top, xi, pstack, marked, M) :
+        dfs(i, begin, index, top, xi, pstack, marked, M);
+}
+
+
+/* ==========================================================================
+ * dfs_end
+ *
+ * adapted from T. Davis, CSPARSE
+ * ========================================================================== */
+
+static lu_int dfs_end(
+    lu_int i, const lu_int *begin, const lu_int *end, const lu_int *index,
+    lu_int top, lu_int *xi, lu_int *pstack, lu_int *marked, const lu_int M)
+{
+    lu_int inext, done, p, head = 0;
+    assert(marked[i] != M);
+
+    xi[0] = i;
+    while (head >= 0)
+    {
+        i = xi[head];
+        if (marked[i] != M)     /* node i has not been visited */
+        {
+            marked[i] = M;
+            pstack[head] = begin[i];
+        }
+        done = 1;
+        /* continue dfs at node i */
+        for (p = pstack[head]; p < end[i]; p++)
+        {
+            inext = index[p];
+            if (marked[inext] == M)
+                continue;       /* skip visited node */
+            pstack[head] = p+1;
+            xi[++head] = inext; /* start dfs at node inext */
+            done = 0;
+            break;
+        }
+        if (done)               /* node i has no unvisited neighbours */
+        {
+            head--;
+            xi[--top] = i;
+        }
+    }
+
+    return top;
+}
+
+
+/* ==========================================================================
+ * dfs
+ *
+ * adapted from T. Davis, CSPARSE
+ * ========================================================================== */
+
+static lu_int dfs(
+    lu_int i, const lu_int *begin, const lu_int *index,
+    lu_int top, lu_int *xi, lu_int *pstack, lu_int *marked, const lu_int M)
+{
+    lu_int inext, done, p, head = 0;
+    assert(marked[i] != M);
+
+    xi[0] = i;
+    while (head >= 0)
+    {
+        i = xi[head];
+        if (marked[i] != M)     /* node i has not been visited */
+        {
+            marked[i] = M;
+            pstack[head] = begin[i];
+        }
+        done = 1;
+        /* continue dfs at node i */
+        for (p = pstack[head]; (inext = index[p]) >= 0; p++)
+        {
+            if (marked[inext] == M)
+                continue;       /* skip visited node */
+            pstack[head] = p+1;
+            xi[++head] = inext; /* start dfs at node inext */
+            done = 0;
+            break;
+        }
+        if (done)               /* node i has no unvisited neighbours */
+        {
+            head--;
+            xi[--top] = i;
+        }
+    }
+
+    return top;
+}

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

@@ -0,0 +1,56 @@
+/* 
+ * lu_factorize_bump.c
+ *
+ * Copyright (C) 2016-2019  ERGO-Code
+ *
+ * Bump factorization driver routine
+ *
+ */
+
+#include "ipm/basiclu/lu_internal.h"
+#include "ipm/basiclu/lu_list.h"
+
+lu_int lu_factorize_bump(struct lu *this)
+{
+    const lu_int m          = this->m;
+    lu_int *colcount_flink  = this->colcount_flink;
+    lu_int *colcount_blink  = this->colcount_blink;
+    lu_int *pinv            = this->pinv;
+    lu_int *qinv            = this->qinv;
+    lu_int status = BASICLU_OK;
+
+    while (this->rank + this->rankdef < m)
+    {
+        /*
+         * Find pivot element. Markowitz search need not be called if the
+         * previous call to lu_pivot() returned for reallocation. In this case
+         * this->pivot_col is valid.
+         */
+        if (this->pivot_col < 0)
+            lu_markowitz(this);
+        assert(this->pivot_col >= 0);
+
+        if (this->pivot_row < 0)
+        {
+            /* Eliminate empty column without choosing a pivot. */
+            lu_list_remove(colcount_flink, colcount_blink, this->pivot_col);
+            this->pivot_col = -1;
+            this->rankdef++;
+        }
+        else
+        {
+            /* Eliminate pivot. This may require reallocation. */
+            assert(pinv[this->pivot_row] == -1);
+            assert(qinv[this->pivot_col] == -1);
+            status = lu_pivot(this);
+            if (status != BASICLU_OK)
+                break;
+            pinv[this->pivot_row] = this->rank;
+            qinv[this->pivot_col] = this->rank;
+            this->pivot_col = -1;
+            this->pivot_row = -1;
+            this->rank++;
+        }
+    }
+    return status;
+}

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

@@ -0,0 +1,184 @@
+/* 
+ * lu_file.c
+ *
+ * Copyright (C) 2016-2018  ERGO-Code
+ *
+ * Data file implementation
+ *
+ * A data file stores lines of (index,value) pairs. Entries of each line are
+ * contiguous in memory. Lines can be in any order in memory and there can be
+ * gaps between consecutive lines.
+ *
+ * The data file implementation uses arrays
+ *
+ *  index[0:fmem-1], value[0:fmem-1],
+ *  begin[0:nlines], end[0:nlines],
+ *  next[0:nlines], prev[0:nlines]
+ *
+ *  index, value    storing (index,value) pairs
+ *  begin[k]        pointer to first element in line 0 <= k < nlines,
+ *  end[k]          pointer to one past the last element in line k.
+ *  begin[nlines]   pointer to the first element of unused space
+ *  end[nlines]     holds fmem
+ *
+ *  next, prev hold the line numbers (0..nlines-1) in a double linked list in
+ *  the order in which they appear in memory. That is, for line 0 <= k < nlines,
+ *  next[k] and prev[k] are the line which comes before respectively after line
+ *  k in memory. next[nlines] and prev[nlines] are the first respectively last
+ *  line in memory order.
+ *
+ * Methods:
+ *
+ *  lu_file_empty
+ *  lu_file_reappend
+ *  lu_file_compress
+ *  lu_file_diff
+ *
+ */
+
+#include "ipm/basiclu/lu_def.h"
+#include "ipm/basiclu/lu_list.h"
+#include "ipm/basiclu/lu_file.h"
+
+/* ==========================================================================
+ * lu_file_empty
+ *
+ * Initialize empty file with @fmem memory space.
+ * ========================================================================== */
+
+void lu_file_empty(
+    lu_int nlines, lu_int *begin, lu_int *end, lu_int *next, lu_int *prev,
+    lu_int fmem)
+{
+    lu_int i;
+
+    begin[nlines] = 0;
+    end[nlines] = fmem;
+    for (i = 0; i < nlines; i++)
+        begin[i] = end[i] = 0;
+    for (i = 0; i < nlines; i++)
+    {
+        next[i] = i+1;
+        prev[i+1] = i;
+    }
+    next[nlines] = 0;
+    prev[0] = nlines;
+}
+
+
+/* ==========================================================================
+ * lu_file_reappend
+ *
+ * Reappend line to file end and add @extra_space elements room. The file must
+ * have at least length(line) + @extra_space elements free space.
+ * ========================================================================== */
+
+void lu_file_reappend(
+    lu_int line, lu_int nlines, lu_int *begin, lu_int *end, lu_int *next,
+    lu_int *prev, lu_int *index, double *value, lu_int extra_space)
+{
+    lu_int fmem, used, room, ibeg, iend, pos;
+
+    fmem = end[nlines];
+    used = begin[nlines];
+    room = fmem-used;
+    ibeg = begin[line];         /* old beginning of line */
+    iend = end[line];
+    begin[line] = used;         /* new beginning of line */
+    assert(iend-ibeg <= room);
+    for (pos = ibeg; pos < iend; pos++)
+    {
+        index[used] = index[pos];
+        value[used++] = value[pos];
+    }
+    end[line] = used;
+    room = fmem-used;
+    assert(room >= extra_space);
+    used += extra_space;
+    begin[nlines] = used;       /* beginning of unused space */
+    lu_list_move(line, 0, next, prev, nlines, NULL);
+}
+
+
+/* ==========================================================================
+ * lu_file_compress
+ *
+ * Compress file to reuse memory gaps. The ordering of lines in the file is
+ * unchanged. To each line with nz entries add @stretch*nz+@pad elements extra
+ * space. Chop extra space if it would overlap the following line in memory.
+ *
+ * Return: number of entries in file
+ * ========================================================================== */
+
+lu_int lu_file_compress(
+    lu_int nlines, lu_int *begin, lu_int *end, const lu_int *next,
+    lu_int *index, double *value, double stretch, lu_int pad)
+{
+    lu_int i, pos, ibeg, iend, used, extra_space, nz = 0;
+
+    used = 0; extra_space = 0;
+    for (i = next[nlines]; i < nlines; i = next[i]) /* move line i */
+    {
+        ibeg = begin[i];
+        iend = end[i];
+        assert(ibeg >= used);
+        used += extra_space;
+        if (used > ibeg)
+            used = ibeg;        /* chop extra space added before */
+        begin[i] = used;
+        for (pos = ibeg; pos < iend; pos++)
+        {
+            index[used] = index[pos];
+            value[used++] = value[pos];
+        }
+        end[i] = used;
+        extra_space = stretch*(iend-ibeg) + pad;
+        nz += iend-ibeg;
+    }
+    assert(used <= begin[nlines]);
+    used += extra_space;
+    if (used > begin[nlines])
+        used = begin[nlines];   /* never use more space than before */
+    begin[nlines] = used;
+    return nz;
+}
+
+
+/* ==========================================================================
+ * lu_file_diff (for debugging)
+ *
+ * @begin_row, @end_row, @begin_col, @end_col are pointer into @index, @value,
+ * defining lines of the "row file" and the "column file".
+ *
+ * Task:
+ *
+ *  val == NULL: count row file entries that are missing in column file.
+ *  val != NULL: count row file entries that are missing in column file
+ *               or which values are different.
+ *
+ * The method does a column file search for each row file entry. To check
+ * consistency of rowwise and columnwise storage, the method must be called
+ * twice with row pointers and column pointers swapped.
+ * ========================================================================== */
+
+lu_int lu_file_diff(
+    lu_int nrow, const lu_int *begin_row, const lu_int *end_row,
+    const lu_int *begin_col, const lu_int *end_col, const lu_int *index,
+    const double *value)
+{
+    lu_int i, j, pos, where, ndiff = 0;
+
+    for (i = 0; i < nrow; i++)
+    {
+        for (pos = begin_row[i]; pos < end_row[i]; pos++)
+        {
+            j = index[pos];
+            for (where = begin_col[j]; where < end_col[j] &&
+                     index[where] != i; where++)
+                ;
+            if (where == end_col[j] || (value && value[pos] != value[where]))
+                ndiff++;
+        }
+    }
+    return ndiff;
+}

data/ext/lpsolver-highs/highs/ipm/basiclu/lu_file.h

@@ -0,0 +1,21 @@
+#ifndef _LU_FILE_H
+#define _LU_FILE_H
+
+void lu_file_empty(
+    lu_int nlines, lu_int *begin, lu_int *end, lu_int *next, lu_int *prev,
+    lu_int fmem);
+
+void lu_file_reappend(
+    lu_int line, lu_int nlines, lu_int *begin, lu_int *end, lu_int *next,
+    lu_int *prev, lu_int *index, double *value, lu_int extra_space);
+
+lu_int lu_file_compress(
+    lu_int nlines, lu_int *begin, lu_int *end, const lu_int *next,
+    lu_int *index, double *value, double stretch, lu_int pad);
+
+lu_int lu_file_diff(
+    lu_int nrow, const lu_int *begin_row, const lu_int *end_row,
+    const lu_int *begin_col, const lu_int *end_col, const lu_int *index,
+    const double *value);
+
+#endif

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

@@ -0,0 +1,53 @@
+/*
+ * lu_garbage_perm.c
+ *
+ * Copyright (C) 2016-2018  ERGO-Code
+ *
+ */
+
+#include "ipm/basiclu/lu_internal.h"
+
+/*
+ * lu_garbage_perm()
+ *
+ * The sequence of pivot columns and pivot rows is stored in
+ *
+ *  pivotcol[0..pivotlen-1], pivotrow[0..pivotlen-1],
+ *
+ * where pivotlen >= m. When pivotlen > m, then the arrays contain duplicates.
+ * For each index its last occurrence in the arrays is its position in the pivot
+ * sequence and occurrences before mark unused slots.
+ *
+ * This routine removes duplicates and compresses the indices such that
+ * pivotlen == m.
+ */
+
+void lu_garbage_perm(struct lu *this)
+{
+    const lu_int m      = this->m;
+    lu_int pivotlen     = this->pivotlen;
+    lu_int *pivotcol    = this->pivotcol;
+    lu_int *pivotrow    = this->pivotrow;
+    lu_int *marked      = this->marked;
+
+    lu_int j, get, put, marker;
+
+    if (pivotlen > m)
+    {
+        marker = ++this->marker;
+        put = pivotlen;
+        for (get = pivotlen-1; get >= 0; get--)
+        {
+            if (marked[j = pivotcol[get]] != marker)
+            {
+                marked[j] = marker;
+                pivotcol[--put] = j;
+                pivotrow[put] = pivotrow[get];
+            }
+        }
+        assert(put+m == pivotlen);
+        memmove(pivotcol, pivotcol+put, m*sizeof(lu_int));
+        memmove(pivotrow, pivotrow+put, m*sizeof(lu_int));
+        this->pivotlen = m;
+    }
+}

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

@@ -0,0 +1,56 @@
+/* 
+ * lu_initialize.c
+ *
+ * Copyright (C) 2016-2018  ERGO-Code
+ *
+ */
+
+#include "ipm/basiclu/lu_internal.h"
+
+
+/*
+ * lu_initialize()
+ *
+ * Make @istore, @xstore a BASICLU instance. Set parameters to defaults and
+ * initialize global counters. Reset instance for a fresh factorization.
+ *
+ */
+void lu_initialize(lu_int m, lu_int *istore, double *xstore)
+{
+    struct lu this;
+
+    /* set constant entries */
+    istore[0]                               = BASICLU_HASH;
+    xstore[0]                               = BASICLU_HASH;
+    xstore[BASICLU_DIM]                     = m;
+
+    /* set default parameters */
+    xstore[BASICLU_MEMORYL]                 = 0;
+    xstore[BASICLU_MEMORYU]                 = 0;
+    xstore[BASICLU_MEMORYW]                 = 0;
+    xstore[BASICLU_DROP_TOLERANCE]          = 1e-20;
+    xstore[BASICLU_ABS_PIVOT_TOLERANCE]     = 1e-14;
+    xstore[BASICLU_REL_PIVOT_TOLERANCE]     = 0.1;
+    xstore[BASICLU_BIAS_NONZEROS]           = 1;
+    xstore[BASICLU_MAXN_SEARCH_PIVOT]       = 3;
+    xstore[BASICLU_PAD]                     = 4;
+    xstore[BASICLU_STRETCH]                 = 0.3;
+    xstore[BASICLU_COMPRESSION_THRESHOLD]   = 0.5;
+    xstore[BASICLU_SPARSE_THRESHOLD]        = 0.05;
+    xstore[BASICLU_REMOVE_COLUMNS]          = 0;
+    xstore[BASICLU_SEARCH_ROWS]             = 1;
+
+    /* initialize global counters */
+    xstore[BASICLU_NFACTORIZE]              = 0;
+    xstore[BASICLU_NUPDATE_TOTAL]           = 0;
+    xstore[BASICLU_NFORREST_TOTAL]          = 0;
+    xstore[BASICLU_NSYMPERM_TOTAL]          = 0;
+    xstore[BASICLU_TIME_FACTORIZE_TOTAL]    = 0;
+    xstore[BASICLU_TIME_SOLVE_TOTAL]        = 0;
+    xstore[BASICLU_TIME_UPDATE_TOTAL]       = 0;
+
+    /* lu_reset() and lu_save() initializes the remaining slots */
+    lu_load(&this, istore, xstore, NULL, NULL, NULL, NULL, NULL, NULL);
+    lu_reset(&this);
+    lu_save(&this, istore, xstore, BASICLU_OK);
+}