relax4 1.0.0

data/ext/relax4.h

@@ -0,0 +1,187 @@
+#ifndef RELAX4_H_
+#define RELAX4_H_
+
+/* Constants */
+#define RELAX4_OK 0
+#define RELAX4_INFEASIBLE 1
+#define RELAX4_FAIL_OUT_OF_MEMORY 2
+#define RELAX4_FAIL_BAD_SIZE 3
+#define RELAX4_FAIL_BAD_NODE 4
+#define RELAX4_FAIL_BAD_COST 5
+#define RELAX4_FAIL_BAD_CAPACITY 6
+#define RELAX4_OUTPUT_FAIL_NONZERO_DEMAND 101
+#define RELAX4_OUTPUT_FAIL_COMPLEMENTARY_SLACKNESS 102
+
+/**
+ * The default value used for the <tt>large</tt> parameter. It is set to 500
+ * million, which is the value in the original relax4 source.
+ *
+ * Further guidance on how to set <tt>large</tt> is given in NOTE 3 in the
+ * original source:
+ * ALL PROBLEM DATA SHOULD BE LESS THAN LARGE IN MAGNITUDE, AND LARGE SHOULD BE
+ * LESS THAN, SAY, 1/4 THE LARGEST INTEGER*4 OF THE MACHINE USED.  THIS WILL
+ * GUARD PRIMARILY AGAINST OVERFLOW IN UNCAPACITATED PROBLEMS WHERE THE ARC
+ * CAPACITIES ARE TAKEN FINITE BUT VERY LARGE.  NOTE, HOWEVER, THAT AS IN ALL
+ * CODES OPERATING WITH INTEGERS, OVERFLOW MAY OCCUR IF SOME OF THE PROBLEM DATA
+ * TAKES VERY LARGE VALUES.
+ *
+ * Edge capacities must be non-negative and less than or equal to
+ * <tt>large</tt>, and edge costs should not exceed <tt>large/10</tt> in
+ * absolute value, in order to avoid overflow (see RELAX4_DEFAULT_MAX_COST).
+ */
+#define RELAX4_DEFAULT_LARGE 500000000
+
+/**
+ * The guidance in the original relax4 source is that edge costs should not
+ * exceed <tt>large/10</tt> in absolute value, in order to avoid overflow.
+ *
+ * This can be enforced by the relax4_check_inputs function.
+ */
+#define RELAX4_DEFAULT_MAX_COST (RELAX4_DEFAULT_LARGE/10)
+
+/**
+ * Set global state and allocate memory for internal arrays.
+ *
+ * The input arrays are not copied. You can solve several instances of the same
+ * size (same number of nodes and arcs) by modifying the input arrays and then
+ * restarting the call sequence from relax4_check_inputs (or relax4_init_phase1,
+ * if you trust your inputs).
+ *
+ * There can be only one relax4 problem active at a time, because it currently
+ * uses global state.
+ *
+ * The caller is responsible for allocating (and later freeing) the arrays
+ * passed to this function. The relax4_free method should be called to free the
+ * internal arrays. If this call fails, you do not have to call relax4_free to
+ * clean up the internal arrays.
+ *
+ * @param[in] num_nodes number of nodes in the graph; strictly positive
+ *
+ * @param[in] num_arcs number of arcs (edges) in the graph; strictly positive
+ *
+ * @param[in] start_nodes index of node at the start of each arc; the first node
+ * is numbered 1.
+ *
+ * @param[in] end_nodes index of node at the end of each arc; the first node
+ * is numbered 1.
+ *
+ * @param[in] costs cost for each arc; negative costs are allowed; negative cost
+ * cycles are allowed (flows on edges involved in such a cycle are set to
+ * <tt>large</tt>); absolute values of costs must be less than <tt>large</tt>
+ * and should be less than <tt>large/10</tt> to avoid overflow (see
+ * RELAX4_DEFAULT_MAX_COST).
+ *
+ * @param[in] capacities capacity for each arc; for an uncapacitated problem,
+ * set these to a suitably large value (such as <tt>large</tt>); capacities
+ * must be in [0, <tt>large</tt>].
+ *
+ * @param[in] demands demand for each node; a node with negative demand is a
+ * surplus node; demands should balance (sum to zero), or else the problem will
+ * be infeasible.
+ *
+ * @param[in] flows flow on each arc; the solution from relax4_run is stored
+ * in this array.
+ *
+ * @param[in] large a very large integer to represent infinity; see
+ * RELAX4_LARGE_DEFAULT for more information.
+ *
+ * @return RELAX4_OK if allocations succeeded, or RELAX4_FAIL_OUT_OF_MEMORY if
+ * any failed.
+ */
+int relax4_init(integer num_nodes, integer num_arcs,
+    integer start_nodes[],
+    integer end_nodes[],
+    integer costs[],
+    integer capacities[],
+    integer demands[],
+    integer flows[],
+    integer large);
+
+/**
+ * Basic checks on the parameters given to relax4_init.
+ *
+ * You do not have to call this method, but it is recommended (avoid segfaults).
+ *
+ * @param max_cost return RELAX4_FAIL_BAD_COST if any arc cost exceeds
+ * max_cost in absolute value; see RELAX4_DEFAULT_MAX_COST.
+ *
+ * @return RELAX4_OK if checks pass; RELAX4_FAIL_BAD_SIZE (zero arcs or nodes),
+ * RELAX4_FAIL_BAD_NODE (in start_nodes or end_nodes), RELAX4_FAIL_BAD_COST or
+ * RELAX4_FAIL_BAD_CAPACITY otherwise.
+ */
+int relax4_check_inputs(int max_cost);
+
+/**
+ * Reduce arc capacities by as much as possible without changing the problem.
+ *
+ * @return RELAX4_OK if successful; RELAX4_INFEASIBLE if problem was found
+ * to be infeasible during arc capacity reduction.
+ */
+int relax4_init_phase_1();
+
+/**
+ * Initialize the arc flows to satisfy complementary slackness with the node
+ * prices.
+ *
+ * You must call relax4_init_phase_1 first.
+ * Call either this method or relax4_auction, but do not call both.
+ *
+ * @return RELAX4_OK if successful; RELAX4_INFEASIBLE if problem was found to be
+ * infeasible.
+ */
+int relax4_init_phase_2();
+
+/**
+ * Uses a version of the auction algorithm for min cost network flow to compute
+ * a good initial flow and prices for the problem.
+ *
+ * You must call relax4_init_phase_1 first.
+ * Call either this method or relax4_init_phase_2, but do not call both.
+ *
+ * You can get an approximate solution using the auction algorithm by just
+ * calling this method (and not calling relax4_run). The flows will be stored in
+ * the <tt>flows</tt> array passed to relax4_init.
+ *
+ * @return RELAX4_OK if successful; RELAX4_INFEASIBLE if problem was found to be
+ * infeasible.
+ */
+int relax4_auction();
+
+/**
+ * The main solve routine.
+ *
+ * If the problem is feasible, the optimal flows will be stored in
+ * the <tt>flows</tt> array passed to relax4_init. Otherwise, RELAX4_INFEASIBLE
+ * is returned. See also the notes in relax4_init regarding negative cost
+ * cycles.
+ *
+ * You must call (exactly) one of relax4_init_phase_2 or relax4_auction first.
+ *
+ * @return RELAX4_OK if successful; RELAX4_INFEASIBLE if problem was found to be
+ * infeasible.
+ */
+int relax4_run();
+
+/**
+ * Check that there are no unsatisfied demands and that complementary slackness
+ * conditions are satisfied.
+ *
+ * You must call relax4_run first.
+ * You do not have to call this method; it just provides an independent check on
+ * the correctness of relax4_run.
+ *
+ * @return RELAX4_OK if output passes checks; otherwise one of
+ * RELAX4_OUTPUT_FAIL_NONZERO_DEMAND or
+ * RELAX4_OUTPUT_FAIL_COMPLEMENTARY_SLACKNESS.
+ */
+int relax4_check_output();
+
+/**
+ * Free internal working arrays.
+ *
+ * The caller is responsible for freeing the input and output arrays passed in
+ * via relax4_init.
+ */
+void relax4_free();
+
+#endif /* guard */

data/ext/relax4_f2c.h

@@ -0,0 +1,247 @@
+/* RELAX4 includes its own copy of f2c.h in order to avoid depending on f2c,
+ * since we really just need this header.
+ */
+
+/* f2c.h  --  Standard Fortran to C header file */
+
+/**  barf  [ba:rf]  2.  "He suggested using FORTRAN, and everybody barfed."
+
+	- From The Shogakukan DICTIONARY OF NEW ENGLISH (Second edition) */
+
+#ifndef RELAX4_F2C_INCLUDE
+#define RELAX4_F2C_INCLUDE
+
+#if defined(__alpha__) || defined(__sparc64__) || defined(__x86_64__) || defined(__ia64__)
+typedef int integer;
+typedef unsigned int uinteger;
+#else
+typedef long int integer;
+typedef unsigned long int uinteger;
+#endif
+typedef char *address;
+typedef short int shortint;
+typedef float real;
+typedef double doublereal;
+typedef struct { real r, i; } complex;
+typedef struct { doublereal r, i; } doublecomplex;
+#if defined(__alpha__) || defined(__sparc64__) || defined(__x86_64__) || defined(__ia64__)
+typedef int logical;
+#else
+typedef long int logical;
+#endif
+typedef short int shortlogical;
+typedef char logical1;
+typedef char integer1;
+#ifdef INTEGER_STAR_8	/* Adjust for integer*8. */
+#if defined(__alpha__) || defined(__sparc64__) || defined(__x86_64__) || defined(__ia64__)
+typedef long longint;		/* system-dependent */
+typedef unsigned long ulongint;	/* system-dependent */
+#else
+typedef long long longint;              /* system-dependent - oh yeah*/
+typedef unsigned long long ulongint;    /* system-dependent - oh yeah*/
+#endif
+#define qbit_clear(a,b)	((a) & ~((ulongint)1 << (b)))
+#define qbit_set(a,b)	((a) |  ((ulongint)1 << (b)))
+#endif
+
+#define TRUE_ (1)
+#define FALSE_ (0)
+
+/* Extern is for use with -E */
+#ifndef Extern
+#define Extern extern
+#endif
+
+/* I/O stuff */
+
+#ifdef f2c_i2
+/* for -i2 */
+typedef short flag;
+typedef short ftnlen;
+typedef short ftnint;
+#else
+#if defined(__alpha__) || defined(__sparc64__) || defined(__x86_64__) || defined(__ia64__)
+typedef int flag;
+typedef int ftnlen;
+typedef int ftnint;
+#else
+typedef long int flag;
+typedef long int ftnlen;
+typedef long int ftnint;
+#endif
+#endif
+
+/*external read, write*/
+typedef struct
+{	flag cierr;
+	ftnint ciunit;
+	flag ciend;
+	char *cifmt;
+	ftnint cirec;
+} cilist;
+
+/*internal read, write*/
+typedef struct
+{	flag icierr;
+	char *iciunit;
+	flag iciend;
+	char *icifmt;
+	ftnint icirlen;
+	ftnint icirnum;
+} icilist;
+
+/*open*/
+typedef struct
+{	flag oerr;
+	ftnint ounit;
+	char *ofnm;
+	ftnlen ofnmlen;
+	char *osta;
+	char *oacc;
+	char *ofm;
+	ftnint orl;
+	char *oblnk;
+} olist;
+
+/*close*/
+typedef struct
+{	flag cerr;
+	ftnint cunit;
+	char *csta;
+} cllist;
+
+/*rewind, backspace, endfile*/
+typedef struct
+{	flag aerr;
+	ftnint aunit;
+} alist;
+
+/* inquire */
+typedef struct
+{	flag inerr;
+	ftnint inunit;
+	char *infile;
+	ftnlen infilen;
+	ftnint	*inex;	/*parameters in standard's order*/
+	ftnint	*inopen;
+	ftnint	*innum;
+	ftnint	*innamed;
+	char	*inname;
+	ftnlen	innamlen;
+	char	*inacc;
+	ftnlen	inacclen;
+	char	*inseq;
+	ftnlen	inseqlen;
+	char 	*indir;
+	ftnlen	indirlen;
+	char	*infmt;
+	ftnlen	infmtlen;
+	char	*inform;
+	ftnint	informlen;
+	char	*inunf;
+	ftnlen	inunflen;
+	ftnint	*inrecl;
+	ftnint	*innrec;
+	char	*inblank;
+	ftnlen	inblanklen;
+} inlist;
+
+#define VOID void
+
+union Multitype {	/* for multiple entry points */
+	integer1 g;
+	shortint h;
+	integer i;
+	/* longint j; */
+	real r;
+	doublereal d;
+	complex c;
+	doublecomplex z;
+	};
+
+typedef union Multitype Multitype;
+
+/*typedef long int Long;*/	/* No longer used; formerly in Namelist */
+
+struct Vardesc {	/* for Namelist */
+	char *name;
+	char *addr;
+	ftnlen *dims;
+	int  type;
+	};
+typedef struct Vardesc Vardesc;
+
+struct Namelist {
+	char *name;
+	Vardesc **vars;
+	int nvars;
+	};
+typedef struct Namelist Namelist;
+
+#define abs(x) ((x) >= 0 ? (x) : -(x))
+#define dabs(x) (doublereal)abs(x)
+#define min(a,b) ((a) <= (b) ? (a) : (b))
+#define max(a,b) ((a) >= (b) ? (a) : (b))
+#define dmin(a,b) (doublereal)min(a,b)
+#define dmax(a,b) (doublereal)max(a,b)
+#define bit_test(a,b)	((a) >> (b) & 1)
+#define bit_clear(a,b)	((a) & ~((uinteger)1 << (b)))
+#define bit_set(a,b)	((a) |  ((uinteger)1 << (b)))
+
+/* procedure parameter types for -A and -C++ */
+
+#define F2C_proc_par_types 1
+#ifdef __cplusplus
+typedef int /* Unknown procedure type */ (*U_fp)(...);
+typedef shortint (*J_fp)(...);
+typedef integer (*I_fp)(...);
+typedef real (*R_fp)(...);
+typedef doublereal (*D_fp)(...), (*E_fp)(...);
+typedef /* Complex */ VOID (*C_fp)(...);
+typedef /* Double Complex */ VOID (*Z_fp)(...);
+typedef logical (*L_fp)(...);
+typedef shortlogical (*K_fp)(...);
+typedef /* Character */ VOID (*H_fp)(...);
+typedef /* Subroutine */ int (*S_fp)(...);
+#else
+typedef int /* Unknown procedure type */ (*U_fp)();
+typedef shortint (*J_fp)();
+typedef integer (*I_fp)();
+typedef real (*R_fp)();
+typedef doublereal (*D_fp)(), (*E_fp)();
+typedef /* Complex */ VOID (*C_fp)();
+typedef /* Double Complex */ VOID (*Z_fp)();
+typedef logical (*L_fp)();
+typedef shortlogical (*K_fp)();
+typedef /* Character */ VOID (*H_fp)();
+typedef /* Subroutine */ int (*S_fp)();
+#endif
+/* E_fp is for real functions when -R is not specified */
+typedef VOID C_f;	/* complex function */
+typedef VOID H_f;	/* character function */
+typedef VOID Z_f;	/* double complex function */
+typedef doublereal E_f;	/* real function with -R not specified */
+
+/* undef any lower-case symbols that your C compiler predefines, e.g.: */
+
+#ifndef Skip_f2c_Undefs
+#undef cray
+#undef gcos
+#undef mc68010
+#undef mc68020
+#undef mips
+#undef pdp11
+#undef sgi
+#undef sparc
+#undef sun
+#undef sun2
+#undef sun3
+#undef sun4
+#undef u370
+#undef u3b
+#undef u3b2
+#undef u3b5
+#undef unix
+#undef vax
+#endif
+#endif