lpsolver 0.1.0 → 0.2.1

data/ext/lpsolver-highs/build/include/highs/io/filereaderlp/model.hpp

@@ -0,0 +1,68 @@
+#ifndef __READERLP_MODEL_HPP__
+#define __READERLP_MODEL_HPP__
+
+#include <limits>
+#include <memory>
+#include <string>
+#include <vector>
+
+enum class VariableType {
+  CONTINUOUS,
+  BINARY,
+  GENERAL,
+  SEMICONTINUOUS,
+  SEMIINTEGER
+};
+
+enum class ObjectiveSense { MIN, MAX };
+
+struct Variable {
+  VariableType type = VariableType::CONTINUOUS;
+  double lowerbound = 0.0;
+  double upperbound = std::numeric_limits<double>::infinity();
+  std::string name;
+
+  Variable(std::string n = "") : name(n){};
+};
+
+struct LinTerm {
+  std::shared_ptr<Variable> var;
+  double coef = 1.0;
+};
+
+struct QuadTerm {
+  std::shared_ptr<Variable> var1;
+  std::shared_ptr<Variable> var2;
+  double coef = 1.0;
+};
+
+struct Expression {
+  std::vector<std::shared_ptr<LinTerm>> linterms;
+  std::vector<std::shared_ptr<QuadTerm>> quadterms;
+  double offset = 0.0;
+  std::string name = "";
+};
+
+struct Constraint {
+  double lowerbound = -std::numeric_limits<double>::infinity();
+  double upperbound = std::numeric_limits<double>::infinity();
+  std::shared_ptr<Expression> expr;
+
+  Constraint() : expr(std::shared_ptr<Expression>(new Expression)){};
+};
+
+struct SOS {
+  std::string name = "";
+  short type = 0;  // 1 or 2
+  std::vector<std::pair<std::shared_ptr<Variable>, double>> entries;
+};
+
+struct Model {
+  std::shared_ptr<Expression> objective;
+  ObjectiveSense sense = ObjectiveSense::MIN;
+  std::vector<std::shared_ptr<Constraint>> constraints;
+  std::vector<std::shared_ptr<Variable>> variables;
+  std::vector<std::shared_ptr<SOS>> soss;
+};
+
+#endif

data/ext/lpsolver-highs/build/include/highs/io/filereaderlp/reader.hpp

@@ -0,0 +1,10 @@
+#ifndef __READERLP_READER_HPP__
+#define __READERLP_READER_HPP__
+
+#include <string>
+
+#include "io/filereaderlp/model.hpp"
+
+Model readinstance(std::string filename);
+
+#endif

data/ext/lpsolver-highs/build/include/highs/ipm/IpxSolution.h

@@ -0,0 +1,32 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file ipm/IpxSolution.h
+ * @brief
+ */
+#ifndef IPM_IPX_SOLUTION_H_
+#define IPM_IPX_SOLUTION_H_
+
+#include <stdint.h>
+
+#include <vector>
+
+#include "util/HighsInt.h"
+typedef HighsInt ipxint;
+
+struct IpxSolution {
+  ipxint num_col;
+  ipxint num_row;
+  std::vector<double> ipx_col_value;
+  std::vector<double> ipx_row_value;
+  std::vector<double> ipx_col_dual;
+  std::vector<double> ipx_row_dual;
+  std::vector<ipxint> ipx_col_status;
+  std::vector<ipxint> ipx_row_status;
+};
+
+#endif

data/ext/lpsolver-highs/build/include/highs/ipm/IpxWrapper.h

@@ -0,0 +1,106 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file ipm/IpxWrapper.h
+ * @brief
+ */
+#ifndef IPM_IPX_WRAPPER_H_
+#define IPM_IPX_WRAPPER_H_
+
+#include <algorithm>
+#include <cassert>
+
+#include "ipm/IpxSolution.h"
+#include "ipm/ipx/ipx_status.h"
+#include "ipm/ipx/lp_solver.h"
+#include "lp_data/HighsSolution.h"
+
+#ifdef HIPO
+#include "ipm/hipo/ipm/Solver.h"
+#endif
+
+HighsStatus solveLpIpx(HighsLpSolverObject& solver_object);
+
+HighsStatus solveLpIpx(const HighsOptions& options, HighsTimer& timer,
+                       const HighsLp& lp, HighsBasis& highs_basis,
+                       HighsSolution& highs_solution,
+                       HighsModelStatus& model_status, HighsInfo& highs_info,
+                       HighsCallback& callback);
+
+#ifdef HIPO
+HighsStatus solveLpHipo(HighsLpSolverObject& solver_object);
+
+HighsStatus solveHipo(const HighsOptions& options, HighsTimer& timer,
+                      const HighsLp& lp, const HighsHessian& H,
+                      HighsBasis& highs_basis, HighsSolution& highs_solution,
+                      HighsModelStatus& model_status, HighsInfo& highs_info,
+                      HighsCallback& callback);
+
+HighsStatus reportHipoStatus(const HighsOptions& options,
+                             const hipo::Int status, const hipo::Solver& hipo);
+
+HighsStatus reportHipoCrossoverStatus(const HighsOptions& options,
+                                      const ipx::Int status, bool is_qp);
+
+void reportHipoNoProgress(const HighsOptions& options,
+                          const hipo::Info& hipo_info);
+
+void getHipoNonVertexSolution(const HighsOptions& options, const HighsLp& lp,
+                              const hipo::Int num_col, const hipo::Int num_row,
+                              const std::vector<double>& rhs,
+                              const std::vector<char>& constraint_type,
+                              const hipo::Solver& hipo,
+                              const HighsModelStatus model_status,
+                              HighsSolution& highs_solution);
+
+#endif
+
+void fillInIpxData(const HighsLp& lp, ipx::Int& num_col, ipx::Int& num_row,
+                   double& offset, std::vector<double>& obj,
+                   std::vector<double>& col_lb, std::vector<double>& col_ub,
+                   std::vector<ipx::Int>& Ap, std::vector<ipx::Int>& Ai,
+                   std::vector<double>& Ax, std::vector<double>& rhs,
+                   std::vector<char>& constraint_type);
+
+void fillInRhsAndConstraints(const HighsLp& lp, std::vector<double>& rhs,
+                             std::vector<char>& constraint_type);
+
+HighsStatus reportIpxSolveStatus(const HighsOptions& options,
+                                 const ipx::Int solve_status,
+                                 const ipx::Int error_flag);
+
+HighsStatus reportIpxIpmCrossoverStatus(const HighsOptions& options,
+                                        const ipx::Int status,
+                                        const bool ipm_status);
+
+bool ipxStatusError(const bool status_error, const HighsOptions& options,
+                    const std::string& solver, const std::string& message,
+                    const int value = -1);
+
+bool illegalIpxSolvedStatus(const ipx::Info& ipx_info,
+                            const HighsOptions& options);
+
+bool illegalIpxStoppedIpmStatus(const ipx::Info& ipx_info,
+                                const HighsOptions& options);
+
+bool illegalIpxStoppedCrossoverStatus(const ipx::Info& ipx_info,
+                                      const HighsOptions& options);
+
+void reportIpmNoProgress(const HighsOptions& options,
+                         const ipx::Info& ipx_info);
+
+void getHighsNonVertexSolution(const HighsOptions& options, const HighsLp& lp,
+                               const ipx::Int num_col, const ipx::Int num_row,
+                               const std::vector<double>& rhs,
+                               const std::vector<char>& constraint_type,
+                               const ipx::LpSolver& lps,
+                               const HighsModelStatus model_status,
+                               HighsSolution& highs_solution);
+
+void reportSolveData(const HighsLogOptions& log_options,
+                     const ipx::Info& ipx_info);
+#endif

data/ext/lpsolver-highs/build/include/highs/ipm/basiclu/basiclu.h

@@ -0,0 +1,161 @@
+#ifndef _BASICLU_H
+#define _BASICLU_H
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+/*
+ * BASICLU integer type
+ *
+ * All integers in BASICLU code are of type lu_int, which must be a signed
+ * integer type. It is required that all integer values arising in the
+ * computation can be stored in double variables and converted back to lu_int
+ * without altering their value.
+ *
+ * LU_INT_MAX must be the maximum value of a variable of type lu_int.
+ *
+ * The default is 64 bit integers to make the code easily callable from Julia.
+ * int64_t is optional in the C99 standard, but available on most systems.
+ *
+ */
+#include <limits.h>
+#include <stdint.h>
+#include "HConfig.h"
+  
+#ifdef HIGHSINT64
+typedef int64_t lu_int;
+#define LU_INT_MAX INT64_MAX
+#else
+typedef int lu_int;
+#define LU_INT_MAX INT_MAX
+#endif
+/* #include <limits.h> */
+/* typedef long lu_int; */
+/* #define LU_INT_MAX LONG_MAX */
+
+/* size of istore */
+#define BASICLU_SIZE_ISTORE_1 1024
+#define BASICLU_SIZE_ISTORE_M 21
+
+/* size of xstore */
+#define BASICLU_SIZE_XSTORE_1 1024
+#define BASICLU_SIZE_XSTORE_M 4
+
+/* ------------ */
+/* status codes */
+/* ------------ */
+
+#define BASICLU_OK 0
+#define BASICLU_REALLOCATE 1
+#define BASICLU_WARNING_singular_matrix 2
+#define BASICLU_ERROR_invalid_store (-1)
+#define BASICLU_ERROR_invalid_call (-2)
+#define BASICLU_ERROR_argument_missing (-3)
+#define BASICLU_ERROR_invalid_argument (-4)
+#define BASICLU_ERROR_maximum_updates (-5)
+#define BASICLU_ERROR_singular_update (-6)
+
+#define BASICLU_ERROR_invalid_object (-8)
+#define BASICLU_ERROR_out_of_memory (-9)
+
+/* ------------------------ */
+/* public entries in xstore */
+/* ------------------------ */
+
+/* user parameters */
+#define BASICLU_MEMORYL 1
+#define BASICLU_MEMORYU 2
+#define BASICLU_MEMORYW 3
+#define BASICLU_DROP_TOLERANCE 4
+#define BASICLU_ABS_PIVOT_TOLERANCE 5
+#define BASICLU_REL_PIVOT_TOLERANCE 6
+#define BASICLU_BIAS_NONZEROS 7
+#define BASICLU_MAXN_SEARCH_PIVOT 8
+#define BASICLU_PAD 9
+#define BASICLU_STRETCH 10
+#define BASICLU_COMPRESSION_THRESHOLD 11
+#define BASICLU_SPARSE_THRESHOLD 12
+#define BASICLU_REMOVE_COLUMNS 13
+#define BASICLU_SEARCH_ROWS 14
+
+/* user readable */
+#define BASICLU_DIM 64
+#define BASICLU_STATUS 65
+#define BASICLU_ADD_MEMORYL 66
+#define BASICLU_ADD_MEMORYU 67
+#define BASICLU_ADD_MEMORYW 68
+
+#define BASICLU_NUPDATE 70
+#define BASICLU_NFORREST 71
+#define BASICLU_NFACTORIZE 72
+#define BASICLU_NUPDATE_TOTAL 73
+#define BASICLU_NFORREST_TOTAL 74
+#define BASICLU_NSYMPERM_TOTAL 75
+#define BASICLU_LNZ 76
+#define BASICLU_UNZ 77
+#define BASICLU_RNZ 78
+#define BASICLU_MIN_PIVOT 79
+#define BASICLU_MAX_PIVOT 80
+#define BASICLU_UPDATE_COST 81
+#define BASICLU_TIME_FACTORIZE 82
+#define BASICLU_TIME_SOLVE 83
+#define BASICLU_TIME_UPDATE 84
+#define BASICLU_TIME_FACTORIZE_TOTAL 85
+#define BASICLU_TIME_SOLVE_TOTAL 86
+#define BASICLU_TIME_UPDATE_TOTAL 87
+#define BASICLU_LFLOPS 88
+#define BASICLU_UFLOPS 89
+#define BASICLU_RFLOPS 90
+#define BASICLU_CONDEST_L 91
+#define BASICLU_CONDEST_U 92
+#define BASICLU_MAX_ETA 93
+#define BASICLU_NORM_L 94
+#define BASICLU_NORM_U 95
+#define BASICLU_NORMEST_LINV 96
+#define BASICLU_NORMEST_UINV 97
+#define BASICLU_MATRIX_ONENORM 98
+#define BASICLU_MATRIX_INFNORM 99
+#define BASICLU_RESIDUAL_TEST 111
+
+#define BASICLU_MATRIX_NZ 100
+#define BASICLU_RANK 101
+#define BASICLU_BUMP_SIZE 102
+#define BASICLU_BUMP_NZ 103
+#define BASICLU_NSEARCH_PIVOT 104
+#define BASICLU_NEXPAND 105
+#define BASICLU_NGARBAGE 106
+#define BASICLU_FACTOR_FLOPS 107
+#define BASICLU_TIME_SINGLETONS 108
+#define BASICLU_TIME_SEARCH_PIVOT 109
+#define BASICLU_TIME_ELIM_PIVOT 110
+
+#define BASICLU_PIVOT_ERROR 120
+
+/* ----------------------- */
+/* user callable functions */
+/* ----------------------- */
+
+#include "ipm/basiclu/basiclu_initialize.h"
+#include "ipm/basiclu/basiclu_factorize.h"
+#include "ipm/basiclu/basiclu_get_factors.h"
+#include "ipm/basiclu/basiclu_solve_dense.h"
+#include "ipm/basiclu/basiclu_solve_sparse.h"
+#include "ipm/basiclu/basiclu_solve_for_update.h"
+#include "ipm/basiclu/basiclu_update.h"
+
+#include "ipm/basiclu/basiclu_object.h"
+#include "ipm/basiclu/basiclu_obj_initialize.h"
+#include "ipm/basiclu/basiclu_obj_factorize.h"
+#include "ipm/basiclu/basiclu_obj_get_factors.h"
+#include "ipm/basiclu/basiclu_obj_solve_dense.h"
+#include "ipm/basiclu/basiclu_obj_solve_sparse.h"
+#include "ipm/basiclu/basiclu_obj_solve_for_update.h"
+#include "ipm/basiclu/basiclu_obj_update.h"
+#include "ipm/basiclu/basiclu_obj_free.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/lpsolver-highs/build/include/highs/ipm/basiclu/basiclu_factorize.h

@@ -0,0 +1,247 @@
+lu_int basiclu_factorize
+(
+    lu_int istore[],
+    double xstore[],
+    lu_int Li[],
+    double Lx[],
+    lu_int Ui[],
+    double Ux[],
+    lu_int Wi[],
+    double Wx[],
+    const lu_int Bbegin[],
+    const lu_int Bend[],
+    const lu_int Bi[],
+    const double Bx[],
+    lu_int c0ntinue
+);
+
+/*
+Purpose:
+
+    Factorize the matrix B into its LU factors. Choose pivot elements by a
+    Markowitz criterion subject to columnwise threshold pivoting (the pivot may
+    not be smaller than a factor of the largest entry in its column).
+
+Return:
+
+    BASICLU_ERROR_invalid_store if istore, xstore do not hold a BASICLU
+    instance. In this case xstore[BASICLU_STATUS] is not set.
+
+    Otherwise return the status code. See xstore[BASICLU_STATUS] below.
+
+Arguments:
+
+    lu_int istore[]
+    double xstore[]
+
+        BASICLU instance. The instance determines the dimension of matrix B
+        (stored in xstore[BASICLU_DIM]).
+
+    lu_int Li[]
+    double Lx[]
+    lu_int Ui[]
+    double Ux[]
+    lu_int Wi[]
+    double Wx[]
+
+        Arrays used for workspace during the factorization and to store the
+        final factors. They must be allocated by the user and their length
+        must be provided as parameters:
+
+            xstore[BASICLU_MEMORYL]: length of Li and Lx
+            xstore[BASICLU_MEMORYU]: length of Ui and Ux
+            xstore[BASICLU_MEMORYW]: length of Wi and Wx
+
+        When the allocated length is insufficient to complete the factorization,
+        basiclu_factorize() returns to the caller for reallocation (see
+        xstore[BASICLU_STATUS] below). A successful factorization requires at
+        least nnz(B) length for each of the arrays.
+
+    const lu_int Bbegin[]
+    const lu_int Bend[]
+    const lu_int Bi[]
+    const double Bx[]
+
+        Matrix B in packed column form. Bi and Bx are arrays of row indices
+        and nonzero values. Column j of matrix B contains elements
+
+            Bi[Bbegin[j] .. Bend[j]-1], Bx[Bbegin[j] .. Bend[j]-1].
+
+        The columns must not contain duplicate row indices. The arrays Bbegin
+        and Bend may overlap, so that it is valid to pass Bp, Bp+1 for a matrix
+        stored in compressed column form (Bp, Bi, Bx).
+
+    lu_int c0ntinue
+
+        zero to start a new factorization; nonzero to continue a factorization
+        after reallocation.
+
+Parameters:
+
+    xstore[BASICLU_DROP_TOLERANCE]
+
+        Nonzeros which magnitude is less than or equal to the drop tolerance can
+        be removed after each pivot step. They are guaranteed removed at the end
+        of the factorization. Default: 1e-20
+
+    xstore[BASICLU_ABS_PIVOT_TOLERANCE]
+
+        A pivot element must be nonzero and in absolute value must be greater
+        than or equal to xstore[BASICLU_ABS_PIVOT_TOLERANCE]. Default: 1e-14
+
+    xstore[BASICLU_REL_PIVOT_TOLERANCE]
+
+        A pivot element must be (in absolute value) greater than or equal to
+        xstore[BASICLU_REL_PIVOT_TOLERANCE] times the largest entry in its
+        column. A value greater than or equal to 1.0 is treated as 1.0 and
+        enforces partial pivoting. Default: 0.1
+
+    xstore[BASICLU_BIAS_NONZEROS]
+
+        When this value is greater than or equal to zero, the pivot choice
+        attempts to keep L sparse, putting entries into U when possible.
+        When this value is less than zero, the pivot choice attempts to keep U
+        sparse, putting entries into L when possible. Default: 1
+
+    xstore[BASICLU_MAXN_SEARCH_PIVOT]
+
+        The Markowitz search is terminated after searching
+        xstore[BASICLU_MAXN_SERACH_PIVOT] rows or columns if a numerically
+        stable pivot element has been found. Default: 3
+
+    xstore[BASICLU_SEARCH_ROWS]
+
+        If xstore[BASICLU_SEARCH_ROWS] is zero, then the Markowitz search only
+        scans columns. If nonzero, then both columns and rows are searched in
+        increasing order of number of entries. Default: 1
+
+    xstore[BASICLU_PAD]
+    xstore[BASICLU_STRETCH]
+
+        When a row or column cannot be updated by the pivot operation in place,
+        it is appended to the end of the workspace. For a row or column with nz
+        elements, xstore[BASICLU_PAD] + nz * xstore[BASICLU_STRETCH] elements
+        extra space are added for later fill-in.
+        Default: xstore[BASICLU_PAD] = 4, xstore[BASICLU_STRETCH] = 0.3
+
+    xstore[BASICLU_REMOVE_COLUMNS]
+
+        This parameter is present for compatibility to previous versions but has
+        no effect. If during factorization the maximum entry of a column of the
+        active submatrix becomes zero or less than
+        xstore[BASICLU_ABS_PIVOT_TOLERANCE], then that column is immediately
+        removed without choosing a pivot.
+
+Info:
+
+    xstore[BASICLU_STATUS]: status code.
+
+        BASICLU_OK
+
+            The factorization has successfully completed.
+
+        BASICLU_WARNING_singular_matrix
+
+            The factorization did xstore[BASICLU_RANK] < xstore[BASICLU_DIM]
+            pivot steps. The remaining elements in the active submatrix are zero
+            or less than xstore[BASICLU_ABS_PIVOT_TOLERANCE]. The factors have
+            been augmented by unit columns to form a square matrix. See
+            basiclu_get_factors() on how to get the indices of linearly
+            dependent columns.
+
+        BASICLU_ERROR_argument_missing
+
+            One or more of the pointer/array arguments are NULL.
+
+        BASICLU_ERROR_invalid_call
+
+            c0ntinue is nonzero, but the factorization was not started before.
+
+        BASICLU_ERROR_invalid_argument
+
+            The matrix is invalid (a column has a negative number of entries,
+            a row index is out of range, or a column has duplicate entries).
+
+        BASICLU_REALLOCATE
+
+            Factorization requires more memory in Li,Lx and/or Ui,Ux and/or
+            Wi,Wx. The number of additional elements in each of the array pairs
+            required for the next pivot operation is given by:
+
+                xstore[BASICLU_ADD_MEMORYL] >= 0
+                xstore[BASICLU_ADD_MEMORYU] >= 0
+                xstore[BASICLU_ADD_MEMORYW] >= 0
+
+            The user must reallocate the arrays for which additional memory is
+            required. It is recommended to reallocate for the requested number
+            of additional elements plus some extra space (e.g. 0.5 times the
+            current array length). The new array lengths must be provided in
+
+                xstore[BASICLU_MEMORYL]: length of Li and Lx
+                xstore[BASICLU_MEMORYU]: length of Ui and Ux
+                xstore[BASICLU_MEMORYW]: length of Wi and Wx
+
+            basiclu_factorize() can be called again with c0ntinue not equal to
+            zero to continue the factorization.
+
+    xstore[BASICLU_MATRIX_NZ] number of nonzeros in B
+
+    xstore[BASICLU_MATRIX_ONENORM]
+    xstore[BASICLU_MATRIX_INFNORM] 1-norm and inf-norm of the input matrix
+                                   after replacing dependent columns by unit
+                                   columns.
+
+    xstore[BASICLU_RANK] number of pivot steps performed
+
+    xstore[BASICLU_BUMP_SIZE] dimension of matrix after removing singletons
+
+    xstore[BASICLU_BUMP_NZ] # nonzeros in matrix after removing singletons
+
+    xstore[BASICLU_NSEARCH_PIVOT] total # columns/rows searched for pivots
+
+    xstore[BASICLU_NEXPAND] # columns/rows which had to be appended to the end
+                            of the workspace for the rank-1 update
+
+    xstore[BASICLU_NGARBAGE] # garbage collections
+
+    xstore[BASICLU_FACTOR_FLOPS] # floating point operations performed,
+                                 counting multiply-add as one flop
+
+    xstore[BASICLU_TIME_SINGLETONS] wall clock time for removing the initial
+                                    triangular factors
+
+    xstore[BASICLU_TIME_SEARCH_PIVOT] wall clock time for Markowitz search
+
+    xstore[BASIClU_TIME_ELIM_PIVOT] wall clock time for pivot elimination
+
+    xstore[BASICLU_RESIDUAL_TEST]
+
+            An estimate for numerical stability of the factorization.
+            xstore[BASICLU_RESIDUAL_TEST] is the maximum of the scaled residuals
+
+              ||b-Bx|| / (||b|| + ||B||*||x||)
+
+            and
+
+              ||c-B'y|| / (||c|| + ||B'||*||y||),
+
+            where x=B\b and y=B'\c are computed from the LU factors, b and c
+            have components +/-1 that are chosen to make x respectively y large,
+            and ||.|| is the 1-norm. Here B is the input matrix after replacing
+            dependent columns by unit columns.
+
+            If xstore[BASICLU_RESIDUAL_TEST] > 1e-12, say, the factorization is
+            numerically unstable. (This is independent of the condition number
+            of B.) In this case tightening the relative pivot tolerance and
+            refactorizing is appropriate.
+
+    xstore[BASICLU_NORM_L]
+    xstore[BASICLU_NORM_U] 1-norm of L and U.
+
+    xstore[BASICLU_NORMEST_LINV]
+    xstore[BASICLU_NORMEST_UINV] Estimated 1-norm of L^{-1} and U^{-1},
+                                 computed by the LINPACK algorithm.
+
+    xstore[BASICLU_CONDEST_L]
+    xstore[BASICLU_CONDEST_U] Estimated 1-norm condition number of L and U.
+*/