lpsolver 0.1.0 → 0.2.1

data/ext/lpsolver-highs/extern/metis/libmetis/graph.c

@@ -0,0 +1,268 @@
+/**
+\file
+\brief Functions that deal with setting up the graphs for METIS.
+
+\date   Started 7/25/1997
+\author George  
+\author Copyright 1997-2009, Regents of the University of Minnesota 
+\version\verbatim $Id: graph.c 15817 2013-11-25 14:58:41Z karypis $ \endverbatim
+*/
+
+#include "metislib.h"
+
+
+/*************************************************************************/
+/*! This function sets up the graph from the user input */
+/*************************************************************************/
+graph_t *SetupGraph(ctrl_t *ctrl, idx_t nvtxs, idx_t ncon, const idx_t *xadj, 
+             const idx_t *adjncy, idx_t *vwgt, idx_t *vsize, idx_t *adjwgt) 
+{
+  idx_t i, j, k, sum;
+  real_t *nvwgt;
+  graph_t *graph;
+
+  /* allocate the graph and fill in the fields */
+  graph = CreateGraph();
+
+  graph->nvtxs  = nvtxs;
+  graph->nedges = xadj[nvtxs];
+  graph->ncon   = ncon;
+
+  graph->xadj_orig = xadj;
+  graph->xadj      = NULL;
+  graph->free_xadj = 0;
+
+  graph->adjncy_orig = adjncy;
+  graph->adjncy      = NULL;
+  graph->free_adjncy = 0;
+
+  graph->droppedewgt = 0;
+
+  /* setup the vertex weights */
+  if (vwgt) {
+    graph->vwgt      = vwgt;
+    graph->free_vwgt = 0;
+  }
+  else {
+    vwgt = graph->vwgt = ismalloc(ncon*nvtxs, 1);
+  }
+
+  graph->tvwgt    = imalloc(ncon);
+  graph->invtvwgt = rmalloc(ncon);
+  for (i=0; i<ncon; i++) {
+    graph->tvwgt[i]    = isum(nvtxs, vwgt+i, ncon);
+    graph->invtvwgt[i] = 1.0/(graph->tvwgt[i] > 0 ? graph->tvwgt[i] : 1);
+  }
+
+
+  /* setup the edge weights */
+  if (adjwgt) {
+    graph->adjwgt      = adjwgt;
+    graph->free_adjwgt = 0;
+  }
+  else {
+    adjwgt = graph->adjwgt = ismalloc(graph->nedges, 1);
+  }
+  
+
+
+  /* setup various derived info */
+  SetupGraph_tvwgt(graph);
+
+  if (ctrl->optype == METIS_OP_OMETIS) 
+    SetupGraph_label(graph);
+
+
+  return graph;
+}
+
+
+/*************************************************************************/
+/*! Set's up the tvwgt/invtvwgt info */
+/*************************************************************************/
+void SetupGraph_tvwgt(graph_t *graph)
+{
+  idx_t i;
+
+  if (graph->tvwgt == NULL) 
+    graph->tvwgt  = imalloc(graph->ncon);
+  if (graph->invtvwgt == NULL) 
+    graph->invtvwgt = rmalloc(graph->ncon);
+
+  for (i=0; i<graph->ncon; i++) {
+    graph->tvwgt[i]    = isum(graph->nvtxs, graph->vwgt+i, graph->ncon);
+    graph->invtvwgt[i] = 1.0/(graph->tvwgt[i] > 0 ? graph->tvwgt[i] : 1);
+  }
+}
+
+
+/*************************************************************************/
+/*! Set's up the label info */
+/*************************************************************************/
+void SetupGraph_label(graph_t *graph)
+{
+  idx_t i;
+
+  if (graph->label == NULL)
+    graph->label = imalloc(graph->nvtxs);
+
+  for (i=0; i<graph->nvtxs; i++)
+    graph->label[i] = i;
+}
+
+
+/*************************************************************************/
+/*! Setup the various arrays for the split graph */
+/*************************************************************************/
+graph_t *SetupSplitGraph(graph_t *graph, idx_t snvtxs, idx_t snedges)
+{
+  graph_t *sgraph;
+
+  sgraph = CreateGraph();
+
+  sgraph->nvtxs  = snvtxs;
+  sgraph->nedges = snedges;
+  sgraph->ncon   = graph->ncon;
+
+  /* Allocate memory for the split graph */
+  sgraph->xadj        = imalloc(snvtxs+1);
+  sgraph->vwgt        = imalloc(sgraph->ncon*snvtxs);
+  sgraph->adjncy      = imalloc(snedges);
+  sgraph->adjwgt      = imalloc(snedges);
+  sgraph->label	      = imalloc(snvtxs);
+  sgraph->tvwgt       = imalloc(sgraph->ncon);
+  sgraph->invtvwgt    = rmalloc(sgraph->ncon);
+
+  if (graph->vsize)
+    sgraph->vsize     = imalloc(snvtxs);
+
+  return sgraph;
+}
+
+
+/*************************************************************************/
+/*! This function creates and initializes a graph_t data structure */
+/*************************************************************************/
+graph_t *CreateGraph(void)
+{
+  graph_t *graph;
+
+  graph = (graph_t *)malloc(sizeof(graph_t));
+
+  InitGraph(graph);
+
+  return graph;
+}
+
+
+/*************************************************************************/
+/*! This function initializes a graph_t data structure */
+/*************************************************************************/
+void InitGraph(graph_t *graph) 
+{
+  memset((void *)graph, 0, sizeof(graph_t));
+
+  /* graph size constants */
+  graph->nvtxs     = -1;
+  graph->nedges    = -1;
+  graph->ncon      = -1;
+  graph->mincut    = -1;
+  graph->minvol    = -1;
+  graph->nbnd      = -1;
+
+  /* memory for the graph structure */
+  graph->xadj      = NULL;
+  graph->vwgt      = NULL;
+  graph->vsize     = NULL;
+  graph->adjncy    = NULL;
+  graph->adjwgt    = NULL;
+  graph->label     = NULL;
+  graph->cmap      = NULL;
+  graph->tvwgt     = NULL;
+  graph->invtvwgt  = NULL;
+
+  graph->xadj_orig   = NULL;
+  graph->adjncy_orig = NULL;
+
+  /* by default these are set to true, but the can be explicitly changed afterwards */
+  graph->free_xadj   = 1;
+  graph->free_vwgt   = 1;
+  graph->free_vsize  = 1;
+  graph->free_adjncy = 1;
+  graph->free_adjwgt = 1;
+
+
+  /* memory for the partition/refinement structure */
+  graph->where     = NULL;
+  graph->pwgts     = NULL;
+  graph->id        = NULL;
+  graph->ed        = NULL;
+  graph->bndptr    = NULL;
+  graph->bndind    = NULL;
+  graph->nrinfo    = NULL;
+
+  /* linked-list structure */
+  graph->coarser   = NULL;
+  graph->finer     = NULL;
+
+}
+
+
+/*************************************************************************/
+/*! This function frees the memory storing the structure of the graph */
+/*************************************************************************/
+void FreeSData(graph_t *graph) 
+{
+  /* free graph structure */
+  if (graph->free_xadj)
+    gk_free((void **)&graph->xadj);
+  if (graph->free_vwgt)
+    gk_free((void **)&graph->vwgt);
+  if (graph->free_vsize)
+    gk_free((void **)&graph->vsize);
+  if (graph->free_adjncy)
+    gk_free((void **)&graph->adjncy);
+  if (graph->free_adjwgt)
+    gk_free((void **)&graph->adjwgt);
+}
+
+
+/*************************************************************************/
+/*! This function frees the refinement/partition memory stored in a graph */
+/*************************************************************************/
+void FreeRData(graph_t *graph) 
+{
+  /* free partition/refinement structure */
+  gk_free((void **)&graph->where);
+  gk_free((void**)&graph->pwgts);
+  gk_free((void**)&graph->id);
+  gk_free((void**)&graph->ed);
+  gk_free((void**)&graph->bndptr);
+  gk_free((void**)&graph->bndind);
+  gk_free((void**)&graph->nrinfo);
+}
+
+
+/*************************************************************************/
+/*! This function deallocates any memory stored in a graph */
+/*************************************************************************/
+void FreeGraph(graph_t **r_graph) 
+{
+  graph_t *graph;
+
+  graph = *r_graph;
+
+  /* free the graph structure's fields */
+  FreeSData(graph);
+
+  /* free the partition/refinement fields */
+  FreeRData(graph);
+
+  gk_free((void **)&graph->tvwgt);
+  gk_free((void**)&graph->invtvwgt);
+  gk_free((void**)&graph->label);
+  gk_free((void**)&graph->cmap);
+  gk_free((void**)&graph);
+
+  *r_graph = NULL;
+}

data/ext/lpsolver-highs/extern/metis/libmetis/initpart.c

@@ -0,0 +1,385 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * initpart.c
+ *
+ * This file contains code that performs the initial partition of the
+ * coarsest graph
+ *
+ * Started 7/23/97
+ * George
+ *
+ */
+
+#include "metislib.h"
+
+/*************************************************************************/
+/*! This function computes the initial separator of the coarsest graph */
+/*************************************************************************/
+void InitSeparator(ctrl_t *ctrl, graph_t *graph, idx_t niparts) 
+{
+  real_t ntpwgts[2] = {0.5, 0.5};
+  mdbglvl_et dbglvl;
+
+  dbglvl = ctrl->dbglvl;
+  IFSET(ctrl->dbglvl, METIS_DBG_REFINE, ctrl->dbglvl -= METIS_DBG_REFINE);
+  IFSET(ctrl->dbglvl, METIS_DBG_MOVEINFO, ctrl->dbglvl -= METIS_DBG_MOVEINFO);
+
+  /* this is required for the cut-based part of the refinement */
+  Setup2WayBalMultipliers(ctrl, graph, ntpwgts);
+
+  switch (ctrl->iptype) {
+    case METIS_IPTYPE_EDGE:
+      if (graph->nedges == 0)
+        RandomBisection(ctrl, graph, ntpwgts, niparts);
+      else
+        GrowBisection(ctrl, graph, ntpwgts, niparts);
+
+      Compute2WayPartitionParams(ctrl, graph);
+      ConstructSeparator(ctrl, graph);
+      break;
+
+    case METIS_IPTYPE_NODE:
+      GrowBisectionNode(ctrl, graph, ntpwgts, niparts);
+      break;
+
+    default:
+      GK_ERREXIT("Unknown iptype of %"PRIDX"\n", ctrl->iptype);
+  }
+
+  IFSET(ctrl->dbglvl, METIS_DBG_IPART, HIGHS_ORDERING_PRINT("Initial Sep: %"PRIDX"\n", graph->mincut));
+
+  ctrl->dbglvl = dbglvl;
+
+}
+
+
+/*************************************************************************/
+/*! This function computes a bisection of a graph by randomly assigning
+    the vertices followed by a bisection refinement.
+    The resulting partition is returned in graph->where.
+*/
+/*************************************************************************/
+void RandomBisection(ctrl_t *ctrl, graph_t *graph, real_t *ntpwgts, 
+         idx_t niparts)
+{
+  idx_t i, ii, j, k, nvtxs, pwgts[2], zeromaxpwgt, from, me, 
+        bestcut=0, icut, mincut, inbfs;
+  const idx_t *xadj, *adjncy;
+  idx_t *vwgt, *adjwgt, *where;
+  idx_t *perm, *bestwhere;
+
+  WCOREPUSH;
+
+  nvtxs  = graph->nvtxs;
+  xadj   = graph->xadj_orig ? graph->xadj_orig : graph->xadj;
+  vwgt   = graph->vwgt;
+  adjncy = graph->adjncy_orig ? graph->adjncy_orig : graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  Allocate2WayPartitionMemory(ctrl, graph);
+  where = graph->where;
+
+  bestwhere = iwspacemalloc(ctrl, nvtxs);
+  perm      = iwspacemalloc(ctrl, nvtxs);
+
+  zeromaxpwgt = ctrl->ubfactors[0]*graph->tvwgt[0]*ntpwgts[0];
+
+  for (inbfs=0; inbfs<niparts; inbfs++) {
+    iset(nvtxs, 1, where);
+
+    if (inbfs > 0) {
+      irandArrayPermute(nvtxs, perm, nvtxs/2, 1, &ctrl->rng_state);
+      pwgts[1] = graph->tvwgt[0];
+      pwgts[0] = 0;
+
+      for (ii=0; ii<nvtxs; ii++) {
+        i = perm[ii];
+        if (pwgts[0]+vwgt[i] < zeromaxpwgt) {
+          where[i] = 0;
+          pwgts[0] += vwgt[i];
+          pwgts[1] -= vwgt[i];
+          if (pwgts[0] > zeromaxpwgt)
+            break;
+        }
+      }
+    }
+
+    /* Do some partition refinement  */
+    Compute2WayPartitionParams(ctrl, graph);
+
+    Balance2Way(ctrl, graph, ntpwgts);
+
+    FM_2WayRefine(ctrl, graph, ntpwgts, 4);
+
+    if (inbfs==0 || bestcut > graph->mincut) {
+      bestcut = graph->mincut;
+      icopy(nvtxs, where, bestwhere);
+      if (bestcut == 0)
+        break;
+    }
+  }
+
+  graph->mincut = bestcut;
+  icopy(nvtxs, bestwhere, where);
+
+  WCOREPOP;
+}
+
+
+/*************************************************************************/
+/*! This function takes a graph and produces a bisection by using a region
+    growing algorithm. The resulting bisection is refined using FM.
+    The resulting partition is returned in graph->where.
+*/
+/*************************************************************************/
+void GrowBisection(ctrl_t *ctrl, graph_t *graph, real_t *ntpwgts, 
+         idx_t niparts)
+{
+  idx_t i, j, k, nvtxs, drain, nleft, first, last, 
+        pwgts[2], oneminpwgt, onemaxpwgt, 
+        from, me, bestcut=0, icut, mincut, inbfs;
+  const idx_t *xadj, *adjncy;
+  idx_t *vwgt, *adjwgt, *where;
+  idx_t *queue, *touched, *gain, *bestwhere;
+
+  WCOREPUSH;
+
+  nvtxs  = graph->nvtxs;
+  xadj   = graph->xadj_orig ? graph->xadj_orig : graph->xadj;
+  vwgt   = graph->vwgt;
+  adjncy = graph->adjncy_orig ? graph->adjncy_orig : graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  Allocate2WayPartitionMemory(ctrl, graph);
+  where = graph->where;
+
+  bestwhere = iwspacemalloc(ctrl, nvtxs);
+  queue     = iwspacemalloc(ctrl, nvtxs);
+  touched   = iwspacemalloc(ctrl, nvtxs);
+
+  onemaxpwgt = ctrl->ubfactors[0]*graph->tvwgt[0]*ntpwgts[1];
+  oneminpwgt = (1.0/ctrl->ubfactors[0])*graph->tvwgt[0]*ntpwgts[1];
+
+  for (inbfs=0; inbfs<niparts; inbfs++) {
+    iset(nvtxs, 1, where);
+
+    iset(nvtxs, 0, touched);
+
+    pwgts[1] = graph->tvwgt[0];
+    pwgts[0] = 0;
+
+
+    queue[0] = irandInRange(nvtxs, &ctrl->rng_state);
+    touched[queue[0]] = 1;
+    first = 0; 
+    last  = 1;
+    nleft = nvtxs-1;
+    drain = 0;
+
+    /* Start the BFS from queue to get a partition */
+    for (;;) {
+      if (first == last) { /* Empty. Disconnected graph! */
+        if (nleft == 0 || drain)
+          break;
+
+        k = irandInRange(nleft, &ctrl->rng_state);
+        for (i=0; i<nvtxs; i++) {
+          if (touched[i] == 0) {
+            if (k == 0)
+              break;
+            else
+              k--;
+          }
+        }
+
+        queue[0]   = i;
+        touched[i] = 1;
+        first      = 0; 
+        last       = 1;
+        nleft--;
+      }
+
+      i = queue[first++];
+      if (pwgts[0] > 0 && pwgts[1]-vwgt[i] < oneminpwgt) {
+        drain = 1;
+        continue;
+      }
+
+      where[i] = 0;
+      INC_DEC(pwgts[0], pwgts[1], vwgt[i]);
+      if (pwgts[1] <= onemaxpwgt)
+        break;
+
+      drain = 0;
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        k = adjncy[j];
+        if (touched[k] == 0) {
+          queue[last++] = k;
+          touched[k] = 1;
+          nleft--;
+        }
+      }
+    }
+
+    /* Check to see if we hit any bad limiting cases */
+    if (pwgts[1] == 0) 
+      where[irandInRange(nvtxs, &ctrl->rng_state)] = 1;
+    if (pwgts[0] == 0) 
+      where[irandInRange(nvtxs, &ctrl->rng_state)] = 0;
+
+    /*************************************************************
+    * Do some partition refinement 
+    **************************************************************/
+    Compute2WayPartitionParams(ctrl, graph);
+
+    Balance2Way(ctrl, graph, ntpwgts);
+
+    FM_2WayRefine(ctrl, graph, ntpwgts, ctrl->niter);
+
+    if (inbfs == 0 || bestcut > graph->mincut) {
+      bestcut = graph->mincut;
+      icopy(nvtxs, where, bestwhere);
+      if (bestcut == 0)
+        break;
+    }
+  }
+
+  graph->mincut = bestcut;
+  icopy(nvtxs, bestwhere, where);
+
+  WCOREPOP;
+}
+
+/*************************************************************************/
+/* This function takes a graph and produces a tri-section into left, right,
+   and separator using a region growing algorithm. The resulting separator
+   is refined using node FM.
+   The resulting partition is returned in graph->where.
+*/
+/**************************************************************************/
+void GrowBisectionNode(ctrl_t *ctrl, graph_t *graph, real_t *ntpwgts, 
+         idx_t niparts)
+{
+  idx_t i, j, k, nvtxs, drain, nleft, first, last, pwgts[2], oneminpwgt, 
+        onemaxpwgt, from, me, bestcut=0, icut, mincut, inbfs;
+  const idx_t *xadj, *adjncy;
+  idx_t *vwgt, *adjwgt, *where, *bndind;
+  idx_t *queue, *touched, *gain, *bestwhere;
+
+  WCOREPUSH;
+
+  nvtxs  = graph->nvtxs;
+  xadj   = graph->xadj_orig ? graph->xadj_orig : graph->xadj;
+  vwgt   = graph->vwgt;
+  adjncy = graph->adjncy_orig ? graph->adjncy_orig : graph->adjncy;
+  adjwgt = graph->adjwgt;
+
+  bestwhere = iwspacemalloc(ctrl, nvtxs);
+  queue     = iwspacemalloc(ctrl, nvtxs);
+  touched   = iwspacemalloc(ctrl, nvtxs);
+
+  onemaxpwgt = ctrl->ubfactors[0]*graph->tvwgt[0]*0.5;
+  oneminpwgt = (1.0/ctrl->ubfactors[0])*graph->tvwgt[0]*0.5;
+
+
+  /* Allocate refinement memory. Allocate sufficient memory for both edge and node */
+  graph->pwgts  = imalloc(3);
+  graph->where  = imalloc(nvtxs);
+  graph->bndptr = imalloc(nvtxs);
+  graph->bndind = imalloc(nvtxs);
+  graph->id     = imalloc(nvtxs);
+  graph->ed     = imalloc(nvtxs);
+  graph->nrinfo = (nrinfo_t *)malloc(nvtxs*sizeof(nrinfo_t));
+  
+  where  = graph->where;
+  bndind = graph->bndind;
+
+  for (inbfs=0; inbfs<niparts; inbfs++) {
+    iset(nvtxs, 1, where);
+    iset(nvtxs, 0, touched);
+
+    pwgts[1] = graph->tvwgt[0];
+    pwgts[0] = 0;
+
+    queue[0] = irandInRange(nvtxs, &ctrl->rng_state);
+    touched[queue[0]] = 1;
+    first = 0; last = 1;
+    nleft = nvtxs-1;
+    drain = 0;
+
+    /* Start the BFS from queue to get a partition */
+    for (;;) {
+      if (first == last) { /* Empty. Disconnected graph! */
+        if (nleft == 0 || drain)
+          break;
+  
+        k = irandInRange(nleft, &ctrl->rng_state);
+        for (i=0; i<nvtxs; i++) { /* select the kth untouched vertex */
+          if (touched[i] == 0) {
+            if (k == 0)
+              break;
+            else
+              k--;
+          }
+        }
+
+        queue[0]   = i;
+        touched[i] = 1;
+        first      = 0; 
+        last       = 1;
+        nleft--;
+      }
+
+      i = queue[first++];
+      if (pwgts[1]-vwgt[i] < oneminpwgt) {
+        drain = 1;
+        continue;
+      }
+
+      where[i] = 0;
+      INC_DEC(pwgts[0], pwgts[1], vwgt[i]);
+      if (pwgts[1] <= onemaxpwgt)
+        break;
+
+      drain = 0;
+      for (j=xadj[i]; j<xadj[i+1]; j++) {
+        k = adjncy[j];
+        if (touched[k] == 0) {
+          queue[last++] = k;
+          touched[k] = 1;
+          nleft--;
+        }
+      }
+    }
+
+    /*************************************************************
+    * Do some partition refinement 
+    **************************************************************/
+    Compute2WayPartitionParams(ctrl, graph);
+    Balance2Way(ctrl, graph, ntpwgts);
+    FM_2WayRefine(ctrl, graph, ntpwgts, 4);
+
+    /* Construct and refine the vertex separator */
+    for (i=0; i<graph->nbnd; i++) {
+      j = bndind[i];
+      if (xadj[j+1]-xadj[j] > 0) /* ignore islands */
+        where[j] = 2;
+    }
+
+    Compute2WayNodePartitionParams(ctrl, graph); 
+    FM_2WayNodeRefine2Sided(ctrl, graph, 1);
+    FM_2WayNodeRefine1Sided(ctrl, graph, 4);
+
+    
+    if (inbfs == 0 || bestcut > graph->mincut) {
+      bestcut = graph->mincut;
+      icopy(nvtxs, where, bestwhere);
+    }
+  }
+
+  graph->mincut = bestcut;
+  icopy(nvtxs, bestwhere, where);
+
+  WCOREPOP;
+}

data/ext/lpsolver-highs/extern/metis/libmetis/macros.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 1997, Regents of the University of Minnesota
+ *
+ * macros.h
+ *
+ * This file contains macros used in multilevel
+ *
+ * Started 9/25/94
+ * George
+ *
+ * $Id: macros.h 10060 2011-06-02 18:56:30Z karypis $
+ *
+ */
+
+#ifndef _LIBMETIS_MACROS_H_
+#define _LIBMETIS_MACROS_H_
+
+#define SWAP gk_SWAP
+
+/* gets the appropriate option value */
+#define GETOPTION(options, idx, defval) \
+            ((options) == NULL || (options)[idx] == -1 ? defval : (options)[idx]) 
+
+/* converts a user provided ufactor into a real ubfactor */
+#define I2RUBFACTOR(ufactor) (1.0+0.001*(ufactor))
+
+/* set/reset the current workspace core */
+#define WCOREPUSH    wspacepush(ctrl)
+#define WCOREPOP     wspacepop(ctrl)
+
+
+
+/*************************************************************************
+* These macros insert and remove nodes from a Direct Access list 
+**************************************************************************/
+#define ListInsert(n, lind, lptr, i) \
+   do { \
+     lind[n] = i; \
+     lptr[i] = (n)++;\
+   } while(0) 
+
+#define ListDelete(n, lind, lptr, i) \
+   do { \
+     lind[lptr[i]] = lind[--(n)]; \
+     lptr[lind[n]] = lptr[i]; \
+     lptr[i] = -1; \
+   } while(0) 
+
+
+/*************************************************************************
+* These macros insert and remove nodes from the boundary list
+**************************************************************************/
+#define BNDInsert(nbnd, bndind, bndptr, vtx) \
+  ListInsert(nbnd, bndind, bndptr, vtx)
+
+#define BNDDelete(nbnd, bndind, bndptr, vtx) \
+  ListDelete(nbnd, bndind, bndptr, vtx)
+
+#endif