SoPlex Doxygen Documentation
spxratiotester.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-2012 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 spxratiotester.h
17  * @brief Abstract ratio test base class.
18  */
19 #ifndef _SPXRATIOTESTER_H_
20 #define _SPXRATIOTESTER_H_
21 
22 
23 #include <assert.h>
24 
25 #include "spxdefines.h"
26 #include "spxsolver.h"
27 
28 namespace soplex
29 {
30 
31 /**@brief Abstract ratio test base class.
32  @ingroup Algo
33 
34  Class SPxRatioTester is the virtual base class for computing the ratio
35  test within the Simplex algorithm driven by SoPlex. After a SoPlex
36  solver has been #load()%ed to an SPxRatioTester, the solver calls
37  #selectLeave() for computing the ratio test for the entering simplex and
38  #selectEnter() for computing the ratio test in leaving simplex.
39 */
40 class SPxRatioTester
41 {
42 protected:
43 
44  //-------------------------------------
45  /**@name Data */
46  //@{
47  /// the solver
48  SPxSolver* thesolver;
49  /// name of the ratio tester
50  const char* m_name;
51  /// internal storage of type
52  SPxSolver::Type m_type;
53  /// allowed bound violation
54  Real delta;
55  //@}
56 
57 public:
58 
59  //-------------------------------------
60  /**@name Access / modification */
61  //@{
62  /// get name of ratio tester.
63  virtual const char* getName() const
64  {
65  return m_name;
66  }
67  /// loads LP.
68  /** Load the solver and LP for which pricing steps are to be performed.
69  */
70  virtual void load(SPxSolver* p_solver)
71  {
72  thesolver = p_solver;
73  }
74 
75  /// unloads LP.
76  virtual void clear()
77  {
78  thesolver = 0;
79  }
80 
81  /// returns loaded LP solver.
82  virtual SPxSolver* solver() const
83  {
84  return thesolver;
85  }
86 
87  /// set allowed bound violation
88  virtual void setDelta( Real newDelta )
89  {
90  if( newDelta <= DEFAULT_EPS_ZERO )
91  delta = DEFAULT_EPS_ZERO;
92  else
93  delta = newDelta;
94  }
95 
96  /// get allowed bound violation
97  virtual Real getDelta()
98  {
99  return delta;
100  }
101  //@}
102 
103  //-------------------------------------
104  /**@name Entering / leaving */
105  //@{
106  /// selects index to leave the basis.
107  /** Method #selectLeave() is called by the loaded SoPlex solver when
108  computing the entering simplex algorithm. Its task is to select and
109  return the index of the basis variable that is to leave the basis.
110  When being called,
111  \ref SPxSolver::fVec() "fVec()" fullfills the basic bounds
112  \ref SPxSolver::lbBound() "lbBound()" and
113  \ref SPxSolver::ubBound() "ubBound()" within
114  \ref SPxSolver::entertol() "entertol()".
115  fVec().delta() is the vector by
116  which fVec() will be updated in this simplex step. Its nonzero
117  indices are stored in sorted order in fVec().idx().
118 
119  If \p val > 0, \p val is the maximum allowed update value for fVec(),
120  otherwise the minimum. Method #selectLeave() must chose \p val of the
121  same sign as passed, such that updating fVec() by \p val yields a
122  new vector that satisfies all basic bounds (within entertol). The
123  returned index, must be the index of an element of fVec(), that
124  reaches one of its bounds with this update.
125  */
126  virtual int selectLeave(Real& val, SPxId enterId) = 0;
127 
128  /// selects variable Id to enter the basis.
129  /** Method #selectEnter() is called by the loaded SoPlex solver, when
130  computing the leaving simplex algorithm. It's task is to select and
131  return the Id of the basis variable that is to enter the basis.
132  When being called,
133  \ref SPxSolver::pVec() "pVec()" fullfills the bounds
134  \ref SPxSolver::lbBound() "lbBound()" and
135  \ref SPxSolver::ubBound() "ubBound()" within
136  \ref SPxSolver::leavetol() "leavetol()".
137  Similarly,
138  \ref SPxSolver::coPvec() "coPvec()" fulfills the bounds
139  \ref SPxSolver::lbBound() "lbBound()" and
140  \ref SPxSolver::ubBound() "ubBound()" within
141  \ref SPxSolver::leavetol() "leavetol()".
142  pVec().delta() and coPvec().delta() are
143  the vectors by which pVec() and coPvec() will be updated in this
144  simplex step. Their nonzero indices are stored in sorted order in
145  pVec().idx() and coPvec().idx().
146 
147  If \p val > 0, \p val is the maximum allowed update value for pVec()
148  and coPvec(), otherwise the minimum. Method #selectEnter() must
149  chose \p val of the same sign as passed, such that updating pVec()
150  and coPvec() by \p val yields a new vector that satisfies all basic
151  bounds (within leavetol). The returned Id must be the Id of an
152  element of pVec() or coPvec(), that reaches one of its bounds
153  with this update.
154  */
155  virtual SPxId selectEnter(Real& val, int leaveIdx) = 0;
156 
157  /// sets Simplex type.
158  /** Informs pricer about (a change of) the loaded SoPlex's Type. In
159  the sequel, only the corresponding select methods may be called.
160  */
161  virtual void setType(SPxSolver::Type)
162  {}
163  //@}
164 
165  //-------------------------------------
166  /**@name Construction / destruction */
167  //@{
168  /// default constructor
169  explicit SPxRatioTester(const char* name)
170  : thesolver(0)
171  , m_name(name)
172  , delta(1e-6)
173  {}
174  /// copy constructor
175  SPxRatioTester( const SPxRatioTester& old)
176  : thesolver(old.thesolver)
177  , m_name(old.m_name)
178  , m_type(old.m_type)
179  , delta(old.delta)
180  {}
181  /// assignment operator
182  SPxRatioTester& operator=( const SPxRatioTester& rhs)
183  {
184  if(this != &rhs)
185  {
186  m_name = rhs.m_name;
187  thesolver = rhs.thesolver;
188  m_type = rhs.m_type;
189  delta = rhs.delta;
190  }
191 
192  return *this;
193  }
194  /// destructor.
195  virtual ~SPxRatioTester()
196  {
197  thesolver = 0;
198  m_name = 0;
199  }
200  /// clone function for polymorphism
201  virtual SPxRatioTester* clone() const = 0;
202  //@}
203 
204 };
205 
206 
207 } // namespace soplex
208 #endif // _SPXRATIOTESTER_H_
209 
210 //-----------------------------------------------------------------------------
211 //Emacs Local Variables:
212 //Emacs mode:c++
213 //Emacs c-basic-offset:3
214 //Emacs tab-width:8
215 //Emacs indent-tabs-mode:nil
216 //Emacs End:
217 //-----------------------------------------------------------------------------
© 2003-2013 by Zuse Institute Berlin (ZIB), Imprint Generated on Wed Jan 9 2013 for SoPlex by doxygen