Scippy

SoPlex

Sequential object-oriented simPlex

spxharrisrt.cpp
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-2016 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 #include <assert.h>
17 #include <iostream>
18 
19 #include "spxdefines.h"
20 #include "spxharrisrt.h"
21 
22 namespace soplex
23 {
24 /**@todo suspicious: *max is not set, but it is used
25  * (with the default setting *max=1) in selectLeave and selectEnter
26  * The question might be if max shouldn't be updated with themax?
27  *
28  * numCycle and maxCycle are integers. So degeneps will be
29  * exactly delta until numCycle >= maxCycle. Then it will be
30  * 0 until numCycle >= 2 * maxCycle, after wich it becomes
31  * negative. This does not look ok.
32  */
34 {
35  return solver()->delta()
36  * (1.0 - solver()->numCycle() / solver()->maxCycle());
37 }
38 
40  Real* /*max*/, /* max abs value in upd */
41  Real* val, /* initial and chosen value */
42  int num, /* # of indices in idx */
43  const int* idx, /* nonzero indices in upd */
44  const Real* upd, /* update vector for vec */
45  const Real* vec, /* current vector */
46  const Real* low, /* lower bounds for vec */
47  const Real* up, /* upper bounds for vec */
48  Real epsilon) const /* what is 0? */
49 {
50  Real x;
51  Real theval;
52  /**@todo patch suggests using *max instead of themax */
53  Real themax;
54  int sel;
55  int i;
56 
57  assert(*val >= 0);
58 
59  theval = *val;
60  themax = 0;
61  sel = -1;
62 
63  while (num--)
64  {
65  i = idx[num];
66  x = upd[i];
67  if (x > epsilon)
68  {
69  themax = (x > themax) ? x : themax;
70  x = (up[i] - vec[i] + delta) / x;
71  if (x < theval && up[i] < infinity)
72  theval = x;
73  }
74  else if (x < -epsilon)
75  {
76  themax = (-x > themax) ? -x : themax;
77  x = (low[i] - vec[i] - delta) / x;
78  if (x < theval && low[i] > -infinity)
79  theval = x;
80  }
81  }
82  *val = theval;
83  return sel;
84 }
85 
86 /**@todo suspicious: *max is not set, but it is used
87  (with the default setting *max=1)
88  in selectLeave and selectEnter
89 */
91  Real* /*max*/, /* max abs value in upd */
92  Real* val, /* initial and chosen value */
93  int num, /* # of indices in idx */
94  const int* idx, /* nonzero indices in upd */
95  const Real* upd, /* update vector for vec */
96  const Real* vec, /* current vector */
97  const Real* low, /* lower bounds for vec */
98  const Real* up, /* upper bounds for vec */
99  Real epsilon) const /* what is 0? */
100 {
101  Real x;
102  Real theval;
103  /**@todo patch suggests using *max instead of themax */
104  Real themax;
105  int sel;
106  int i;
107 
108  assert(*val < 0);
109 
110  theval = *val;
111  themax = 0;
112  sel = -1;
113 
114  while (num--)
115  {
116  i = idx[num];
117  x = upd[i];
118  if (x > epsilon)
119  {
120  themax = (x > themax) ? x : themax;
121  x = (low[i] - vec[i] - delta) / x;
122  if (x > theval && low[i] > -infinity)
123  theval = x;
124  }
125  else if (x < -epsilon)
126  {
127  themax = (-x > themax) ? -x : themax;
128  x = (up[i] - vec[i] + delta) / x;
129  if (x > theval && up[i] < infinity)
130  theval = x;
131  }
132  }
133  *val = theval;
134  return sel;
135 }
136 
137 /**
138  Here comes our implementation of the Harris procedure improved by shifting
139  bounds. The basic idea is to used the tolerated infeasibility within
140  solver()->entertol() for searching numerically stable pivots.
141 
142  The algorithms operates in two phases. In a first phase, the maximum \p val
143  is determined, when infeasibility within solver()->entertol() is allowed. In the second
144  phase, between all variables with values < \p val the one is selected which
145  gives the best step forward in the simplex iteration. However, this may not
146  allways yield an improvement. In that case, we shift the variable toward
147  infeasibility and retry. This avoids cycling in the shifted LP.
148  */
150 {
151  int i, j;
152  Real stab, x, y;
153  Real max;
154  Real sel;
155  Real lastshift;
156  Real useeps;
157  int leave = -1;
158  Real maxabs = 1;
159 
160  Real epsilon = solver()->epsilon();
161  Real degeneps = degenerateEps();
162 
163  SSVector& upd = solver()->fVec().delta();
164  Vector& vec = solver()->fVec();
165 
166  const Vector& up = solver()->ubBound();
167  const Vector& low = solver()->lbBound();
168 
169  assert(delta > epsilon);
170  assert(epsilon > 0);
171  assert(solver()->maxCycle() > 0);
172 
173  max = val;
174  lastshift = solver()->shift();
175 
176  solver()->fVec().delta().setup();
177 
178  if (max > epsilon)
179  {
180  // phase 1:
181  maxDelta(
182  &maxabs, /* max abs value in upd */
183  &max, /* initial and chosen value */
184  upd.size(), /* # of indices in upd */
185  upd.indexMem(), /* nonzero indices in upd */
186  upd.values(), /* update vector for vec */
187  vec.get_const_ptr(), /* current vector */
188  low.get_const_ptr(), /* lower bounds for vec */
189  up.get_const_ptr(), /* upper bounds for vec */
190  epsilon); /* what is 0? */
191 
192  if (max == val)
193  return -1;
194 
195 
196  // phase 2:
197  stab = 0;
198  sel = -infinity;
199  useeps = maxabs * epsilon * 0.001;
200  if (useeps < epsilon)
201  useeps = epsilon;
202  for (j = upd.size() - 1; j >= 0; --j)
203  {
204  i = upd.index(j);
205  x = upd[i];
206  if (x > useeps)
207  {
208  y = up[i] - vec[i];
209  if (y < -degeneps)
210  solver()->shiftUBbound(i, vec[i]); // ensure simplex improvement
211  else
212  {
213  y /= x;
214  if (y <= max && y > sel - epsilon && x > stab)
215  {
216  sel = y;
217  leave = i;
218  stab = x;
219  }
220  }
221  }
222  else if (x < -useeps)
223  {
224  y = low[i] - vec[i];
225  if (y > degeneps)
226  solver()->shiftLBbound(i, vec[i]); // ensure simplex improvement
227  else
228  {
229  y /= x;
230  if (y <= max && y > sel - epsilon && -x > stab)
231  {
232  sel = y;
233  leave = i;
234  stab = -x;
235  }
236  }
237  }
238  else
239  upd.clearNum(j);
240  }
241  }
242 
243 
244  else if (max < -epsilon)
245  {
246  // phase 1:
247  minDelta(
248  &maxabs, /* max abs value in upd */
249  &max, /* initial and chosen value */
250  upd.size(), /* # of indices in upd */
251  upd.indexMem(), /* nonzero indices in upd */
252  upd.values(), /* update vector for vec */
253  vec.get_const_ptr(), /* current vector */
254  low.get_const_ptr(), /* lower bounds for vec */
255  up.get_const_ptr(), /* upper bounds for vec */
256  epsilon); /* what is 0? */
257 
258  if (max == val)
259  return -1;
260 
261  // phase 2:
262  stab = 0;
263  sel = infinity;
264  useeps = maxabs * epsilon * 0.001;
265  if (useeps < epsilon)
266  useeps = epsilon;
267  for (j = upd.size() - 1; j >= 0; --j)
268  {
269  i = upd.index(j);
270  x = upd[i];
271  if (x < -useeps)
272  {
273  y = up[i] - vec[i];
274  if (y < -degeneps)
275  solver()->shiftUBbound(i, vec[i]); // ensure simplex improvement
276  else
277  {
278  y /= x;
279  if (y >= max && y < sel + epsilon && -x > stab)
280  {
281  sel = y;
282  leave = i;
283  stab = -x;
284  }
285  }
286  }
287  else if (x > useeps)
288  {
289  y = low[i] - vec[i];
290  if (y > degeneps)
291  solver()->shiftLBbound(i, vec[i]); // ensure simplex improvement
292  else
293  {
294  y /= x;
295  if (y >= max && y < sel + epsilon && x > stab)
296  {
297  sel = y;
298  leave = i;
299  stab = x;
300  }
301  }
302  }
303  else
304  upd.clearNum(j);
305  }
306  }
307 
308  else
309  return -1;
310 
311 
312  if (lastshift != solver()->shift())
313  return selectLeave(val, 0);
314 
315  assert(leave >= 0);
316 
317  val = sel;
318  return leave;
319 }
320 
321 
323 {
324  int i, j;
325  SPxId enterId;
326  Real stab, x, y;
327  Real max = 0.0;
328  Real sel = 0.0;
329  Real lastshift;
330  Real cuseeps;
331  Real ruseeps;
332  Real cmaxabs = 1;
333  Real rmaxabs = 1;
334  int pnr, cnr;
335 
336  Real minStability = 0.0001;
337  Real epsilon = solver()->epsilon();
338  Real degeneps = degenerateEps();
339 
340  Vector& pvec = solver()->pVec();
341  SSVector& pupd = solver()->pVec().delta();
342 
343  Vector& cvec = solver()->coPvec();
344  SSVector& cupd = solver()->coPvec().delta();
345 
346  const Vector& upb = solver()->upBound();
347  const Vector& lpb = solver()->lpBound();
348  const Vector& ucb = solver()->ucBound();
349  const Vector& lcb = solver()->lcBound();
350 
351  assert(delta > epsilon);
352  assert(epsilon > 0);
353  assert(solver()->maxCycle() > 0);
354 
355  solver()->coPvec().delta().setup();
356  solver()->pVec().delta().setup();
357 
358  if (val > epsilon)
359  {
360  for(;;)
361  {
362  pnr = -1;
363  cnr = -1;
364  max = val;
365  sel = val;
366  lastshift = solver()->shift();
367  assert(delta > epsilon);
368 
369  // phase 1:
370  maxDelta(
371  &rmaxabs, /* max abs value in upd */
372  &max, /* initial and chosen value */
373  pupd.size(), /* # of indices in pupd */
374  pupd.indexMem(), /* nonzero indices in pupd */
375  pupd.values(), /* update vector for vec */
376  pvec.get_const_ptr(), /* current vector */
377  lpb.get_const_ptr(), /* lower bounds for vec */
378  upb.get_const_ptr(), /* upper bounds for vec */
379  epsilon); /* what is 0? */
380 
381  maxDelta(
382  &cmaxabs, /* max abs value in upd */
383  &max, /* initial and chosen value */
384  cupd.size(), /* # of indices in cupd */
385  cupd.indexMem(), /* nonzero indices in cupd */
386  cupd.values(), /* update vector for vec */
387  cvec.get_const_ptr(), /* current vector */
388  lcb.get_const_ptr(), /* lower bounds for vec */
389  ucb.get_const_ptr(), /* upper bounds for vec */
390  epsilon); /* what is 0? */
391 
392  if (max == val)
393  return enterId;
394 
395 
396  // phase 2:
397  stab = 0;
398  sel = -infinity;
399  ruseeps = rmaxabs * 0.001 * epsilon;
400  if (ruseeps < epsilon)
401  ruseeps = epsilon;
402  cuseeps = cmaxabs * 0.001 * epsilon;
403  if (cuseeps < epsilon)
404  cuseeps = epsilon;
405  for (j = pupd.size() - 1; j >= 0; --j)
406  {
407  i = pupd.index(j);
408  x = pupd[i];
409  if (x > ruseeps)
410  {
411  y = upb[i] - pvec[i];
412  if (y < -degeneps)
413  solver()->shiftUPbound(i, pvec[i] - degeneps);
414  else
415  {
416  y /= x;
417  if (y <= max && x >= stab) // && y > sel-epsilon
418  {
419  enterId = solver()->id(i);
420  sel = y;
421  pnr = i;
422  stab = x;
423  }
424  }
425  }
426  else if (x < -ruseeps)
427  {
428  y = lpb[i] - pvec[i];
429  if (y > degeneps)
430  solver()->shiftLPbound(i, pvec[i] + degeneps);
431  else
432  {
433  y /= x;
434  if (y <= max && -x >= stab) // && y > sel-epsilon
435  {
436  enterId = solver()->id(i);
437  sel = y;
438  pnr = i;
439  stab = -x;
440  }
441  }
442  }
443  else
444  {
445  MSG_DEBUG( std::cout << "DHARRI01 removing value " << pupd[i] << std::endl; )
446  pupd.clearNum(j);
447  }
448  }
449  for (j = cupd.size() - 1; j >= 0; --j)
450  {
451  i = cupd.index(j);
452  x = cupd[i];
453  if (x > cuseeps)
454  {
455  y = ucb[i] - cvec[i];
456  if (y < -degeneps)
457  solver()->shiftUCbound(i, cvec[i] - degeneps);
458  else
459  {
460  y /= x;
461  if (y <= max && x >= stab) // && y > sel-epsilon
462  {
463  enterId = solver()->coId(i);
464  sel = y;
465  cnr = j;
466  stab = x;
467  }
468  }
469  }
470  else if (x < -cuseeps)
471  {
472  y = lcb[i] - cvec[i];
473  if (y > degeneps)
474  solver()->shiftLCbound(i, cvec[i] + degeneps);
475  else
476  {
477  y /= x;
478  if (y <= max && -x >= stab) // && y > sel-epsilon
479  {
480  enterId = solver()->coId(i);
481  sel = y;
482  cnr = j;
483  stab = -x;
484  }
485  }
486  }
487  else
488  {
489  MSG_DEBUG( std::cout << "DHARRI02 removing value " << cupd[i] << std::endl; )
490  cupd.clearNum(j);
491  }
492  }
493 
494  if (lastshift == solver()->shift())
495  {
496  if (cnr >= 0)
497  {
498  if (solver()->isBasic(enterId))
499  {
500  cupd.clearNum(cnr);
501  continue;
502  }
503  else
504  break;
505  }
506  else if (pnr >= 0)
507  {
508  pvec[pnr] = solver()->vector(pnr) * cvec;
509  if (solver()->isBasic(enterId))
510  {
511  pupd.setValue(pnr, 0.0);
512  continue;
513  }
514  else
515  {
516  x = pupd[pnr];
517  if (x > 0)
518  {
519  sel = upb[pnr] - pvec[pnr];
520  if (x < minStability && sel < delta)
521  {
522  minStability /= 2.0;
523  solver()->shiftUPbound(pnr, pvec[pnr]);
524  continue;
525  }
526  }
527  else
528  {
529  sel = lpb[pnr] - pvec[pnr];
530  if (-x < minStability && -sel < delta)
531  {
532  minStability /= 2.0;
533  solver()->shiftLPbound(pnr, pvec[pnr]);
534  continue;
535  }
536  }
537  sel /= x;
538  }
539  }
540  else
541  {
542  val = 0;
543  enterId.inValidate();
544  return enterId;
545  }
546 
547  if (sel > max) // instability detected => recompute
548  continue; // ratio test with corrected value
549  break;
550  }
551  }
552  }
553  else if (val < -epsilon)
554  {
555  for(;;)
556  {
557  pnr = -1;
558  cnr = -1;
559  max = val;
560  sel = val;
561  lastshift = solver()->shift();
562  assert(delta > epsilon);
563 
564 
565  // phase 1:
566  minDelta
567  (
568  &rmaxabs, /* max abs value in upd */
569  &max, /* initial and chosen value */
570  pupd.size(), /* # of indices in pupd */
571  pupd.indexMem(), /* nonzero indices in pupd */
572  pupd.values(), /* update vector for vec */
573  pvec.get_const_ptr(), /* current vector */
574  lpb.get_const_ptr(), /* lower bounds for vec */
575  upb.get_const_ptr(), /* upper bounds for vec */
576  epsilon); /* what is 0? */
577 
578  minDelta
579  (
580  &cmaxabs, /* max abs value in upd */
581  &max, /* initial and chosen value */
582  cupd.size(), /* # of indices in cupd */
583  cupd.indexMem(), /* nonzero indices in cupd */
584  cupd.values(), /* update vector for vec */
585  cvec.get_const_ptr(), /* current vector */
586  lcb.get_const_ptr(), /* lower bounds for vec */
587  ucb.get_const_ptr(), /* upper bounds for vec */
588  epsilon); /* what is 0? */
589 
590  if (max == val)
591  return enterId;
592 
593 
594  // phase 2:
595  stab = 0;
596  sel = infinity;
597  ruseeps = rmaxabs * epsilon * 0.001;
598  cuseeps = cmaxabs * epsilon * 0.001;
599  for (j = pupd.size() - 1; j >= 0; --j)
600  {
601  i = pupd.index(j);
602  x = pupd[i];
603  if (x > ruseeps)
604  {
605  y = lpb[i] - pvec[i];
606  if (y > degeneps)
607  solver()->shiftLPbound(i, pvec[i]); // ensure simplex improvement
608  else
609  {
610  y /= x;
611  if (y >= max && x > stab) // && y < sel+epsilon
612  {
613  enterId = solver()->id(i);
614  sel = y;
615  pnr = i;
616  stab = x;
617  }
618  }
619  }
620  else if (x < -ruseeps)
621  {
622  y = upb[i] - pvec[i];
623  if (y < -degeneps)
624  solver()->shiftUPbound(i, pvec[i]); // ensure simplex improvement
625  else
626  {
627  y /= x;
628  if (y >= max && -x > stab) // && y < sel+epsilon
629  {
630  enterId = solver()->id(i);
631  sel = y;
632  pnr = i;
633  stab = -x;
634  }
635  }
636  }
637  else
638  {
639  MSG_DEBUG( std::cout << "DHARRI03 removing value " << pupd[i] << std::endl; )
640  pupd.clearNum(j);
641  }
642  }
643  for (j = cupd.size() - 1; j >= 0; --j)
644  {
645  i = cupd.index(j);
646  x = cupd[i];
647  if (x > cuseeps)
648  {
649  y = lcb[i] - cvec[i];
650  if (y > degeneps)
651  solver()->shiftLCbound(i, cvec[i]); // ensure simplex improvement
652  else
653  {
654  y /= x;
655  if (y >= max && x > stab) // && y < sel+epsilon
656  {
657  enterId = solver()->coId(i);
658  sel = y;
659  cnr = j;
660  stab = x;
661  }
662  }
663  }
664  else if (x < -cuseeps)
665  {
666  y = ucb[i] - cvec[i];
667  if (y < -degeneps)
668  solver()->shiftUCbound(i, cvec[i]); // ensure simplex improvement
669  else
670  {
671  y /= x;
672  if (y >= max && -x > stab) // && y < sel+epsilon
673  {
674  enterId = solver()->coId(i);
675  sel = y;
676  cnr = j;
677  stab = -x;
678  }
679  }
680  }
681  else
682  {
683  MSG_DEBUG( std::cout << "DHARRI04 removing value " << x << std::endl; );
684  cupd.clearNum(j);
685  }
686  }
687 
688  if (lastshift == solver()->shift())
689  {
690  if (cnr >= 0)
691  {
692  if (solver()->isBasic(enterId))
693  {
694  cupd.clearNum(cnr);
695  continue;
696  }
697  else
698  break;
699  }
700  else if (pnr >= 0)
701  {
702  pvec[pnr] = solver()->vector(pnr) * cvec;
703  if (solver()->isBasic(enterId))
704  {
705  pupd.setValue(pnr, 0.0);
706  continue;
707  }
708  else
709  {
710  x = pupd[pnr];
711  if (x > 0)
712  {
713  sel = lpb[pnr] - pvec[pnr];
714  if (x < minStability && -sel < delta)
715  {
716  minStability /= 2;
717  solver()->shiftLPbound(pnr, pvec[pnr]);
718  continue;
719  }
720  }
721  else
722  {
723  sel = upb[pnr] - pvec[pnr];
724  if (-x < minStability && sel < delta)
725  {
726  minStability /= 2;
727  solver()->shiftUPbound(pnr, pvec[pnr]);
728  continue;
729  }
730  }
731  sel /= x;
732  }
733  }
734  else
735  {
736  val = 0;
737  enterId.inValidate();
738  return enterId;
739  }
740  if (sel < max) // instability detected => recompute
741  continue; // ratio test with corrected value
742  break;
743  }
744  }
745  }
746  assert(max * val >= 0);
747  assert(enterId.type() != SPxId::INVALID);
748 
749  val = sel;
750 
751  return enterId;
752 }
753 } // namespace soplex
const R * values() const
Returns array values.
Definition: ssvectorbase.h:288
int maxDelta(Real *, Real *val, int num, const int *idx, const Real *upd, const Real *vec, const Real *low, const Real *up, Real epsilon) const
Definition: spxharrisrt.cpp:39
Real delta
allowed bound violation
const Vector & lbBound() const
lower bound for fVec.
Definition: spxsolver.h:1220
void inValidate()
makes the id invalid.
Definition: spxid.h:155
void setValue(int i, R x)
Sets i &#39;th element to x.
Definition: ssvectorbase.h:218
const R * get_const_ptr() const
Conversion to C-style pointer.
Definition: vectorbase.h:412
UpdateVector & fVec() const
feasibility vector.
Definition: spxsolver.h:1184
void shiftLBbound(int i, Real to)
shift i &#39;th lbBound to to.
Definition: spxsolver.h:1444
UpdateVector & pVec() const
pricing vector.
Definition: spxsolver.h:1339
const Vector & ubBound() const
upper bound for fVec.
Definition: spxsolver.h:1202
SPxId coId(int i) const
id of i &#39;th covector.
Definition: spxsolver.h:978
virtual Real shift() const
total current shift amount.
Definition: spxsolver.h:1482
Real delta() const
guaranteed primal and dual bound violation for optimal solution, returning the maximum of feastol() a...
Definition: spxsolver.h:705
invalid id.
Definition: spxid.h:98
Type type() const
returns the type of the id.
Definition: spxid.h:145
Real degenerateEps() const
Definition: spxharrisrt.cpp:33
Generic Ids for LP rows or columns.Both SPxColIds and SPxRowIds may be treated uniformly as SPxIds: ...
Definition: spxid.h:85
UpdateVector & coPvec() const
copricing vector.
Definition: spxsolver.h:1259
double Real
SOPLEX_DEBUG.
Definition: spxdefines.h:200
int index(int n) const
Returns index of the n &#39;th nonzero element.
Definition: ssvectorbase.h:174
#define MSG_DEBUG(x)
Definition: spxdefines.h:127
void shiftLPbound(int i, Real to)
shift i &#39;th lpBound to to.
Definition: spxsolver.h:1458
void clearNum(int n)
Sets n &#39;th nonzero element to 0 (index n must exist).
Definition: ssvectorbase.h:258
virtual SPxId selectEnter(Real &val, int)
void shiftUCbound(int i, Real to)
shift i &#39;th ucBound to to.
Definition: spxsolver.h:1465
const Vector & lcBound() const
Definition: spxsolver.h:1299
void shiftUBbound(int i, Real to)
shift i &#39;th ubBound to to.
Definition: spxsolver.h:1437
const Vector & upBound() const
Definition: spxsolver.h:1344
Debugging, floating point type and parameter definitions.
Everything should be within this namespace.
void shiftUPbound(int i, Real to)
shift i &#39;th upBound to to.
Definition: spxsolver.h:1451
Harris pricing with shifting.
void shiftLCbound(int i, Real to)
shift i &#39;th lcBound to to.
Definition: spxsolver.h:1472
const SVector & vector(int i) const
i &#39;th vector.
Definition: spxsolver.h:1018
void setup()
Initializes nonzero indices for elements with absolute values above epsilon and sets all other elemen...
Definition: ssvectorbase.h:132
int maxCycle() const
maximum number of degenerate simplex steps before we detect cycling.
Definition: spxsolver.h:755
SPxId id(int i) const
id of i &#39;th vector.
Definition: spxsolver.h:959
const Vector & lpBound() const
Definition: spxsolver.h:1365
Real epsilon() const
values are considered to be 0.
Definition: spxsolver.h:670
const Real infinity
Definition: spxdefines.cpp:26
const int * indexMem() const
Returns array indices.
Definition: ssvectorbase.h:282
SSVector & delta()
update vector , writeable
Definition: updatevector.h:122
const Vector & ucBound() const
Definition: spxsolver.h:1278
int numCycle() const
actual number of degenerate simplex steps encountered so far.
Definition: spxsolver.h:760
int size() const
Returns the number of nonzeros.
Definition: ssvectorbase.h:199
virtual SPxSolver * solver() const
returns loaded LP solver.
int minDelta(Real *, Real *val, int num, const int *idx, const Real *upd, const Real *vec, const Real *low, const Real *up, Real epsilon) const
Definition: spxharrisrt.cpp:90
virtual int selectLeave(Real &val, Real)