lpsolver 0.1.0 → 0.2.0

data/ext/lpsolver-highs/highs/ipm/ipx/ipm.h

@@ -0,0 +1,94 @@
+#ifndef IPX_IPM_H_
+#define IPX_IPM_H_
+
+#include "ipm/ipx/control.h"
+#include "ipm/ipx/kkt_solver.h"
+#include "ipm/ipx/iterate.h"
+
+namespace ipx {
+
+// IPM implements an interior point method based on KKTSolver and Iterate.
+// The algorithm is a variant of Mehrotra's [1] predictor-corrector method
+// that requires two linear system solves per iteration.
+//
+// [1] S. Mehrotra, "On the implementation of a primal-dual interior point
+//     method", SIAM J. Optim., 2 (1992).
+
+class IPM {
+public:
+    explicit IPM(const Control& control);
+
+    // Initializes @iterate with a starting point for Driver(). The KKT solver
+    // must allow Factorize(NULL, info) (see kkt_solver.h).
+    // On return info->status_ipm is
+    // IPX_STATUS_not_run    if successful,
+    // IPX_STATUS_time_limit if the KKT solver was interrupted by time limit,
+    // IPX_STATUS_failed     if the KKT solver failed with info->errflag.
+    // If the method did not terminate successfully, @iterate is unchanged.
+    void StartingPoint(KKTSolver* kkt, Iterate* iterate, Info* info);
+
+    // Updates @iterate by interior point iterations. On return ipm_status is
+    // IPX_STATUS_optimal       if iterate->term_crit_reached() is true,
+    // IPX_STATUS_iter_limit    if info->iter >= maxiter(),
+    // IPX_STATUS_no_progress   if no progress over a number of iterations,
+    // IPX_STATUS_time_limit    if interrupted by time limit,
+    // IPX_STATUS_failed        if the KKT solver failed with info->errflag.
+    void Driver(KKTSolver* kkt, Iterate* iterate, Info* info);
+
+    Int maxiter() const { return maxiter_; }
+    void maxiter(Int i) { maxiter_ = i; }
+    void PrintHeader();
+
+private:
+    struct Step;
+    // IPM terminates when the complementarity gap of the current iterate
+    // exceeds kDivergeTol times the smallest complementarity gap of all
+    // iterates so far.
+    static constexpr double kDivergeTol = 1e6;
+
+    void ComputeStartingPoint();
+    void Predictor(Step& step);
+    void AddCorrector(Step& step);
+    void Centring(Step& step, double mu_to_use);
+    void AssessCentrality(const Vector& xl, const Vector& xu, const Vector& zl, 
+                          const Vector& zu,double mu, bool print = true);
+    bool EvaluateCentringStep(const Step& step, double prev_ratio, Int prev_bad);
+    void StepSizes(const Step& step, bool isCentring = false);
+    void MakeStep(const Step& step, bool isCentring = false);
+    // Reduces the following linear system to KKT form:
+    //  [ AI                 ] [dx ]    [rb]
+    //  [ I  -I              ] [dxl] =  [rl]
+    //  [ I      I           ] [dxu]    [ru]
+    //  [          AI'  I -I ] [dy ]    [rc]
+    //  [    Zl        Xl    ] [dzl]    [sl]
+    //  [       Zu        Xu ] [dzu]    [su]
+    // Each of @rb, @rc, @rl and @ru can be NULL, in which case its entries are
+    // assumed to be 0.0. This is currently not used, but was implemented for
+    // computing centrality correctors.
+    void SolveNewtonSystem(const double* rb, const double* rc,
+                           const double* rl, const double* ru,
+                           const double* sl, const double* su, Step& lhs);
+    void PrintOutput();
+
+    const Control& control_;
+    KKTSolver* kkt_{nullptr};
+    Iterate* iterate_{nullptr};
+    Info* info_{nullptr};
+
+    double step_primal_{0.0}, step_dual_{0.0};
+    // Counts the # bad iterations since the last good iteration. An iteration
+    // is bad if the primal or dual step size is < 0.05.
+    Int num_bad_iter_{0};
+    // Smallest complementarity gap of all iterates so far.
+    double best_complementarity_{0.0};
+
+    Int maxiter_{-1};
+
+    // indicators of centrality for centring steps
+    double centring_ratio{0.0};
+    Int bad_products{0};
+};
+
+}  // namespace ipx
+
+#endif  // IPX_IPM_H_

data/ext/lpsolver-highs/highs/ipm/ipx/ipx_c.cc

@@ -0,0 +1,83 @@
+#include "ipm/ipx/ipx_c.h"
+#include "ipm/ipx/ipx_internal.h"
+#include "ipm/ipx/lp_solver.h"
+
+using namespace ipx;
+
+ipxint ipx_load_model(void* self, ipxint num_var, const double* obj,
+                      const double* lb, const double* ub, ipxint num_constr,
+                      const ipxint* Ap, const ipxint* Ai, const double* Ax,
+                      const double* rhs, const char* constr_type) {
+    LpSolver* solver = static_cast<LpSolver*>(self);
+    const double offset = 0;
+    return solver->LoadModel(num_var, offset, obj, lb, ub, num_constr, Ap, Ai, Ax, rhs,
+                             constr_type);
+}
+
+ipxint ipx_load_ipm_starting_point(void* self, const double* x,
+                                   const double* xl, const double* xu,
+                                   const double* slack, const double* y,
+                                   const double* zl, const double* zu) {
+    LpSolver* solver = static_cast<LpSolver*>(self);
+    return solver->LoadIPMStartingPoint(x, xl, xu, slack, y, zl, zu);
+}
+
+ipxint ipx_solve(void* self) {
+    LpSolver* solver = static_cast<LpSolver*>(self);
+    return solver->Solve();
+}
+
+struct ipx_info ipx_get_info(void* self) {
+    LpSolver* solver = static_cast<LpSolver*>(self);
+    return solver->GetInfo();
+}
+
+ipxint ipx_get_interior_solution(void* self, double* x, double* xl, double* xu,
+                                 double* slack, double* y, double* zl,
+                                 double* zu) {
+    LpSolver* solver = static_cast<LpSolver*>(self);
+    return solver->GetInteriorSolution(x, xl, xu, slack, y, zl, zu);
+}
+
+ipxint ipx_get_basic_solution(void* self, double* x, double* slack, double* y,
+                              double* z, ipxint* cbasis, ipxint* vbasis) {
+    LpSolver* solver = static_cast<LpSolver*>(self);
+    return solver->GetBasicSolution(x, slack, y, z, cbasis, vbasis);
+}
+
+struct ipx_parameters ipx_get_parameters(void* self) {
+    LpSolver* solver = static_cast<LpSolver*>(self);
+    return solver->GetParameters();
+}
+
+void ipx_set_parameters(void* self, struct ipx_parameters new_parameters) {
+    LpSolver* solver = static_cast<LpSolver*>(self);
+    solver->SetParameters(new_parameters);
+}
+
+void ipx_clear_model(void* self) {
+    LpSolver* solver = static_cast<LpSolver*>(self);
+    solver->ClearModel();
+}
+
+ipxint ipx_get_basis(void* self, ipxint* cbasis, ipxint* vbasis) {
+    LpSolver* solver = static_cast<LpSolver*>(self);
+    return solver->GetBasis(cbasis, vbasis);
+}
+
+ipxint ipx_get_iterate(void* self, double* x, double* y, double* zl,
+                       double* zu, double* xl, double* xu) {
+    LpSolver* solver = static_cast<LpSolver*>(self);
+    return solver->GetIterate(x, y, zl, zu, xl, xu);
+}
+
+ipxint ipx_get_kktmatrix(void* self, ipxint* AIp, ipxint* AIi, double* AIx,
+                         double* g) {
+    LpSolver* solver = static_cast<LpSolver*>(self);
+    return solver->GetKKTMatrix(AIp, AIi, AIx, g);
+}
+
+ipxint ipx_symbolic_invert(void* self, ipxint* rowcounts, ipxint* colcounts) {
+    LpSolver* solver = static_cast<LpSolver*>(self);
+    return solver->SymbolicInvert(rowcounts, colcounts);
+}

data/ext/lpsolver-highs/highs/ipm/ipx/ipx_c.h

@@ -0,0 +1,47 @@
+#ifndef IPX_C_H_
+#define IPX_C_H_
+
+#include "ipm/ipx/ipx_config.h"
+#include "ipm/ipx/ipx_info.h"
+#include "ipm/ipx/ipx_parameters.h"
+#include "ipm/ipx/ipx_status.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+    /* These functions call their equivalent method of LpSolver for
+       the object pointed to by @self. See highs/lp_solver.h for
+       documentation of the methods. */
+    ipxint ipx_load_model(void* self, ipxint num_var, const double* obj,
+                          const double* lb, const double* ub, ipxint num_constr,
+                          const ipxint* Ap, const ipxint* Ai, const double* Ax,
+                          const double* rhs, const char* constr_type);
+    ipxint ipx_load_ipm_starting_point(void* self, const double* x,
+                                       const double* xl, const double* xu,
+                                       const double* slack, const double* y,
+                                       const double* zl, const double* zu);
+    ipxint ipx_solve(void* self);
+    struct ipx_info ipx_get_info(void* self);
+    ipxint ipx_get_interior_solution(void* self, double* x, double* xl,
+                                     double* xu, double* slack, double* y,
+                                     double* zl, double* zu);
+    ipxint ipx_get_basic_solution(void* self, double* x, double* slack,
+                                  double* y, double* z,
+                                  ipxint* cbasis, ipxint* vbasis);
+    struct ipx_parameters ipx_get_parameters(void* self);
+    void ipx_set_parameters(void* self, struct ipx_parameters);
+    void ipx_clear_model(void* self);
+
+    /* for debugging */
+    ipxint ipx_get_iterate(void* self, double* x, double* y, double* zl,
+                           double* zu, double* xl, double* xu);
+    ipxint ipx_get_basis(void* self, ipxint* cbasis, ipxint* vbasis);
+    ipxint ipx_get_kktmatrix(void* self, ipxint* AIp, ipxint* AIi, double* AIx,
+                             double* g);
+    ipxint ipx_symbolic_invert(void* self, ipxint* rowcounts,
+                               ipxint* colcounts);
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* IPX_C_H_ */

data/ext/lpsolver-highs/highs/ipm/ipx/ipx_config.h

@@ -0,0 +1,9 @@
+#ifndef IPX_CONFIG_H_
+#define IPX_CONFIG_H_
+
+#include <stdint.h>
+
+#include "util/HighsInt.h"
+typedef HighsInt ipxint;
+
+#endif /* IPX_CONFIG_H_ */

data/ext/lpsolver-highs/highs/ipm/ipx/ipx_info.h

@@ -0,0 +1,111 @@
+#ifndef IPX_INFO_H_
+#define IPX_INFO_H_
+
+#include "ipm/ipx/ipx_config.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+struct ipx_info {
+    ipxint status;
+    ipxint status_ipm;
+    ipxint status_crossover;
+    ipxint errflag;
+
+    /* dimension of LP model as given by user */
+    ipxint num_var;
+    ipxint num_constr;
+    ipxint num_entries;
+
+    /* dimension of constraint matrix in solver (including slack columns) */
+    ipxint num_rows_solver;
+    ipxint num_cols_solver;
+    ipxint num_entries_solver;
+
+    ipxint dualized;            /* dualized model? */
+    ipxint dense_cols;          /* # columns classified "dense" */
+
+    ipxint centring_tried;      /* centring steps tried? */
+    ipxint centring_success;    /* centring steps successful? */
+
+    /* reductions in IPM */
+    ipxint dependent_rows;      /* # dependent rows (to eq constr) removed */
+    ipxint dependent_cols;      /* # dependent cols (to free vars) removed */
+    ipxint rows_inconsistent;   /* dependent rows inconsistent? */
+    ipxint cols_inconsistent;   /* dependent cols inconsistent? */
+    ipxint primal_dropped;      /* # primal variables dropped to bound */
+    ipxint dual_dropped;        /* # dual variables dropped to zero */
+
+    /* interior solution */
+    double abs_presidual;       /* max violation A*x+s=rhs, x-xl=lb, x+xu=ub */
+    double abs_dresidual;       /* max violation A'y+zl-zu=obj */
+    double rel_presidual;       /* relative primal residual */
+    double rel_dresidual;       /* relative dual residual */
+    double pobjval;             /* primal objective */
+    double dobjval;             /* dual objective */
+    double rel_objgap;          /* relative gap between primal and dual obj */
+    double complementarity;     /* zl'xl + zu'xu + y'slack */
+    double normx;               /* infnorm(x) */
+    double normy;               /* infnorm(y) */
+    double normz;               /* infnorm(zl,zu) */
+
+    /* basic solution */
+    double objval;              /* (primal) objective */
+    double primal_infeas;       /* max violation of lb <= x <= ub */
+    double dual_infeas;         /* max violation of sign condition on (y,z) */
+
+    /* operation counts */
+    ipxint iter;                /* # interior point iterations */
+    ipxint kktiter1;            /* # linear solver iterations before switch */
+    ipxint kktiter2;            /* # linear solver iterations after switch */
+    ipxint basis_repairs;       /* # basis repairs after crash, < 0 discarded */
+    ipxint updates_start;       /* # basis updates for starting basis */
+    ipxint updates_ipm;         /* # basis updates in IPM */
+    ipxint updates_crossover;   /* # basis updates in crossover */
+
+    /* major computation times */
+    double time_total;          /* total runtime (wallclock) */
+    double time_ipm1;           /* IPM before switch */
+    double time_ipm2;           /* IPM after switch (without starting basis) */
+    double time_starting_basis; /* constructing starting basis */
+    double time_crossover;      /* crossover */
+
+    /* profiling linear solver */
+    double time_kkt_factorize;  /* factorize/build precond for KKT matrix */
+    double time_kkt_solve;      /* linear system solves with KKT matrix */
+    double time_maxvol;         /* algorithm "maxvolume" */
+    double time_cr1;            /* CR method with diag precond */
+    double time_cr1_AAt;        /* ... matrix-vector products with AA' */
+    double time_cr1_pre;        /* ... preconditioner (diag+dense col) */
+    double time_cr2;            /* CR method with basis precond */
+    double time_cr2_NNt;        /* ... matrix-vector products with NN' */
+    double time_cr2_B;          /* ... solves with B */
+    double time_cr2_Bt;         /* ... solves with B' */
+
+    /* profiling basis factorization */
+    double ftran_sparse;        /* fraction of FTRAN solutions sparse */
+    double btran_sparse;        /* fraction of BTRAN solutions sparse */
+    double time_ftran;          /* all FTRAN operations */
+    double time_btran;          /* all BTRAN operations */
+    double time_lu_invert;      /* LU factorizations */
+    double time_lu_update;      /* LU updates */
+    double mean_fill;           /* geom. mean of LU fill factors */
+    double max_fill;            /* max LU fill factor */
+    double time_symb_invert;    /* computing row/column counts of inverse(B) */
+
+    /* analysis of algorithm maxvolume */
+    ipxint maxvol_updates;      /* # basis updates */
+    ipxint maxvol_skipped;      /* # columns computed but basis not updated */
+    ipxint maxvol_passes;       /* # passes over tableau matrix */
+    ipxint tbl_nnz;             /* nnz in tbl matrix computed */
+    double tbl_max;             /* max entry in tbl matrix computed */
+    double frobnorm_squared;    /* Frobnorm^2 of tbl matrix computed */
+    double lambdamax;           /* max eigenval of transformed normal matrix */
+    double volume_increase;     /* base-2 log of volume(new)/volume(old) */
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* IPX_INFO_H_ */

data/ext/lpsolver-highs/highs/ipm/ipx/ipx_internal.h

@@ -0,0 +1,89 @@
+#ifndef IPX_INTERNAL_H_
+#define IPX_INTERNAL_H_
+
+#include <cstring>
+#include <valarray>
+
+#include "ipm/ipx/ipx_config.h"
+#include "ipm/ipx/ipx_info.h"
+#include "ipm/ipx/ipx_parameters.h"
+#include "ipm/ipx/ipx_status.h"
+
+namespace ipx {
+
+using Int = ipxint;
+
+struct Info : public ipx_info {
+  Info() { std::memset(this, 0, sizeof(Info)); }
+};
+
+struct Parameters : public ipx_parameters {
+  Parameters() {
+    display = 1;
+    logfile = nullptr;
+    print_interval = 60.0;
+    analyse_basis_data = false;
+    time_limit = -1.0;
+    dualize = -1;
+    scale = 1;
+    ipm_maxiter = 300;
+    ipm_feasibility_tol = 1e-6;
+    ipm_optimality_tol = 1e-8;
+    ipm_drop_primal = 1e-9;
+    ipm_drop_dual = 1e-9;
+    kkt_tol = 0.3;
+    crash_basis = 1;
+    dependency_tol = 1e-6;
+    volume_tol = 2.0;
+    rows_per_slice = 10000;
+    maxskip_updates = 10;
+    lu_kernel = 0;
+    lu_pivottol = 0.0625;
+    run_crossover = 1;
+    start_crossover_tol = 1e-8;
+    pfeasibility_tol = 1e-7;
+    dfeasibility_tol = 1e-7;
+    debug = 0;
+    switchiter = -1;
+    stop_at_switch = 0;
+    update_heuristic = 1;
+    maxpasses = -1;
+    run_centring = 0;
+    max_centring_steps = 5;
+    centring_ratio_tolerance = 100.0;
+    centring_ratio_reduction = 1.5;
+    centring_alpha_scaling = 0.5;
+    bad_products_tolerance = 3;
+    highs_logging = false;
+    timeless_log = false;
+    log_options = nullptr;
+  }
+
+  Parameters(const ipx_parameters& p) : ipx_parameters(p) {}
+};
+
+using Vector = std::valarray<double>;
+
+// A vector is treated sparse if it has no more than kHypersparseThreshold * dim
+// nonzeros.
+static constexpr double kHypersparseThreshold = 0.1;
+
+// When LU factorization is used for rank detection, columns of the active
+// submatrix whose maximum entry is <= kLuDependencyTol are removed immediately
+// without choosing a pivot.
+static constexpr double kLuDependencyTol = 1e-3;
+
+// A fresh LU factorization is considered unstable if
+//   ||b-Bx|| / (||b||+||B||*||x||) > kLuStabilityThreshold,
+// where x=B\b is computed from the LU factors, b has components +/- 1 that are
+// chosen to make x large, and ||.|| is the 1-norm. An unstable factorization
+// triggers tightening of the pivot tolerance and refactorization.
+static constexpr double kLuStabilityThreshold = 1e-12;
+
+// A Forrest-Tomlin LU update is declared numerically unstable if the relative
+// error in the new diagonal entry of U is larger than kFtDiagErrorTol.
+static constexpr double kFtDiagErrorTol = 1e-8;
+
+}  // namespace ipx
+
+#endif // IPX_INTERNAL_H_

data/ext/lpsolver-highs/highs/ipm/ipx/ipx_parameters.h

@@ -0,0 +1,76 @@
+#ifndef IPX_PARAMETERS_H_
+#define IPX_PARAMETERS_H_
+
+#include "io/HighsIO.h"
+#include "ipm/ipx/ipx_config.h"
+#include <iostream>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+struct ipx_parameters {
+    /* Solver control */
+    ipxint display;
+    const char* logfile;
+    double print_interval;
+    double time_limit;
+    bool analyse_basis_data;
+
+    /* Preprocessing */
+    ipxint dualize;
+    ipxint scale;
+
+    /* Interior point method */
+    ipxint ipm_maxiter;
+    double ipm_feasibility_tol;
+    double ipm_optimality_tol;
+    double ipm_drop_primal;
+    double ipm_drop_dual;
+
+    /* Linear solver */
+    double kkt_tol;
+
+    /* Basis construction in IPM */
+    ipxint crash_basis;
+    double dependency_tol;
+    double volume_tol;
+    ipxint rows_per_slice;
+    ipxint maxskip_updates;
+
+    /* LU factorization */
+    ipxint lu_kernel;
+    double lu_pivottol;
+
+    /* Crossover */
+    ipxint run_crossover;
+    double start_crossover_tol;
+    double pfeasibility_tol;
+    double dfeasibility_tol;
+
+    /* Debugging */
+    ipxint debug;
+    ipxint switchiter;
+    ipxint stop_at_switch;
+    ipxint update_heuristic;
+    ipxint maxpasses;
+
+    /* Centring */
+    ipxint run_centring;
+    ipxint max_centring_steps;
+    double centring_ratio_tolerance;
+    double centring_ratio_reduction;
+    double centring_alpha_scaling;
+    ipxint bad_products_tolerance;
+
+    /* HiGHS logging parameters */
+    bool highs_logging;
+    bool timeless_log;
+    const HighsLogOptions* log_options;
+  
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* IPX_PARAMETERS_H_ */

data/ext/lpsolver-highs/highs/ipm/ipx/ipx_status.h

@@ -0,0 +1,57 @@
+#ifndef IPX_STATUS_H_
+#define IPX_STATUS_H_
+
+/* for status */
+#define IPX_STATUS_not_run                  0
+#define IPX_STATUS_solved                   1000
+#define IPX_STATUS_stopped                  1005
+#define IPX_STATUS_no_model                 1006
+#define IPX_STATUS_out_of_memory            1003
+#define IPX_STATUS_internal_error           1004
+
+/* for status_ipm and status_crossover */
+#define IPX_STATUS_optimal                  1
+#define IPX_STATUS_imprecise                2
+#define IPX_STATUS_primal_infeas            3
+#define IPX_STATUS_dual_infeas              4
+#define IPX_STATUS_user_interrupt           5
+#define IPX_STATUS_time_limit               6
+#define IPX_STATUS_iter_limit               7
+#define IPX_STATUS_no_progress              8
+#define IPX_STATUS_failed                   9
+#define IPX_STATUS_debug                    10
+
+/* error flags for invalid input */
+#define IPX_ERROR_argument_null             102
+#define IPX_ERROR_invalid_dimension         103
+#define IPX_ERROR_invalid_matrix            104
+#define IPX_ERROR_invalid_vector            105
+#define IPX_ERROR_invalid_basis             107
+
+/* error flags CR method */
+#define IPX_ERROR_cr_iter_limit             201
+#define IPX_ERROR_cr_matrix_not_posdef      202
+#define IPX_ERROR_cr_precond_not_posdef     203
+#define IPX_ERROR_cr_no_progress            204
+#define IPX_ERROR_cr_inf_or_nan             205
+
+/* error flags basis factorization */
+#define IPX_ERROR_basis_singular            301
+#define IPX_ERROR_basis_almost_singular     302
+#define IPX_ERROR_basis_update_singular     303
+#define IPX_ERROR_basis_repair_overflow     304
+#define IPX_ERROR_basis_repair_search       305
+#define IPX_ERROR_basis_too_ill_conditioned 306
+
+#define IPX_ERROR_lapack_chol               401
+#define IPX_ERROR_not_implemented           901
+#define IPX_ERROR_user_interrupt            998
+#define IPX_ERROR_time_interrupt            999
+
+#define IPX_basic                            0
+#define IPX_nonbasic                        -1
+#define IPX_nonbasic_lb                     -1
+#define IPX_nonbasic_ub                     -2
+#define IPX_superbasic                      -3
+
+#endif  /* IPX_STATUS_H_ */