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-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 #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, false);
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  lastshift = solver()->shift();
366  assert(delta > epsilon);
367 
368  // phase 1:
369  maxDelta(
370  &rmaxabs, /* max abs value in upd */
371  &max, /* initial and chosen value */
372  pupd.size(), /* # of indices in pupd */
373  pupd.indexMem(), /* nonzero indices in pupd */
374  pupd.values(), /* update vector for vec */
375  pvec.get_const_ptr(), /* current vector */
376  lpb.get_const_ptr(), /* lower bounds for vec */
377  upb.get_const_ptr(), /* upper bounds for vec */
378  epsilon); /* what is 0? */
379 
380  maxDelta(
381  &cmaxabs, /* max abs value in upd */
382  &max, /* initial and chosen value */
383  cupd.size(), /* # of indices in cupd */
384  cupd.indexMem(), /* nonzero indices in cupd */
385  cupd.values(), /* update vector for vec */
386  cvec.get_const_ptr(), /* current vector */
387  lcb.get_const_ptr(), /* lower bounds for vec */
388  ucb.get_const_ptr(), /* upper bounds for vec */
389  epsilon); /* what is 0? */
390 
391  if (max == val)
392  return enterId;
393 
394 
395  // phase 2:
396  stab = 0;
397  sel = -infinity;
398  ruseeps = rmaxabs * 0.001 * epsilon;
399  if (ruseeps < epsilon)
400  ruseeps = epsilon;
401  cuseeps = cmaxabs * 0.001 * epsilon;
402  if (cuseeps < epsilon)
403  cuseeps = epsilon;
404  for (j = pupd.size() - 1; j >= 0; --j)
405  {
406  i = pupd.index(j);
407  x = pupd[i];
408  if (x > ruseeps)
409  {
410  y = upb[i] - pvec[i];
411  if (y < -degeneps)
412  solver()->shiftUPbound(i, pvec[i] - degeneps);
413  else
414  {
415  y /= x;
416  if (y <= max && x >= stab) // && y > sel-epsilon
417  {
418  enterId = solver()->id(i);
419  sel = y;
420  pnr = i;
421  stab = x;
422  }
423  }
424  }
425  else if (x < -ruseeps)
426  {
427  y = lpb[i] - pvec[i];
428  if (y > degeneps)
429  solver()->shiftLPbound(i, pvec[i] + degeneps);
430  else
431  {
432  y /= x;
433  if (y <= max && -x >= stab) // && y > sel-epsilon
434  {
435  enterId = solver()->id(i);
436  sel = y;
437  pnr = i;
438  stab = -x;
439  }
440  }
441  }
442  else
443  {
444  MSG_DEBUG( std::cout << "DHARRI01 removing value " << pupd[i] << std::endl; )
445  pupd.clearNum(j);
446  }
447  }
448  for (j = cupd.size() - 1; j >= 0; --j)
449  {
450  i = cupd.index(j);
451  x = cupd[i];
452  if (x > cuseeps)
453  {
454  y = ucb[i] - cvec[i];
455  if (y < -degeneps)
456  solver()->shiftUCbound(i, cvec[i] - degeneps);
457  else
458  {
459  y /= x;
460  if (y <= max && x >= stab) // && y > sel-epsilon
461  {
462  enterId = solver()->coId(i);
463  sel = y;
464  cnr = j;
465  stab = x;
466  }
467  }
468  }
469  else if (x < -cuseeps)
470  {
471  y = lcb[i] - cvec[i];
472  if (y > degeneps)
473  solver()->shiftLCbound(i, cvec[i] + degeneps);
474  else
475  {
476  y /= x;
477  if (y <= max && -x >= stab) // && y > sel-epsilon
478  {
479  enterId = solver()->coId(i);
480  sel = y;
481  cnr = j;
482  stab = -x;
483  }
484  }
485  }
486  else
487  {
488  MSG_DEBUG( std::cout << "DHARRI02 removing value " << cupd[i] << std::endl; )
489  cupd.clearNum(j);
490  }
491  }
492 
493  if (lastshift == solver()->shift())
494  {
495  if (cnr >= 0)
496  {
497  if (solver()->isBasic(enterId))
498  {
499  cupd.clearNum(cnr);
500  continue;
501  }
502  else
503  break;
504  }
505  else if (pnr >= 0)
506  {
507  pvec[pnr] = solver()->vector(pnr) * cvec;
508  if (solver()->isBasic(enterId))
509  {
510  pupd.setValue(pnr, 0.0);
511  continue;
512  }
513  else
514  {
515  x = pupd[pnr];
516  if (x > 0)
517  {
518  sel = upb[pnr] - pvec[pnr];
519  if (x < minStability && sel < delta)
520  {
521  minStability /= 2.0;
522  solver()->shiftUPbound(pnr, pvec[pnr]);
523  continue;
524  }
525  }
526  else
527  {
528  sel = lpb[pnr] - pvec[pnr];
529  if (-x < minStability && -sel < delta)
530  {
531  minStability /= 2.0;
532  solver()->shiftLPbound(pnr, pvec[pnr]);
533  continue;
534  }
535  }
536  sel /= x;
537  }
538  }
539  else
540  {
541  val = 0;
542  enterId.inValidate();
543  return enterId;
544  }
545 
546  if (sel > max) // instability detected => recompute
547  continue; // ratio test with corrected value
548  break;
549  }
550  }
551  }
552  else if (val < -epsilon)
553  {
554  for(;;)
555  {
556  pnr = -1;
557  cnr = -1;
558  max = val;
559  lastshift = solver()->shift();
560  assert(delta > epsilon);
561 
562 
563  // phase 1:
564  minDelta
565  (
566  &rmaxabs, /* max abs value in upd */
567  &max, /* initial and chosen value */
568  pupd.size(), /* # of indices in pupd */
569  pupd.indexMem(), /* nonzero indices in pupd */
570  pupd.values(), /* update vector for vec */
571  pvec.get_const_ptr(), /* current vector */
572  lpb.get_const_ptr(), /* lower bounds for vec */
573  upb.get_const_ptr(), /* upper bounds for vec */
574  epsilon); /* what is 0? */
575 
576  minDelta
577  (
578  &cmaxabs, /* max abs value in upd */
579  &max, /* initial and chosen value */
580  cupd.size(), /* # of indices in cupd */
581  cupd.indexMem(), /* nonzero indices in cupd */
582  cupd.values(), /* update vector for vec */
583  cvec.get_const_ptr(), /* current vector */
584  lcb.get_const_ptr(), /* lower bounds for vec */
585  ucb.get_const_ptr(), /* upper bounds for vec */
586  epsilon); /* what is 0? */
587 
588  if (max == val)
589  return enterId;
590 
591 
592  // phase 2:
593  stab = 0;
594  sel = infinity;
595  ruseeps = rmaxabs * epsilon * 0.001;
596  cuseeps = cmaxabs * epsilon * 0.001;
597  for (j = pupd.size() - 1; j >= 0; --j)
598  {
599  i = pupd.index(j);
600  x = pupd[i];
601  if (x > ruseeps)
602  {
603  y = lpb[i] - pvec[i];
604  if (y > degeneps)
605  solver()->shiftLPbound(i, pvec[i]); // ensure simplex improvement
606  else
607  {
608  y /= x;
609  if (y >= max && x > stab) // && y < sel+epsilon
610  {
611  enterId = solver()->id(i);
612  sel = y;
613  pnr = i;
614  stab = x;
615  }
616  }
617  }
618  else if (x < -ruseeps)
619  {
620  y = upb[i] - pvec[i];
621  if (y < -degeneps)
622  solver()->shiftUPbound(i, pvec[i]); // ensure simplex improvement
623  else
624  {
625  y /= x;
626  if (y >= max && -x > stab) // && y < sel+epsilon
627  {
628  enterId = solver()->id(i);
629  sel = y;
630  pnr = i;
631  stab = -x;
632  }
633  }
634  }
635  else
636  {
637  MSG_DEBUG( std::cout << "DHARRI03 removing value " << pupd[i] << std::endl; )
638  pupd.clearNum(j);
639  }
640  }
641  for (j = cupd.size() - 1; j >= 0; --j)
642  {
643  i = cupd.index(j);
644  x = cupd[i];
645  if (x > cuseeps)
646  {
647  y = lcb[i] - cvec[i];
648  if (y > degeneps)
649  solver()->shiftLCbound(i, cvec[i]); // ensure simplex improvement
650  else
651  {
652  y /= x;
653  if (y >= max && x > stab) // && y < sel+epsilon
654  {
655  enterId = solver()->coId(i);
656  sel = y;
657  cnr = j;
658  stab = x;
659  }
660  }
661  }
662  else if (x < -cuseeps)
663  {
664  y = ucb[i] - cvec[i];
665  if (y < -degeneps)
666  solver()->shiftUCbound(i, cvec[i]); // ensure simplex improvement
667  else
668  {
669  y /= x;
670  if (y >= max && -x > stab) // && y < sel+epsilon
671  {
672  enterId = solver()->coId(i);
673  sel = y;
674  cnr = j;
675  stab = -x;
676  }
677  }
678  }
679  else
680  {
681  MSG_DEBUG( std::cout << "DHARRI04 removing value " << x << std::endl; );
682  cupd.clearNum(j);
683  }
684  }
685 
686  if (lastshift == solver()->shift())
687  {
688  if (cnr >= 0)
689  {
690  if (solver()->isBasic(enterId))
691  {
692  cupd.clearNum(cnr);
693  continue;
694  }
695  else
696  break;
697  }
698  else if (pnr >= 0)
699  {
700  pvec[pnr] = solver()->vector(pnr) * cvec;
701  if (solver()->isBasic(enterId))
702  {
703  pupd.setValue(pnr, 0.0);
704  continue;
705  }
706  else
707  {
708  x = pupd[pnr];
709  if (x > 0)
710  {
711  sel = lpb[pnr] - pvec[pnr];
712  if (x < minStability && -sel < delta)
713  {
714  minStability /= 2;
715  solver()->shiftLPbound(pnr, pvec[pnr]);
716  continue;
717  }
718  }
719  else
720  {
721  sel = upb[pnr] - pvec[pnr];
722  if (-x < minStability && sel < delta)
723  {
724  minStability /= 2;
725  solver()->shiftUPbound(pnr, pvec[pnr]);
726  continue;
727  }
728  }
729  sel /= x;
730  }
731  }
732  else
733  {
734  val = 0;
735  enterId.inValidate();
736  return enterId;
737  }
738  if (sel < max) // instability detected => recompute
739  continue; // ratio test with corrected value
740  break;
741  }
742  }
743  }
744  assert(max * val >= 0);
745  assert(enterId.type() != SPxId::INVALID);
746 
747  val = sel;
748 
749  return enterId;
750 }
751 } // namespace soplex
SPxId coId(int i) const
id of i &#39;th covector.
Definition: spxsolver.h:1098
const Vector & ucBound() const
Definition: spxsolver.h:1398
virtual Real shift() const
total current shift amount.
Definition: spxsolver.h:1602
virtual SPxId selectEnter(Real &val, int, bool)
THREADLOCAL const Real infinity
Definition: spxdefines.cpp:26
Real delta
allowed bound violation
virtual int selectLeave(Real &val, Real, bool)
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
Real degenerateEps() const
Definition: spxharrisrt.cpp:33
const Vector & lcBound() const
Definition: spxsolver.h:1419
void shiftLBbound(int i, Real to)
shift i &#39;th lbBound to to.
Definition: spxsolver.h:1564
invalid id.
Definition: spxid.h:98
int maxCycle() const
maximum number of degenerate simplex steps before we detect cycling.
Definition: spxsolver.h:865
const R * get_const_ptr() const
Conversion to C-style pointer.
Definition: vectorbase.h:453
const Vector & ubBound() const
upper bound for fVec.
Definition: spxsolver.h:1322
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:1379
double Real
Definition: spxdefines.h:218
const R * values() const
Returns array values.
Definition: ssvectorbase.h:299
#define MSG_DEBUG(x)
Definition: spxdefines.h:132
void shiftLPbound(int i, Real to)
shift i &#39;th lpBound to to.
Definition: spxsolver.h:1578
const Vector & lbBound() const
lower bound for fVec.
Definition: spxsolver.h:1340
SPxId id(int i) const
id of i &#39;th vector.
Definition: spxsolver.h:1079
UpdateVector & fVec() const
feasibility vector.
Definition: spxsolver.h:1304
void clearNum(int n)
Sets n &#39;th nonzero element to 0 (index n must exist).
Definition: ssvectorbase.h:269
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
Real delta() const
guaranteed primal and dual bound violation for optimal solution, returning the maximum of feastol() a...
Definition: spxsolver.h:802
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
void shiftUCbound(int i, Real to)
shift i &#39;th ucBound to to.
Definition: spxsolver.h:1585
int index(int n) const
Returns index of the n &#39;th nonzero element.
Definition: ssvectorbase.h:174
void shiftUBbound(int i, Real to)
shift i &#39;th ubBound to to.
Definition: spxsolver.h:1557
const int * indexMem() const
Returns array indices.
Definition: ssvectorbase.h:293
Real epsilon() const
values are considered to be 0.
Definition: spxsolver.h:767
Debugging, floating point type and parameter definitions.
UpdateVector & pVec() const
pricing vector.
Definition: spxsolver.h:1459
const Vector & lpBound() const
Definition: spxsolver.h:1485
int size() const
Returns the number of nonzeros.
Definition: ssvectorbase.h:199
Everything should be within this namespace.
void shiftUPbound(int i, Real to)
shift i &#39;th upBound to to.
Definition: spxsolver.h:1571
Harris pricing with shifting.
void shiftLCbound(int i, Real to)
shift i &#39;th lcBound to to.
Definition: spxsolver.h:1592
virtual SPxSolver * solver() const
returns loaded LP solver.
void setup()
Initializes nonzero indices for elements with absolute values above epsilon and sets all other elemen...
Definition: ssvectorbase.h:132
int numCycle() const
actual number of degenerate simplex steps encountered so far.
Definition: spxsolver.h:870
const Vector & upBound() const
Definition: spxsolver.h:1464
Type type() const
returns the type of the id.
Definition: spxid.h:145
const SVector & vector(int i) const
i &#39;th vector.
Definition: spxsolver.h:1138
SSVector & delta()
update vector , writeable
Definition: updatevector.h:122