casadi 3.6.4__cp312-none-win_amd64.whl → 3.6.7__cp312-none-win_amd64.whl

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

@@ -0,0 +1,351 @@
+#ifndef IPX_BASIS_H_
+#define IPX_BASIS_H_
+
+#include <memory>
+#include <vector>
+#include "ipm/ipx/control.h"
+#include "ipm/ipx/indexed_vector.h"
+#include "ipm/ipx/lu_update.h"
+#include "ipm/ipx/model.h"
+#include "ipm/ipx/sparse_matrix.h"
+
+namespace ipx {
+
+// A Basis object is associated with a model. It manages an ordered set of m
+// column indices such that AI[:,basis] is nonsingular, where AI is the
+// m-by-(n+m) matrix of the model. The class provides the usual simplex-type
+// linear algebra operations.
+
+class Basis {
+public:
+    // Constructor initializes to slack basis. The object stores a reference to
+    // a model, which must be valid as long as the basis is used. No data from
+    // model is copied.
+    Basis(const Control& control, const Model& model);
+
+    // A basis object cannot be copied (at the moment) because the LU
+    // factorization is owned by a std::unique_ptr.
+    Basis(const Basis&) = delete;
+    Basis& operator=(const Basis&) = delete;
+
+    // Move is OK.
+    Basis(Basis&&) = default;
+    // But assignment is implicitly deleted due to reference members
+    Basis& operator=(Basis&&) = delete;
+
+    ~Basis() = default;
+
+    // Returns the index of the variable at position p in the basis.
+    Int operator[](Int p) const;
+
+    // If variable j is basic, then returns its position in the basis.
+    // Otherwise returns -1.
+    Int PositionOf(Int j) const;
+
+    // Returns true if variable j is in the basis.
+    bool IsBasic(Int j) const;
+
+    // Returns true if variable j is not in the basis.
+    bool IsNonbasic(Int j) const;
+
+    // Each variable has a status from one of the following:
+    //
+    //  NONBASIC_FIXED: variable is not in the basis (and will never enter)
+    //  NONBASIC:       variable is not in the basis (but may enter)
+    //  BASIC:          variable is in the basis (but may leave)
+    //  BASIC_FREE:     variable is in the basis (and will never leave)
+    //
+    // The notes in () are not enforced or required by the implementation.
+    // From the view point of the class the two nonbasic and the two basic
+    // statuses behave the same. The four statuses are provided to make writing
+    // user code more convenient.
+    enum BasicStatus { NONBASIC_FIXED = -2, NONBASIC, BASIC, BASIC_FREE };
+
+    // Returns status of variable j.
+    BasicStatus StatusOf(Int j) const;
+
+    // Switches status of variable j to NONBASIC_FIXED. The variable must not be
+    // in the basis.
+    void FixNonbasicVariable(Int j);
+
+    // Switches status of variable j to BASIC_FREE. The variable must be in the
+    // basis.
+    void FreeBasicVariable(Int j);
+
+    // Switches status from NONBASIC_FIXED to NONBASIC for all variables.
+    void UnfixVariables();
+
+    // Switches status from BASIC_FREE to BASIC for all variables.
+    void UnfreeVariables();
+
+    // Sets the basis to the slack basis.
+    void SetToSlackBasis();
+
+    // Loads basis and factorizes it.
+    // @basic_status: size n+m array with BasicStatus of each variable
+    // Returns: IPX_ERROR_invalid_basis if the basis is invalid (basic_status
+    //          contains an invalid entry or # basic variables != m). In this
+    //          case the old basis is unchanged.
+    //          Otherwise the return code from Factorize() is returned and the
+    //          old basis has been replaced. If the given basis is singular, it
+    //          will be repaired with slack variables by the LU factorization.
+    Int Load(const int* basic_status);
+
+    // Factorizes the current basis matrix from scratch. If nonsingular, a
+    // stability check is performed afterwards and the factorization is repeated
+    // with a tighter pivot tolerance if the LU factors were unstable.
+    // Returns: IPX_ERROR_basis_singular if the factorization was singular and
+    //          slack columns have been inserted into the basis. This is not an
+    //          "error" from the view point of the Basis object, which remains
+    //          in a perfectly valid state.
+    //          0 otherwise.
+    Int Factorize();
+
+    // Returns true if the LU factorization has not been updated.
+    bool FactorizationIsFresh() const;
+
+    // Extracts L, U and permutations such that
+    //
+    //   B[rowperm,colperm] = (L+I)*U,
+    //
+    // where B is the current basis matrix, L is strictly lower triangular and
+    // U is upper triangular. All arguments can be NULL, in which case the
+    // quantity is not returned. Can only be called if FactorizationIsFresh()
+    // returns true.
+    void GetLuFactors(SparseMatrix* L, SparseMatrix* U, Int* rowperm,
+                      Int* colperm) const;
+
+    // Solves linear system with dense right-hand side.
+    // @rhs: size m right-hand side vector
+    // @lhs: size m solution vector
+    // @trans: 't' or 'T' for transposed, other character for forward system
+    // @rhs and @lhs may refer to the same object.
+    void SolveDense(const Vector& rhs, Vector& lhs, char trans) const;
+
+    // Solves linear system in preparation for update.
+    // @j:   column index defining the linear system to be solved.
+    //       If j is basic then BTRAN is computed. RHS is the unit vector
+    //       corresponding to position of j in the basis.
+    //       If j is nonbasic then FTRAN is computed. RHS is AI[:,j].
+    // @lhs: returns the solution to the linear system if given.
+    void SolveForUpdate(Int j, IndexedVector& lhs);
+    void SolveForUpdate(Int j);
+
+    // Computes a row of the (simplex) tableau matrix and performs BTRAN in
+    // preparation for an update.
+    // @jb:    basic variable. When jb is at position p in the basis, then row p
+    //         of the tableau matrix is computed.
+    // @btran: BTRAN solution
+    // @row:   returns the tableau row. Basic variables have value zero.
+    // @ignore_fixed: If true, then the tableau row entry of variables with
+    //                status NONBASIC_FIXED is set to zero.
+    // The method chooses between a sparse-vector*sparse-matrix and a
+    // dense-vector*sparse-matrix operation. Accordingly the pattern of row is
+    // or is not set up.
+    void TableauRow(Int jb, IndexedVector& btran, IndexedVector& row,
+                    bool ignore_fixed = false);
+
+    // Exchanges basic variable jb with nonbasic variable jn if the update to
+    // the factorization is stable. In detail, the following steps are done:
+    //
+    // (1)  Updates the LU factorization.
+    // (2a) If the LU update was stable, updates the basis.
+    // (2b) If the LU update was unstable, keeps the basis unchanged and
+    //      refactorizes, possibly after tightening the LU pivot tolerance.
+    //
+    // Returns:
+    // (2a) The new basis might be refactorized for speed or memory reasons.
+    //      In this case returns Factorize(). Otherwise returns 0.
+    // (2b) If the factorization was not fresh and/or the pivot tolerance was
+    //      tightened, returns Factorize(). Otherwise returns
+    //      IPX_ERROR_basis_too_ill_conditioned. In this case the Basis object
+    //      is in an inconsistent state. (A basis repair could be done here; at
+    //      the moment we simply give up.)
+    //
+    // At least one of the forward or transposed system must have been solved
+    // before in preparation for the update.
+    //
+    // @jb: Basic variable that leaves the basis. Status of jb becomes NONBASIC.
+    // @jn: Nonbasic variable that enters the basis. Status of jn becomes BASIC.
+    // @tableau_entry: entry in pivot col and pivot row of the tableau matrix.
+    // @sys: > 0 if forward system needs to be solved in preparation for update.
+    //       < 0 if transposed sys needs to be solved in preparation for update.
+    //         0 if both systems have already been solved.
+    // @exchanged: true on return if the basis exchange was performed.
+    Int ExchangeIfStable(Int jb, Int jn, double tableau_entry, int sys,
+                         bool* exchanged);
+
+    // Computes x[basic], y and z[nonbasic] such that Ax=b and A'y+z=c.
+    // @x vector of size n+m. On entry the nonbasic components of x must be set.
+    // @y vector of size m, undefined on entry.
+    // @z vector of size n+m. On entry the basic components of z must be set.
+    // On return the remaining components have been computed.
+    void ComputeBasicSolution(Vector& x, Vector& y, Vector& z) const;
+
+    // Constructs a (nonsingular) basis. Given a nonnegative weight for each
+    // column of AI, columns with larger weight are preferably chosen as basic
+    // columns. Columns with infinite weight will always become basic unless the
+    // basis matrix would become singular. Columns with zero weight will always
+    // become nonbasic unless (for a slack column) they are required to form a
+    // nonsingular basis.
+    //
+    // If parameter crash_basis is nonzero, a crash procedure is used.
+    // Otherwise the method starts with the slack basis and pivots columns with
+    // zero or infinite weight out of or into the basis one at a time.
+    //
+    // @colweights: vector of length n+m with nonnegative entries
+    void ConstructBasisFromWeights(const double* colweights, Info* info);
+
+    // Estimates the smallest singular value of the basis matrix.
+    double MinSingularValue() const;
+
+    // Computes the # structural nonzero entries per row and column of
+    // inverse(B).
+    // @rowcounts, @colcounts: either NULL or size m array
+    void SymbolicInvert(Int* rowcounts, Int* colcounts) const;
+
+    // Computes the structural density of inverse(B).
+    double DensityInverse() const;
+
+    // Returns the associated Model.
+    const Model& model() const;
+
+    // Returns statistics.
+    Int factorizations() const;       // # LU factorizations
+    Int updates_total() const;        // total # basis updates
+    double frac_ftran_sparse() const; // fraction of FTRAN solutions sparse
+    double frac_btran_sparse() const; // fraction of BTRAN solutions sparse
+    double time_factorize() const;    // time LU factorizations
+    double time_ftran() const;        // time FTRAN, including partial
+    double time_btran() const;        // time BTRAN, including partial
+    double time_update() const;       // time LU update
+    double mean_fill() const;         // geom. mean of LU fill factors
+    double max_fill() const;          // max LU fill factor
+    
+    void reportBasisData() const;
+  
+private:
+    // Basis repair terminates when the maximum absolute entry in inverse(B)
+    // is smaller than kBasisRepairThreshold. At most kMaxBasisRepair repair
+    // operations are performed.
+    static constexpr double kBasisRepairThreshold = 1e5;
+    static constexpr Int kMaxBasisRepair = 200;
+
+    // Adjusts basis_ and map2basis_ after a singular factorization. Must be
+    // called exactly once after the factorization. Returns the # slack
+    // variables inserted into the basis (0 if the factorization was
+    // nonsingular).
+    Int AdaptToSingularFactorization();
+
+    // If possible, tightens the pivot tolerance for subsequent LU
+    // factorizations. Returns true if the tolerance was tightened.
+    bool TightenLuPivotTol();
+
+    // "Crashes" a basis with preference for variables with larger weight.
+    // On return the object has been initialized to a basis that is nonsingular
+    // in exact arithmetic. The condition number of the basis matrix can be
+    // unacceptably high, however.
+    void CrashBasis(const double* colweights);
+
+    // Repairs singularities in the basis matrix by replacing basic columns by
+    // slack columns. The status of slack variables that enter the basis becomes
+    // BASIC and the status of variables that leave the basis becomes NONBASIC.
+    // On return info->basis_repairs >= 0 if repaired successfully, < 0 if
+    // failed.
+    void Repair(Info* info);
+
+    // Factorizes the basis matrix using a strict absolute pivot tolerance (if
+    // supported by the LU implementation). Does not perform the stability check
+    // that Factorize() does.
+    // @num_dropped: if not NULL, returns the # columns that were dropped from
+    //               the basis matrix and replaced by unit columns.
+    void CrashFactorize(Int* num_dropped);
+
+    // Similar to ExchangeIfStable() but is guaranteed to exchange jb and jn.
+    // If refactorization is required (either for speed or because the LU
+    // update was unstable) calls CrashFactorize() on the new basis.
+    // @num_dropped: is passed to CrashFactorize() if called; otherwise is set
+    //               to 0 if not NULL.
+    void CrashExchange(Int jb, Int jn, double tableau_entry, int sys,
+                       Int* num_dropped);
+
+    // Pivots free variables into the basis if they can replace a nonfree
+    // basic variable. A variable is "free" if its weight is infinite. If a free
+    // variable cannot be pivoted into the basis, then its column is linearly
+    // dependent on columns of free basic variables. info->dependent_cols
+    // reports the # such variables.
+    void PivotFreeVariablesIntoBasis(const double* colweights, Info* info);
+
+    // Pivots fixed variables out of the basis if they can be replaced by a
+    // nonfixed variable. A variable is "fixed" if its weight is zero. If a
+    // fixed variable cannot be pivoted out of the basis, then
+    // the rows of AI without that variable are linearly dependent.
+    // info->dependent_rows reports the # such variables.
+    void PivotFixedVariablesOutOfBasis(const double* colweights, Info* info);
+
+    const Control& control_;
+    const Model& model_;
+    std::vector<Int> basis_;    // m column indices of AI
+
+    // For 0 <= j < n+m, map2basis_[j] is one of the following:
+    //  -2:            variable is NONBASIC_FIXED
+    //  -1:            variable is NONBASIC
+    //   0 <= p < m:   variable is BASIC and at position p in the basis
+    //   m <= p < 2*m: variable is BASIC_FREE and at position p-m in the basis
+    std::vector<Int> map2basis_;
+
+    mutable std::unique_ptr<LuUpdate> lu_; // LU factorization of basis matrix
+    bool factorization_is_fresh_;  // true if LU factorization not updated
+
+    Int num_factorizations_{0};    // # LU factorizations
+    Int num_updates_{0};           // # basis updates
+    Int num_ftran_{0};             // # FTRAN operations, excluding partial
+    Int num_btran_{0};             // # BTRAN operations, excluding partial
+    Int num_ftran_sparse_{0};      // # ... with sparse solution
+    Int num_btran_sparse_{0};      // # ... with sparse solution
+    double time_ftran_{0.0};       // time for FTRAN ops, including partial
+    double time_btran_{0.0};       // time for BTRAN ops, including partial
+    double time_update_{0.0};      // time for LU updates
+    double time_factorize_{0.0};   // time for LU factorizations
+    std::vector<double> fill_factors_; // fill factors from LU factorizations
+    double sum_ftran_density_{0.0};
+    double sum_btran_density_{0.0};
+};
+
+#include <cassert>
+
+inline Int Basis::operator[](Int p) const {
+    return basis_[p];
+}
+
+inline Basis::BasicStatus Basis::StatusOf(Int j) const {
+    const Int m = model_.rows();
+    const Int p = map2basis_[j];
+    assert(p >= -2 && p < 2*m);
+    if (p < 0)
+        return p == -1 ? NONBASIC : NONBASIC_FIXED;
+    else
+        return p < m ? BASIC : BASIC_FREE;
+}
+
+inline Int Basis::PositionOf(Int j) const {
+    const Int m = model_.rows();
+    const Int p = map2basis_[j];
+    assert(p >= -2 && p < 2*m);
+    return p < 0 ? -1 : p < m ? p : p-m;
+}
+
+inline bool Basis::IsBasic(Int j) const {
+    return StatusOf(j) == BASIC || StatusOf(j) == BASIC_FREE;
+}
+
+inline bool Basis::IsNonbasic(Int j) const {
+    return StatusOf(j) == NONBASIC || StatusOf(j) == NONBASIC_FIXED;
+}
+
+// Returns x[basis] (in Matlab notation).
+Vector CopyBasic(const Vector& x, const Basis& basis);
+
+}  // namespace ipx
+
+#endif  // IPX_BASIS_H_

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

@@ -0,0 +1,74 @@
+#ifndef IPX_CONJUGATE_RESIDUALS_H_
+#define IPX_CONJUGATE_RESIDUALS_H_
+
+// Implementation of the (preconditioned) Conjugate Residuals (CR) method for
+// symmetric positive definite linear systems. Without preconditioning, the
+// method is implemented as in [1, Algorithm 6.20]. The implementation with
+// preconditioning is described in [2, Section 6.3].
+//
+// [1] Y. Saad, "Iterative Methods for Sparse Linear Systems", 2nd (2003)
+// [2] L. Schork, "Basis Preconditioning in Interior Point Methods", PhD thesis
+//     (2018)
+
+#include "ipm/ipx/control.h"
+#include "ipm/ipx/linear_operator.h"
+
+namespace ipx {
+
+class ConjugateResiduals {
+public:
+    // Constructs a ConjugateReisdual object. The object does not have any
+    // memory allocated between calls to Solve().
+    // @control for InterruptCheck() and Debug(). No parameters are accessed.
+    ConjugateResiduals(const Control& control);
+
+    // Solves C*lhs = rhs. @lhs has initial iterate on entry, solution on
+    // return. The method terminates when reaching the accuracy criterion
+    //
+    //   Infnorm(residual) <= tol               (if resscale == NULL), or
+    //   Infnorm(resscale.*residual) <= tol     (if resscale != NULL).
+    //
+    // In the latter case, @resscale must be an array of dimension @rhs.size().
+    // The method also stops after @maxiter iterations. If @maxiter < 0, a
+    // maximum of @rhs.size()+100 iterations is performed. (In exact arithmetic
+    // the solution would be found after @rhs.size() iterations. It happened on
+    // some LP models with m << n, e.g. "rvb-sub" from MIPLIB2010, that the CR
+    // method did not reach the termination criterion within m iterations,
+    // causing the IPM to fail. Giving the CR method 100 extra iterations
+    // resolved the issue on all LP models from our test set where it occurred.)
+    //
+    // If the @P argument is given, it is used as preconditioner (which
+    // approximates inverse(C)) and must be symmetric positive definite.
+    //
+    void Solve(LinearOperator& C, const Vector& rhs,
+               double tol, const double* resscale, Int maxiter, Vector& lhs);
+    void Solve(LinearOperator& C, LinearOperator& P, const Vector& rhs,
+               double tol, const double* resscale, Int maxiter, Vector& lhs);
+
+    // Returns 0 if the last call to Solve() terminated successfully (i.e.
+    // the system was solved to the required accuracy). Otherwise returns
+    // IPX_ERROR_cr_iter_limit          if iteration limit was reached
+    // IPX_ERROR_cr_matrix_not_posdef   if v'*C*v <= 0 for some vector v
+    // IPX_ERROR_cr_precond_not_posdef  if v'*P*v <= 0 for some vector v
+    // IPX_ERROR_cr_inf_or_nan          if overflow occurred
+    // IPX_ERROR_cr_no_progress         if no progress due to round-off errors
+    // IPX_ERROR_user_interrupt         if interrupted by user in control
+    // IPX_ERROR_time_interrupt         if interrupted by time limit in control
+    Int errflag() const;
+
+    // Returns the # iterations in the last call to Solve().
+    Int iter() const;
+
+    // Returns the runtime of the last call to Solve().
+    double time() const;
+
+private:
+    const Control& control_;
+    Int errflag_{0};
+    Int iter_{0};
+    double time_{0.0};
+};
+
+}  // namespace ipx
+
+#endif  // IPX_CONJUGATE_RESIDUALS_H_

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

@@ -0,0 +1,163 @@
+#ifndef IPX_CONTROL_H_
+#define IPX_CONTROL_H_
+
+#include <fstream>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include "io/HighsIO.h"
+#include "ipm/ipx/ipx_internal.h"
+#include "ipm/ipx/multistream.h"
+#include "ipm/ipx/timer.h"
+
+namespace ipx {
+
+// Class Control handles
+// (1) accessing user parameters,
+// (2) solver output,
+// (3) solver interruption.
+// Currently the solver is interrupted only by time limit. The interrupt
+// mechanism could also be used if we run IPX and a simplex code concurrently
+// and want to interrupt IPX when the simplex finished. For that reason a
+// Control object cannot be copied; assuming that one thread sets an interrupt
+// signal (not implemented yet), a call to control.InterruptCheck() from any
+// part of the solver must return nonzero. Hence we must only have references or
+// pointers to a single Control object in the whole of IPX.
+
+class Control {
+public:
+    Control();
+
+    // disallow copy and copy construction
+    Control& operator=(const Control&) = delete;
+    Control(const Control&) = delete;
+
+    // disallow move and move construction
+    Control& operator=(Control&&) = delete;
+    Control(const Control&&) = delete;
+
+    // Returns IPX_ERROR_* if interrupt is requested, 0 otherwise.
+    Int InterruptCheck(const Int ipm_iteration_count = -1) const;
+
+    // Returns output streams for log and debugging messages. The streams
+    // evaluate to false if they discard output, so that we can write
+    //
+    //   if (control.Debug(3))
+    //     control.Debug(3) << expensive_computation(...) << '\n';
+    //
+    // If the debug level is < 3, expensive_computation() is not performed.
+    void hLog(std::stringstream& logging) const;
+    void hLog(std::string str) const;
+    void hDebug(std::stringstream& logging, Int level=1) const;
+    std::ostream& Debug(Int level=1) const;
+
+    // Sends logging to HiGHS logging or the log stream according to
+    // parameters.highs_logging, if >= parameters.print_interval
+    // seconds have been elapsed since the last call to IntervalLog()
+    // or to ResetPrintInterval().
+    void hIntervalLog(std::stringstream& logging) const;
+    void ResetPrintInterval() const;
+
+    double Elapsed() const;     // total runtime
+
+    ipxint dualize() const { return parameters_.dualize; }
+    ipxint scale() const { return parameters_.scale; }
+    ipxint ipm_maxiter() const { return parameters_.ipm_maxiter; }
+    double ipm_feasibility_tol() const {
+        return parameters_.ipm_feasibility_tol; }
+    double ipm_optimality_tol() const { return parameters_.ipm_optimality_tol; }
+    double ipm_drop_primal() const { return parameters_.ipm_drop_primal; }
+    double ipm_drop_dual() const { return parameters_.ipm_drop_dual; }
+    double kkt_tol() const { return parameters_.kkt_tol; }
+    ipxint crash_basis() const { return parameters_.crash_basis; }
+    double dependency_tol() const { return parameters_.dependency_tol; }
+    double volume_tol() const { return parameters_.volume_tol; }
+    ipxint rows_per_slice() const { return parameters_.rows_per_slice; }
+    ipxint maxskip_updates() const { return parameters_.maxskip_updates; }
+    ipxint lu_kernel() const { return parameters_.lu_kernel; }
+    double lu_pivottol() const { return parameters_.lu_pivottol; }
+    ipxint run_crossover() const { return parameters_.run_crossover; }
+    double start_crossover_tol() const { return parameters_.start_crossover_tol; }
+    double pfeasibility_tol() const { return parameters_.pfeasibility_tol; }
+    double dfeasibility_tol() const { return parameters_.dfeasibility_tol; }
+    ipxint switchiter() const { return parameters_.switchiter; }
+    ipxint stop_at_switch() const { return parameters_.stop_at_switch; }
+    ipxint update_heuristic() const { return parameters_.update_heuristic; }
+    ipxint maxpasses() const { return parameters_.maxpasses; }
+    bool reportBasisData() const { return parameters_.analyse_basis_data; }
+    ipxint runCentring() const{return parameters_.run_centring; }
+    ipxint maxCentringSteps() const{return parameters_.max_centring_steps; }
+    double centringRatioTolerance() const{return parameters_.centring_ratio_tolerance; }
+    double centringRatioReduction() const {return parameters_.centring_ratio_reduction; }
+    double centringAlphaScaling() const{return parameters_.centring_alpha_scaling; }
+    ipxint badProductsTolerance() const{return parameters_.bad_products_tolerance; }
+
+    const Parameters& parameters() const;
+    void parameters(const Parameters& new_parameters);
+    void callback(HighsCallback* callback);
+
+    // Opens the log file defined in parameters.logfile, if any.
+    // Ignores if an error occurs; in this case no file log is written.
+    void OpenLogfile();
+
+    // Closes an opened log file, if any.
+    void CloseLogfile();
+
+    // Resets the total runtime counter.
+    void ResetTimer();
+
+private:
+    void MakeStream();           // composes output_
+    Parameters parameters_;
+    HighsCallback* callback_ = nullptr;
+    std::ofstream logfile_;
+    Timer timer_;                // total runtime
+    mutable Timer interval_;     // time since last interval log
+    mutable Multistream output_; // forwards to logfile and/or console
+    mutable Multistream dummy_;  // discards everything
+};
+
+// Formats integer, string literal or floating point value into a string of
+// size at least @width. So we can put formatted output into a stream without
+// altering the stream's state.
+std::string Format(Int i, int width);
+std::string Format(const char* c, int width);
+std::string Format(double d, int width, int prec,
+                   std::ios_base::fmtflags floatfield);
+
+// shortcuts
+inline std::string Scientific(double d, int width, int prec) {
+    return Format(d, width, prec, std::ios_base::scientific);
+}
+inline std::string Fixed(double d, int width, int prec) {
+    return Format(d, width, prec, std::ios_base::fixed);
+}
+inline std::string sci2(double d) { return Scientific(d,0,2); }
+inline std::string sci8(double d) { return Scientific(d,0,8); }
+inline std::string fix2(double d) { return Fixed(d,0,2); }
+inline std::string fix8(double d) { return Fixed(d,0,8); }
+
+// Formats @text into a line of fixed width and indentation.
+// This is used to print messages like
+//
+//     Number of variables:                                1464
+//     Number of constraints:                              696
+//
+// consistently via control.hLog(h_logging_stream) using 
+//
+//   h_logging_stream << Textline("Number of variables:") << 1464 << '\n'
+//                    << Textline("Number of constraints:") << 696 << '\n';
+//
+template <typename T>
+std::string Textline(const T& text) {
+    std::ostringstream s;
+    s << "    ";
+    s.setf(std::ios_base::left);
+    s.width(52);
+    s << text;
+    return s.str();
+}
+
+}  // namespace ipx
+
+#endif  // IPX_CONTROL_H_