Scippy

SoPlex

Sequential object-oriented simPlex

soplexlegacy.h
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the class library */
4 /* SoPlex --- the Sequential object-oriented simPlex. */
5 /* */
6 /* Copyright (C) 1996-2017 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SoPlex is distributed under the terms of the ZIB Academic Licence. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SoPlex; see the file COPYING. If not email to soplex@zib.de. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file soplexlegacy.h
17  * @brief preconfigured \ref soplex::SoPlexLegacy "SoPlexLegacy" LP-solver.
18  */
19 #ifndef _SOPLEXLEGACY_H_
20 #define _SOPLEXLEGACY_H_
21 
22 #include <assert.h>
23 #include <string.h>
24 
25 #include "spxsolver.h"
26 #include "spxscaler.h"
27 #include "spxsimplifier.h"
28 #include "spxsteeppr.h"
29 #include "spxboundflippingrt.h"
30 #include "spxfileio.h"
31 #include "spxweightst.h"
32 #include "slufactor.h"
33 
34 namespace soplex
35 {
36 
37 /**@class SoPlexLegacy
38  @brief Preconfigured SoPlexLegacy LP-solver.
39  @ingroup Algo
40 */
41 class SoPlexLegacy : public SPxLP
42 {
43 protected:
44 
45  //-------------------------
46  //**@name Protected data */
47  //@{
48  // SPxWeightST st; ///< weight starter
49  SLUFactor m_slu; ///< LU Factorisation
50  SPxSolver m_solver; ///< solver
51  SPxScaler* m_postScaler; ///< post-scaler
52  SPxSimplifier* m_simplifier; ///< simplifier
53  bool m_vanished; ///< did the presolver solve the problem ?
54  bool m_freePostScaler; ///< true iff m_postScaler should be freed inside of this object
55  bool m_freeSimplifier; ///< true iff m_simplifier should be freed inside of this object
58  //@}
59 
60 public:
61 
62  //---------------------------------------
63  //**@name Construction / destruction */
64  //@{
65  /// default construtor.
66  explicit SoPlexLegacy(
67  SPxOut& outstream,
70  virtual ~SoPlexLegacy();
71  /// assignment operator.
73  /// copy constructor.
74  SoPlexLegacy(const SoPlexLegacy&);
75  //@}
76 
77  /// message handler
78 // mutable SPxOut spxout;
79 
80  //---------------------------------------
81  //**@name Access / modification */
82  //@{
83 
84  /// set verbosity
85 // virtual void setVerbosity(const SPxOut::Verbosity v)
86 // {
87 // spxout.setVerbosity(v);
88 // setOutstream(spxout);
89 // }
90 
91  /// set update type for factorization.
93  {
94  m_slu.setUtype(tp);
95  }
96  /// return current Pricing.
97  inline SPxSolver::Pricing pricing() const
98  {
99  return m_solver.pricing();
100  }
101  /// set FULL or PARTIAL pricing.
103  {
104  m_solver.setPricing(pr);
105  }
106  /// return current Type.
107  inline SPxSolver::Type type() const
108  {
109  return m_solver.type();
110  }
111  /// return current basis representation.
113  {
114  return m_solver.rep();
115  }
116  /// set LEAVE or ENTER algorithm.
117  virtual void setType(SPxSolver::Type tp)
118  {
119  m_solver.setType(tp);
120  }
121  /// set ROW or COLUMN representation.
122  virtual void setRep (SPxSolver::Representation p_rep)
123  {
124  m_solver.setRep(p_rep);
125  }
126  /// setup postscaler to use. If \p destroy is true, \p scaler will be freed in destructor.
127  virtual void setPostScaler(SPxScaler* scaler, const bool destroy = false);
128  /// setup simplifier to use. If \p destroy is true, \p simpli will be freed in destructor.
129  virtual void setSimplifier(SPxSimplifier* simpli, const bool destroy = false);
130  /// has a simplifier been set?
131  inline bool has_simplifier() const
132  {
133  return m_simplifier != 0;
134  }
135  /// has a postscaler been set?
136  inline bool has_postscaler() const
137  {
138  return m_postScaler != 0;
139  }
140  /// setup pricer to use.
141  virtual void setPricer(SPxPricer* pricer, const bool destroy = false)
142  {
143  m_solver.setPricer(pricer, destroy);
144  }
145  /// setup ratio-tester to use.
146  virtual void setTester(SPxRatioTester* tester, const bool destroy = false)
147  {
148  m_solver.setTester(tester, destroy);
149  }
150  /// setup starting basis generator to use.
151  virtual void setStarter(SPxStarter* starter, const bool destroy = false)
152  {
153  m_solver.setStarter(starter, destroy);
154  }
155  /// @throw SPxStatusException if simplifier loaded, this is not yet implemented
156  /// set starting basis
158  {
159  if (has_simplifier())
160  {
161  MSG_ERROR( std::cerr << "ESOLVR04 setting starting basis with presolving not yet implemented" << std::endl; )
162  throw SPxStatusException("XSOLVR04 setting starting basis with presolving not yet implemented");
163  }
164 
165  m_colsbasisstatus.reSize(nCols());
166  for (int i = 0; i < nCols(); i++)
167  m_colsbasisstatus[i] = cols[i];
168 
169  m_rowsbasisstatus.reSize(nRows());
170  for (int i = 0; i < nRows(); i++)
171  m_rowsbasisstatus[i] = rows[i];
172  }
173  /// clear starting basis
174  virtual void clearBasis()
175  {
176  m_colsbasisstatus.clear();
177  m_rowsbasisstatus.clear();
178  m_solver.reLoad();
179  }
180  /// set time limit.
181  virtual void setTerminationTime(Real time = infinity)
182  {
183  m_solver.setTerminationTime(time);
184  }
185  /// return time limit.
186  inline Real terminationTime() const
187  {
188  return m_solver.terminationTime();
189  }
190  /// set iteration limit.
191  virtual void setTerminationIter(int iter = -1)
192  {
193  m_solver.setTerminationIter(iter);
194  }
195  /// return iteration limit.
196  inline int terminationIter() const
197  {
198  return m_solver.terminationIter();
199  }
200  /// set objective limit.
201  virtual void setTerminationValue(Real val = infinity)
202  {
203  m_solver.setTerminationValue(val);
204  }
205  /// return objective limit.
206  inline Real terminationValue() const
207  {
208  return m_solver.terminationValue();
209  }
210  /// allowed primal feasibility tolerance.
211  virtual Real feastol() const
212  {
213  return m_solver.feastol();
214  }
215  /// allowed optimality, i.e., dual feasibility tolerance.
216  virtual Real opttol() const
217  {
218  return m_solver.opttol();
219  }
220  /// guaranteed primal and dual bound violation for optimal solution, returning the maximum of feastol() and opttol(), i.e., the less tight tolerance.
221  virtual Real delta() const
222  {
223  return m_solver.delta();
224  }
225  /// set parameter \p feastol.
226  virtual void setFeastol(Real d)
227  {
228  m_solver.setFeastol(d);
229  }
230  /// set parameter \p opttol.
231  virtual void setOpttol(Real d)
232  {
233  m_solver.setOpttol(d);
234  }
235  /// set parameter \p delta, i.e., set \p feastol and \p opttol to same value.
236  virtual void setDelta(Real d)
237  {
238  m_solver.setDelta(d);
239  }
240  //@}
241 
242  //---------------------------------------
243  //**@name Solving and solution query */
244  //@{
245  /// @throw SPxStatusException if no problem loaded
246  virtual SPxSolver::Status solve();
247  ///
248  virtual Real objValue() const;
249  ///
250  virtual SPxSolver::Status getPrimal(Vector& vector) const;
251  ///
252  virtual SPxSolver::Status getSlacks(Vector& vector) const;
253  ///
254  virtual SPxSolver::Status getDual(Vector& vector) const;
255  ///
256  virtual SPxSolver::Status getRedCost(Vector& vector) const;
257 
258  /// gets basis status for a single row.
260 
261  /// gets basis status for a single column.
263 
264  /// get current basis, and return solver status.
266 
267  const char* getColName(
268  int idx,
269  const NameSet* cnames,
270  char* buf)
271  {
272  assert(buf != 0);
273  assert(idx >= 0);
274  assert(idx < nCols());
275 
276  if (cnames != 0)
277  {
278  DataKey key = cId(idx);
279 
280  if (cnames->has(key))
281  return (*cnames)[key];
282  }
283  spxSnprintf(buf, SPX_MAXSTRLEN, "x%d", idx);
284 
285  return buf;
286  }
287 
288  const char* getRowName(
289  int idx,
290  const NameSet* rnames,
291  char* buf)
292  {
293  assert(buf != 0);
294  assert(idx >= 0);
295  assert(idx < nRows());
296 
297  if (rnames != 0)
298  {
299  DataKey key = rId(idx);
300 
301  if (rnames->has(key))
302  return (*rnames)[key];
303  }
304  spxSnprintf(buf, SPX_MAXSTRLEN, "C%d", idx);
305 
306  return buf;
307  }
308 
309  /// @throw SPxStatusException if simplifier loaded, this is not yet
310  /// implemented
311  virtual SPxSolver::Status getPrimalray(Vector& vector) const;
312 
313  /// @throw SPxStatusException if simplifier loaded, this is not yet
314  /// implemented
315  virtual SPxSolver::Status getDualfarkas(Vector& vector) const;
316 
317  /// get violation of constraints.
318  virtual void qualConstraintViolation(Real& maxviol, Real& sumviol) const;
319  /// get violations of bounds.
320  virtual void qualBoundViolation(Real& maxviol, Real& sumviol) const;
321 #if 0
322  /// get the residuum |Ax-b|.
323  virtual void qualSlackViolation(Real& maxviol, Real& sumviol) const;
324  /// get violation of optimality criterion.
325  virtual void qualRedCostViolation(Real& maxviol, Real& sumviol) const;
326 #endif
327  /// time spent in factorizations
328  virtual Real getFactorTime() const
329  {
330  return m_vanished ? REAL(0.0) : m_slu.getFactorTime();
331  }
332  /// number of factorizations performed
333  virtual int getFactorCount() const
334  {
335  return m_vanished ? 0 : m_slu.getFactorCount();
336  }
337  /// time spent in solves
338  virtual Real getSolveTime() const
339  {
340  return m_vanished ? REAL(0.0) : m_slu.getSolveTime();
341  }
342  /// number of solves performed
343  virtual int getSolveCount() const
344  {
345  return m_vanished ? 0 : m_slu.getSolveCount();
346  }
347  ///
348  virtual int iteration() const
349  {
350  return m_vanished ? 0 : m_solver.basis().iteration();
351  }
352  ///
353  virtual bool terminate()
354  {
355  return m_solver.terminate();
356  }
357  /// returns the current status
358  virtual SPxSolver::Status status() const
359  {
360  if (m_vanished)
361  return SPxSolver::OPTIMAL;
362 
363  return m_solver.status();
364  }
365  //@}
366 
367  //---------------------------------------
368  //**@name I/O */
369  //@{
370 
371  /** Load basis from \p filename in MPS format. If \p rowNames and \p
372  * colNames are \c NULL, default names are used for the constraints and
373  * variables.
374  */
375  virtual bool readBasisFile(const char* filename,
376  const NameSet* rowNames, const NameSet* colNames);
377 
378  /** Write basis to \p filename in MPS format. If \p rowNames and \p
379  * colNames are \c NULL, default names are used for the constraints and
380  * variables.
381  */
382  virtual bool writeBasisFile(const char* filename,
383  const NameSet* rowNames, const NameSet* colNames);
384 
385  /** Write LP, basis and parameter settings of the current SPxSolver object
386  * (i.e. after simplifying and scaling).
387  * LP is written in MPS format to "\p filename".mps, basis is written in
388  * "\p filename".bas, and parameters are written to "\p filename".set.
389  * If \p rowNames and \p colNames are \c NULL, default names are used for
390  * the constraints and variables.
391  */
392  virtual bool writeState(const char* filename,
393  const NameSet* rowNames = NULL, const NameSet* colNames = NULL) const;
394 
395  /// returns statistical information in form of a string.
396  std::string statistics() const
397  {
398  return m_solver.statistics();
399  }
400  //@}
401 
402 private:
403 
404  //------------------------------------
405  //**@name Private helpers */
406  //@{
407  /// undoes preprocessing such that the unsimplified solution values and basis is available
408  void unsimplify() const;
409  //@}
410 };
411 } // namespace soplex
412 #endif // _SOPLEX_H_
const VectorBase< R > & rhs() const
Returns right hand side vector.
Definition: spxlpbase.h:219
std::string statistics() const
returns statistical information in form of a string.
Definition: soplexlegacy.h:396
int iteration() const
returns number of basis changes since last load().
Definition: spxbasis.h:545
int getSolveCount() const
number of solves performed
Definition: slufactor.h:263
SPxSolver::Status getBasis(SPxSolver::VarStatus rows[], SPxSolver::VarStatus cols[]) const
get current basis, and return solver status.
UpdateType
Specifies how to perform change method.
Definition: slufactor.h:49
SPxRowId rId(int n) const
Returns the row identifier for row n.
Definition: spxlpbase.h:562
void setRep(Representation p_rep)
switch to ROW or COLUMN representation if not already used.
Definition: spxsolver.cpp:256
#define REAL(x)
Definition: spxdefines.h:221
virtual void clearBasis()
clear starting basis
Definition: soplexlegacy.h:174
THREADLOCAL const Real infinity
Definition: spxdefines.cpp:26
virtual int iteration() const
Definition: soplexlegacy.h:348
Type
Algorithmic type.
Definition: spxsolver.h:124
Pricing pricing() const
return current Pricing.
Definition: spxsolver.h:490
std::string statistics() const
returns statistical information in form of a string.
Definition: spxsolver.h:2185
int spxSnprintf(char *t, int len, const char *s,...)
safe version of snprintf
Definition: spxdefines.h:464
virtual void setDelta(Real d)
set parameter delta, i.e., set feastol and opttol to same value.
Definition: soplexlegacy.h:236
virtual void setStarter(SPxStarter *starter, const bool destroy=false)
setup starting basis generator to use. If destroy is true, starter will be freed in destructor...
Definition: spxsolver.cpp:154
Real feastol() const
allowed primal feasibility tolerance.
Definition: spxsolver.h:786
DataKey key(int i) const
Returns DataKey of i &#39;th LPColBase in LPColSetBase.
Definition: lpcolsetbase.h:226
virtual void setTerminationIter(int iter=-1)
set iteration limit.
Definition: soplexlegacy.h:191
void setUtype(UpdateType tp)
sets update type.
Definition: slufactor.h:122
Representation
LP basis representation.
Definition: spxsolver.h:105
Real getFactorTime() const
time spent in factorizations
Definition: slufactor.h:238
void setType(Type tp)
set LEAVE or ENTER algorithm.
Definition: spxsolver.cpp:169
SPxSolver::VarStatus getBasisRowStatus(int row) const
gets basis status for a single row.
SPxSimplifier * m_simplifier
simplifier
Definition: soplexlegacy.h:52
virtual int terminationIter() const
return iteration limit.
Definition: spxsolver.cpp:1575
SPxSolver::Type type() const
return current Type.
Definition: soplexlegacy.h:107
Implementation of Sparse Linear Solver.
Abstract ratio test base class.Class SPxRatioTester is the virtual base class for computing the ratio...
virtual SPxSolver::Status getPrimal(Vector &vector) const
SoPlex start basis generation base class.SPxStarter is the virtual base class for classes generating ...
Definition: spxstarter.h:41
bool m_vanished
did the presolver solve the problem ?
Definition: soplexlegacy.h:53
void clear()
remove all elements.
Definition: dataarray.h:205
virtual void setOpttol(Real d)
set parameter opttol.
Definition: soplexlegacy.h:231
int getFactorCount() const
number of factorizations performed
Definition: slufactor.h:248
void setOpttol(Real d)
set parameter opttol.
Definition: spxsolver.cpp:941
virtual void setTester(SPxRatioTester *tester, const bool destroy=false)
setup ratio-tester to use.
Definition: soplexlegacy.h:146
Real terminationValue() const
return objective limit.
Definition: soplexlegacy.h:206
virtual void setTerminationTime(Real time=infinity)
set time limit.
Definition: spxsolver.cpp:1556
SPxSolver::Representation rep() const
return current basis representation.
Definition: soplexlegacy.h:112
virtual void setBasis(SPxSolver::VarStatus rows[], SPxSolver::VarStatus cols[])
Definition: soplexlegacy.h:157
SPxColId cId(int n) const
Returns the column identifier for column n.
Definition: spxlpbase.h:568
LP simplification base class.
Entry identifier class for items of a DataSet.Every item in a DataSet is assigned a DataKey by which ...
Definition: datakey.h:46
int nRows() const
Returns number of rows in LP.
Definition: spxlpbase.h:151
virtual int getFactorCount() const
number of factorizations performed
Definition: soplexlegacy.h:333
virtual void setFeastol(Real d)
set parameter feastol.
Definition: soplexlegacy.h:226
Steepest edge pricer.
virtual Real delta() const
guaranteed primal and dual bound violation for optimal solution, returning the maximum of feastol() a...
Definition: soplexlegacy.h:221
Leaving Simplex.
Definition: spxsolver.h:143
bool has_simplifier() const
has a simplifier been set?
Definition: soplexlegacy.h:131
declaration of types for file output
double Real
Definition: spxdefines.h:218
virtual void setPostScaler(SPxScaler *scaler, const bool destroy=false)
setup postscaler to use. If destroy is true, scaler will be freed in destructor.
SoPlexLegacy(SPxOut &outstream, SPxSolver::Type type=SPxSolver::LEAVE, SPxSolver::Representation rep=SPxSolver::COLUMN)
default construtor.
SoPlexLegacy & operator=(const SoPlexLegacy &rhs)
assignment operator.
Pricing
Pricing type.
Definition: spxsolver.h:152
Status status() const
Status of solution process.
Definition: spxsolve.cpp:1910
const char * getColName(int idx, const NameSet *cnames, char *buf)
Definition: soplexlegacy.h:267
virtual void setType(SPxSolver::Type tp)
set LEAVE or ENTER algorithm.
Definition: soplexlegacy.h:117
LP simplification abstract base class.Instances of classes derived from SPxSimplifier may be loaded t...
Definition: spxsimplifier.h:41
LP has been solved to optimality.
Definition: spxsolver.h:220
virtual bool writeState(const char *filename, const NameSet *rowNames=NULL, const NameSet *colNames=NULL) const
virtual bool terminate()
Definition: soplexlegacy.h:353
virtual void setPricer(SPxPricer *pricer, const bool destroy=false)
setup pricer to use. If destroy is true, pricer will be freed in destructor.
Definition: spxsolver.cpp:103
#define MSG_ERROR(x)
Prints out message x if the verbosity level is at least SPxOut::ERROR.
Definition: spxdefines.h:114
virtual Real terminationTime() const
return time limit.
Definition: spxsolver.cpp:1563
Wrapper for several output streams. A verbosity level is used to decide which stream to use and wheth...
Definition: spxout.h:63
virtual SPxSolver::Status getPrimalray(Vector &vector) const
main LP solver class
Real delta() const
guaranteed primal and dual bound violation for optimal solution, returning the maximum of feastol() a...
Definition: spxsolver.h:802
virtual bool writeBasisFile(const char *filename, const NameSet *rowNames, const NameSet *colNames)
Abstract pricer base class.Class SPxPricer is a pure virtual class defining the interface for pricer ...
Definition: spxpricer.h:46
virtual void setPricer(SPxPricer *pricer, const bool destroy=false)
setup pricer to use.
Definition: soplexlegacy.h:141
virtual bool readBasisFile(const char *filename, const NameSet *rowNames, const NameSet *colNames)
virtual SPxSolver::Status getSlacks(Vector &vector) const
virtual void setTerminationTime(Real time=infinity)
set time limit.
Definition: soplexlegacy.h:181
const char * getRowName(int idx, const NameSet *rnames, char *buf)
Definition: soplexlegacy.h:288
bool m_freePostScaler
true iff m_postScaler should be freed inside of this object
Definition: soplexlegacy.h:54
virtual SPxSolver::Status status() const
returns the current status
Definition: soplexlegacy.h:358
SPxSolver::VarStatus getBasisColStatus(int col) const
gets basis status for a single column.
virtual void setRep(SPxSolver::Representation p_rep)
set ROW or COLUMN representation.
Definition: soplexlegacy.h:122
bool has_postscaler() const
has a postscaler been set?
Definition: soplexlegacy.h:136
Bound flipping ratio test (long step dual) for SoPlex.
Preconfigured SoPlexLegacy LP-solver.
Definition: soplexlegacy.h:41
Set of strings.Class NameSet implements a symbol or name table. It allows to store or remove names (i...
Definition: nameset.h:61
virtual void setPricing(SPxSolver::Pricing pr)
set FULL or PARTIAL pricing.
Definition: soplexlegacy.h:102
Sequential object-oriented SimPlex.SPxSolver is an LP solver class using the revised Simplex algorith...
Definition: spxsolver.h:84
virtual void setTerminationIter(int iteration=-1)
set iteration limit.
Definition: spxsolver.cpp:1568
Implementation of Sparse Linear Solver.This class implements a SLinSolver interface by using the spar...
Definition: slufactor.h:41
Everything should be within this namespace.
virtual Real opttol() const
allowed optimality, i.e., dual feasibility tolerance.
Definition: soplexlegacy.h:216
virtual bool terminate()
Termination criterion.
Definition: spxsolve.cpp:1401
virtual void setTester(SPxRatioTester *tester, const bool destroy=false)
setup ratio-tester to use. If destroy is true, tester will be freed in destructor.
Definition: spxsolver.cpp:130
virtual Real objValue() const
Weighted start basis.
DataArray< SPxSolver::VarStatus > m_rowsbasisstatus
Definition: soplexlegacy.h:57
SPxSolver m_solver
solver
Definition: soplexlegacy.h:50
LP scaling base class.
virtual Real getFactorTime() const
time spent in factorizations
Definition: soplexlegacy.h:328
SPxScaler * m_postScaler
post-scaler
Definition: soplexlegacy.h:51
virtual Real getSolveTime() const
time spent in solves
Definition: soplexlegacy.h:338
Real terminationTime() const
return time limit.
Definition: soplexlegacy.h:186
LP scaler abstract base class.Instances of classes derived from SPxScaler may be loaded to SoPlex in ...
Definition: spxscaler.h:76
virtual Real terminationValue() const
return objective limit.
Definition: spxsolver.cpp:1625
void unsimplify() const
undoes preprocessing such that the unsimplified solution values and basis is available ...
virtual SPxSolver::Status getDual(Vector &vector) const
virtual SPxSolver::Status getDualfarkas(Vector &vector) const
Type type() const
return current Type.
Definition: spxsolver.h:484
SLUFactor m_slu
LU Factorisation.
Definition: soplexlegacy.h:49
virtual SPxSolver::Status getRedCost(Vector &vector) const
Real getSolveTime() const
time spent in solves
Definition: slufactor.h:253
bool m_freeSimplifier
true iff m_simplifier should be freed inside of this object
Definition: soplexlegacy.h:55
DataArray< SPxSolver::VarStatus > m_colsbasisstatus
Definition: soplexlegacy.h:56
virtual void setUtype(SLUFactor::UpdateType tp)
message handler
Definition: soplexlegacy.h:92
virtual void setStarter(SPxStarter *starter, const bool destroy=false)
setup starting basis generator to use.
Definition: soplexlegacy.h:151
int nCols() const
Returns number of columns in LP.
Definition: spxlpbase.h:157
Exception class for status exceptions during the computationsThis class is derived from the SoPlex ex...
Definition: exceptions.h:89
void setFeastol(Real d)
set parameter feastol.
Definition: spxsolver.cpp:929
Real opttol() const
allowed optimality, i.e., dual feasibility tolerance.
Definition: spxsolver.h:794
virtual int getSolveCount() const
number of solves performed
Definition: soplexlegacy.h:343
virtual void setTerminationValue(Real value=infinity)
set objective limit.
Definition: spxsolver.cpp:1620
virtual void qualBoundViolation(Real &maxviol, Real &sumviol) const
get violations of bounds.
const SPxBasis & basis() const
Return current basis.
Definition: spxsolver.h:1736
virtual SPxSolver::Status solve()
virtual void reLoad()
reload LP.
Definition: spxsolver.cpp:55
void reSize(int newsize)
reset size to newsize.
Definition: dataarray.h:223
Representation rep() const
return the current basis representation.
Definition: spxsolver.h:478
columnwise representation.
Definition: spxsolver.h:108
SPxSolver::Pricing pricing() const
return current Pricing.
Definition: soplexlegacy.h:97
virtual void qualConstraintViolation(Real &maxviol, Real &sumviol) const
get violation of constraints.
bool has(int pnum) const
does NameSet has a name with number pnum?
Definition: nameset.h:231
virtual void setSimplifier(SPxSimplifier *simpli, const bool destroy=false)
setup simplifier to use. If destroy is true, simpli will be freed in destructor.
virtual void setTerminationValue(Real val=infinity)
set objective limit.
Definition: soplexlegacy.h:201
int terminationIter() const
return iteration limit.
Definition: soplexlegacy.h:196
void setPricing(Pricing pr)
set FULL or PARTIAL pricing.
Definition: spxsolver.cpp:438
void setDelta(Real d)
set parameter delta, i.e., set feastol and opttol to same value.
Definition: spxsolver.cpp:953
virtual Real feastol() const
allowed primal feasibility tolerance.
Definition: soplexlegacy.h:211
#define SPX_MAXSTRLEN
Definition: spxdefines.h:249