QSopt_ex.h

Go to the documentation of this file.

/* ========================================================================== */
#ifndef __QSopt_ex__
#define __QSopt_ex__
/* config.h.  Generated from config.h.in by configure.  */
/* config.h.in.  Generated from configure.ac by autoheader.  */
/* Compilation-time debug level */
#ifndef DEBUG
#define DEBUG 1
#endif

/* Define to one if yiu want long double support (if present in the system) */
#ifndef ENABLE_LONG_DOUBLE
#define ENABLE_LONG_DOUBLE 1
#endif

/* Define to 1 if you have the <assert.h> header file. */
#ifndef HAVE_ASSERT_H
#define HAVE_ASSERT_H 1
#endif

/* Define to 1 if you have the <bzlib.h> header file. */
#ifndef HAVE_BZLIB_H
#define HAVE_BZLIB_H 1
#endif

/* Define to 1 if you have the `clock' function. */
#ifndef HAVE_CLOCK
#define HAVE_CLOCK 1
#endif


/* Define to 1 if you don't have `vprintf' but do have `_doprnt.' */
#ifndef HAVE_DOPRNT
/* #undef HAVE_DOPRNT */
#endif

/* Define to 1 if you have the <EGlib.h> header file. */
#ifndef HAVE_EGLIB_H
#define HAVE_EGLIB_H 1
#endif

/* Define to 1 if you have the <errno.h> header file. */
#ifndef HAVE_ERRNO_H
#define HAVE_ERRNO_H 1
#endif

/* Define to 1 if you have the <fcntl.h> header file. */
#ifndef HAVE_FCNTL_H
#define HAVE_FCNTL_H 1
#endif

/* Define to 1 if you have the <float.h> header file. */
#ifndef HAVE_FLOAT_H
#define HAVE_FLOAT_H 1
#endif

/* Define to 1 if you have the `floor' function. */
#ifndef HAVE_FLOOR
#define HAVE_FLOOR 1
#endif

/* Define to 1 if you have the `getrusage' function. */
#ifndef HAVE_GETRUSAGE
#define HAVE_GETRUSAGE 1
#endif

/* Define to 1 if you have the <gmp.h> header file. */
#ifndef HAVE_GMP_H
#define HAVE_GMP_H 1
#endif

/* Define to 1 if you have the <inttypes.h> header file. */
#ifndef HAVE_INTTYPES_H
#define HAVE_INTTYPES_H 1
#endif
/* Define if you have libgmp */
#ifndef HAVE_LIBGMP
#define HAVE_LIBGMP 1
#endif

/* Define to 1 if you have the `m' library (-lm). */
#ifndef HAVE_LIBM
#define HAVE_LIBM 1
#endif

/* Define to 1 if you have the `nsl' library (-lnsl). */
#ifndef HAVE_LIBNSL
/* #undef HAVE_LIBNSL */
#endif

/* Define to 1 if you have the `pthread' library (-lpthread). */
#ifndef HAVE_LIBPTHREAD
#define HAVE_LIBPTHREAD 1
#endif

/* Define to 1 if you have the `resolv' library (-lresolv). */
#ifndef HAVE_LIBRESOLV
#define HAVE_LIBRESOLV 1
#endif

/* Define to 1 if you have the `z' library (-lz). */
#ifndef HAVE_LIBZ
#define HAVE_LIBZ 1
#endif

/* Define to 1 if you have the <limits.h> header file. */
#ifndef HAVE_LIMITS_H
#define HAVE_LIMITS_H 1
#endif

/* Define to 1 if the system has the type `long double'. */
#ifndef HAVE_LONG_DOUBLE
#define HAVE_LONG_DOUBLE 1
#endif

/* Define to 1 if your system has a GNU libc compatible `malloc' function, and
   to 0 otherwise. */
#ifndef HAVE_MALLOC
#define HAVE_MALLOC 1
#endif

/* Define to 1 if you have the <malloc.h> header file. */
#ifndef HAVE_MALLOC_H
#define HAVE_MALLOC_H 1
#endif

/* Define to 1 if you have the <math.h> header file. */
#ifndef HAVE_MATH_H
#define HAVE_MATH_H 1
#endif

/* Define to 1 if you have the <memory.h> header file. */
#ifndef HAVE_MEMORY_H
#define HAVE_MEMORY_H 1
#endif

/* Define to 1 if you have the `memset' function. */
#ifndef HAVE_MEMSET
#define HAVE_MEMSET 1
#endif

/* Define to 1 if you have the <netdb.h> header file. */
#ifndef HAVE_NETDB_H
#define HAVE_NETDB_H 1
#endif

/* Define to 1 if you have the <netinet/in.h> header file. */
#ifndef HAVE_NETINET_IN_H
#define HAVE_NETINET_IN_H 1
#endif

/* Define to 1 if you have the `pow' function. */
#ifndef HAVE_POW
#define HAVE_POW 1
#endif

/* Define to 1 if your system has a GNU libc compatible `realloc' function,
   and to 0 otherwise. */
#ifndef HAVE_REALLOC
#define HAVE_REALLOC 1
#endif

/* Define to 1 if you have the <setjmp.h> header file. */
#ifndef HAVE_SETJMP_H
#define HAVE_SETJMP_H 1
#endif

/* Define to 1 if you have the `sigaction' function. */
#ifndef HAVE_SIGACTION
#define HAVE_SIGACTION 1
#endif

/* Define to 1 if you have the `signal' function. */
#ifndef HAVE_SIGNAL
#define HAVE_SIGNAL 1
#endif

/* Define to 1 if you have the <signal.h> header file. */
#ifndef HAVE_SIGNAL_H
#define HAVE_SIGNAL_H 1
#endif

/* Define to 1 if you have the `sleep' function. */
#ifndef HAVE_SLEEP
#define HAVE_SLEEP 1
#endif

/* Define to one if you want software-based 128-bit floating point numbers */
#ifndef HAVE_SOFTFLOAT
#define HAVE_SOFTFLOAT 1
#endif

/* Define to 1 if you have the `sqrt' function. */
#ifndef HAVE_SQRT
#define HAVE_SQRT 1
#endif

/* Define to 1 if you have the <stdarg.h> header file. */
#ifndef HAVE_STDARG_H
#define HAVE_STDARG_H 1
#endif

/* Define to 1 if you have the <stddef.h> header file. */
#ifndef HAVE_STDDEF_H
#define HAVE_STDDEF_H 1
#endif

/* Define to 1 if you have the <stdint.h> header file. */
#ifndef HAVE_STDINT_H
#define HAVE_STDINT_H 1
#endif

/* Define to 1 if you have the <stdio.h> header file. */
#ifndef HAVE_STDIO_H
#define HAVE_STDIO_H 1
#endif

/* Define to 1 if you have the <stdlib.h> header file. */
#ifndef HAVE_STDLIB_H
#define HAVE_STDLIB_H 1
#endif

/* Define to 1 if you have the `strdup' function. */
#ifndef HAVE_STRDUP
#define HAVE_STRDUP 1
#endif

/* Define to 1 if you have the `strerror' function. */
#ifndef HAVE_STRERROR
#define HAVE_STRERROR 1
#endif

/* Define to 1 if you have the <strings.h> header file. */
#ifndef HAVE_STRINGS_H
#define HAVE_STRINGS_H 1
#endif

/* Define to 1 if you have the <string.h> header file. */
#ifndef HAVE_STRING_H
#define HAVE_STRING_H 1
#endif

/* Define to 1 if you have the <sys/param.h> header file. */
#ifndef HAVE_SYS_PARAM_H
#define HAVE_SYS_PARAM_H 1
#endif

/* Define to 1 if you have the <sys/resource.h> header file. */
#ifndef HAVE_SYS_RESOURCE_H
#define HAVE_SYS_RESOURCE_H 1
#endif

/* Define to 1 if you have the <sys/socket.h> header file. */
#ifndef HAVE_SYS_SOCKET_H
#define HAVE_SYS_SOCKET_H 1
#endif

/* Define to 1 if you have the <sys/stat.h> header file. */
#ifndef HAVE_SYS_STAT_H
#define HAVE_SYS_STAT_H 1
#endif

/* Define to 1 if you have the <sys/times.h> header file. */
#ifndef HAVE_SYS_TIMES_H
#define HAVE_SYS_TIMES_H 1
#endif

/* Define to 1 if you have the <sys/time.h> header file. */
#ifndef HAVE_SYS_TIME_H
#define HAVE_SYS_TIME_H 1
#endif

/* Define to 1 if you have the <sys/types.h> header file. */
#ifndef HAVE_SYS_TYPES_H
#define HAVE_SYS_TYPES_H 1
#endif

/* Define to 1 if you have the <sys/utsname.h> header file. */
#ifndef HAVE_SYS_UTSNAME_H
#define HAVE_SYS_UTSNAME_H 1
#endif

/* Define to 1 if you have the `times' function. */
#ifndef HAVE_TIMES
#define HAVE_TIMES 1
#endif

/* Define to 1 if you have the <time.h> header file. */
#ifndef HAVE_TIME_H
#define HAVE_TIME_H 1
#endif

/* Define to 1 if typeof works with your compiler. */
#ifndef HAVE_TYPEOF
#define HAVE_TYPEOF 1
#endif

/* Define to 1 if you have the <unistd.h> header file. */
#ifndef HAVE_UNISTD_H
#define HAVE_UNISTD_H 1
#endif

/* Define to 1 if you have the `vprintf' function. */
#ifndef HAVE_VPRINTF
#define HAVE_VPRINTF 1
#endif

/* Define to 1 if you have the <zlib.h> header file. */
#ifndef HAVE_ZLIB_H
#define HAVE_ZLIB_H 1
#endif

/* Define to the address where bug reports for this package should be sent. */
#ifndef PACKAGE_BUGREPORT
#define PACKAGE_BUGREPORT "daespino@gmail.com"
#endif

/* Define to the full name of this package. */
#ifndef PACKAGE_NAME
#define PACKAGE_NAME "QSopt_ex"
#endif

/* Define to the full name and version of this package. */
#ifndef PACKAGE_STRING
#define PACKAGE_STRING "QSopt_ex 2.5.10"
#endif

/* Define to the one symbol short name of this package. */
#ifndef PACKAGE_TARNAME
#define PACKAGE_TARNAME "-qsopt_ex-"
#endif

/* Define to the version of this package. */
#ifndef PACKAGE_VERSION
#define PACKAGE_VERSION "2.5.10"
#endif

/* Define as the return type of signal handlers (`int' or `void'). */
#ifndef RETSIGTYPE
#define RETSIGTYPE void
#endif

/* Define to 1 if you have the ANSI C header files. */
#ifndef STDC_HEADERS
#define STDC_HEADERS 1
#endif

/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
#ifndef TIME_WITH_SYS_TIME
#define TIME_WITH_SYS_TIME 1
#endif

/* Compilation-time verbose level */
#ifndef VERBOSE_LEVEL
#define VERBOSE_LEVEL 100
#endif

/* Define to 1 if on AIX 3.
   System headers sometimes define this.
   We just want to avoid a redefinition error message.  */
#ifndef _ALL_SOURCE
# define _ALL_SOURCE 1
#endif

/* Enable GNU extensions on systems that have them.  */
#ifndef _GNU_SOURCE
# define _GNU_SOURCE 1
#endif

/* Define to 1 if on MINIX. */
#ifndef _MINIX
/* #undef _MINIX */
#endif

/* Define to 2 if the system does not provide POSIX.1 features except with
   this defined. */
#ifndef _POSIX_1_SOURCE
/* #undef _POSIX_1_SOURCE */
#endif

/* Define to 1 if you need to in order for `stat' and other things to work. */
#ifndef _POSIX_SOURCE
/* #undef _POSIX_SOURCE */
#endif

/* Define for Solaris 2.5.1 so the uint32_t typedef from <sys/synch.h>,
   <pthread.h>, or <semaphore.h> is not used. If the typedef was allowed, the
   #define below would cause a syntax error. */
#ifndef _UINT32_T
/* #undef _UINT32_T */
#endif

/* Define for Solaris 2.5.1 so the uint64_t typedef from <sys/synch.h>,
   <pthread.h>, or <semaphore.h> is not used. If the typedef was allowed, the
   #define below would cause a syntax error. */
#ifndef _UINT64_T
/* #undef _UINT64_T */
#endif

/* Define for Solaris 2.5.1 so the uint8_t typedef from <sys/synch.h>,
   <pthread.h>, or <semaphore.h> is not used. If the typedef was allowed, the
   #define below would cause a syntax error. */
#ifndef _UINT8_T
/* #undef _UINT8_T */
#endif

/* Required for correct definition of functions like exp2 */
#ifndef _XOPEN_SOURCE
#define _XOPEN_SOURCE 600
#endif

/* Enable extensions on Solaris.  */
#ifndef __EXTENSIONS__
# define __EXTENSIONS__ 1
#endif
#ifndef _POSIX_PTHREAD_SEMANTICS
# define _POSIX_PTHREAD_SEMANTICS 1
#endif
#ifndef _TANDEM_SOURCE
# define _TANDEM_SOURCE 1
#endif

/* Define to empty if `const' does not conform to ANSI C. */
#ifndef const
/* #undef const */
#endif

/* Define to `__inline__' or `__inline' if that's what the C compiler
   calls it, or to nothing if 'inline' is not supported under any name.  */
#ifndef __cplusplus
#ifndef inline
/* #undef inline */
#endif
#endif

/* Define to the type of a signed integer type of width exactly 16 bits if
   such a type exists and the standard includes do not define it. */
#ifndef int16_t
/* #undef int16_t */
#endif

/* Define to the type of a signed integer type of width exactly 32 bits if
   such a type exists and the standard includes do not define it. */
#ifndef int32_t
/* #undef int32_t */
#endif

/* Define to the type of a signed integer type of width exactly 64 bits if
   such a type exists and the standard includes do not define it. */
#ifndef int64_t
/* #undef int64_t */
#endif

/* Define to the type of a signed integer type of width exactly 8 bits if such
   a type exists and the standard includes do not define it. */
#ifndef int8_t
/* #undef int8_t */
#endif

/* Define to rpl_malloc if the replacement function should be used. */
#ifndef malloc
/* #undef malloc */
#endif

/* Define to `int' if <sys/types.h> does not define. */
#ifndef pid_t
/* #undef pid_t */
#endif

/* Define to rpl_realloc if the replacement function should be used. */
#ifndef realloc
/* #undef realloc */
#endif

/* Define to equivalent of C99 restrict keyword, or to nothing if this is not
   supported. Do not define if restrict is supported directly. */
#ifndef restrict
#define restrict __restrict
#endif

/* Define to `unsigned int' if <sys/types.h> does not define. */
#ifndef size_t
/* #undef size_t */
#endif

/* Define to `int' if <sys/types.h> does not define. */
#ifndef ssize_t
/* #undef ssize_t */
#endif

/* Define to __typeof__ if your compiler spells it that way. */
#ifndef typeof
/* #undef typeof */
#endif

/* Define to the type of an unsigned integer type of width exactly 16 bits if
   such a type exists and the standard includes do not define it. */
#ifndef uint16_t
/* #undef uint16_t */
#endif

/* Define to the type of an unsigned integer type of width exactly 32 bits if
   such a type exists and the standard includes do not define it. */
#ifndef uint32_t
/* #undef uint32_t */
#endif

/* Define to the type of an unsigned integer type of width exactly 64 bits if
   such a type exists and the standard includes do not define it. */
#ifndef uint64_t
/* #undef uint64_t */
#endif

/* Define to the type of an unsigned integer type of width exactly 8 bits if
   such a type exists and the standard includes do not define it. */
#ifndef uint8_t
/* #undef uint8_t */
#endif

/* Define to empty if the keyword `volatile' does not work. Warning: valid
   code using `volatile' can become incorrect without. Disable with care. */
#ifndef volatile
/* #undef volatile */
#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/
#ifndef __BASICDEFS__
#define __BASICDEFS__

/* storage type */
#define DENSE          0
#define SPARSE         1

/* type of vector */
#define ROW_SOLVE      1
#define COLUMN_SOLVE   2

/* direction of change in non-basic var */
#define VINCREASE      1
#define VDECREASE      2

/* status of variables */
#define STAT_BASIC     1
#define STAT_UPPER     2
#define STAT_LOWER     3
#define STAT_ZERO      4

#define BOUND_LOWER    1
#define BOUND_UPPER    2

/* type of variables */
#define VARTIFICIAL    1
#define VFIXED         2
#define VFREE          4
#define VUPPER         8
#define VLOWER         16
#define VBOUNDED       32

/* class of variables */
#define CLASS_STRUCT   0
#define CLASS_LOGICAL  1

/* algo */
#define PRIMAL_SIMPLEX 1
#define DUAL_SIMPLEX   2
#define PRIMAL_OR_DUAL 3

/* phase */
#define PRIMAL_PHASEI  1
#define PRIMAL_PHASEII 2
#define DUAL_PHASEI    3
#define DUAL_PHASEII   4

/* number of phases */
#define PHASEI         1
#define PHASEII        2

/* type of pricing (all vars or some) */
#define COMPLETE_PRICING   1
#define PARTIAL_PRICING    2
#define MULTI_PART_PRICING 3

/* default pricing */

#define QS_DEFAULT_PRICE_PI  QS_PRICE_PSTEEP
#define QS_DEFAULT_PRICE_PII QS_PRICE_PSTEEP
#define QS_DEFAULT_PRICE_DI  QS_PRICE_DSTEEP
#define QS_DEFAULT_PRICE_DII QS_PRICE_DSTEEP

/* lp sol status */
#define ILL_LP_SOLVED            1
#define ILL_LP_UNSOLVED          2
#define ILL_MAX_ITER             3
#define ILL_MAX_TIME             4
#define ILL_BND_REACHED          5
#define ILL_PPHASEI_ERROR        6
#define ILL_PPHASEII_ERROR       7
#define ILL_DPHASEI_ERROR        8
#define ILL_DPHASEII_ERROR       9
#define ILL_LP_ABORTED          10

/* basis status */
#define OPTIMAL                  1
#define NONOPTIMAL               2
#define PRIMAL_FEASIBLE          3
#define PRIMAL_INFEASIBLE        4
#define PRIMAL_UNBOUNDED         5
#define DUAL_FEASIBLE            7
#define DUAL_INFEASIBLE          8
#define DUAL_UNBOUNDED           9

/* type of ratio test */
#define RATIOTEST_NORMAL 1
#define RATIOTEST_HARRIS 2

/* control parameters */
#define PARAM_PRATIOTESTS        10
#define PARAM_DRATIOTESTS        20
#define PARAM_PRIMAL_REFACTORGAP 50
#define PARAM_PRIMAL_RESOLVEGAP  25
#define PARAM_DUAL_REFACTORGAP   100
#define PARAM_DUAL_RESOLVEGAP    25
#define PARAM_MAX_NOSOLVE        500
#define PARAM_MAX_NOPROG         300
#define PARAM_NOPROG_FACTOR      15

/* numerical parameters */
#define PARAM_BSHIFT             10
#define PARAM_CSHIFT             10

/* general constants */
#define PARAM_HEAP_UTRIGGER      10
#define PARAM_HEAP_RATIO         4.0

/* errors */
#define E_GENERAL_ERROR          1
#define E_INV_LINSOLVE_OPTION    2
#define E_NO_MEMORY              3
#define E_INVALID_OPTION         4
#define E_NULL_ARGUMENT          5
#define E_SIMPLEX_ERROR          6
#define E_BASIS_SINGULAR         7

#ifndef __QS_BASIS__
#define __QS_BASIS__
typedef struct qsbasis
{
  int nstruct;
  int nrows;
  char *cstat;
  char *rstat;
}
QSbasis;
#endif

typedef struct itcnt_t
{
  int pI_iter;
  int pII_iter;
  int dI_iter;
  int dII_iter;
  int tot_iter;
} itcnt_t;

#ifndef QS_DEFINITIONS
#define QS_DEFINITIONS
#define QS_MIN       (1)
#define QS_MAX       (-1)

/****************************************************************************/
/*                                                                          */
/*                 PARAMETERS THAT CAN BE SET BY setparam                   */
/*                                                                          */
/****************************************************************************/


#define QS_PARAM_PRIMAL_PRICING    0
#define QS_PARAM_DUAL_PRICING      2
#define QS_PARAM_SIMPLEX_DISPLAY   4
#define QS_PARAM_SIMPLEX_MAX_ITERATIONS 5
#define QS_PARAM_SIMPLEX_MAX_TIME  6
#define QS_PARAM_SIMPLEX_SCALING   7
#define QS_PARAM_OBJULIM           8
#define QS_PARAM_OBJLLIM           9


/****************************************************************************/
/*                                                                          */
/*                     VALUES FOR PRICING PARAMETERS                        */
/*                                                                          */
/****************************************************************************/

#define QS_PRICE_PDANTZIG 1
#define QS_PRICE_PDEVEX 2
#define QS_PRICE_PSTEEP 3
#define QS_PRICE_PMULTPARTIAL 4

#define QS_PRICE_DDANTZIG 6
#define QS_PRICE_DSTEEP 7
#define QS_PRICE_DMULTPARTIAL 8
#define QS_PRICE_DDEVEX 9


/****************************************************************************/
/*                                                                          */
/*                         VALUES FOR BASIS STATUS                          */
/*                                                                          */
/****************************************************************************/


#define QS_COL_BSTAT_LOWER     '0'
#define QS_COL_BSTAT_BASIC     '1'
#define QS_COL_BSTAT_UPPER     '2'
#define QS_COL_BSTAT_FREE      '3'

#define QS_ROW_BSTAT_LOWER     '0'
#define QS_ROW_BSTAT_BASIC     '1'
#define QS_ROW_BSTAT_UPPER     '2'


/****************************************************************************/
/*                                                                          */
/*         Return Status for dbl_QSopt_primal, dbl_QSopt_dual, dbl_QSget_status         */
/*                                                                          */
/****************************************************************************/

#define QS_LP_OPTIMAL           1
#define QS_LP_INFEASIBLE        2
#define QS_LP_UNBOUNDED         3
#define QS_LP_ITER_LIMIT        4
#define QS_LP_TIME_LIMIT        5
#define QS_LP_UNSOLVED          6
#define QS_LP_ABORTED   7
#define QS_LP_NUMERR            8
#define QS_LP_OBJ_LIMIT         9
#define QS_LP_MODIFIED        100
#define QS_LP_CHANGE_PREC     1024
#endif



/** @brief If set to one, them we allow to re-start the simplex algorithm due to
 * numerical issues */
#define DO_NUMER 0
/** @brief If set to one, then we allow to re-start simplex due to singular
 * basis */
#define DO_SINGULAR 0

/** @brief Factor for wich we change tolerances each time we have to resume
 * simplex */
#define SIMPLEX_FACTOR 5U
#define DENSE_PI 0
#define DENSE_PIIPI 0
#define DENSE_NORM 0
#define SIMPLEX_DEBUG 0


/* possible values of nextstep */
#define SIMPLEX_CONTINUE   1
#define SIMPLEX_TERMINATE  2
#define SIMPLEX_RESUME     3

/* reason for resuming simplex */
#define SIMPLEX_RESUME_SING     1
#define SIMPLEX_RESUME_UNSHIFT  2
#define SIMPLEX_RESUME_NUMER    3

/* values for newphase */
#define SIMPLEX_PHASE_RECOMP  1
#define SIMPLEX_PHASE_NEW     2

#define SIMPLEX_PIVOTINROW 1
#define SIMPLEX_PIVOTINCOL 2
#define SIMPLEX_MAX_RESTART 4
#define SIMPLEX_MAX_PIVOT_FAIL 300


#define FALSE 0
#define TRUE  1
#define QS_FACTOR_MAX_K        1
#define QS_FACTOR_P            2
#define QS_FACTOR_ETAMAX       3
#define QS_FACTOR_FZERO_TOL    4
#define QS_FACTOR_SZERO_TOL    5
#define QS_FACTOR_PARTIAL_TOL  6
#define QS_FACTOR_UR_SPACE_MUL 7
#define QS_FACTOR_UC_SPACE_MUL 8
#define QS_FACTOR_LC_SPACE_MUL 9
#define QS_FACTOR_LR_SPACE_MUL 10
#define QS_FACTOR_ER_SPACE_MUL 11
#define QS_FACTOR_GROW_MUL     12
#define QS_FACTOR_MAXMULT      13
#define QS_FACTOR_MINMULT      14
#define QS_FACTOR_UPDMAXMULT   15
#define QS_FACTOR_DENSE_FRACT  16
#define QS_FACTOR_DENSE_MIN    17
#define E_CHECK_FAILED 6
#define E_NO_PIVOT 7
#define E_FACTOR_BLOWUP 8
#define E_UPDATE_NOSPACE 9
#define E_UPDATE_SINGULAR_ROW 10
#define E_UPDATE_SINGULAR_COL 11
#define E_SING_NO_DATA 12
#define E_SINGULAR_INTERNAL 13
#define SPARSE_FACTOR 0.05
#define CNT_YNZ           1     /* nz in entering columns */
#define CNT_ZNZ           2     /* nz in ith row of B^{-1}, ie z_i */
#define CNT_ZANZ          3     /* nz in ith row of B^{-1}, ie z_i */
#define CNT_PINZ          4     /* nz in phase II pi (solve) */
#define CNT_P1PINZ        5     /* nz in phase I pi (solve) */
#define CNT_UPNZ          6     /* nz in ftran_updates */
#define CNT_PPHASE1ITER   7     /* primal phase I iterations */
#define CNT_PPHASE2ITER   8
#define CNT_DPHASE1ITER   9     /* dual phase I iterations */
#define CNT_DPHASE2ITER   10
#define CNT_PIPIV         11
#define CNT_PIIPIV        12
#define CNT_DIPIV         13
#define CNT_DIIPIV        14
#define CNT_YRAVG         15
#define CNT_ZARAVG        16

#define ROW_PIVOT         0
#define COL_PIVOT         1

#define ILL_LP_OPTIMAL           1
#define ILL_LP_NONOPTIMAL        2
#define ILL_LP_PRIMAL_FEASIBLE   3
#define ILL_LP_PRIMAL_INFEASIBLE 4
#define ILL_LP_PRIMAL_UNBOUNDED  5
#define ILL_LP_DUAL_FEASIBLE     6
#define ILL_LP_DUAL_INFEASIBLE   7
#define ILL_LP_DUAL_UNBOUNDED    8

typedef enum
{ ILL_MPS_NAME, ILL_MPS_OBJSENSE, ILL_MPS_OBJNAME,
  ILL_MPS_ROWS, ILL_MPS_COLS, ILL_MPS_RHS, ILL_MPS_RANGES,
  ILL_MPS_BOUNDS, ILL_MPS_REFROW, ILL_MPS_ENDATA,
  ILL_MPS_NONE
}
ILLmps_section;

#define ILL_MPS_N_SECTIONS ILL_MPS_NONE

/*define as > 0 if heap is to be used */
#define USEHEAP 1

/*result of pricing */
#define PRICE_OPTIMAL 1
#define PRICE_NONOPTIMAL  2

/*type of pricing */
#define ROW_PRICING 1
#define COL_PRICING 2


/****************************************************************************
 * error collection
 */
#define QS_DATA_ERROR     0
#define QS_DATA_WARN      1
#define QS_MPS_FORMAT_ERROR   2
#define QS_MPS_FORMAT_WARN    3
#define QS_LP_FORMAT_ERROR    4
#define QS_LP_FORMAT_WARN   5
#define QS_INPUT_NERROR        8

/* defs for phase I ratio test */
#define BBOUND    1
#define BATOLOWER 2
#define BATOUPPER 3
#define BBTOLOWER 4
#define BBTOUPPER 5
#define BSKIP     6

/* result of ratio test */
#define RATIO_UNBOUNDED 1
#define RATIO_NOBCHANGE 2
#define RATIO_BCHANGE   3
#define RATIO_FAILED    4
#define RATIO_NEGATIVE  5

/* warning level */
#define QSE_WLVL 10000






#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

#ifndef __URANDOM_H__
#define __URANDOM_H__
/****************************************************************************/
/*                                                                          */
/*                             urandom.c                                    */
/*                                                                          */
/****************************************************************************/

/* since urandom's generator does everything modulo ILL_PRANDMAX, if two
 * seeds are congruent mod x and x|ILL_PRANDMAX, then the resulting numbers
 * will be congruent mod x.  One example was if ILL_PRANDMAX = 1000000000 and
 * urandom is used to generate a point set from a 1000x1000 grid, seeds
 * congruent mod 1000 generate the same point set.
 *
 * For this reason, we use 1000000007 (a prime)
 */
#define ILL_PRANDMAX 1000000007

typedef struct ILLrandstate
{
  int a;
  int b;
  int arr[55];
}
ILLrandstate;


void ILLutil_sprand (
  int seed,
  ILLrandstate * r);

int ILLutil_lprand (
  ILLrandstate * r);



#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: symtab.h,v 1.2 2003/11/05 16:47:22 meven Exp $ */
#ifndef ILL_SYMTAB_H
#define ILL_SYMTAB_H

/* we allow 256KB of buffer space i.e. 2^17*/
#define ILL_namebufsize 0x20000U

typedef struct ILLsymbolent
{
  int symbol;
  int index;
  int next;
}
ILLsymbolent;

typedef struct ILLsymboltab
{
  int *hashtable;
  ILLsymbolent *nametable;
  char *namelist;
  int tablesize;
  int strsize;
  int hashspace;
  int name_space;
  int strspace;
  int freedchars;
  int the_hash;
  int the_index;
  int the_prev_index;
  int index_ok;
}
ILLsymboltab;

/* 
 * hashtable[stringhash(entry) % hashspace] either NO_INDEX or some hash number
 * nametable[hash number] = { next:    another index for nametable 
 *                            symbol:  index into namelist where string resides
 *                          }
 * tablesize:  number of entries   (tablesize <= name_space)
 * name_space:  length of nametable and indexlist
 * hashspace:  length of hashtable   nextprime(name_space)
 * strsize:    number of chars used in namelist 
 * strspace:   length of namelist
 * indexlist:  LP col/row indices for the table entries
 * indexlist_ok:  1 if column indices in indexlist are up-to-date, 0 otherwise
 *
 * Deletion of entries affects their ordering in symboltab->nametable. 
 * Strings may move around within symboltab->namelist. 
 */


#define ILL_SYM_NOINDEX (-1)
extern void ILLsymboltab_init (
  ILLsymboltab * h),
  ILLsymboltab_free (
  ILLsymboltab * h),
  ILLsymboltab_size (
  const ILLsymboltab * h,
  int *p_size),
  ILLsymboltab_prt (
  FILE * fd,
  ILLsymboltab * h);

extern int ILLsymboltab_create (
  ILLsymboltab * h,
  int init_size),
  ILLsymboltab_copy (
  ILLsymboltab * src,
  ILLsymboltab * dst),
  ILLsymboltab_register (
  ILLsymboltab * h,
  const char *s,
  int itemindex,
  int *p_index,
  int *p_existed),
  ILLsymboltab_lookup (
  ILLsymboltab * h,
  const char *s,
  int *p_index),
  ILLsymboltab_index_ok (
  ILLsymboltab * h),
  ILLsymboltab_index_reset (
  ILLsymboltab * h,
  int icount,
  char **names),
  ILLsymboltab_getindex (
  ILLsymboltab * h,
  const char *name,
  int *hindex),
  ILLsymboltab_contains (
  ILLsymboltab * h,
  const char *s),
  ILLsymboltab_delete (
  ILLsymboltab * h,
  const char *s),
  ILLsymboltab_uname (
  ILLsymboltab * h,
  char name[ILL_namebufsize],
  const char *try_prefix1,
  const char *try_prefix2);

extern void ILLsymboltab_unique_name (
  ILLsymboltab * tab,
  int i,
  const char *pref,
  char uname[ILL_namebufsize]);

extern const char *ILLsymboltab_get (
  const ILLsymboltab * tab,
  int i);
extern int ILLsymboltab_rename (
  ILLsymboltab * h,
  int i,
  const char *new_name);

#endif /* __SYMTAB_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* $RCSfile: reporter.h,v $ $Revision: 1.2 $ $Date: 2003/11/05 16:57:39 $ */
#ifndef REPORTER_FILE
#define REPORTER_FILE

typedef int (
  *qsreport_string_fct) (
  void *dest,
  const char *s);

typedef struct qsstring_reporter
{
  qsreport_string_fct report_fct;
  void *dest;
}
qsstring_reporter;

extern int ILL_fprintf (
  void *dest,
  const char *s);

void ILLstring_reporter_init (
  qsstring_reporter * reporter,
  qsreport_string_fct fct,
  void *dest);

void ILLstring_reporter_copy (
  qsstring_reporter * dest,
  qsstring_reporter * src);

#define ILLstring_report(s, reporter)  \
  ((reporter)->report_fct((reporter)->dest, s) < 0)
                   /* used from with ILL fct to report progress */

/* REPORTER_FILE */
#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

#ifndef __ALLOCRUS_H__
#define __ALLOCRUS_H__
/****************************************************************************/
/*                                                                          */
/*                             allocrus.c                                   */
/*                                                                          */
/****************************************************************************/

/****************************************************************************/
/*                                                                          */
/*                   MEMORY ALLOCATION MACROS                               */
/*                                                                          */
/*                           TSP CODE                                       */
/*                                                                          */
/*                                                                          */
/*  Written by:  Applegate, Bixby, Chvatal, and Cook                        */
/*  Date: February 24, 1995 (cofeb24)                                       */
/*  see allocrus.c                                                          */
/*                                                                          */
/****************************************************************************/

extern int ILLTRACE_MALLOC;

#ifndef USEDMALLOC
#define ILL_UTIL_SAFE_MALLOC(nnum,type,varname)                             \
    (((ILLTRACE_MALLOC) ? printf("%s.%d: %s: ILL_UTIL_SAFE_MALLOC: %s = %d * %s\n", __FILE__, __LINE__, __DEV_FUNCTION__, #varname, nnum, #type) : 0), \
     (type *) ILLutil_allocrus (((size_t) (nnum)) * sizeof (type)))
#else
#define ILL_UTIL_SAFE_MALLOC(nnum,type,varname)                             \
    (((ILLTRACE_MALLOC) ? printf("%s.%d: %s: ILL_UTIL_SAFE_MALLOC: %s = %d * %s\n", __FILE__, __LINE__, __DEV_FUNCTION__, #varname, nnum, #type) : 0), \
     (type *) malloc (((size_t) (nnum)) * sizeof (type)))
#endif

#define ILL_IFFREE(object,type) {                                           \
    if ((object)) {                                                        \
       ILLutil_freerus ((void *) (object));                                 \
       object = (type *) NULL;                                             \
    }}

#define ILL_PTRWORLD_ALLOC_ROUTINE(type, ptr_alloc_r, ptr_bulkalloc_r)        \
                                                                             \
static int ptr_bulkalloc_r (ILLptrworld *world, int nalloc)                   \
{                                                                            \
    ILLbigchunkptr *bp;                                                       \
    int i;                                                                   \
    int count = ILL_BIGCHUNK / sizeof ( type );                               \
    type *p;                                                                 \
                                                                             \
    while (nalloc > 0) {                                                     \
        bp = ILLutil_bigchunkalloc ();                                        \
        if (bp == (ILLbigchunkptr *) NULL) {                                  \
            fprintf (stderr, "ptr alloc failed\n");                          \
            return 1;                                                        \
        }                                                                    \
        bp->next = world->chunklist ;                                        \
        world->chunklist = bp;                                               \
                                                                             \
        p = ( type * ) bp->this_one;                                         \
        for (i=count-2; i>=0; i--) {                                         \
            p[i].next = &p[i+1];                                             \
        }                                                                    \
        p[count - 1].next = (type *) world->freelist;                        \
        world->freelist = (void *) p;                                        \
        nalloc -= count;                                                     \
    }                                                                        \
    return 0;                                                                \
}                                                                            \
                                                                             \
static type *ptr_alloc_r (ILLptrworld *world)                                 \
{                                                                            \
    type *p;                                                                 \
                                                                             \
    if (world->freelist == (void *) NULL) {                                  \
        if (ptr_bulkalloc_r (world, 1)) {                                    \
            fprintf (stderr, "ptr alloc failed\n");                          \
            return ( type * ) NULL;                                          \
        }                                                                    \
    }                                                                        \
    p = (type *) world->freelist ;                                           \
    world->freelist = (void *) p->next;                                      \
                                                                             \
    return p;                                                                \
}

#define ILL_PTRWORLD_FREE_ROUTINE(type, ptr_free_r)                           \
                                                                             \
static void ptr_free_r (ILLptrworld *world, type *p)                          \
{                                                                            \
    p->next = (type *) world->freelist ;                                     \
    world->freelist = (void *) p;                                            \
}

#define ILL_PTRWORLD_LISTADD_ROUTINE(type, entrytype, ptr_listadd_r, ptr_alloc_r) \
                                                                             \
static int ptr_listadd_r (type **list, entrytype x, ILLptrworld *world)       \
{                                                                            \
    if (list != (type **) NULL) {                                            \
        type *p = ptr_alloc_r (world);                                       \
                                                                             \
        if (p == (type *) NULL) {                                            \
            fprintf (stderr, "ptr list add failed\n");                       \
            return 1;                                                        \
        }                                                                    \
        p->this = x;                                                         \
        p->next = *list;                                                     \
        *list = p;                                                           \
    }                                                                        \
    return 0;                                                                \
}

#define ILL_PTRWORLD_LISTFREE_ROUTINE(type, ptr_listfree_r, ptr_free_r)       \
                                                                             \
static void ptr_listfree_r (ILLptrworld *world, type *p)                      \
{                                                                            \
    type *next;                                                              \
                                                                             \
    while (p != (type *) NULL) {                                             \
        next = p->next;                                                      \
        ptr_free_r (world, p);                                               \
        p = next;                                                            \
    }                                                                        \
}

#define ILL_PTRWORLD_LEAKS_ROUTINE(type, ptr_leaks_r, field, fieldtype)       \
                                                                             \
static int ptr_leaks_r (ILLptrworld *world, int *total, int *onlist)          \
{                                                                            \
    int count = ILL_BIGCHUNK / sizeof ( type );                               \
    int duplicates = 0;                                                      \
    type * p;                                                                \
    ILLbigchunkptr *bp;                                                       \
                                                                             \
    *total = 0;                                                              \
    *onlist = 0;                                                             \
                                                                             \
    for (bp = world->chunklist ; bp; bp = bp->next)                          \
        (*total) += count;                                                   \
                                                                             \
    for (p = (type *) world->freelist ; p; p = p->next) {                    \
        (*onlist)++;                                                         \
        p-> field = ( fieldtype ) 0;                                         \
    }                                                                        \
    for (p = (type *) world->freelist ; p; p = p->next) {                    \
        if ((unsigned long) p-> field == (unsigned long) (size_t) 1)                           \
            duplicates++;                                                    \
        else                                                                 \
            p-> field = ( fieldtype ) (size_t) 1;                            \
    }                                                                        \
    if (duplicates) {                                                        \
        fprintf (stderr, "WARNING: %d duplicates on ptr free list \n",       \
                 duplicates);                                                \
    }                                                                        \
    return *total - *onlist;                                                 \
}

#define ILL_PTRWORLD_ROUTINES(type, ptr_alloc_r, ptr_bulkalloc_r, ptr_free_r) \
ILL_PTRWORLD_ALLOC_ROUTINE (type, ptr_alloc_r, ptr_bulkalloc_r)               \
ILL_PTRWORLD_FREE_ROUTINE (type, ptr_free_r)

#define ILL_PTRWORLD_LIST_ROUTINES(type, entrytype, ptr_alloc_r, ptr_bulkalloc_r, ptr_free_r, ptr_listadd_r, ptr_listfree_r) \
ILL_PTRWORLD_ROUTINES (type, ptr_alloc_r, ptr_bulkalloc_r, ptr_free_r)        \
ILL_PTRWORLD_LISTADD_ROUTINE (type, entrytype, ptr_listadd_r, ptr_alloc_r)    \
ILL_PTRWORLD_LISTFREE_ROUTINE (type, ptr_listfree_r, ptr_free_r)

#define ILL_BIGCHUNK ((int) ((1<<16) - sizeof (ILLbigchunkptr) - 16))

struct ILLbigchunk;

typedef struct ILLbigchunkptr
{
  void *this_one;
  struct ILLbigchunk *this_chunk;
  struct ILLbigchunkptr *next;
}
ILLbigchunkptr;


typedef struct ILLptrworld
{
  int refcount;
  void *freelist;
  ILLbigchunkptr *chunklist;
}
ILLptrworld;



void *ILLutil_allocrus (
  size_t size),
 *ILLutil_reallocrus (
  void *ptr,
  size_t size),
  ILLutil_freerus (
  void *p),
  ILLutil_bigchunkfree (
  ILLbigchunkptr * bp),
  ILLptrworld_init (
  ILLptrworld * world),
  ILLptrworld_add (
  ILLptrworld * world),
  ILLptrworld_delete (
  ILLptrworld * world);

int ILLutil_reallocrus_scale (
  void **pptr,
  int *pnnum,
  int count,
  double scale,
  size_t size),
  ILLutil_reallocrus_count (
  void **pptr,
  int count,
  size_t size);

ILLbigchunkptr *ILLutil_bigchunkalloc (
  void);



#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

#ifndef __BGETOPT_H__
#define __BGETOPT_H__

/****************************************************************************/
/*                                                                          */
/*                             bgetopt.c                                    */
/*                                                                          */
/****************************************************************************/
int ILLutil_bix_getopt (
  int argc,
  char **argv,
  const char *def,
  int *p_optind,
  char **p_optarg);


#define ILL_BIX_GETOPT_UNKNOWN -3038



#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

#ifndef __ZEIT_H__
#define __ZEIT_H__
/****************************************************************************/
/*                                                                          */
/*                             zeit.c                                       */
/*                                                                          */
/****************************************************************************/

typedef struct ILLutil_timer
{
  double szeit;
  double cum_zeit;
  char name[40];
  int count;
}
ILLutil_timer;


double ILLutil_zeit (
  void),
  ILLutil_real_zeit (
  void),
  ILLutil_stop_timer (
  ILLutil_timer * t,
  int printit),
  ILLutil_total_timer (
  ILLutil_timer * t,
  int printit);


void ILLutil_init_timer (
  ILLutil_timer * t,
  const char *name),
  ILLutil_start_timer (
  ILLutil_timer * t),
  ILLutil_suspend_timer (
  ILLutil_timer * t),
  ILLutil_resume_timer (
  ILLutil_timer * t);



#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: except.h,v 1.3 2003/11/05 17:02:10 meven Exp $ */
#ifndef ILL_except
#define ILL_except

/* Version 2.4 and later of GCC define a magical variable `__PRETTY_FUNCTION__'
   which contains the name of the function currently being defined.
#  define __DEV_FUNCTION__     __PRETTY_FUNCTION__
   This is broken in G++ before version 2.6.
   C9x has a similar variable called __func__, but prefer the GCC one since
   it demangles C++ function names.  */
# ifdef __GNUC__
#  if __GNUC__ > 2 || (__GNUC__ == 2 \
                       && __GNUC_MINOR__ >= (defined __cplusplus ? 6 : 4))
#   define __DEV_FUNCTION__    __PRETTY_FUNCTION__
#  else
#   define __DEV_FUNCTION__    ((__const char *) 0)
#  endif
# else
#  if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
#   define __DEV_FUNCTION__    __func__
#  else
#   define __DEV_FUNCTION__    ((const char *) 0)
#  endif
# endif


/* put debugger breakpoint here */
extern void ILL_report (
  const char *msg,
  const char *fct,
  const char *file,
  unsigned int line,
  int with_source_info);

/* printed message looks as follows
 *
 * with_source_info == 0:   <msg> + "\n"
 *
 * with_source_info == 1:   if (fct != NULL) 
 *                              <msg> + " in function <fct>\n";
 *                          else 
 *                              <msg> + " in file <file> line <line>\n"; 
 */

#define ILL_GENERAL_ERROR -1
#define ILL_NO_MEMORY 2
#define ILL_NULL_PTR  3

#define ILL_REPORT(msg,with) \
    ILL_report(msg, __DEV_FUNCTION__, __FILE__, __LINE__, with)
#ifdef NDEBUG
#define ILL_REPRT(msg) \
    ILL_report(msg, __DEV_FUNCTION__, __FILE__, __LINE__, 0)
#else
#define ILL_REPRT(msg) \
    ILL_report(msg, __DEV_FUNCTION__, __FILE__, __LINE__, 1)
#endif

#define ILL_RESULT(expr, msg) \
{               \
  if (TRACE > 0) { ILL_RETURN(expr, msg); } \
    return expr; \
}

#define ILL_RETURN_PTR(ptr, msg) \
    { void *ILL_RETURN_p = ptr; \
      if (ILL_RETURN_p == NULL) {  \
        if (TRACE > 0) ILL_REPRT(msg); \
      } \
      return ILL_RETURN_p;  \
    }

#ifdef NDEBUG
#define ILL_RETURN(expr, msg)           \
{                   \
  if (expr != 0) {          \
      if (TRACE > 0) ILL_REPRT(msg); \
    }                 \
    return expr;            \
}

#else
#define ILL_RETURN(expr, msg)           \
  {                 \
    if (expr != 0) {                \
      ILL_REPRT(msg);             \
    }                               \
    ILL_IFTRACE("%s: returning %d\n", __DEV_FUNCTION__, expr); \
    return expr;          \
  }
#endif

#define ILL_CHECKnull(expr, msg) \
    { if ((expr) == NULL)  {  \
         ILL_REPRT(msg); \
         rval = ILL_NULL_PTR; \
         goto CLEANUP;  \
      } }

#define ILL_FAILtrue(expr, msg) \
    { if (expr)  {  \
         ILL_REPRT(msg); \
         rval = ILL_GENERAL_ERROR; \
         goto CLEANUP;  \
      } }

#define ILL_FAILtrue_no_rval(expr, msg) \
    { if (expr)  {  \
         ILL_REPRT(msg); \
         goto CLEANUP;  \
      } }


#define ILL_FAILfalse(expr, msg)  ILL_FAILtrue(!(expr), msg)
#define ILL_FAILfalse_no_rval(expr, msg)  ILL_FAILtrue_no_rval(!(expr), msg)

#define ILL_ERROR(rval, msg)      {                 \
                  fprintf(stderr, "%s\n", msg); \
                  rval = 1; goto CLEANUP;     \
                  }
#define ILL_CLEANUP_IF(rval)      { if ((rval) != 0) { goto CLEANUP; } }
#define ILL_CLEANUP               goto CLEANUP

#define ILL_SAFE_MALLOC(lhs, n, type) \
    { lhs = ILL_UTIL_SAFE_MALLOC(n, type, lhs); \
      if (lhs == NULL)  {  \
         ILL_REPRT("Out of memory"); \
         rval = ILL_NO_MEMORY; \
         goto CLEANUP;  \
      }}

#define ILL_SAFE_MALLOC_no_rval(lhs, n, type) \
    { lhs = ILL_UTIL_SAFE_MALLOC(n, type, lhs); \
      if (lhs == NULL)  {  \
         ILL_REPRT("Out of memory"); \
         goto CLEANUP;  \
      }}


#define ILL_NEW(ptr, type) ILL_SAFE_MALLOC(ptr, 1, type)
#define ILL_NEW_no_rval(ptr, type) ILL_SAFE_MALLOC_no_rval(ptr, 1, type)

/* we define debugging verbosity for singular basis */
extern int __QS_SB_VERB;
#endif
/* Taken from EGlib 10-09-26 */
/* EGlib "Efficient General Library" provides some basic structures and
 * algorithms commons in many optimization algorithms.
 *
 * Copyright (C) 2005 Daniel Espinoza and Marcos Goycoolea.
 * 
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by the
 * Free Software Foundation; either version 2.1 of the License, or (at your
 * option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public 
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA 
 * */
/* ========================================================================= */
/** Main Configuration for the library, as debug levels and so on
 * 
 * @par History:
 * - 2010-09-26
 *            - Addapted for QSopt_ex
 * - 2010-08-13
 *            - Add suport for autoconf and configure for header and feature
 *            selection
 * - 2006-01-27
 *          - Handle some problems with stdint.h in SUN
 * - 2005-08-17
 *          - Set memory aligment to 8 bits
 * - 2003-06-02
 *          - First Implementation
 * @version 1.1.1 
 * */
/* ========================================================================= */
#ifndef __QS_CONFIG_H__
#define __QS_CONFIG_H__
#ifdef HAVE_STDIO_H
# include <stdio.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
# include <sys/socket.h>
#endif
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
#ifdef HAVE_SYS_STAT_H
# include <sys/stat.h>
#endif
#ifdef STDC_HEADERS
# include <stdlib.h>
# include <stddef.h>
#else
# ifdef HAVE_STDLIB_H
# include <stdlib.h>
# endif
#endif
#ifdef HAVE_STRING_H
# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
# include <memory.h>
# endif
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#ifdef HAVE_INTTYPES_H
# include <inttypes.h>
#endif
#ifdef HAVE_STDINT_H
# include <stdint.h>
#endif
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#ifdef HAVE_ERRNO_H
# include <errno.h>
#endif
#ifdef HAVE_LIMITS_H
# include <limits.h>
#endif
#ifdef HAVE_MATH_H
# include <math.h>
#endif
#ifdef HAVE_FLOAT_H
# include <float.h>
#endif
#ifdef HAVE_GETOPT_H
# include <getopt.h>
#endif
#ifdef HAVE_NETINET_IN_H
# include <netinet/in.h>
#endif
#ifdef HAVE_NETINET_TCP_H
# include <netinet/tcp.h>
#endif
#ifdef HAVE_NETDB_H
# include <netdb.h>
#endif
#ifdef HAVE_FCNTL_H
# include <fcntl.h>
#endif
#ifdef HAVE_SYS_RESOURCE_H
# include <sys/resource.h>
#endif
#ifdef HAVE_SYS_PARAM_H
# include <sys/param.h>
#endif
#ifdef TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# ifdef HAVE_SYS_TIME_H
# include <sys/time.h>
# else
# include <time.h>
# endif
#endif
#ifdef HAVE_SYS_TIMES_H
# include <sys/times.h>
#endif
#ifdef HAVE_STDARG_H
# include <stdarg.h>
#endif
#ifdef HAVE_SYS_UTSNAME_H
# include <sys/utsname.h>
#endif
#ifdef HAVE_SIGNAL_H
# include <signal.h>
#endif
#ifdef HAVE_SETJMP_H
# include <setjmp.h>
#endif
/* ========================================================================= */
/** @brief if no gmp support, we do not include gmp.h, if on the otherhand, we
 * have libgmp, we MUST have gmp.h */
#ifdef HAVE_LIBGMP
# if HAVE_LIBGMP
#  ifdef HAVE_GMP_H
#   include <gmp.h>
#  else
#   error Must have gmp.h for compiling QSopt_ex
#  endif
# else
#  error Must have gmp.h for compiling QSopt_ex
# endif
# else
#  error Must have gmp.h for compiling QSopt_ex
#endif
/* ========================================================================= */
/** @brief assert Debug options definitions, by defoult set on */
#ifndef DEBUG
#warning you should define DEBUG, assuming it to be 1
#define DEBUG 1
#endif

/* ========================================================================= */
/** @brief assert Verbose options definition, by default set on */
#ifndef VERBOSE_LEVEL
#warning you should define VERBOSE_LEVEL, assuming it to be 1
#define VERBOSE_LEVEL 1
#endif
/* ========================================================================= */
#ifdef HAVE_EGLIB_H
# if HAVE_EGLIB_H
#  include "EGlib.h"
# else
#  error You must have EGlib.h for compilation
# endif
#else
#  error You must have EGlib.h for compilation
#endif
/* ========================================================================= */
/** @brief define version function name */
void QSopt_ex_version(void);
#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  $RCSfile: dbl_qstruct.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $" */
#ifndef dbl___QS_QSTRUCT_H
#define dbl___QS_QSTRUCT_H

typedef struct dbl_qsdata
{
  struct dbl_ILLlpdata *qslp;
  struct dbl_lpinfo *lp;
  struct dbl_price_info *pricing;
  struct dbl_ILLlp_basis *basis;
  struct dbl_ILLlp_cache *cache;
  char *name;
  int qstatus;                  /* QS_LP_UNSOLVED or an opt status  */
  int factorok;                 /* set to 0 if factorization is old */
  int simplex_display;          /* 0 off, 1 on */
  int simplex_scaling;          /* 0 off, 1 on */
  itcnt_t itcnt;
  double uobjlim;
  double lobjlim;
}
dbl_QSdata;

#endif /* dbl___QS_QSTRUCT_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: dbl_editor.h,v 1.2 2003/11/05 16:57:39 meven Exp $ */
#ifndef dbl_EDITOR_H
#define dbl_EDITOR_H

extern void dbl_ILLeditor_init (
  void);
extern void dbl_ILLeditor (
  dbl_QSdata * p);
extern int dbl_ILLeditor_solve (
  dbl_QSdata * p,
  int salgo);

#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: dbl_dstruct.h,v 1.3 2003/11/05 16:57:39 meven Exp $ */
/****************************************************************************/
/*                                                                          */
/*                           dbl_svector.h                                      */
/*                                                                          */
/****************************************************************************/

#ifndef dbl___SVECTOR_H
#define dbl___SVECTOR_H

typedef struct dbl_svector
{
  int nzcnt;
  int *indx;
  int size;
  double *coef;
}
dbl_svector;

void dbl_ILLsvector_init (
  dbl_svector * s),
  dbl_ILLsvector_free (
  dbl_svector * s);

int dbl_ILLsvector_alloc (
  dbl_svector * s,
  int nzcnt),
  dbl_ILLsvector_copy (
  const dbl_svector * s_in,
  dbl_svector * s_out);

#endif /* dbl___SVECTOR_H */

/****************************************************************************/
/*                                                                          */
/*                           dbl_heap.h                                         */
/*                                                                          */
/****************************************************************************/

#ifndef dbl___HEAP_H
#define dbl___HEAP_H

typedef struct
{
  int *entry;
  int *loc;
  double *key;
  int hexist;
  int maxsize;
  int size;
}
dbl_heap;

void dbl_ILLheap_insert (
  dbl_heap * const h,
  int const ix),
  dbl_ILLheap_modify (
  dbl_heap * const h,
  int const ix),
  dbl_ILLheap_delete (
  dbl_heap * const h,
  int const ix),
  dbl_ILLheap_init (
  dbl_heap * const h),
  dbl_ILLheap_free (
  dbl_heap * const h);

int dbl_ILLheap_findmin (
  dbl_heap * const h),
  dbl_ILLheap_build (
  dbl_heap * const h,
  int const nelems,
  double * key);

#endif /* dbl___HEAP_H */

/****************************************************************************/
/*                                                                          */
/*                         matrix.h                                         */
/*                                                                          */
/****************************************************************************/

#ifndef dbl___MATRIX_H
#define dbl___MATRIX_H

typedef struct dbl_ILLmatrix
{
  double *matval;           /* The coefficients.                       */
  int *matcnt;                  /* Number of coefs in each col.            */
  int *matind;                  /* The row indices of the coefs.           */
  int *matbeg;                  /* The start of each col.                  */
  int matcols;                  /* Number of columns.                      */
  int matrows;
  int matcolsize;               /* Length of matbeg and matcnt.            */
  int matsize;                  /* Length of matind and matval.            */
  int matfree;                  /* Free space at end of matind.            */
  /* Note: free elements marked by -1 in     */
  /* matind; we keep at least 1 free at end. */
}
dbl_ILLmatrix;

void dbl_ILLmatrix_init (
  dbl_ILLmatrix * A);
void dbl_ILLmatrix_free (
  dbl_ILLmatrix * A);
void dbl_ILLmatrix_prt (
  EGioFile_t * fd,
  dbl_ILLmatrix * A);

#endif /* dbl___MATRIX_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: dbl_factor.h,v 1.3 2003/11/05 16:57:39 meven Exp $ */
#ifndef dbl___QS_FACTOR_H_
#define dbl___QS_FACTOR_H_

typedef char dbl_QSbool;

typedef struct dbl_uc_info
{
  int cbeg;
  int nzcnt;
  int next;
  int prev;
  int delay;
}
dbl_uc_info;

typedef struct dbl_ur_info
{
  double max;
  int rbeg;
  int nzcnt;
  int pivcnt;
  int next;
  int prev;
  int delay;
}
dbl_ur_info;

typedef struct dbl_lc_info
{
  int cbeg;
  int nzcnt;
  int c;
  int crank;
  int delay;
}
dbl_lc_info;

typedef struct dbl_lr_info
{
  int rbeg;
  int nzcnt;
  int r;
  int rrank;
  int delay;
}
dbl_lr_info;

typedef struct dbl_er_info
{
  int rbeg;
  int nzcnt;
  int r;
}
dbl_er_info;

typedef struct dbl_factor_work
{
  int max_k;
  double fzero_tol;
  double szero_tol;
  double partial_tol;
  double ur_space_mul;
  double uc_space_mul;
  double lc_space_mul;
  double lr_space_mul;
  double er_space_mul;
  double grow_mul;
  int p;
  int etamax;
  double minmult;
  double maxmult;
  double updmaxmult;
  double dense_fract;
  int dense_min;

  double maxelem_orig;
  int nzcnt_orig;
  double maxelem_factor;
  int nzcnt_factor;
  double maxelem_cur;
  int nzcnt_cur;

  double partial_cur;

  int dim;
  int stage;
  int nstages;
  int etacnt;
  double *work_coef;
  int *work_indx;
  dbl_uc_info *uc_inf;
  dbl_ur_info *ur_inf;
  dbl_lc_info *lc_inf;
  dbl_lr_info *lr_inf;
  dbl_er_info *er_inf;
  int *ucindx;                  /* row index for column data */
  int *ucrind;                  /* index of column in row data */
  double *uccoef;           /* coefficient for column data */
  int *urindx;                  /* col index for row data */
  int *urcind;                  /* index of row in column data */
  double *urcoef;           /* coefficient for row data */
  int *lcindx;                  /* row index for L data */
  double *lccoef;           /* coefficient for L row data */
  int *lrindx;                  /* col index for L data */
  double *lrcoef;           /* coefficient for L col data */
  int *erindx;                  /* col index for eta data */
  double *ercoef;           /* coefficient for eta data */
  int *rperm;
  int *rrank;
  int *cperm;
  int *crank;
  dbl_svector xtmp;
  int ur_freebeg;
  int ur_space;
  int uc_freebeg;
  int uc_space;
  int lc_freebeg;
  int lc_space;
  int lr_freebeg;
  int lr_space;
  int er_freebeg;
  int er_space;

  int *p_nsing;
  int **p_singr;
  int **p_singc;

  double *dmat;
  int drows;
  int dcols;
  int dense_base;
}
dbl_factor_work;

void dbl_ILLfactor_init_factor_work (
  dbl_factor_work * f),
  dbl_ILLfactor_free_factor_work (
  dbl_factor_work * f),
  dbl_ILLfactor_ftran (
  dbl_factor_work * f,
  dbl_svector * a,
  dbl_svector * x),
  dbl_ILLfactor_ftran_update (
  dbl_factor_work * f,
  dbl_svector * a,
  dbl_svector * upd,
  dbl_svector * x),
  dbl_ILLfactor_btran (
  dbl_factor_work * f,
  dbl_svector * a,
  dbl_svector * x);

int dbl_ILLfactor_create_factor_work (
  dbl_factor_work * f,
  int dim),
  dbl_ILLfactor_set_factor_iparam (
  dbl_factor_work * f,
  int param,
  int val),
  dbl_ILLfactor_set_factor_dparam (
  dbl_factor_work * f,
  int param,
  double val),
  dbl_ILLfactor (
  dbl_factor_work * f,
  int *basis,
  int *cbeg,
  int *clen,
  int *cindx,
  double * ccoef,
  int *p_nsing,
  int **p_singr,
  int **p_singc),
  dbl_ILLfactor_update (
  dbl_factor_work * f,
  dbl_svector * a,
  int col,
  int *p_refact);

#endif /* dbl___QS_FACTOR_H_ */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: dbl_lpdefs.h,v 1.3 2003/11/05 16:57:39 meven Exp $ */
#ifndef dbl___QS_LPDEFS_H
#define dbl___QS_LPDEFS_H


/* infinity and negative infinity */
#define dbl_INFTY  dbl_ILL_MAXDOUBLE
#define dbl_NINFTY dbl_ILL_MINDOUBLE

/* tolerances, these are initialized in dbl_ILLstart, file dbl_lpdata.c */
//#if EGLPNUM_TYPE != DBL_TYPE && EGLPNUM_TYPE != LDBL_TYPE
/* these three constants are defined in dbl_lpdata.c */
extern double dbl_PARAM_IBASIS_RPIVOT;  /*       0.98 */
extern double dbl_PARAM_IBASIS_RTRIANG;/*       0.01 */
extern double dbl_PARAM_MIN_DNORM;      /*      1e-24 */
extern double dbl_PFEAS_TOLER;          /*       1e-6 */
extern double dbl_BD_TOLER;           /*       1e-7 */
extern double dbl_DFEAS_TOLER;          /*       1e-6 */
extern double dbl_PIVOT_TOLER;          /*      1e-10 */
extern double dbl_SZERO_TOLER;          /*      1e-15 */
extern double dbl_PIVZ_TOLER;         /*      1e-12 */
extern double dbl_OBJBND_TOLER;       /*       1e-2 */
extern double dbl_DBNDPIV_TOLER;        /*       1e-3 */
extern double dbl_DBNDPIV_RATIO;        /*       1e-2 */
extern double dbl_ALTPIV_TOLER;       /*       1e-8 */
//extern double DJZERO_TOLER;/*             1e-8 */
extern double dbl_PROGRESS_ZERO;        /*       1e-7 */
extern double dbl_PROGRESS_THRESH;      /*       1e-5 */
extern double dbl_CB_EPS;             /*      0.001 */
extern double dbl_CB_INF_RATIO;       /*       10.0 */
extern double dbl_CB_PRI_RLIMIT;        /*       0.25 */

/* structure for statistics */
typedef struct
{
  int ynz_cnt;                  /* nz in entering columns */
  int num_y;
  double y_ravg;              /* weighted avg. of current & prior y */
  int znz_cnt;                  /* nz in ith row of B^{-1}, ie z_i */
  int num_z;
  double z_ravg;              /* weighted avg. of current & prior z */
  int zanz_cnt;                 /* nz in z^TA */
  int num_za;
  double za_ravg;           /* weighted avg. of current & prior za */
  int pnorm_cnt;                /* nz in columns for primal norms */
  int dnorm_cnt;                /* nz in rows for dual norms */
  int pinz_cnt;                 /* nz in phase II pi (solve) */
  int num_pi;                   /* # of pi solves */
  int pi1nz_cnt;                /* nz in phase I pi (solve) */
  int num_pi1;                  /* # of phase I pi solves */
  int upnz_cnt;                 /* nz in ftran update vector */
  int num_up;                   /* # of ftran_updates */
  int pupv_cnt;                 /* nz in primal steep updates */
  int dupv_cnt;                 /* nz in dual steep updates */

  int start_slacks;             /* # slacks in beginning */
  int final_slacks;             /* # slacks in the end */
  int start_art;                /* # arts in beginning */
  int final_art;                /* # arts in the end */

  int pI_iter;                  /* primal phase I iterations */
  int pII_iter;
  int dI_iter;                  /* dual phase I iterations */
  int dII_iter;
  int tot_iter;

  int pivpI[10];                /* sizes of pivots */
  int pivpII[10];
  int pivdI[10];
  int pivdII[10];
}
dbl_count_struct;

/* structure for tolerances */
typedef struct
{
  double pfeas_tol;
  double dfeas_tol;
  double pivot_tol;
  double szero_tol;
  double ip_tol;              /* inner primal & dual feas toler */
  double id_tol;
}
dbl_tol_struct;

/* bound information */
typedef struct dbl_bndinfo
{
  double pbound;
  double cbound;
  int btype;
  int varnum;
  struct dbl_bndinfo *next;
}
dbl_bndinfo;

/* bound information */
typedef struct dbl_coefinfo
{
  double pcoef;
  double ccoef;
  int varnum;
  struct dbl_coefinfo *next;
}
dbl_coefinfo;

/* feasibility info */
typedef struct dbl_feas_info
{
  int pstatus;
  int dstatus;
  double totinfeas;
}
dbl_feas_info;

typedef struct dbl_lp_status_info
{
  char optimal;
  char primal_feasible;
  char primal_infeasible;
  char primal_unbounded;
  char dual_feasible;
  char dual_infeasible;
  char dual_unbounded;
  char padd;
}
dbl_lp_status_info;

typedef struct dbl_pI_uinfo
{
  int tctr;
  int i;
  int *perm;
  int *ix;
  int fs;
  double piv;
  double *t;
  double dty;
  double c_obj;
  double tz;
}
dbl_pI_uinfo;

extern void dbl_ILLlp_status_info_init (
  dbl_lp_status_info * ls);

/* structure for local lp information
 * contains lp obj values - status - dimensions - input data -
 * solution vecs - basis info - update vecs - work vecs - bound changes -
 * tolerances - time info - statistics 
 */
typedef struct dbl_lpinfo
{

  double objval;              /* obj info */
  double pobjval;           /* intermediate status info */
  double dobjval;
  double pinfeas;
  double dinfeas;
  double objbound;
  dbl_lp_status_info probstat;      /* final status */
  dbl_lp_status_info basisstat;     /* final status */
  int nrows;                    /* input info follows; given in col format */
  int ncols;
  int *matcnt;
  int *matbeg;
  int *matind;
  double *matval;
  int matfree;
  int matsize;
  double *bz;
  double *lz;
  double *uz;
  double *cz;
  int localrows;                /* set to 1 if these are created locally */
  int *rowcnt;                  /* row info follows, copy of col info */
  int *rowbeg;
  int *rowind;
  double *rowval;

  double *xbz;                /* output info x, pi, reduced cost */
  double *piz;
  double *dz;
  double *pIxbz;              /* output info (phase I) x, pi, reduced cost */
  double *pIpiz;
  double *pIdz;

  int final_phase;              /* final phase, inf & unboundedness info */
  int infub_ix;

  int basisid;                  /* basis and variable info follows */
  int nnbasic;
  int *baz;
  int *nbaz;
  int *vstat;
  int *vindex;
  int fbasisid;
  dbl_factor_work *f;
  int *vtype;                   /* internal var info */
  char *vclass;                 /* structural or logical */

  dbl_svector zz;                   /* local dbl_ILLfactor_update vectors z, yj, za */
  dbl_svector yjz;
  dbl_svector zA;
  dbl_svector work;                 /* local work vector */
  dbl_svector srhs;                 /* local vectors for lin. eq. solves */
  dbl_svector ssoln;
  int *iwork;                   /* local work vector */
  dbl_pI_uinfo upd;                 /* phase I update info */
  int *bfeas;                   /* primal and dual infeasibility info */
  int *dfeas;

  dbl_tol_struct *tol;              /* tolerances */
  dbl_count_struct *cnts;           /* counts */
  int nbchange;                 /* # bound shifts */
  int ncchange;                 /* # obj coef shifts */
  dbl_bndinfo *bchanges;            /* list of bound shifts */
  dbl_coefinfo *cchanges;           /* list of coef shifts */
  int pIratio;                  /* ratio tests */
  int pIIratio;
  int dIratio;
  int dIIratio;

  int maxiter;
  int iterskip;
  double maxtime;
  double starttime;
  struct dbl_ILLlpdata *O;
  ILLrandstate rstate;

}
dbl_lpinfo;

/* pricing structures */
typedef struct
{
  int ninit;
  double *norms;
  int *refframe;
}
dbl_p_devex_info;

typedef struct
{
  double *norms;
}
dbl_p_steep_info;

typedef struct
{
  int k;
  int cgroup;
  int ngroups;
  int *gstart;
  int *gshift;
  int *gsize;
  int bsize;
  int *bucket;
  int *perm;
  double *infeas;
}
dbl_mpart_info;

typedef struct
{
  int ninit;
  double *norms;
  int *refframe;
}
dbl_d_devex_info;

typedef struct
{
  double *norms;
}
dbl_d_steep_info;

/* pricing information */
typedef struct dbl_price_info
{
  int p_strategy;
  int d_strategy;
  int pI_price;
  int pII_price;
  int dI_price;
  int dII_price;
  int cur_price;
  double *p_scaleinf;
  double *d_scaleinf;
  dbl_p_devex_info pdinfo;
  dbl_p_steep_info psinfo;
  dbl_mpart_info pmpinfo;
  dbl_d_devex_info ddinfo;
  dbl_d_steep_info dsinfo;
  dbl_mpart_info dmpinfo;
  dbl_heap h;
  double htrigger;
  int hineff;
  char init;
}
dbl_price_info;

#endif /* dbl___QS_LPDEFS_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: rdline.h,v 1.2 2003/11/05 16:57:39 meven Exp $ */
#ifndef dbl_LINE_READER_FILE_H
#define dbl_LINE_READER_FILE_H


/* #ifdef _WINDOWS */
typedef char *(
  *dbl_qsread_line_fct) (
  char *s,
  int size,
  void *src);

typedef struct dbl_qsline_reader
{
  dbl_qsread_line_fct read_line_fct;
  void *data_src;
  struct dbl_qserror_collector *error_collector;
}
dbl_qsline_reader;

dbl_qsline_reader *dbl_ILLline_reader_new (
  dbl_qsread_line_fct fct,
  void *data_src);
void dbl_ILLline_reader_free (
  dbl_qsline_reader * reader);

#define dbl_ILLline_reader_get(s, size, reader)  \
  (reader)->read_line_fct(s, size, (reader)->data_src)
                   /* used by parsers to retrieve next input line */
/* #else  
 *
 * typedef FILE dbl_qsline_reader; 
 *
 * #define dbl_ILLline_reader_new(fct, data) ((FILE*) (data)) 
 * #define dbl_ILLline_reader_free(reader)  
 * #define dbl_ILLline_reader_get(s, size, reader) fgets(s,size,reader) 
 * #endif 
 */

#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: dbl_lpdata.h,v 1.4 2003/11/05 17:00:56 meven Exp $ */
#ifndef dbl_ILL_LPDATA_H
#define dbl_ILL_LPDATA_H


extern double dbl_ILL_MAXDOUBLE;  /*  1e150 */
extern double dbl_ILL_MINDOUBLE;  /* -1e150 */

#define dbl_ILL_MAXINT    (2147483647)  /* this is equal to 2^31-1 */
#define dbl_ILL_MIN       (1)       /* Must be same as QS_MIN */
#define dbl_ILL_MAX       (-1)      /* Must be same as QS_MAX */

/*  Setting Alg in Presolve  */

#define dbl_ILL_PRE_SCALE           1
#define dbl_ILL_PRE_FIXED           2
#define dbl_ILL_PRE_SINGLE_ROW      4
#define dbl_ILL_PRE_FORCING         8
#define dbl_ILL_PRE_SINGLE_COL     16
#define dbl_ILL_PRE_DUPLICATE_ROW  32
#define dbl_ILL_PRE_DUPLICATE_COL  64
#define dbl_ILL_PRE_EMPTY_COL     128
#define dbl_ILL_PRE_ALL (dbl_ILL_PRE_SCALE | dbl_ILL_PRE_FIXED | dbl_ILL_PRE_SINGLE_ROW           \
                    dbl_ILL_PRE_FORCING | dbl_ILL_PRE_SINGLE_COL | dbl_ILL_PRE_DUPLICATE_ROW \
                   dbl_ILL_PRE_DUPLICATE_COL | dbl_ILL_PRE_EMPTY_COL)
#define dbl_ILL_PRE_SIMPLE (dbl_ILL_PRE_FIXED | dbl_ILL_PRE_EMPTY_COL)

typedef struct dbl_ILLlpdata
{                               /* Complete LP data filled in by mpsread.  */
  int nrows;
  int ncols;
  int nstruct;                  /* Not including logicals.                 */
  int nzcount;
  int rowsize;                  /* Length of row arrays.                   */
  int colsize;                  /* Length of col arrays.                   */
  int structsize;               /* Length of intmarker, structmap,         */
  /* colnames                                */
  int objsense;
  char *sense;                  /* Original sense, not after logicals.     */
  double *obj;
  double *rhs;
  double *rangeval;
  double *lower;
  double *upper;
  dbl_ILLmatrix A;                  /* The coef matrix.                        */
  struct dbl_ILLlp_rows *rA;        /* Coef matrix in row form.                */

  char **rownames;
  ILLsymboltab rowtab;          /* contains rownames in no particular order */
  char *objname;                /* if colname is not NULL it is entered into 
                                 * the rowtab, see reader fcts in dbl_lp.c, dbl_mps.c*/

  char **colnames;              /* columns of struct variables */
  ILLsymboltab coltab;          /* contains colnames in no particular order */

  char *probname;
  char *intmarker;
  int *structmap;               /* Indices of structural variables         */
  int *rowmap;                  /* Indices of logical and range variables  */
  struct dbl_ILLlp_basis *basis;
  struct dbl_ILLlp_predata *presolve;
  struct dbl_ILLlp_sinfo *sinfo;

   /**************************************************************************/
  /* these fields are currently only set by dbl_mps.c reader fcts               */
   /**************************************************************************/
  dbl_ILLmatrix sos;                /* columns are the sets, rows are the  
                                 * problem's structural variables
                                 * coefficients are the weights */

  char *sos_type;               /* type of each set */
  int *is_sos_mem;              /* for each structural variable contains 
                                 *    -1 == not a set member
                                 *     i == member of sos set i 
                                 *          where 0 <= i < sos.matcols */
  char *refrowname;             /* name of reference row */
  int refind;                   /* index of reference row 
                                 *     -1 if refrow was a free row 
                                 *          and weights are found only in the 
                                 *          sos matrix 
                                 *     index >=0 if refrow is also a lp-row */

   /**************************************************************************
    * dbl_QSset_reporter initializes reporter 
    **************************************************************************/
  qsstring_reporter reporter;   /* used from within ILL fcts 
                                 * to report dbl_feedback */
}
dbl_ILLlpdata;

typedef struct dbl_ILLlp_basis
{
  int nstruct;
  int nrows;
  int rownorms_size;
  int colnorms_size;
  char *cstat;
  char *rstat;
  double *rownorms;
  double *colnorms;
}
dbl_ILLlp_basis;

typedef struct dbl_ILLlp_cache
{
  int nstruct;
  int nrows;
  int status;
  double val;
  double *x;
  double *pi;
  double *rc;
  double *slack;
}
dbl_ILLlp_cache;

typedef struct dbl_ILLlp_sinfo
{                               /* LP info returned by presolve            */
  int ncols;
  int nrows;
  int nzcount;
  int rowsize;
  int colsize;
  int objsense;

  double *obj;
  double *rhs;
  double *lower;
  double *upper;

  dbl_ILLmatrix A;

  char **colnames;              /* Just for debugging - not updated */
}
dbl_ILLlp_sinfo;

typedef struct dbl_ILLlp_preline
{
  double rhs;
  double obj;
  double lower;
  double upper;
  int count;
  int *ind;
  int row_or_col;               /* 0 is row, 1 is col */
  double *val;
}
dbl_ILLlp_preline;

typedef struct dbl_ILLlp_preop
{
  int ptype;
  int rowindex;
  int colindex;
  dbl_ILLlp_preline line;
}
dbl_ILLlp_preop;

typedef struct dbl_ILLlp_predata
{                               /* Data needed in un-presolve.            */
  int opcount;
  int opsize;
  dbl_ILLlp_preop *oplist;
  int r_nrows;
  int r_ncols;
  int *colmap;
  int *rowmap;
  double *rowscale;
  double *colscale;
  double *colfixval;
  double *rowfixval;
}
dbl_ILLlp_predata;

typedef struct dbl_ILLlp_rows
{
  int *rowbeg;
  int *rowcnt;
  int *rowind;
  double *rowval;
}
dbl_ILLlp_rows;


/****************************************************************************/
/*                                                                          */
/*                             dbl_lpdata.c                                     */
/*                                                                          */
/****************************************************************************/

struct dbl_qsdata *dbl_ILLread (
  dbl_qsline_reader * file,
  const char *dbl_fname,
  int isMps);
void dbl_ILLstart (
  void);              /**< initialize dbl_ILL_MAXDOUBLE and other 

                           constants, this funtion should be callef AFTER 
                           EGlpNumStart() */
void dbl_ILLend (
  void);            /**< free any internal data asociated with variable 

                         dbl_precision numbers */
void dbl_ILLchange_precision (
  void);                        /**< This function re-compute the internal 

                                     variables dbl_precision to the (previously 
                                     set) EGLPNUM_PRECISION value (done with 
                                     EGlpNumSetPrecision) */
void dbl_ILLlpdata_init (
  dbl_ILLlpdata * lp);
void dbl_ILLlpdata_free (
  dbl_ILLlpdata * lp);
void dbl_ILLlp_basis_init (
  dbl_ILLlp_basis * B);
void dbl_ILLlp_basis_free (
  dbl_ILLlp_basis * B);
void dbl_ILLlp_cache_init (
  dbl_ILLlp_cache * C);
void dbl_ILLlp_cache_free (
  dbl_ILLlp_cache * C);
int dbl_ILLlp_basis_alloc (
  dbl_ILLlp_basis * B,
  int ncols,
  int nrows);
int dbl_ILLlp_cache_alloc (
  dbl_ILLlp_cache * C,
  int ncols,
  int nrows);

int dbl_ILLlp_rows_init (
  dbl_ILLlp_rows * lp_rows,
  dbl_ILLlpdata * lp,
  int include_logicals);
void dbl_ILLlp_rows_clear (
  dbl_ILLlp_rows * lp_rows);
int dbl_ILLprint_report (
  dbl_ILLlpdata * lp,
  const char *format,
  ...);

              /* print to lp->reporter */

/****************************************************************************/
/*                                                                          */
/*                             dbl_presolve.c                                   */
/*                                                                          */
/****************************************************************************/

void dbl_ILLlp_sinfo_init (
  dbl_ILLlp_sinfo * sinfo),
  dbl_ILLlp_sinfo_free (
  dbl_ILLlp_sinfo * sinfo),
  dbl_ILLlp_predata_init (
  dbl_ILLlp_predata * pre),
  dbl_ILLlp_predata_free (
  dbl_ILLlp_predata * pre);

int dbl_ILLlp_add_logicals (
  dbl_ILLlpdata * lp),
  dbl_ILLlp_scale (
  dbl_ILLlpdata * lp),
  dbl_ILLlp_presolve (
  dbl_ILLlpdata * lp,
  int pre_types);

/* ========================================================================= */
/* if non-zero, then internal data has been initialized, and there is some
 * memory allocated, if zero, no internal memory has been allocated
 * (or it has been freed) */
extern int dbl___QSEX_SETUP;

#endif /* __ILL_LPDATA_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: dbl_basis.h,v 1.3 2003/11/05 16:57:39 meven Exp $ */
#ifndef dbl___BASIS_H
#define dbl___BASIS_H


#if 0
#if EGLPNUM_TYPE != DBL_TYPE && EGLPNUM_TYPE != LDBL_TYPE
extern double dbl_CB_PRI_RLIMIT;  /* = 0.25 */
extern double dbl_CB_INF_RATIO; /* = 10.0 */
extern double dbl_CB_EPS;       /* = 0.001 */
#endif
#endif

typedef struct dbl_var_data
{
  int nartif;
  int nslacks;
  int nfree;
  int nbndone;
  int nbounded;
  int nfixed;
  double cmax;
}
dbl_var_data;

void dbl_ILLbasis_init_vardata (
  dbl_var_data * vd);
void dbl_ILLbasis_clear_vardata (
  dbl_var_data * vd);

int dbl_ILLbasis_build_basisinfo (
  dbl_lpinfo * lp),
  dbl_ILLbasis_get_initial (
  dbl_lpinfo * lp,
  int algorithm),
  dbl_ILLbasis_get_cinitial (
  dbl_lpinfo * lp,
  int algorithm),
  dbl_ILLbasis_load (
  dbl_lpinfo * lp,
  dbl_ILLlp_basis * B),
  dbl_ILLbasis_tableau_row (
  dbl_lpinfo * lp,
  int row,
  double * brow,
  double * trow,
  double * rhs,
  int strict),
  dbl_ILLbasis_factor (
  dbl_lpinfo * lp,
  int *singular),
  dbl_ILLbasis_refactor (
  dbl_lpinfo * lp),
  dbl_ILLbasis_update (
  dbl_lpinfo * lp,
  dbl_svector * y,
  int lindex,
  int *refactor,
  int *singular);

void dbl_ILLbasis_column_solve (
  dbl_lpinfo * lp,
  dbl_svector * rhs,
  dbl_svector * soln),
  dbl_ILLbasis_column_solve_update (
  dbl_lpinfo * lp,
  dbl_svector * rhs,
  dbl_svector * upd,
  dbl_svector * soln),
  dbl_ILLbasis_row_solve (
  dbl_lpinfo * lp,
  dbl_svector * rhs,
  dbl_svector * soln),
  dbl_ILLbasis_free_basisinfo (
  dbl_lpinfo * lp),
  dbl_ILLbasis_free_fbasisinfo (
  dbl_lpinfo * lp),
  dbl_ILLbasis_init_basisinfo (
  dbl_lpinfo * lp);

#endif /* dbl___BASIS_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

#ifndef dbl___DHEAPS_I_H__
#define dbl___DHEAPS_I_H__
/****************************************************************************/
/*                                                                          */
/*                             dbl_dheaps_i.c                                   */
/*                                                                          */
/****************************************************************************/

typedef struct dbl_ILLdheap
{
  double *key;
  int *entry;
  int *loc;
  int total_space;
  int size;
}
dbl_ILLdheap;

void dbl_ILLutil_dheap_free (
  dbl_ILLdheap * h),
  dbl_ILLutil_dheap_delete (
  dbl_ILLdheap * h,
  int i),
  dbl_ILLutil_dheap_changekey (
  dbl_ILLdheap * h,
  int i,
  double * newkey),
  dbl_ILLutil_dheap_findmin (
  dbl_ILLdheap * h,
  int *i),
  dbl_ILLutil_dheap_deletemin (
  dbl_ILLdheap * h,
  int *i);

int dbl_ILLutil_dheap_init (
  dbl_ILLdheap * h,
  int k),
  dbl_ILLutil_dheap_resize (
  dbl_ILLdheap * h,
  int newsize),
  dbl_ILLutil_dheap_insert (
  dbl_ILLdheap * h,
  int i);



#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  $RCSfile: dbl_qsopt.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $" */
#ifndef dbl___QS_QSOPT_H
#define dbl___QS_QSOPT_H


#ifdef WIN32

#ifdef QSLIB_EXPORTS
#define dbl_QSLIB_INTERFACE __declspec(dllexport)
#else
#define dbl_QSLIB_INTERFACE __declspec(dllimport)
#endif

#else
#define dbl_QSLIB_INTERFACE extern
#endif

#ifdef WIN32
typedef struct dbl_QSLIB_INTERFACE dbl_qsdata *dbl_QSprob;
typedef struct dbl_QSLIB_INTERFACE qsbasis *dbl_QSbas;
#else
typedef struct dbl_qsdata *dbl_QSprob;
typedef struct qsbasis *dbl_QSbas;
#endif

/****************************************************************************/
/*                                                                          */
/*                 PARAMETERS TO SPECIFY OBJECTIVE SENSE                    */
/*                                                                          */
/****************************************************************************/
/*
#define QS_LP_PRIMAL_FEASIBLE   11
#define QS_LP_PRIMAL_INFEASIBLE 12
#define QS_LP_PRIMAL_UNBOUNDED  13
#define QS_LP_DUAL_FEASIBLE     14
#define QS_LP_DUAL_INFEASIBLE   15
#define QS_LP_DUAL_UNBOUNDED    16
*/

/****************************************************************************/
/*                                                                          */
/*                      QSopt Library Functions                             */
/*                                                                          */
/****************************************************************************/
#ifdef  __cplusplus
extern "C"
{
#endif

#ifdef WIN32
/* 
 *  in WINDOWS we make 
 *     dbl_solver_main/dbl_reader_main part of DLL
 */
dbl_QSLIB_INTERFACE int dbl_solver_main ( int argc, char **argv);
dbl_QSLIB_INTERFACE int dbl_reader_main ( int argc, char **argv);
#endif

dbl_QSLIB_INTERFACE void dbl_QSfree ( void *ptr),
    dbl_QSfree_prob ( dbl_QSprob p),
    dbl_QSfree_basis ( dbl_QSbas B),
    dbl_QSset_precision ( const unsigned prec),/**< set the dbl_precision for floating 
                                                 point numbers to the given 
                                                 number of bits */
    dbl_QSstart ( void),/**< whe we use non native numbers, we need to make 
                         some initializations before operating with the
                         library */
    dbl_QSend ( void);  /**< just to free any internal static data needed by
                         the variable dbl_precision numbers */

dbl_QSLIB_INTERFACE int dbl_QSopt_primal ( dbl_QSprob p, int *status),
    dbl_QSopt_dual ( dbl_QSprob p, int *status),
    dbl_QSopt_pivotin_col ( dbl_QSprob p, int ccnt, int *clist),
    dbl_QSopt_pivotin_row ( dbl_QSprob p, int rcnt, int *rlist),
    dbl_QSopt_strongbranch ( dbl_QSprob p, int ncand, int *candidatelist,
      double * xlist, double * down_vals, double * up_vals,
      int iterations, double objbound),
    dbl_QSchange_objsense ( dbl_QSprob p, int newsense),
    dbl_QSget_objsense ( dbl_QSprob p, int *newsense),
    dbl_QSnew_col ( dbl_QSprob p,const double obj,const double lower,const double upper,
      const char *name),
    dbl_QSadd_cols ( dbl_QSprob p, int num, int *cmatcnt, int *cmatbeg, int *cmatind,
      double * cmatval, double * obj, double * lower,
      double * upper, const char **names),
    dbl_QSadd_col ( dbl_QSprob p, int cnt, int *cmatind, double * cmatval,
      double obj, double lower, double upper, const char *name),
    dbl_QSnew_row ( dbl_QSprob p,const double rhs, int sense, const char *name),
    dbl_QSadd_ranged_rows ( dbl_QSprob p, int num, int *rmatcnt, int *rmatbeg, 
      int *rmatind,const double * rmatval,const double * rhs, char *sense,
      const double* range, const char **names),
    dbl_QSadd_ranged_row ( dbl_QSprob p, int cnt, int *rmatind,const double * rmatval,
      const double * rhs, int sense,const double * range, const char *name),
    dbl_QSadd_rows ( dbl_QSprob p, int num, int *rmatcnt, int *rmatbeg, int *rmatind,
      const double * rmatval,const double * rhs, char *sense, const char **names),
    dbl_QSadd_row ( dbl_QSprob p, int cnt, int *rmatind,const double * rmatval,
      const double * rhs, int sense, const char *name),
    dbl_QSdelete_rows ( dbl_QSprob p, int num, int *dellist),
    dbl_QSdelete_row ( dbl_QSprob p, int rowindex),
    dbl_QSdelete_setrows ( dbl_QSprob p, int *flags),
    dbl_QSdelete_named_row ( dbl_QSprob p, const char *rowname),
    dbl_QSdelete_named_rows_list ( dbl_QSprob p, int num, const char **rownames),
    dbl_QSdelete_cols ( dbl_QSprob p, int num, int *dellist),
    dbl_QSdelete_col ( dbl_QSprob p, int colindex),
    dbl_QSdelete_setcols ( dbl_QSprob p, int *flags),
    dbl_QSdelete_named_column ( dbl_QSprob p, const char *colname),
    dbl_QSdelete_named_columns_list ( dbl_QSprob p, int num, const char **colnames),
    dbl_QSchange_senses ( dbl_QSprob p, int num, int *rowlist, char *sense),
    dbl_QSchange_sense ( dbl_QSprob p, int rowindex, int sense),
    dbl_QSchange_coef ( dbl_QSprob p, int rowindex, int colindex, double coef),
    dbl_QSchange_objcoef ( dbl_QSprob p, int indx, double coef),
    dbl_QSchange_rhscoef ( dbl_QSprob p, int indx, double coef),
    dbl_QSchange_range(dbl_QSprob p, int rowindex, double range),
    dbl_QSchange_bounds ( dbl_QSprob p, int num, int *collist, char *lu, 
      const double * bounds),
    dbl_QSchange_bound ( dbl_QSprob p, int indx, int lu,const double bound),
    dbl_QSload_basis ( dbl_QSprob p, dbl_QSbas B),
    dbl_QSread_and_load_basis ( dbl_QSprob p, const char *filename),
    dbl_QSload_basis_array ( dbl_QSprob p, char *cstat, char *rstat),
    dbl_QSload_basis_and_row_norms_array ( dbl_QSprob p, char *cstat, char *rstat, 
      double * rownorms),
    dbl_QSget_basis_array ( dbl_QSprob p, char *cstat, char *rstat),
    dbl_QSget_basis_and_row_norms_array ( dbl_QSprob p, char *cstat, char *rstat,
      double * rownorms),
    dbl_QSget_binv_row ( dbl_QSprob p, int indx, double * binvrow),
    dbl_QSget_tableau_row ( dbl_QSprob p, int indx, double * tableaurow),
    dbl_QSget_basis_order ( dbl_QSprob p, int *basorder), 
    dbl_QSget_coef (dbl_QSprob p, int rowindex, int colindex, double*coef),
    dbl_QSget_status ( dbl_QSprob p, int *status),
    dbl_QSget_solution ( dbl_QSprob p, double * value, double * x,
      double * pi, double * slack, double * rc),
    dbl_QSget_objval ( dbl_QSprob p, double * value),
    dbl_QSget_pi_array ( dbl_QSprob p, double * pi),
    dbl_QSget_rc_array ( dbl_QSprob p, double * rc),
    dbl_QSget_x_array ( dbl_QSprob p, double * x),
    dbl_QSget_slack_array ( dbl_QSprob p, double * slack),
    dbl_QSget_infeas_array ( dbl_QSprob p, double * pi),
    dbl_QSget_colcount ( dbl_QSprob p),
    dbl_QSget_rowcount ( dbl_QSprob p),
    dbl_QSget_nzcount ( dbl_QSprob p),
    dbl_QSget_obj_list(dbl_QSprob p, int num, int*collist, double*obj),
    dbl_QSget_obj ( dbl_QSprob p, double * obj),
    dbl_QSget_rhs ( dbl_QSprob p, double * rhs),
    dbl_QSget_ranged_rows_list ( dbl_QSprob p, int num, int *rowlist, int **rowcnt,
      int **rowbeg, int **rowind, double ** rowval, double ** rhs,
      char **sense, double **range, char ***names),
    dbl_QSget_ranged_rows ( dbl_QSprob p, int **rowcnt, int **rowbeg, int **rowind,
      double ** rowval, double ** rhs, char **sense, 
      double ** range, char ***names),
    dbl_QSget_senses ( dbl_QSprob p, char*senses),
    dbl_QSget_rows_list ( dbl_QSprob p, int num, int *rowlist, int **rowcnt,
      int **rowbeg, int **rowind, double ** rowval, double ** rhs,
      char **sense, char ***names),
    dbl_QSget_rows ( dbl_QSprob p, int **rowcnt, int **rowbeg, int **rowind,
      double ** rowval, double ** rhs, char **sense, char ***names),
    dbl_QSget_columns_list ( dbl_QSprob p, int num, int *collist, int **colcnt,
      int **colbeg, int **colind, double ** colval, double ** obj,
      double ** lower, double ** upper, char ***names),
    dbl_QSget_columns ( dbl_QSprob p, int **colcnt, int **colbeg, int **colind,
      double ** colval, double ** obj, double ** lower,
      double ** upper, char ***names),
    dbl_QSget_rownames ( dbl_QSprob p, char **rownames),
    dbl_QSget_colnames ( dbl_QSprob p, char **colnames),
    dbl_QSget_bound ( dbl_QSprob p, int colindex, int lu, double * bound),
    dbl_QSget_bounds ( dbl_QSprob p, double * lower, double * upper),
    dbl_QSget_bounds_list(dbl_QSprob p, int num, int*collist, double*lb,
      double*ub),
    dbl_QSget_intflags ( dbl_QSprob p, int *intflags),
    dbl_QSget_intcount ( dbl_QSprob p, int *count),
    dbl_QSget_column_index ( dbl_QSprob p, const char *name, int *colindex),
    dbl_QSget_row_index ( dbl_QSprob p, const char *name, int *rowindex),
    dbl_QSget_named_x ( dbl_QSprob p, const char *colname, double * val),
    dbl_QSget_named_rc ( dbl_QSprob p, const char *colname, double * val),
    dbl_QSget_named_pi ( dbl_QSprob p, const char *rowname, double * val),
    dbl_QSget_named_slack ( dbl_QSprob p, const char *rowname, double * val),
    dbl_QScompute_row_norms ( dbl_QSprob p),
    dbl_QSwrite_prob ( dbl_QSprob p, const char *filename, const char *filetype),
    dbl_QSwrite_prob_file ( dbl_QSprob p, FILE * file, const char *filetype),
    dbl_QSwrite_basis ( dbl_QSprob p, dbl_QSbas B, const char *filename),
    dbl_QStest_row_norms ( dbl_QSprob p),
    dbl_QSget_itcnt(dbl_QSprob p, int *pI_iter, int *pII_iter, int *dI_iter,
      int *dII_iter, int *tot_iter),
    dbl_QSset_param ( dbl_QSprob p, int whichparam, int newvalue),
    dbl_QSset_param_EGlpNum ( dbl_QSprob p, int whichparam, double newvalue),
    dbl_QSget_param ( dbl_QSprob p, int whichparam, int *value),
    dbl_QSget_param_EGlpNum ( dbl_QSprob p, int whichparam, double * value); 

dbl_QSLIB_INTERFACE char *dbl_QSget_probname ( dbl_QSprob p);
dbl_QSLIB_INTERFACE char *dbl_QSget_objname ( dbl_QSprob p);
dbl_QSLIB_INTERFACE char *dbl_QSversion ( void);

dbl_QSLIB_INTERFACE dbl_QSprob dbl_QScreate_prob ( const char *name, int objsense),
    dbl_QSread_prob ( const char *filename, const char *filetype),
    dbl_QSload_prob ( const char *probname, int ncols, int nrows, int *cmatcnt,
      int *cmatbeg, int *cmatind, double * cmatval, int objsense,
      double * obj, double * rhs, char *sense, double * lower,
      double * upper, const char **colnames, const char **rownames),
    dbl_QScopy_prob ( dbl_QSprob p, const char *newname);

dbl_QSLIB_INTERFACE dbl_QSbas dbl_QSget_basis ( dbl_QSprob p),
    dbl_QSread_basis ( dbl_QSprob p, const char *filename);

#ifdef  __cplusplus
}
#endif

/****************************************************************************
 *
 * This is the undocumented part of the QSlib interface 
 *
 ****************************************************************************/
/* 
 * functions to facilitate line by line reading from other sources than 
 * files from within MPS/LP parsers  
 * 
 * functions to facilitate the collection of error information instead of 
 * having the parsers print messages to stderr
 *                              by mps/lp format writers
 * 
 * a problem's reporter is used by the solver code to provide important 
 * dbl_feedback/progress information
 */

#ifdef WIN32
typedef struct dbl_QSLIB_INTERFACE dbl_qsline_reader *dbl_QSline_reader;
typedef struct dbl_QSLIB_INTERFACE dbl_qsformat_error *dbl_QSformat_error;
typedef struct dbl_QSLIB_INTERFACE dbl_qserror_collector *dbl_QSerror_collector;
typedef struct dbl_QSLIB_INTERFACE dbl_qserror_memory *dbl_QSerror_memory;
#else
typedef struct dbl_qsline_reader *dbl_QSline_reader;
typedef struct dbl_qsformat_error *dbl_QSformat_error;
typedef struct dbl_qserror_collector *dbl_QSerror_collector;
typedef struct dbl_qserror_memory *dbl_QSerror_memory;
#endif

#ifdef  __cplusplus
extern "C"
{
#endif
  dbl_QSLIB_INTERFACE const char *dbl_QSformat_error_type_string (
  int tp);

  dbl_QSLIB_INTERFACE int dbl_QSerror_get_type (
  dbl_QSformat_error error);
  dbl_QSLIB_INTERFACE const char *dbl_QSerror_get_desc (
  dbl_QSformat_error error);
  dbl_QSLIB_INTERFACE int dbl_QSerror_get_line_number (
  dbl_QSformat_error error);
  dbl_QSLIB_INTERFACE int dbl_QSerror_get_pos (
  dbl_QSformat_error error);
  dbl_QSLIB_INTERFACE const char *dbl_QSerror_get_line (
  dbl_QSformat_error error);
  dbl_QSLIB_INTERFACE void dbl_QSerror_print (
  FILE * f,
  dbl_QSformat_error error);

  dbl_QSLIB_INTERFACE dbl_QSerror_collector dbl_QSerror_collector_new (
  void *fct,
  void *dest);
  dbl_QSLIB_INTERFACE dbl_QSerror_collector dbl_QSerror_memory_collector_new (
  dbl_QSerror_memory mem);
  dbl_QSLIB_INTERFACE void dbl_QSerror_collector_free (
  dbl_QSerror_collector c);

/****************************************************************************
 * line reader 
 */
  dbl_QSLIB_INTERFACE dbl_QSline_reader dbl_QSline_reader_new (
  void *fct,
  void *data_src);
  /* reader->read_line_fct defaults to fgets */

  dbl_QSLIB_INTERFACE void dbl_QSline_reader_free (
  dbl_QSline_reader reader);

  dbl_QSLIB_INTERFACE void dbl_QSline_reader_set_error_collector (
  dbl_QSline_reader reader,
  dbl_QSerror_collector collector);

  dbl_QSLIB_INTERFACE char *dbl_QSline_reader_get (
  dbl_QSline_reader reader,
  char *s,
  int size);

  dbl_QSLIB_INTERFACE dbl_QSprob dbl_QSget_prob (
  dbl_QSline_reader reader,
  const char *probname,
  const char *filetype);
  /* the MPS and LP parsers uses the fct from reader 
   * to get to next input line */


/****************************************************************************
 * error memory 
 */
  dbl_QSLIB_INTERFACE dbl_QSerror_memory dbl_QSerror_memory_create (
  int takeErrorLines);
  dbl_QSLIB_INTERFACE void dbl_QSerror_memory_free (
  dbl_QSerror_memory mem);

  dbl_QSLIB_INTERFACE int dbl_QSerror_memory_get_nof (
  dbl_QSerror_memory mem,
  int error_type);
  dbl_QSLIB_INTERFACE int dbl_QSerror_memory_get_nerrors (
  dbl_QSerror_memory mem);

  dbl_QSLIB_INTERFACE dbl_QSformat_error dbl_QSerror_memory_get_last_error (
  dbl_QSerror_memory mem);
  dbl_QSLIB_INTERFACE dbl_QSformat_error dbl_QSerror_memory_get_prev_error (
  dbl_QSformat_error e);

/**************************************************************************** 
 * reporter for solver dbl_feedback 
 */
  dbl_QSLIB_INTERFACE void dbl_QSset_reporter (
  dbl_QSprob prob,
  int iterskip,
  void *fct,
  void *dest);

  dbl_QSLIB_INTERFACE int dbl_QSreport_prob (
  dbl_QSprob p,
  const char *filetype,
  dbl_QSerror_collector c);

#ifdef  __cplusplus
}
#endif
#endif                          /* dbl___QS_QSOPT_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: dbl_format.h,v 1.3 2003/11/05 16:59:48 meven Exp $ */
#ifndef dbl_QS_FORMAT_ERROR_H
#define dbl_QS_FORMAT_ERROR_H


/****************************************************************************/
/*
   The LP/MPS readers, writers, 
       dbl_ILLrawlpdata_to_lpdata, and 
   use dbl_ILLformat_error to report problems with their input iff
       the line reader used in reading the problem  or 
       the  dbl_qserror_collector pointer passed to dbl_ILLwrite_lp_file
   is not NULL.

   The QSgui code uses this feature to collect dbl_qsformat_error instances 
   which it uses after reading is done to insert error messages into the 
   input window. 
*/
/****************************************************************************/

/* 
for error type USE: 
          QS_DATA_ERROR     
          QS_DATA_WARN      
          QS_MPS_FORMAT_ERROR   
          QS_MPS_FORMAT_WARN    
          QS_LP_FORMAT_ERROR    
          QS_LP_FORMAT_WARN   
          QS_LP_OBJ_WARN      
          QS_GENERIC_ERROR    
*/

typedef struct dbl_qsformat_error
{
  char *desc;
  char *theLine;
  struct dbl_qsformat_error *next;
  int type;
  int lineNumber;               /* 1 based line counting */
  int at;
}
dbl_qsformat_error;

extern int dbl_ILLformat_error_create (
  dbl_qsformat_error * error,
  int mode,
  const char *desc,
  int lineNum,
  const char *theLine,
  int atPos);
extern void dbl_ILLformat_error_delete (
  dbl_qsformat_error * error);

extern void dbl_ILLformat_error_print (
  EGioFile_t * out,
  dbl_qsformat_error * e);



/*****************************************************************************
 * collecting error messages 
 * either with defining own qsad_error_fct and corresponding data structure 
 * or by using predefined dbl_ILLadd_error_to_memory fct with dbl_qserror_memory
 */

typedef int (
  *dbl_qsadd_error_fct) (
  void *dest,
  const dbl_qsformat_error * error);

typedef struct dbl_qserror_collector
{
  dbl_qsadd_error_fct add_error;
  void *dest;
}
dbl_qserror_collector;

typedef struct dbl_qserror_memory
{
  unsigned int nerror;
  dbl_qsformat_error *error_list;
  char has_error[QS_INPUT_NERROR];
  char hasErrorLines;
}
dbl_qserror_memory;


extern dbl_qserror_collector *dbl_ILLerror_collector_new (
  dbl_qsadd_error_fct fct,
  void *dest);

dbl_qserror_collector *dbl_ILLerror_memory_collector_new (
  dbl_qserror_memory * dest);

extern void dbl_ILLerror_collector_free (
  dbl_qserror_collector * c);

#define dbl_ILLformat_error(collector, error)  \
  ((collector)->add_error((collector)->dest, error))


extern int dbl_ILLadd_error_to_memory (
  void *dest,
  const dbl_qsformat_error * error);

extern dbl_qserror_memory *dbl_ILLerror_memory_create (
  int takeErrorLines);
extern void dbl_ILLerror_memory_free (
  dbl_qserror_memory * mem);

#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  RCS_INFO = "$RCSfile: dbl_rawlp.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $"; */
#ifndef dbl___ILL_RAWLP_H_
#define dbl___ILL_RAWLP_H_

/****************************************************************************/
/* DataStructure and Routines                                               */
/*          to deal with raw lp information as read from mps or lp files    */
/*          support scanning of input                                       */
/*          error reporting                                                 */
/****************************************************************************/


#define dbl_ILL_ISBLANK(p) \
             (((*(p))==' '||(*(p))=='\t'||(*(p))=='\r'||(*(p))=='\f') ? 1 : 0)

/* 
 * we rely on ILLsymboltab property:
 *   the ith name added can be retrieved by ILLsymboltab_get(table, i) 
 *   as long as we never delete names from the symbol table 
 */
typedef struct dbl_rawlpdata
{
  char *name;

  char *rhsname;
  char *rangesname;
  char *boundsname;

  int objsense;                 /* maximize or minimize */
  int objindex;                 /* index of objective row */

  int nrows;                    /* number of rows in problem */
  ILLsymboltab rowtab;          /* ILLsymboltab_get(rowtab, i) name of ith row */

  int sensesize;                /* size of rowsense */
  char *rowsense;               /* rowsense[i] snese of row[i] */

  char *rhsind;                 /* rhsind[i] == 1 we saw an rhs for row[i] */
  /* size is nrows */
  int rhssize;                  /* size of rhs array */
  double *rhs;                /* rhs values for rows; size is nrows */
  char *rangesind;              /* ranges[i] == 1 we saw a range def for row[i] */
  struct dbl_colptr *ranges;        /* list of range values */

  int ncols;                    /* number of cols in problem */
  ILLsymboltab coltab;          /* ILLsymboltab_get(coltab, i) name of ith col */
  int colsize;                  /* size of cols array */
  struct dbl_colptr **cols;

  char *lbind;                  /* lbind[i] == 1  we saw a lower bound for col[i] */
  char *ubind;                  /* ubind[i] == 1  we saw a upper bound for col[i] */
  double *lower;              /* lower[i] = lower bound for col[i] */
  double *upper;              /* upper[i] = upper bound for col[i] */

  int intsize;                  /* size of intmarker array */
  char *intmarker;              /* intmarker[i] == 1  col[i] is an int var */

  /* sos information is tranfered into dbl_ILLmatrix lpdata->sos */
  char *refrow;                 /* name of reference row */
  int refrowind;                /* index of refrow or -1  */

  int is_sos_size;              /* size of is_sos_member array */
  int *is_sos_member;           /* for each col contains either               
                                 *     -1 == no sos memeber 
                                 *     i  == member of set #i */

  int nsos_member;              /* total number of sos set members */
  int sos_weight_size;          /* size of sos_weight array */
  double *sos_weight;       /* sos set elem i has weight of sos_weight[i] 
                                 * value comes from refrow coeficients */
  int sos_col_size;             /* size of sos_col array */
  int *sos_col;                 /* sos elem i is column sos_col[i] */

  int nsos;                     /* number of sos sets */
  int sos_setsize;              /* size of sosset array */
  struct dbl_sosptr *sos_set;       /* type, size, first element of sos sets 
                                 * first is index into sos_weight and sos_col 
                                 * arrays */
  dbl_qserror_collector *error_collector;
  ILLptrworld ptrworld;
}
dbl_rawlpdata;

typedef struct dbl_colptr
{
  double coef;
  struct dbl_colptr *next;
  int this_val;                     /* row index */
}
dbl_colptr;
extern dbl_colptr *dbl_ILLcolptralloc (
  ILLptrworld * p);

typedef struct dbl_sosptr
{
  int nelem;                    /* number of set elements */
  int first;                    /* index of first set element in sosmemeber */
  char type;                    /* set type */
}
dbl_sosptr;
extern const int dbl_ILL_SOS_TYPE1;
extern const int dbl_ILL_SOS_TYPE2;

extern void dbl_ILLinit_rawlpdata (
  dbl_rawlpdata * lp,
  dbl_qserror_collector * collector);
extern void dbl_ILLfree_rawlpdata (
  dbl_rawlpdata * lp);
extern void dbl_ILLraw_clear_matrix (
  dbl_rawlpdata * lp);

extern const char *dbl_ILLraw_rowname (
  dbl_rawlpdata * lp,
  int i);
extern const char *dbl_ILLraw_colname (
  dbl_rawlpdata * lp,
  int i);

extern int dbl_ILLraw_add_col (
  dbl_rawlpdata * lp,
  const char *name,
  int intmarker);
extern int dbl_ILLraw_add_row (
  dbl_rawlpdata * lp,
  const char *name,
  int sense,
  const double rhs);

extern int dbl_ILLraw_add_col_coef (
  dbl_rawlpdata * lp,
  int colind,
  int rowind,
  double coef);

extern int dbl_ILLraw_init_ranges (
  dbl_rawlpdata * lp);
extern int dbl_ILLraw_init_rhs (
  dbl_rawlpdata * lp);

extern int dbl_ILLraw_add_ranges_coef (
  dbl_rawlpdata * lp,
  int rowind,
  double coef);


extern int dbl_ILLraw_add_sos (
  dbl_rawlpdata * lp,
  int sos_type);

                                                /* add empty set with type */
extern int dbl_ILLraw_add_sos_member (
  dbl_rawlpdata * lp,
  int colind);

                                                /* add col to last set */
extern int dbl_ILLraw_is_mem_other_sos (
  dbl_rawlpdata * lp,
  int colind);

extern int dbl_ILLraw_set_rhs_name (
  dbl_rawlpdata * lp,
  const char *name,
  int *skip);
extern int dbl_ILLraw_set_bounds_name (
  dbl_rawlpdata * lp,
  const char *name,
  int *skip);
extern int dbl_ILLraw_set_ranges_name (
  dbl_rawlpdata * lp,
  const char *name,
  int *skip);
extern void dbl_ILLprint_rawlpdata (
  dbl_rawlpdata * lp);

extern char *dbl_ILLraw_unique_name (
  ILLsymboltab * tab,
  char *prefix,
  int i);
extern int dbl_ILLraw_fill_in_rownames (
  dbl_rawlpdata * lp);

extern int dbl_ILLraw_init_bounds (
  dbl_rawlpdata * lp);

extern const char *dbl_ILLraw_set_lowerBound (
  dbl_rawlpdata * lp,
  int i,
  double bnd);
extern const char *dbl_ILLraw_set_upperBound (
  dbl_rawlpdata * lp,
  int i,
  double bnd);
extern const char *dbl_ILLraw_set_fixedBound (
  dbl_rawlpdata * lp,
  int i,
  double bnd);
extern const char *dbl_ILLraw_set_binaryBound (
  dbl_rawlpdata * lp,
  int i);
extern const char *dbl_ILLraw_set_unbound (
  dbl_rawlpdata * lp,
  int colind);
extern int dbl_ILLraw_fill_in_bounds (
  dbl_rawlpdata * lp);

extern int dbl_ILLraw_first_nondefault_bound (
  dbl_ILLlpdata * lp);
extern int dbl_ILLraw_default_lower (
  dbl_ILLlpdata * lp,
  int i);
extern int dbl_ILLraw_default_upper (
  dbl_ILLlpdata * lp,
  int i,
  int ri);

extern int dbl_ILLrawlpdata_to_lpdata (
  dbl_rawlpdata * raw,
  dbl_ILLlpdata * lp);

extern int dbl_ILLdata_error (
  dbl_qserror_collector * collector,
  const char *format,
  ...);
extern void dbl_ILLdata_warn (
  dbl_qserror_collector * collector,
  const char *format,
  ...);

#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: dbl_mps.h,v 1.2 2003/11/05 16:57:39 meven Exp $ */
#ifndef dbl_MPS_H
#define dbl_MPS_H


/****************************************************************************/
/*                                                                          */
/*              Routines to support Reading and Writing MPS Files           */
/*                                                                          */
/****************************************************************************/
extern const char *dbl_ILLmps_section_name[ILL_MPS_N_SECTIONS + 2];


extern int dbl_ILLread_mps (
  dbl_qsline_reader * file,
  const char *filename,
  dbl_rawlpdata * lp);

extern int dbl_ILLwrite_mps (
  dbl_ILLlpdata * lp,
  dbl_qserror_collector * collector);

        /* use lp->reporter for output */

#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  $RCSfile: dbl_price.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $" */
#ifndef dbl___PRICE_H
#define dbl___PRICE_H


typedef struct dbl_price_res
{
  int eindex;
  int dir;
  int lindex;
  int lvstat;
  int price_stat;
  double dinfeas;
  double pinfeas;
}
dbl_price_res;

int dbl_ILLprice_test_for_heap (
  dbl_lpinfo * const lp,
  dbl_price_info * const pinf,
  int const nkeys,
  double * keylist,
  int const algo,
  int const upd),
  dbl_ILLprice_build_heap (
  dbl_price_info * const pinf,
  int const nkeys,
  double * keylist),
  dbl_ILLprice_build_pricing_info (
  dbl_lpinfo * const lp,
  dbl_price_info * const pinf,
  int const phase),
  dbl_ILLprice_update_pricing_info (
  dbl_lpinfo * const lp,
  dbl_price_info * const pinf,
  int const phase,
  dbl_svector * const wz,
  int const eindex,
  int const lindex,
  double y),
  dbl_ILLprice_get_price (
  dbl_price_info * const p,
  int const phase),
  dbl_ILLprice_build_mpartial_info (
  dbl_lpinfo * const lp,
  dbl_price_info * const pinf,
  int const pricetype),
  dbl_ILLprice_build_pdevex_norms (
  dbl_lpinfo * const lp,
  dbl_p_devex_info * const pdinfo,
  int const reinit),
  dbl_ILLprice_update_pdevex_norms (
  dbl_lpinfo * const lp,
  dbl_p_devex_info * const pdinfo,
  int const eindex,
  double yl),
  dbl_ILLprice_build_psteep_norms (
  dbl_lpinfo * const lp,
  dbl_p_steep_info * const psinfo),
  dbl_ILLprice_build_ddevex_norms (
  dbl_lpinfo * const lp,
  dbl_d_devex_info * const ddinfo,
  int const reinit),
  dbl_ILLprice_update_ddevex_norms (
  dbl_lpinfo * const lp,
  dbl_d_devex_info * const ddinfo,
  int const eindex,
  double yl),
  dbl_ILLprice_build_dsteep_norms (
  dbl_lpinfo * const lp,
  dbl_d_steep_info * const dsinfo),
  dbl_ILLprice_get_dsteep_norms (
  dbl_lpinfo * const lp,
  int const count,
  int *constrowind,
  double * const norms),
  dbl_ILLprice_get_rownorms (
  dbl_lpinfo * const lp,
  dbl_price_info * const pinf,
  double * const rnorms),
  dbl_ILLprice_get_colnorms (
  dbl_lpinfo * const lp,
  dbl_price_info * const pinf,
  double * const cnorms),
  dbl_ILLprice_get_newnorms (
  dbl_lpinfo * const lp,
  int const nelems,
  double * const norms,
  int *const matcnt,
  int *const matbeg,
  int *const matind,
  double * const matval,
  int const option),
  dbl_ILLprice_get_new_rownorms (
  dbl_lpinfo * const lp,
  int const newrows,
  double * const rnorms,
  int *const rmatcnt,
  int *const rmatbeg,
  int *const rmatind,
  double * const rmatval),
  dbl_ILLprice_get_new_colnorms (
  dbl_lpinfo * const lp,
  int const newrows,
  double * const rnorms,
  int *const matcnt,
  int *const matbeg,
  int *const matind,
  double * const matval),
  dbl_ILLprice_load_rownorms (
  dbl_lpinfo * const lp,
  double * const rnorms,
  dbl_price_info * const pinf),
  dbl_ILLprice_load_colnorms (
  dbl_lpinfo * const lp,
  double * const cnorms,
  dbl_price_info * const pinf);


void dbl_ILLprice_free_heap (
  dbl_price_info * const pinf),
  dbl_ILLprice_init_pricing_info (
  dbl_price_info * const pinf),
  dbl_ILLprice_free_pricing_info (
  dbl_price_info * const pinf),
  dbl_ILLprice_free_mpartial_info (
  dbl_mpart_info * p),
  dbl_ILLprice_init_mpartial_price (
  dbl_lpinfo * const lp,
  dbl_price_info * const pinf,
  int const phase,
  int const pricetype),
  dbl_ILLprice_update_mpartial_price (
  dbl_lpinfo * const lp,
  dbl_price_info * const pinf,
  int const phase,
  int const pricetype),
  dbl_ILLprice_delete_onempart_price (
  /*dbl_lpinfo * const lp,*/
  dbl_price_info * const pinf,
  int const indx,
  int const pricetype),
  dbl_ILLprice_mpartial_group (
  dbl_lpinfo * const lp,
  dbl_mpart_info * const p,
  int const phase,
  int const g,
  int const pricetype),
  dbl_ILLprice_column (
  dbl_lpinfo * const lp,
  int const ix,
  int const phase,
  dbl_price_res * const pr),
  dbl_ILLprice_row (
  dbl_lpinfo * const lp,
  int const ix,
  int const phase,
  dbl_price_res * const pr),
  dbl_ILLprice_update_psteep_norms (
  dbl_lpinfo * lp,
  dbl_p_steep_info * psinfo,
  dbl_svector * wz,
  int eindex,
  double yl),
  dbl_ILLprice_update_dsteep_norms (
  dbl_lpinfo * const lp,
  dbl_d_steep_info * const dsinfo,
  dbl_svector * const wz,
  int const lindex,
  double yl),
  dbl_ILLprice_compute_dual_inf (
  dbl_lpinfo * const lp,
  dbl_price_info * const p,
  int *const ix,
  int const icnt,
  int const phase),
  dbl_ILLprice_primal (
  dbl_lpinfo * const lp,
  dbl_price_info * const pinf,
  dbl_price_res * const pr,
  int const phase),
  dbl_ILLprice_compute_primal_inf (
  dbl_lpinfo * const lp,
  dbl_price_info * const p,
  int *const ix,
  int const icnt,
  int const phase),
  dbl_ILLprice_dual (
  dbl_lpinfo * const lp,
  dbl_price_info * const pinf,
  int const phase,
  dbl_price_res * const pr);

void dbl_test_dsteep_norms (
  dbl_lpinfo * const lp,
  dbl_price_info * const p);

#endif /* dbl___PRICE_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

#ifndef dbl___PRIORITY_H__
#define dbl___PRIORITY_H__
/****************************************************************************/
/*                                                                          */
/*                             dbl_priority.c                                   */
/*                                                                          */
/****************************************************************************/

typedef struct dbl_ILLpriority
{
  dbl_ILLdheap dbl_heap;
  union dbl_ILLpri_data
  {
    void *data;
    int next;
  }
   *pri_info;
  int space;
  int freelist;
}
dbl_ILLpriority;

void dbl_ILLutil_priority_free (
  dbl_ILLpriority * pri),
  dbl_ILLutil_priority_delete (
  dbl_ILLpriority * pri,
  int handle),
  dbl_ILLutil_priority_changekey (
  dbl_ILLpriority * pri,
  int handle,
  double * newkey),
  dbl_ILLutil_priority_findmin (
  dbl_ILLpriority * pri,
  double * keyval,
  void **en),
  dbl_ILLutil_priority_deletemin (
  dbl_ILLpriority * pri,
  double * keyval,
  void **en);

int dbl_ILLutil_priority_init (
  dbl_ILLpriority * pri,
  int k),
  dbl_ILLutil_priority_insert (
  dbl_ILLpriority * pri,
  void *data,
  double * keyval,
  int *handle);



#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  $RCSfile: dbl_ratio.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $" */
#ifndef dbl___RATIO_H
#define dbl___RATIO_H
typedef struct dbl_ratio_res
{
  double tz;
  int eindex;
  int lindex;
  int lvstat;
  int ratio_stat;
  int boundch;
  int coeffch;
  double lbound;
  double ecoeff;
  double pivotval;
}
dbl_ratio_res;

void dbl_ILLratio_pI_test (
  dbl_lpinfo * const lp,
  int const eindex,
  int const dir,
  dbl_ratio_res * const rs),
  dbl_ILLratio_pII_test (
  dbl_lpinfo * const lp,
  int const eindex,
  int const dir,
  dbl_ratio_res * const rs),
  dbl_ILLratio_dI_test (
  dbl_lpinfo * const lp,
  int const lindex,
  int const lvstat,
  dbl_ratio_res * const rs),
  dbl_ILLratio_dII_test (
  dbl_lpinfo * const lp,
  /*int const lindex,*/
  int const lvstat,
  dbl_ratio_res * const rs),
  dbl_ILLratio_longdII_test (
  dbl_lpinfo * const lp,
  int const lindex,
  int const lvstat,
  dbl_ratio_res * const rs),
  dbl_ILLratio_pivotin_test (
  dbl_lpinfo * const lp,
  int *const rlist,
  int const rcnt,
  dbl_ratio_res * const rs);

#endif /* dbl___RATIO_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  RCS_INFO = "$RCSfile: read_lp_state.h,v $ $Revision: 1.2 $ $Date: 2003/11/05 16:57:39 $"; */
#ifndef dbl_READ_LP_STATE_H
#define dbl_READ_LP_STATE_H

/****************************************************************************/
/*                                                                          */
/*               Routines to support Reading LP Files                       */
/*                                                                          */
/****************************************************************************/

/* 
 * -) anything after '\' is comment 
 * -) variables consist of a-z A-Z 0-9!"#$%(),;.?@_`'{}|~ 
 *    don't start with a digit or '.'
 */


typedef struct dbl_ILLread_lp_state
{
  dbl_qsline_reader *file;
  const char *file_name;
  char *p;
  double bound_val;
  int dbl_interactive;
  int line_num;
  int column_index;
  char realline[ILL_namebufsize];
  char line[ILL_namebufsize];
  char field[ILL_namebufsize + 1];
  char fieldOnFirstCol;
  char eof;
  char sense_val;
}
dbl_ILLread_lp_state;

extern int dbl_ILLread_lp_state_init (
  dbl_ILLread_lp_state * state,
  dbl_qsline_reader * file,
  const char *dbl_fname,
  int interactve);
extern int dbl_ILLread_lp_state_next_line (
  dbl_ILLread_lp_state * state);
extern int dbl_ILLread_lp_state_next_var (
  dbl_ILLread_lp_state * state);
extern int dbl_ILLread_lp_state_keyword (
  dbl_ILLread_lp_state * state,
  const char **kwd);
extern int dbl_ILLread_lp_state_bad_keyword (
  dbl_ILLread_lp_state * state);
extern int dbl_ILLtest_lp_state_keyword (
  dbl_ILLread_lp_state * state,
  const char *kwd[]);
extern int dbl_ILLread_lp_state_next_field (
  dbl_ILLread_lp_state * state);
extern int dbl_ILLread_lp_state_next_field_on_line (
  dbl_ILLread_lp_state * state);
extern void dbl_ILLread_lp_state_prev_field (
  dbl_ILLread_lp_state * state);
extern int dbl_ILLread_lp_state_sign (
  dbl_ILLread_lp_state * state,
  double * sign);
extern int dbl_ILLread_lp_state_possible_coef (
  dbl_ILLread_lp_state * state,
  double * coef,
  const double defValue);

                                        /* returns 1 iff found a number 
                                         * otherwise 0 */
extern int dbl_ILLread_lp_state_possible_bound_value (
  dbl_ILLread_lp_state * state);

                                               /* returns 1 iff found a number 
                                                * otherwise 0 */
extern int dbl_ILLread_lp_state_colon (
  dbl_ILLread_lp_state * state);
extern int dbl_ILLread_lp_state_has_colon (
  dbl_ILLread_lp_state * state);
extern int dbl_ILLread_lp_statxe_has_colon (
  dbl_ILLread_lp_state * state);
extern int dbl_ILLread_lp_state_next_constraint (
  dbl_ILLread_lp_state * state);
extern int dbl_ILLread_lp_state_sense (
  dbl_ILLread_lp_state * state);
extern int dbl_ILLtest_lp_state_sense (
  dbl_ILLread_lp_state * state,
  int all);
extern void dbl_ILLtest_lp_state_bound_sense (
  dbl_ILLread_lp_state * state);
extern int dbl_ILLread_lp_state_value (
  dbl_ILLread_lp_state * state,
  double * d);
extern int dbl_ILLtest_lp_state_next_is (
  dbl_ILLread_lp_state * state,
  const char *str);
extern int dbl_ILLread_lp_state_skip_blanks (
  dbl_ILLread_lp_state * state,
  int wrapLines);

extern int dbl_ILLcheck_subject_to (
  dbl_ILLread_lp_state * state);

/*---------------------------------------------------------------------------*/
/* errors and warnings 
 */
extern int dbl_ILLlp_error (
  dbl_ILLread_lp_state * state,
  const char *format,
  ...);
extern void dbl_ILLlp_warn (
  dbl_ILLread_lp_state * state,
  const char *format,
  ...);

/*---------------------------------------------------------------------------*/
/* shared with read_mps_state.c 
 */
extern int dbl_ILLget_value (
  char *line,
  double * coef);

#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* $RCSfile: rd_mps.h,v $ $Revision: 1.2 $ $Date: 2003/11/05 16:57:39 $ */
#ifndef dbl_READ_MPS_STATE_H
#define dbl_READ_MPS_STATE_H



typedef struct dbl_ILLread_mps_state_struct
{
  int section[ILL_MPS_N_SECTIONS];
  ILLmps_section active;
  const char *file_name;
  dbl_qsline_reader *file;
  unsigned int line_num;
  unsigned int field_num;       /* number of successfully read fields on line */
  int intvar;
  int sosvar;
  char line[ILL_namebufsize];
  char key[ILL_namebufsize];
  char field[ILL_namebufsize];
  char *obj;
  char *p;                      /* ptr to next 'unread' character */
}
dbl_ILLread_mps_state;

extern int dbl_ILLmps_state_init (
  dbl_ILLread_mps_state * state,
  dbl_qsline_reader * file,
  const char *dbl_fname);
extern void dbl_ILLmps_state_clear (
  dbl_ILLread_mps_state * state);
extern int dbl_ILLmps_set_section (
  dbl_ILLread_mps_state * state,
  const ILLmps_section sec);

extern int dbl_ILLmps_next_line (
  dbl_ILLread_mps_state * state);
extern int dbl_ILLmps_next_field (
  dbl_ILLread_mps_state * state);
extern int dbl_ILLmps_next_coef (
  dbl_ILLread_mps_state * state,
  double * coef);
extern int dbl_ILLmps_next_bound (
  dbl_ILLread_mps_state * state,
  double * coef);
extern void dbl_ILLmps_check_end_of_line (
  dbl_ILLread_mps_state * state);
extern void dbl_ILLmps_set_end_of_line (
  dbl_ILLread_mps_state * state);

extern int dbl_ILLmps_int_sos_mode (
  dbl_ILLread_mps_state * state);

extern const char *dbl_ILLmps_possibly_blank_name (
  const char *field,
  dbl_ILLread_mps_state * state,
  ILLsymboltab * tab);
extern int dbl_ILLmps_empty_key (
  dbl_ILLread_mps_state * state);
extern int dbl_ILLmps_empty_field (
  dbl_ILLread_mps_state * state);

extern int dbl_ILLmps_error (
  dbl_ILLread_mps_state * state,
  const char *format,
  ...);
extern void dbl_ILLmps_warn (
  dbl_ILLread_mps_state * state,
  const char *format,
  ...);

#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* $RCSfile: dbl_simplex.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $ */

#ifndef dbl___SIMPLEX_H
#define dbl___SIMPLEX_H

struct itcnt_t;
typedef struct dbl_param_info
{
  int origalgo;
  int pphaseI;
  int pphaseII;
  int dphaseI;
  int dphaseII;
  int p_strategy;
  int d_strategy;
}
dbl_param_info;

typedef struct dbl_iter_info
{
  int newphase;
  int nextphase;
  int nextstep;
  int sdisplay;
  int itercnt;
  int solstatus;
  int curtime;
  int rounds;
  int chkobj;
  int nosolve;
  int noprog;
  int inner;
  int algorithm;
  int resumeid;
  int pricetype;
  int n_restart;
  int n_pivot_fail;
  double prevobj;
  double objtol;
  dbl_param_info oldinfo;
}
dbl_iter_info;

void dbl_ILLsimplex_init_lpinfo ( dbl_lpinfo * lp),
    dbl_ILLsimplex_free_lpinfo ( dbl_lpinfo * lp),
    dbl_ILLsimplex_load_lpinfo ( dbl_ILLlpdata * qslp, dbl_lpinfo * lp),
    dbl_ILLsimplex_set_bound ( dbl_lpinfo * lp, const double * objbound, int sense);
void dbl_free_internal_lpinfo ( dbl_lpinfo * lp);
void dbl_init_internal_lpinfo ( dbl_lpinfo * lp);
int dbl_build_internal_lpinfo ( dbl_lpinfo * lp);
int dbl_ILLsimplex_retest_psolution ( dbl_lpinfo * lp, dbl_price_info * p, int phase,
      dbl_feas_info * fs),
    dbl_ILLsimplex_retest_dsolution ( dbl_lpinfo * lp, dbl_price_info * p, int phase,
      dbl_feas_info * fs),
    dbl_ILLsimplex_solution ( dbl_lpinfo * lp, double * xz, double * piz,
      double * dz, double * objval),
    dbl_ILLsimplex_infcertificate ( dbl_lpinfo * lp, double * pi),
    dbl_ILLsimplex ( dbl_lpinfo * lp, int algorithm, dbl_ILLlp_basis * B, 
      dbl_price_info * pinf, int *sol_status, int sdisplay, itcnt_t* itcnt),
    dbl_ILLsimplex_pivotin ( dbl_lpinfo * lp, dbl_price_info * pinf, int rcnt, 
      int *rlist, int pivot_opt, int *basis_mod);

#endif /* dbl___SIMPLEX_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  RCS_INFO = "$RCSfile: wr_lp.h,v $ $Revision: 1.2 $ $Date: 2003/11/05 16:57:39 $"; */
#ifndef dbl_WRITE_LP_STATE_H
#define dbl_WRITE_LP_STATE_H

/****************************************************************************/
/*                                                                          */
/*               Routines to support writing of LP files                    */
/*                                                                          */
/****************************************************************************/

/* 
 * -) anything after '\' is comment 
 * -) variables consist of a-z A-Z 0-9!"#$%(),;.?@_`'{}|~ 
 *    don't start with a digit or '.'
 */

typedef struct dbl_ILLwrite_lp_state
{
  char buf[ILL_namebufsize];
  char *p;
  int startlen;
  int total;
}
dbl_ILLwrite_lp_state;

extern void dbl_ILLwrite_lp_state_init (
  dbl_ILLwrite_lp_state * line,
  const char *str);
extern void dbl_ILLwrite_lp_state_append (
  dbl_ILLwrite_lp_state * line,
  const char *str);
extern void dbl_ILLwrite_lp_state_append_coef (
  dbl_ILLwrite_lp_state * line,
  double v,
  int cnt);

      /* append number sign ('+', '-') iff cnt > 0 or v < 0.0  
       * append number iff v != 1.0, v != -1.0  
       */
extern void dbl_ILLwrite_lp_state_append_number (
  dbl_ILLwrite_lp_state * line,
  double v);
extern void dbl_ILLwrite_lp_state_save_start (
  dbl_ILLwrite_lp_state * line);
extern void dbl_ILLwrite_lp_state_start (
  dbl_ILLwrite_lp_state * line);

#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: dbl_lib.h,v 1.4 2003/11/05 17:00:26 meven Exp $ */
#ifndef dbl_ILL_LIB_H
#define dbl_ILL_LIB_H


/****************************************************************************/
/*                                                                          */
/*                   Return Status for dbl_ILLlib_optimize                      */
/*                                                                          */
/****************************************************************************/

/****************************************************************************/
/*                                                                          */
/*                               dbl_lib.c                                      */
/*                                                                          */
/****************************************************************************/

struct itcnt_t;

int dbl_ILLlib_optimize ( dbl_lpinfo * lp, dbl_ILLlp_basis * B, dbl_price_info * pinf, int algo,
      int *status, int simplex_display, struct itcnt_t*itcnt),
    dbl_ILLlib_cache_solution ( dbl_lpinfo * lp, dbl_ILLlp_cache * C), 
    dbl_ILLlib_solution ( dbl_lpinfo * lp, dbl_ILLlp_cache * C, double * val, 
      double * x, double * pi, double * slack, double * rc),
    dbl_ILLlib_get_x ( dbl_lpinfo * lp, dbl_ILLlp_cache * C, double * x),
    dbl_ILLlib_get_slack ( dbl_lpinfo * lp, dbl_ILLlp_cache * C, double * slack),
    dbl_ILLlib_objval ( dbl_lpinfo * lp, dbl_ILLlp_cache * C, double * val),
    dbl_ILLlib_tableau ( dbl_lpinfo * lp, int row, double * binv, double * tabrow),
    dbl_ILLlib_basis_order ( dbl_lpinfo * lp, int *header),
    dbl_ILLlib_newrow ( dbl_lpinfo * lp, dbl_ILLlp_basis * B,const double rhs, int sense,
      const double range, const char *name),
    dbl_ILLlib_newrows ( dbl_lpinfo * lp, dbl_ILLlp_basis * B, int num,const double * rhs,
      char *sense, const double * range, const char **names),
    dbl_ILLlib_addrow ( dbl_lpinfo * lp, dbl_ILLlp_basis * B, int cnt, int *ind,
      const double * val, const double rhs, int sense,const double range,
      const char *rowname),
    dbl_ILLlib_addrows ( dbl_lpinfo * lp, dbl_ILLlp_basis * B, int num, int *rmatcnt, 
      int *rmatbeg, int *rmatind,const double * rmatval,const double * rhs, 
      char *sense, const double * range, const char **names, int *nofactor),
    dbl_ILLlib_delrows ( dbl_lpinfo * lp, dbl_ILLlp_basis * B, dbl_ILLlp_cache * C, int num, 
      int *dellist, int *basis_ok, int *cache_ok), 
    dbl_ILLlib_newcol ( dbl_lpinfo * lp, dbl_ILLlp_basis * B,const double obj, 
      const double lower,const double upper, const char *name, int factorok), 
    dbl_ILLlib_newcols ( dbl_lpinfo * lp, dbl_ILLlp_basis * B, int num, double * obj,
      double * lower, double * upper, const char **names, int factorok),
    dbl_ILLlib_addcol ( dbl_lpinfo * lp, dbl_ILLlp_basis * B, int cnt, int *ind,
      double * val,const double obj,const double lower,const double upper, 
      const char *name, int factorok),
    dbl_ILLlib_addcols ( dbl_lpinfo * lp, dbl_ILLlp_basis * B, int num, int *cmatcnt,
      int *cmatbeg, int *cmatind, double * cmatval, double * obj,
      double * lower, double * upper, const char **names, int factorok),
    dbl_ILLlib_delcols ( dbl_lpinfo * lp, dbl_ILLlp_basis * B, int num, int *dellist,
      int *basis_ok),
    dbl_ILLlib_chgcoef ( dbl_lpinfo * lp, int rowindex, int colindex, double coef), 
    dbl_ILLlib_getcoef (dbl_lpinfo *lp, int rowindex, int colindex, double* coef),
    dbl_ILLlib_chgrange (dbl_lpinfo *lp, int indx, double coef),
    dbl_ILLlib_chgsense ( dbl_lpinfo * lp, int num, int *rowlist, char *sense),
    dbl_ILLlib_getsenses (dbl_lpinfo *lp, char *senses),
    dbl_ILLlib_getrows ( dbl_lpinfo * lp, int num, int *rowlist, int **rowcnt,
      int **rowbeg, int **rowind, double ** rowval, double ** rhs,
      char **sense, double ** range, char ***names),
    dbl_ILLlib_getcols ( dbl_lpinfo * lp, int num, int *collist, int **colcnt,
      int **colbeg, int **colind, double ** colval, double ** obj,
      double ** lower, double ** upper, char ***names),
    dbl_ILLlib_getobj ( dbl_lpinfo * lp, double * obj),
    dbl_ILLlib_getobj_list (dbl_lpinfo *lp, int num, int* collist, double* obj),
    dbl_ILLlib_chgobj ( dbl_lpinfo * lp, int indx, double coef),
    dbl_ILLlib_getrhs ( dbl_lpinfo * lp, double * rhs),
    dbl_ILLlib_chgrhs ( dbl_lpinfo * lp, int indx, double coef),
    dbl_ILLlib_getintflags ( dbl_lpinfo * lp, int *intflags),
    dbl_ILLlib_rownames ( dbl_lpinfo * lp, char **rownames),
    dbl_ILLlib_colnames ( dbl_lpinfo * lp, char **colnames),
    dbl_ILLlib_colindex ( dbl_lpinfo * lp, const char *name, int *colindex),
    dbl_ILLlib_rowindex ( dbl_lpinfo * lp, const char *name, int *rowindex),
    dbl_ILLlib_chgbnd ( dbl_lpinfo * lp, int indx, int lu,const double bnd),
    dbl_ILLlib_chgbnds ( dbl_lpinfo * lp, int cnt, int *indx, char *lu, const double * bnd),
    dbl_ILLlib_getbnd ( dbl_lpinfo * lp, int indx, int lu, double * bnd),
    dbl_ILLlib_getbnds ( dbl_lpinfo * lp, double * lower, double * upper),
    dbl_ILLlib_getbnds_list ( dbl_lpinfo *lp, int num, int*collist, double *lower,
      double *upper),
    dbl_ILLlib_strongbranch ( dbl_lpinfo * lp, dbl_price_info * pinf, int *candidatelist,
      int ncand, double * xlist, double * downpen, double * uppen,
      int iterations, double objbound, struct itcnt_t*itcnt),
    dbl_ILLlib_getbasis ( dbl_lpinfo * lp, char *cstat, char *rstat),
    dbl_ILLlib_loadbasis ( dbl_ILLlp_basis * B, int nstruct, int nrows, char *cstat,
      char *rstat),
    dbl_ILLlib_readbasis ( dbl_lpinfo * lp, dbl_ILLlp_basis * B, const char *dbl_fname),
    dbl_ILLlib_writebasis ( dbl_lpinfo * lp, dbl_ILLlp_basis * B, const char *dbl_fname),
    dbl_ILLlib_getrownorms ( dbl_lpinfo * lp, dbl_price_info * pinf, double * rownorms),
    dbl_ILLlib_loadrownorms ( dbl_lpinfo * lp, dbl_price_info * pinf, double * rownorms),
    dbl_ILLlib_recompute_rownorms ( dbl_lpinfo * lp, dbl_price_info * pinf),
    dbl_ILLlib_iter ( dbl_lpinfo * lp),
    dbl_ILLlib_print_x ( EGioFile_t * fd, dbl_lpinfo * lp, dbl_ILLlp_cache * C, double * x,
      int nonZerosOnly),
    dbl_ILLwrite_lp_file ( dbl_ILLlpdata * lp, EGioFile_t * eout, dbl_qserror_collector * c);


extern int dbl_ILLlib_findName (
  dbl_ILLlpdata * qslp,
  int forRow,
  const char *name,
  int id,
  char buf[ILL_namebufsize]);

/****************************************************************************/
/*                                                                          */
/*                           dbl_presolve.c                                     */
/*                                                                          */
/****************************************************************************/

int dbl_ILLpresolve_add_logicals (
  dbl_ILLlpdata * lp);


/****************************************************************************/
/*                                                                          */
/*                            dbl_binary.c                                      */
/*                                                                          */
/****************************************************************************/

int dbl_ILLmip_binary_dfs (
  dbl_lpinfo * lp);

#endif /* dbl_ILL_LIB_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  $RCSfile: fp20_qstruct.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $" */
#ifndef fp20___QS_QSTRUCT_H
#define fp20___QS_QSTRUCT_H

typedef struct fp20_qsdata
{
  struct fp20_ILLlpdata *qslp;
  struct fp20_lpinfo *lp;
  struct fp20_price_info *pricing;
  struct fp20_ILLlp_basis *basis;
  struct fp20_ILLlp_cache *cache;
  char *name;
  int qstatus;                  /* QS_LP_UNSOLVED or an opt status  */
  int factorok;                 /* set to 0 if factorization is old */
  int simplex_display;          /* 0 off, 1 on */
  int simplex_scaling;          /* 0 off, 1 on */
  itcnt_t itcnt;
  EGfp20_t uobjlim;
  EGfp20_t lobjlim;
}
fp20_QSdata;

#endif /* fp20___QS_QSTRUCT_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: fp20_editor.h,v 1.2 2003/11/05 16:57:39 meven Exp $ */
#ifndef fp20_EDITOR_H
#define fp20_EDITOR_H

extern void fp20_ILLeditor_init (
  void);
extern void fp20_ILLeditor (
  fp20_QSdata * p);
extern int fp20_ILLeditor_solve (
  fp20_QSdata * p,
  int salgo);

#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: fp20_dstruct.h,v 1.3 2003/11/05 16:57:39 meven Exp $ */
/****************************************************************************/
/*                                                                          */
/*                           fp20_svector.h                                      */
/*                                                                          */
/****************************************************************************/

#ifndef fp20___SVECTOR_H
#define fp20___SVECTOR_H

typedef struct fp20_svector
{
  int nzcnt;
  int *indx;
  int size;
  EGfp20_t *coef;
}
fp20_svector;

void fp20_ILLsvector_init (
  fp20_svector * s),
  fp20_ILLsvector_free (
  fp20_svector * s);

int fp20_ILLsvector_alloc (
  fp20_svector * s,
  int nzcnt),
  fp20_ILLsvector_copy (
  const fp20_svector * s_in,
  fp20_svector * s_out);

#endif /* fp20___SVECTOR_H */

/****************************************************************************/
/*                                                                          */
/*                           fp20_heap.h                                         */
/*                                                                          */
/****************************************************************************/

#ifndef fp20___HEAP_H
#define fp20___HEAP_H

typedef struct
{
  int *entry;
  int *loc;
  EGfp20_t *key;
  int hexist;
  int maxsize;
  int size;
}
fp20_heap;

void fp20_ILLheap_insert (
  fp20_heap * const h,
  int const ix),
  fp20_ILLheap_modify (
  fp20_heap * const h,
  int const ix),
  fp20_ILLheap_delete (
  fp20_heap * const h,
  int const ix),
  fp20_ILLheap_init (
  fp20_heap * const h),
  fp20_ILLheap_free (
  fp20_heap * const h);

int fp20_ILLheap_findmin (
  fp20_heap * const h),
  fp20_ILLheap_build (
  fp20_heap * const h,
  int const nelems,
  EGfp20_t * key);

#endif /* fp20___HEAP_H */

/****************************************************************************/
/*                                                                          */
/*                         matrix.h                                         */
/*                                                                          */
/****************************************************************************/

#ifndef fp20___MATRIX_H
#define fp20___MATRIX_H

typedef struct fp20_ILLmatrix
{
  EGfp20_t *matval;           /* The coefficients.                       */
  int *matcnt;                  /* Number of coefs in each col.            */
  int *matind;                  /* The row indices of the coefs.           */
  int *matbeg;                  /* The start of each col.                  */
  int matcols;                  /* Number of columns.                      */
  int matrows;
  int matcolsize;               /* Length of matbeg and matcnt.            */
  int matsize;                  /* Length of matind and matval.            */
  int matfree;                  /* Free space at end of matind.            */
  /* Note: free elements marked by -1 in     */
  /* matind; we keep at least 1 free at end. */
}
fp20_ILLmatrix;

void fp20_ILLmatrix_init (
  fp20_ILLmatrix * A);
void fp20_ILLmatrix_free (
  fp20_ILLmatrix * A);
void fp20_ILLmatrix_prt (
  EGioFile_t * fd,
  fp20_ILLmatrix * A);

#endif /* fp20___MATRIX_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: fp20_factor.h,v 1.3 2003/11/05 16:57:39 meven Exp $ */
#ifndef fp20___QS_FACTOR_H_
#define fp20___QS_FACTOR_H_

typedef char fp20_QSbool;

typedef struct fp20_uc_info
{
  int cbeg;
  int nzcnt;
  int next;
  int prev;
  int delay;
}
fp20_uc_info;

typedef struct fp20_ur_info
{
  EGfp20_t max;
  int rbeg;
  int nzcnt;
  int pivcnt;
  int next;
  int prev;
  int delay;
}
fp20_ur_info;

typedef struct fp20_lc_info
{
  int cbeg;
  int nzcnt;
  int c;
  int crank;
  int delay;
}
fp20_lc_info;

typedef struct fp20_lr_info
{
  int rbeg;
  int nzcnt;
  int r;
  int rrank;
  int delay;
}
fp20_lr_info;

typedef struct fp20_er_info
{
  int rbeg;
  int nzcnt;
  int r;
}
fp20_er_info;

typedef struct fp20_factor_work
{
  int max_k;
  EGfp20_t fzero_tol;
  EGfp20_t szero_tol;
  EGfp20_t partial_tol;
  double ur_space_mul;
  double uc_space_mul;
  double lc_space_mul;
  double lr_space_mul;
  double er_space_mul;
  double grow_mul;
  int p;
  int etamax;
  double minmult;
  double maxmult;
  double updmaxmult;
  double dense_fract;
  int dense_min;

  EGfp20_t maxelem_orig;
  int nzcnt_orig;
  EGfp20_t maxelem_factor;
  int nzcnt_factor;
  EGfp20_t maxelem_cur;
  int nzcnt_cur;

  EGfp20_t partial_cur;

  int dim;
  int stage;
  int nstages;
  int etacnt;
  EGfp20_t *work_coef;
  int *work_indx;
  fp20_uc_info *uc_inf;
  fp20_ur_info *ur_inf;
  fp20_lc_info *lc_inf;
  fp20_lr_info *lr_inf;
  fp20_er_info *er_inf;
  int *ucindx;                  /* row index for column data */
  int *ucrind;                  /* index of column in row data */
  EGfp20_t *uccoef;           /* coefficient for column data */
  int *urindx;                  /* col index for row data */
  int *urcind;                  /* index of row in column data */
  EGfp20_t *urcoef;           /* coefficient for row data */
  int *lcindx;                  /* row index for L data */
  EGfp20_t *lccoef;           /* coefficient for L row data */
  int *lrindx;                  /* col index for L data */
  EGfp20_t *lrcoef;           /* coefficient for L col data */
  int *erindx;                  /* col index for eta data */
  EGfp20_t *ercoef;           /* coefficient for eta data */
  int *rperm;
  int *rrank;
  int *cperm;
  int *crank;
  fp20_svector xtmp;
  int ur_freebeg;
  int ur_space;
  int uc_freebeg;
  int uc_space;
  int lc_freebeg;
  int lc_space;
  int lr_freebeg;
  int lr_space;
  int er_freebeg;
  int er_space;

  int *p_nsing;
  int **p_singr;
  int **p_singc;

  EGfp20_t *dmat;
  int drows;
  int dcols;
  int dense_base;
}
fp20_factor_work;

void fp20_ILLfactor_init_factor_work (
  fp20_factor_work * f),
  fp20_ILLfactor_free_factor_work (
  fp20_factor_work * f),
  fp20_ILLfactor_ftran (
  fp20_factor_work * f,
  fp20_svector * a,
  fp20_svector * x),
  fp20_ILLfactor_ftran_update (
  fp20_factor_work * f,
  fp20_svector * a,
  fp20_svector * upd,
  fp20_svector * x),
  fp20_ILLfactor_btran (
  fp20_factor_work * f,
  fp20_svector * a,
  fp20_svector * x);

int fp20_ILLfactor_create_factor_work (
  fp20_factor_work * f,
  int dim),
  fp20_ILLfactor_set_factor_iparam (
  fp20_factor_work * f,
  int param,
  int val),
  fp20_ILLfactor_set_factor_dparam (
  fp20_factor_work * f,
  int param,
  EGfp20_t val),
  fp20_ILLfactor (
  fp20_factor_work * f,
  int *basis,
  int *cbeg,
  int *clen,
  int *cindx,
  EGfp20_t * ccoef,
  int *p_nsing,
  int **p_singr,
  int **p_singc),
  fp20_ILLfactor_update (
  fp20_factor_work * f,
  fp20_svector * a,
  int col,
  int *p_refact);

#endif /* fp20___QS_FACTOR_H_ */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: fp20_lpdefs.h,v 1.3 2003/11/05 16:57:39 meven Exp $ */
#ifndef fp20___QS_LPDEFS_H
#define fp20___QS_LPDEFS_H


/* infinity and negative infinity */
#define fp20_INFTY  fp20_ILL_MAXDOUBLE
#define fp20_NINFTY fp20_ILL_MINDOUBLE

/* tolerances, these are initialized in fp20_ILLstart, file fp20_lpdata.c */
//#if EGLPNUM_TYPE != DBL_TYPE && EGLPNUM_TYPE != LDBL_TYPE
/* these three constants are defined in fp20_lpdata.c */
extern EGfp20_t fp20_PARAM_IBASIS_RPIVOT; /*       0.98 */
extern EGfp20_t fp20_PARAM_IBASIS_RTRIANG;/*       0.01 */
extern EGfp20_t fp20_PARAM_MIN_DNORM;     /*      1e-24 */
extern EGfp20_t fp20_PFEAS_TOLER;         /*       1e-6 */
extern EGfp20_t fp20_BD_TOLER;            /*       1e-7 */
extern EGfp20_t fp20_DFEAS_TOLER;         /*       1e-6 */
extern EGfp20_t fp20_PIVOT_TOLER;         /*      1e-10 */
extern EGfp20_t fp20_SZERO_TOLER;         /*      1e-15 */
extern EGfp20_t fp20_PIVZ_TOLER;          /*      1e-12 */
extern EGfp20_t fp20_OBJBND_TOLER;        /*       1e-2 */
extern EGfp20_t fp20_DBNDPIV_TOLER;       /*       1e-3 */
extern EGfp20_t fp20_DBNDPIV_RATIO;       /*       1e-2 */
extern EGfp20_t fp20_ALTPIV_TOLER;        /*       1e-8 */
//extern EGfp20_t DJZERO_TOLER;/*             1e-8 */
extern EGfp20_t fp20_PROGRESS_ZERO;       /*       1e-7 */
extern EGfp20_t fp20_PROGRESS_THRESH;     /*       1e-5 */
extern EGfp20_t fp20_CB_EPS;              /*      0.001 */
extern EGfp20_t fp20_CB_INF_RATIO;        /*       10.0 */
extern EGfp20_t fp20_CB_PRI_RLIMIT;       /*       0.25 */

/* structure for statistics */
typedef struct
{
  int ynz_cnt;                  /* nz in entering columns */
  int num_y;
  EGfp20_t y_ravg;              /* weighted avg. of current & prior y */
  int znz_cnt;                  /* nz in ith row of B^{-1}, ie z_i */
  int num_z;
  EGfp20_t z_ravg;              /* weighted avg. of current & prior z */
  int zanz_cnt;                 /* nz in z^TA */
  int num_za;
  EGfp20_t za_ravg;           /* weighted avg. of current & prior za */
  int pnorm_cnt;                /* nz in columns for primal norms */
  int dnorm_cnt;                /* nz in rows for dual norms */
  int pinz_cnt;                 /* nz in phase II pi (solve) */
  int num_pi;                   /* # of pi solves */
  int pi1nz_cnt;                /* nz in phase I pi (solve) */
  int num_pi1;                  /* # of phase I pi solves */
  int upnz_cnt;                 /* nz in ftran update vector */
  int num_up;                   /* # of ftran_updates */
  int pupv_cnt;                 /* nz in primal steep updates */
  int dupv_cnt;                 /* nz in dual steep updates */

  int start_slacks;             /* # slacks in beginning */
  int final_slacks;             /* # slacks in the end */
  int start_art;                /* # arts in beginning */
  int final_art;                /* # arts in the end */

  int pI_iter;                  /* primal phase I iterations */
  int pII_iter;
  int dI_iter;                  /* dual phase I iterations */
  int dII_iter;
  int tot_iter;

  int pivpI[10];                /* sizes of pivots */
  int pivpII[10];
  int pivdI[10];
  int pivdII[10];
}
fp20_count_struct;

/* structure for tolerances */
typedef struct
{
  EGfp20_t pfeas_tol;
  EGfp20_t dfeas_tol;
  EGfp20_t pivot_tol;
  EGfp20_t szero_tol;
  EGfp20_t ip_tol;              /* inner primal & dual feas toler */
  EGfp20_t id_tol;
}
fp20_tol_struct;

/* bound information */
typedef struct fp20_bndinfo
{
  EGfp20_t pbound;
  EGfp20_t cbound;
  int btype;
  int varnum;
  struct fp20_bndinfo *next;
}
fp20_bndinfo;

/* bound information */
typedef struct fp20_coefinfo
{
  EGfp20_t pcoef;
  EGfp20_t ccoef;
  int varnum;
  struct fp20_coefinfo *next;
}
fp20_coefinfo;

/* feasibility info */
typedef struct fp20_feas_info
{
  int pstatus;
  int dstatus;
  EGfp20_t totinfeas;
}
fp20_feas_info;

typedef struct fp20_lp_status_info
{
  char optimal;
  char primal_feasible;
  char primal_infeasible;
  char primal_unbounded;
  char dual_feasible;
  char dual_infeasible;
  char dual_unbounded;
  char padd;
}
fp20_lp_status_info;

typedef struct fp20_pI_uinfo
{
  int tctr;
  int i;
  int *perm;
  int *ix;
  int fs;
  EGfp20_t piv;
  EGfp20_t *t;
  EGfp20_t dty;
  EGfp20_t c_obj;
  EGfp20_t tz;
}
fp20_pI_uinfo;

extern void fp20_ILLlp_status_info_init (
  fp20_lp_status_info * ls);

/* structure for local lp information
 * contains lp obj values - status - dimensions - input data -
 * solution vecs - basis info - update vecs - work vecs - bound changes -
 * tolerances - time info - statistics 
 */
typedef struct fp20_lpinfo
{

  EGfp20_t objval;              /* obj info */
  EGfp20_t pobjval;           /* intermediate status info */
  EGfp20_t dobjval;
  EGfp20_t pinfeas;
  EGfp20_t dinfeas;
  EGfp20_t objbound;
  fp20_lp_status_info probstat;     /* final status */
  fp20_lp_status_info basisstat;      /* final status */
  int nrows;                    /* input info follows; given in col format */
  int ncols;
  int *matcnt;
  int *matbeg;
  int *matind;
  EGfp20_t *matval;
  int matfree;
  int matsize;
  EGfp20_t *bz;
  EGfp20_t *lz;
  EGfp20_t *uz;
  EGfp20_t *cz;
  int localrows;                /* set to 1 if these are created locally */
  int *rowcnt;                  /* row info follows, copy of col info */
  int *rowbeg;
  int *rowind;
  EGfp20_t *rowval;

  EGfp20_t *xbz;                /* output info x, pi, reduced cost */
  EGfp20_t *piz;
  EGfp20_t *dz;
  EGfp20_t *pIxbz;              /* output info (phase I) x, pi, reduced cost */
  EGfp20_t *pIpiz;
  EGfp20_t *pIdz;

  int final_phase;              /* final phase, inf & unboundedness info */
  int infub_ix;

  int basisid;                  /* basis and variable info follows */
  int nnbasic;
  int *baz;
  int *nbaz;
  int *vstat;
  int *vindex;
  int fbasisid;
  fp20_factor_work *f;
  int *vtype;                   /* internal var info */
  char *vclass;                 /* structural or logical */

  fp20_svector zz;                    /* local fp20_ILLfactor_update vectors z, yj, za */
  fp20_svector yjz;
  fp20_svector zA;
  fp20_svector work;                  /* local work vector */
  fp20_svector srhs;                  /* local vectors for lin. eq. solves */
  fp20_svector ssoln;
  int *iwork;                   /* local work vector */
  fp20_pI_uinfo upd;                  /* phase I update info */
  int *bfeas;                   /* primal and dual infeasibility info */
  int *dfeas;

  fp20_tol_struct *tol;             /* tolerances */
  fp20_count_struct *cnts;            /* counts */
  int nbchange;                 /* # bound shifts */
  int ncchange;                 /* # obj coef shifts */
  fp20_bndinfo *bchanges;           /* list of bound shifts */
  fp20_coefinfo *cchanges;            /* list of coef shifts */
  int pIratio;                  /* ratio tests */
  int pIIratio;
  int dIratio;
  int dIIratio;

  int maxiter;
  int iterskip;
  double maxtime;
  double starttime;
  struct fp20_ILLlpdata *O;
  ILLrandstate rstate;

}
fp20_lpinfo;

/* pricing structures */
typedef struct
{
  int ninit;
  EGfp20_t *norms;
  int *refframe;
}
fp20_p_devex_info;

typedef struct
{
  EGfp20_t *norms;
}
fp20_p_steep_info;

typedef struct
{
  int k;
  int cgroup;
  int ngroups;
  int *gstart;
  int *gshift;
  int *gsize;
  int bsize;
  int *bucket;
  int *perm;
  EGfp20_t *infeas;
}
fp20_mpart_info;

typedef struct
{
  int ninit;
  EGfp20_t *norms;
  int *refframe;
}
fp20_d_devex_info;

typedef struct
{
  EGfp20_t *norms;
}
fp20_d_steep_info;

/* pricing information */
typedef struct fp20_price_info
{
  int p_strategy;
  int d_strategy;
  int pI_price;
  int pII_price;
  int dI_price;
  int dII_price;
  int cur_price;
  EGfp20_t *p_scaleinf;
  EGfp20_t *d_scaleinf;
  fp20_p_devex_info pdinfo;
  fp20_p_steep_info psinfo;
  fp20_mpart_info pmpinfo;
  fp20_d_devex_info ddinfo;
  fp20_d_steep_info dsinfo;
  fp20_mpart_info dmpinfo;
  fp20_heap h;
  EGfp20_t htrigger;
  int hineff;
  char init;
}
fp20_price_info;

#endif /* fp20___QS_LPDEFS_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: rdline.h,v 1.2 2003/11/05 16:57:39 meven Exp $ */
#ifndef fp20_LINE_READER_FILE_H
#define fp20_LINE_READER_FILE_H


/* #ifdef _WINDOWS */
typedef char *(
  *fp20_qsread_line_fct) (
  char *s,
  int size,
  void *src);

typedef struct fp20_qsline_reader
{
  fp20_qsread_line_fct read_line_fct;
  void *data_src;
  struct fp20_qserror_collector *error_collector;
}
fp20_qsline_reader;

fp20_qsline_reader *fp20_ILLline_reader_new (
  fp20_qsread_line_fct fct,
  void *data_src);
void fp20_ILLline_reader_free (
  fp20_qsline_reader * reader);

#define fp20_ILLline_reader_get(s, size, reader)  \
  (reader)->read_line_fct(s, size, (reader)->data_src)
                   /* used by parsers to retrieve next input line */
/* #else  
 *
 * typedef FILE fp20_qsline_reader; 
 *
 * #define fp20_ILLline_reader_new(fct, data) ((FILE*) (data)) 
 * #define fp20_ILLline_reader_free(reader)  
 * #define fp20_ILLline_reader_get(s, size, reader) fgets(s,size,reader) 
 * #endif 
 */

#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: fp20_lpdata.h,v 1.4 2003/11/05 17:00:56 meven Exp $ */
#ifndef fp20_ILL_LPDATA_H
#define fp20_ILL_LPDATA_H


extern EGfp20_t fp20_ILL_MAXDOUBLE; /*  1e150 */
extern EGfp20_t fp20_ILL_MINDOUBLE; /* -1e150 */

#define fp20_ILL_MAXINT    (2147483647) /* this is equal to 2^31-1 */
#define fp20_ILL_MIN       (1)        /* Must be same as QS_MIN */
#define fp20_ILL_MAX       (-1)     /* Must be same as QS_MAX */

/*  Setting Alg in Presolve  */

#define fp20_ILL_PRE_SCALE           1
#define fp20_ILL_PRE_FIXED           2
#define fp20_ILL_PRE_SINGLE_ROW      4
#define fp20_ILL_PRE_FORCING         8
#define fp20_ILL_PRE_SINGLE_COL     16
#define fp20_ILL_PRE_DUPLICATE_ROW  32
#define fp20_ILL_PRE_DUPLICATE_COL  64
#define fp20_ILL_PRE_EMPTY_COL     128
#define fp20_ILL_PRE_ALL (fp20_ILL_PRE_SCALE | fp20_ILL_PRE_FIXED | fp20_ILL_PRE_SINGLE_ROW           \
                    fp20_ILL_PRE_FORCING | fp20_ILL_PRE_SINGLE_COL | fp20_ILL_PRE_DUPLICATE_ROW \
                   fp20_ILL_PRE_DUPLICATE_COL | fp20_ILL_PRE_EMPTY_COL)
#define fp20_ILL_PRE_SIMPLE (fp20_ILL_PRE_FIXED | fp20_ILL_PRE_EMPTY_COL)

typedef struct fp20_ILLlpdata
{                               /* Complete LP data filled in by mpsread.  */
  int nrows;
  int ncols;
  int nstruct;                  /* Not including logicals.                 */
  int nzcount;
  int rowsize;                  /* Length of row arrays.                   */
  int colsize;                  /* Length of col arrays.                   */
  int structsize;               /* Length of intmarker, structmap,         */
  /* colnames                                */
  int objsense;
  char *sense;                  /* Original sense, not after logicals.     */
  EGfp20_t *obj;
  EGfp20_t *rhs;
  EGfp20_t *rangeval;
  EGfp20_t *lower;
  EGfp20_t *upper;
  fp20_ILLmatrix A;                 /* The coef matrix.                        */
  struct fp20_ILLlp_rows *rA;       /* Coef matrix in row form.                */

  char **rownames;
  ILLsymboltab rowtab;          /* contains rownames in no particular order */
  char *objname;                /* if colname is not NULL it is entered into 
                                 * the rowtab, see reader fcts in fp20_lp.c, fp20_mps.c*/

  char **colnames;              /* columns of struct variables */
  ILLsymboltab coltab;          /* contains colnames in no particular order */

  char *probname;
  char *intmarker;
  int *structmap;               /* Indices of structural variables         */
  int *rowmap;                  /* Indices of logical and range variables  */
  struct fp20_ILLlp_basis *basis;
  struct fp20_ILLlp_predata *presolve;
  struct fp20_ILLlp_sinfo *sinfo;

   /**************************************************************************/
  /* these fields are currently only set by fp20_mps.c reader fcts               */
   /**************************************************************************/
  fp20_ILLmatrix sos;               /* columns are the sets, rows are the  
                                 * problem's structural variables
                                 * coefficients are the weights */

  char *sos_type;               /* type of each set */
  int *is_sos_mem;              /* for each structural variable contains 
                                 *    -1 == not a set member
                                 *     i == member of sos set i 
                                 *          where 0 <= i < sos.matcols */
  char *refrowname;             /* name of reference row */
  int refind;                   /* index of reference row 
                                 *     -1 if refrow was a free row 
                                 *          and weights are found only in the 
                                 *          sos matrix 
                                 *     index >=0 if refrow is also a lp-row */

   /**************************************************************************
    * fp20_QSset_reporter initializes reporter 
    **************************************************************************/
  qsstring_reporter reporter;   /* used from within ILL fcts 
                                 * to report fp20_feedback */
}
fp20_ILLlpdata;

typedef struct fp20_ILLlp_basis
{
  int nstruct;
  int nrows;
  int rownorms_size;
  int colnorms_size;
  char *cstat;
  char *rstat;
  EGfp20_t *rownorms;
  EGfp20_t *colnorms;
}
fp20_ILLlp_basis;

typedef struct fp20_ILLlp_cache
{
  int nstruct;
  int nrows;
  int status;
  EGfp20_t val;
  EGfp20_t *x;
  EGfp20_t *pi;
  EGfp20_t *rc;
  EGfp20_t *slack;
}
fp20_ILLlp_cache;

typedef struct fp20_ILLlp_sinfo
{                               /* LP info returned by presolve            */
  int ncols;
  int nrows;
  int nzcount;
  int rowsize;
  int colsize;
  int objsense;

  EGfp20_t *obj;
  EGfp20_t *rhs;
  EGfp20_t *lower;
  EGfp20_t *upper;

  fp20_ILLmatrix A;

  char **colnames;              /* Just for debugging - not updated */
}
fp20_ILLlp_sinfo;

typedef struct fp20_ILLlp_preline
{
  EGfp20_t rhs;
  EGfp20_t obj;
  EGfp20_t lower;
  EGfp20_t upper;
  int count;
  int *ind;
  int row_or_col;               /* 0 is row, 1 is col */
  EGfp20_t *val;
}
fp20_ILLlp_preline;

typedef struct fp20_ILLlp_preop
{
  int ptype;
  int rowindex;
  int colindex;
  fp20_ILLlp_preline line;
}
fp20_ILLlp_preop;

typedef struct fp20_ILLlp_predata
{                               /* Data needed in un-presolve.            */
  int opcount;
  int opsize;
  fp20_ILLlp_preop *oplist;
  int r_nrows;
  int r_ncols;
  int *colmap;
  int *rowmap;
  EGfp20_t *rowscale;
  EGfp20_t *colscale;
  EGfp20_t *colfixval;
  EGfp20_t *rowfixval;
}
fp20_ILLlp_predata;

typedef struct fp20_ILLlp_rows
{
  int *rowbeg;
  int *rowcnt;
  int *rowind;
  EGfp20_t *rowval;
}
fp20_ILLlp_rows;


/****************************************************************************/
/*                                                                          */
/*                             fp20_lpdata.c                                     */
/*                                                                          */
/****************************************************************************/

struct fp20_qsdata *fp20_ILLread (
  fp20_qsline_reader * file,
  const char *fp20_fname,
  int isMps);
void fp20_ILLstart (
  void);              /**< initialize fp20_ILL_MAXDOUBLE and other 

                           constants, this funtion should be callef AFTER 
                           EGlpNumStart() */
void fp20_ILLend (
  void);            /**< free any internal data asociated with variable 

                         fp20_precision numbers */
void fp20_ILLchange_precision (
  void);                        /**< This function re-compute the internal 

                                     variables fp20_precision to the (previously 
                                     set) EGLPNUM_PRECISION value (done with 
                                     EGlpNumSetPrecision) */
void fp20_ILLlpdata_init (
  fp20_ILLlpdata * lp);
void fp20_ILLlpdata_free (
  fp20_ILLlpdata * lp);
void fp20_ILLlp_basis_init (
  fp20_ILLlp_basis * B);
void fp20_ILLlp_basis_free (
  fp20_ILLlp_basis * B);
void fp20_ILLlp_cache_init (
  fp20_ILLlp_cache * C);
void fp20_ILLlp_cache_free (
  fp20_ILLlp_cache * C);
int fp20_ILLlp_basis_alloc (
  fp20_ILLlp_basis * B,
  int ncols,
  int nrows);
int fp20_ILLlp_cache_alloc (
  fp20_ILLlp_cache * C,
  int ncols,
  int nrows);

int fp20_ILLlp_rows_init (
  fp20_ILLlp_rows * lp_rows,
  fp20_ILLlpdata * lp,
  int include_logicals);
void fp20_ILLlp_rows_clear (
  fp20_ILLlp_rows * lp_rows);
int fp20_ILLprint_report (
  fp20_ILLlpdata * lp,
  const char *format,
  ...);

              /* print to lp->reporter */

/****************************************************************************/
/*                                                                          */
/*                             fp20_presolve.c                                   */
/*                                                                          */
/****************************************************************************/

void fp20_ILLlp_sinfo_init (
  fp20_ILLlp_sinfo * sinfo),
  fp20_ILLlp_sinfo_free (
  fp20_ILLlp_sinfo * sinfo),
  fp20_ILLlp_predata_init (
  fp20_ILLlp_predata * pre),
  fp20_ILLlp_predata_free (
  fp20_ILLlp_predata * pre);

int fp20_ILLlp_add_logicals (
  fp20_ILLlpdata * lp),
  fp20_ILLlp_scale (
  fp20_ILLlpdata * lp),
  fp20_ILLlp_presolve (
  fp20_ILLlpdata * lp,
  int pre_types);

/* ========================================================================= */
/* if non-zero, then internal data has been initialized, and there is some
 * memory allocated, if zero, no internal memory has been allocated
 * (or it has been freed) */
extern int fp20___QSEX_SETUP;

#endif /* __ILL_LPDATA_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: fp20_basis.h,v 1.3 2003/11/05 16:57:39 meven Exp $ */
#ifndef fp20___BASIS_H
#define fp20___BASIS_H


#if 0
#if EGLPNUM_TYPE != DBL_TYPE && EGLPNUM_TYPE != LDBL_TYPE
extern EGfp20_t fp20_CB_PRI_RLIMIT; /* = 0.25 */
extern EGfp20_t fp20_CB_INF_RATIO;  /* = 10.0 */
extern EGfp20_t fp20_CB_EPS;        /* = 0.001 */
#endif
#endif

typedef struct fp20_var_data
{
  int nartif;
  int nslacks;
  int nfree;
  int nbndone;
  int nbounded;
  int nfixed;
  EGfp20_t cmax;
}
fp20_var_data;

void fp20_ILLbasis_init_vardata (
  fp20_var_data * vd);
void fp20_ILLbasis_clear_vardata (
  fp20_var_data * vd);

int fp20_ILLbasis_build_basisinfo (
  fp20_lpinfo * lp),
  fp20_ILLbasis_get_initial (
  fp20_lpinfo * lp,
  int algorithm),
  fp20_ILLbasis_get_cinitial (
  fp20_lpinfo * lp,
  int algorithm),
  fp20_ILLbasis_load (
  fp20_lpinfo * lp,
  fp20_ILLlp_basis * B),
  fp20_ILLbasis_tableau_row (
  fp20_lpinfo * lp,
  int row,
  EGfp20_t * brow,
  EGfp20_t * trow,
  EGfp20_t * rhs,
  int strict),
  fp20_ILLbasis_factor (
  fp20_lpinfo * lp,
  int *singular),
  fp20_ILLbasis_refactor (
  fp20_lpinfo * lp),
  fp20_ILLbasis_update (
  fp20_lpinfo * lp,
  fp20_svector * y,
  int lindex,
  int *refactor,
  int *singular);

void fp20_ILLbasis_column_solve (
  fp20_lpinfo * lp,
  fp20_svector * rhs,
  fp20_svector * soln),
  fp20_ILLbasis_column_solve_update (
  fp20_lpinfo * lp,
  fp20_svector * rhs,
  fp20_svector * upd,
  fp20_svector * soln),
  fp20_ILLbasis_row_solve (
  fp20_lpinfo * lp,
  fp20_svector * rhs,
  fp20_svector * soln),
  fp20_ILLbasis_free_basisinfo (
  fp20_lpinfo * lp),
  fp20_ILLbasis_free_fbasisinfo (
  fp20_lpinfo * lp),
  fp20_ILLbasis_init_basisinfo (
  fp20_lpinfo * lp);

#endif /* fp20___BASIS_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

#ifndef fp20___DHEAPS_I_H__
#define fp20___DHEAPS_I_H__
/****************************************************************************/
/*                                                                          */
/*                             fp20_dheaps_i.c                                   */
/*                                                                          */
/****************************************************************************/

typedef struct fp20_ILLdheap
{
  EGfp20_t *key;
  int *entry;
  int *loc;
  int total_space;
  int size;
}
fp20_ILLdheap;

void fp20_ILLutil_dheap_free (
  fp20_ILLdheap * h),
  fp20_ILLutil_dheap_delete (
  fp20_ILLdheap * h,
  int i),
  fp20_ILLutil_dheap_changekey (
  fp20_ILLdheap * h,
  int i,
  EGfp20_t * newkey),
  fp20_ILLutil_dheap_findmin (
  fp20_ILLdheap * h,
  int *i),
  fp20_ILLutil_dheap_deletemin (
  fp20_ILLdheap * h,
  int *i);

int fp20_ILLutil_dheap_init (
  fp20_ILLdheap * h,
  int k),
  fp20_ILLutil_dheap_resize (
  fp20_ILLdheap * h,
  int newsize),
  fp20_ILLutil_dheap_insert (
  fp20_ILLdheap * h,
  int i);



#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  $RCSfile: fp20_qsopt.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $" */
#ifndef fp20___QS_QSOPT_H
#define fp20___QS_QSOPT_H


#ifdef WIN32

#ifdef QSLIB_EXPORTS
#define fp20_QSLIB_INTERFACE __declspec(dllexport)
#else
#define fp20_QSLIB_INTERFACE __declspec(dllimport)
#endif

#else
#define fp20_QSLIB_INTERFACE extern
#endif

#ifdef WIN32
typedef struct fp20_QSLIB_INTERFACE fp20_qsdata *fp20_QSprob;
typedef struct fp20_QSLIB_INTERFACE qsbasis *fp20_QSbas;
#else
typedef struct fp20_qsdata *fp20_QSprob;
typedef struct qsbasis *fp20_QSbas;
#endif

/****************************************************************************/
/*                                                                          */
/*                 PARAMETERS TO SPECIFY OBJECTIVE SENSE                    */
/*                                                                          */
/****************************************************************************/
/*
#define QS_LP_PRIMAL_FEASIBLE   11
#define QS_LP_PRIMAL_INFEASIBLE 12
#define QS_LP_PRIMAL_UNBOUNDED  13
#define QS_LP_DUAL_FEASIBLE     14
#define QS_LP_DUAL_INFEASIBLE   15
#define QS_LP_DUAL_UNBOUNDED    16
*/

/****************************************************************************/
/*                                                                          */
/*                      QSopt Library Functions                             */
/*                                                                          */
/****************************************************************************/
#ifdef  __cplusplus
extern "C"
{
#endif

#ifdef WIN32
/* 
 *  in WINDOWS we make 
 *     fp20_solver_main/fp20_reader_main part of DLL
 */
fp20_QSLIB_INTERFACE int fp20_solver_main ( int argc, char **argv);
fp20_QSLIB_INTERFACE int fp20_reader_main ( int argc, char **argv);
#endif

fp20_QSLIB_INTERFACE void fp20_QSfree ( void *ptr),
    fp20_QSfree_prob ( fp20_QSprob p),
    fp20_QSfree_basis ( fp20_QSbas B),
    fp20_QSset_precision ( const unsigned prec),/**< set the fp20_precision for floating 
                                                 point numbers to the given 
                                                 number of bits */
    fp20_QSstart ( void),/**< whe we use non native numbers, we need to make 
                         some initializations before operating with the
                         library */
    fp20_QSend ( void); /**< just to free any internal static data needed by
                         the variable fp20_precision numbers */

fp20_QSLIB_INTERFACE int fp20_QSopt_primal ( fp20_QSprob p, int *status),
    fp20_QSopt_dual ( fp20_QSprob p, int *status),
    fp20_QSopt_pivotin_col ( fp20_QSprob p, int ccnt, int *clist),
    fp20_QSopt_pivotin_row ( fp20_QSprob p, int rcnt, int *rlist),
    fp20_QSopt_strongbranch ( fp20_QSprob p, int ncand, int *candidatelist,
      EGfp20_t * xlist, EGfp20_t * down_vals, EGfp20_t * up_vals,
      int iterations, EGfp20_t objbound),
    fp20_QSchange_objsense ( fp20_QSprob p, int newsense),
    fp20_QSget_objsense ( fp20_QSprob p, int *newsense),
    fp20_QSnew_col ( fp20_QSprob p,const EGfp20_t obj,const EGfp20_t lower,const EGfp20_t upper,
      const char *name),
    fp20_QSadd_cols ( fp20_QSprob p, int num, int *cmatcnt, int *cmatbeg, int *cmatind,
      EGfp20_t * cmatval, EGfp20_t * obj, EGfp20_t * lower,
      EGfp20_t * upper, const char **names),
    fp20_QSadd_col ( fp20_QSprob p, int cnt, int *cmatind, EGfp20_t * cmatval,
      EGfp20_t obj, EGfp20_t lower, EGfp20_t upper, const char *name),
    fp20_QSnew_row ( fp20_QSprob p,const EGfp20_t rhs, int sense, const char *name),
    fp20_QSadd_ranged_rows ( fp20_QSprob p, int num, int *rmatcnt, int *rmatbeg, 
      int *rmatind,const EGfp20_t * rmatval,const EGfp20_t * rhs, char *sense,
      const EGfp20_t* range, const char **names),
    fp20_QSadd_ranged_row ( fp20_QSprob p, int cnt, int *rmatind,const EGfp20_t * rmatval,
      const EGfp20_t * rhs, int sense,const EGfp20_t * range, const char *name),
    fp20_QSadd_rows ( fp20_QSprob p, int num, int *rmatcnt, int *rmatbeg, int *rmatind,
      const EGfp20_t * rmatval,const EGfp20_t * rhs, char *sense, const char **names),
    fp20_QSadd_row ( fp20_QSprob p, int cnt, int *rmatind,const EGfp20_t * rmatval,
      const EGfp20_t * rhs, int sense, const char *name),
    fp20_QSdelete_rows ( fp20_QSprob p, int num, int *dellist),
    fp20_QSdelete_row ( fp20_QSprob p, int rowindex),
    fp20_QSdelete_setrows ( fp20_QSprob p, int *flags),
    fp20_QSdelete_named_row ( fp20_QSprob p, const char *rowname),
    fp20_QSdelete_named_rows_list ( fp20_QSprob p, int num, const char **rownames),
    fp20_QSdelete_cols ( fp20_QSprob p, int num, int *dellist),
    fp20_QSdelete_col ( fp20_QSprob p, int colindex),
    fp20_QSdelete_setcols ( fp20_QSprob p, int *flags),
    fp20_QSdelete_named_column ( fp20_QSprob p, const char *colname),
    fp20_QSdelete_named_columns_list ( fp20_QSprob p, int num, const char **colnames),
    fp20_QSchange_senses ( fp20_QSprob p, int num, int *rowlist, char *sense),
    fp20_QSchange_sense ( fp20_QSprob p, int rowindex, int sense),
    fp20_QSchange_coef ( fp20_QSprob p, int rowindex, int colindex, EGfp20_t coef),
    fp20_QSchange_objcoef ( fp20_QSprob p, int indx, EGfp20_t coef),
    fp20_QSchange_rhscoef ( fp20_QSprob p, int indx, EGfp20_t coef),
    fp20_QSchange_range(fp20_QSprob p, int rowindex, EGfp20_t range),
    fp20_QSchange_bounds ( fp20_QSprob p, int num, int *collist, char *lu, 
      const EGfp20_t * bounds),
    fp20_QSchange_bound ( fp20_QSprob p, int indx, int lu,const EGfp20_t bound),
    fp20_QSload_basis ( fp20_QSprob p, fp20_QSbas B),
    fp20_QSread_and_load_basis ( fp20_QSprob p, const char *filename),
    fp20_QSload_basis_array ( fp20_QSprob p, char *cstat, char *rstat),
    fp20_QSload_basis_and_row_norms_array ( fp20_QSprob p, char *cstat, char *rstat, 
      EGfp20_t * rownorms),
    fp20_QSget_basis_array ( fp20_QSprob p, char *cstat, char *rstat),
    fp20_QSget_basis_and_row_norms_array ( fp20_QSprob p, char *cstat, char *rstat,
      EGfp20_t * rownorms),
    fp20_QSget_binv_row ( fp20_QSprob p, int indx, EGfp20_t * binvrow),
    fp20_QSget_tableau_row ( fp20_QSprob p, int indx, EGfp20_t * tableaurow),
    fp20_QSget_basis_order ( fp20_QSprob p, int *basorder), 
    fp20_QSget_coef (fp20_QSprob p, int rowindex, int colindex, EGfp20_t*coef),
    fp20_QSget_status ( fp20_QSprob p, int *status),
    fp20_QSget_solution ( fp20_QSprob p, EGfp20_t * value, EGfp20_t * x,
      EGfp20_t * pi, EGfp20_t * slack, EGfp20_t * rc),
    fp20_QSget_objval ( fp20_QSprob p, EGfp20_t * value),
    fp20_QSget_pi_array ( fp20_QSprob p, EGfp20_t * pi),
    fp20_QSget_rc_array ( fp20_QSprob p, EGfp20_t * rc),
    fp20_QSget_x_array ( fp20_QSprob p, EGfp20_t * x),
    fp20_QSget_slack_array ( fp20_QSprob p, EGfp20_t * slack),
    fp20_QSget_infeas_array ( fp20_QSprob p, EGfp20_t * pi),
    fp20_QSget_colcount ( fp20_QSprob p),
    fp20_QSget_rowcount ( fp20_QSprob p),
    fp20_QSget_nzcount ( fp20_QSprob p),
    fp20_QSget_obj_list(fp20_QSprob p, int num, int*collist, EGfp20_t*obj),
    fp20_QSget_obj ( fp20_QSprob p, EGfp20_t * obj),
    fp20_QSget_rhs ( fp20_QSprob p, EGfp20_t * rhs),
    fp20_QSget_ranged_rows_list ( fp20_QSprob p, int num, int *rowlist, int **rowcnt,
      int **rowbeg, int **rowind, EGfp20_t ** rowval, EGfp20_t ** rhs,
      char **sense, EGfp20_t **range, char ***names),
    fp20_QSget_ranged_rows ( fp20_QSprob p, int **rowcnt, int **rowbeg, int **rowind,
      EGfp20_t ** rowval, EGfp20_t ** rhs, char **sense, 
      EGfp20_t ** range, char ***names),
    fp20_QSget_senses ( fp20_QSprob p, char*senses),
    fp20_QSget_rows_list ( fp20_QSprob p, int num, int *rowlist, int **rowcnt,
      int **rowbeg, int **rowind, EGfp20_t ** rowval, EGfp20_t ** rhs,
      char **sense, char ***names),
    fp20_QSget_rows ( fp20_QSprob p, int **rowcnt, int **rowbeg, int **rowind,
      EGfp20_t ** rowval, EGfp20_t ** rhs, char **sense, char ***names),
    fp20_QSget_columns_list ( fp20_QSprob p, int num, int *collist, int **colcnt,
      int **colbeg, int **colind, EGfp20_t ** colval, EGfp20_t ** obj,
      EGfp20_t ** lower, EGfp20_t ** upper, char ***names),
    fp20_QSget_columns ( fp20_QSprob p, int **colcnt, int **colbeg, int **colind,
      EGfp20_t ** colval, EGfp20_t ** obj, EGfp20_t ** lower,
      EGfp20_t ** upper, char ***names),
    fp20_QSget_rownames ( fp20_QSprob p, char **rownames),
    fp20_QSget_colnames ( fp20_QSprob p, char **colnames),
    fp20_QSget_bound ( fp20_QSprob p, int colindex, int lu, EGfp20_t * bound),
    fp20_QSget_bounds ( fp20_QSprob p, EGfp20_t * lower, EGfp20_t * upper),
    fp20_QSget_bounds_list(fp20_QSprob p, int num, int*collist, EGfp20_t*lb,
      EGfp20_t*ub),
    fp20_QSget_intflags ( fp20_QSprob p, int *intflags),
    fp20_QSget_intcount ( fp20_QSprob p, int *count),
    fp20_QSget_column_index ( fp20_QSprob p, const char *name, int *colindex),
    fp20_QSget_row_index ( fp20_QSprob p, const char *name, int *rowindex),
    fp20_QSget_named_x ( fp20_QSprob p, const char *colname, EGfp20_t * val),
    fp20_QSget_named_rc ( fp20_QSprob p, const char *colname, EGfp20_t * val),
    fp20_QSget_named_pi ( fp20_QSprob p, const char *rowname, EGfp20_t * val),
    fp20_QSget_named_slack ( fp20_QSprob p, const char *rowname, EGfp20_t * val),
    fp20_QScompute_row_norms ( fp20_QSprob p),
    fp20_QSwrite_prob ( fp20_QSprob p, const char *filename, const char *filetype),
    fp20_QSwrite_prob_file ( fp20_QSprob p, FILE * file, const char *filetype),
    fp20_QSwrite_basis ( fp20_QSprob p, fp20_QSbas B, const char *filename),
    fp20_QStest_row_norms ( fp20_QSprob p),
    fp20_QSget_itcnt(fp20_QSprob p, int *pI_iter, int *pII_iter, int *dI_iter,
      int *dII_iter, int *tot_iter),
    fp20_QSset_param ( fp20_QSprob p, int whichparam, int newvalue),
    fp20_QSset_param_EGlpNum ( fp20_QSprob p, int whichparam, EGfp20_t newvalue),
    fp20_QSget_param ( fp20_QSprob p, int whichparam, int *value),
    fp20_QSget_param_EGlpNum ( fp20_QSprob p, int whichparam, EGfp20_t * value); 

fp20_QSLIB_INTERFACE char *fp20_QSget_probname ( fp20_QSprob p);
fp20_QSLIB_INTERFACE char *fp20_QSget_objname ( fp20_QSprob p);
fp20_QSLIB_INTERFACE char *fp20_QSversion ( void);

fp20_QSLIB_INTERFACE fp20_QSprob fp20_QScreate_prob ( const char *name, int objsense),
    fp20_QSread_prob ( const char *filename, const char *filetype),
    fp20_QSload_prob ( const char *probname, int ncols, int nrows, int *cmatcnt,
      int *cmatbeg, int *cmatind, EGfp20_t * cmatval, int objsense,
      EGfp20_t * obj, EGfp20_t * rhs, char *sense, EGfp20_t * lower,
      EGfp20_t * upper, const char **colnames, const char **rownames),
    fp20_QScopy_prob ( fp20_QSprob p, const char *newname);

fp20_QSLIB_INTERFACE fp20_QSbas fp20_QSget_basis ( fp20_QSprob p),
    fp20_QSread_basis ( fp20_QSprob p, const char *filename);

#ifdef  __cplusplus
}
#endif

/****************************************************************************
 *
 * This is the undocumented part of the QSlib interface 
 *
 ****************************************************************************/
/* 
 * functions to facilitate line by line reading from other sources than 
 * files from within MPS/LP parsers  
 * 
 * functions to facilitate the collection of error information instead of 
 * having the parsers print messages to stderr
 *                              by mps/lp format writers
 * 
 * a problem's reporter is used by the solver code to provide important 
 * fp20_feedback/progress information
 */

#ifdef WIN32
typedef struct fp20_QSLIB_INTERFACE fp20_qsline_reader *fp20_QSline_reader;
typedef struct fp20_QSLIB_INTERFACE fp20_qsformat_error *fp20_QSformat_error;
typedef struct fp20_QSLIB_INTERFACE fp20_qserror_collector *fp20_QSerror_collector;
typedef struct fp20_QSLIB_INTERFACE fp20_qserror_memory *fp20_QSerror_memory;
#else
typedef struct fp20_qsline_reader *fp20_QSline_reader;
typedef struct fp20_qsformat_error *fp20_QSformat_error;
typedef struct fp20_qserror_collector *fp20_QSerror_collector;
typedef struct fp20_qserror_memory *fp20_QSerror_memory;
#endif

#ifdef  __cplusplus
extern "C"
{
#endif
  fp20_QSLIB_INTERFACE const char *fp20_QSformat_error_type_string (
  int tp);

  fp20_QSLIB_INTERFACE int fp20_QSerror_get_type (
  fp20_QSformat_error error);
  fp20_QSLIB_INTERFACE const char *fp20_QSerror_get_desc (
  fp20_QSformat_error error);
  fp20_QSLIB_INTERFACE int fp20_QSerror_get_line_number (
  fp20_QSformat_error error);
  fp20_QSLIB_INTERFACE int fp20_QSerror_get_pos (
  fp20_QSformat_error error);
  fp20_QSLIB_INTERFACE const char *fp20_QSerror_get_line (
  fp20_QSformat_error error);
  fp20_QSLIB_INTERFACE void fp20_QSerror_print (
  FILE * f,
  fp20_QSformat_error error);

  fp20_QSLIB_INTERFACE fp20_QSerror_collector fp20_QSerror_collector_new (
  void *fct,
  void *dest);
  fp20_QSLIB_INTERFACE fp20_QSerror_collector fp20_QSerror_memory_collector_new (
  fp20_QSerror_memory mem);
  fp20_QSLIB_INTERFACE void fp20_QSerror_collector_free (
  fp20_QSerror_collector c);

/****************************************************************************
 * line reader 
 */
  fp20_QSLIB_INTERFACE fp20_QSline_reader fp20_QSline_reader_new (
  void *fct,
  void *data_src);
  /* reader->read_line_fct defaults to fgets */

  fp20_QSLIB_INTERFACE void fp20_QSline_reader_free (
  fp20_QSline_reader reader);

  fp20_QSLIB_INTERFACE void fp20_QSline_reader_set_error_collector (
  fp20_QSline_reader reader,
  fp20_QSerror_collector collector);

  fp20_QSLIB_INTERFACE char *fp20_QSline_reader_get (
  fp20_QSline_reader reader,
  char *s,
  int size);

  fp20_QSLIB_INTERFACE fp20_QSprob fp20_QSget_prob (
  fp20_QSline_reader reader,
  const char *probname,
  const char *filetype);
  /* the MPS and LP parsers uses the fct from reader 
   * to get to next input line */


/****************************************************************************
 * error memory 
 */
  fp20_QSLIB_INTERFACE fp20_QSerror_memory fp20_QSerror_memory_create (
  int takeErrorLines);
  fp20_QSLIB_INTERFACE void fp20_QSerror_memory_free (
  fp20_QSerror_memory mem);

  fp20_QSLIB_INTERFACE int fp20_QSerror_memory_get_nof (
  fp20_QSerror_memory mem,
  int error_type);
  fp20_QSLIB_INTERFACE int fp20_QSerror_memory_get_nerrors (
  fp20_QSerror_memory mem);

  fp20_QSLIB_INTERFACE fp20_QSformat_error fp20_QSerror_memory_get_last_error (
  fp20_QSerror_memory mem);
  fp20_QSLIB_INTERFACE fp20_QSformat_error fp20_QSerror_memory_get_prev_error (
  fp20_QSformat_error e);

/**************************************************************************** 
 * reporter for solver fp20_feedback 
 */
  fp20_QSLIB_INTERFACE void fp20_QSset_reporter (
  fp20_QSprob prob,
  int iterskip,
  void *fct,
  void *dest);

  fp20_QSLIB_INTERFACE int fp20_QSreport_prob (
  fp20_QSprob p,
  const char *filetype,
  fp20_QSerror_collector c);

#ifdef  __cplusplus
}
#endif
#endif                          /* fp20___QS_QSOPT_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: fp20_format.h,v 1.3 2003/11/05 16:59:48 meven Exp $ */
#ifndef fp20_QS_FORMAT_ERROR_H
#define fp20_QS_FORMAT_ERROR_H


/****************************************************************************/
/*
   The LP/MPS readers, writers, 
       fp20_ILLrawlpdata_to_lpdata, and 
   use fp20_ILLformat_error to report problems with their input iff
       the line reader used in reading the problem  or 
       the  fp20_qserror_collector pointer passed to fp20_ILLwrite_lp_file
   is not NULL.

   The QSgui code uses this feature to collect fp20_qsformat_error instances 
   which it uses after reading is done to insert error messages into the 
   input window. 
*/
/****************************************************************************/

/* 
for error type USE: 
          QS_DATA_ERROR     
          QS_DATA_WARN      
          QS_MPS_FORMAT_ERROR   
          QS_MPS_FORMAT_WARN    
          QS_LP_FORMAT_ERROR    
          QS_LP_FORMAT_WARN   
          QS_LP_OBJ_WARN      
          QS_GENERIC_ERROR    
*/

typedef struct fp20_qsformat_error
{
  char *desc;
  char *theLine;
  struct fp20_qsformat_error *next;
  int type;
  int lineNumber;               /* 1 based line counting */
  int at;
}
fp20_qsformat_error;

extern int fp20_ILLformat_error_create (
  fp20_qsformat_error * error,
  int mode,
  const char *desc,
  int lineNum,
  const char *theLine,
  int atPos);
extern void fp20_ILLformat_error_delete (
  fp20_qsformat_error * error);

extern void fp20_ILLformat_error_print (
  EGioFile_t * out,
  fp20_qsformat_error * e);



/*****************************************************************************
 * collecting error messages 
 * either with defining own qsad_error_fct and corresponding data structure 
 * or by using predefined fp20_ILLadd_error_to_memory fct with fp20_qserror_memory
 */

typedef int (
  *fp20_qsadd_error_fct) (
  void *dest,
  const fp20_qsformat_error * error);

typedef struct fp20_qserror_collector
{
  fp20_qsadd_error_fct add_error;
  void *dest;
}
fp20_qserror_collector;

typedef struct fp20_qserror_memory
{
  unsigned int nerror;
  fp20_qsformat_error *error_list;
  char has_error[QS_INPUT_NERROR];
  char hasErrorLines;
}
fp20_qserror_memory;


extern fp20_qserror_collector *fp20_ILLerror_collector_new (
  fp20_qsadd_error_fct fct,
  void *dest);

fp20_qserror_collector *fp20_ILLerror_memory_collector_new (
  fp20_qserror_memory * dest);

extern void fp20_ILLerror_collector_free (
  fp20_qserror_collector * c);

#define fp20_ILLformat_error(collector, error)  \
  ((collector)->add_error((collector)->dest, error))


extern int fp20_ILLadd_error_to_memory (
  void *dest,
  const fp20_qsformat_error * error);

extern fp20_qserror_memory *fp20_ILLerror_memory_create (
  int takeErrorLines);
extern void fp20_ILLerror_memory_free (
  fp20_qserror_memory * mem);

#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  RCS_INFO = "$RCSfile: fp20_rawlp.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $"; */
#ifndef fp20___ILL_RAWLP_H_
#define fp20___ILL_RAWLP_H_

/****************************************************************************/
/* DataStructure and Routines                                               */
/*          to deal with raw lp information as read from mps or lp files    */
/*          support scanning of input                                       */
/*          error reporting                                                 */
/****************************************************************************/


#define fp20_ILL_ISBLANK(p) \
             (((*(p))==' '||(*(p))=='\t'||(*(p))=='\r'||(*(p))=='\f') ? 1 : 0)

/* 
 * we rely on ILLsymboltab property:
 *   the ith name added can be retrieved by ILLsymboltab_get(table, i) 
 *   as long as we never delete names from the symbol table 
 */
typedef struct fp20_rawlpdata
{
  char *name;

  char *rhsname;
  char *rangesname;
  char *boundsname;

  int objsense;                 /* maximize or minimize */
  int objindex;                 /* index of objective row */

  int nrows;                    /* number of rows in problem */
  ILLsymboltab rowtab;          /* ILLsymboltab_get(rowtab, i) name of ith row */

  int sensesize;                /* size of rowsense */
  char *rowsense;               /* rowsense[i] snese of row[i] */

  char *rhsind;                 /* rhsind[i] == 1 we saw an rhs for row[i] */
  /* size is nrows */
  int rhssize;                  /* size of rhs array */
  EGfp20_t *rhs;                /* rhs values for rows; size is nrows */
  char *rangesind;              /* ranges[i] == 1 we saw a range def for row[i] */
  struct fp20_colptr *ranges;       /* list of range values */

  int ncols;                    /* number of cols in problem */
  ILLsymboltab coltab;          /* ILLsymboltab_get(coltab, i) name of ith col */
  int colsize;                  /* size of cols array */
  struct fp20_colptr **cols;

  char *lbind;                  /* lbind[i] == 1  we saw a lower bound for col[i] */
  char *ubind;                  /* ubind[i] == 1  we saw a upper bound for col[i] */
  EGfp20_t *lower;              /* lower[i] = lower bound for col[i] */
  EGfp20_t *upper;              /* upper[i] = upper bound for col[i] */

  int intsize;                  /* size of intmarker array */
  char *intmarker;              /* intmarker[i] == 1  col[i] is an int var */

  /* sos information is tranfered into fp20_ILLmatrix lpdata->sos */
  char *refrow;                 /* name of reference row */
  int refrowind;                /* index of refrow or -1  */

  int is_sos_size;              /* size of is_sos_member array */
  int *is_sos_member;           /* for each col contains either               
                                 *     -1 == no sos memeber 
                                 *     i  == member of set #i */

  int nsos_member;              /* total number of sos set members */
  int sos_weight_size;          /* size of sos_weight array */
  EGfp20_t *sos_weight;       /* sos set elem i has weight of sos_weight[i] 
                                 * value comes from refrow coeficients */
  int sos_col_size;             /* size of sos_col array */
  int *sos_col;                 /* sos elem i is column sos_col[i] */

  int nsos;                     /* number of sos sets */
  int sos_setsize;              /* size of sosset array */
  struct fp20_sosptr *sos_set;        /* type, size, first element of sos sets 
                                 * first is index into sos_weight and sos_col 
                                 * arrays */
  fp20_qserror_collector *error_collector;
  ILLptrworld ptrworld;
}
fp20_rawlpdata;

typedef struct fp20_colptr
{
  EGfp20_t coef;
  struct fp20_colptr *next;
  int this_val;                     /* row index */
}
fp20_colptr;
extern fp20_colptr *fp20_ILLcolptralloc (
  ILLptrworld * p);

typedef struct fp20_sosptr
{
  int nelem;                    /* number of set elements */
  int first;                    /* index of first set element in sosmemeber */
  char type;                    /* set type */
}
fp20_sosptr;
extern const int fp20_ILL_SOS_TYPE1;
extern const int fp20_ILL_SOS_TYPE2;

extern void fp20_ILLinit_rawlpdata (
  fp20_rawlpdata * lp,
  fp20_qserror_collector * collector);
extern void fp20_ILLfree_rawlpdata (
  fp20_rawlpdata * lp);
extern void fp20_ILLraw_clear_matrix (
  fp20_rawlpdata * lp);

extern const char *fp20_ILLraw_rowname (
  fp20_rawlpdata * lp,
  int i);
extern const char *fp20_ILLraw_colname (
  fp20_rawlpdata * lp,
  int i);

extern int fp20_ILLraw_add_col (
  fp20_rawlpdata * lp,
  const char *name,
  int intmarker);
extern int fp20_ILLraw_add_row (
  fp20_rawlpdata * lp,
  const char *name,
  int sense,
  const EGfp20_t rhs);

extern int fp20_ILLraw_add_col_coef (
  fp20_rawlpdata * lp,
  int colind,
  int rowind,
  EGfp20_t coef);

extern int fp20_ILLraw_init_ranges (
  fp20_rawlpdata * lp);
extern int fp20_ILLraw_init_rhs (
  fp20_rawlpdata * lp);

extern int fp20_ILLraw_add_ranges_coef (
  fp20_rawlpdata * lp,
  int rowind,
  EGfp20_t coef);


extern int fp20_ILLraw_add_sos (
  fp20_rawlpdata * lp,
  int sos_type);

                                                /* add empty set with type */
extern int fp20_ILLraw_add_sos_member (
  fp20_rawlpdata * lp,
  int colind);

                                                /* add col to last set */
extern int fp20_ILLraw_is_mem_other_sos (
  fp20_rawlpdata * lp,
  int colind);

extern int fp20_ILLraw_set_rhs_name (
  fp20_rawlpdata * lp,
  const char *name,
  int *skip);
extern int fp20_ILLraw_set_bounds_name (
  fp20_rawlpdata * lp,
  const char *name,
  int *skip);
extern int fp20_ILLraw_set_ranges_name (
  fp20_rawlpdata * lp,
  const char *name,
  int *skip);
extern void fp20_ILLprint_rawlpdata (
  fp20_rawlpdata * lp);

extern char *fp20_ILLraw_unique_name (
  ILLsymboltab * tab,
  char *prefix,
  int i);
extern int fp20_ILLraw_fill_in_rownames (
  fp20_rawlpdata * lp);

extern int fp20_ILLraw_init_bounds (
  fp20_rawlpdata * lp);

extern const char *fp20_ILLraw_set_lowerBound (
  fp20_rawlpdata * lp,
  int i,
  EGfp20_t bnd);
extern const char *fp20_ILLraw_set_upperBound (
  fp20_rawlpdata * lp,
  int i,
  EGfp20_t bnd);
extern const char *fp20_ILLraw_set_fixedBound (
  fp20_rawlpdata * lp,
  int i,
  EGfp20_t bnd);
extern const char *fp20_ILLraw_set_binaryBound (
  fp20_rawlpdata * lp,
  int i);
extern const char *fp20_ILLraw_set_unbound (
  fp20_rawlpdata * lp,
  int colind);
extern int fp20_ILLraw_fill_in_bounds (
  fp20_rawlpdata * lp);

extern int fp20_ILLraw_first_nondefault_bound (
  fp20_ILLlpdata * lp);
extern int fp20_ILLraw_default_lower (
  fp20_ILLlpdata * lp,
  int i);
extern int fp20_ILLraw_default_upper (
  fp20_ILLlpdata * lp,
  int i,
  int ri);

extern int fp20_ILLrawlpdata_to_lpdata (
  fp20_rawlpdata * raw,
  fp20_ILLlpdata * lp);

extern int fp20_ILLdata_error (
  fp20_qserror_collector * collector,
  const char *format,
  ...);
extern void fp20_ILLdata_warn (
  fp20_qserror_collector * collector,
  const char *format,
  ...);

#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: fp20_mps.h,v 1.2 2003/11/05 16:57:39 meven Exp $ */
#ifndef fp20_MPS_H
#define fp20_MPS_H


/****************************************************************************/
/*                                                                          */
/*              Routines to support Reading and Writing MPS Files           */
/*                                                                          */
/****************************************************************************/
extern const char *fp20_ILLmps_section_name[ILL_MPS_N_SECTIONS + 2];


extern int fp20_ILLread_mps (
  fp20_qsline_reader * file,
  const char *filename,
  fp20_rawlpdata * lp);

extern int fp20_ILLwrite_mps (
  fp20_ILLlpdata * lp,
  fp20_qserror_collector * collector);

        /* use lp->reporter for output */

#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  $RCSfile: fp20_price.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $" */
#ifndef fp20___PRICE_H
#define fp20___PRICE_H


typedef struct fp20_price_res
{
  int eindex;
  int dir;
  int lindex;
  int lvstat;
  int price_stat;
  EGfp20_t dinfeas;
  EGfp20_t pinfeas;
}
fp20_price_res;

int fp20_ILLprice_test_for_heap (
  fp20_lpinfo * const lp,
  fp20_price_info * const pinf,
  int const nkeys,
  EGfp20_t * keylist,
  int const algo,
  int const upd),
  fp20_ILLprice_build_heap (
  fp20_price_info * const pinf,
  int const nkeys,
  EGfp20_t * keylist),
  fp20_ILLprice_build_pricing_info (
  fp20_lpinfo * const lp,
  fp20_price_info * const pinf,
  int const phase),
  fp20_ILLprice_update_pricing_info (
  fp20_lpinfo * const lp,
  fp20_price_info * const pinf,
  int const phase,
  fp20_svector * const wz,
  int const eindex,
  int const lindex,
  EGfp20_t y),
  fp20_ILLprice_get_price (
  fp20_price_info * const p,
  int const phase),
  fp20_ILLprice_build_mpartial_info (
  fp20_lpinfo * const lp,
  fp20_price_info * const pinf,
  int const pricetype),
  fp20_ILLprice_build_pdevex_norms (
  fp20_lpinfo * const lp,
  fp20_p_devex_info * const pdinfo,
  int const reinit),
  fp20_ILLprice_update_pdevex_norms (
  fp20_lpinfo * const lp,
  fp20_p_devex_info * const pdinfo,
  int const eindex,
  EGfp20_t yl),
  fp20_ILLprice_build_psteep_norms (
  fp20_lpinfo * const lp,
  fp20_p_steep_info * const psinfo),
  fp20_ILLprice_build_ddevex_norms (
  fp20_lpinfo * const lp,
  fp20_d_devex_info * const ddinfo,
  int const reinit),
  fp20_ILLprice_update_ddevex_norms (
  fp20_lpinfo * const lp,
  fp20_d_devex_info * const ddinfo,
  int const eindex,
  EGfp20_t yl),
  fp20_ILLprice_build_dsteep_norms (
  fp20_lpinfo * const lp,
  fp20_d_steep_info * const dsinfo),
  fp20_ILLprice_get_dsteep_norms (
  fp20_lpinfo * const lp,
  int const count,
  int *constrowind,
  EGfp20_t * const norms),
  fp20_ILLprice_get_rownorms (
  fp20_lpinfo * const lp,
  fp20_price_info * const pinf,
  EGfp20_t * const rnorms),
  fp20_ILLprice_get_colnorms (
  fp20_lpinfo * const lp,
  fp20_price_info * const pinf,
  EGfp20_t * const cnorms),
  fp20_ILLprice_get_newnorms (
  fp20_lpinfo * const lp,
  int const nelems,
  EGfp20_t * const norms,
  int *const matcnt,
  int *const matbeg,
  int *const matind,
  EGfp20_t * const matval,
  int const option),
  fp20_ILLprice_get_new_rownorms (
  fp20_lpinfo * const lp,
  int const newrows,
  EGfp20_t * const rnorms,
  int *const rmatcnt,
  int *const rmatbeg,
  int *const rmatind,
  EGfp20_t * const rmatval),
  fp20_ILLprice_get_new_colnorms (
  fp20_lpinfo * const lp,
  int const newrows,
  EGfp20_t * const rnorms,
  int *const matcnt,
  int *const matbeg,
  int *const matind,
  EGfp20_t * const matval),
  fp20_ILLprice_load_rownorms (
  fp20_lpinfo * const lp,
  EGfp20_t * const rnorms,
  fp20_price_info * const pinf),
  fp20_ILLprice_load_colnorms (
  fp20_lpinfo * const lp,
  EGfp20_t * const cnorms,
  fp20_price_info * const pinf);


void fp20_ILLprice_free_heap (
  fp20_price_info * const pinf),
  fp20_ILLprice_init_pricing_info (
  fp20_price_info * const pinf),
  fp20_ILLprice_free_pricing_info (
  fp20_price_info * const pinf),
  fp20_ILLprice_free_mpartial_info (
  fp20_mpart_info * p),
  fp20_ILLprice_init_mpartial_price (
  fp20_lpinfo * const lp,
  fp20_price_info * const pinf,
  int const phase,
  int const pricetype),
  fp20_ILLprice_update_mpartial_price (
  fp20_lpinfo * const lp,
  fp20_price_info * const pinf,
  int const phase,
  int const pricetype),
  fp20_ILLprice_delete_onempart_price (
  /*fp20_lpinfo * const lp,*/
  fp20_price_info * const pinf,
  int const indx,
  int const pricetype),
  fp20_ILLprice_mpartial_group (
  fp20_lpinfo * const lp,
  fp20_mpart_info * const p,
  int const phase,
  int const g,
  int const pricetype),
  fp20_ILLprice_column (
  fp20_lpinfo * const lp,
  int const ix,
  int const phase,
  fp20_price_res * const pr),
  fp20_ILLprice_row (
  fp20_lpinfo * const lp,
  int const ix,
  int const phase,
  fp20_price_res * const pr),
  fp20_ILLprice_update_psteep_norms (
  fp20_lpinfo * lp,
  fp20_p_steep_info * psinfo,
  fp20_svector * wz,
  int eindex,
  EGfp20_t yl),
  fp20_ILLprice_update_dsteep_norms (
  fp20_lpinfo * const lp,
  fp20_d_steep_info * const dsinfo,
  fp20_svector * const wz,
  int const lindex,
  EGfp20_t yl),
  fp20_ILLprice_compute_dual_inf (
  fp20_lpinfo * const lp,
  fp20_price_info * const p,
  int *const ix,
  int const icnt,
  int const phase),
  fp20_ILLprice_primal (
  fp20_lpinfo * const lp,
  fp20_price_info * const pinf,
  fp20_price_res * const pr,
  int const phase),
  fp20_ILLprice_compute_primal_inf (
  fp20_lpinfo * const lp,
  fp20_price_info * const p,
  int *const ix,
  int const icnt,
  int const phase),
  fp20_ILLprice_dual (
  fp20_lpinfo * const lp,
  fp20_price_info * const pinf,
  int const phase,
  fp20_price_res * const pr);

void fp20_test_dsteep_norms (
  fp20_lpinfo * const lp,
  fp20_price_info * const p);

#endif /* fp20___PRICE_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

#ifndef fp20___PRIORITY_H__
#define fp20___PRIORITY_H__
/****************************************************************************/
/*                                                                          */
/*                             fp20_priority.c                                   */
/*                                                                          */
/****************************************************************************/

typedef struct fp20_ILLpriority
{
  fp20_ILLdheap fp20_heap;
  union fp20_ILLpri_data
  {
    void *data;
    int next;
  }
   *pri_info;
  int space;
  int freelist;
}
fp20_ILLpriority;

void fp20_ILLutil_priority_free (
  fp20_ILLpriority * pri),
  fp20_ILLutil_priority_delete (
  fp20_ILLpriority * pri,
  int handle),
  fp20_ILLutil_priority_changekey (
  fp20_ILLpriority * pri,
  int handle,
  EGfp20_t * newkey),
  fp20_ILLutil_priority_findmin (
  fp20_ILLpriority * pri,
  EGfp20_t * keyval,
  void **en),
  fp20_ILLutil_priority_deletemin (
  fp20_ILLpriority * pri,
  EGfp20_t * keyval,
  void **en);

int fp20_ILLutil_priority_init (
  fp20_ILLpriority * pri,
  int k),
  fp20_ILLutil_priority_insert (
  fp20_ILLpriority * pri,
  void *data,
  EGfp20_t * keyval,
  int *handle);



#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  $RCSfile: fp20_ratio.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $" */
#ifndef fp20___RATIO_H
#define fp20___RATIO_H
typedef struct fp20_ratio_res
{
  EGfp20_t tz;
  int eindex;
  int lindex;
  int lvstat;
  int ratio_stat;
  int boundch;
  int coeffch;
  EGfp20_t lbound;
  EGfp20_t ecoeff;
  EGfp20_t pivotval;
}
fp20_ratio_res;

void fp20_ILLratio_pI_test (
  fp20_lpinfo * const lp,
  int const eindex,
  int const dir,
  fp20_ratio_res * const rs),
  fp20_ILLratio_pII_test (
  fp20_lpinfo * const lp,
  int const eindex,
  int const dir,
  fp20_ratio_res * const rs),
  fp20_ILLratio_dI_test (
  fp20_lpinfo * const lp,
  int const lindex,
  int const lvstat,
  fp20_ratio_res * const rs),
  fp20_ILLratio_dII_test (
  fp20_lpinfo * const lp,
  /*int const lindex,*/
  int const lvstat,
  fp20_ratio_res * const rs),
  fp20_ILLratio_longdII_test (
  fp20_lpinfo * const lp,
  int const lindex,
  int const lvstat,
  fp20_ratio_res * const rs),
  fp20_ILLratio_pivotin_test (
  fp20_lpinfo * const lp,
  int *const rlist,
  int const rcnt,
  fp20_ratio_res * const rs);

#endif /* fp20___RATIO_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  RCS_INFO = "$RCSfile: read_lp_state.h,v $ $Revision: 1.2 $ $Date: 2003/11/05 16:57:39 $"; */
#ifndef fp20_READ_LP_STATE_H
#define fp20_READ_LP_STATE_H

/****************************************************************************/
/*                                                                          */
/*               Routines to support Reading LP Files                       */
/*                                                                          */
/****************************************************************************/

/* 
 * -) anything after '\' is comment 
 * -) variables consist of a-z A-Z 0-9!"#$%(),;.?@_`'{}|~ 
 *    don't start with a digit or '.'
 */


typedef struct fp20_ILLread_lp_state
{
  fp20_qsline_reader *file;
  const char *file_name;
  char *p;
  EGfp20_t bound_val;
  int fp20_interactive;
  int line_num;
  int column_index;
  char realline[ILL_namebufsize];
  char line[ILL_namebufsize];
  char field[ILL_namebufsize + 1];
  char fieldOnFirstCol;
  char eof;
  char sense_val;
}
fp20_ILLread_lp_state;

extern int fp20_ILLread_lp_state_init (
  fp20_ILLread_lp_state * state,
  fp20_qsline_reader * file,
  const char *fp20_fname,
  int interactve);
extern int fp20_ILLread_lp_state_next_line (
  fp20_ILLread_lp_state * state);
extern int fp20_ILLread_lp_state_next_var (
  fp20_ILLread_lp_state * state);
extern int fp20_ILLread_lp_state_keyword (
  fp20_ILLread_lp_state * state,
  const char **kwd);
extern int fp20_ILLread_lp_state_bad_keyword (
  fp20_ILLread_lp_state * state);
extern int fp20_ILLtest_lp_state_keyword (
  fp20_ILLread_lp_state * state,
  const char *kwd[]);
extern int fp20_ILLread_lp_state_next_field (
  fp20_ILLread_lp_state * state);
extern int fp20_ILLread_lp_state_next_field_on_line (
  fp20_ILLread_lp_state * state);
extern void fp20_ILLread_lp_state_prev_field (
  fp20_ILLread_lp_state * state);
extern int fp20_ILLread_lp_state_sign (
  fp20_ILLread_lp_state * state,
  EGfp20_t * sign);
extern int fp20_ILLread_lp_state_possible_coef (
  fp20_ILLread_lp_state * state,
  EGfp20_t * coef,
  const EGfp20_t defValue);

                                        /* returns 1 iff found a number 
                                         * otherwise 0 */
extern int fp20_ILLread_lp_state_possible_bound_value (
  fp20_ILLread_lp_state * state);

                                               /* returns 1 iff found a number 
                                                * otherwise 0 */
extern int fp20_ILLread_lp_state_colon (
  fp20_ILLread_lp_state * state);
extern int fp20_ILLread_lp_state_has_colon (
  fp20_ILLread_lp_state * state);
extern int fp20_ILLread_lp_statxe_has_colon (
  fp20_ILLread_lp_state * state);
extern int fp20_ILLread_lp_state_next_constraint (
  fp20_ILLread_lp_state * state);
extern int fp20_ILLread_lp_state_sense (
  fp20_ILLread_lp_state * state);
extern int fp20_ILLtest_lp_state_sense (
  fp20_ILLread_lp_state * state,
  int all);
extern void fp20_ILLtest_lp_state_bound_sense (
  fp20_ILLread_lp_state * state);
extern int fp20_ILLread_lp_state_value (
  fp20_ILLread_lp_state * state,
  EGfp20_t * d);
extern int fp20_ILLtest_lp_state_next_is (
  fp20_ILLread_lp_state * state,
  const char *str);
extern int fp20_ILLread_lp_state_skip_blanks (
  fp20_ILLread_lp_state * state,
  int wrapLines);

extern int fp20_ILLcheck_subject_to (
  fp20_ILLread_lp_state * state);

/*---------------------------------------------------------------------------*/
/* errors and warnings 
 */
extern int fp20_ILLlp_error (
  fp20_ILLread_lp_state * state,
  const char *format,
  ...);
extern void fp20_ILLlp_warn (
  fp20_ILLread_lp_state * state,
  const char *format,
  ...);

/*---------------------------------------------------------------------------*/
/* shared with read_mps_state.c 
 */
extern int fp20_ILLget_value (
  char *line,
  EGfp20_t * coef);

#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* $RCSfile: rd_mps.h,v $ $Revision: 1.2 $ $Date: 2003/11/05 16:57:39 $ */
#ifndef fp20_READ_MPS_STATE_H
#define fp20_READ_MPS_STATE_H



typedef struct fp20_ILLread_mps_state_struct
{
  int section[ILL_MPS_N_SECTIONS];
  ILLmps_section active;
  const char *file_name;
  fp20_qsline_reader *file;
  unsigned int line_num;
  unsigned int field_num;       /* number of successfully read fields on line */
  int intvar;
  int sosvar;
  char line[ILL_namebufsize];
  char key[ILL_namebufsize];
  char field[ILL_namebufsize];
  char *obj;
  char *p;                      /* ptr to next 'unread' character */
}
fp20_ILLread_mps_state;

extern int fp20_ILLmps_state_init (
  fp20_ILLread_mps_state * state,
  fp20_qsline_reader * file,
  const char *fp20_fname);
extern void fp20_ILLmps_state_clear (
  fp20_ILLread_mps_state * state);
extern int fp20_ILLmps_set_section (
  fp20_ILLread_mps_state * state,
  const ILLmps_section sec);

extern int fp20_ILLmps_next_line (
  fp20_ILLread_mps_state * state);
extern int fp20_ILLmps_next_field (
  fp20_ILLread_mps_state * state);
extern int fp20_ILLmps_next_coef (
  fp20_ILLread_mps_state * state,
  EGfp20_t * coef);
extern int fp20_ILLmps_next_bound (
  fp20_ILLread_mps_state * state,
  EGfp20_t * coef);
extern void fp20_ILLmps_check_end_of_line (
  fp20_ILLread_mps_state * state);
extern void fp20_ILLmps_set_end_of_line (
  fp20_ILLread_mps_state * state);

extern int fp20_ILLmps_int_sos_mode (
  fp20_ILLread_mps_state * state);

extern const char *fp20_ILLmps_possibly_blank_name (
  const char *field,
  fp20_ILLread_mps_state * state,
  ILLsymboltab * tab);
extern int fp20_ILLmps_empty_key (
  fp20_ILLread_mps_state * state);
extern int fp20_ILLmps_empty_field (
  fp20_ILLread_mps_state * state);

extern int fp20_ILLmps_error (
  fp20_ILLread_mps_state * state,
  const char *format,
  ...);
extern void fp20_ILLmps_warn (
  fp20_ILLread_mps_state * state,
  const char *format,
  ...);

#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* $RCSfile: fp20_simplex.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $ */

#ifndef fp20___SIMPLEX_H
#define fp20___SIMPLEX_H

struct itcnt_t;
typedef struct fp20_param_info
{
  int origalgo;
  int pphaseI;
  int pphaseII;
  int dphaseI;
  int dphaseII;
  int p_strategy;
  int d_strategy;
}
fp20_param_info;

typedef struct fp20_iter_info
{
  int newphase;
  int nextphase;
  int nextstep;
  int sdisplay;
  int itercnt;
  int solstatus;
  int curtime;
  int rounds;
  int chkobj;
  int nosolve;
  int noprog;
  int inner;
  int algorithm;
  int resumeid;
  int pricetype;
  int n_restart;
  int n_pivot_fail;
  EGfp20_t prevobj;
  EGfp20_t objtol;
  fp20_param_info oldinfo;
}
fp20_iter_info;

void fp20_ILLsimplex_init_lpinfo ( fp20_lpinfo * lp),
    fp20_ILLsimplex_free_lpinfo ( fp20_lpinfo * lp),
    fp20_ILLsimplex_load_lpinfo ( fp20_ILLlpdata * qslp, fp20_lpinfo * lp),
    fp20_ILLsimplex_set_bound ( fp20_lpinfo * lp, const EGfp20_t * objbound, int sense);
void fp20_free_internal_lpinfo ( fp20_lpinfo * lp);
void fp20_init_internal_lpinfo ( fp20_lpinfo * lp);
int fp20_build_internal_lpinfo ( fp20_lpinfo * lp);
int fp20_ILLsimplex_retest_psolution ( fp20_lpinfo * lp, fp20_price_info * p, int phase,
      fp20_feas_info * fs),
    fp20_ILLsimplex_retest_dsolution ( fp20_lpinfo * lp, fp20_price_info * p, int phase,
      fp20_feas_info * fs),
    fp20_ILLsimplex_solution ( fp20_lpinfo * lp, EGfp20_t * xz, EGfp20_t * piz,
      EGfp20_t * dz, EGfp20_t * objval),
    fp20_ILLsimplex_infcertificate ( fp20_lpinfo * lp, EGfp20_t * pi),
    fp20_ILLsimplex ( fp20_lpinfo * lp, int algorithm, fp20_ILLlp_basis * B, 
      fp20_price_info * pinf, int *sol_status, int sdisplay, itcnt_t* itcnt),
    fp20_ILLsimplex_pivotin ( fp20_lpinfo * lp, fp20_price_info * pinf, int rcnt, 
      int *rlist, int pivot_opt, int *basis_mod);

#endif /* fp20___SIMPLEX_H */
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  RCS_INFO = "$RCSfile: wr_lp.h,v $ $Revision: 1.2 $ $Date: 2003/11/05 16:57:39 $"; */
#ifndef fp20_WRITE_LP_STATE_H
#define fp20_WRITE_LP_STATE_H

/****************************************************************************/
/*                                                                          */
/*               Routines to support writing of LP files                    */
/*                                                                          */
/****************************************************************************/

/* 
 * -) anything after '\' is comment 
 * -) variables consist of a-z A-Z 0-9!"#$%(),;.?@_`'{}|~ 
 *    don't start with a digit or '.'
 */

typedef struct fp20_ILLwrite_lp_state
{
  char buf[ILL_namebufsize];
  char *p;
  int startlen;
  int total;
}
fp20_ILLwrite_lp_state;

extern void fp20_ILLwrite_lp_state_init (
  fp20_ILLwrite_lp_state * line,
  const char *str);
extern void fp20_ILLwrite_lp_state_append (
  fp20_ILLwrite_lp_state * line,
  const char *str);
extern void fp20_ILLwrite_lp_state_append_coef (
  fp20_ILLwrite_lp_state * line,
  EGfp20_t v,
  int cnt);

      /* append number sign ('+', '-') iff cnt > 0 or v < 0.0  
       * append number iff v != 1.0, v != -1.0  
       */
extern void fp20_ILLwrite_lp_state_append_number (
  fp20_ILLwrite_lp_state * line,
  EGfp20_t v);
extern void fp20_ILLwrite_lp_state_save_start (
  fp20_ILLwrite_lp_state * line);
extern void fp20_ILLwrite_lp_state_start (
  fp20_ILLwrite_lp_state * line);

#endif
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: fp20_lib.h,v 1.4 2003/11/05 17:00:26 meven Exp $ */
#ifndef fp20_ILL_LIB_H
#define fp20_ILL_LIB_H


/****************************************************************************/
/*                                                                          */
/*                   Return Status for fp20_ILLlib_optimize                      */
/*                                                                          */
/****************************************************************************/

/****************************************************************************/
/*                                                                          */
/*                               fp20_lib.c                                      */
/*                                                                          */
/****************************************************************************/

struct itcnt_t;

int fp20_ILLlib_optimize ( fp20_lpinfo * lp, fp20_ILLlp_basis * B, fp20_price_info * pinf, int algo,
      int *status, int simplex_display, struct itcnt_t*itcnt),
    fp20_ILLlib_cache_solution ( fp20_lpinfo * lp, fp20_ILLlp_cache * C), 
    fp20_ILLlib_solution ( fp20_lpinfo * lp, fp20_ILLlp_cache * C, EGfp20_t * val, 
      EGfp20_t * x, EGfp20_t * pi, EGfp20_t * slack, EGfp20_t * rc),
    fp20_ILLlib_get_x ( fp20_lpinfo * lp, fp20_ILLlp_cache * C, EGfp20_t * x),
    fp20_ILLlib_get_slack ( fp20_lpinfo * lp, fp20_ILLlp_cache * C, EGfp20_t * slack),
    fp20_ILLlib_objval ( fp20_lpinfo * lp, fp20_ILLlp_cache * C, EGfp20_t * val),
    fp20_ILLlib_tableau ( fp20_lpinfo * lp, int row, EGfp20_t * binv, EGfp20_t * tabrow),
    fp20_ILLlib_basis_order ( fp20_lpinfo * lp, int *header),
    fp20_ILLlib_newrow ( fp20_lpinfo * lp, fp20_ILLlp_basis * B,const EGfp20_t rhs, int sense,
      const EGfp20_t range, const char *name),
    fp20_ILLlib_newrows ( fp20_lpinfo * lp, fp20_ILLlp_basis * B, int num,const EGfp20_t * rhs,
      char *sense, const EGfp20_t * range, const char **names),
    fp20_ILLlib_addrow ( fp20_lpinfo * lp, fp20_ILLlp_basis * B, int cnt, int *ind,
      const EGfp20_t * val, const EGfp20_t rhs, int sense,const EGfp20_t range,
      const char *rowname),
    fp20_ILLlib_addrows ( fp20_lpinfo * lp, fp20_ILLlp_basis * B, int num, int *rmatcnt, 
      int *rmatbeg, int *rmatind,const EGfp20_t * rmatval,const EGfp20_t * rhs, 
      char *sense, const EGfp20_t * range, const char **names, int *nofactor),
    fp20_ILLlib_delrows ( fp20_lpinfo * lp, fp20_ILLlp_basis * B, fp20_ILLlp_cache * C, int num, 
      int *dellist, int *basis_ok, int *cache_ok), 
    fp20_ILLlib_newcol ( fp20_lpinfo * lp, fp20_ILLlp_basis * B,const EGfp20_t obj, 
      const EGfp20_t lower,const EGfp20_t upper, const char *name, int factorok), 
    fp20_ILLlib_newcols ( fp20_lpinfo * lp, fp20_ILLlp_basis * B, int num, EGfp20_t * obj,
      EGfp20_t * lower, EGfp20_t * upper, const char **names, int factorok),
    fp20_ILLlib_addcol ( fp20_lpinfo * lp, fp20_ILLlp_basis * B, int cnt, int *ind,
      EGfp20_t * val,const EGfp20_t obj,const EGfp20_t lower,const EGfp20_t upper, 
      const char *name, int factorok),
    fp20_ILLlib_addcols ( fp20_lpinfo * lp, fp20_ILLlp_basis * B, int num, int *cmatcnt,
      int *cmatbeg, int *cmatind, EGfp20_t * cmatval, EGfp20_t * obj,
      EGfp20_t * lower, EGfp20_t * upper, const char **names, int factorok),
    fp20_ILLlib_delcols ( fp20_lpinfo * lp, fp20_ILLlp_basis * B, int num, int *dellist,
      int *basis_ok),
    fp20_ILLlib_chgcoef ( fp20_lpinfo * lp, int rowindex, int colindex, EGfp20_t coef), 
    fp20_ILLlib_getcoef (fp20_lpinfo *lp, int rowindex, int colindex, EGfp20_t* coef),
    fp20_ILLlib_chgrange (fp20_lpinfo *lp, int indx, EGfp20_t coef),
    fp20_ILLlib_chgsense ( fp20_lpinfo * lp, int num, int *rowlist, char *sense),
    fp20_ILLlib_getsenses (fp20_lpinfo *lp, char *senses),
    fp20_ILLlib_getrows ( fp20_lpinfo * lp, int num, int *rowlist, int **rowcnt,
      int **rowbeg, int **rowind, EGfp20_t ** rowval, EGfp20_t ** rhs,
      char **sense, EGfp20_t ** range, char ***names),
    fp20_ILLlib_getcols ( fp20_lpinfo * lp, int num, int *collist, int **colcnt,
      int **colbeg, int **colind, EGfp20_t ** colval, EGfp20_t ** obj,
      EGfp20_t ** lower, EGfp20_t ** upper, char ***names),
    fp20_ILLlib_getobj ( fp20_lpinfo * lp, EGfp20_t * obj),
    fp20_ILLlib_getobj_list (fp20_lpinfo *lp, int num, int* collist, EGfp20_t* obj),
    fp20_ILLlib_chgobj ( fp20_lpinfo * lp, int indx, EGfp20_t coef),
    fp20_ILLlib_getrhs ( fp20_lpinfo * lp, EGfp20_t * rhs),
    fp20_ILLlib_chgrhs ( fp20_lpinfo * lp, int indx, EGfp20_t coef),
    fp20_ILLlib_getintflags ( fp20_lpinfo * lp, int *intflags),
    fp20_ILLlib_rownames ( fp20_lpinfo * lp, char **rownames),
    fp20_ILLlib_colnames ( fp20_lpinfo * lp, char **colnames),
    fp20_ILLlib_colindex ( fp20_lpinfo * lp, const char *name, int *colindex),
    fp20_ILLlib_rowindex ( fp20_lpinfo * lp, const char *name, int *rowindex),
    fp20_ILLlib_chgbnd ( fp20_lpinfo * lp, int indx, int lu,const EGfp20_t bnd),
    fp20_ILLlib_chgbnds ( fp20_lpinfo * lp, int cnt, int *indx, char *lu, const EGfp20_t * bnd),
    fp20_ILLlib_getbnd ( fp20_lpinfo * lp, int indx, int lu, EGfp20_t * bnd),
    fp20_ILLlib_getbnds ( fp20_lpinfo * lp, EGfp20_t * lower, EGfp20_t * upper),
    fp20_ILLlib_getbnds_list ( fp20_lpinfo *lp, int num, int*collist, EGfp20_t *lower,
      EGfp20_t *upper),
    fp20_ILLlib_strongbranch ( fp20_lpinfo * lp, fp20_price_info * pinf, int *candidatelist,
      int ncand, EGfp20_t * xlist, EGfp20_t * downpen, EGfp20_t * uppen,
      int iterations, EGfp20_t objbound, struct itcnt_t*itcnt),
    fp20_ILLlib_getbasis ( fp20_lpinfo * lp, char *cstat, char *rstat),
    fp20_ILLlib_loadbasis ( fp20_ILLlp_basis * B, int nstruct, int nrows, char *cstat,
      char *rstat),
    fp20_ILLlib_readbasis ( fp20_lpinfo * lp, fp20_ILLlp_basis * B, const char *fp20_fname),
    fp20_ILLlib_writebasis ( fp20_lpinfo * lp, fp20_ILLlp_basis * B, const char *fp20_fname),
    fp20_ILLlib_getrownorms ( fp20_lpinfo * lp, fp20_price_info * pinf, EGfp20_t * rownorms),
    fp20_ILLlib_loadrownorms ( fp20_lpinfo * lp, fp20_price_info * pinf, EGfp20_t * rownorms),
    fp20_ILLlib_recompute_rownorms ( fp20_lpinfo * lp, fp20_price_info * pinf),
    fp20_ILLlib_iter ( fp20_lpinfo * lp),
    fp20_ILLlib_print_x ( EGioFile_t * fd, fp20_lpinfo * lp, fp20_ILLlp_cache * C, EGfp20_t * x,
      int nonZerosOnly),
    fp20_ILLwrite_lp_file ( fp20_ILLlpdata * lp, EGioFile_t * eout, fp20_qserror_collector * c);


extern int fp20_ILLlib_findName (
  fp20_ILLlpdata * qslp,
  int forRow,
  const char *name,
  int id,
  char buf[ILL_namebufsize]);

/****************************************************************************/
/*                                                                          */
/*                           fp20_presolve.c                                     */
/*                                                                          */
/****************************************************************************/

int fp20_ILLpresolve_add_logicals (
  fp20_ILLlpdata * lp);


/****************************************************************************/
/*                                                                          */
/*                            fp20_binary.c                                      */
/*                                                                          */
/****************************************************************************/

int fp20_ILLmip_binary_dfs (
  fp20_lpinfo * lp);

#endif /* fp20_ILL_LIB_H */
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  $RCSfile: ldbl_qstruct.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $" */
#ifndef ldbl___QS_QSTRUCT_H
#define ldbl___QS_QSTRUCT_H

typedef struct ldbl_qsdata
{
  struct ldbl_ILLlpdata *qslp;
  struct ldbl_lpinfo *lp;
  struct ldbl_price_info *pricing;
  struct ldbl_ILLlp_basis *basis;
  struct ldbl_ILLlp_cache *cache;
  char *name;
  int qstatus;                  /* QS_LP_UNSOLVED or an opt status  */
  int factorok;                 /* set to 0 if factorization is old */
  int simplex_display;          /* 0 off, 1 on */
  int simplex_scaling;          /* 0 off, 1 on */
  itcnt_t itcnt;
  long double uobjlim;
  long double lobjlim;
}
ldbl_QSdata;

#endif /* ldbl___QS_QSTRUCT_H */
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: ldbl_editor.h,v 1.2 2003/11/05 16:57:39 meven Exp $ */
#ifndef ldbl_EDITOR_H
#define ldbl_EDITOR_H

extern void ldbl_ILLeditor_init (
  void);
extern void ldbl_ILLeditor (
  ldbl_QSdata * p);
extern int ldbl_ILLeditor_solve (
  ldbl_QSdata * p,
  int salgo);

#endif
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: ldbl_dstruct.h,v 1.3 2003/11/05 16:57:39 meven Exp $ */
/****************************************************************************/
/*                                                                          */
/*                           ldbl_svector.h                                      */
/*                                                                          */
/****************************************************************************/

#ifndef ldbl___SVECTOR_H
#define ldbl___SVECTOR_H

typedef struct ldbl_svector
{
  int nzcnt;
  int *indx;
  int size;
  long double *coef;
}
ldbl_svector;

void ldbl_ILLsvector_init (
  ldbl_svector * s),
  ldbl_ILLsvector_free (
  ldbl_svector * s);

int ldbl_ILLsvector_alloc (
  ldbl_svector * s,
  int nzcnt),
  ldbl_ILLsvector_copy (
  const ldbl_svector * s_in,
  ldbl_svector * s_out);

#endif /* ldbl___SVECTOR_H */

/****************************************************************************/
/*                                                                          */
/*                           ldbl_heap.h                                         */
/*                                                                          */
/****************************************************************************/

#ifndef ldbl___HEAP_H
#define ldbl___HEAP_H

typedef struct
{
  int *entry;
  int *loc;
  long double *key;
  int hexist;
  int maxsize;
  int size;
}
ldbl_heap;

void ldbl_ILLheap_insert (
  ldbl_heap * const h,
  int const ix),
  ldbl_ILLheap_modify (
  ldbl_heap * const h,
  int const ix),
  ldbl_ILLheap_delete (
  ldbl_heap * const h,
  int const ix),
  ldbl_ILLheap_init (
  ldbl_heap * const h),
  ldbl_ILLheap_free (
  ldbl_heap * const h);

int ldbl_ILLheap_findmin (
  ldbl_heap * const h),
  ldbl_ILLheap_build (
  ldbl_heap * const h,
  int const nelems,
  long double * key);

#endif /* ldbl___HEAP_H */

/****************************************************************************/
/*                                                                          */
/*                         matrix.h                                         */
/*                                                                          */
/****************************************************************************/

#ifndef ldbl___MATRIX_H
#define ldbl___MATRIX_H

typedef struct ldbl_ILLmatrix
{
  long double *matval;            /* The coefficients.                       */
  int *matcnt;                  /* Number of coefs in each col.            */
  int *matind;                  /* The row indices of the coefs.           */
  int *matbeg;                  /* The start of each col.                  */
  int matcols;                  /* Number of columns.                      */
  int matrows;
  int matcolsize;               /* Length of matbeg and matcnt.            */
  int matsize;                  /* Length of matind and matval.            */
  int matfree;                  /* Free space at end of matind.            */
  /* Note: free elements marked by -1 in     */
  /* matind; we keep at least 1 free at end. */
}
ldbl_ILLmatrix;

void ldbl_ILLmatrix_init (
  ldbl_ILLmatrix * A);
void ldbl_ILLmatrix_free (
  ldbl_ILLmatrix * A);
void ldbl_ILLmatrix_prt (
  EGioFile_t * fd,
  ldbl_ILLmatrix * A);

#endif /* ldbl___MATRIX_H */
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: ldbl_factor.h,v 1.3 2003/11/05 16:57:39 meven Exp $ */
#ifndef ldbl___QS_FACTOR_H_
#define ldbl___QS_FACTOR_H_

typedef char ldbl_QSbool;

typedef struct ldbl_uc_info
{
  int cbeg;
  int nzcnt;
  int next;
  int prev;
  int delay;
}
ldbl_uc_info;

typedef struct ldbl_ur_info
{
  long double max;
  int rbeg;
  int nzcnt;
  int pivcnt;
  int next;
  int prev;
  int delay;
}
ldbl_ur_info;

typedef struct ldbl_lc_info
{
  int cbeg;
  int nzcnt;
  int c;
  int crank;
  int delay;
}
ldbl_lc_info;

typedef struct ldbl_lr_info
{
  int rbeg;
  int nzcnt;
  int r;
  int rrank;
  int delay;
}
ldbl_lr_info;

typedef struct ldbl_er_info
{
  int rbeg;
  int nzcnt;
  int r;
}
ldbl_er_info;

typedef struct ldbl_factor_work
{
  int max_k;
  long double fzero_tol;
  long double szero_tol;
  long double partial_tol;
  double ur_space_mul;
  double uc_space_mul;
  double lc_space_mul;
  double lr_space_mul;
  double er_space_mul;
  double grow_mul;
  int p;
  int etamax;
  double minmult;
  double maxmult;
  double updmaxmult;
  double dense_fract;
  int dense_min;

  long double maxelem_orig;
  int nzcnt_orig;
  long double maxelem_factor;
  int nzcnt_factor;
  long double maxelem_cur;
  int nzcnt_cur;

  long double partial_cur;

  int dim;
  int stage;
  int nstages;
  int etacnt;
  long double *work_coef;
  int *work_indx;
  ldbl_uc_info *uc_inf;
  ldbl_ur_info *ur_inf;
  ldbl_lc_info *lc_inf;
  ldbl_lr_info *lr_inf;
  ldbl_er_info *er_inf;
  int *ucindx;                  /* row index for column data */
  int *ucrind;                  /* index of column in row data */
  long double *uccoef;            /* coefficient for column data */
  int *urindx;                  /* col index for row data */
  int *urcind;                  /* index of row in column data */
  long double *urcoef;            /* coefficient for row data */
  int *lcindx;                  /* row index for L data */
  long double *lccoef;            /* coefficient for L row data */
  int *lrindx;                  /* col index for L data */
  long double *lrcoef;            /* coefficient for L col data */
  int *erindx;                  /* col index for eta data */
  long double *ercoef;            /* coefficient for eta data */
  int *rperm;
  int *rrank;
  int *cperm;
  int *crank;
  ldbl_svector xtmp;
  int ur_freebeg;
  int ur_space;
  int uc_freebeg;
  int uc_space;
  int lc_freebeg;
  int lc_space;
  int lr_freebeg;
  int lr_space;
  int er_freebeg;
  int er_space;

  int *p_nsing;
  int **p_singr;
  int **p_singc;

  long double *dmat;
  int drows;
  int dcols;
  int dense_base;
}
ldbl_factor_work;

void ldbl_ILLfactor_init_factor_work (
  ldbl_factor_work * f),
  ldbl_ILLfactor_free_factor_work (
  ldbl_factor_work * f),
  ldbl_ILLfactor_ftran (
  ldbl_factor_work * f,
  ldbl_svector * a,
  ldbl_svector * x),
  ldbl_ILLfactor_ftran_update (
  ldbl_factor_work * f,
  ldbl_svector * a,
  ldbl_svector * upd,
  ldbl_svector * x),
  ldbl_ILLfactor_btran (
  ldbl_factor_work * f,
  ldbl_svector * a,
  ldbl_svector * x);

int ldbl_ILLfactor_create_factor_work (
  ldbl_factor_work * f,
  int dim),
  ldbl_ILLfactor_set_factor_iparam (
  ldbl_factor_work * f,
  int param,
  int val),
  ldbl_ILLfactor_set_factor_dparam (
  ldbl_factor_work * f,
  int param,
  long double val),
  ldbl_ILLfactor (
  ldbl_factor_work * f,
  int *basis,
  int *cbeg,
  int *clen,
  int *cindx,
  long double * ccoef,
  int *p_nsing,
  int **p_singr,
  int **p_singc),
  ldbl_ILLfactor_update (
  ldbl_factor_work * f,
  ldbl_svector * a,
  int col,
  int *p_refact);

#endif /* ldbl___QS_FACTOR_H_ */
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: ldbl_lpdefs.h,v 1.3 2003/11/05 16:57:39 meven Exp $ */
#ifndef ldbl___QS_LPDEFS_H
#define ldbl___QS_LPDEFS_H


/* infinity and negative infinity */
#define ldbl_INFTY  ldbl_ILL_MAXDOUBLE
#define ldbl_NINFTY ldbl_ILL_MINDOUBLE

/* tolerances, these are initialized in ldbl_ILLstart, file ldbl_lpdata.c */
//#if EGLPNUM_TYPE != DBL_TYPE && EGLPNUM_TYPE != LDBL_TYPE
/* these three constants are defined in ldbl_lpdata.c */
extern long double ldbl_PARAM_IBASIS_RPIVOT;  /*       0.98 */
extern long double ldbl_PARAM_IBASIS_RTRIANG;/*       0.01 */
extern long double ldbl_PARAM_MIN_DNORM;      /*      1e-24 */
extern long double ldbl_PFEAS_TOLER;          /*       1e-6 */
extern long double ldbl_BD_TOLER;           /*       1e-7 */
extern long double ldbl_DFEAS_TOLER;          /*       1e-6 */
extern long double ldbl_PIVOT_TOLER;          /*      1e-10 */
extern long double ldbl_SZERO_TOLER;          /*      1e-15 */
extern long double ldbl_PIVZ_TOLER;         /*      1e-12 */
extern long double ldbl_OBJBND_TOLER;       /*       1e-2 */
extern long double ldbl_DBNDPIV_TOLER;        /*       1e-3 */
extern long double ldbl_DBNDPIV_RATIO;        /*       1e-2 */
extern long double ldbl_ALTPIV_TOLER;       /*       1e-8 */
//extern long double DJZERO_TOLER;/*             1e-8 */
extern long double ldbl_PROGRESS_ZERO;        /*       1e-7 */
extern long double ldbl_PROGRESS_THRESH;      /*       1e-5 */
extern long double ldbl_CB_EPS;             /*      0.001 */
extern long double ldbl_CB_INF_RATIO;       /*       10.0 */
extern long double ldbl_CB_PRI_RLIMIT;        /*       0.25 */

/* structure for statistics */
typedef struct
{
  int ynz_cnt;                  /* nz in entering columns */
  int num_y;
  long double y_ravg;             /* weighted avg. of current & prior y */
  int znz_cnt;                  /* nz in ith row of B^{-1}, ie z_i */
  int num_z;
  long double z_ravg;             /* weighted avg. of current & prior z */
  int zanz_cnt;                 /* nz in z^TA */
  int num_za;
  long double za_ravg;            /* weighted avg. of current & prior za */
  int pnorm_cnt;                /* nz in columns for primal norms */
  int dnorm_cnt;                /* nz in rows for dual norms */
  int pinz_cnt;                 /* nz in phase II pi (solve) */
  int num_pi;                   /* # of pi solves */
  int pi1nz_cnt;                /* nz in phase I pi (solve) */
  int num_pi1;                  /* # of phase I pi solves */
  int upnz_cnt;                 /* nz in ftran update vector */
  int num_up;                   /* # of ftran_updates */
  int pupv_cnt;                 /* nz in primal steep updates */
  int dupv_cnt;                 /* nz in dual steep updates */

  int start_slacks;             /* # slacks in beginning */
  int final_slacks;             /* # slacks in the end */
  int start_art;                /* # arts in beginning */
  int final_art;                /* # arts in the end */

  int pI_iter;                  /* primal phase I iterations */
  int pII_iter;
  int dI_iter;                  /* dual phase I iterations */
  int dII_iter;
  int tot_iter;

  int pivpI[10];                /* sizes of pivots */
  int pivpII[10];
  int pivdI[10];
  int pivdII[10];
}
ldbl_count_struct;

/* structure for tolerances */
typedef struct
{
  long double pfeas_tol;
  long double dfeas_tol;
  long double pivot_tol;
  long double szero_tol;
  long double ip_tol;             /* inner primal & dual feas toler */
  long double id_tol;
}
ldbl_tol_struct;

/* bound information */
typedef struct ldbl_bndinfo
{
  long double pbound;
  long double cbound;
  int btype;
  int varnum;
  struct ldbl_bndinfo *next;
}
ldbl_bndinfo;

/* bound information */
typedef struct ldbl_coefinfo
{
  long double pcoef;
  long double ccoef;
  int varnum;
  struct ldbl_coefinfo *next;
}
ldbl_coefinfo;

/* feasibility info */
typedef struct ldbl_feas_info
{
  int pstatus;
  int dstatus;
  long double totinfeas;
}
ldbl_feas_info;

typedef struct ldbl_lp_status_info
{
  char optimal;
  char primal_feasible;
  char primal_infeasible;
  char primal_unbounded;
  char dual_feasible;
  char dual_infeasible;
  char dual_unbounded;
  char padd;
}
ldbl_lp_status_info;

typedef struct ldbl_pI_uinfo
{
  int tctr;
  int i;
  int *perm;
  int *ix;
  int fs;
  long double piv;
  long double *t;
  long double dty;
  long double c_obj;
  long double tz;
}
ldbl_pI_uinfo;

extern void ldbl_ILLlp_status_info_init (
  ldbl_lp_status_info * ls);

/* structure for local lp information
 * contains lp obj values - status - dimensions - input data -
 * solution vecs - basis info - update vecs - work vecs - bound changes -
 * tolerances - time info - statistics 
 */
typedef struct ldbl_lpinfo
{

  long double objval;             /* obj info */
  long double pobjval;            /* intermediate status info */
  long double dobjval;
  long double pinfeas;
  long double dinfeas;
  long double objbound;
  ldbl_lp_status_info probstat;     /* final status */
  ldbl_lp_status_info basisstat;      /* final status */
  int nrows;                    /* input info follows; given in col format */
  int ncols;
  int *matcnt;
  int *matbeg;
  int *matind;
  long double *matval;
  int matfree;
  int matsize;
  long double *bz;
  long double *lz;
  long double *uz;
  long double *cz;
  int localrows;                /* set to 1 if these are created locally */
  int *rowcnt;                  /* row info follows, copy of col info */
  int *rowbeg;
  int *rowind;
  long double *rowval;

  long double *xbz;               /* output info x, pi, reduced cost */
  long double *piz;
  long double *dz;
  long double *pIxbz;             /* output info (phase I) x, pi, reduced cost */
  long double *pIpiz;
  long double *pIdz;

  int final_phase;              /* final phase, inf & unboundedness info */
  int infub_ix;

  int basisid;                  /* basis and variable info follows */
  int nnbasic;
  int *baz;
  int *nbaz;
  int *vstat;
  int *vindex;
  int fbasisid;
  ldbl_factor_work *f;
  int *vtype;                   /* internal var info */
  char *vclass;                 /* structural or logical */

  ldbl_svector zz;                    /* local ldbl_ILLfactor_update vectors z, yj, za */
  ldbl_svector yjz;
  ldbl_svector zA;
  ldbl_svector work;                  /* local work vector */
  ldbl_svector srhs;                  /* local vectors for lin. eq. solves */
  ldbl_svector ssoln;
  int *iwork;                   /* local work vector */
  ldbl_pI_uinfo upd;                  /* phase I update info */
  int *bfeas;                   /* primal and dual infeasibility info */
  int *dfeas;

  ldbl_tol_struct *tol;             /* tolerances */
  ldbl_count_struct *cnts;            /* counts */
  int nbchange;                 /* # bound shifts */
  int ncchange;                 /* # obj coef shifts */
  ldbl_bndinfo *bchanges;           /* list of bound shifts */
  ldbl_coefinfo *cchanges;            /* list of coef shifts */
  int pIratio;                  /* ratio tests */
  int pIIratio;
  int dIratio;
  int dIIratio;

  int maxiter;
  int iterskip;
  double maxtime;
  double starttime;
  struct ldbl_ILLlpdata *O;
  ILLrandstate rstate;

}
ldbl_lpinfo;

/* pricing structures */
typedef struct
{
  int ninit;
  long double *norms;
  int *refframe;
}
ldbl_p_devex_info;

typedef struct
{
  long double *norms;
}
ldbl_p_steep_info;

typedef struct
{
  int k;
  int cgroup;
  int ngroups;
  int *gstart;
  int *gshift;
  int *gsize;
  int bsize;
  int *bucket;
  int *perm;
  long double *infeas;
}
ldbl_mpart_info;

typedef struct
{
  int ninit;
  long double *norms;
  int *refframe;
}
ldbl_d_devex_info;

typedef struct
{
  long double *norms;
}
ldbl_d_steep_info;

/* pricing information */
typedef struct ldbl_price_info
{
  int p_strategy;
  int d_strategy;
  int pI_price;
  int pII_price;
  int dI_price;
  int dII_price;
  int cur_price;
  long double *p_scaleinf;
  long double *d_scaleinf;
  ldbl_p_devex_info pdinfo;
  ldbl_p_steep_info psinfo;
  ldbl_mpart_info pmpinfo;
  ldbl_d_devex_info ddinfo;
  ldbl_d_steep_info dsinfo;
  ldbl_mpart_info dmpinfo;
  ldbl_heap h;
  long double htrigger;
  int hineff;
  char init;
}
ldbl_price_info;

#endif /* ldbl___QS_LPDEFS_H */
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: rdline.h,v 1.2 2003/11/05 16:57:39 meven Exp $ */
#ifndef ldbl_LINE_READER_FILE_H
#define ldbl_LINE_READER_FILE_H


/* #ifdef _WINDOWS */
typedef char *(
  *ldbl_qsread_line_fct) (
  char *s,
  int size,
  void *src);

typedef struct ldbl_qsline_reader
{
  ldbl_qsread_line_fct read_line_fct;
  void *data_src;
  struct ldbl_qserror_collector *error_collector;
}
ldbl_qsline_reader;

ldbl_qsline_reader *ldbl_ILLline_reader_new (
  ldbl_qsread_line_fct fct,
  void *data_src);
void ldbl_ILLline_reader_free (
  ldbl_qsline_reader * reader);

#define ldbl_ILLline_reader_get(s, size, reader)  \
  (reader)->read_line_fct(s, size, (reader)->data_src)
                   /* used by parsers to retrieve next input line */
/* #else  
 *
 * typedef FILE ldbl_qsline_reader; 
 *
 * #define ldbl_ILLline_reader_new(fct, data) ((FILE*) (data)) 
 * #define ldbl_ILLline_reader_free(reader)  
 * #define ldbl_ILLline_reader_get(s, size, reader) fgets(s,size,reader) 
 * #endif 
 */

#endif
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: ldbl_lpdata.h,v 1.4 2003/11/05 17:00:56 meven Exp $ */
#ifndef ldbl_ILL_LPDATA_H
#define ldbl_ILL_LPDATA_H


extern long double ldbl_ILL_MAXDOUBLE;  /*  1e150 */
extern long double ldbl_ILL_MINDOUBLE;  /* -1e150 */

#define ldbl_ILL_MAXINT    (2147483647) /* this is equal to 2^31-1 */
#define ldbl_ILL_MIN       (1)        /* Must be same as QS_MIN */
#define ldbl_ILL_MAX       (-1)     /* Must be same as QS_MAX */

/*  Setting Alg in Presolve  */

#define ldbl_ILL_PRE_SCALE           1
#define ldbl_ILL_PRE_FIXED           2
#define ldbl_ILL_PRE_SINGLE_ROW      4
#define ldbl_ILL_PRE_FORCING         8
#define ldbl_ILL_PRE_SINGLE_COL     16
#define ldbl_ILL_PRE_DUPLICATE_ROW  32
#define ldbl_ILL_PRE_DUPLICATE_COL  64
#define ldbl_ILL_PRE_EMPTY_COL     128
#define ldbl_ILL_PRE_ALL (ldbl_ILL_PRE_SCALE | ldbl_ILL_PRE_FIXED | ldbl_ILL_PRE_SINGLE_ROW           \
                    ldbl_ILL_PRE_FORCING | ldbl_ILL_PRE_SINGLE_COL | ldbl_ILL_PRE_DUPLICATE_ROW \
                   ldbl_ILL_PRE_DUPLICATE_COL | ldbl_ILL_PRE_EMPTY_COL)
#define ldbl_ILL_PRE_SIMPLE (ldbl_ILL_PRE_FIXED | ldbl_ILL_PRE_EMPTY_COL)

typedef struct ldbl_ILLlpdata
{                               /* Complete LP data filled in by mpsread.  */
  int nrows;
  int ncols;
  int nstruct;                  /* Not including logicals.                 */
  int nzcount;
  int rowsize;                  /* Length of row arrays.                   */
  int colsize;                  /* Length of col arrays.                   */
  int structsize;               /* Length of intmarker, structmap,         */
  /* colnames                                */
  int objsense;
  char *sense;                  /* Original sense, not after logicals.     */
  long double *obj;
  long double *rhs;
  long double *rangeval;
  long double *lower;
  long double *upper;
  ldbl_ILLmatrix A;                 /* The coef matrix.                        */
  struct ldbl_ILLlp_rows *rA;       /* Coef matrix in row form.                */

  char **rownames;
  ILLsymboltab rowtab;          /* contains rownames in no particular order */
  char *objname;                /* if colname is not NULL it is entered into 
                                 * the rowtab, see reader fcts in ldbl_lp.c, ldbl_mps.c*/

  char **colnames;              /* columns of struct variables */
  ILLsymboltab coltab;          /* contains colnames in no particular order */

  char *probname;
  char *intmarker;
  int *structmap;               /* Indices of structural variables         */
  int *rowmap;                  /* Indices of logical and range variables  */
  struct ldbl_ILLlp_basis *basis;
  struct ldbl_ILLlp_predata *presolve;
  struct ldbl_ILLlp_sinfo *sinfo;

   /**************************************************************************/
  /* these fields are currently only set by ldbl_mps.c reader fcts               */
   /**************************************************************************/
  ldbl_ILLmatrix sos;               /* columns are the sets, rows are the  
                                 * problem's structural variables
                                 * coefficients are the weights */

  char *sos_type;               /* type of each set */
  int *is_sos_mem;              /* for each structural variable contains 
                                 *    -1 == not a set member
                                 *     i == member of sos set i 
                                 *          where 0 <= i < sos.matcols */
  char *refrowname;             /* name of reference row */
  int refind;                   /* index of reference row 
                                 *     -1 if refrow was a free row 
                                 *          and weights are found only in the 
                                 *          sos matrix 
                                 *     index >=0 if refrow is also a lp-row */

   /**************************************************************************
    * ldbl_QSset_reporter initializes reporter 
    **************************************************************************/
  qsstring_reporter reporter;   /* used from within ILL fcts 
                                 * to report ldbl_feedback */
}
ldbl_ILLlpdata;

typedef struct ldbl_ILLlp_basis
{
  int nstruct;
  int nrows;
  int rownorms_size;
  int colnorms_size;
  char *cstat;
  char *rstat;
  long double *rownorms;
  long double *colnorms;
}
ldbl_ILLlp_basis;

typedef struct ldbl_ILLlp_cache
{
  int nstruct;
  int nrows;
  int status;
  long double val;
  long double *x;
  long double *pi;
  long double *rc;
  long double *slack;
}
ldbl_ILLlp_cache;

typedef struct ldbl_ILLlp_sinfo
{                               /* LP info returned by presolve            */
  int ncols;
  int nrows;
  int nzcount;
  int rowsize;
  int colsize;
  int objsense;

  long double *obj;
  long double *rhs;
  long double *lower;
  long double *upper;

  ldbl_ILLmatrix A;

  char **colnames;              /* Just for debugging - not updated */
}
ldbl_ILLlp_sinfo;

typedef struct ldbl_ILLlp_preline
{
  long double rhs;
  long double obj;
  long double lower;
  long double upper;
  int count;
  int *ind;
  int row_or_col;               /* 0 is row, 1 is col */
  long double *val;
}
ldbl_ILLlp_preline;

typedef struct ldbl_ILLlp_preop
{
  int ptype;
  int rowindex;
  int colindex;
  ldbl_ILLlp_preline line;
}
ldbl_ILLlp_preop;

typedef struct ldbl_ILLlp_predata
{                               /* Data needed in un-presolve.            */
  int opcount;
  int opsize;
  ldbl_ILLlp_preop *oplist;
  int r_nrows;
  int r_ncols;
  int *colmap;
  int *rowmap;
  long double *rowscale;
  long double *colscale;
  long double *colfixval;
  long double *rowfixval;
}
ldbl_ILLlp_predata;

typedef struct ldbl_ILLlp_rows
{
  int *rowbeg;
  int *rowcnt;
  int *rowind;
  long double *rowval;
}
ldbl_ILLlp_rows;


/****************************************************************************/
/*                                                                          */
/*                             ldbl_lpdata.c                                     */
/*                                                                          */
/****************************************************************************/

struct ldbl_qsdata *ldbl_ILLread (
  ldbl_qsline_reader * file,
  const char *ldbl_fname,
  int isMps);
void ldbl_ILLstart (
  void);              /**< initialize ldbl_ILL_MAXDOUBLE and other 

                           constants, this funtion should be callef AFTER 
                           EGlpNumStart() */
void ldbl_ILLend (
  void);            /**< free any internal data asociated with variable 

                         ldbl_precision numbers */
void ldbl_ILLchange_precision (
  void);                        /**< This function re-compute the internal 

                                     variables ldbl_precision to the (previously 
                                     set) EGLPNUM_PRECISION value (done with 
                                     EGlpNumSetPrecision) */
void ldbl_ILLlpdata_init (
  ldbl_ILLlpdata * lp);
void ldbl_ILLlpdata_free (
  ldbl_ILLlpdata * lp);
void ldbl_ILLlp_basis_init (
  ldbl_ILLlp_basis * B);
void ldbl_ILLlp_basis_free (
  ldbl_ILLlp_basis * B);
void ldbl_ILLlp_cache_init (
  ldbl_ILLlp_cache * C);
void ldbl_ILLlp_cache_free (
  ldbl_ILLlp_cache * C);
int ldbl_ILLlp_basis_alloc (
  ldbl_ILLlp_basis * B,
  int ncols,
  int nrows);
int ldbl_ILLlp_cache_alloc (
  ldbl_ILLlp_cache * C,
  int ncols,
  int nrows);

int ldbl_ILLlp_rows_init (
  ldbl_ILLlp_rows * lp_rows,
  ldbl_ILLlpdata * lp,
  int include_logicals);
void ldbl_ILLlp_rows_clear (
  ldbl_ILLlp_rows * lp_rows);
int ldbl_ILLprint_report (
  ldbl_ILLlpdata * lp,
  const char *format,
  ...);

              /* print to lp->reporter */

/****************************************************************************/
/*                                                                          */
/*                             ldbl_presolve.c                                   */
/*                                                                          */
/****************************************************************************/

void ldbl_ILLlp_sinfo_init (
  ldbl_ILLlp_sinfo * sinfo),
  ldbl_ILLlp_sinfo_free (
  ldbl_ILLlp_sinfo * sinfo),
  ldbl_ILLlp_predata_init (
  ldbl_ILLlp_predata * pre),
  ldbl_ILLlp_predata_free (
  ldbl_ILLlp_predata * pre);

int ldbl_ILLlp_add_logicals (
  ldbl_ILLlpdata * lp),
  ldbl_ILLlp_scale (
  ldbl_ILLlpdata * lp),
  ldbl_ILLlp_presolve (
  ldbl_ILLlpdata * lp,
  int pre_types);

/* ========================================================================= */
/* if non-zero, then internal data has been initialized, and there is some
 * memory allocated, if zero, no internal memory has been allocated
 * (or it has been freed) */
extern int ldbl___QSEX_SETUP;

#endif /* __ILL_LPDATA_H */
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: ldbl_basis.h,v 1.3 2003/11/05 16:57:39 meven Exp $ */
#ifndef ldbl___BASIS_H
#define ldbl___BASIS_H


#if 0
#if EGLPNUM_TYPE != DBL_TYPE && EGLPNUM_TYPE != LDBL_TYPE
extern long double ldbl_CB_PRI_RLIMIT;  /* = 0.25 */
extern long double ldbl_CB_INF_RATIO; /* = 10.0 */
extern long double ldbl_CB_EPS;       /* = 0.001 */
#endif
#endif

typedef struct ldbl_var_data
{
  int nartif;
  int nslacks;
  int nfree;
  int nbndone;
  int nbounded;
  int nfixed;
  long double cmax;
}
ldbl_var_data;

void ldbl_ILLbasis_init_vardata (
  ldbl_var_data * vd);
void ldbl_ILLbasis_clear_vardata (
  ldbl_var_data * vd);

int ldbl_ILLbasis_build_basisinfo (
  ldbl_lpinfo * lp),
  ldbl_ILLbasis_get_initial (
  ldbl_lpinfo * lp,
  int algorithm),
  ldbl_ILLbasis_get_cinitial (
  ldbl_lpinfo * lp,
  int algorithm),
  ldbl_ILLbasis_load (
  ldbl_lpinfo * lp,
  ldbl_ILLlp_basis * B),
  ldbl_ILLbasis_tableau_row (
  ldbl_lpinfo * lp,
  int row,
  long double * brow,
  long double * trow,
  long double * rhs,
  int strict),
  ldbl_ILLbasis_factor (
  ldbl_lpinfo * lp,
  int *singular),
  ldbl_ILLbasis_refactor (
  ldbl_lpinfo * lp),
  ldbl_ILLbasis_update (
  ldbl_lpinfo * lp,
  ldbl_svector * y,
  int lindex,
  int *refactor,
  int *singular);

void ldbl_ILLbasis_column_solve (
  ldbl_lpinfo * lp,
  ldbl_svector * rhs,
  ldbl_svector * soln),
  ldbl_ILLbasis_column_solve_update (
  ldbl_lpinfo * lp,
  ldbl_svector * rhs,
  ldbl_svector * upd,
  ldbl_svector * soln),
  ldbl_ILLbasis_row_solve (
  ldbl_lpinfo * lp,
  ldbl_svector * rhs,
  ldbl_svector * soln),
  ldbl_ILLbasis_free_basisinfo (
  ldbl_lpinfo * lp),
  ldbl_ILLbasis_free_fbasisinfo (
  ldbl_lpinfo * lp),
  ldbl_ILLbasis_init_basisinfo (
  ldbl_lpinfo * lp);

#endif /* ldbl___BASIS_H */
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

#ifndef ldbl___DHEAPS_I_H__
#define ldbl___DHEAPS_I_H__
/****************************************************************************/
/*                                                                          */
/*                             ldbl_dheaps_i.c                                   */
/*                                                                          */
/****************************************************************************/

typedef struct ldbl_ILLdheap
{
  long double *key;
  int *entry;
  int *loc;
  int total_space;
  int size;
}
ldbl_ILLdheap;

void ldbl_ILLutil_dheap_free (
  ldbl_ILLdheap * h),
  ldbl_ILLutil_dheap_delete (
  ldbl_ILLdheap * h,
  int i),
  ldbl_ILLutil_dheap_changekey (
  ldbl_ILLdheap * h,
  int i,
  long double * newkey),
  ldbl_ILLutil_dheap_findmin (
  ldbl_ILLdheap * h,
  int *i),
  ldbl_ILLutil_dheap_deletemin (
  ldbl_ILLdheap * h,
  int *i);

int ldbl_ILLutil_dheap_init (
  ldbl_ILLdheap * h,
  int k),
  ldbl_ILLutil_dheap_resize (
  ldbl_ILLdheap * h,
  int newsize),
  ldbl_ILLutil_dheap_insert (
  ldbl_ILLdheap * h,
  int i);



#endif
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  $RCSfile: ldbl_qsopt.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $" */
#ifndef ldbl___QS_QSOPT_H
#define ldbl___QS_QSOPT_H


#ifdef WIN32

#ifdef QSLIB_EXPORTS
#define ldbl_QSLIB_INTERFACE __declspec(dllexport)
#else
#define ldbl_QSLIB_INTERFACE __declspec(dllimport)
#endif

#else
#define ldbl_QSLIB_INTERFACE extern
#endif

#ifdef WIN32
typedef struct ldbl_QSLIB_INTERFACE ldbl_qsdata *ldbl_QSprob;
typedef struct ldbl_QSLIB_INTERFACE qsbasis *ldbl_QSbas;
#else
typedef struct ldbl_qsdata *ldbl_QSprob;
typedef struct qsbasis *ldbl_QSbas;
#endif

/****************************************************************************/
/*                                                                          */
/*                 PARAMETERS TO SPECIFY OBJECTIVE SENSE                    */
/*                                                                          */
/****************************************************************************/
/*
#define QS_LP_PRIMAL_FEASIBLE   11
#define QS_LP_PRIMAL_INFEASIBLE 12
#define QS_LP_PRIMAL_UNBOUNDED  13
#define QS_LP_DUAL_FEASIBLE     14
#define QS_LP_DUAL_INFEASIBLE   15
#define QS_LP_DUAL_UNBOUNDED    16
*/

/****************************************************************************/
/*                                                                          */
/*                      QSopt Library Functions                             */
/*                                                                          */
/****************************************************************************/
#ifdef  __cplusplus
extern "C"
{
#endif

#ifdef WIN32
/* 
 *  in WINDOWS we make 
 *     ldbl_solver_main/ldbl_reader_main part of DLL
 */
ldbl_QSLIB_INTERFACE int ldbl_solver_main ( int argc, char **argv);
ldbl_QSLIB_INTERFACE int ldbl_reader_main ( int argc, char **argv);
#endif

ldbl_QSLIB_INTERFACE void ldbl_QSfree ( void *ptr),
    ldbl_QSfree_prob ( ldbl_QSprob p),
    ldbl_QSfree_basis ( ldbl_QSbas B),
    ldbl_QSset_precision ( const unsigned prec),/**< set the ldbl_precision for floating 
                                                 point numbers to the given 
                                                 number of bits */
    ldbl_QSstart ( void),/**< whe we use non native numbers, we need to make 
                         some initializations before operating with the
                         library */
    ldbl_QSend ( void); /**< just to free any internal static data needed by
                         the variable ldbl_precision numbers */

ldbl_QSLIB_INTERFACE int ldbl_QSopt_primal ( ldbl_QSprob p, int *status),
    ldbl_QSopt_dual ( ldbl_QSprob p, int *status),
    ldbl_QSopt_pivotin_col ( ldbl_QSprob p, int ccnt, int *clist),
    ldbl_QSopt_pivotin_row ( ldbl_QSprob p, int rcnt, int *rlist),
    ldbl_QSopt_strongbranch ( ldbl_QSprob p, int ncand, int *candidatelist,
      long double * xlist, long double * down_vals, long double * up_vals,
      int iterations, long double objbound),
    ldbl_QSchange_objsense ( ldbl_QSprob p, int newsense),
    ldbl_QSget_objsense ( ldbl_QSprob p, int *newsense),
    ldbl_QSnew_col ( ldbl_QSprob p,const long double obj,const long double lower,const long double upper,
      const char *name),
    ldbl_QSadd_cols ( ldbl_QSprob p, int num, int *cmatcnt, int *cmatbeg, int *cmatind,
      long double * cmatval, long double * obj, long double * lower,
      long double * upper, const char **names),
    ldbl_QSadd_col ( ldbl_QSprob p, int cnt, int *cmatind, long double * cmatval,
      long double obj, long double lower, long double upper, const char *name),
    ldbl_QSnew_row ( ldbl_QSprob p,const long double rhs, int sense, const char *name),
    ldbl_QSadd_ranged_rows ( ldbl_QSprob p, int num, int *rmatcnt, int *rmatbeg, 
      int *rmatind,const long double * rmatval,const long double * rhs, char *sense,
      const long double* range, const char **names),
    ldbl_QSadd_ranged_row ( ldbl_QSprob p, int cnt, int *rmatind,const long double * rmatval,
      const long double * rhs, int sense,const long double * range, const char *name),
    ldbl_QSadd_rows ( ldbl_QSprob p, int num, int *rmatcnt, int *rmatbeg, int *rmatind,
      const long double * rmatval,const long double * rhs, char *sense, const char **names),
    ldbl_QSadd_row ( ldbl_QSprob p, int cnt, int *rmatind,const long double * rmatval,
      const long double * rhs, int sense, const char *name),
    ldbl_QSdelete_rows ( ldbl_QSprob p, int num, int *dellist),
    ldbl_QSdelete_row ( ldbl_QSprob p, int rowindex),
    ldbl_QSdelete_setrows ( ldbl_QSprob p, int *flags),
    ldbl_QSdelete_named_row ( ldbl_QSprob p, const char *rowname),
    ldbl_QSdelete_named_rows_list ( ldbl_QSprob p, int num, const char **rownames),
    ldbl_QSdelete_cols ( ldbl_QSprob p, int num, int *dellist),
    ldbl_QSdelete_col ( ldbl_QSprob p, int colindex),
    ldbl_QSdelete_setcols ( ldbl_QSprob p, int *flags),
    ldbl_QSdelete_named_column ( ldbl_QSprob p, const char *colname),
    ldbl_QSdelete_named_columns_list ( ldbl_QSprob p, int num, const char **colnames),
    ldbl_QSchange_senses ( ldbl_QSprob p, int num, int *rowlist, char *sense),
    ldbl_QSchange_sense ( ldbl_QSprob p, int rowindex, int sense),
    ldbl_QSchange_coef ( ldbl_QSprob p, int rowindex, int colindex, long double coef),
    ldbl_QSchange_objcoef ( ldbl_QSprob p, int indx, long double coef),
    ldbl_QSchange_rhscoef ( ldbl_QSprob p, int indx, long double coef),
    ldbl_QSchange_range(ldbl_QSprob p, int rowindex, long double range),
    ldbl_QSchange_bounds ( ldbl_QSprob p, int num, int *collist, char *lu, 
      const long double * bounds),
    ldbl_QSchange_bound ( ldbl_QSprob p, int indx, int lu,const long double bound),
    ldbl_QSload_basis ( ldbl_QSprob p, ldbl_QSbas B),
    ldbl_QSread_and_load_basis ( ldbl_QSprob p, const char *filename),
    ldbl_QSload_basis_array ( ldbl_QSprob p, char *cstat, char *rstat),
    ldbl_QSload_basis_and_row_norms_array ( ldbl_QSprob p, char *cstat, char *rstat, 
      long double * rownorms),
    ldbl_QSget_basis_array ( ldbl_QSprob p, char *cstat, char *rstat),
    ldbl_QSget_basis_and_row_norms_array ( ldbl_QSprob p, char *cstat, char *rstat,
      long double * rownorms),
    ldbl_QSget_binv_row ( ldbl_QSprob p, int indx, long double * binvrow),
    ldbl_QSget_tableau_row ( ldbl_QSprob p, int indx, long double * tableaurow),
    ldbl_QSget_basis_order ( ldbl_QSprob p, int *basorder), 
    ldbl_QSget_coef (ldbl_QSprob p, int rowindex, int colindex, long double*coef),
    ldbl_QSget_status ( ldbl_QSprob p, int *status),
    ldbl_QSget_solution ( ldbl_QSprob p, long double * value, long double * x,
      long double * pi, long double * slack, long double * rc),
    ldbl_QSget_objval ( ldbl_QSprob p, long double * value),
    ldbl_QSget_pi_array ( ldbl_QSprob p, long double * pi),
    ldbl_QSget_rc_array ( ldbl_QSprob p, long double * rc),
    ldbl_QSget_x_array ( ldbl_QSprob p, long double * x),
    ldbl_QSget_slack_array ( ldbl_QSprob p, long double * slack),
    ldbl_QSget_infeas_array ( ldbl_QSprob p, long double * pi),
    ldbl_QSget_colcount ( ldbl_QSprob p),
    ldbl_QSget_rowcount ( ldbl_QSprob p),
    ldbl_QSget_nzcount ( ldbl_QSprob p),
    ldbl_QSget_obj_list(ldbl_QSprob p, int num, int*collist, long double*obj),
    ldbl_QSget_obj ( ldbl_QSprob p, long double * obj),
    ldbl_QSget_rhs ( ldbl_QSprob p, long double * rhs),
    ldbl_QSget_ranged_rows_list ( ldbl_QSprob p, int num, int *rowlist, int **rowcnt,
      int **rowbeg, int **rowind, long double ** rowval, long double ** rhs,
      char **sense, long double **range, char ***names),
    ldbl_QSget_ranged_rows ( ldbl_QSprob p, int **rowcnt, int **rowbeg, int **rowind,
      long double ** rowval, long double ** rhs, char **sense, 
      long double ** range, char ***names),
    ldbl_QSget_senses ( ldbl_QSprob p, char*senses),
    ldbl_QSget_rows_list ( ldbl_QSprob p, int num, int *rowlist, int **rowcnt,
      int **rowbeg, int **rowind, long double ** rowval, long double ** rhs,
      char **sense, char ***names),
    ldbl_QSget_rows ( ldbl_QSprob p, int **rowcnt, int **rowbeg, int **rowind,
      long double ** rowval, long double ** rhs, char **sense, char ***names),
    ldbl_QSget_columns_list ( ldbl_QSprob p, int num, int *collist, int **colcnt,
      int **colbeg, int **colind, long double ** colval, long double ** obj,
      long double ** lower, long double ** upper, char ***names),
    ldbl_QSget_columns ( ldbl_QSprob p, int **colcnt, int **colbeg, int **colind,
      long double ** colval, long double ** obj, long double ** lower,
      long double ** upper, char ***names),
    ldbl_QSget_rownames ( ldbl_QSprob p, char **rownames),
    ldbl_QSget_colnames ( ldbl_QSprob p, char **colnames),
    ldbl_QSget_bound ( ldbl_QSprob p, int colindex, int lu, long double * bound),
    ldbl_QSget_bounds ( ldbl_QSprob p, long double * lower, long double * upper),
    ldbl_QSget_bounds_list(ldbl_QSprob p, int num, int*collist, long double*lb,
      long double*ub),
    ldbl_QSget_intflags ( ldbl_QSprob p, int *intflags),
    ldbl_QSget_intcount ( ldbl_QSprob p, int *count),
    ldbl_QSget_column_index ( ldbl_QSprob p, const char *name, int *colindex),
    ldbl_QSget_row_index ( ldbl_QSprob p, const char *name, int *rowindex),
    ldbl_QSget_named_x ( ldbl_QSprob p, const char *colname, long double * val),
    ldbl_QSget_named_rc ( ldbl_QSprob p, const char *colname, long double * val),
    ldbl_QSget_named_pi ( ldbl_QSprob p, const char *rowname, long double * val),
    ldbl_QSget_named_slack ( ldbl_QSprob p, const char *rowname, long double * val),
    ldbl_QScompute_row_norms ( ldbl_QSprob p),
    ldbl_QSwrite_prob ( ldbl_QSprob p, const char *filename, const char *filetype),
    ldbl_QSwrite_prob_file ( ldbl_QSprob p, FILE * file, const char *filetype),
    ldbl_QSwrite_basis ( ldbl_QSprob p, ldbl_QSbas B, const char *filename),
    ldbl_QStest_row_norms ( ldbl_QSprob p),
    ldbl_QSget_itcnt(ldbl_QSprob p, int *pI_iter, int *pII_iter, int *dI_iter,
      int *dII_iter, int *tot_iter),
    ldbl_QSset_param ( ldbl_QSprob p, int whichparam, int newvalue),
    ldbl_QSset_param_EGlpNum ( ldbl_QSprob p, int whichparam, long double newvalue),
    ldbl_QSget_param ( ldbl_QSprob p, int whichparam, int *value),
    ldbl_QSget_param_EGlpNum ( ldbl_QSprob p, int whichparam, long double * value); 

ldbl_QSLIB_INTERFACE char *ldbl_QSget_probname ( ldbl_QSprob p);
ldbl_QSLIB_INTERFACE char *ldbl_QSget_objname ( ldbl_QSprob p);
ldbl_QSLIB_INTERFACE char *ldbl_QSversion ( void);

ldbl_QSLIB_INTERFACE ldbl_QSprob ldbl_QScreate_prob ( const char *name, int objsense),
    ldbl_QSread_prob ( const char *filename, const char *filetype),
    ldbl_QSload_prob ( const char *probname, int ncols, int nrows, int *cmatcnt,
      int *cmatbeg, int *cmatind, long double * cmatval, int objsense,
      long double * obj, long double * rhs, char *sense, long double * lower,
      long double * upper, const char **colnames, const char **rownames),
    ldbl_QScopy_prob ( ldbl_QSprob p, const char *newname);

ldbl_QSLIB_INTERFACE ldbl_QSbas ldbl_QSget_basis ( ldbl_QSprob p),
    ldbl_QSread_basis ( ldbl_QSprob p, const char *filename);

#ifdef  __cplusplus
}
#endif

/****************************************************************************
 *
 * This is the undocumented part of the QSlib interface 
 *
 ****************************************************************************/
/* 
 * functions to facilitate line by line reading from other sources than 
 * files from within MPS/LP parsers  
 * 
 * functions to facilitate the collection of error information instead of 
 * having the parsers print messages to stderr
 *                              by mps/lp format writers
 * 
 * a problem's reporter is used by the solver code to provide important 
 * ldbl_feedback/progress information
 */

#ifdef WIN32
typedef struct ldbl_QSLIB_INTERFACE ldbl_qsline_reader *ldbl_QSline_reader;
typedef struct ldbl_QSLIB_INTERFACE ldbl_qsformat_error *ldbl_QSformat_error;
typedef struct ldbl_QSLIB_INTERFACE ldbl_qserror_collector *ldbl_QSerror_collector;
typedef struct ldbl_QSLIB_INTERFACE ldbl_qserror_memory *ldbl_QSerror_memory;
#else
typedef struct ldbl_qsline_reader *ldbl_QSline_reader;
typedef struct ldbl_qsformat_error *ldbl_QSformat_error;
typedef struct ldbl_qserror_collector *ldbl_QSerror_collector;
typedef struct ldbl_qserror_memory *ldbl_QSerror_memory;
#endif

#ifdef  __cplusplus
extern "C"
{
#endif
  ldbl_QSLIB_INTERFACE const char *ldbl_QSformat_error_type_string (
  int tp);

  ldbl_QSLIB_INTERFACE int ldbl_QSerror_get_type (
  ldbl_QSformat_error error);
  ldbl_QSLIB_INTERFACE const char *ldbl_QSerror_get_desc (
  ldbl_QSformat_error error);
  ldbl_QSLIB_INTERFACE int ldbl_QSerror_get_line_number (
  ldbl_QSformat_error error);
  ldbl_QSLIB_INTERFACE int ldbl_QSerror_get_pos (
  ldbl_QSformat_error error);
  ldbl_QSLIB_INTERFACE const char *ldbl_QSerror_get_line (
  ldbl_QSformat_error error);
  ldbl_QSLIB_INTERFACE void ldbl_QSerror_print (
  FILE * f,
  ldbl_QSformat_error error);

  ldbl_QSLIB_INTERFACE ldbl_QSerror_collector ldbl_QSerror_collector_new (
  void *fct,
  void *dest);
  ldbl_QSLIB_INTERFACE ldbl_QSerror_collector ldbl_QSerror_memory_collector_new (
  ldbl_QSerror_memory mem);
  ldbl_QSLIB_INTERFACE void ldbl_QSerror_collector_free (
  ldbl_QSerror_collector c);

/****************************************************************************
 * line reader 
 */
  ldbl_QSLIB_INTERFACE ldbl_QSline_reader ldbl_QSline_reader_new (
  void *fct,
  void *data_src);
  /* reader->read_line_fct defaults to fgets */

  ldbl_QSLIB_INTERFACE void ldbl_QSline_reader_free (
  ldbl_QSline_reader reader);

  ldbl_QSLIB_INTERFACE void ldbl_QSline_reader_set_error_collector (
  ldbl_QSline_reader reader,
  ldbl_QSerror_collector collector);

  ldbl_QSLIB_INTERFACE char *ldbl_QSline_reader_get (
  ldbl_QSline_reader reader,
  char *s,
  int size);

  ldbl_QSLIB_INTERFACE ldbl_QSprob ldbl_QSget_prob (
  ldbl_QSline_reader reader,
  const char *probname,
  const char *filetype);
  /* the MPS and LP parsers uses the fct from reader 
   * to get to next input line */


/****************************************************************************
 * error memory 
 */
  ldbl_QSLIB_INTERFACE ldbl_QSerror_memory ldbl_QSerror_memory_create (
  int takeErrorLines);
  ldbl_QSLIB_INTERFACE void ldbl_QSerror_memory_free (
  ldbl_QSerror_memory mem);

  ldbl_QSLIB_INTERFACE int ldbl_QSerror_memory_get_nof (
  ldbl_QSerror_memory mem,
  int error_type);
  ldbl_QSLIB_INTERFACE int ldbl_QSerror_memory_get_nerrors (
  ldbl_QSerror_memory mem);

  ldbl_QSLIB_INTERFACE ldbl_QSformat_error ldbl_QSerror_memory_get_last_error (
  ldbl_QSerror_memory mem);
  ldbl_QSLIB_INTERFACE ldbl_QSformat_error ldbl_QSerror_memory_get_prev_error (
  ldbl_QSformat_error e);

/**************************************************************************** 
 * reporter for solver ldbl_feedback 
 */
  ldbl_QSLIB_INTERFACE void ldbl_QSset_reporter (
  ldbl_QSprob prob,
  int iterskip,
  void *fct,
  void *dest);

  ldbl_QSLIB_INTERFACE int ldbl_QSreport_prob (
  ldbl_QSprob p,
  const char *filetype,
  ldbl_QSerror_collector c);

#ifdef  __cplusplus
}
#endif
#endif                          /* ldbl___QS_QSOPT_H */
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: ldbl_format.h,v 1.3 2003/11/05 16:59:48 meven Exp $ */
#ifndef ldbl_QS_FORMAT_ERROR_H
#define ldbl_QS_FORMAT_ERROR_H


/****************************************************************************/
/*
   The LP/MPS readers, writers, 
       ldbl_ILLrawlpdata_to_lpdata, and 
   use ldbl_ILLformat_error to report problems with their input iff
       the line reader used in reading the problem  or 
       the  ldbl_qserror_collector pointer passed to ldbl_ILLwrite_lp_file
   is not NULL.

   The QSgui code uses this feature to collect ldbl_qsformat_error instances 
   which it uses after reading is done to insert error messages into the 
   input window. 
*/
/****************************************************************************/

/* 
for error type USE: 
          QS_DATA_ERROR     
          QS_DATA_WARN      
          QS_MPS_FORMAT_ERROR   
          QS_MPS_FORMAT_WARN    
          QS_LP_FORMAT_ERROR    
          QS_LP_FORMAT_WARN   
          QS_LP_OBJ_WARN      
          QS_GENERIC_ERROR    
*/

typedef struct ldbl_qsformat_error
{
  char *desc;
  char *theLine;
  struct ldbl_qsformat_error *next;
  int type;
  int lineNumber;               /* 1 based line counting */
  int at;
}
ldbl_qsformat_error;

extern int ldbl_ILLformat_error_create (
  ldbl_qsformat_error * error,
  int mode,
  const char *desc,
  int lineNum,
  const char *theLine,
  int atPos);
extern void ldbl_ILLformat_error_delete (
  ldbl_qsformat_error * error);

extern void ldbl_ILLformat_error_print (
  EGioFile_t * out,
  ldbl_qsformat_error * e);



/*****************************************************************************
 * collecting error messages 
 * either with defining own qsad_error_fct and corresponding data structure 
 * or by using predefined ldbl_ILLadd_error_to_memory fct with ldbl_qserror_memory
 */

typedef int (
  *ldbl_qsadd_error_fct) (
  void *dest,
  const ldbl_qsformat_error * error);

typedef struct ldbl_qserror_collector
{
  ldbl_qsadd_error_fct add_error;
  void *dest;
}
ldbl_qserror_collector;

typedef struct ldbl_qserror_memory
{
  unsigned int nerror;
  ldbl_qsformat_error *error_list;
  char has_error[QS_INPUT_NERROR];
  char hasErrorLines;
}
ldbl_qserror_memory;


extern ldbl_qserror_collector *ldbl_ILLerror_collector_new (
  ldbl_qsadd_error_fct fct,
  void *dest);

ldbl_qserror_collector *ldbl_ILLerror_memory_collector_new (
  ldbl_qserror_memory * dest);

extern void ldbl_ILLerror_collector_free (
  ldbl_qserror_collector * c);

#define ldbl_ILLformat_error(collector, error)  \
  ((collector)->add_error((collector)->dest, error))


extern int ldbl_ILLadd_error_to_memory (
  void *dest,
  const ldbl_qsformat_error * error);

extern ldbl_qserror_memory *ldbl_ILLerror_memory_create (
  int takeErrorLines);
extern void ldbl_ILLerror_memory_free (
  ldbl_qserror_memory * mem);

#endif
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  RCS_INFO = "$RCSfile: ldbl_rawlp.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $"; */
#ifndef ldbl___ILL_RAWLP_H_
#define ldbl___ILL_RAWLP_H_

/****************************************************************************/
/* DataStructure and Routines                                               */
/*          to deal with raw lp information as read from mps or lp files    */
/*          support scanning of input                                       */
/*          error reporting                                                 */
/****************************************************************************/


#define ldbl_ILL_ISBLANK(p) \
             (((*(p))==' '||(*(p))=='\t'||(*(p))=='\r'||(*(p))=='\f') ? 1 : 0)

/* 
 * we rely on ILLsymboltab property:
 *   the ith name added can be retrieved by ILLsymboltab_get(table, i) 
 *   as long as we never delete names from the symbol table 
 */
typedef struct ldbl_rawlpdata
{
  char *name;

  char *rhsname;
  char *rangesname;
  char *boundsname;

  int objsense;                 /* maximize or minimize */
  int objindex;                 /* index of objective row */

  int nrows;                    /* number of rows in problem */
  ILLsymboltab rowtab;          /* ILLsymboltab_get(rowtab, i) name of ith row */

  int sensesize;                /* size of rowsense */
  char *rowsense;               /* rowsense[i] snese of row[i] */

  char *rhsind;                 /* rhsind[i] == 1 we saw an rhs for row[i] */
  /* size is nrows */
  int rhssize;                  /* size of rhs array */
  long double *rhs;               /* rhs values for rows; size is nrows */
  char *rangesind;              /* ranges[i] == 1 we saw a range def for row[i] */
  struct ldbl_colptr *ranges;       /* list of range values */

  int ncols;                    /* number of cols in problem */
  ILLsymboltab coltab;          /* ILLsymboltab_get(coltab, i) name of ith col */
  int colsize;                  /* size of cols array */
  struct ldbl_colptr **cols;

  char *lbind;                  /* lbind[i] == 1  we saw a lower bound for col[i] */
  char *ubind;                  /* ubind[i] == 1  we saw a upper bound for col[i] */
  long double *lower;             /* lower[i] = lower bound for col[i] */
  long double *upper;             /* upper[i] = upper bound for col[i] */

  int intsize;                  /* size of intmarker array */
  char *intmarker;              /* intmarker[i] == 1  col[i] is an int var */

  /* sos information is tranfered into ldbl_ILLmatrix lpdata->sos */
  char *refrow;                 /* name of reference row */
  int refrowind;                /* index of refrow or -1  */

  int is_sos_size;              /* size of is_sos_member array */
  int *is_sos_member;           /* for each col contains either               
                                 *     -1 == no sos memeber 
                                 *     i  == member of set #i */

  int nsos_member;              /* total number of sos set members */
  int sos_weight_size;          /* size of sos_weight array */
  long double *sos_weight;        /* sos set elem i has weight of sos_weight[i] 
                                 * value comes from refrow coeficients */
  int sos_col_size;             /* size of sos_col array */
  int *sos_col;                 /* sos elem i is column sos_col[i] */

  int nsos;                     /* number of sos sets */
  int sos_setsize;              /* size of sosset array */
  struct ldbl_sosptr *sos_set;        /* type, size, first element of sos sets 
                                 * first is index into sos_weight and sos_col 
                                 * arrays */
  ldbl_qserror_collector *error_collector;
  ILLptrworld ptrworld;
}
ldbl_rawlpdata;

typedef struct ldbl_colptr
{
  long double coef;
  struct ldbl_colptr *next;
  int this_val;                     /* row index */
}
ldbl_colptr;
extern ldbl_colptr *ldbl_ILLcolptralloc (
  ILLptrworld * p);

typedef struct ldbl_sosptr
{
  int nelem;                    /* number of set elements */
  int first;                    /* index of first set element in sosmemeber */
  char type;                    /* set type */
}
ldbl_sosptr;
extern const int ldbl_ILL_SOS_TYPE1;
extern const int ldbl_ILL_SOS_TYPE2;

extern void ldbl_ILLinit_rawlpdata (
  ldbl_rawlpdata * lp,
  ldbl_qserror_collector * collector);
extern void ldbl_ILLfree_rawlpdata (
  ldbl_rawlpdata * lp);
extern void ldbl_ILLraw_clear_matrix (
  ldbl_rawlpdata * lp);

extern const char *ldbl_ILLraw_rowname (
  ldbl_rawlpdata * lp,
  int i);
extern const char *ldbl_ILLraw_colname (
  ldbl_rawlpdata * lp,
  int i);

extern int ldbl_ILLraw_add_col (
  ldbl_rawlpdata * lp,
  const char *name,
  int intmarker);
extern int ldbl_ILLraw_add_row (
  ldbl_rawlpdata * lp,
  const char *name,
  int sense,
  const long double rhs);

extern int ldbl_ILLraw_add_col_coef (
  ldbl_rawlpdata * lp,
  int colind,
  int rowind,
  long double coef);

extern int ldbl_ILLraw_init_ranges (
  ldbl_rawlpdata * lp);
extern int ldbl_ILLraw_init_rhs (
  ldbl_rawlpdata * lp);

extern int ldbl_ILLraw_add_ranges_coef (
  ldbl_rawlpdata * lp,
  int rowind,
  long double coef);


extern int ldbl_ILLraw_add_sos (
  ldbl_rawlpdata * lp,
  int sos_type);

                                                /* add empty set with type */
extern int ldbl_ILLraw_add_sos_member (
  ldbl_rawlpdata * lp,
  int colind);

                                                /* add col to last set */
extern int ldbl_ILLraw_is_mem_other_sos (
  ldbl_rawlpdata * lp,
  int colind);

extern int ldbl_ILLraw_set_rhs_name (
  ldbl_rawlpdata * lp,
  const char *name,
  int *skip);
extern int ldbl_ILLraw_set_bounds_name (
  ldbl_rawlpdata * lp,
  const char *name,
  int *skip);
extern int ldbl_ILLraw_set_ranges_name (
  ldbl_rawlpdata * lp,
  const char *name,
  int *skip);
extern void ldbl_ILLprint_rawlpdata (
  ldbl_rawlpdata * lp);

extern char *ldbl_ILLraw_unique_name (
  ILLsymboltab * tab,
  char *prefix,
  int i);
extern int ldbl_ILLraw_fill_in_rownames (
  ldbl_rawlpdata * lp);

extern int ldbl_ILLraw_init_bounds (
  ldbl_rawlpdata * lp);

extern const char *ldbl_ILLraw_set_lowerBound (
  ldbl_rawlpdata * lp,
  int i,
  long double bnd);
extern const char *ldbl_ILLraw_set_upperBound (
  ldbl_rawlpdata * lp,
  int i,
  long double bnd);
extern const char *ldbl_ILLraw_set_fixedBound (
  ldbl_rawlpdata * lp,
  int i,
  long double bnd);
extern const char *ldbl_ILLraw_set_binaryBound (
  ldbl_rawlpdata * lp,
  int i);
extern const char *ldbl_ILLraw_set_unbound (
  ldbl_rawlpdata * lp,
  int colind);
extern int ldbl_ILLraw_fill_in_bounds (
  ldbl_rawlpdata * lp);

extern int ldbl_ILLraw_first_nondefault_bound (
  ldbl_ILLlpdata * lp);
extern int ldbl_ILLraw_default_lower (
  ldbl_ILLlpdata * lp,
  int i);
extern int ldbl_ILLraw_default_upper (
  ldbl_ILLlpdata * lp,
  int i,
  int ri);

extern int ldbl_ILLrawlpdata_to_lpdata (
  ldbl_rawlpdata * raw,
  ldbl_ILLlpdata * lp);

extern int ldbl_ILLdata_error (
  ldbl_qserror_collector * collector,
  const char *format,
  ...);
extern void ldbl_ILLdata_warn (
  ldbl_qserror_collector * collector,
  const char *format,
  ...);

#endif
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: ldbl_mps.h,v 1.2 2003/11/05 16:57:39 meven Exp $ */
#ifndef ldbl_MPS_H
#define ldbl_MPS_H


/****************************************************************************/
/*                                                                          */
/*              Routines to support Reading and Writing MPS Files           */
/*                                                                          */
/****************************************************************************/
extern const char *ldbl_ILLmps_section_name[ILL_MPS_N_SECTIONS + 2];


extern int ldbl_ILLread_mps (
  ldbl_qsline_reader * file,
  const char *filename,
  ldbl_rawlpdata * lp);

extern int ldbl_ILLwrite_mps (
  ldbl_ILLlpdata * lp,
  ldbl_qserror_collector * collector);

        /* use lp->reporter for output */

#endif
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  $RCSfile: ldbl_price.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $" */
#ifndef ldbl___PRICE_H
#define ldbl___PRICE_H


typedef struct ldbl_price_res
{
  int eindex;
  int dir;
  int lindex;
  int lvstat;
  int price_stat;
  long double dinfeas;
  long double pinfeas;
}
ldbl_price_res;

int ldbl_ILLprice_test_for_heap (
  ldbl_lpinfo * const lp,
  ldbl_price_info * const pinf,
  int const nkeys,
  long double * keylist,
  int const algo,
  int const upd),
  ldbl_ILLprice_build_heap (
  ldbl_price_info * const pinf,
  int const nkeys,
  long double * keylist),
  ldbl_ILLprice_build_pricing_info (
  ldbl_lpinfo * const lp,
  ldbl_price_info * const pinf,
  int const phase),
  ldbl_ILLprice_update_pricing_info (
  ldbl_lpinfo * const lp,
  ldbl_price_info * const pinf,
  int const phase,
  ldbl_svector * const wz,
  int const eindex,
  int const lindex,
  long double y),
  ldbl_ILLprice_get_price (
  ldbl_price_info * const p,
  int const phase),
  ldbl_ILLprice_build_mpartial_info (
  ldbl_lpinfo * const lp,
  ldbl_price_info * const pinf,
  int const pricetype),
  ldbl_ILLprice_build_pdevex_norms (
  ldbl_lpinfo * const lp,
  ldbl_p_devex_info * const pdinfo,
  int const reinit),
  ldbl_ILLprice_update_pdevex_norms (
  ldbl_lpinfo * const lp,
  ldbl_p_devex_info * const pdinfo,
  int const eindex,
  long double yl),
  ldbl_ILLprice_build_psteep_norms (
  ldbl_lpinfo * const lp,
  ldbl_p_steep_info * const psinfo),
  ldbl_ILLprice_build_ddevex_norms (
  ldbl_lpinfo * const lp,
  ldbl_d_devex_info * const ddinfo,
  int const reinit),
  ldbl_ILLprice_update_ddevex_norms (
  ldbl_lpinfo * const lp,
  ldbl_d_devex_info * const ddinfo,
  int const eindex,
  long double yl),
  ldbl_ILLprice_build_dsteep_norms (
  ldbl_lpinfo * const lp,
  ldbl_d_steep_info * const dsinfo),
  ldbl_ILLprice_get_dsteep_norms (
  ldbl_lpinfo * const lp,
  int const count,
  int *constrowind,
  long double * const norms),
  ldbl_ILLprice_get_rownorms (
  ldbl_lpinfo * const lp,
  ldbl_price_info * const pinf,
  long double * const rnorms),
  ldbl_ILLprice_get_colnorms (
  ldbl_lpinfo * const lp,
  ldbl_price_info * const pinf,
  long double * const cnorms),
  ldbl_ILLprice_get_newnorms (
  ldbl_lpinfo * const lp,
  int const nelems,
  long double * const norms,
  int *const matcnt,
  int *const matbeg,
  int *const matind,
  long double * const matval,
  int const option),
  ldbl_ILLprice_get_new_rownorms (
  ldbl_lpinfo * const lp,
  int const newrows,
  long double * const rnorms,
  int *const rmatcnt,
  int *const rmatbeg,
  int *const rmatind,
  long double * const rmatval),
  ldbl_ILLprice_get_new_colnorms (
  ldbl_lpinfo * const lp,
  int const newrows,
  long double * const rnorms,
  int *const matcnt,
  int *const matbeg,
  int *const matind,
  long double * const matval),
  ldbl_ILLprice_load_rownorms (
  ldbl_lpinfo * const lp,
  long double * const rnorms,
  ldbl_price_info * const pinf),
  ldbl_ILLprice_load_colnorms (
  ldbl_lpinfo * const lp,
  long double * const cnorms,
  ldbl_price_info * const pinf);


void ldbl_ILLprice_free_heap (
  ldbl_price_info * const pinf),
  ldbl_ILLprice_init_pricing_info (
  ldbl_price_info * const pinf),
  ldbl_ILLprice_free_pricing_info (
  ldbl_price_info * const pinf),
  ldbl_ILLprice_free_mpartial_info (
  ldbl_mpart_info * p),
  ldbl_ILLprice_init_mpartial_price (
  ldbl_lpinfo * const lp,
  ldbl_price_info * const pinf,
  int const phase,
  int const pricetype),
  ldbl_ILLprice_update_mpartial_price (
  ldbl_lpinfo * const lp,
  ldbl_price_info * const pinf,
  int const phase,
  int const pricetype),
  ldbl_ILLprice_delete_onempart_price (
  /*ldbl_lpinfo * const lp,*/
  ldbl_price_info * const pinf,
  int const indx,
  int const pricetype),
  ldbl_ILLprice_mpartial_group (
  ldbl_lpinfo * const lp,
  ldbl_mpart_info * const p,
  int const phase,
  int const g,
  int const pricetype),
  ldbl_ILLprice_column (
  ldbl_lpinfo * const lp,
  int const ix,
  int const phase,
  ldbl_price_res * const pr),
  ldbl_ILLprice_row (
  ldbl_lpinfo * const lp,
  int const ix,
  int const phase,
  ldbl_price_res * const pr),
  ldbl_ILLprice_update_psteep_norms (
  ldbl_lpinfo * lp,
  ldbl_p_steep_info * psinfo,
  ldbl_svector * wz,
  int eindex,
  long double yl),
  ldbl_ILLprice_update_dsteep_norms (
  ldbl_lpinfo * const lp,
  ldbl_d_steep_info * const dsinfo,
  ldbl_svector * const wz,
  int const lindex,
  long double yl),
  ldbl_ILLprice_compute_dual_inf (
  ldbl_lpinfo * const lp,
  ldbl_price_info * const p,
  int *const ix,
  int const icnt,
  int const phase),
  ldbl_ILLprice_primal (
  ldbl_lpinfo * const lp,
  ldbl_price_info * const pinf,
  ldbl_price_res * const pr,
  int const phase),
  ldbl_ILLprice_compute_primal_inf (
  ldbl_lpinfo * const lp,
  ldbl_price_info * const p,
  int *const ix,
  int const icnt,
  int const phase),
  ldbl_ILLprice_dual (
  ldbl_lpinfo * const lp,
  ldbl_price_info * const pinf,
  int const phase,
  ldbl_price_res * const pr);

void ldbl_test_dsteep_norms (
  ldbl_lpinfo * const lp,
  ldbl_price_info * const p);

#endif /* ldbl___PRICE_H */
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

#ifndef ldbl___PRIORITY_H__
#define ldbl___PRIORITY_H__
/****************************************************************************/
/*                                                                          */
/*                             ldbl_priority.c                                   */
/*                                                                          */
/****************************************************************************/

typedef struct ldbl_ILLpriority
{
  ldbl_ILLdheap ldbl_heap;
  union ldbl_ILLpri_data
  {
    void *data;
    int next;
  }
   *pri_info;
  int space;
  int freelist;
}
ldbl_ILLpriority;

void ldbl_ILLutil_priority_free (
  ldbl_ILLpriority * pri),
  ldbl_ILLutil_priority_delete (
  ldbl_ILLpriority * pri,
  int handle),
  ldbl_ILLutil_priority_changekey (
  ldbl_ILLpriority * pri,
  int handle,
  long double * newkey),
  ldbl_ILLutil_priority_findmin (
  ldbl_ILLpriority * pri,
  long double * keyval,
  void **en),
  ldbl_ILLutil_priority_deletemin (
  ldbl_ILLpriority * pri,
  long double * keyval,
  void **en);

int ldbl_ILLutil_priority_init (
  ldbl_ILLpriority * pri,
  int k),
  ldbl_ILLutil_priority_insert (
  ldbl_ILLpriority * pri,
  void *data,
  long double * keyval,
  int *handle);



#endif
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  $RCSfile: ldbl_ratio.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $" */
#ifndef ldbl___RATIO_H
#define ldbl___RATIO_H
typedef struct ldbl_ratio_res
{
  long double tz;
  int eindex;
  int lindex;
  int lvstat;
  int ratio_stat;
  int boundch;
  int coeffch;
  long double lbound;
  long double ecoeff;
  long double pivotval;
}
ldbl_ratio_res;

void ldbl_ILLratio_pI_test (
  ldbl_lpinfo * const lp,
  int const eindex,
  int const dir,
  ldbl_ratio_res * const rs),
  ldbl_ILLratio_pII_test (
  ldbl_lpinfo * const lp,
  int const eindex,
  int const dir,
  ldbl_ratio_res * const rs),
  ldbl_ILLratio_dI_test (
  ldbl_lpinfo * const lp,
  int const lindex,
  int const lvstat,
  ldbl_ratio_res * const rs),
  ldbl_ILLratio_dII_test (
  ldbl_lpinfo * const lp,
  /*int const lindex,*/
  int const lvstat,
  ldbl_ratio_res * const rs),
  ldbl_ILLratio_longdII_test (
  ldbl_lpinfo * const lp,
  int const lindex,
  int const lvstat,
  ldbl_ratio_res * const rs),
  ldbl_ILLratio_pivotin_test (
  ldbl_lpinfo * const lp,
  int *const rlist,
  int const rcnt,
  ldbl_ratio_res * const rs);

#endif /* ldbl___RATIO_H */
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  RCS_INFO = "$RCSfile: read_lp_state.h,v $ $Revision: 1.2 $ $Date: 2003/11/05 16:57:39 $"; */
#ifndef ldbl_READ_LP_STATE_H
#define ldbl_READ_LP_STATE_H

/****************************************************************************/
/*                                                                          */
/*               Routines to support Reading LP Files                       */
/*                                                                          */
/****************************************************************************/

/* 
 * -) anything after '\' is comment 
 * -) variables consist of a-z A-Z 0-9!"#$%(),;.?@_`'{}|~ 
 *    don't start with a digit or '.'
 */


typedef struct ldbl_ILLread_lp_state
{
  ldbl_qsline_reader *file;
  const char *file_name;
  char *p;
  long double bound_val;
  int ldbl_interactive;
  int line_num;
  int column_index;
  char realline[ILL_namebufsize];
  char line[ILL_namebufsize];
  char field[ILL_namebufsize + 1];
  char fieldOnFirstCol;
  char eof;
  char sense_val;
}
ldbl_ILLread_lp_state;

extern int ldbl_ILLread_lp_state_init (
  ldbl_ILLread_lp_state * state,
  ldbl_qsline_reader * file,
  const char *ldbl_fname,
  int interactve);
extern int ldbl_ILLread_lp_state_next_line (
  ldbl_ILLread_lp_state * state);
extern int ldbl_ILLread_lp_state_next_var (
  ldbl_ILLread_lp_state * state);
extern int ldbl_ILLread_lp_state_keyword (
  ldbl_ILLread_lp_state * state,
  const char **kwd);
extern int ldbl_ILLread_lp_state_bad_keyword (
  ldbl_ILLread_lp_state * state);
extern int ldbl_ILLtest_lp_state_keyword (
  ldbl_ILLread_lp_state * state,
  const char *kwd[]);
extern int ldbl_ILLread_lp_state_next_field (
  ldbl_ILLread_lp_state * state);
extern int ldbl_ILLread_lp_state_next_field_on_line (
  ldbl_ILLread_lp_state * state);
extern void ldbl_ILLread_lp_state_prev_field (
  ldbl_ILLread_lp_state * state);
extern int ldbl_ILLread_lp_state_sign (
  ldbl_ILLread_lp_state * state,
  long double * sign);
extern int ldbl_ILLread_lp_state_possible_coef (
  ldbl_ILLread_lp_state * state,
  long double * coef,
  const long double defValue);

                                        /* returns 1 iff found a number 
                                         * otherwise 0 */
extern int ldbl_ILLread_lp_state_possible_bound_value (
  ldbl_ILLread_lp_state * state);

                                               /* returns 1 iff found a number 
                                                * otherwise 0 */
extern int ldbl_ILLread_lp_state_colon (
  ldbl_ILLread_lp_state * state);
extern int ldbl_ILLread_lp_state_has_colon (
  ldbl_ILLread_lp_state * state);
extern int ldbl_ILLread_lp_statxe_has_colon (
  ldbl_ILLread_lp_state * state);
extern int ldbl_ILLread_lp_state_next_constraint (
  ldbl_ILLread_lp_state * state);
extern int ldbl_ILLread_lp_state_sense (
  ldbl_ILLread_lp_state * state);
extern int ldbl_ILLtest_lp_state_sense (
  ldbl_ILLread_lp_state * state,
  int all);
extern void ldbl_ILLtest_lp_state_bound_sense (
  ldbl_ILLread_lp_state * state);
extern int ldbl_ILLread_lp_state_value (
  ldbl_ILLread_lp_state * state,
  long double * d);
extern int ldbl_ILLtest_lp_state_next_is (
  ldbl_ILLread_lp_state * state,
  const char *str);
extern int ldbl_ILLread_lp_state_skip_blanks (
  ldbl_ILLread_lp_state * state,
  int wrapLines);

extern int ldbl_ILLcheck_subject_to (
  ldbl_ILLread_lp_state * state);

/*---------------------------------------------------------------------------*/
/* errors and warnings 
 */
extern int ldbl_ILLlp_error (
  ldbl_ILLread_lp_state * state,
  const char *format,
  ...);
extern void ldbl_ILLlp_warn (
  ldbl_ILLread_lp_state * state,
  const char *format,
  ...);

/*---------------------------------------------------------------------------*/
/* shared with read_mps_state.c 
 */
extern int ldbl_ILLget_value (
  char *line,
  long double * coef);

#endif
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* $RCSfile: rd_mps.h,v $ $Revision: 1.2 $ $Date: 2003/11/05 16:57:39 $ */
#ifndef ldbl_READ_MPS_STATE_H
#define ldbl_READ_MPS_STATE_H



typedef struct ldbl_ILLread_mps_state_struct
{
  int section[ILL_MPS_N_SECTIONS];
  ILLmps_section active;
  const char *file_name;
  ldbl_qsline_reader *file;
  unsigned int line_num;
  unsigned int field_num;       /* number of successfully read fields on line */
  int intvar;
  int sosvar;
  char line[ILL_namebufsize];
  char key[ILL_namebufsize];
  char field[ILL_namebufsize];
  char *obj;
  char *p;                      /* ptr to next 'unread' character */
}
ldbl_ILLread_mps_state;

extern int ldbl_ILLmps_state_init (
  ldbl_ILLread_mps_state * state,
  ldbl_qsline_reader * file,
  const char *ldbl_fname);
extern void ldbl_ILLmps_state_clear (
  ldbl_ILLread_mps_state * state);
extern int ldbl_ILLmps_set_section (
  ldbl_ILLread_mps_state * state,
  const ILLmps_section sec);

extern int ldbl_ILLmps_next_line (
  ldbl_ILLread_mps_state * state);
extern int ldbl_ILLmps_next_field (
  ldbl_ILLread_mps_state * state);
extern int ldbl_ILLmps_next_coef (
  ldbl_ILLread_mps_state * state,
  long double * coef);
extern int ldbl_ILLmps_next_bound (
  ldbl_ILLread_mps_state * state,
  long double * coef);
extern void ldbl_ILLmps_check_end_of_line (
  ldbl_ILLread_mps_state * state);
extern void ldbl_ILLmps_set_end_of_line (
  ldbl_ILLread_mps_state * state);

extern int ldbl_ILLmps_int_sos_mode (
  ldbl_ILLread_mps_state * state);

extern const char *ldbl_ILLmps_possibly_blank_name (
  const char *field,
  ldbl_ILLread_mps_state * state,
  ILLsymboltab * tab);
extern int ldbl_ILLmps_empty_key (
  ldbl_ILLread_mps_state * state);
extern int ldbl_ILLmps_empty_field (
  ldbl_ILLread_mps_state * state);

extern int ldbl_ILLmps_error (
  ldbl_ILLread_mps_state * state,
  const char *format,
  ...);
extern void ldbl_ILLmps_warn (
  ldbl_ILLread_mps_state * state,
  const char *format,
  ...);

#endif
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* $RCSfile: ldbl_simplex.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $ */

#ifndef ldbl___SIMPLEX_H
#define ldbl___SIMPLEX_H

struct itcnt_t;
typedef struct ldbl_param_info
{
  int origalgo;
  int pphaseI;
  int pphaseII;
  int dphaseI;
  int dphaseII;
  int p_strategy;
  int d_strategy;
}
ldbl_param_info;

typedef struct ldbl_iter_info
{
  int newphase;
  int nextphase;
  int nextstep;
  int sdisplay;
  int itercnt;
  int solstatus;
  int curtime;
  int rounds;
  int chkobj;
  int nosolve;
  int noprog;
  int inner;
  int algorithm;
  int resumeid;
  int pricetype;
  int n_restart;
  int n_pivot_fail;
  long double prevobj;
  long double objtol;
  ldbl_param_info oldinfo;
}
ldbl_iter_info;

void ldbl_ILLsimplex_init_lpinfo ( ldbl_lpinfo * lp),
    ldbl_ILLsimplex_free_lpinfo ( ldbl_lpinfo * lp),
    ldbl_ILLsimplex_load_lpinfo ( ldbl_ILLlpdata * qslp, ldbl_lpinfo * lp),
    ldbl_ILLsimplex_set_bound ( ldbl_lpinfo * lp, const long double * objbound, int sense);
void ldbl_free_internal_lpinfo ( ldbl_lpinfo * lp);
void ldbl_init_internal_lpinfo ( ldbl_lpinfo * lp);
int ldbl_build_internal_lpinfo ( ldbl_lpinfo * lp);
int ldbl_ILLsimplex_retest_psolution ( ldbl_lpinfo * lp, ldbl_price_info * p, int phase,
      ldbl_feas_info * fs),
    ldbl_ILLsimplex_retest_dsolution ( ldbl_lpinfo * lp, ldbl_price_info * p, int phase,
      ldbl_feas_info * fs),
    ldbl_ILLsimplex_solution ( ldbl_lpinfo * lp, long double * xz, long double * piz,
      long double * dz, long double * objval),
    ldbl_ILLsimplex_infcertificate ( ldbl_lpinfo * lp, long double * pi),
    ldbl_ILLsimplex ( ldbl_lpinfo * lp, int algorithm, ldbl_ILLlp_basis * B, 
      ldbl_price_info * pinf, int *sol_status, int sdisplay, itcnt_t* itcnt),
    ldbl_ILLsimplex_pivotin ( ldbl_lpinfo * lp, ldbl_price_info * pinf, int rcnt, 
      int *rlist, int pivot_opt, int *basis_mod);

#endif /* ldbl___SIMPLEX_H */
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  RCS_INFO = "$RCSfile: wr_lp.h,v $ $Revision: 1.2 $ $Date: 2003/11/05 16:57:39 $"; */
#ifndef ldbl_WRITE_LP_STATE_H
#define ldbl_WRITE_LP_STATE_H

/****************************************************************************/
/*                                                                          */
/*               Routines to support writing of LP files                    */
/*                                                                          */
/****************************************************************************/

/* 
 * -) anything after '\' is comment 
 * -) variables consist of a-z A-Z 0-9!"#$%(),;.?@_`'{}|~ 
 *    don't start with a digit or '.'
 */

typedef struct ldbl_ILLwrite_lp_state
{
  char buf[ILL_namebufsize];
  char *p;
  int startlen;
  int total;
}
ldbl_ILLwrite_lp_state;

extern void ldbl_ILLwrite_lp_state_init (
  ldbl_ILLwrite_lp_state * line,
  const char *str);
extern void ldbl_ILLwrite_lp_state_append (
  ldbl_ILLwrite_lp_state * line,
  const char *str);
extern void ldbl_ILLwrite_lp_state_append_coef (
  ldbl_ILLwrite_lp_state * line,
  long double v,
  int cnt);

      /* append number sign ('+', '-') iff cnt > 0 or v < 0.0  
       * append number iff v != 1.0, v != -1.0  
       */
extern void ldbl_ILLwrite_lp_state_append_number (
  ldbl_ILLwrite_lp_state * line,
  long double v);
extern void ldbl_ILLwrite_lp_state_save_start (
  ldbl_ILLwrite_lp_state * line);
extern void ldbl_ILLwrite_lp_state_start (
  ldbl_ILLwrite_lp_state * line);

#endif
#endif
#endif
#ifdef HAVE_LONG_DOUBLE
#if HAVE_LONG_DOUBLE
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: ldbl_lib.h,v 1.4 2003/11/05 17:00:26 meven Exp $ */
#ifndef ldbl_ILL_LIB_H
#define ldbl_ILL_LIB_H


/****************************************************************************/
/*                                                                          */
/*                   Return Status for ldbl_ILLlib_optimize                      */
/*                                                                          */
/****************************************************************************/

/****************************************************************************/
/*                                                                          */
/*                               ldbl_lib.c                                      */
/*                                                                          */
/****************************************************************************/

struct itcnt_t;

int ldbl_ILLlib_optimize ( ldbl_lpinfo * lp, ldbl_ILLlp_basis * B, ldbl_price_info * pinf, int algo,
      int *status, int simplex_display, struct itcnt_t*itcnt),
    ldbl_ILLlib_cache_solution ( ldbl_lpinfo * lp, ldbl_ILLlp_cache * C), 
    ldbl_ILLlib_solution ( ldbl_lpinfo * lp, ldbl_ILLlp_cache * C, long double * val, 
      long double * x, long double * pi, long double * slack, long double * rc),
    ldbl_ILLlib_get_x ( ldbl_lpinfo * lp, ldbl_ILLlp_cache * C, long double * x),
    ldbl_ILLlib_get_slack ( ldbl_lpinfo * lp, ldbl_ILLlp_cache * C, long double * slack),
    ldbl_ILLlib_objval ( ldbl_lpinfo * lp, ldbl_ILLlp_cache * C, long double * val),
    ldbl_ILLlib_tableau ( ldbl_lpinfo * lp, int row, long double * binv, long double * tabrow),
    ldbl_ILLlib_basis_order ( ldbl_lpinfo * lp, int *header),
    ldbl_ILLlib_newrow ( ldbl_lpinfo * lp, ldbl_ILLlp_basis * B,const long double rhs, int sense,
      const long double range, const char *name),
    ldbl_ILLlib_newrows ( ldbl_lpinfo * lp, ldbl_ILLlp_basis * B, int num,const long double * rhs,
      char *sense, const long double * range, const char **names),
    ldbl_ILLlib_addrow ( ldbl_lpinfo * lp, ldbl_ILLlp_basis * B, int cnt, int *ind,
      const long double * val, const long double rhs, int sense,const long double range,
      const char *rowname),
    ldbl_ILLlib_addrows ( ldbl_lpinfo * lp, ldbl_ILLlp_basis * B, int num, int *rmatcnt, 
      int *rmatbeg, int *rmatind,const long double * rmatval,const long double * rhs, 
      char *sense, const long double * range, const char **names, int *nofactor),
    ldbl_ILLlib_delrows ( ldbl_lpinfo * lp, ldbl_ILLlp_basis * B, ldbl_ILLlp_cache * C, int num, 
      int *dellist, int *basis_ok, int *cache_ok), 
    ldbl_ILLlib_newcol ( ldbl_lpinfo * lp, ldbl_ILLlp_basis * B,const long double obj, 
      const long double lower,const long double upper, const char *name, int factorok), 
    ldbl_ILLlib_newcols ( ldbl_lpinfo * lp, ldbl_ILLlp_basis * B, int num, long double * obj,
      long double * lower, long double * upper, const char **names, int factorok),
    ldbl_ILLlib_addcol ( ldbl_lpinfo * lp, ldbl_ILLlp_basis * B, int cnt, int *ind,
      long double * val,const long double obj,const long double lower,const long double upper, 
      const char *name, int factorok),
    ldbl_ILLlib_addcols ( ldbl_lpinfo * lp, ldbl_ILLlp_basis * B, int num, int *cmatcnt,
      int *cmatbeg, int *cmatind, long double * cmatval, long double * obj,
      long double * lower, long double * upper, const char **names, int factorok),
    ldbl_ILLlib_delcols ( ldbl_lpinfo * lp, ldbl_ILLlp_basis * B, int num, int *dellist,
      int *basis_ok),
    ldbl_ILLlib_chgcoef ( ldbl_lpinfo * lp, int rowindex, int colindex, long double coef), 
    ldbl_ILLlib_getcoef (ldbl_lpinfo *lp, int rowindex, int colindex, long double* coef),
    ldbl_ILLlib_chgrange (ldbl_lpinfo *lp, int indx, long double coef),
    ldbl_ILLlib_chgsense ( ldbl_lpinfo * lp, int num, int *rowlist, char *sense),
    ldbl_ILLlib_getsenses (ldbl_lpinfo *lp, char *senses),
    ldbl_ILLlib_getrows ( ldbl_lpinfo * lp, int num, int *rowlist, int **rowcnt,
      int **rowbeg, int **rowind, long double ** rowval, long double ** rhs,
      char **sense, long double ** range, char ***names),
    ldbl_ILLlib_getcols ( ldbl_lpinfo * lp, int num, int *collist, int **colcnt,
      int **colbeg, int **colind, long double ** colval, long double ** obj,
      long double ** lower, long double ** upper, char ***names),
    ldbl_ILLlib_getobj ( ldbl_lpinfo * lp, long double * obj),
    ldbl_ILLlib_getobj_list (ldbl_lpinfo *lp, int num, int* collist, long double* obj),
    ldbl_ILLlib_chgobj ( ldbl_lpinfo * lp, int indx, long double coef),
    ldbl_ILLlib_getrhs ( ldbl_lpinfo * lp, long double * rhs),
    ldbl_ILLlib_chgrhs ( ldbl_lpinfo * lp, int indx, long double coef),
    ldbl_ILLlib_getintflags ( ldbl_lpinfo * lp, int *intflags),
    ldbl_ILLlib_rownames ( ldbl_lpinfo * lp, char **rownames),
    ldbl_ILLlib_colnames ( ldbl_lpinfo * lp, char **colnames),
    ldbl_ILLlib_colindex ( ldbl_lpinfo * lp, const char *name, int *colindex),
    ldbl_ILLlib_rowindex ( ldbl_lpinfo * lp, const char *name, int *rowindex),
    ldbl_ILLlib_chgbnd ( ldbl_lpinfo * lp, int indx, int lu,const long double bnd),
    ldbl_ILLlib_chgbnds ( ldbl_lpinfo * lp, int cnt, int *indx, char *lu, const long double * bnd),
    ldbl_ILLlib_getbnd ( ldbl_lpinfo * lp, int indx, int lu, long double * bnd),
    ldbl_ILLlib_getbnds ( ldbl_lpinfo * lp, long double * lower, long double * upper),
    ldbl_ILLlib_getbnds_list ( ldbl_lpinfo *lp, int num, int*collist, long double *lower,
      long double *upper),
    ldbl_ILLlib_strongbranch ( ldbl_lpinfo * lp, ldbl_price_info * pinf, int *candidatelist,
      int ncand, long double * xlist, long double * downpen, long double * uppen,
      int iterations, long double objbound, struct itcnt_t*itcnt),
    ldbl_ILLlib_getbasis ( ldbl_lpinfo * lp, char *cstat, char *rstat),
    ldbl_ILLlib_loadbasis ( ldbl_ILLlp_basis * B, int nstruct, int nrows, char *cstat,
      char *rstat),
    ldbl_ILLlib_readbasis ( ldbl_lpinfo * lp, ldbl_ILLlp_basis * B, const char *ldbl_fname),
    ldbl_ILLlib_writebasis ( ldbl_lpinfo * lp, ldbl_ILLlp_basis * B, const char *ldbl_fname),
    ldbl_ILLlib_getrownorms ( ldbl_lpinfo * lp, ldbl_price_info * pinf, long double * rownorms),
    ldbl_ILLlib_loadrownorms ( ldbl_lpinfo * lp, ldbl_price_info * pinf, long double * rownorms),
    ldbl_ILLlib_recompute_rownorms ( ldbl_lpinfo * lp, ldbl_price_info * pinf),
    ldbl_ILLlib_iter ( ldbl_lpinfo * lp),
    ldbl_ILLlib_print_x ( EGioFile_t * fd, ldbl_lpinfo * lp, ldbl_ILLlp_cache * C, long double * x,
      int nonZerosOnly),
    ldbl_ILLwrite_lp_file ( ldbl_ILLlpdata * lp, EGioFile_t * eout, ldbl_qserror_collector * c);


extern int ldbl_ILLlib_findName (
  ldbl_ILLlpdata * qslp,
  int forRow,
  const char *name,
  int id,
  char buf[ILL_namebufsize]);

/****************************************************************************/
/*                                                                          */
/*                           ldbl_presolve.c                                     */
/*                                                                          */
/****************************************************************************/

int ldbl_ILLpresolve_add_logicals (
  ldbl_ILLlpdata * lp);


/****************************************************************************/
/*                                                                          */
/*                            ldbl_binary.c                                      */
/*                                                                          */
/****************************************************************************/

int ldbl_ILLmip_binary_dfs (
  ldbl_lpinfo * lp);

#endif /* ldbl_ILL_LIB_H */
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  $RCSfile: mpq_qstruct.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $" */
#ifndef mpq___QS_QSTRUCT_H
#define mpq___QS_QSTRUCT_H

typedef struct mpq_qsdata
{
  struct mpq_ILLlpdata *qslp;
  struct mpq_lpinfo *lp;
  struct mpq_price_info *pricing;
  struct mpq_ILLlp_basis *basis;
  struct mpq_ILLlp_cache *cache;
  char *name;
  int qstatus;                  /* QS_LP_UNSOLVED or an opt status  */
  int factorok;                 /* set to 0 if factorization is old */
  int simplex_display;          /* 0 off, 1 on */
  int simplex_scaling;          /* 0 off, 1 on */
  itcnt_t itcnt;
  mpq_t uobjlim;
  mpq_t lobjlim;
}
mpq_QSdata;

#endif /* mpq___QS_QSTRUCT_H */
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: mpq_editor.h,v 1.2 2003/11/05 16:57:39 meven Exp $ */
#ifndef mpq_EDITOR_H
#define mpq_EDITOR_H

extern void mpq_ILLeditor_init (
  void);
extern void mpq_ILLeditor (
  mpq_QSdata * p);
extern int mpq_ILLeditor_solve (
  mpq_QSdata * p,
  int salgo);

#endif
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: mpq_dstruct.h,v 1.3 2003/11/05 16:57:39 meven Exp $ */
/****************************************************************************/
/*                                                                          */
/*                           mpq_svector.h                                      */
/*                                                                          */
/****************************************************************************/

#ifndef mpq___SVECTOR_H
#define mpq___SVECTOR_H

typedef struct mpq_svector
{
  int nzcnt;
  int *indx;
  int size;
  mpq_t *coef;
}
mpq_svector;

void mpq_ILLsvector_init (
  mpq_svector * s),
  mpq_ILLsvector_free (
  mpq_svector * s);

int mpq_ILLsvector_alloc (
  mpq_svector * s,
  int nzcnt),
  mpq_ILLsvector_copy (
  const mpq_svector * s_in,
  mpq_svector * s_out);

#endif /* mpq___SVECTOR_H */

/****************************************************************************/
/*                                                                          */
/*                           mpq_heap.h                                         */
/*                                                                          */
/****************************************************************************/

#ifndef mpq___HEAP_H
#define mpq___HEAP_H

typedef struct
{
  int *entry;
  int *loc;
  mpq_t *key;
  int hexist;
  int maxsize;
  int size;
}
mpq_heap;

void mpq_ILLheap_insert (
  mpq_heap * const h,
  int const ix),
  mpq_ILLheap_modify (
  mpq_heap * const h,
  int const ix),
  mpq_ILLheap_delete (
  mpq_heap * const h,
  int const ix),
  mpq_ILLheap_init (
  mpq_heap * const h),
  mpq_ILLheap_free (
  mpq_heap * const h);

int mpq_ILLheap_findmin (
  mpq_heap * const h),
  mpq_ILLheap_build (
  mpq_heap * const h,
  int const nelems,
  mpq_t * key);

#endif /* mpq___HEAP_H */

/****************************************************************************/
/*                                                                          */
/*                         matrix.h                                         */
/*                                                                          */
/****************************************************************************/

#ifndef mpq___MATRIX_H
#define mpq___MATRIX_H

typedef struct mpq_ILLmatrix
{
  mpq_t *matval;            /* The coefficients.                       */
  int *matcnt;                  /* Number of coefs in each col.            */
  int *matind;                  /* The row indices of the coefs.           */
  int *matbeg;                  /* The start of each col.                  */
  int matcols;                  /* Number of columns.                      */
  int matrows;
  int matcolsize;               /* Length of matbeg and matcnt.            */
  int matsize;                  /* Length of matind and matval.            */
  int matfree;                  /* Free space at end of matind.            */
  /* Note: free elements marked by -1 in     */
  /* matind; we keep at least 1 free at end. */
}
mpq_ILLmatrix;

void mpq_ILLmatrix_init (
  mpq_ILLmatrix * A);
void mpq_ILLmatrix_free (
  mpq_ILLmatrix * A);
void mpq_ILLmatrix_prt (
  EGioFile_t * fd,
  mpq_ILLmatrix * A);

#endif /* mpq___MATRIX_H */
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: mpq_factor.h,v 1.3 2003/11/05 16:57:39 meven Exp $ */
#ifndef mpq___QS_FACTOR_H_
#define mpq___QS_FACTOR_H_

typedef char mpq_QSbool;

typedef struct mpq_uc_info
{
  int cbeg;
  int nzcnt;
  int next;
  int prev;
  int delay;
}
mpq_uc_info;

typedef struct mpq_ur_info
{
  mpq_t max;
  int rbeg;
  int nzcnt;
  int pivcnt;
  int next;
  int prev;
  int delay;
}
mpq_ur_info;

typedef struct mpq_lc_info
{
  int cbeg;
  int nzcnt;
  int c;
  int crank;
  int delay;
}
mpq_lc_info;

typedef struct mpq_lr_info
{
  int rbeg;
  int nzcnt;
  int r;
  int rrank;
  int delay;
}
mpq_lr_info;

typedef struct mpq_er_info
{
  int rbeg;
  int nzcnt;
  int r;
}
mpq_er_info;

typedef struct mpq_factor_work
{
  int max_k;
  mpq_t fzero_tol;
  mpq_t szero_tol;
  mpq_t partial_tol;
  double ur_space_mul;
  double uc_space_mul;
  double lc_space_mul;
  double lr_space_mul;
  double er_space_mul;
  double grow_mul;
  int p;
  int etamax;
  double minmult;
  double maxmult;
  double updmaxmult;
  double dense_fract;
  int dense_min;

  mpq_t maxelem_orig;
  int nzcnt_orig;
  mpq_t maxelem_factor;
  int nzcnt_factor;
  mpq_t maxelem_cur;
  int nzcnt_cur;

  mpq_t partial_cur;

  int dim;
  int stage;
  int nstages;
  int etacnt;
  mpq_t *work_coef;
  int *work_indx;
  mpq_uc_info *uc_inf;
  mpq_ur_info *ur_inf;
  mpq_lc_info *lc_inf;
  mpq_lr_info *lr_inf;
  mpq_er_info *er_inf;
  int *ucindx;                  /* row index for column data */
  int *ucrind;                  /* index of column in row data */
  mpq_t *uccoef;            /* coefficient for column data */
  int *urindx;                  /* col index for row data */
  int *urcind;                  /* index of row in column data */
  mpq_t *urcoef;            /* coefficient for row data */
  int *lcindx;                  /* row index for L data */
  mpq_t *lccoef;            /* coefficient for L row data */
  int *lrindx;                  /* col index for L data */
  mpq_t *lrcoef;            /* coefficient for L col data */
  int *erindx;                  /* col index for eta data */
  mpq_t *ercoef;            /* coefficient for eta data */
  int *rperm;
  int *rrank;
  int *cperm;
  int *crank;
  mpq_svector xtmp;
  int ur_freebeg;
  int ur_space;
  int uc_freebeg;
  int uc_space;
  int lc_freebeg;
  int lc_space;
  int lr_freebeg;
  int lr_space;
  int er_freebeg;
  int er_space;

  int *p_nsing;
  int **p_singr;
  int **p_singc;

  mpq_t *dmat;
  int drows;
  int dcols;
  int dense_base;
}
mpq_factor_work;

void mpq_ILLfactor_init_factor_work (
  mpq_factor_work * f),
  mpq_ILLfactor_free_factor_work (
  mpq_factor_work * f),
  mpq_ILLfactor_ftran (
  mpq_factor_work * f,
  mpq_svector * a,
  mpq_svector * x),
  mpq_ILLfactor_ftran_update (
  mpq_factor_work * f,
  mpq_svector * a,
  mpq_svector * upd,
  mpq_svector * x),
  mpq_ILLfactor_btran (
  mpq_factor_work * f,
  mpq_svector * a,
  mpq_svector * x);

int mpq_ILLfactor_create_factor_work (
  mpq_factor_work * f,
  int dim),
  mpq_ILLfactor_set_factor_iparam (
  mpq_factor_work * f,
  int param,
  int val),
  mpq_ILLfactor_set_factor_dparam (
  mpq_factor_work * f,
  int param,
  mpq_t val),
  mpq_ILLfactor (
  mpq_factor_work * f,
  int *basis,
  int *cbeg,
  int *clen,
  int *cindx,
  mpq_t * ccoef,
  int *p_nsing,
  int **p_singr,
  int **p_singc),
  mpq_ILLfactor_update (
  mpq_factor_work * f,
  mpq_svector * a,
  int col,
  int *p_refact);

#endif /* mpq___QS_FACTOR_H_ */
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: mpq_lpdefs.h,v 1.3 2003/11/05 16:57:39 meven Exp $ */
#ifndef mpq___QS_LPDEFS_H
#define mpq___QS_LPDEFS_H


/* infinity and negative infinity */
#define mpq_INFTY  mpq_ILL_MAXDOUBLE
#define mpq_NINFTY mpq_ILL_MINDOUBLE

/* tolerances, these are initialized in mpq_ILLstart, file mpq_lpdata.c */
//#if EGLPNUM_TYPE != DBL_TYPE && EGLPNUM_TYPE != LDBL_TYPE
/* these three constants are defined in mpq_lpdata.c */
extern mpq_t mpq_PARAM_IBASIS_RPIVOT; /*       0.98 */
extern mpq_t mpq_PARAM_IBASIS_RTRIANG;/*       0.01 */
extern mpq_t mpq_PARAM_MIN_DNORM;     /*      1e-24 */
extern mpq_t mpq_PFEAS_TOLER;         /*       1e-6 */
extern mpq_t mpq_BD_TOLER;            /*       1e-7 */
extern mpq_t mpq_DFEAS_TOLER;         /*       1e-6 */
extern mpq_t mpq_PIVOT_TOLER;         /*      1e-10 */
extern mpq_t mpq_SZERO_TOLER;         /*      1e-15 */
extern mpq_t mpq_PIVZ_TOLER;          /*      1e-12 */
extern mpq_t mpq_OBJBND_TOLER;        /*       1e-2 */
extern mpq_t mpq_DBNDPIV_TOLER;       /*       1e-3 */
extern mpq_t mpq_DBNDPIV_RATIO;       /*       1e-2 */
extern mpq_t mpq_ALTPIV_TOLER;        /*       1e-8 */
//extern mpq_t DJZERO_TOLER;/*             1e-8 */
extern mpq_t mpq_PROGRESS_ZERO;       /*       1e-7 */
extern mpq_t mpq_PROGRESS_THRESH;     /*       1e-5 */
extern mpq_t mpq_CB_EPS;              /*      0.001 */
extern mpq_t mpq_CB_INF_RATIO;        /*       10.0 */
extern mpq_t mpq_CB_PRI_RLIMIT;       /*       0.25 */

/* structure for statistics */
typedef struct
{
  int ynz_cnt;                  /* nz in entering columns */
  int num_y;
  mpq_t y_ravg;             /* weighted avg. of current & prior y */
  int znz_cnt;                  /* nz in ith row of B^{-1}, ie z_i */
  int num_z;
  mpq_t z_ravg;             /* weighted avg. of current & prior z */
  int zanz_cnt;                 /* nz in z^TA */
  int num_za;
  mpq_t za_ravg;            /* weighted avg. of current & prior za */
  int pnorm_cnt;                /* nz in columns for primal norms */
  int dnorm_cnt;                /* nz in rows for dual norms */
  int pinz_cnt;                 /* nz in phase II pi (solve) */
  int num_pi;                   /* # of pi solves */
  int pi1nz_cnt;                /* nz in phase I pi (solve) */
  int num_pi1;                  /* # of phase I pi solves */
  int upnz_cnt;                 /* nz in ftran update vector */
  int num_up;                   /* # of ftran_updates */
  int pupv_cnt;                 /* nz in primal steep updates */
  int dupv_cnt;                 /* nz in dual steep updates */

  int start_slacks;             /* # slacks in beginning */
  int final_slacks;             /* # slacks in the end */
  int start_art;                /* # arts in beginning */
  int final_art;                /* # arts in the end */

  int pI_iter;                  /* primal phase I iterations */
  int pII_iter;
  int dI_iter;                  /* dual phase I iterations */
  int dII_iter;
  int tot_iter;

  int pivpI[10];                /* sizes of pivots */
  int pivpII[10];
  int pivdI[10];
  int pivdII[10];
}
mpq_count_struct;

/* structure for tolerances */
typedef struct
{
  mpq_t pfeas_tol;
  mpq_t dfeas_tol;
  mpq_t pivot_tol;
  mpq_t szero_tol;
  mpq_t ip_tol;             /* inner primal & dual feas toler */
  mpq_t id_tol;
}
mpq_tol_struct;

/* bound information */
typedef struct mpq_bndinfo
{
  mpq_t pbound;
  mpq_t cbound;
  int btype;
  int varnum;
  struct mpq_bndinfo *next;
}
mpq_bndinfo;

/* bound information */
typedef struct mpq_coefinfo
{
  mpq_t pcoef;
  mpq_t ccoef;
  int varnum;
  struct mpq_coefinfo *next;
}
mpq_coefinfo;

/* feasibility info */
typedef struct mpq_feas_info
{
  int pstatus;
  int dstatus;
  mpq_t totinfeas;
}
mpq_feas_info;

typedef struct mpq_lp_status_info
{
  char optimal;
  char primal_feasible;
  char primal_infeasible;
  char primal_unbounded;
  char dual_feasible;
  char dual_infeasible;
  char dual_unbounded;
  char padd;
}
mpq_lp_status_info;

typedef struct mpq_pI_uinfo
{
  int tctr;
  int i;
  int *perm;
  int *ix;
  int fs;
  mpq_t piv;
  mpq_t *t;
  mpq_t dty;
  mpq_t c_obj;
  mpq_t tz;
}
mpq_pI_uinfo;

extern void mpq_ILLlp_status_info_init (
  mpq_lp_status_info * ls);

/* structure for local lp information
 * contains lp obj values - status - dimensions - input data -
 * solution vecs - basis info - update vecs - work vecs - bound changes -
 * tolerances - time info - statistics 
 */
typedef struct mpq_lpinfo
{

  mpq_t objval;             /* obj info */
  mpq_t pobjval;            /* intermediate status info */
  mpq_t dobjval;
  mpq_t pinfeas;
  mpq_t dinfeas;
  mpq_t objbound;
  mpq_lp_status_info probstat;      /* final status */
  mpq_lp_status_info basisstat;     /* final status */
  int nrows;                    /* input info follows; given in col format */
  int ncols;
  int *matcnt;
  int *matbeg;
  int *matind;
  mpq_t *matval;
  int matfree;
  int matsize;
  mpq_t *bz;
  mpq_t *lz;
  mpq_t *uz;
  mpq_t *cz;
  int localrows;                /* set to 1 if these are created locally */
  int *rowcnt;                  /* row info follows, copy of col info */
  int *rowbeg;
  int *rowind;
  mpq_t *rowval;

  mpq_t *xbz;               /* output info x, pi, reduced cost */
  mpq_t *piz;
  mpq_t *dz;
  mpq_t *pIxbz;             /* output info (phase I) x, pi, reduced cost */
  mpq_t *pIpiz;
  mpq_t *pIdz;

  int final_phase;              /* final phase, inf & unboundedness info */
  int infub_ix;

  int basisid;                  /* basis and variable info follows */
  int nnbasic;
  int *baz;
  int *nbaz;
  int *vstat;
  int *vindex;
  int fbasisid;
  mpq_factor_work *f;
  int *vtype;                   /* internal var info */
  char *vclass;                 /* structural or logical */

  mpq_svector zz;                   /* local mpq_ILLfactor_update vectors z, yj, za */
  mpq_svector yjz;
  mpq_svector zA;
  mpq_svector work;                 /* local work vector */
  mpq_svector srhs;                 /* local vectors for lin. eq. solves */
  mpq_svector ssoln;
  int *iwork;                   /* local work vector */
  mpq_pI_uinfo upd;                 /* phase I update info */
  int *bfeas;                   /* primal and dual infeasibility info */
  int *dfeas;

  mpq_tol_struct *tol;              /* tolerances */
  mpq_count_struct *cnts;           /* counts */
  int nbchange;                 /* # bound shifts */
  int ncchange;                 /* # obj coef shifts */
  mpq_bndinfo *bchanges;            /* list of bound shifts */
  mpq_coefinfo *cchanges;           /* list of coef shifts */
  int pIratio;                  /* ratio tests */
  int pIIratio;
  int dIratio;
  int dIIratio;

  int maxiter;
  int iterskip;
  double maxtime;
  double starttime;
  struct mpq_ILLlpdata *O;
  ILLrandstate rstate;

}
mpq_lpinfo;

/* pricing structures */
typedef struct
{
  int ninit;
  mpq_t *norms;
  int *refframe;
}
mpq_p_devex_info;

typedef struct
{
  mpq_t *norms;
}
mpq_p_steep_info;

typedef struct
{
  int k;
  int cgroup;
  int ngroups;
  int *gstart;
  int *gshift;
  int *gsize;
  int bsize;
  int *bucket;
  int *perm;
  mpq_t *infeas;
}
mpq_mpart_info;

typedef struct
{
  int ninit;
  mpq_t *norms;
  int *refframe;
}
mpq_d_devex_info;

typedef struct
{
  mpq_t *norms;
}
mpq_d_steep_info;

/* pricing information */
typedef struct mpq_price_info
{
  int p_strategy;
  int d_strategy;
  int pI_price;
  int pII_price;
  int dI_price;
  int dII_price;
  int cur_price;
  mpq_t *p_scaleinf;
  mpq_t *d_scaleinf;
  mpq_p_devex_info pdinfo;
  mpq_p_steep_info psinfo;
  mpq_mpart_info pmpinfo;
  mpq_d_devex_info ddinfo;
  mpq_d_steep_info dsinfo;
  mpq_mpart_info dmpinfo;
  mpq_heap h;
  mpq_t htrigger;
  int hineff;
  char init;
}
mpq_price_info;

#endif /* mpq___QS_LPDEFS_H */
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: rdline.h,v 1.2 2003/11/05 16:57:39 meven Exp $ */
#ifndef mpq_LINE_READER_FILE_H
#define mpq_LINE_READER_FILE_H


/* #ifdef _WINDOWS */
typedef char *(
  *mpq_qsread_line_fct) (
  char *s,
  int size,
  void *src);

typedef struct mpq_qsline_reader
{
  mpq_qsread_line_fct read_line_fct;
  void *data_src;
  struct mpq_qserror_collector *error_collector;
}
mpq_qsline_reader;

mpq_qsline_reader *mpq_ILLline_reader_new (
  mpq_qsread_line_fct fct,
  void *data_src);
void mpq_ILLline_reader_free (
  mpq_qsline_reader * reader);

#define mpq_ILLline_reader_get(s, size, reader)  \
  (reader)->read_line_fct(s, size, (reader)->data_src)
                   /* used by parsers to retrieve next input line */
/* #else  
 *
 * typedef FILE mpq_qsline_reader; 
 *
 * #define mpq_ILLline_reader_new(fct, data) ((FILE*) (data)) 
 * #define mpq_ILLline_reader_free(reader)  
 * #define mpq_ILLline_reader_get(s, size, reader) fgets(s,size,reader) 
 * #endif 
 */

#endif
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: mpq_lpdata.h,v 1.4 2003/11/05 17:00:56 meven Exp $ */
#ifndef mpq_ILL_LPDATA_H
#define mpq_ILL_LPDATA_H


extern mpq_t mpq_ILL_MAXDOUBLE; /*  1e150 */
extern mpq_t mpq_ILL_MINDOUBLE; /* -1e150 */

#define mpq_ILL_MAXINT    (2147483647)  /* this is equal to 2^31-1 */
#define mpq_ILL_MIN       (1)       /* Must be same as QS_MIN */
#define mpq_ILL_MAX       (-1)      /* Must be same as QS_MAX */

/*  Setting Alg in Presolve  */

#define mpq_ILL_PRE_SCALE           1
#define mpq_ILL_PRE_FIXED           2
#define mpq_ILL_PRE_SINGLE_ROW      4
#define mpq_ILL_PRE_FORCING         8
#define mpq_ILL_PRE_SINGLE_COL     16
#define mpq_ILL_PRE_DUPLICATE_ROW  32
#define mpq_ILL_PRE_DUPLICATE_COL  64
#define mpq_ILL_PRE_EMPTY_COL     128
#define mpq_ILL_PRE_ALL (mpq_ILL_PRE_SCALE | mpq_ILL_PRE_FIXED | mpq_ILL_PRE_SINGLE_ROW           \
                    mpq_ILL_PRE_FORCING | mpq_ILL_PRE_SINGLE_COL | mpq_ILL_PRE_DUPLICATE_ROW \
                   mpq_ILL_PRE_DUPLICATE_COL | mpq_ILL_PRE_EMPTY_COL)
#define mpq_ILL_PRE_SIMPLE (mpq_ILL_PRE_FIXED | mpq_ILL_PRE_EMPTY_COL)

typedef struct mpq_ILLlpdata
{                               /* Complete LP data filled in by mpsread.  */
  int nrows;
  int ncols;
  int nstruct;                  /* Not including logicals.                 */
  int nzcount;
  int rowsize;                  /* Length of row arrays.                   */
  int colsize;                  /* Length of col arrays.                   */
  int structsize;               /* Length of intmarker, structmap,         */
  /* colnames                                */
  int objsense;
  char *sense;                  /* Original sense, not after logicals.     */
  mpq_t *obj;
  mpq_t *rhs;
  mpq_t *rangeval;
  mpq_t *lower;
  mpq_t *upper;
  mpq_ILLmatrix A;                  /* The coef matrix.                        */
  struct mpq_ILLlp_rows *rA;        /* Coef matrix in row form.                */

  char **rownames;
  ILLsymboltab rowtab;          /* contains rownames in no particular order */
  char *objname;                /* if colname is not NULL it is entered into 
                                 * the rowtab, see reader fcts in mpq_lp.c, mpq_mps.c*/

  char **colnames;              /* columns of struct variables */
  ILLsymboltab coltab;          /* contains colnames in no particular order */

  char *probname;
  char *intmarker;
  int *structmap;               /* Indices of structural variables         */
  int *rowmap;                  /* Indices of logical and range variables  */
  struct mpq_ILLlp_basis *basis;
  struct mpq_ILLlp_predata *presolve;
  struct mpq_ILLlp_sinfo *sinfo;

   /**************************************************************************/
  /* these fields are currently only set by mpq_mps.c reader fcts               */
   /**************************************************************************/
  mpq_ILLmatrix sos;                /* columns are the sets, rows are the  
                                 * problem's structural variables
                                 * coefficients are the weights */

  char *sos_type;               /* type of each set */
  int *is_sos_mem;              /* for each structural variable contains 
                                 *    -1 == not a set member
                                 *     i == member of sos set i 
                                 *          where 0 <= i < sos.matcols */
  char *refrowname;             /* name of reference row */
  int refind;                   /* index of reference row 
                                 *     -1 if refrow was a free row 
                                 *          and weights are found only in the 
                                 *          sos matrix 
                                 *     index >=0 if refrow is also a lp-row */

   /**************************************************************************
    * mpq_QSset_reporter initializes reporter 
    **************************************************************************/
  qsstring_reporter reporter;   /* used from within ILL fcts 
                                 * to report mpq_feedback */
}
mpq_ILLlpdata;

typedef struct mpq_ILLlp_basis
{
  int nstruct;
  int nrows;
  int rownorms_size;
  int colnorms_size;
  char *cstat;
  char *rstat;
  mpq_t *rownorms;
  mpq_t *colnorms;
}
mpq_ILLlp_basis;

typedef struct mpq_ILLlp_cache
{
  int nstruct;
  int nrows;
  int status;
  mpq_t val;
  mpq_t *x;
  mpq_t *pi;
  mpq_t *rc;
  mpq_t *slack;
}
mpq_ILLlp_cache;

typedef struct mpq_ILLlp_sinfo
{                               /* LP info returned by presolve            */
  int ncols;
  int nrows;
  int nzcount;
  int rowsize;
  int colsize;
  int objsense;

  mpq_t *obj;
  mpq_t *rhs;
  mpq_t *lower;
  mpq_t *upper;

  mpq_ILLmatrix A;

  char **colnames;              /* Just for debugging - not updated */
}
mpq_ILLlp_sinfo;

typedef struct mpq_ILLlp_preline
{
  mpq_t rhs;
  mpq_t obj;
  mpq_t lower;
  mpq_t upper;
  int count;
  int *ind;
  int row_or_col;               /* 0 is row, 1 is col */
  mpq_t *val;
}
mpq_ILLlp_preline;

typedef struct mpq_ILLlp_preop
{
  int ptype;
  int rowindex;
  int colindex;
  mpq_ILLlp_preline line;
}
mpq_ILLlp_preop;

typedef struct mpq_ILLlp_predata
{                               /* Data needed in un-presolve.            */
  int opcount;
  int opsize;
  mpq_ILLlp_preop *oplist;
  int r_nrows;
  int r_ncols;
  int *colmap;
  int *rowmap;
  mpq_t *rowscale;
  mpq_t *colscale;
  mpq_t *colfixval;
  mpq_t *rowfixval;
}
mpq_ILLlp_predata;

typedef struct mpq_ILLlp_rows
{
  int *rowbeg;
  int *rowcnt;
  int *rowind;
  mpq_t *rowval;
}
mpq_ILLlp_rows;


/****************************************************************************/
/*                                                                          */
/*                             mpq_lpdata.c                                     */
/*                                                                          */
/****************************************************************************/

struct mpq_qsdata *mpq_ILLread (
  mpq_qsline_reader * file,
  const char *mpq_fname,
  int isMps);
void mpq_ILLstart (
  void);              /**< initialize mpq_ILL_MAXDOUBLE and other 

                           constants, this funtion should be callef AFTER 
                           EGlpNumStart() */
void mpq_ILLend (
  void);            /**< free any internal data asociated with variable 

                         mpq_precision numbers */
void mpq_ILLchange_precision (
  void);                        /**< This function re-compute the internal 

                                     variables mpq_precision to the (previously 
                                     set) EGLPNUM_PRECISION value (done with 
                                     EGlpNumSetPrecision) */
void mpq_ILLlpdata_init (
  mpq_ILLlpdata * lp);
void mpq_ILLlpdata_free (
  mpq_ILLlpdata * lp);
void mpq_ILLlp_basis_init (
  mpq_ILLlp_basis * B);
void mpq_ILLlp_basis_free (
  mpq_ILLlp_basis * B);
void mpq_ILLlp_cache_init (
  mpq_ILLlp_cache * C);
void mpq_ILLlp_cache_free (
  mpq_ILLlp_cache * C);
int mpq_ILLlp_basis_alloc (
  mpq_ILLlp_basis * B,
  int ncols,
  int nrows);
int mpq_ILLlp_cache_alloc (
  mpq_ILLlp_cache * C,
  int ncols,
  int nrows);

int mpq_ILLlp_rows_init (
  mpq_ILLlp_rows * lp_rows,
  mpq_ILLlpdata * lp,
  int include_logicals);
void mpq_ILLlp_rows_clear (
  mpq_ILLlp_rows * lp_rows);
int mpq_ILLprint_report (
  mpq_ILLlpdata * lp,
  const char *format,
  ...);

              /* print to lp->reporter */

/****************************************************************************/
/*                                                                          */
/*                             mpq_presolve.c                                   */
/*                                                                          */
/****************************************************************************/

void mpq_ILLlp_sinfo_init (
  mpq_ILLlp_sinfo * sinfo),
  mpq_ILLlp_sinfo_free (
  mpq_ILLlp_sinfo * sinfo),
  mpq_ILLlp_predata_init (
  mpq_ILLlp_predata * pre),
  mpq_ILLlp_predata_free (
  mpq_ILLlp_predata * pre);

int mpq_ILLlp_add_logicals (
  mpq_ILLlpdata * lp),
  mpq_ILLlp_scale (
  mpq_ILLlpdata * lp),
  mpq_ILLlp_presolve (
  mpq_ILLlpdata * lp,
  int pre_types);

/* ========================================================================= */
/* if non-zero, then internal data has been initialized, and there is some
 * memory allocated, if zero, no internal memory has been allocated
 * (or it has been freed) */
extern int mpq___QSEX_SETUP;

#endif /* __ILL_LPDATA_H */
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: mpq_basis.h,v 1.3 2003/11/05 16:57:39 meven Exp $ */
#ifndef mpq___BASIS_H
#define mpq___BASIS_H


#if 0
#if EGLPNUM_TYPE != DBL_TYPE && EGLPNUM_TYPE != LDBL_TYPE
extern mpq_t mpq_CB_PRI_RLIMIT; /* = 0.25 */
extern mpq_t mpq_CB_INF_RATIO;  /* = 10.0 */
extern mpq_t mpq_CB_EPS;        /* = 0.001 */
#endif
#endif

typedef struct mpq_var_data
{
  int nartif;
  int nslacks;
  int nfree;
  int nbndone;
  int nbounded;
  int nfixed;
  mpq_t cmax;
}
mpq_var_data;

void mpq_ILLbasis_init_vardata (
  mpq_var_data * vd);
void mpq_ILLbasis_clear_vardata (
  mpq_var_data * vd);

int mpq_ILLbasis_build_basisinfo (
  mpq_lpinfo * lp),
  mpq_ILLbasis_get_initial (
  mpq_lpinfo * lp,
  int algorithm),
  mpq_ILLbasis_get_cinitial (
  mpq_lpinfo * lp,
  int algorithm),
  mpq_ILLbasis_load (
  mpq_lpinfo * lp,
  mpq_ILLlp_basis * B),
  mpq_ILLbasis_tableau_row (
  mpq_lpinfo * lp,
  int row,
  mpq_t * brow,
  mpq_t * trow,
  mpq_t * rhs,
  int strict),
  mpq_ILLbasis_factor (
  mpq_lpinfo * lp,
  int *singular),
  mpq_ILLbasis_refactor (
  mpq_lpinfo * lp),
  mpq_ILLbasis_update (
  mpq_lpinfo * lp,
  mpq_svector * y,
  int lindex,
  int *refactor,
  int *singular);

void mpq_ILLbasis_column_solve (
  mpq_lpinfo * lp,
  mpq_svector * rhs,
  mpq_svector * soln),
  mpq_ILLbasis_column_solve_update (
  mpq_lpinfo * lp,
  mpq_svector * rhs,
  mpq_svector * upd,
  mpq_svector * soln),
  mpq_ILLbasis_row_solve (
  mpq_lpinfo * lp,
  mpq_svector * rhs,
  mpq_svector * soln),
  mpq_ILLbasis_free_basisinfo (
  mpq_lpinfo * lp),
  mpq_ILLbasis_free_fbasisinfo (
  mpq_lpinfo * lp),
  mpq_ILLbasis_init_basisinfo (
  mpq_lpinfo * lp);

#endif /* mpq___BASIS_H */
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

#ifndef mpq___DHEAPS_I_H__
#define mpq___DHEAPS_I_H__
/****************************************************************************/
/*                                                                          */
/*                             mpq_dheaps_i.c                                   */
/*                                                                          */
/****************************************************************************/

typedef struct mpq_ILLdheap
{
  mpq_t *key;
  int *entry;
  int *loc;
  int total_space;
  int size;
}
mpq_ILLdheap;

void mpq_ILLutil_dheap_free (
  mpq_ILLdheap * h),
  mpq_ILLutil_dheap_delete (
  mpq_ILLdheap * h,
  int i),
  mpq_ILLutil_dheap_changekey (
  mpq_ILLdheap * h,
  int i,
  mpq_t * newkey),
  mpq_ILLutil_dheap_findmin (
  mpq_ILLdheap * h,
  int *i),
  mpq_ILLutil_dheap_deletemin (
  mpq_ILLdheap * h,
  int *i);

int mpq_ILLutil_dheap_init (
  mpq_ILLdheap * h,
  int k),
  mpq_ILLutil_dheap_resize (
  mpq_ILLdheap * h,
  int newsize),
  mpq_ILLutil_dheap_insert (
  mpq_ILLdheap * h,
  int i);



#endif
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  $RCSfile: mpq_qsopt.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $" */
#ifndef mpq___QS_QSOPT_H
#define mpq___QS_QSOPT_H


#ifdef WIN32

#ifdef QSLIB_EXPORTS
#define mpq_QSLIB_INTERFACE __declspec(dllexport)
#else
#define mpq_QSLIB_INTERFACE __declspec(dllimport)
#endif

#else
#define mpq_QSLIB_INTERFACE extern
#endif

#ifdef WIN32
typedef struct mpq_QSLIB_INTERFACE mpq_qsdata *mpq_QSprob;
typedef struct mpq_QSLIB_INTERFACE qsbasis *mpq_QSbas;
#else
typedef struct mpq_qsdata *mpq_QSprob;
typedef struct qsbasis *mpq_QSbas;
#endif

/****************************************************************************/
/*                                                                          */
/*                 PARAMETERS TO SPECIFY OBJECTIVE SENSE                    */
/*                                                                          */
/****************************************************************************/
/*
#define QS_LP_PRIMAL_FEASIBLE   11
#define QS_LP_PRIMAL_INFEASIBLE 12
#define QS_LP_PRIMAL_UNBOUNDED  13
#define QS_LP_DUAL_FEASIBLE     14
#define QS_LP_DUAL_INFEASIBLE   15
#define QS_LP_DUAL_UNBOUNDED    16
*/

/****************************************************************************/
/*                                                                          */
/*                      QSopt Library Functions                             */
/*                                                                          */
/****************************************************************************/
#ifdef  __cplusplus
extern "C"
{
#endif

#ifdef WIN32
/* 
 *  in WINDOWS we make 
 *     mpq_solver_main/mpq_reader_main part of DLL
 */
mpq_QSLIB_INTERFACE int mpq_solver_main ( int argc, char **argv);
mpq_QSLIB_INTERFACE int mpq_reader_main ( int argc, char **argv);
#endif

mpq_QSLIB_INTERFACE void mpq_QSfree ( void *ptr),
    mpq_QSfree_prob ( mpq_QSprob p),
    mpq_QSfree_basis ( mpq_QSbas B),
    mpq_QSset_precision ( const unsigned prec),/**< set the mpq_precision for floating 
                                                 point numbers to the given 
                                                 number of bits */
    mpq_QSstart ( void),/**< whe we use non native numbers, we need to make 
                         some initializations before operating with the
                         library */
    mpq_QSend ( void);  /**< just to free any internal static data needed by
                         the variable mpq_precision numbers */

mpq_QSLIB_INTERFACE int mpq_QSopt_primal ( mpq_QSprob p, int *status),
    mpq_QSopt_dual ( mpq_QSprob p, int *status),
    mpq_QSopt_pivotin_col ( mpq_QSprob p, int ccnt, int *clist),
    mpq_QSopt_pivotin_row ( mpq_QSprob p, int rcnt, int *rlist),
    mpq_QSopt_strongbranch ( mpq_QSprob p, int ncand, int *candidatelist,
      mpq_t * xlist, mpq_t * down_vals, mpq_t * up_vals,
      int iterations, mpq_t objbound),
    mpq_QSchange_objsense ( mpq_QSprob p, int newsense),
    mpq_QSget_objsense ( mpq_QSprob p, int *newsense),
    mpq_QSnew_col ( mpq_QSprob p,const mpq_t obj,const mpq_t lower,const mpq_t upper,
      const char *name),
    mpq_QSadd_cols ( mpq_QSprob p, int num, int *cmatcnt, int *cmatbeg, int *cmatind,
      mpq_t * cmatval, mpq_t * obj, mpq_t * lower,
      mpq_t * upper, const char **names),
    mpq_QSadd_col ( mpq_QSprob p, int cnt, int *cmatind, mpq_t * cmatval,
      mpq_t obj, mpq_t lower, mpq_t upper, const char *name),
    mpq_QSnew_row ( mpq_QSprob p,const mpq_t rhs, int sense, const char *name),
    mpq_QSadd_ranged_rows ( mpq_QSprob p, int num, int *rmatcnt, int *rmatbeg, 
      int *rmatind,const mpq_t * rmatval,const mpq_t * rhs, char *sense,
      const mpq_t* range, const char **names),
    mpq_QSadd_ranged_row ( mpq_QSprob p, int cnt, int *rmatind,const mpq_t * rmatval,
      const mpq_t * rhs, int sense,const mpq_t * range, const char *name),
    mpq_QSadd_rows ( mpq_QSprob p, int num, int *rmatcnt, int *rmatbeg, int *rmatind,
      const mpq_t * rmatval,const mpq_t * rhs, char *sense, const char **names),
    mpq_QSadd_row ( mpq_QSprob p, int cnt, int *rmatind,const mpq_t * rmatval,
      const mpq_t * rhs, int sense, const char *name),
    mpq_QSdelete_rows ( mpq_QSprob p, int num, int *dellist),
    mpq_QSdelete_row ( mpq_QSprob p, int rowindex),
    mpq_QSdelete_setrows ( mpq_QSprob p, int *flags),
    mpq_QSdelete_named_row ( mpq_QSprob p, const char *rowname),
    mpq_QSdelete_named_rows_list ( mpq_QSprob p, int num, const char **rownames),
    mpq_QSdelete_cols ( mpq_QSprob p, int num, int *dellist),
    mpq_QSdelete_col ( mpq_QSprob p, int colindex),
    mpq_QSdelete_setcols ( mpq_QSprob p, int *flags),
    mpq_QSdelete_named_column ( mpq_QSprob p, const char *colname),
    mpq_QSdelete_named_columns_list ( mpq_QSprob p, int num, const char **colnames),
    mpq_QSchange_senses ( mpq_QSprob p, int num, int *rowlist, char *sense),
    mpq_QSchange_sense ( mpq_QSprob p, int rowindex, int sense),
    mpq_QSchange_coef ( mpq_QSprob p, int rowindex, int colindex, mpq_t coef),
    mpq_QSchange_objcoef ( mpq_QSprob p, int indx, mpq_t coef),
    mpq_QSchange_rhscoef ( mpq_QSprob p, int indx, mpq_t coef),
    mpq_QSchange_range(mpq_QSprob p, int rowindex, mpq_t range),
    mpq_QSchange_bounds ( mpq_QSprob p, int num, int *collist, char *lu, 
      const mpq_t * bounds),
    mpq_QSchange_bound ( mpq_QSprob p, int indx, int lu,const mpq_t bound),
    mpq_QSload_basis ( mpq_QSprob p, mpq_QSbas B),
    mpq_QSread_and_load_basis ( mpq_QSprob p, const char *filename),
    mpq_QSload_basis_array ( mpq_QSprob p, char *cstat, char *rstat),
    mpq_QSload_basis_and_row_norms_array ( mpq_QSprob p, char *cstat, char *rstat, 
      mpq_t * rownorms),
    mpq_QSget_basis_array ( mpq_QSprob p, char *cstat, char *rstat),
    mpq_QSget_basis_and_row_norms_array ( mpq_QSprob p, char *cstat, char *rstat,
      mpq_t * rownorms),
    mpq_QSget_binv_row ( mpq_QSprob p, int indx, mpq_t * binvrow),
    mpq_QSget_tableau_row ( mpq_QSprob p, int indx, mpq_t * tableaurow),
    mpq_QSget_basis_order ( mpq_QSprob p, int *basorder), 
    mpq_QSget_coef (mpq_QSprob p, int rowindex, int colindex, mpq_t*coef),
    mpq_QSget_status ( mpq_QSprob p, int *status),
    mpq_QSget_solution ( mpq_QSprob p, mpq_t * value, mpq_t * x,
      mpq_t * pi, mpq_t * slack, mpq_t * rc),
    mpq_QSget_objval ( mpq_QSprob p, mpq_t * value),
    mpq_QSget_pi_array ( mpq_QSprob p, mpq_t * pi),
    mpq_QSget_rc_array ( mpq_QSprob p, mpq_t * rc),
    mpq_QSget_x_array ( mpq_QSprob p, mpq_t * x),
    mpq_QSget_slack_array ( mpq_QSprob p, mpq_t * slack),
    mpq_QSget_infeas_array ( mpq_QSprob p, mpq_t * pi),
    mpq_QSget_colcount ( mpq_QSprob p),
    mpq_QSget_rowcount ( mpq_QSprob p),
    mpq_QSget_nzcount ( mpq_QSprob p),
    mpq_QSget_obj_list(mpq_QSprob p, int num, int*collist, mpq_t*obj),
    mpq_QSget_obj ( mpq_QSprob p, mpq_t * obj),
    mpq_QSget_rhs ( mpq_QSprob p, mpq_t * rhs),
    mpq_QSget_ranged_rows_list ( mpq_QSprob p, int num, int *rowlist, int **rowcnt,
      int **rowbeg, int **rowind, mpq_t ** rowval, mpq_t ** rhs,
      char **sense, mpq_t **range, char ***names),
    mpq_QSget_ranged_rows ( mpq_QSprob p, int **rowcnt, int **rowbeg, int **rowind,
      mpq_t ** rowval, mpq_t ** rhs, char **sense, 
      mpq_t ** range, char ***names),
    mpq_QSget_senses ( mpq_QSprob p, char*senses),
    mpq_QSget_rows_list ( mpq_QSprob p, int num, int *rowlist, int **rowcnt,
      int **rowbeg, int **rowind, mpq_t ** rowval, mpq_t ** rhs,
      char **sense, char ***names),
    mpq_QSget_rows ( mpq_QSprob p, int **rowcnt, int **rowbeg, int **rowind,
      mpq_t ** rowval, mpq_t ** rhs, char **sense, char ***names),
    mpq_QSget_columns_list ( mpq_QSprob p, int num, int *collist, int **colcnt,
      int **colbeg, int **colind, mpq_t ** colval, mpq_t ** obj,
      mpq_t ** lower, mpq_t ** upper, char ***names),
    mpq_QSget_columns ( mpq_QSprob p, int **colcnt, int **colbeg, int **colind,
      mpq_t ** colval, mpq_t ** obj, mpq_t ** lower,
      mpq_t ** upper, char ***names),
    mpq_QSget_rownames ( mpq_QSprob p, char **rownames),
    mpq_QSget_colnames ( mpq_QSprob p, char **colnames),
    mpq_QSget_bound ( mpq_QSprob p, int colindex, int lu, mpq_t * bound),
    mpq_QSget_bounds ( mpq_QSprob p, mpq_t * lower, mpq_t * upper),
    mpq_QSget_bounds_list(mpq_QSprob p, int num, int*collist, mpq_t*lb,
      mpq_t*ub),
    mpq_QSget_intflags ( mpq_QSprob p, int *intflags),
    mpq_QSget_intcount ( mpq_QSprob p, int *count),
    mpq_QSget_column_index ( mpq_QSprob p, const char *name, int *colindex),
    mpq_QSget_row_index ( mpq_QSprob p, const char *name, int *rowindex),
    mpq_QSget_named_x ( mpq_QSprob p, const char *colname, mpq_t * val),
    mpq_QSget_named_rc ( mpq_QSprob p, const char *colname, mpq_t * val),
    mpq_QSget_named_pi ( mpq_QSprob p, const char *rowname, mpq_t * val),
    mpq_QSget_named_slack ( mpq_QSprob p, const char *rowname, mpq_t * val),
    mpq_QScompute_row_norms ( mpq_QSprob p),
    mpq_QSwrite_prob ( mpq_QSprob p, const char *filename, const char *filetype),
    mpq_QSwrite_prob_file ( mpq_QSprob p, FILE * file, const char *filetype),
    mpq_QSwrite_basis ( mpq_QSprob p, mpq_QSbas B, const char *filename),
    mpq_QStest_row_norms ( mpq_QSprob p),
    mpq_QSget_itcnt(mpq_QSprob p, int *pI_iter, int *pII_iter, int *dI_iter,
      int *dII_iter, int *tot_iter),
    mpq_QSset_param ( mpq_QSprob p, int whichparam, int newvalue),
    mpq_QSset_param_EGlpNum ( mpq_QSprob p, int whichparam, mpq_t newvalue),
    mpq_QSget_param ( mpq_QSprob p, int whichparam, int *value),
    mpq_QSget_param_EGlpNum ( mpq_QSprob p, int whichparam, mpq_t * value); 

mpq_QSLIB_INTERFACE char *mpq_QSget_probname ( mpq_QSprob p);
mpq_QSLIB_INTERFACE char *mpq_QSget_objname ( mpq_QSprob p);
mpq_QSLIB_INTERFACE char *mpq_QSversion ( void);

mpq_QSLIB_INTERFACE mpq_QSprob mpq_QScreate_prob ( const char *name, int objsense),
    mpq_QSread_prob ( const char *filename, const char *filetype),
    mpq_QSload_prob ( const char *probname, int ncols, int nrows, int *cmatcnt,
      int *cmatbeg, int *cmatind, mpq_t * cmatval, int objsense,
      mpq_t * obj, mpq_t * rhs, char *sense, mpq_t * lower,
      mpq_t * upper, const char **colnames, const char **rownames),
    mpq_QScopy_prob ( mpq_QSprob p, const char *newname);

mpq_QSLIB_INTERFACE mpq_QSbas mpq_QSget_basis ( mpq_QSprob p),
    mpq_QSread_basis ( mpq_QSprob p, const char *filename);

#ifdef  __cplusplus
}
#endif

/****************************************************************************
 *
 * This is the undocumented part of the QSlib interface 
 *
 ****************************************************************************/
/* 
 * functions to facilitate line by line reading from other sources than 
 * files from within MPS/LP parsers  
 * 
 * functions to facilitate the collection of error information instead of 
 * having the parsers print messages to stderr
 *                              by mps/lp format writers
 * 
 * a problem's reporter is used by the solver code to provide important 
 * mpq_feedback/progress information
 */

#ifdef WIN32
typedef struct mpq_QSLIB_INTERFACE mpq_qsline_reader *mpq_QSline_reader;
typedef struct mpq_QSLIB_INTERFACE mpq_qsformat_error *mpq_QSformat_error;
typedef struct mpq_QSLIB_INTERFACE mpq_qserror_collector *mpq_QSerror_collector;
typedef struct mpq_QSLIB_INTERFACE mpq_qserror_memory *mpq_QSerror_memory;
#else
typedef struct mpq_qsline_reader *mpq_QSline_reader;
typedef struct mpq_qsformat_error *mpq_QSformat_error;
typedef struct mpq_qserror_collector *mpq_QSerror_collector;
typedef struct mpq_qserror_memory *mpq_QSerror_memory;
#endif

#ifdef  __cplusplus
extern "C"
{
#endif
  mpq_QSLIB_INTERFACE const char *mpq_QSformat_error_type_string (
  int tp);

  mpq_QSLIB_INTERFACE int mpq_QSerror_get_type (
  mpq_QSformat_error error);
  mpq_QSLIB_INTERFACE const char *mpq_QSerror_get_desc (
  mpq_QSformat_error error);
  mpq_QSLIB_INTERFACE int mpq_QSerror_get_line_number (
  mpq_QSformat_error error);
  mpq_QSLIB_INTERFACE int mpq_QSerror_get_pos (
  mpq_QSformat_error error);
  mpq_QSLIB_INTERFACE const char *mpq_QSerror_get_line (
  mpq_QSformat_error error);
  mpq_QSLIB_INTERFACE void mpq_QSerror_print (
  FILE * f,
  mpq_QSformat_error error);

  mpq_QSLIB_INTERFACE mpq_QSerror_collector mpq_QSerror_collector_new (
  void *fct,
  void *dest);
  mpq_QSLIB_INTERFACE mpq_QSerror_collector mpq_QSerror_memory_collector_new (
  mpq_QSerror_memory mem);
  mpq_QSLIB_INTERFACE void mpq_QSerror_collector_free (
  mpq_QSerror_collector c);

/****************************************************************************
 * line reader 
 */
  mpq_QSLIB_INTERFACE mpq_QSline_reader mpq_QSline_reader_new (
  void *fct,
  void *data_src);
  /* reader->read_line_fct defaults to fgets */

  mpq_QSLIB_INTERFACE void mpq_QSline_reader_free (
  mpq_QSline_reader reader);

  mpq_QSLIB_INTERFACE void mpq_QSline_reader_set_error_collector (
  mpq_QSline_reader reader,
  mpq_QSerror_collector collector);

  mpq_QSLIB_INTERFACE char *mpq_QSline_reader_get (
  mpq_QSline_reader reader,
  char *s,
  int size);

  mpq_QSLIB_INTERFACE mpq_QSprob mpq_QSget_prob (
  mpq_QSline_reader reader,
  const char *probname,
  const char *filetype);
  /* the MPS and LP parsers uses the fct from reader 
   * to get to next input line */


/****************************************************************************
 * error memory 
 */
  mpq_QSLIB_INTERFACE mpq_QSerror_memory mpq_QSerror_memory_create (
  int takeErrorLines);
  mpq_QSLIB_INTERFACE void mpq_QSerror_memory_free (
  mpq_QSerror_memory mem);

  mpq_QSLIB_INTERFACE int mpq_QSerror_memory_get_nof (
  mpq_QSerror_memory mem,
  int error_type);
  mpq_QSLIB_INTERFACE int mpq_QSerror_memory_get_nerrors (
  mpq_QSerror_memory mem);

  mpq_QSLIB_INTERFACE mpq_QSformat_error mpq_QSerror_memory_get_last_error (
  mpq_QSerror_memory mem);
  mpq_QSLIB_INTERFACE mpq_QSformat_error mpq_QSerror_memory_get_prev_error (
  mpq_QSformat_error e);

/**************************************************************************** 
 * reporter for solver mpq_feedback 
 */
  mpq_QSLIB_INTERFACE void mpq_QSset_reporter (
  mpq_QSprob prob,
  int iterskip,
  void *fct,
  void *dest);

  mpq_QSLIB_INTERFACE int mpq_QSreport_prob (
  mpq_QSprob p,
  const char *filetype,
  mpq_QSerror_collector c);

#ifdef  __cplusplus
}
#endif
#endif                          /* mpq___QS_QSOPT_H */
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: mpq_format.h,v 1.3 2003/11/05 16:59:48 meven Exp $ */
#ifndef mpq_QS_FORMAT_ERROR_H
#define mpq_QS_FORMAT_ERROR_H


/****************************************************************************/
/*
   The LP/MPS readers, writers, 
       mpq_ILLrawlpdata_to_lpdata, and 
   use mpq_ILLformat_error to report problems with their input iff
       the line reader used in reading the problem  or 
       the  mpq_qserror_collector pointer passed to mpq_ILLwrite_lp_file
   is not NULL.

   The QSgui code uses this feature to collect mpq_qsformat_error instances 
   which it uses after reading is done to insert error messages into the 
   input window. 
*/
/****************************************************************************/

/* 
for error type USE: 
          QS_DATA_ERROR     
          QS_DATA_WARN      
          QS_MPS_FORMAT_ERROR   
          QS_MPS_FORMAT_WARN    
          QS_LP_FORMAT_ERROR    
          QS_LP_FORMAT_WARN   
          QS_LP_OBJ_WARN      
          QS_GENERIC_ERROR    
*/

typedef struct mpq_qsformat_error
{
  char *desc;
  char *theLine;
  struct mpq_qsformat_error *next;
  int type;
  int lineNumber;               /* 1 based line counting */
  int at;
}
mpq_qsformat_error;

extern int mpq_ILLformat_error_create (
  mpq_qsformat_error * error,
  int mode,
  const char *desc,
  int lineNum,
  const char *theLine,
  int atPos);
extern void mpq_ILLformat_error_delete (
  mpq_qsformat_error * error);

extern void mpq_ILLformat_error_print (
  EGioFile_t * out,
  mpq_qsformat_error * e);



/*****************************************************************************
 * collecting error messages 
 * either with defining own qsad_error_fct and corresponding data structure 
 * or by using predefined mpq_ILLadd_error_to_memory fct with mpq_qserror_memory
 */

typedef int (
  *mpq_qsadd_error_fct) (
  void *dest,
  const mpq_qsformat_error * error);

typedef struct mpq_qserror_collector
{
  mpq_qsadd_error_fct add_error;
  void *dest;
}
mpq_qserror_collector;

typedef struct mpq_qserror_memory
{
  unsigned int nerror;
  mpq_qsformat_error *error_list;
  char has_error[QS_INPUT_NERROR];
  char hasErrorLines;
}
mpq_qserror_memory;


extern mpq_qserror_collector *mpq_ILLerror_collector_new (
  mpq_qsadd_error_fct fct,
  void *dest);

mpq_qserror_collector *mpq_ILLerror_memory_collector_new (
  mpq_qserror_memory * dest);

extern void mpq_ILLerror_collector_free (
  mpq_qserror_collector * c);

#define mpq_ILLformat_error(collector, error)  \
  ((collector)->add_error((collector)->dest, error))


extern int mpq_ILLadd_error_to_memory (
  void *dest,
  const mpq_qsformat_error * error);

extern mpq_qserror_memory *mpq_ILLerror_memory_create (
  int takeErrorLines);
extern void mpq_ILLerror_memory_free (
  mpq_qserror_memory * mem);

#endif
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  RCS_INFO = "$RCSfile: mpq_rawlp.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $"; */
#ifndef mpq___ILL_RAWLP_H_
#define mpq___ILL_RAWLP_H_

/****************************************************************************/
/* DataStructure and Routines                                               */
/*          to deal with raw lp information as read from mps or lp files    */
/*          support scanning of input                                       */
/*          error reporting                                                 */
/****************************************************************************/


#define mpq_ILL_ISBLANK(p) \
             (((*(p))==' '||(*(p))=='\t'||(*(p))=='\r'||(*(p))=='\f') ? 1 : 0)

/* 
 * we rely on ILLsymboltab property:
 *   the ith name added can be retrieved by ILLsymboltab_get(table, i) 
 *   as long as we never delete names from the symbol table 
 */
typedef struct mpq_rawlpdata
{
  char *name;

  char *rhsname;
  char *rangesname;
  char *boundsname;

  int objsense;                 /* maximize or minimize */
  int objindex;                 /* index of objective row */

  int nrows;                    /* number of rows in problem */
  ILLsymboltab rowtab;          /* ILLsymboltab_get(rowtab, i) name of ith row */

  int sensesize;                /* size of rowsense */
  char *rowsense;               /* rowsense[i] snese of row[i] */

  char *rhsind;                 /* rhsind[i] == 1 we saw an rhs for row[i] */
  /* size is nrows */
  int rhssize;                  /* size of rhs array */
  mpq_t *rhs;               /* rhs values for rows; size is nrows */
  char *rangesind;              /* ranges[i] == 1 we saw a range def for row[i] */
  struct mpq_colptr *ranges;        /* list of range values */

  int ncols;                    /* number of cols in problem */
  ILLsymboltab coltab;          /* ILLsymboltab_get(coltab, i) name of ith col */
  int colsize;                  /* size of cols array */
  struct mpq_colptr **cols;

  char *lbind;                  /* lbind[i] == 1  we saw a lower bound for col[i] */
  char *ubind;                  /* ubind[i] == 1  we saw a upper bound for col[i] */
  mpq_t *lower;             /* lower[i] = lower bound for col[i] */
  mpq_t *upper;             /* upper[i] = upper bound for col[i] */

  int intsize;                  /* size of intmarker array */
  char *intmarker;              /* intmarker[i] == 1  col[i] is an int var */

  /* sos information is tranfered into mpq_ILLmatrix lpdata->sos */
  char *refrow;                 /* name of reference row */
  int refrowind;                /* index of refrow or -1  */

  int is_sos_size;              /* size of is_sos_member array */
  int *is_sos_member;           /* for each col contains either               
                                 *     -1 == no sos memeber 
                                 *     i  == member of set #i */

  int nsos_member;              /* total number of sos set members */
  int sos_weight_size;          /* size of sos_weight array */
  mpq_t *sos_weight;        /* sos set elem i has weight of sos_weight[i] 
                                 * value comes from refrow coeficients */
  int sos_col_size;             /* size of sos_col array */
  int *sos_col;                 /* sos elem i is column sos_col[i] */

  int nsos;                     /* number of sos sets */
  int sos_setsize;              /* size of sosset array */
  struct mpq_sosptr *sos_set;       /* type, size, first element of sos sets 
                                 * first is index into sos_weight and sos_col 
                                 * arrays */
  mpq_qserror_collector *error_collector;
  ILLptrworld ptrworld;
}
mpq_rawlpdata;

typedef struct mpq_colptr
{
  mpq_t coef;
  struct mpq_colptr *next;
  int this_val;                     /* row index */
}
mpq_colptr;
extern mpq_colptr *mpq_ILLcolptralloc (
  ILLptrworld * p);

typedef struct mpq_sosptr
{
  int nelem;                    /* number of set elements */
  int first;                    /* index of first set element in sosmemeber */
  char type;                    /* set type */
}
mpq_sosptr;
extern const int mpq_ILL_SOS_TYPE1;
extern const int mpq_ILL_SOS_TYPE2;

extern void mpq_ILLinit_rawlpdata (
  mpq_rawlpdata * lp,
  mpq_qserror_collector * collector);
extern void mpq_ILLfree_rawlpdata (
  mpq_rawlpdata * lp);
extern void mpq_ILLraw_clear_matrix (
  mpq_rawlpdata * lp);

extern const char *mpq_ILLraw_rowname (
  mpq_rawlpdata * lp,
  int i);
extern const char *mpq_ILLraw_colname (
  mpq_rawlpdata * lp,
  int i);

extern int mpq_ILLraw_add_col (
  mpq_rawlpdata * lp,
  const char *name,
  int intmarker);
extern int mpq_ILLraw_add_row (
  mpq_rawlpdata * lp,
  const char *name,
  int sense,
  const mpq_t rhs);

extern int mpq_ILLraw_add_col_coef (
  mpq_rawlpdata * lp,
  int colind,
  int rowind,
  mpq_t coef);

extern int mpq_ILLraw_init_ranges (
  mpq_rawlpdata * lp);
extern int mpq_ILLraw_init_rhs (
  mpq_rawlpdata * lp);

extern int mpq_ILLraw_add_ranges_coef (
  mpq_rawlpdata * lp,
  int rowind,
  mpq_t coef);


extern int mpq_ILLraw_add_sos (
  mpq_rawlpdata * lp,
  int sos_type);

                                                /* add empty set with type */
extern int mpq_ILLraw_add_sos_member (
  mpq_rawlpdata * lp,
  int colind);

                                                /* add col to last set */
extern int mpq_ILLraw_is_mem_other_sos (
  mpq_rawlpdata * lp,
  int colind);

extern int mpq_ILLraw_set_rhs_name (
  mpq_rawlpdata * lp,
  const char *name,
  int *skip);
extern int mpq_ILLraw_set_bounds_name (
  mpq_rawlpdata * lp,
  const char *name,
  int *skip);
extern int mpq_ILLraw_set_ranges_name (
  mpq_rawlpdata * lp,
  const char *name,
  int *skip);
extern void mpq_ILLprint_rawlpdata (
  mpq_rawlpdata * lp);

extern char *mpq_ILLraw_unique_name (
  ILLsymboltab * tab,
  char *prefix,
  int i);
extern int mpq_ILLraw_fill_in_rownames (
  mpq_rawlpdata * lp);

extern int mpq_ILLraw_init_bounds (
  mpq_rawlpdata * lp);

extern const char *mpq_ILLraw_set_lowerBound (
  mpq_rawlpdata * lp,
  int i,
  mpq_t bnd);
extern const char *mpq_ILLraw_set_upperBound (
  mpq_rawlpdata * lp,
  int i,
  mpq_t bnd);
extern const char *mpq_ILLraw_set_fixedBound (
  mpq_rawlpdata * lp,
  int i,
  mpq_t bnd);
extern const char *mpq_ILLraw_set_binaryBound (
  mpq_rawlpdata * lp,
  int i);
extern const char *mpq_ILLraw_set_unbound (
  mpq_rawlpdata * lp,
  int colind);
extern int mpq_ILLraw_fill_in_bounds (
  mpq_rawlpdata * lp);

extern int mpq_ILLraw_first_nondefault_bound (
  mpq_ILLlpdata * lp);
extern int mpq_ILLraw_default_lower (
  mpq_ILLlpdata * lp,
  int i);
extern int mpq_ILLraw_default_upper (
  mpq_ILLlpdata * lp,
  int i,
  int ri);

extern int mpq_ILLrawlpdata_to_lpdata (
  mpq_rawlpdata * raw,
  mpq_ILLlpdata * lp);

extern int mpq_ILLdata_error (
  mpq_qserror_collector * collector,
  const char *format,
  ...);
extern void mpq_ILLdata_warn (
  mpq_qserror_collector * collector,
  const char *format,
  ...);

#endif
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: mpq_mps.h,v 1.2 2003/11/05 16:57:39 meven Exp $ */
#ifndef mpq_MPS_H
#define mpq_MPS_H


/****************************************************************************/
/*                                                                          */
/*              Routines to support Reading and Writing MPS Files           */
/*                                                                          */
/****************************************************************************/
extern const char *mpq_ILLmps_section_name[ILL_MPS_N_SECTIONS + 2];


extern int mpq_ILLread_mps (
  mpq_qsline_reader * file,
  const char *filename,
  mpq_rawlpdata * lp);

extern int mpq_ILLwrite_mps (
  mpq_ILLlpdata * lp,
  mpq_qserror_collector * collector);

        /* use lp->reporter for output */

#endif
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  $RCSfile: mpq_price.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $" */
#ifndef mpq___PRICE_H
#define mpq___PRICE_H


typedef struct mpq_price_res
{
  int eindex;
  int dir;
  int lindex;
  int lvstat;
  int price_stat;
  mpq_t dinfeas;
  mpq_t pinfeas;
}
mpq_price_res;

int mpq_ILLprice_test_for_heap (
  mpq_lpinfo * const lp,
  mpq_price_info * const pinf,
  int const nkeys,
  mpq_t * keylist,
  int const algo,
  int const upd),
  mpq_ILLprice_build_heap (
  mpq_price_info * const pinf,
  int const nkeys,
  mpq_t * keylist),
  mpq_ILLprice_build_pricing_info (
  mpq_lpinfo * const lp,
  mpq_price_info * const pinf,
  int const phase),
  mpq_ILLprice_update_pricing_info (
  mpq_lpinfo * const lp,
  mpq_price_info * const pinf,
  int const phase,
  mpq_svector * const wz,
  int const eindex,
  int const lindex,
  mpq_t y),
  mpq_ILLprice_get_price (
  mpq_price_info * const p,
  int const phase),
  mpq_ILLprice_build_mpartial_info (
  mpq_lpinfo * const lp,
  mpq_price_info * const pinf,
  int const pricetype),
  mpq_ILLprice_build_pdevex_norms (
  mpq_lpinfo * const lp,
  mpq_p_devex_info * const pdinfo,
  int const reinit),
  mpq_ILLprice_update_pdevex_norms (
  mpq_lpinfo * const lp,
  mpq_p_devex_info * const pdinfo,
  int const eindex,
  mpq_t yl),
  mpq_ILLprice_build_psteep_norms (
  mpq_lpinfo * const lp,
  mpq_p_steep_info * const psinfo),
  mpq_ILLprice_build_ddevex_norms (
  mpq_lpinfo * const lp,
  mpq_d_devex_info * const ddinfo,
  int const reinit),
  mpq_ILLprice_update_ddevex_norms (
  mpq_lpinfo * const lp,
  mpq_d_devex_info * const ddinfo,
  int const eindex,
  mpq_t yl),
  mpq_ILLprice_build_dsteep_norms (
  mpq_lpinfo * const lp,
  mpq_d_steep_info * const dsinfo),
  mpq_ILLprice_get_dsteep_norms (
  mpq_lpinfo * const lp,
  int const count,
  int *constrowind,
  mpq_t * const norms),
  mpq_ILLprice_get_rownorms (
  mpq_lpinfo * const lp,
  mpq_price_info * const pinf,
  mpq_t * const rnorms),
  mpq_ILLprice_get_colnorms (
  mpq_lpinfo * const lp,
  mpq_price_info * const pinf,
  mpq_t * const cnorms),
  mpq_ILLprice_get_newnorms (
  mpq_lpinfo * const lp,
  int const nelems,
  mpq_t * const norms,
  int *const matcnt,
  int *const matbeg,
  int *const matind,
  mpq_t * const matval,
  int const option),
  mpq_ILLprice_get_new_rownorms (
  mpq_lpinfo * const lp,
  int const newrows,
  mpq_t * const rnorms,
  int *const rmatcnt,
  int *const rmatbeg,
  int *const rmatind,
  mpq_t * const rmatval),
  mpq_ILLprice_get_new_colnorms (
  mpq_lpinfo * const lp,
  int const newrows,
  mpq_t * const rnorms,
  int *const matcnt,
  int *const matbeg,
  int *const matind,
  mpq_t * const matval),
  mpq_ILLprice_load_rownorms (
  mpq_lpinfo * const lp,
  mpq_t * const rnorms,
  mpq_price_info * const pinf),
  mpq_ILLprice_load_colnorms (
  mpq_lpinfo * const lp,
  mpq_t * const cnorms,
  mpq_price_info * const pinf);


void mpq_ILLprice_free_heap (
  mpq_price_info * const pinf),
  mpq_ILLprice_init_pricing_info (
  mpq_price_info * const pinf),
  mpq_ILLprice_free_pricing_info (
  mpq_price_info * const pinf),
  mpq_ILLprice_free_mpartial_info (
  mpq_mpart_info * p),
  mpq_ILLprice_init_mpartial_price (
  mpq_lpinfo * const lp,
  mpq_price_info * const pinf,
  int const phase,
  int const pricetype),
  mpq_ILLprice_update_mpartial_price (
  mpq_lpinfo * const lp,
  mpq_price_info * const pinf,
  int const phase,
  int const pricetype),
  mpq_ILLprice_delete_onempart_price (
  /*mpq_lpinfo * const lp,*/
  mpq_price_info * const pinf,
  int const indx,
  int const pricetype),
  mpq_ILLprice_mpartial_group (
  mpq_lpinfo * const lp,
  mpq_mpart_info * const p,
  int const phase,
  int const g,
  int const pricetype),
  mpq_ILLprice_column (
  mpq_lpinfo * const lp,
  int const ix,
  int const phase,
  mpq_price_res * const pr),
  mpq_ILLprice_row (
  mpq_lpinfo * const lp,
  int const ix,
  int const phase,
  mpq_price_res * const pr),
  mpq_ILLprice_update_psteep_norms (
  mpq_lpinfo * lp,
  mpq_p_steep_info * psinfo,
  mpq_svector * wz,
  int eindex,
  mpq_t yl),
  mpq_ILLprice_update_dsteep_norms (
  mpq_lpinfo * const lp,
  mpq_d_steep_info * const dsinfo,
  mpq_svector * const wz,
  int const lindex,
  mpq_t yl),
  mpq_ILLprice_compute_dual_inf (
  mpq_lpinfo * const lp,
  mpq_price_info * const p,
  int *const ix,
  int const icnt,
  int const phase),
  mpq_ILLprice_primal (
  mpq_lpinfo * const lp,
  mpq_price_info * const pinf,
  mpq_price_res * const pr,
  int const phase),
  mpq_ILLprice_compute_primal_inf (
  mpq_lpinfo * const lp,
  mpq_price_info * const p,
  int *const ix,
  int const icnt,
  int const phase),
  mpq_ILLprice_dual (
  mpq_lpinfo * const lp,
  mpq_price_info * const pinf,
  int const phase,
  mpq_price_res * const pr);

void mpq_test_dsteep_norms (
  mpq_lpinfo * const lp,
  mpq_price_info * const p);

#endif /* mpq___PRICE_H */
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

#ifndef mpq___PRIORITY_H__
#define mpq___PRIORITY_H__
/****************************************************************************/
/*                                                                          */
/*                             mpq_priority.c                                   */
/*                                                                          */
/****************************************************************************/

typedef struct mpq_ILLpriority
{
  mpq_ILLdheap mpq_heap;
  union mpq_ILLpri_data
  {
    void *data;
    int next;
  }
   *pri_info;
  int space;
  int freelist;
}
mpq_ILLpriority;

void mpq_ILLutil_priority_free (
  mpq_ILLpriority * pri),
  mpq_ILLutil_priority_delete (
  mpq_ILLpriority * pri,
  int handle),
  mpq_ILLutil_priority_changekey (
  mpq_ILLpriority * pri,
  int handle,
  mpq_t * newkey),
  mpq_ILLutil_priority_findmin (
  mpq_ILLpriority * pri,
  mpq_t * keyval,
  void **en),
  mpq_ILLutil_priority_deletemin (
  mpq_ILLpriority * pri,
  mpq_t * keyval,
  void **en);

int mpq_ILLutil_priority_init (
  mpq_ILLpriority * pri,
  int k),
  mpq_ILLutil_priority_insert (
  mpq_ILLpriority * pri,
  void *data,
  mpq_t * keyval,
  int *handle);



#endif
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  $RCSfile: mpq_ratio.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $" */
#ifndef mpq___RATIO_H
#define mpq___RATIO_H
typedef struct mpq_ratio_res
{
  mpq_t tz;
  int eindex;
  int lindex;
  int lvstat;
  int ratio_stat;
  int boundch;
  int coeffch;
  mpq_t lbound;
  mpq_t ecoeff;
  mpq_t pivotval;
}
mpq_ratio_res;

void mpq_ILLratio_pI_test (
  mpq_lpinfo * const lp,
  int const eindex,
  int const dir,
  mpq_ratio_res * const rs),
  mpq_ILLratio_pII_test (
  mpq_lpinfo * const lp,
  int const eindex,
  int const dir,
  mpq_ratio_res * const rs),
  mpq_ILLratio_dI_test (
  mpq_lpinfo * const lp,
  int const lindex,
  int const lvstat,
  mpq_ratio_res * const rs),
  mpq_ILLratio_dII_test (
  mpq_lpinfo * const lp,
  /*int const lindex,*/
  int const lvstat,
  mpq_ratio_res * const rs),
  mpq_ILLratio_longdII_test (
  mpq_lpinfo * const lp,
  int const lindex,
  int const lvstat,
  mpq_ratio_res * const rs),
  mpq_ILLratio_pivotin_test (
  mpq_lpinfo * const lp,
  int *const rlist,
  int const rcnt,
  mpq_ratio_res * const rs);

#endif /* mpq___RATIO_H */
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  RCS_INFO = "$RCSfile: read_lp_state.h,v $ $Revision: 1.2 $ $Date: 2003/11/05 16:57:39 $"; */
#ifndef mpq_READ_LP_STATE_H
#define mpq_READ_LP_STATE_H

/****************************************************************************/
/*                                                                          */
/*               Routines to support Reading LP Files                       */
/*                                                                          */
/****************************************************************************/

/* 
 * -) anything after '\' is comment 
 * -) variables consist of a-z A-Z 0-9!"#$%(),;.?@_`'{}|~ 
 *    don't start with a digit or '.'
 */


typedef struct mpq_ILLread_lp_state
{
  mpq_qsline_reader *file;
  const char *file_name;
  char *p;
  mpq_t bound_val;
  int mpq_interactive;
  int line_num;
  int column_index;
  char realline[ILL_namebufsize];
  char line[ILL_namebufsize];
  char field[ILL_namebufsize + 1];
  char fieldOnFirstCol;
  char eof;
  char sense_val;
}
mpq_ILLread_lp_state;

extern int mpq_ILLread_lp_state_init (
  mpq_ILLread_lp_state * state,
  mpq_qsline_reader * file,
  const char *mpq_fname,
  int interactve);
extern int mpq_ILLread_lp_state_next_line (
  mpq_ILLread_lp_state * state);
extern int mpq_ILLread_lp_state_next_var (
  mpq_ILLread_lp_state * state);
extern int mpq_ILLread_lp_state_keyword (
  mpq_ILLread_lp_state * state,
  const char **kwd);
extern int mpq_ILLread_lp_state_bad_keyword (
  mpq_ILLread_lp_state * state);
extern int mpq_ILLtest_lp_state_keyword (
  mpq_ILLread_lp_state * state,
  const char *kwd[]);
extern int mpq_ILLread_lp_state_next_field (
  mpq_ILLread_lp_state * state);
extern int mpq_ILLread_lp_state_next_field_on_line (
  mpq_ILLread_lp_state * state);
extern void mpq_ILLread_lp_state_prev_field (
  mpq_ILLread_lp_state * state);
extern int mpq_ILLread_lp_state_sign (
  mpq_ILLread_lp_state * state,
  mpq_t * sign);
extern int mpq_ILLread_lp_state_possible_coef (
  mpq_ILLread_lp_state * state,
  mpq_t * coef,
  const mpq_t defValue);

                                        /* returns 1 iff found a number 
                                         * otherwise 0 */
extern int mpq_ILLread_lp_state_possible_bound_value (
  mpq_ILLread_lp_state * state);

                                               /* returns 1 iff found a number 
                                                * otherwise 0 */
extern int mpq_ILLread_lp_state_colon (
  mpq_ILLread_lp_state * state);
extern int mpq_ILLread_lp_state_has_colon (
  mpq_ILLread_lp_state * state);
extern int mpq_ILLread_lp_statxe_has_colon (
  mpq_ILLread_lp_state * state);
extern int mpq_ILLread_lp_state_next_constraint (
  mpq_ILLread_lp_state * state);
extern int mpq_ILLread_lp_state_sense (
  mpq_ILLread_lp_state * state);
extern int mpq_ILLtest_lp_state_sense (
  mpq_ILLread_lp_state * state,
  int all);
extern void mpq_ILLtest_lp_state_bound_sense (
  mpq_ILLread_lp_state * state);
extern int mpq_ILLread_lp_state_value (
  mpq_ILLread_lp_state * state,
  mpq_t * d);
extern int mpq_ILLtest_lp_state_next_is (
  mpq_ILLread_lp_state * state,
  const char *str);
extern int mpq_ILLread_lp_state_skip_blanks (
  mpq_ILLread_lp_state * state,
  int wrapLines);

extern int mpq_ILLcheck_subject_to (
  mpq_ILLread_lp_state * state);

/*---------------------------------------------------------------------------*/
/* errors and warnings 
 */
extern int mpq_ILLlp_error (
  mpq_ILLread_lp_state * state,
  const char *format,
  ...);
extern void mpq_ILLlp_warn (
  mpq_ILLread_lp_state * state,
  const char *format,
  ...);

/*---------------------------------------------------------------------------*/
/* shared with read_mps_state.c 
 */
extern int mpq_ILLget_value (
  char *line,
  mpq_t * coef);

#endif
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* $RCSfile: rd_mps.h,v $ $Revision: 1.2 $ $Date: 2003/11/05 16:57:39 $ */
#ifndef mpq_READ_MPS_STATE_H
#define mpq_READ_MPS_STATE_H



typedef struct mpq_ILLread_mps_state_struct
{
  int section[ILL_MPS_N_SECTIONS];
  ILLmps_section active;
  const char *file_name;
  mpq_qsline_reader *file;
  unsigned int line_num;
  unsigned int field_num;       /* number of successfully read fields on line */
  int intvar;
  int sosvar;
  char line[ILL_namebufsize];
  char key[ILL_namebufsize];
  char field[ILL_namebufsize];
  char *obj;
  char *p;                      /* ptr to next 'unread' character */
}
mpq_ILLread_mps_state;

extern int mpq_ILLmps_state_init (
  mpq_ILLread_mps_state * state,
  mpq_qsline_reader * file,
  const char *mpq_fname);
extern void mpq_ILLmps_state_clear (
  mpq_ILLread_mps_state * state);
extern int mpq_ILLmps_set_section (
  mpq_ILLread_mps_state * state,
  const ILLmps_section sec);

extern int mpq_ILLmps_next_line (
  mpq_ILLread_mps_state * state);
extern int mpq_ILLmps_next_field (
  mpq_ILLread_mps_state * state);
extern int mpq_ILLmps_next_coef (
  mpq_ILLread_mps_state * state,
  mpq_t * coef);
extern int mpq_ILLmps_next_bound (
  mpq_ILLread_mps_state * state,
  mpq_t * coef);
extern void mpq_ILLmps_check_end_of_line (
  mpq_ILLread_mps_state * state);
extern void mpq_ILLmps_set_end_of_line (
  mpq_ILLread_mps_state * state);

extern int mpq_ILLmps_int_sos_mode (
  mpq_ILLread_mps_state * state);

extern const char *mpq_ILLmps_possibly_blank_name (
  const char *field,
  mpq_ILLread_mps_state * state,
  ILLsymboltab * tab);
extern int mpq_ILLmps_empty_key (
  mpq_ILLread_mps_state * state);
extern int mpq_ILLmps_empty_field (
  mpq_ILLread_mps_state * state);

extern int mpq_ILLmps_error (
  mpq_ILLread_mps_state * state,
  const char *format,
  ...);
extern void mpq_ILLmps_warn (
  mpq_ILLread_mps_state * state,
  const char *format,
  ...);

#endif
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* $RCSfile: mpq_simplex.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $ */

#ifndef mpq___SIMPLEX_H
#define mpq___SIMPLEX_H

struct itcnt_t;
typedef struct mpq_param_info
{
  int origalgo;
  int pphaseI;
  int pphaseII;
  int dphaseI;
  int dphaseII;
  int p_strategy;
  int d_strategy;
}
mpq_param_info;

typedef struct mpq_iter_info
{
  int newphase;
  int nextphase;
  int nextstep;
  int sdisplay;
  int itercnt;
  int solstatus;
  int curtime;
  int rounds;
  int chkobj;
  int nosolve;
  int noprog;
  int inner;
  int algorithm;
  int resumeid;
  int pricetype;
  int n_restart;
  int n_pivot_fail;
  mpq_t prevobj;
  mpq_t objtol;
  mpq_param_info oldinfo;
}
mpq_iter_info;

void mpq_ILLsimplex_init_lpinfo ( mpq_lpinfo * lp),
    mpq_ILLsimplex_free_lpinfo ( mpq_lpinfo * lp),
    mpq_ILLsimplex_load_lpinfo ( mpq_ILLlpdata * qslp, mpq_lpinfo * lp),
    mpq_ILLsimplex_set_bound ( mpq_lpinfo * lp, const mpq_t * objbound, int sense);
void mpq_free_internal_lpinfo ( mpq_lpinfo * lp);
void mpq_init_internal_lpinfo ( mpq_lpinfo * lp);
int mpq_build_internal_lpinfo ( mpq_lpinfo * lp);
int mpq_ILLsimplex_retest_psolution ( mpq_lpinfo * lp, mpq_price_info * p, int phase,
      mpq_feas_info * fs),
    mpq_ILLsimplex_retest_dsolution ( mpq_lpinfo * lp, mpq_price_info * p, int phase,
      mpq_feas_info * fs),
    mpq_ILLsimplex_solution ( mpq_lpinfo * lp, mpq_t * xz, mpq_t * piz,
      mpq_t * dz, mpq_t * objval),
    mpq_ILLsimplex_infcertificate ( mpq_lpinfo * lp, mpq_t * pi),
    mpq_ILLsimplex ( mpq_lpinfo * lp, int algorithm, mpq_ILLlp_basis * B, 
      mpq_price_info * pinf, int *sol_status, int sdisplay, itcnt_t* itcnt),
    mpq_ILLsimplex_pivotin ( mpq_lpinfo * lp, mpq_price_info * pinf, int rcnt, 
      int *rlist, int pivot_opt, int *basis_mod);

#endif /* mpq___SIMPLEX_H */
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  RCS_INFO = "$RCSfile: wr_lp.h,v $ $Revision: 1.2 $ $Date: 2003/11/05 16:57:39 $"; */
#ifndef mpq_WRITE_LP_STATE_H
#define mpq_WRITE_LP_STATE_H

/****************************************************************************/
/*                                                                          */
/*               Routines to support writing of LP files                    */
/*                                                                          */
/****************************************************************************/

/* 
 * -) anything after '\' is comment 
 * -) variables consist of a-z A-Z 0-9!"#$%(),;.?@_`'{}|~ 
 *    don't start with a digit or '.'
 */

typedef struct mpq_ILLwrite_lp_state
{
  char buf[ILL_namebufsize];
  char *p;
  int startlen;
  int total;
}
mpq_ILLwrite_lp_state;

extern void mpq_ILLwrite_lp_state_init (
  mpq_ILLwrite_lp_state * line,
  const char *str);
extern void mpq_ILLwrite_lp_state_append (
  mpq_ILLwrite_lp_state * line,
  const char *str);
extern void mpq_ILLwrite_lp_state_append_coef (
  mpq_ILLwrite_lp_state * line,
  mpq_t v,
  int cnt);

      /* append number sign ('+', '-') iff cnt > 0 or v < 0.0  
       * append number iff v != 1.0, v != -1.0  
       */
extern void mpq_ILLwrite_lp_state_append_number (
  mpq_ILLwrite_lp_state * line,
  mpq_t v);
extern void mpq_ILLwrite_lp_state_save_start (
  mpq_ILLwrite_lp_state * line);
extern void mpq_ILLwrite_lp_state_start (
  mpq_ILLwrite_lp_state * line);

#endif
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCSINFO $Id: mpq_lib.h,v 1.4 2003/11/05 17:00:26 meven Exp $ */
#ifndef mpq_ILL_LIB_H
#define mpq_ILL_LIB_H


/****************************************************************************/
/*                                                                          */
/*                   Return Status for mpq_ILLlib_optimize                      */
/*                                                                          */
/****************************************************************************/

/****************************************************************************/
/*                                                                          */
/*                               mpq_lib.c                                      */
/*                                                                          */
/****************************************************************************/

struct itcnt_t;

int mpq_ILLlib_optimize ( mpq_lpinfo * lp, mpq_ILLlp_basis * B, mpq_price_info * pinf, int algo,
      int *status, int simplex_display, struct itcnt_t*itcnt),
    mpq_ILLlib_cache_solution ( mpq_lpinfo * lp, mpq_ILLlp_cache * C), 
    mpq_ILLlib_solution ( mpq_lpinfo * lp, mpq_ILLlp_cache * C, mpq_t * val, 
      mpq_t * x, mpq_t * pi, mpq_t * slack, mpq_t * rc),
    mpq_ILLlib_get_x ( mpq_lpinfo * lp, mpq_ILLlp_cache * C, mpq_t * x),
    mpq_ILLlib_get_slack ( mpq_lpinfo * lp, mpq_ILLlp_cache * C, mpq_t * slack),
    mpq_ILLlib_objval ( mpq_lpinfo * lp, mpq_ILLlp_cache * C, mpq_t * val),
    mpq_ILLlib_tableau ( mpq_lpinfo * lp, int row, mpq_t * binv, mpq_t * tabrow),
    mpq_ILLlib_basis_order ( mpq_lpinfo * lp, int *header),
    mpq_ILLlib_newrow ( mpq_lpinfo * lp, mpq_ILLlp_basis * B,const mpq_t rhs, int sense,
      const mpq_t range, const char *name),
    mpq_ILLlib_newrows ( mpq_lpinfo * lp, mpq_ILLlp_basis * B, int num,const mpq_t * rhs,
      char *sense, const mpq_t * range, const char **names),
    mpq_ILLlib_addrow ( mpq_lpinfo * lp, mpq_ILLlp_basis * B, int cnt, int *ind,
      const mpq_t * val, const mpq_t rhs, int sense,const mpq_t range,
      const char *rowname),
    mpq_ILLlib_addrows ( mpq_lpinfo * lp, mpq_ILLlp_basis * B, int num, int *rmatcnt, 
      int *rmatbeg, int *rmatind,const mpq_t * rmatval,const mpq_t * rhs, 
      char *sense, const mpq_t * range, const char **names, int *nofactor),
    mpq_ILLlib_delrows ( mpq_lpinfo * lp, mpq_ILLlp_basis * B, mpq_ILLlp_cache * C, int num, 
      int *dellist, int *basis_ok, int *cache_ok), 
    mpq_ILLlib_newcol ( mpq_lpinfo * lp, mpq_ILLlp_basis * B,const mpq_t obj, 
      const mpq_t lower,const mpq_t upper, const char *name, int factorok), 
    mpq_ILLlib_newcols ( mpq_lpinfo * lp, mpq_ILLlp_basis * B, int num, mpq_t * obj,
      mpq_t * lower, mpq_t * upper, const char **names, int factorok),
    mpq_ILLlib_addcol ( mpq_lpinfo * lp, mpq_ILLlp_basis * B, int cnt, int *ind,
      mpq_t * val,const mpq_t obj,const mpq_t lower,const mpq_t upper, 
      const char *name, int factorok),
    mpq_ILLlib_addcols ( mpq_lpinfo * lp, mpq_ILLlp_basis * B, int num, int *cmatcnt,
      int *cmatbeg, int *cmatind, mpq_t * cmatval, mpq_t * obj,
      mpq_t * lower, mpq_t * upper, const char **names, int factorok),
    mpq_ILLlib_delcols ( mpq_lpinfo * lp, mpq_ILLlp_basis * B, int num, int *dellist,
      int *basis_ok),
    mpq_ILLlib_chgcoef ( mpq_lpinfo * lp, int rowindex, int colindex, mpq_t coef), 
    mpq_ILLlib_getcoef (mpq_lpinfo *lp, int rowindex, int colindex, mpq_t* coef),
    mpq_ILLlib_chgrange (mpq_lpinfo *lp, int indx, mpq_t coef),
    mpq_ILLlib_chgsense ( mpq_lpinfo * lp, int num, int *rowlist, char *sense),
    mpq_ILLlib_getsenses (mpq_lpinfo *lp, char *senses),
    mpq_ILLlib_getrows ( mpq_lpinfo * lp, int num, int *rowlist, int **rowcnt,
      int **rowbeg, int **rowind, mpq_t ** rowval, mpq_t ** rhs,
      char **sense, mpq_t ** range, char ***names),
    mpq_ILLlib_getcols ( mpq_lpinfo * lp, int num, int *collist, int **colcnt,
      int **colbeg, int **colind, mpq_t ** colval, mpq_t ** obj,
      mpq_t ** lower, mpq_t ** upper, char ***names),
    mpq_ILLlib_getobj ( mpq_lpinfo * lp, mpq_t * obj),
    mpq_ILLlib_getobj_list (mpq_lpinfo *lp, int num, int* collist, mpq_t* obj),
    mpq_ILLlib_chgobj ( mpq_lpinfo * lp, int indx, mpq_t coef),
    mpq_ILLlib_getrhs ( mpq_lpinfo * lp, mpq_t * rhs),
    mpq_ILLlib_chgrhs ( mpq_lpinfo * lp, int indx, mpq_t coef),
    mpq_ILLlib_getintflags ( mpq_lpinfo * lp, int *intflags),
    mpq_ILLlib_rownames ( mpq_lpinfo * lp, char **rownames),
    mpq_ILLlib_colnames ( mpq_lpinfo * lp, char **colnames),
    mpq_ILLlib_colindex ( mpq_lpinfo * lp, const char *name, int *colindex),
    mpq_ILLlib_rowindex ( mpq_lpinfo * lp, const char *name, int *rowindex),
    mpq_ILLlib_chgbnd ( mpq_lpinfo * lp, int indx, int lu,const mpq_t bnd),
    mpq_ILLlib_chgbnds ( mpq_lpinfo * lp, int cnt, int *indx, char *lu, const mpq_t * bnd),
    mpq_ILLlib_getbnd ( mpq_lpinfo * lp, int indx, int lu, mpq_t * bnd),
    mpq_ILLlib_getbnds ( mpq_lpinfo * lp, mpq_t * lower, mpq_t * upper),
    mpq_ILLlib_getbnds_list ( mpq_lpinfo *lp, int num, int*collist, mpq_t *lower,
      mpq_t *upper),
    mpq_ILLlib_strongbranch ( mpq_lpinfo * lp, mpq_price_info * pinf, int *candidatelist,
      int ncand, mpq_t * xlist, mpq_t * downpen, mpq_t * uppen,
      int iterations, mpq_t objbound, struct itcnt_t*itcnt),
    mpq_ILLlib_getbasis ( mpq_lpinfo * lp, char *cstat, char *rstat),
    mpq_ILLlib_loadbasis ( mpq_ILLlp_basis * B, int nstruct, int nrows, char *cstat,
      char *rstat),
    mpq_ILLlib_readbasis ( mpq_lpinfo * lp, mpq_ILLlp_basis * B, const char *mpq_fname),
    mpq_ILLlib_writebasis ( mpq_lpinfo * lp, mpq_ILLlp_basis * B, const char *mpq_fname),
    mpq_ILLlib_getrownorms ( mpq_lpinfo * lp, mpq_price_info * pinf, mpq_t * rownorms),
    mpq_ILLlib_loadrownorms ( mpq_lpinfo * lp, mpq_price_info * pinf, mpq_t * rownorms),
    mpq_ILLlib_recompute_rownorms ( mpq_lpinfo * lp, mpq_price_info * pinf),
    mpq_ILLlib_iter ( mpq_lpinfo * lp),
    mpq_ILLlib_print_x ( EGioFile_t * fd, mpq_lpinfo * lp, mpq_ILLlp_cache * C, mpq_t * x,
      int nonZerosOnly),
    mpq_ILLwrite_lp_file ( mpq_ILLlpdata * lp, EGioFile_t * eout, mpq_qserror_collector * c);


extern int mpq_ILLlib_findName (
  mpq_ILLlpdata * qslp,
  int forRow,
  const char *name,
  int id,
  char buf[ILL_namebufsize]);

/****************************************************************************/
/*                                                                          */
/*                           mpq_presolve.c                                     */
/*                                                                          */
/****************************************************************************/

int mpq_ILLpresolve_add_logicals (
  mpq_ILLlpdata * lp);


/****************************************************************************/
/*                                                                          */
/*                            mpq_binary.c                                      */
/*                                                                          */
/****************************************************************************/

int mpq_ILLmip_binary_dfs (
  mpq_lpinfo * lp);

#endif /* mpq_ILL_LIB_H */
#endif
#endif
#ifdef HAVE_LIBGMP
#if HAVE_LIBGMP
/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/*  $RCSfile: mpf_qstruct.h,v $ $Revision: 1.3 $ $Date: 2003/11/05 16:57:39 $" */
#ifndef mpf___QS_QSTRUCT_H
#define mpf___QS_QSTRUCT_H

typedef struct mpf_qsdata
{
  struct mpf_ILLlpdata *qslp;
  struct mpf_lpinfo *lp;
  struct mpf_price_info *pricing;
  struct mpf_ILLlp_basis *basis;
  struct mpf_ILLlp_cache *cache;
  char *name;
  int qstatus;                  /* QS_LP_UNSOLVED or an opt status  */
  int factorok;                 /* set to 0 if factorization is old */
  int simplex_display;          /* 0 off, 1 on */
  int simplex_scaling;          /* 0 off, 1 on */
  itcnt_t itcnt;