SoPlex Doxygen Documentation
spxshift.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-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 //#define DEBUGGING 1
17 
18 #include <assert.h>
19 #include <iostream>
20 
21 #include "spxdefines.h"
22 #include "spxsolver.h"
23 #include "spxout.h"
24 
25 namespace soplex
26 {
27 void SPxSolver::shiftFvec()
28 {
29  METHOD( "SPxSolver::shiftFvec()" );
30 
31  /* the allowed tolerance is (rep() == COLUMN) ? feastol() : opttol() because theFvec is the primal vector in COLUMN
32  * and the dual vector in ROW representation; this is equivalent to entertol()
33  */
34  Random mult(10.0 * entertol(), 100.0 * entertol());
35  Real allow = entertol() - epsilon();
36 
37  assert(type() == ENTER);
38  assert(allow > 0);
39 
40  for (int i = dim() - 1; i >= 0; --i)
41  {
42  if (theUBbound[i] + allow < (*theFvec)[i])
43  {
44  MSG_DEBUG( spxout << "DSHIFT08 theUBbound[" << i << "] violated by " << (*theFvec)[i] - theUBbound[i] - allow << std::endl );
45 
46  if (theUBbound[i] != theLBbound[i])
47  shiftUBbound(i, (*theFvec)[i] + Real(mult));
48  else
49  {
50  shiftUBbound(i, (*theFvec)[i]);
51  theLBbound[i] = theUBbound[i];
52  }
53  }
54  else if ((*theFvec)[i] < theLBbound[i] - allow)
55  {
56  MSG_DEBUG( spxout << "DSHIFT08 theLBbound[" << i << "] violated by " << theLBbound[i] - (*theFvec)[i] - allow << std::endl );
57 
58  if (theUBbound[i] != theLBbound[i])
59  shiftLBbound(i, (*theFvec)[i] - Real(mult));
60  else
61  {
62  shiftLBbound(i, (*theFvec)[i]);
63  theUBbound[i] = theLBbound[i];
64  }
65  }
66  }
67 
68 #ifndef NDEBUG
69  testBounds();
70  MSG_DEBUG( spxout << "DSHIFT01 shiftFvec: OK" << std::endl; )
71 #endif
72 }
73 
74 // -----------------------------------------------------------------
75 
76 /*
77  This methods assumes correctly setup vectors |pVec| and |coPvec| and bound
78  vectors for leaving simplex. Then it checks all values of |pVec| and
79  |coPvec| to obey these bounds and enlarges them if neccessary.
80  */
81 void SPxSolver::shiftPvec()
82 {
83  METHOD( "SPxSolver::shiftPvec()" );
84 
85  /* the allowed tolerance is (rep() == ROW) ? feastol() : opttol() because thePvec is the primal vector in ROW and the
86  * dual vector in COLUMN representation; this is equivalent to leavetol()
87  */
88  Random mult(10.0 * leavetol(), 100.0 * leavetol());
89  Real allow = leavetol() - epsilon();
90  int i, tmp;
91 
92  assert(type() == LEAVE);
93  assert(allow > 0.0);
94 
95  for (i = dim() - 1; i >= 0; --i)
96  {
97  tmp = !isBasic(coId(i));
98  if ((*theCoUbound)[i] + allow <= (*theCoPvec)[i] && tmp)
99  {
100  if ((*theCoUbound)[i] != (*theCoLbound)[i])
101  shiftUCbound(i, (*theCoPvec)[i] + Real(mult));
102  else
103  {
104  shiftUCbound(i, (*theCoPvec)[i]);
105  (*theCoLbound)[i] = (*theCoUbound)[i];
106  }
107  }
108  else if ((*theCoLbound)[i] - allow >= (*theCoPvec)[i] && tmp)
109  {
110  if ((*theCoUbound)[i] != (*theCoLbound)[i])
111  shiftLCbound(i, (*theCoPvec)[i] - Real(mult));
112  else
113  {
114  shiftLCbound(i, (*theCoPvec)[i]);
115  (*theCoUbound)[i] = (*theCoLbound)[i];
116  }
117  }
118  }
119 
120  for (i = coDim() - 1; i >= 0; --i)
121  {
122  tmp = !isBasic(id(i));
123  if ((*theUbound)[i] + allow <= (*thePvec)[i] && tmp)
124  {
125  if ((*theUbound)[i] != (*theLbound)[i])
126  shiftUPbound(i, (*thePvec)[i] + Real(mult));
127  else
128  {
129  shiftUPbound(i, (*thePvec)[i]);
130  (*theLbound)[i] = (*theUbound)[i];
131  }
132  }
133  else if ((*theLbound)[i] - allow >= (*thePvec)[i] && tmp)
134  {
135  if ((*theUbound)[i] != (*theLbound)[i])
136  shiftLPbound(i, (*thePvec)[i] - Real(mult));
137  else
138  {
139  shiftLPbound(i, (*thePvec)[i]);
140  (*theUbound)[i] = (*theLbound)[i];
141  }
142  }
143  }
144 
145 #ifndef NDEBUG
146  testBounds();
147  MSG_DEBUG( spxout << "DSHIFT02 shiftPvec: OK" << std::endl; )
148 #endif
149 }
150 // -----------------------------------------------------------------
151 void SPxSolver::perturbMin(
152  const UpdateVector& uvec,
153  Vector& p_low,
154  Vector& p_up,
155  Real eps,
156  Real delta,
157  int start,
158  int incr)
159 {
160  METHOD( "SPxSolver::perturbMin()" );
161  assert(uvec.dim() == p_low.dim());
162  assert(uvec.dim() == p_up.dim());
163 
164  const Real* vec = uvec.get_const_ptr();
165  const Real* upd = uvec.delta().values();
166  const IdxSet& idx = uvec.delta().indices();
167  Random mult(10.0 * delta, 100.0 * delta);
168  Real x, l, u;
169  int i, j;
170 
171 #ifdef FULL_SHIFT
172  eps = delta;
173 
174  for (i = uvec.dim() - start - 1; i >= 0; i -= incr)
175  {
176  u = p_up[i];
177  l = p_low[i];
178 
179  if (p_up[i] <= vec[i] + eps)
180  {
181  p_up[i] = vec[i] + Real(mult);
182  theShift += p_up[i] - u;
183  }
184  if (p_low[i] >= vec[i] - eps)
185  {
186  p_low[i] = vec[i] - Real(mult);
187  theShift -= p_low[i] - l;
188  }
189  }
190 
191 #else // !FULL_SHIFT
192  for (j = uvec.delta().size() - start - 1; j >= 0; j -= incr)
193  {
194  i = idx.index(j);
195  x = upd[i];
196  u = p_up[i];
197  l = p_low[i];
198 
199  if (x < epsilon())
200  {
201  if (u != l && vec[i] >= u - eps)
202  {
203  p_up[i] = vec[i] + Real(mult);
204  theShift += p_up[i] - u;
205  }
206  }
207  else if (x > epsilon())
208  {
209  if (u != l && vec[i] <= l + eps)
210  {
211  p_low[i] = vec[i] - Real(mult);
212  theShift -= p_low[i] - l;
213  }
214  }
215  }
216 #endif // !FULL_SHIFT
217 }
218 // -----------------------------------------------------------------
219 void SPxSolver::perturbMax(
220  const UpdateVector& uvec,
221  Vector& p_low,
222  Vector& p_up,
223  Real eps,
224  Real delta,
225  int start,
226  int incr)
227 {
228  METHOD( "SPxSolver::perturbMax()" );
229  assert(uvec.dim() == p_low.dim());
230  assert(uvec.dim() == p_up.dim());
231 
232  const Real* vec = uvec.get_const_ptr();
233  const Real* upd = uvec.delta().values();
234  const IdxSet& idx = uvec.delta().indices();
235  Random mult(10.0 * delta, 100.0 * delta);
236  Real x, l, u;
237  int i, j;
238 
239 #ifdef FULL_SHIFT
240  eps = delta;
241  for (i = uvec.dim() - start - 1; i >= 0; i -= incr)
242  {
243  u = p_up[i];
244  l = p_low[i];
245  if (p_up[i] <= vec[i] + eps)
246  {
247  p_up[i] = vec[i] + Real(mult);
248  theShift += p_up[i] - u;
249  }
250  if (p_low[i] >= vec[i] - eps)
251  {
252  p_low[i] = vec[i] - Real(mult);
253  theShift -= p_low[i] - l;
254  }
255  }
256 
257 #else // !FULL_SHIFT
258  for (j = uvec.delta().size() - start - 1; j >= 0; j -= incr)
259  {
260  i = idx.index(j);
261  x = upd[i];
262  u = p_up[i];
263  l = p_low[i];
264  if (x > epsilon())
265  {
266  if (u != l && vec[i] >= u - eps)
267  {
268  p_up[i] = vec[i] + Real(mult);
269  theShift += p_up[i] - u;
270  }
271  }
272  else if (x < epsilon())
273  {
274  if (u != l && vec[i] <= l + eps)
275  {
276  p_low[i] = vec[i] - Real(mult);
277  theShift -= p_low[i] - l;
278  }
279  }
280  }
281 #endif // !FULL_SHIFT
282 }
283 
284 void SPxSolver::perturbMinEnter(void)
285 {
286  METHOD( "SPxSolver::perturbMinEnter()" );
287  MSG_DEBUG( spxout << "DSHIFT03 iteration= " << iteration() << ": perturbing " << shift(); )
288  fVec().delta().setup();
289  perturbMin(fVec(), lbBound(), ubBound(), epsilon(), entertol());
290  MSG_DEBUG( spxout << "\t->" << shift() << std::endl; )
291 }
292 
293 
294 void SPxSolver::perturbMaxEnter(void)
295 {
296  METHOD( "SPxSolver::perturbMaxEnter()" );
297  MSG_DEBUG( spxout << "DSHIFT04 iteration= " << iteration() << ": perturbing " << shift(); )
298  fVec().delta().setup();
299  perturbMax(fVec(), lbBound(), ubBound(), epsilon(), entertol());
300  MSG_DEBUG( spxout << "\t->" << shift() << std::endl; )
301 }
302 
303 
304 Real SPxSolver::perturbMin(
305  const UpdateVector& uvec,
306  Vector& p_low,
307  Vector& p_up,
308  Real eps,
309  Real p_delta,
310  const SPxBasis::Desc::Status* stat,
311  int start,
312  int incr) const
313 {
314  METHOD( "SPxSolver::perturbMin()" );
315  assert(uvec.dim() == p_low.dim());
316  assert(uvec.dim() == p_up.dim());
317 
318  const Real* vec = uvec.get_const_ptr();
319  const Real* upd = uvec.delta().values();
320  const IdxSet& idx = uvec.delta().indices();
321  Random mult(10*p_delta, 100*p_delta);
322  Real x, l, u;
323  int i, j;
324  Real l_theShift = 0;
325 
326 #ifdef FULL_SHIFT
327  eps = p_delta;
328  for (i = uvec.dim() - start - 1; i >= 0; i -= incr)
329  {
330  u = p_up[i];
331  l = p_low[i];
332  if (p_up[i] <= vec[i] + eps && rep()*stat[i] < 0)
333  {
334  p_up[i] = vec[i] + Real(mult);
335  l_theShift += p_up[i] - u;
336  }
337  if (p_low[i] >= vec[i] - eps && rep()*stat[i] < 0)
338  {
339  p_low[i] = vec[i] - Real(mult);
340  l_theShift -= p_low[i] - l;
341  }
342  }
343 
344 #else // !FULL_SHIFT
345  for (j = uvec.delta().size() - start - 1; j >= 0; j -= incr)
346  {
347  i = idx.index(j);
348  x = upd[i];
349  u = p_up[i];
350  l = p_low[i];
351  if (x < eps)
352  {
353  if (u != l && vec[i] >= u - eps && rep()*stat[i] < 0)
354  {
355  p_up[i] = vec[i] + Real(mult);
356  l_theShift += p_up[i] - u;
357  }
358  }
359  else if (x > eps)
360  {
361  if (u != l && vec[i] <= l + eps && rep()*stat[i] < 0)
362  {
363  p_low[i] = vec[i] - Real(mult);
364  l_theShift -= p_low[i] - l;
365  }
366  }
367  }
368 #endif // !FULL_SHIFT
369  return l_theShift;
370 }
371 
372 Real SPxSolver::perturbMax(
373  const UpdateVector& uvec,
374  Vector& p_low,
375  Vector& p_up,
376  Real eps,
377  Real p_delta,
378  const SPxBasis::Desc::Status* stat,
379  int start,
380  int incr) const
381 {
382  METHOD( "SPxSolver::perturbMax()" );
383  assert(uvec.dim() == p_low.dim());
384  assert(uvec.dim() == p_up.dim());
385 
386  const Real* vec = uvec.get_const_ptr();
387  const Real* upd = uvec.delta().values();
388  const IdxSet& idx = uvec.delta().indices();
389  Random mult(10*p_delta, 100*p_delta);
390  Real x, l, u;
391  int i, j;
392  Real l_theShift = 0;
393 
394 #ifdef FULL_SHIFT
395  eps = p_delta;
396  for (i = uvec.dim() - start - 1; i >= 0; i -= incr)
397  {
398  u = p_up[i];
399  l = p_low[i];
400  if (p_up[i] <= vec[i] + eps && rep()*stat[i] < 0)
401  {
402  p_up[i] = vec[i] + Real(mult);
403  l_theShift += p_up[i] - u;
404  }
405  if (p_low[i] >= vec[i] - eps && rep()*stat[i] < 0)
406  {
407  p_low[i] = vec[i] - Real(mult);
408  l_theShift -= p_low[i] - l;
409  }
410  }
411 
412 #else // !FULL_SHIFT
413  for (j = uvec.delta().size() - start - 1; j >= 0; j -= incr)
414  {
415  i = idx.index(j);
416  x = upd[i];
417  u = p_up[i];
418  l = p_low[i];
419  if (x > eps)
420  {
421  if (u != l && vec[i] >= u - eps && rep()*stat[i] < 0)
422  {
423  p_up[i] = vec[i] + Real(mult);
424  l_theShift += p_up[i] - u;
425  }
426  }
427  else if (x < eps)
428  {
429  if (u != l && vec[i] <= l + eps && rep()*stat[i] < 0)
430  {
431  p_low[i] = vec[i] - Real(mult);
432  l_theShift -= p_low[i] - l;
433  }
434  }
435  }
436 #endif // !FULL_SHIFT
437  return l_theShift;
438 }
439 
440 
441 void SPxSolver::perturbMinLeave(void)
442 {
443  METHOD( "SPxSolver::perturbMinLeave()" );
444  MSG_DEBUG( spxout << "DSHIFT05 iteration= " << iteration() << ": perturbing " << shift(); )
445  pVec().delta().setup();
446  coPvec().delta().setup();
447  theShift += perturbMin(pVec(), lpBound(), upBound(), epsilon(), leavetol(),
448  desc().status(), 0, 1);
449  theShift += perturbMin(coPvec(), lcBound(), ucBound(), epsilon(), leavetol(),
450  desc().coStatus(), 0, 1);
451  MSG_DEBUG( spxout << "\t->" << shift() << std::endl; )
452 }
453 
454 
455 void SPxSolver::perturbMaxLeave(void)
456 {
457  METHOD( "SPxSolver::perturbMaxLeave()" );
458  MSG_DEBUG( spxout << "DSHIFT06 iteration= " << iteration() << ": perturbing " << shift(); )
459  pVec().delta().setup();
460  coPvec().delta().setup();
461  theShift += perturbMax(pVec(), lpBound(), upBound(), epsilon(), leavetol(),
462  desc().status(), 0, 1);
463  theShift += perturbMax(coPvec(), lcBound(), ucBound(), epsilon(), leavetol(),
464  desc().coStatus(), 0, 1);
465  MSG_DEBUG( spxout << "\t->" << shift() << std::endl; )
466 }
467 
468 
469 void SPxSolver::unShift(void)
470 {
471  METHOD( "SPxSolver::unShift()" );
472  MSG_INFO3( spxout << "DSHIFT07 = " << "unshifting ..." << std::endl; );
473 
474  if (isInitialized())
475  {
476  int i;
477  Real t_up, t_low;
478  const SPxBasis::Desc& ds = desc();
479 
480  theShift = 0;
481  if (type() == ENTER)
482  {
483  Real eps = entertol();
484 
485  if (rep() == COLUMN)
486  {
487  for (i = dim(); i-- > 0;)
488  {
489  SPxId l_id = baseId(i);
490  int l_num = number(l_id);
491  if (l_id.type() == SPxId::ROW_ID)
492  {
493  t_up = -lhs(l_num);
494  t_low = -rhs(l_num);
495  }
496  else
497  {
498  assert(l_id.type() == SPxId::COL_ID);
499  t_up = upper(l_num);
500  t_low = lower(l_num);
501  }
502  if (t_up != t_low)
503  {
504  if ((*theFvec)[i] < t_up - eps)
505  theUBbound[i] = t_up;
506  else if ((*theFvec)[i] > t_up)
507  theShift += theUBbound[i] - t_up;
508  if ((*theFvec)[i] > t_low + eps)
509  theLBbound[i] = t_low;
510  else if ((*theFvec)[i] < t_low)
511  theShift -= theLBbound[i] - t_low;
512  }
513  else
514  {
515  if (theUBbound[i] > t_up)
516  theShift += theUBbound[i] - t_up;
517  else if (theLBbound[i] < t_low)
518  theShift += t_low - theLBbound[i];
519  }
520  }
521  for (i = nRows(); i-- > 0;)
522  {
523  if (!isBasic(ds.rowStatus(i)))
524  {
525  t_up = -lhs(i);
526  t_low = -rhs(i);
527  if (theURbound[i] > t_up)
528  theShift += theURbound[i] - t_up;
529  if (t_low > theLRbound[i])
530  theShift += t_low - theLRbound[i];
531  }
532  }
533  for (i = nCols(); i-- > 0;)
534  {
535  if (!isBasic(ds.colStatus(i)))
536  {
537  t_up = upper(i);
538  t_low = lower(i);
539  if (theUCbound[i] > t_up)
540  theShift += theUCbound[i] - t_up;
541  if (t_low > theLCbound[i])
542  theShift += t_low - theLCbound[i];
543  }
544  }
545  }
546  else
547  {
548  assert(rep() == ROW);
549  for (i = dim(); i-- > 0;)
550  {
551  SPxId l_id = baseId(i);
552  int l_num = number(l_id);
553  t_up = t_low = 0;
554  if (l_id.type() == SPxId::ROW_ID)
555  clearDualBounds(ds.rowStatus(l_num), t_up, t_low);
556  else
557  clearDualBounds(ds.colStatus(l_num), t_up, t_low);
558  if (theUBbound[i] != theLBbound[i])
559  {
560  if (theUBbound[i] > t_up)
561  theShift += theUBbound[i] - t_up;
562  else
563  theShift -= theUBbound[i] - t_up;
564  }
565  else
566  {
567  /* if the basic (primal or dual) variable is fixed (e.g., basis status P_FREE in row representation)
568  * then shiftFvec() and shiftPvec() do not relax the bounds, but shift both, hence they may be outside
569  * of [t_low,t_up] */
570  assert(theLBbound[i] == theUBbound[i] || theUBbound[i] >= t_up);
571  assert(theLBbound[i] == theUBbound[i] || theLBbound[i] <= t_low);
572 
573  if ((*theFvec)[i] < t_up - eps)
574  theUBbound[i] = t_up;
575  else if ((*theFvec)[i] > t_up)
576  theShift += theUBbound[i] - t_up;
577 
578  if ((*theFvec)[i] > t_low + eps)
579  theLBbound[i] = t_low;
580  else if ((*theFvec)[i] < t_low)
581  theShift -= theLBbound[i] - t_low;
582  }
583  }
584  for (i = nRows(); i-- > 0;)
585  {
586  if (!isBasic(ds.rowStatus(i)))
587  {
588  t_up = t_low = 0;
589  clearDualBounds(ds.rowStatus(i), t_up, t_low);
590  if (theURbound[i] > t_up)
591  theShift += theURbound[i] - t_up;
592  if (t_low > theLRbound[i])
593  theShift += t_low - theLRbound[i];
594  }
595  }
596  for (i = nCols(); i-- > 0;)
597  {
598  if (!isBasic(ds.colStatus(i)))
599  {
600  t_up = t_low = 0;
601  clearDualBounds(ds.colStatus(i), t_up, t_low);
602  if (theUCbound[i] > t_up)
603  theShift += theUCbound[i] - t_up;
604  if (t_low > theLCbound[i])
605  theShift += t_low - theLCbound[i];
606  }
607  }
608  }
609  }
610  else
611  {
612  assert(type() == LEAVE);
613 
614  Real eps = leavetol();
615 
616  if (rep() == COLUMN)
617  {
618  for (i = nRows(); i-- > 0;)
619  {
620  t_up = t_low = 0;
621  clearDualBounds(ds.rowStatus(i), t_up, t_low);
622  if (!isBasic(ds.rowStatus(i)))
623  {
624  if ((*theCoPvec)[i] < t_up - eps)
625  {
626  theURbound[i] = t_up;
627  if( t_up == t_low )
628  theLRbound[i] = t_low; // for fixed rows we change both bounds
629  }
630  else
631  theShift += theURbound[i] - t_up;
632  if ((*theCoPvec)[i] > t_low + eps)
633  {
634  theLRbound[i] = t_low;
635  if( t_up == t_low )
636  theURbound[i] = t_up; // for fixed rows we change both bounds
637  }
638  else
639  theShift += t_low - theLRbound[i];
640  }
641  else if (theURbound[i] > t_up)
642  theShift += theURbound[i] - t_up;
643  else if (theLRbound[i] < t_low)
644  theShift += t_low - theLRbound[i];
645  }
646  for (i = nCols(); i-- > 0;)
647  {
648  t_up = t_low = -maxObj(i);
649  clearDualBounds(ds.colStatus(i), t_low, t_up);
650  if (!isBasic(ds.colStatus(i)))
651  {
652  if ((*thePvec)[i] < -t_up - eps)
653  {
654  theUCbound[i] = -t_up;
655  if( t_up == t_low )
656  theLCbound[i] = -t_low; // for fixed variables we change both bounds
657  }
658  else
659  theShift += theUCbound[i] - (-t_up);
660  if ((*thePvec)[i] > -t_low + eps)
661  {
662  theLCbound[i] = -t_low;
663  if( t_up == t_low )
664  theUCbound[i] = -t_up; // for fixed variables we change both bounds
665  }
666  else
667  theShift += (-t_low) - theLCbound[i];
668  }
669  else if (theUCbound[i] > -t_up)
670  theShift += theUCbound[i] - (-t_up);
671  else if (theLCbound[i] < -t_low)
672  theShift += (-t_low) - theLCbound[i];
673  }
674  }
675  else
676  {
677  assert(rep() == ROW);
678  for (i = nRows(); i-- > 0;)
679  {
680  t_up = rhs(i);
681  t_low = lhs(i);
682  if (t_up == t_low)
683  {
684  if (theURbound[i] > t_up)
685  theShift += theURbound[i] - t_up;
686  else
687  theShift += t_low - theLRbound[i];
688  }
689  else
690  if (!isBasic(ds.rowStatus(i)))
691  {
692  if ((*thePvec)[i] < t_up - eps)
693  theURbound[i] = t_up;
694  else
695  theShift += theURbound[i] - t_up;
696  if ((*thePvec)[i] > t_low + eps)
697  theLRbound[i] = t_low;
698  else
699  theShift += t_low - theLRbound[i];
700  }
701  else if (theURbound[i] > t_up)
702  theShift += theURbound[i] - t_up;
703  else if (theLRbound[i] < t_low)
704  theShift += t_low - theLRbound[i];
705  }
706  for (i = nCols(); i-- > 0;)
707  {
708  t_up = upper(i);
709  t_low = lower(i);
710  if (t_up == t_low)
711  {
712  if (theUCbound[i] > t_up)
713  theShift += theUCbound[i] - t_up;
714  else
715  theShift += t_low - theLCbound[i];
716  }
717  else
718  if (!isBasic(ds.colStatus(i)))
719  {
720  if ((*theCoPvec)[i] < t_up - eps)
721  theUCbound[i] = t_up;
722  else
723  theShift += theUCbound[i] - t_up;
724  if ((*theCoPvec)[i] > t_low + eps)
725  theLCbound[i] = t_low;
726  else
727  theShift += t_low - theLCbound[i];
728  }
729  else if (theUCbound[i] > t_up)
730  theShift += theUCbound[i] - t_up;
731  else if (theLCbound[i] < t_low)
732  theShift += t_low - theLCbound[i];
733  }
734  }
735  }
736  }
737 }
738 } // namespace soplex
739 
740 //-----------------------------------------------------------------------------
741 //Emacs Local Variables:
742 //Emacs mode:c++
743 //Emacs c-basic-offset:3
744 //Emacs tab-width:8
745 //Emacs indent-tabs-mode:nil
746 //Emacs End:
747 //-----------------------------------------------------------------------------
© 2003-2013 by Zuse Institute Berlin (ZIB), Imprint Generated on Wed Jan 9 2013 for SoPlex by doxygen