casadi 3.6.4__cp39-none-win_amd64.whl → 3.6.6__cp39-none-win_amd64.whl

casadi/include/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_ */

casadi/include/highs/ipm/ipx/ipx_internal.h

@@ -0,0 +1,88 @@
+#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 = 5.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;
+    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_

casadi/include/highs/ipm/ipx/ipx_parameters.h

@@ -0,0 +1,75 @@
+#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;
+    const HighsLogOptions* log_options;
+  
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* IPX_PARAMETERS_H_ */

casadi/include/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_ */

casadi/include/highs/ipm/ipx/iterate.h

@@ -0,0 +1,328 @@
+#ifndef IPX_ITERATE_H_
+#define IPX_ITERATE_H_
+
+#include <vector>
+#include "ipm/ipx/model.h"
+
+namespace ipx {
+
+// Iterate manages the IPM iterate consisting of primal variables x[n+m],
+// xl[n+m], xu[n+m] and dual variables y[m], zl[n+m], zu[n+m], where m, n are
+// the # rows and structural columns of the model.
+//
+// Each x[j] is in one of three "states":
+//
+// "fixed":     The variable is not moved by the IPM. The IPM works as if b was
+//              reduced by x[j]*AI[:,j] and column j of AI would not be present.
+// "free":      The variable is treated by the IPM as if lb[j] and ub[j] would
+//              be infinite, regardless of their actual values.
+// "barrier":   The variable has at least one finite bound and a barrier term is
+//              added by the IPM.
+//
+// Notice that the state refers to the way the variable is treated by the IPM,
+// not to its bounds in the model. For example, a variable of fixed state might
+// have zero, one or both finite bounds in the model.
+
+class Iterate {
+public:
+    // Constructs an Iterate object associated with a model. @model must be
+    // valid as long as the object is used; no data is copied. The constructor
+    // initializes variables and states to be consistent with finite/infinite
+    // bounds in the model.
+    explicit Iterate(const Model& model);
+
+    // Copies the given values into the Iterate object and sets the state of
+    // each variable to
+    // - free     if the variable has no finite bound in the model,
+    // - barrier  otherwise.
+    // The variables must have values that are consistent with the bounds of the
+    // model; that is:
+    // - If lb[j]==-inf, then   xl[j]==inf and zl[j]==0.0.
+    // - If lb[j]> -inf, then 0<xl[j]< inf and zl[j]> 0.0.
+    // - If ub[j]==+inf, then   xu[j]==inf and zu[j]==0.0.
+    // - If ub[j]< +inf, then 0<xu[j]< inf and zu[j]> 0.0.
+    // Otherwise an assertion will fail.
+    void Initialize(const Vector& x, const Vector& xl, const Vector& xu,
+                    const Vector& y, const Vector& zl, const Vector& zu);
+
+    // Adds sp*[dx;dxl;dxu] to the primal iterate and sd*[dy;dzl;dzu] to the
+    // dual iterate (restrictions see below). Each of the pointer arguments can
+    // be NULL, in which case its entries are assumed to be 0.0.
+    // - x[j] is updated only if StateOf(j) != State::fixed.
+    // - xl[j] and zl[j] are updated only if has_barrier_lb(j). The update to
+    //                   each of xl[j] and zl[j] is truncated such that
+    //                   xl[j] >= kBarrierMin and zl[j] >= kBarrierMin.
+    // - xu[j] and zu[j] are updated only if has_barrier_ub(j). The update to
+    //                   each of xu[j] and zu[j] is truncated such that
+    //                   xu[j] >= kBarrierMin and zu[j] >= kBarrierMin.
+    // If a variable is not updated, then the entry in the step direction is not
+    // accessed.
+    void Update(double sp, const double* dx, const double* dxl,
+                const double* dxu, double sd, const double* dy,
+                const double* dzl, const double* dzu);
+
+    const Model& model() const { return model_; }
+
+    const Vector& x() const  { return x_; }
+    const Vector& xl() const { return xl_; }
+    const Vector& xu() const { return xu_; }
+    const Vector& y() const  { return y_; }
+    const Vector& zl() const { return zl_; }
+    const Vector& zu() const { return zu_; }
+
+    double x(Int j) const  { return x_[j]; }
+    double xl(Int j) const { return xl_[j]; }
+    double xu(Int j) const { return xu_[j]; }
+    double y(Int j) const  { return y_[j]; }
+    double zl(Int j) const { return zl_[j]; }
+    double zu(Int j) const { return zu_[j]; }
+
+    // Returns const references to the residual vectors
+    // rb = b-AI*x,
+    // rl = lb-x+xl,
+    // ru = ub-x-xu,
+    // rc = c-AI'y-zl+zu.
+    // Warning: The residuals are not evaluated immediately after a change to
+    // an Iterate object (such as by Update() or make_fixed()). Instead, the
+    // four residual vectors are evaluated when any of them is required, e.g.
+    // in calls to rb(), presidual(), etc. Hence if a reference to a residual
+    // vector is stored and the Iterate object is changed, you must call e.g.
+    // presidual() to ensure that the residuals are updated.
+    const Vector& rb() const;
+    const Vector& rl() const;
+    const Vector& ru() const;
+    const Vector& rc() const;
+
+    enum class State { fixed, free, barrier };
+
+    // Returns the state of variable j.
+    State StateOf(Int j) const;
+
+    // Returns true if a barrier term exists for the lower or upper bound.
+    // The following expression is true for each variable:
+    // (StateOf(j)==State::barrier) == (has_barrier_lb(j)||has_barrier_ub(j))
+    bool has_barrier_lb(Int j) const;
+    bool has_barrier_ub(Int j) const;
+
+    // Returns true if variable j is "implied", i.e. StateOf(j)==State::free
+    // but the variable has at least one finite bound in the model.
+    bool is_implied(Int j) const;
+
+    // Changes state of variable j to fixed and sets xl[j]=xu[j]=zl[j]=zu[j]=0.
+    // If @value is given, sets x[j]=@value.
+    void make_fixed(Int j);
+    void make_fixed(Int j, double value);
+
+    // Changes the state of variable j to free.
+    // make_implied_lb(j) lb[j] must be finite.
+    //                    The method leaves zl[j] and zu[j] unchanged. The cost
+    //                    coefficient of variable j in the remaining LP becomes
+    //                    c[j]-zl[j]+zu[j].
+    //                    Postprocess() sets x[j]=lb[j], zu[j]=0 and computes
+    //                    zl[j] to satisfy dual feasibility.
+    // make_implied_ub(j) ub[j] must be finite.
+    //                    The method leaves zl[j] and zu[j] unchanged. The cost
+    //                    coefficient of variable j in the remaining LP becomes
+    //                    c[j]-zl[j]+zu[j].
+    //                    Postprocess() sets x[j]=ub[j], zl[j]=0 and computes
+    //                    zu[j] to satisfy dual feasibility.
+    // make_implied_eq(j) must have lb[j]==ub[j].
+    //                    The method sets zl[j]=0 and zu[j]=0.
+    //                    Postprocess sets x[j]=lb[j] and chooses either zl[j]
+    //                    or zu[j] to be nonzero depending on the sign of the
+    //                    reduced cost.
+    void make_implied_lb(Int j);
+    void make_implied_ub(Int j);
+    void make_implied_eq(Int j);
+
+    // Returns the IPM scaling factor for variable j, which is
+    // 0                                 if StateOf(j)==State::fixed,
+    // inf                               if StateOf(j)==State::free,
+    // 1.0/sqrt(zl[j]/xl[j]+zu[j]/xu[j]) if StateOf(j)==State::barrier.
+    // In the latter case the scaling factor is finite and positive.
+    double ScalingFactor(Int j) const;
+
+    // Returns the primal/dual objective value in the LP that is currently
+    // being solved (after fixing and implying variables).
+    double pobjective() const;
+    double dobjective() const;
+
+    // Returns the primal/dual objective value obtained after postprocessing.
+    double pobjective_after_postproc() const;
+    double dobjective_after_postproc() const;
+
+    // Returns the infinity norm of [rb;rl;ru] and rc.
+    double presidual() const;
+    double dresidual() const;
+
+    // complementarity() returns the sum of the pairwise complementarity
+    // products xl[j]*zl[j] and xu[j]*zu[j] from all barrier terms. mu()
+    // returns the average, mu_min() the minimum and mu_max() the maximum.
+    double complementarity() const;
+    double mu() const;
+    double mu_min() const;
+    double mu_max() const;
+
+    // Returns true if the relative primal and dual residuals are <=
+    // feasibility_tol().
+    bool feasible() const;
+
+    // Returns true if the relative objective gap is <= optimality_tol().
+    bool optimal() const;
+
+    // Returns true if the iterate satisfies the IPM termination
+    // criterion.  If start_crossover_tol() <= 0, the termination
+    // criterion is feasible() && optimal(). If start_crossover_tol()
+    // > 0, it is additionally required that the relative residuals
+    // which result from dropping the iterate to complementarity are
+    // <= start_crossover_tol().
+    bool term_crit_reached() const;
+
+    double feasibility_tol() const { return feasibility_tol_; }
+    double optimality_tol() const { return optimality_tol_; }
+    double start_crossover_tol() const { return start_crossover_tol_; }
+
+    void feasibility_tol(double new_tol) { feasibility_tol_ = new_tol; }
+    void optimality_tol(double new_tol) { optimality_tol_ = new_tol; }
+    void start_crossover_tol(double new_tol) { start_crossover_tol_ = new_tol; }
+
+    // Substitutes x[j], xl[j], xu[j], zl[j] and zu[j] for fixed and implied
+    // variables as defined by their state. After Postprocess() the object is
+    // invalid for use as an IPM iterate.
+    void Postprocess();
+
+    // Calls Model::EvaluateInteriorSolution().
+    void EvaluatePostsolved(Info* info) const;
+
+    // Copies y and constructs x and z from the iterate such that
+    // x[j]==lb[j] || x[j]==ub[j] || z[j]==0.0 is true for each j.
+    // The method can only be called after Postprocess().
+    void DropToComplementarity(Vector& x, Vector& y, Vector& z) const;
+
+private:
+    // A (primal or dual) variable that is required to be positive in the IPM is
+    // not moved closer to zero than kBarrierMin.
+    static constexpr double kBarrierMin = 1e-30;
+
+    void assert_consistency();
+    void Evaluate() const;
+    void ComputeResiduals() const;
+    void ComputeObjectives() const;
+    void ComputeComplementarity() const;
+
+    // Computes the maximum primal and dual residual that results from dropping
+    // a barrier variable. Dropping means to set either x[j] to a bound or zl[j]
+    // and zu[j] to zero, where the decision is made by the ratios or primal to
+    // dual variables.
+    void ResidualsFromDropping(double* pres, double* dres) const;
+
+    // Internally, the state of each variable is subdivided as follows:
+    //
+    // State::barrier is represented by StateDetail::
+    //
+    //     BARRIER_LB   0 < xl < inf, xu = inf, zl > 0, zu = 0.
+    //                  The variable is moved by the barrier solver. It has a
+    //                  finite lower bound and an infinite upper bound.
+    //    
+    //     BARRIER_UB   xl = inf, 0 < xu < inf, zl = 0, zu > 0.
+    //                  The variable is moved by the barrier solver. It has an
+    //                  infinite lower bound and a finite upper bound.
+    //    
+    //     BARRIER_BOXED 0 < xl < inf, 0 < xu < inf, zl > 0, zu > 0.
+    //                   The variable is moved by the barrier solver. It has a
+    //                   finite lower bound and a finite upper bound.
+    //
+    // State::fixed is represented by StateDetail::
+    //
+    //     FIXED        xl = 0, xu = 0, zl = 0, zu = 0.
+    //                  The variable is fixed at its current x value.
+    //
+    // State::free is represented by StateDetail::
+    //
+    //     FREE         xl = inf, xu = inf, zl = 0, zu = 0.
+    //                  The variable is moved by the barrier solver. It has no
+    //                  finite bound.
+    //    
+    //     IMPLIED_LB   xl = inf, xu = inf, zl >= 0, zu >= 0
+    //                  The variable has a finite lb but is treated as free by
+    //                  the barrier solver. (The ub may or may not be finite.)
+    //                  After termination we set x = lb, zu = 0 and compute zl
+    //                  from dual feasibility.
+    //                  Evaluate() subtracts (zl-zu) from the cost coefficient
+    //                  when computing the primal objective value.
+    //    
+    //     IMPLIED_UB   xl = inf, xu = inf, zl >= 0, zu >= 0
+    //                  The variable has a finite ub but is treated as free by
+    //                  the barrier solver. (The lb may or may not be finite.)
+    //                  After termination we set x = ub, zl = 0 and compute zu
+    //                  from dual feasibility.
+    //                  Evaluate() subtracts (zl-zu) from the cost coefficient
+    //                  when computing the primal objective value.
+    //    
+    //     IMPLIED_EQ   xl = inf, xu = inf, zl = 0, zu = 0
+    //                  The variable has lb == ub but is treated as free by
+    //                  the barrier solver. After termination we set x = lb
+    //                  and compute either zl or zu from dual feasibility and
+    //                  set the other one to zero.
+    //
+    enum class StateDetail { BARRIER_LB, BARRIER_UB, BARRIER_BOXED, FREE, FIXED,
+                             IMPLIED_LB, IMPLIED_UB, IMPLIED_EQ };
+
+    const Model& model_;
+    Vector x_, xl_, xu_, y_, zl_, zu_;
+    std::vector<StateDetail> variable_state_;
+
+    // The mutable quantities have a defined value if evaluated_ is true.
+    // They are computed by Evaluate(), which is called by any method that
+    // accesses any of these quantities.
+    mutable Vector rb_, rl_, ru_, rc_;
+    mutable double pobjective_{0.0};
+    mutable double dobjective_{0.0};
+    mutable double presidual_{0.0};
+    mutable double dresidual_{0.0};
+    mutable double offset_{0.0};
+    mutable double complementarity_{0.0};
+    mutable double mu_{0.0};
+    mutable double mu_min_{0.0};
+    mutable double mu_max_{0.0};
+    mutable bool evaluated_{false};
+    bool postprocessed_{false};
+
+    double feasibility_tol_{1e-6};
+    double optimality_tol_{1e-8};
+    double start_crossover_tol_{-1.0};
+};
+
+inline Iterate::State Iterate::StateOf(Int j) const {
+    switch (variable_state_[j]) {
+    case StateDetail::FIXED:
+        return State::fixed;
+    case StateDetail::FREE:
+    case StateDetail::IMPLIED_LB:
+    case StateDetail::IMPLIED_UB:
+    case StateDetail::IMPLIED_EQ:
+        return State::free;
+    default:
+        return State::barrier;
+    }
+}
+
+inline bool Iterate::has_barrier_lb(Int j) const {
+    return variable_state_[j] == StateDetail::BARRIER_LB
+        || variable_state_[j] == StateDetail::BARRIER_BOXED;
+}
+
+inline bool Iterate::has_barrier_ub(Int j) const{
+    return variable_state_[j] == StateDetail::BARRIER_UB
+        || variable_state_[j] == StateDetail::BARRIER_BOXED;
+}
+
+inline bool Iterate::is_implied(Int j) const {
+    return variable_state_[j] == StateDetail::IMPLIED_LB
+        || variable_state_[j] == StateDetail::IMPLIED_UB
+        || variable_state_[j] == StateDetail::IMPLIED_EQ;
+}
+
+}  // namespace ipx
+
+#endif  // IPX_ITERATE_H_