source: branches/devel/Clp/src/Idiot.cpp @ 986

Last change on this file since 986 was 986, checked in by forrest, 13 years ago

whoops

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 35.9 KB
Line 
1// Copyright (C) 2002, International Business Machines
2// Corporation and others.  All Rights Reserved.
3
4#include "CoinPragma.hpp"
5#include <stdio.h>
6#include <stdarg.h>
7#include <stdlib.h>
8#include <math.h>
9#include "ClpPresolve.hpp"
10#include "Idiot.hpp"
11#include "CoinTime.hpp"
12#include "CoinMessageHandler.hpp"
13#include "CoinHelperFunctions.hpp"
14// Redefine stuff for Clp
15#ifndef OSI_IDIOT
16#include "ClpMessage.hpp"
17#define OsiObjOffset ClpObjOffset
18#endif
19/**** strategy 4 - drop, exitDrop and djTolerance all relative:
20For first two major iterations these are small.  Then:
21
22drop - exit a major iteration if drop over 5*checkFrequency < this is
23used as info->drop*(10.0+fabs(last weighted objective))
24
25exitDrop - exit idiot if feasible and drop < this is
26used as info->exitDrop*(10.0+fabs(last objective))
27
28djExit - exit a major iteration if largest dj (averaged over 5 checks)
29drops below this - used as info->djTolerance*(10.0+fabs(last weighted objective)
30
31djFlag - mostly skip variables with bad dj worse than this => 2*djExit
32
33djTol - only look at variables with dj better than this => 0.01*djExit
34****************/
35
36#define IDIOT_FIX_TOLERANCE 1e-6
37#define SMALL_IDIOT_FIX_TOLERANCE 1e-10
38int 
39Idiot::dropping(IdiotResult result,
40                    double tolerance,
41                    double small,
42                    int *nbad)
43{
44  if (result.infeas<=small) {
45    double value=CoinMax(fabs(result.objval),fabs(result.dropThis))+1.0;
46    if (result.dropThis>tolerance*value) {
47      *nbad=0;
48      return 1;
49    } else {
50      (*nbad)++;
51      if (*nbad>4) {
52        return 0;
53      } else {
54        return 1;
55      }
56    }
57  } else {
58    *nbad=0;
59    return 1;
60  }
61}
62
63/* returns -1 or start of costed slacks */
64 static int countCostedSlacks(OsiSolverInterface * model)
65{
66#ifdef OSI_IDIOT
67  const CoinPackedMatrix * matrix = model->getMatrixByCol();
68#else
69  ClpMatrixBase * matrix = model->clpMatrix();
70#endif
71  const int * row = matrix->getIndices();
72  const CoinBigIndex * columnStart = matrix->getVectorStarts();
73  const int * columnLength = matrix->getVectorLengths(); 
74  const double * element = matrix->getElements();
75  const double * rowupper = model->getRowUpper();
76  int nrows=model->getNumRows();
77  int ncols=model->getNumCols();
78  int slackStart = ncols-nrows;
79  int nSlacks=nrows;
80  int i;
81 
82  if (ncols<=nrows) return -1;
83  while (1) {
84    for (i=0;i<nrows;i++) {
85      int j=i+slackStart;
86      CoinBigIndex k=columnStart[j];
87      if (columnLength[j]==1) {
88        if (row[k]!=i||element[k]!=1.0) {
89          nSlacks=0;
90          break;
91        }
92      } else {
93        nSlacks=0;
94        break;
95      }
96      if (rowupper[i]<=0.0) {
97        nSlacks=0;
98        break;
99      }
100    }
101    if (nSlacks||!slackStart) break;
102    slackStart=0;
103  }
104  if (!nSlacks) slackStart=-1;
105  return slackStart;
106}
107void
108Idiot::crash(int numberPass, CoinMessageHandler * handler,const CoinMessages *messages)
109{
110  // lightweight options
111  int numberColumns = model_->getNumCols();
112  const double * objective = model_->getObjCoefficients();
113  int nnzero=0;
114  double sum=0.0;
115  int i;
116  for (i=0;i<numberColumns;i++) {
117    if (objective[i]) {
118      sum += fabs(objective[i]);
119      nnzero++;
120    }
121  }
122  sum /= (double) (nnzero+1);
123  if (maxIts_==5)
124    maxIts_=2;
125  if (numberPass<=0)
126    // Cast to double to avoid VACPP complaining
127    majorIterations_=(int)(2+log10((double)(numberColumns+1)));
128  else
129    majorIterations_=numberPass;
130  // If mu not changed then compute
131  if (mu_==1e-4)
132    mu_= CoinMax(1.0e-3,sum*1.0e-5);
133  if (maxIts2_==100) {
134    if (!lightWeight_) {
135      maxIts2_=105;
136    } else if (lightWeight_==1) {
137      mu_ *= 1000.0;
138      maxIts2_=23;
139    } else if (lightWeight_==2) {
140      maxIts2_=11;
141    } else {
142      maxIts2_=23;
143    }
144  }
145  //printf("setting mu to %g and doing %d passes\n",mu_,majorIterations_);
146  solve2(handler,messages);
147#ifndef OSI_IDIOT
148  double averageInfeas = model_->sumPrimalInfeasibilities()/((double) model_->numberRows());
149  if ((averageInfeas<0.01&&(strategy_&512)!=0)||(strategy_&8192)!=0) 
150    crossOver(16+1); 
151  else
152    crossOver(3);
153#endif
154}
155void
156Idiot::solve()
157{
158  CoinMessages dummy;
159  solve2(NULL,&dummy);
160}
161void
162Idiot::solve2(CoinMessageHandler * handler,const CoinMessages * messages)
163{
164  int strategy=0;
165  double d2;
166  int i,n;
167  int allOnes=1;
168  int iteration=0;
169  int iterationTotal=0;
170  int nTry=0; /* number of tries at same weight */
171  double fixTolerance=IDIOT_FIX_TOLERANCE;
172  int maxBigIts=maxBigIts_;
173  int maxIts=maxIts_;
174  int logLevel=logLevel_;
175  int saveMajorIterations = majorIterations_;
176  if (handler) {
177    if (handler->logLevel()>0&&handler->logLevel()<3)
178      logLevel=1;
179    else if (!handler->logLevel())
180      logLevel=0;
181    else
182      logLevel=7;
183  }
184  double djExit=djTolerance_;
185  double djFlag=1.0+100.0*djExit;
186  double djTol=0.00001;
187  double mu =mu_;
188  double drop=drop_;
189  int maxIts2=maxIts2_;
190  double factor=muFactor_;
191  double smallInfeas=smallInfeas_;
192  double reasonableInfeas=reasonableInfeas_;
193  double stopMu=stopMu_;
194  double maxmin,offset;
195  double lastWeighted=1.0e50;
196  double exitDrop=exitDrop_;
197  double fakeSmall=smallInfeas;
198  double firstInfeas;
199  int badIts=0;
200  int slackStart,slackEnd,ordStart,ordEnd;
201  int checkIteration=0;
202  int lambdaIteration=0;
203  int belowReasonable=0; /* set if ever gone below reasonable infeas */
204  double bestWeighted=1.0e60;
205  double bestFeasible=1.0e60; /* best solution while feasible */
206  IdiotResult result,lastResult;
207  int saveStrategy=strategy_;
208  const int strategies[]={0,2,128};
209  double saveLambdaScale=0.0;
210  if ((saveStrategy&128)!=0) {
211    fixTolerance=SMALL_IDIOT_FIX_TOLERANCE;
212  }
213#ifdef OSI_IDIOT
214  const CoinPackedMatrix * matrix = model_->getMatrixByCol();
215#else
216  ClpMatrixBase * matrix = model_->clpMatrix();
217#endif
218  const int * row = matrix->getIndices();
219  const CoinBigIndex * columnStart = matrix->getVectorStarts();
220  const int * columnLength = matrix->getVectorLengths(); 
221  const double * element = matrix->getElements();
222  int nrows=model_->getNumRows();
223  int ncols=model_->getNumCols();
224  double * rowsol, * colsol;
225  double * pi, * dj;
226#ifndef OSI_IDIOT
227  double * cost = model_->objective();
228  double * lower = model_->columnLower();
229  double * upper = model_->columnUpper();
230#else
231  double * cost = new double [ncols];
232  memcpy( cost, model_->getObjCoefficients(), ncols*sizeof(double));
233  const double * lower = model_->getColLower();
234  const double * upper = model_->getColUpper();
235#endif
236  const double *elemXX;
237  double * saveSol;
238  double * rowupper= new double[nrows]; // not const as modified
239  memcpy(rowupper,model_->getRowUpper(),nrows*sizeof(double));
240  double * rowlower= new double[nrows]; // not const as modified
241  memcpy(rowlower,model_->getRowLower(),nrows*sizeof(double));
242  int * whenUsed;
243  double * lambda;
244  saveSol=new double[ncols];
245  lambda=new double [nrows];
246  rowsol= new double[nrows];
247  colsol= new double [ncols];
248  memcpy(colsol,model_->getColSolution(),ncols*sizeof(double));
249  pi= new double[nrows];
250  dj=new double[ncols];
251  delete [] whenUsed_;
252  whenUsed=whenUsed_=new int[ncols];
253  if (model_->getObjSense()==-1.0) {
254    maxmin=-1.0;
255  } else {
256    maxmin=1.0;
257  }
258  model_->getDblParam(OsiObjOffset,offset);
259  if (!maxIts2) maxIts2=maxIts;
260  strategy=strategy_;
261  strategy &= 3;
262  memset(lambda,0,nrows*sizeof(double));
263  slackStart=countCostedSlacks(model_);
264  if (slackStart>=0) {
265    printf("This model has costed slacks\n");
266    slackEnd=slackStart+nrows;
267    if (slackStart) {
268      ordStart=0;
269      ordEnd=slackStart;
270    } else {
271      ordStart=nrows;
272      ordEnd=ncols;
273    }
274  } else {
275    slackEnd=slackStart;
276    ordStart=0;
277    ordEnd=ncols;
278  }
279  if (offset&&logLevel>2) {
280    printf("** Objective offset is %g\n",offset);
281  }
282  /* compute reasonable solution cost */
283  for (i=0;i<nrows;i++) {
284    rowsol[i]=1.0e31;
285  }
286  for (i=0;i<ncols;i++) {
287    CoinBigIndex j;
288    for (j=columnStart[i];j<columnStart[i]+columnLength[i];j++) {
289      if (element[j]!=1.0) {
290        allOnes=0;
291        break;
292      }
293    }
294  }
295  if (allOnes) {
296    elemXX=NULL;
297  } else {
298    elemXX=element;
299  }
300  // Do scaling if wanted
301  bool scaled=false;
302#ifndef OSI_IDIOT
303  if ((strategy_&32)!=0&&!allOnes) {
304    if (model_->scalingFlag()>0)
305      scaled = model_->clpMatrix()->scale(model_)==0;
306    if (scaled) {
307      const double * rowScale = model_->rowScale();
308      const double * columnScale = model_->columnScale();
309      double * oldLower = lower;
310      double * oldUpper = upper;
311      double * oldCost = cost;
312      lower = new double[ncols];
313      upper = new double[ncols];
314      cost = new double[ncols];
315      memcpy(lower,oldLower,ncols*sizeof(double));
316      memcpy(upper,oldUpper,ncols*sizeof(double));
317      memcpy(cost,oldCost,ncols*sizeof(double));
318      int icol,irow;
319      for (icol=0;icol<ncols;icol++) {
320        double multiplier = 1.0/columnScale[icol];
321        if (lower[icol]>-1.0e50)
322          lower[icol] *= multiplier;
323        if (upper[icol]<1.0e50)
324          upper[icol] *= multiplier;
325        colsol[icol] *= multiplier;
326        cost[icol] *= columnScale[icol];
327      }
328      memcpy(rowlower,model_->rowLower(),nrows*sizeof(double));
329      for (irow=0;irow<nrows;irow++) {
330        double multiplier = rowScale[irow];
331        if (rowlower[irow]>-1.0e50)
332          rowlower[irow] *= multiplier;
333        if (rowupper[irow]<1.0e50)
334          rowupper[irow] *= multiplier;
335        rowsol[irow] *= multiplier;
336      }
337      int length = columnStart[ncols-1]+columnLength[ncols-1];
338      double * elemYY = new double[length];
339      for (i=0;i<ncols;i++) {
340        CoinBigIndex j;
341        double scale = columnScale[i];
342        for (j=columnStart[i];j<columnStart[i]+columnLength[i];j++) {
343          int irow=row[j];
344          elemYY[j] = element[j]*scale*rowScale[irow];
345        }
346      }
347      elemXX=elemYY;
348    }
349  }
350#endif
351  for (i=0;i<ncols;i++) {
352    CoinBigIndex j;
353    double dd=columnLength[i];
354    dd=cost[i]/dd;
355    for (j=columnStart[i];j<columnStart[i]+columnLength[i];j++) {
356      int irow=row[j];
357      if (dd<rowsol[irow]) {
358        rowsol[irow]=dd;
359      }
360    }
361  }
362  d2=0.0;
363  for (i=0;i<nrows;i++) {
364    d2+=rowsol[i];
365  }
366  d2*=2.0; /* for luck */
367 
368  d2=d2/((double) (4*nrows+8000));
369  d2*=0.5; /* halve with more flexible method */
370  if (d2<5.0) d2=5.0;
371  if (djExit==0.0) {
372    djExit=d2;
373  }
374  if ((saveStrategy&4)!=0) {
375    /* go to relative tolerances - first small */
376    djExit=1.0e-10;
377    djFlag=1.0e-5;
378    drop=1.0e-10;
379  }
380  memset(whenUsed,0,ncols*sizeof(int));
381  strategy=strategies[strategy];
382  if ((saveStrategy&8)!=0) strategy |= 64; /* don't allow large theta */
383  memcpy(saveSol,colsol,ncols*sizeof(double));
384 
385  lastResult=IdiSolve(nrows,ncols,rowsol ,colsol,pi,
386                       dj,cost,rowlower,rowupper,
387                       lower,upper,elemXX,row,columnStart,columnLength,lambda,
388                       0,mu,drop,
389                       maxmin,offset,strategy,djTol,djExit,djFlag);
390  n=0;
391  for (i=ordStart;i<ordEnd;i++) {
392    if (colsol[i]>lower[i]+fixTolerance) {
393      if (colsol[i]<upper[i]-fixTolerance) {
394        n++;
395      } else {
396        colsol[i]=upper[i];
397      }
398      whenUsed[i]=iteration;
399    } else {
400      colsol[i]=lower[i];
401    }
402  }
403  if ((logLevel_&1)!=0) {
404#ifndef OSI_IDIOT
405    if (!handler) {
406#endif
407      printf("Iteration %d infeasibility %g, objective %g - mu %g, its %d, %d interior\n", 
408             iteration,lastResult.infeas,lastResult.objval,mu,lastResult.iteration,n);
409#ifndef OSI_IDIOT
410    } else {
411      handler->message(CLP_IDIOT_ITERATION,*messages)
412        <<iteration<<lastResult.infeas<<lastResult.objval<<mu<<lastResult.iteration<<n
413        <<CoinMessageEol;
414    }
415#endif
416  }
417  int numberBaseTrys=0; // for first time
418  int numberAway=-1;
419  iterationTotal = lastResult.iteration;
420  firstInfeas=lastResult.infeas;
421  if ((strategy_&1024)!=0) reasonableInfeas=0.5*firstInfeas;
422  if (lastResult.infeas<reasonableInfeas) lastResult.infeas=reasonableInfeas;
423  double keepinfeas=1.0e31;
424  double lastInfeas=1.0e31;
425  double bestInfeas=1.0e31;
426  while ((mu>stopMu&&lastResult.infeas>smallInfeas)||
427         (lastResult.infeas<=smallInfeas&&
428         dropping(lastResult,exitDrop,smallInfeas,&badIts))||
429         checkIteration<2||lambdaIteration<lambdaIterations_) {
430    if (lastResult.infeas<=exitFeasibility_)
431      break; 
432    iteration++;
433    checkIteration++;
434    if (lastResult.infeas<=smallInfeas&&lastResult.objval<bestFeasible) {
435      bestFeasible=lastResult.objval;
436    }
437    if ((saveStrategy&4096)) strategy |=256;
438    if ((saveStrategy&4)!=0&&iteration>2) {
439      /* go to relative tolerances */
440      double weighted=10.0+fabs(lastWeighted);
441      djExit=djTolerance_*weighted;
442      djFlag=2.0*djExit;
443      drop=drop_*weighted;
444      djTol=0.01*djExit;
445    }
446    result=IdiSolve(nrows,ncols,rowsol ,colsol,pi,dj,
447                     cost,rowlower,rowupper,
448                     lower,upper,elemXX,row,columnStart,columnLength,lambda,
449                     maxIts,mu,drop,
450                     maxmin,offset,strategy,djTol,djExit,djFlag);
451    n=0;
452    for (i=ordStart;i<ordEnd;i++) {
453      if (colsol[i]>lower[i]+fixTolerance) {
454        if (colsol[i]<upper[i]-fixTolerance) {
455          n++;
456        } else {
457          colsol[i]=upper[i];
458        }
459        whenUsed[i]=iteration;
460      } else {
461        colsol[i]=lower[i];
462      }
463    }
464    if ((logLevel_&1)!=0) {
465#ifndef OSI_IDIOT
466      if (!handler) {
467#endif
468        printf("Iteration %d infeasibility %g, objective %g - mu %g, its %d, %d interior\n", 
469               iteration,result.infeas,result.objval,mu,result.iteration,n);
470#ifndef OSI_IDIOT
471      } else {
472        handler->message(CLP_IDIOT_ITERATION,*messages)
473          <<iteration<<result.infeas<<result.objval<<mu<<result.iteration<<n
474          <<CoinMessageEol;
475      }
476#endif
477    }
478    if (iteration>50&&n==numberAway&&result.infeas<1.0e-4)
479      break; // not much happening
480    if (lightWeight_==1&&iteration>10&&result.infeas>1.0&&maxIts!=7) {
481      if (lastInfeas!=bestInfeas&&CoinMin(result.infeas,lastInfeas)>0.95*bestInfeas)
482        majorIterations_ = CoinMin(majorIterations_,iteration); // not getting feasible
483    }
484    lastInfeas = result.infeas;
485    numberAway=n;
486    keepinfeas = result.infeas;
487    lastWeighted=result.weighted;
488    iterationTotal += result.iteration;
489    if (iteration==1) {
490      if ((strategy_&1024)!=0&&mu<1.0e-10) 
491        result.infeas=firstInfeas*0.8;
492      if (majorIterations_>=50)
493        result.infeas *= 0.8;
494      if (result.infeas>firstInfeas*0.9
495          &&result.infeas>reasonableInfeas) {
496        iteration--;
497        if (majorIterations_<50)
498          mu*=1.0e-1;
499        else
500          mu*=0.7;
501        bestFeasible=1.0e31;
502        bestWeighted=1.0e60;
503        numberBaseTrys++;
504        if (mu<1.0e-30||(numberBaseTrys>10&&lightWeight_)) {
505          // back to all slack basis
506          lightWeight_=2;
507          break;
508        }
509        memcpy(colsol,saveSol,ncols*sizeof(double));
510      } else {
511        // Save best solution
512        memcpy(saveSol,colsol,ncols*sizeof(double));
513        maxIts=maxIts2;
514        checkIteration=0;
515        if ((strategy_&1024)!=0) mu *= 1.0e-1;
516      }
517    } else if (result.infeas<bestInfeas) {
518      // Save best solution
519      memcpy(saveSol,colsol,ncols*sizeof(double));
520    }
521    bestInfeas=CoinMin(bestInfeas,result.infeas);
522    if (iteration) {
523      /* this code is in to force it to terminate sometime */
524      double changeMu=factor;
525      if ((saveStrategy&64)!=0) {
526        keepinfeas=0.0; /* switch off ranga's increase */
527        fakeSmall=smallInfeas;
528      } else {
529        fakeSmall=-1.0;
530      }
531      saveLambdaScale=0.0;
532      if (result.infeas>reasonableInfeas||
533          (nTry+1==maxBigIts&&result.infeas>fakeSmall)) {
534        if (result.infeas>lastResult.infeas*(1.0-dropEnoughFeasibility_)||
535            nTry+1==maxBigIts||
536            (result.infeas>lastResult.infeas*0.9
537             &&result.weighted>lastResult.weighted
538             -dropEnoughWeighted_*fabs(lastResult.weighted))) {
539          mu*=changeMu;
540          if ((saveStrategy&32)!=0&&result.infeas<reasonableInfeas&&0) {
541            reasonableInfeas=CoinMax(smallInfeas,reasonableInfeas*sqrt(changeMu));
542            printf("reasonable infeas now %g\n",reasonableInfeas);
543          }
544          nTry=0;
545          bestFeasible=1.0e31;
546          bestWeighted=1.0e60;
547          checkIteration=0;
548          lambdaIteration=0;
549#define LAMBDA
550#ifdef LAMBDA
551          if ((saveStrategy&2048)==0) {
552            memset(lambda,0,nrows*sizeof(double));
553          }
554#else
555          memset(lambda,0,nrows*sizeof(double));
556#endif
557        } else {
558          nTry++;
559        }
560      } else if (lambdaIterations_>=0) {
561        /* update lambda  */
562        double scale=1.0/mu;
563        int i,nnz=0;
564        saveLambdaScale=scale;
565         lambdaIteration++;
566         if ((saveStrategy&4)==0) drop = drop_/50.0;
567         if (lambdaIteration>4 && 
568            (((lambdaIteration%10)==0 && smallInfeas<keepinfeas) ||
569             (lambdaIteration%5)==0 && 1.5*smallInfeas<keepinfeas)) {
570           //printf(" Increasing smallInfeas from %f to %f\n",smallInfeas,1.5*smallInfeas);
571           smallInfeas *= 1.5;
572         }
573         if ((saveStrategy&2048)==0) {
574           for (i=0;i<nrows;i++) {
575             if (lambda[i]) nnz++;
576             lambda[i]+= scale*rowsol[i];
577           }
578         } else {
579           nnz=1;
580#ifdef LAMBDA
581           for (i=0;i<nrows;i++) {
582             lambda[i]+= scale*rowsol[i];
583           }
584#else
585           for (i=0;i<nrows;i++) {
586             lambda[i] = scale*rowsol[i];
587           }
588           for (i=0;i<ncols;i++) {
589             CoinBigIndex j;
590             double value=cost[i]*maxmin;
591             for (j=columnStart[i];j<columnStart[i]+columnLength[i];j++) {
592               int irow=row[j];
593               value+=element[j]*lambda[irow];
594             }
595             cost[i]=value*maxmin;
596           }
597           for (i=0;i<nrows;i++) {
598             offset+=lambda[i]*rowupper[i];
599             lambda[i]=0.0;
600           }
601#ifdef DEBUG
602           printf("offset %g\n",offset);
603#endif
604           model_->setDblParam(OsiObjOffset,offset);
605#endif
606         }
607        nTry++;
608        if (!nnz) {
609          bestFeasible=1.0e32;
610          bestWeighted=1.0e60;
611          checkIteration=0;
612          result.weighted=1.0e31;
613        }
614#ifdef DEBUG
615        double trueCost=0.0;
616        for (i=0;i<ncols;i++) {
617          int j;
618          trueCost+=cost[i]*colsol[i];
619        }
620        printf("True objective %g\n",trueCost-offset);
621#endif
622      } else {
623        nTry++;
624      }
625      lastResult=result;
626      if (result.infeas<reasonableInfeas&&!belowReasonable) {
627        belowReasonable=1;
628        bestFeasible=1.0e32;
629        bestWeighted=1.0e60;
630        checkIteration=0;
631        result.weighted=1.0e31;
632      }
633    }
634    if (iteration>=majorIterations_) {
635      // If not feasible and crash then dive dive dive
636      if (mu_>1.0e-12&&result.infeas>1.0&&majorIterations_<40) {
637        mu_=1.0e-30;
638        majorIterations_=iteration+1;
639      } else {
640        if (logLevel>2) 
641          printf("Exiting due to number of major iterations\n");
642        break;
643      }
644    }
645  }
646  majorIterations_ = saveMajorIterations;
647  // put back best solution
648  memcpy(colsol,saveSol,ncols*sizeof(double));
649#ifndef OSI_IDIOT
650  if (scaled) {
651    // Scale solution and free arrays
652    const double * rowScale = model_->rowScale();
653    const double * columnScale = model_->columnScale();
654    int icol,irow;
655    for (icol=0;icol<ncols;icol++) {
656      colsol[icol] *= columnScale[icol];
657      dj[icol] /= columnScale[icol];
658    }
659    for (irow=0;irow<nrows;irow++) {
660      rowsol[irow] /= rowScale[irow];
661      pi[irow] *= rowScale[irow];
662    }
663    // Don't know why getting Microsoft problems
664#if defined (_MSC_VER)
665    delete [] ( double *) elemXX;
666#else
667    delete [] elemXX;
668#endif
669    model_->setRowScale(NULL);
670    model_->setColumnScale(NULL);
671    delete [] lower;
672    delete [] upper;
673    delete [] cost;
674    lower = model_->columnLower();
675    upper = model_->columnUpper();
676    cost = model_->objective();
677    //rowlower = model_->rowLower();
678  }
679#endif
680#define TRYTHIS
681#ifdef TRYTHIS
682  if ((saveStrategy&2048)!=0) {
683    double offset;
684    model_->getDblParam(OsiObjOffset,offset);
685    for (i=0;i<ncols;i++) {
686      CoinBigIndex j;
687      double djval=cost[i]*maxmin;
688      for (j=columnStart[i];j<columnStart[i]+columnLength[i];j++) {
689        int irow=row[j];
690        djval -= element[j]*lambda[irow];
691      }
692      cost[i]=djval;
693    }
694    for (i=0;i<nrows;i++) {
695      offset+=lambda[i]*rowupper[i];
696    }
697    model_->setDblParam(OsiObjOffset,offset);
698  }
699#endif
700  if (saveLambdaScale) {
701    /* back off last update */
702    for (i=0;i<nrows;i++) {
703      lambda[i]-= saveLambdaScale*rowsol[i];
704    }
705  }
706  muAtExit_=mu;
707  n=0;
708  for (i=ordStart;i<ordEnd;i++) {
709    if (colsol[i]>lower[i]+fixTolerance) {
710      n++;
711      whenUsed[i]=iteration;
712    } else {
713      colsol[i]=lower[i];
714    }
715  }
716  if ((logLevel&1)==0) {
717    printf(
718            "%d - mu %g, infeasibility %g, objective %g, %d interior\n",
719            iteration,mu,lastResult.infeas,lastResult.objval,n);
720  }
721#ifndef OSI_IDIOT
722  model_->setSumPrimalInfeasibilities(lastResult.infeas);
723#endif
724  {
725    double large=0.0;
726    int i;
727    memset(rowsol,0,nrows*sizeof(double));
728    for (i=0;i<ncols;i++) {
729      CoinBigIndex j;
730      double value=colsol[i];
731      for (j=columnStart[i];j<columnStart[i]+columnLength[i];j++) {
732        int irow=row[j];
733        rowsol[irow] += element[j]*value;
734      }
735    }
736    for (i=0;i<nrows;i++) {
737      if (rowsol[i] > rowupper[i]) {
738        double diff=rowsol[i]-rowupper[i];
739        if (diff>large) 
740          large=diff;
741      } else if (rowsol[i] < rowlower[i]) {
742        double diff=rowlower[i]-rowsol[i];
743        if (diff>large) 
744          large=diff;
745      } 
746    }
747    if (logLevel>2)
748      printf("largest infeasibility is %g\n",large);
749  }
750  /* subtract out lambda */
751  for (i=0;i<nrows;i++) {
752    pi[i]-=lambda[i];
753  }
754  for (i=0;i<ncols;i++) {
755    CoinBigIndex j;
756    double djval=cost[i]*maxmin;
757    for (j=columnStart[i];j<columnStart[i]+columnLength[i];j++) {
758      int irow=row[j];
759      djval -= element[j]*pi[irow];
760    }
761    dj[i]=djval;
762  }
763  if ((strategy_&1024)!=0) {
764    double ratio = ((double) ncols)/((double) nrows);
765    printf("col/row ratio %g infeas ratio %g\n",ratio,lastResult.infeas/firstInfeas);
766    if (lastResult.infeas>0.01*firstInfeas*ratio) {
767      strategy_ &= (~1024);
768      printf(" - layer off\n");
769    } else {
770      printf(" - layer on\n");
771    }
772  }
773  delete [] saveSol;
774  delete [] lambda;
775  // save solution
776  // duals not much use - but save anyway
777#ifndef OSI_IDIOT
778  memcpy(model_->primalRowSolution(),rowsol,nrows*sizeof(double));
779  memcpy(model_->primalColumnSolution(),colsol,ncols*sizeof(double));
780  memcpy(model_->dualRowSolution(),pi,nrows*sizeof(double));
781  memcpy(model_->dualColumnSolution(),dj,ncols*sizeof(double));
782#else
783  model_->setColSolution(colsol);
784  model_->setRowPrice(pi);
785  delete [] cost;
786#endif
787  delete [] rowsol;
788  delete [] colsol;
789  delete [] pi;
790  delete [] dj;
791  delete [] rowlower;
792  delete [] rowupper;
793  return ;
794}
795#ifndef OSI_IDIOT
796void
797Idiot::crossOver(int mode)
798{
799  if (lightWeight_==2) {
800    // total failure
801    model_->allSlackBasis();
802    return;
803  }
804  double fixTolerance=IDIOT_FIX_TOLERANCE;
805  double startTime = CoinCpuTime();
806  ClpSimplex * saveModel=NULL;
807  ClpMatrixBase * matrix = model_->clpMatrix();
808  const int * row = matrix->getIndices();
809  const CoinBigIndex * columnStart = matrix->getVectorStarts();
810  const int * columnLength = matrix->getVectorLengths(); 
811  const double * element = matrix->getElements();
812  const double * rowupper = model_->getRowUpper();
813  int nrows=model_->getNumRows();
814  int ncols=model_->getNumCols();
815  double * rowsol, * colsol;
816  // different for Osi
817  double * lower = model_->columnLower();
818  double * upper = model_->columnUpper();
819  const double * rowlower= model_->getRowLower();
820  int * whenUsed=whenUsed_;
821  rowsol= model_->primalRowSolution();
822  colsol= model_->primalColumnSolution();;
823  double * cost=model_->objective();
824
825  int slackEnd,ordStart,ordEnd;
826  int slackStart = countCostedSlacks(model_);
827
828  int addAll = mode&7;
829  int presolve=0;
830
831  double djTolerance = djTolerance_;
832  if (djTolerance>0.0&&djTolerance<1.0)
833    djTolerance=1.0;
834  int iteration;
835  int i, n=0;
836  double ratio=1.0;
837  double objValue=0.0;
838  if ((strategy_&128)!=0) {
839    fixTolerance=SMALL_IDIOT_FIX_TOLERANCE;
840  }
841  if ((mode&16)!=0&&addAll<3) presolve=1;
842  double * saveUpper = NULL;
843  double * saveLower = NULL;
844  double * saveRowUpper = NULL;
845  double * saveRowLower = NULL;
846  bool allowInfeasible = (strategy_&8192)!=0;
847  if (addAll<3) {
848    saveUpper = new double [ncols];
849    saveLower = new double [ncols];
850    memcpy(saveUpper,upper,ncols*sizeof(double));
851    memcpy(saveLower,lower,ncols*sizeof(double));
852    if (allowInfeasible) {
853      saveRowUpper = new double [nrows];
854      saveRowLower = new double [nrows];
855      memcpy(saveRowUpper,rowupper,nrows*sizeof(double));
856      memcpy(saveRowLower,rowlower,nrows*sizeof(double));
857      double averageInfeas = model_->sumPrimalInfeasibilities()/((double) model_->numberRows());
858      fixTolerance = CoinMax(fixTolerance,1.0e-5*averageInfeas);
859    }
860  }
861  if (slackStart>=0) {
862    slackEnd=slackStart+nrows;
863    if (slackStart) {
864      ordStart=0;
865      ordEnd=slackStart;
866    } else {
867      ordStart=nrows;
868      ordEnd=ncols;
869    }
870  } else {
871    slackEnd=slackStart;
872    ordStart=0;
873    ordEnd=ncols;
874  }
875  /* get correct rowsol (without known slacks) */
876  memset(rowsol,0,nrows*sizeof(double));
877  for (i=ordStart;i<ordEnd;i++) {
878    CoinBigIndex j;
879    double value=colsol[i];
880    if (value<lower[i]+fixTolerance) {
881      value=lower[i];
882      colsol[i]=value;
883    }
884    for (j=columnStart[i];j<columnStart[i]+columnLength[i];j++) {
885      int irow=row[j];
886      rowsol[irow]+=value*element[j];
887    }
888  }
889  if (slackStart>=0) {
890    for (i=0;i<nrows;i++) {
891      if (ratio*rowsol[i]>rowlower[i]&&rowsol[i]>1.0e-8) {
892        ratio=rowlower[i]/rowsol[i];
893      }
894    }
895    for (i=0;i<nrows;i++) {
896      rowsol[i]*=ratio;
897    }
898    for (i=ordStart;i<ordEnd;i++) {
899      double value=colsol[i]*ratio;
900      colsol[i]=value;
901      objValue+=value*cost[i];
902    }
903    for (i=0;i<nrows;i++) {
904      double value=rowlower[i]-rowsol[i];
905      colsol[i+slackStart]=value;
906      objValue+=value*cost[i+slackStart];
907    }
908    printf("New objective after scaling %g\n",objValue);
909  }
910#if 0
911   maybe put back - but just get feasible ?
912  // If not many fixed then just exit
913  int numberFixed=0;
914  for (i=ordStart;i<ordEnd;i++) {
915    if (colsol[i]<lower[i]+fixTolerance)
916      numberFixed++;
917    else if (colsol[i]>upper[i]-fixTolerance)
918      numberFixed++;
919  }
920  if (numberFixed<ncols/2) {
921    addAll=3;
922    presolve=0;
923  }
924#endif
925  model_->createStatus();
926  /* addAll
927     0 - chosen,all used, all
928     1 - chosen, all
929     2 - all
930     3 - do not do anything  - maybe basis
931  */
932  for (i=ordStart;i<ordEnd;i++) {
933    if (addAll<2) {
934      if (colsol[i]<lower[i]+fixTolerance) {
935        upper[i]=lower[i];
936        colsol[i]=lower[i];
937      } else if (colsol[i]>upper[i]-fixTolerance) {
938        lower[i]=upper[i];
939        colsol[i]=upper[i];
940      }
941    }
942    model_->setColumnStatus(i,ClpSimplex::superBasic);
943  }
944  double maxmin;
945  if (model_->getObjSense()==-1.0) {
946    maxmin=-1.0;
947  } else {
948    maxmin=1.0;
949  }
950  if (slackStart>=0) {
951    for (i=0;i<nrows;i++) {
952      model_->setRowStatus(i,ClpSimplex::superBasic);
953    }
954    for (i=slackStart;i<slackEnd;i++) {
955      model_->setColumnStatus(i,ClpSimplex::basic);
956    }
957  } else {
958    /* still try and put singletons rather than artificials in basis */
959    int ninbas=0;
960    for (i=0;i<nrows;i++) {
961      model_->setRowStatus(i,ClpSimplex::basic);
962    }
963    for (i=0;i<ncols;i++) {
964      if (columnLength[i]==1&&upper[i]>lower[i]+1.0e-5) {
965        CoinBigIndex j =columnStart[i];
966        double value=element[j];
967        int irow=row[j];
968        double rlo=rowlower[irow];
969        double rup=rowupper[irow];
970        double clo=lower[i];
971        double cup=upper[i];
972        double csol=colsol[i];
973        /* adjust towards feasibility */
974        double move=0.0;
975        if (rowsol[irow]>rup) {
976          move=(rup-rowsol[irow])/value;
977          if (value>0.0) {
978            /* reduce */
979            if (csol+move<clo) move=CoinMin(0.0,clo-csol);
980          } else {
981            /* increase */
982            if (csol+move>cup) move=CoinMax(0.0,cup-csol);
983          }
984        } else if (rowsol[irow]<rlo) {
985          move=(rlo-rowsol[irow])/value;
986          if (value>0.0) {
987            /* increase */
988            if (csol+move>cup) move=CoinMax(0.0,cup-csol);
989          } else {
990            /* reduce */
991            if (csol+move<clo) move=CoinMin(0.0,clo-csol);
992          }
993        } else {
994          /* move to improve objective */
995          if (cost[i]*maxmin>0.0) {
996            if (value>0.0) {
997              move=(rlo-rowsol[irow])/value;
998              /* reduce */
999              if (csol+move<clo) move=CoinMin(0.0,clo-csol);
1000            } else {
1001              move=(rup-rowsol[irow])/value;
1002              /* increase */
1003              if (csol+move>cup) move=CoinMax(0.0,cup-csol);
1004            }
1005          } else if (cost[i]*maxmin<0.0) {
1006            if (value>0.0) {
1007              move=(rup-rowsol[irow])/value;
1008              /* increase */
1009              if (csol+move>cup) move=CoinMax(0.0,cup-csol);
1010            } else {
1011              move=(rlo-rowsol[irow])/value;
1012              /* reduce */
1013              if (csol+move<clo) move=CoinMin(0.0,clo-csol);
1014            }
1015          }
1016        }
1017        rowsol[irow] +=move*value;
1018        colsol[i]+=move;
1019        /* put in basis if row was artificial */
1020        if (rup-rlo<1.0e-7&&model_->getRowStatus(irow)==ClpSimplex::basic) {
1021          model_->setRowStatus(irow,ClpSimplex::superBasic);
1022          model_->setColumnStatus(i,ClpSimplex::basic);
1023          ninbas++;
1024        }
1025      }
1026    }
1027    /*printf("%d in basis\n",ninbas);*/
1028  }
1029  bool wantVector=false;
1030  if (dynamic_cast< ClpPackedMatrix*>(model_->clpMatrix())) {
1031    // See if original wanted vector
1032    ClpPackedMatrix * clpMatrixO = dynamic_cast< ClpPackedMatrix*>(model_->clpMatrix());
1033    wantVector = clpMatrixO->wantsSpecialColumnCopy();
1034  }
1035  if (addAll<3) {
1036    ClpPresolve pinfo;
1037    if (presolve) {
1038      if (allowInfeasible) {
1039        // fix up so will be feasible
1040        double * rhs = new double[nrows];
1041        memset(rhs,0,nrows*sizeof(double));
1042        model_->clpMatrix()->times(1.0,colsol,rhs);
1043        double * rowupper = model_->rowUpper();
1044        double * rowlower= model_->rowLower();
1045        double sum = 0.0;
1046        for (i=0;i<nrows;i++) {
1047          if (rhs[i]>rowupper[i]) {
1048            sum += rhs[i]-rowupper[i];
1049            rowupper[i]=rhs[i];
1050          }
1051          if (rhs[i]<rowlower[i]) {
1052            sum += rowlower[i]-rhs[i];
1053            rowlower[i]=rhs[i];
1054          }
1055        }
1056        printf("sum of infeasibilities %g\n",sum);
1057        delete [] rhs;
1058      }
1059      saveModel = model_;
1060      pinfo.setPresolveActions(pinfo.presolveActions()|16384);
1061      model_ = pinfo.presolvedModel(*model_,1.0e-8,false,5);
1062    }
1063    if (model_) {
1064      if (!wantVector) {
1065        model_->primal(1);
1066      } else {
1067        ClpMatrixBase * matrix = model_->clpMatrix();
1068        ClpPackedMatrix * clpMatrix = dynamic_cast< ClpPackedMatrix*>(matrix);
1069        assert (clpMatrix);
1070        clpMatrix->makeSpecialColumnCopy();
1071        model_->primal(1);
1072        clpMatrix->releaseSpecialColumnCopy();
1073      }
1074      if (presolve) {
1075        pinfo.postsolve(true);
1076        delete model_;
1077        model_ = saveModel;
1078        saveModel=NULL;
1079      }
1080    } else {
1081      // not feasible
1082      addAll=1;
1083      presolve=0;
1084      model_ = saveModel;
1085      saveModel=NULL;
1086    }
1087    if (allowInfeasible) {
1088      memcpy(model_->rowUpper(),saveRowUpper,nrows*sizeof(double));
1089      memcpy(model_->rowLower(),saveRowLower,nrows*sizeof(double));
1090      delete [] saveRowUpper;
1091      delete [] saveRowLower;
1092      saveRowUpper = NULL;
1093      saveRowLower = NULL;
1094    }
1095    if (addAll<2) {
1096      n=0;
1097      if (!addAll ) {
1098        /* could do scans to get a good number */
1099        iteration=1;
1100        for (i=ordStart;i<ordEnd;i++) {
1101          if (whenUsed[i]>=iteration) {
1102            if (upper[i]-lower[i]<1.0e-5&&saveUpper[i]-saveLower[i]>1.0e-5) {
1103              n++;
1104              upper[i]=saveUpper[i];
1105              lower[i]=saveLower[i];
1106            }
1107          }
1108        }
1109      } else {
1110        for (i=ordStart;i<ordEnd;i++) {
1111          if (upper[i]-lower[i]<1.0e-5&&saveUpper[i]-saveLower[i]>1.0e-5) {
1112            n++;
1113            upper[i]=saveUpper[i];
1114            lower[i]=saveLower[i];
1115          }
1116        }
1117        delete [] saveUpper;
1118        delete [] saveLower;
1119        saveUpper=NULL;
1120        saveLower=NULL;
1121      }
1122      printf("Time so far %g, %d now added from previous iterations\n",
1123             CoinCpuTime()-startTime,n);
1124      if (addAll)
1125        presolve=0;
1126      if (presolve) {
1127        saveModel = model_;
1128        model_ = pinfo.presolvedModel(*model_,1.0e-8,false,5);
1129      } else {
1130        presolve=0;
1131      }
1132      if (!wantVector) {
1133        model_->primal(1);
1134      } else {
1135        ClpMatrixBase * matrix = model_->clpMatrix();
1136        ClpPackedMatrix * clpMatrix = dynamic_cast< ClpPackedMatrix*>(matrix);
1137        assert (clpMatrix);
1138        clpMatrix->makeSpecialColumnCopy();
1139        model_->primal(1);
1140        clpMatrix->releaseSpecialColumnCopy();
1141      }
1142      if (presolve) {
1143        pinfo.postsolve(true);
1144        delete model_;
1145        model_ = saveModel;
1146        saveModel=NULL;
1147      }
1148      if (!addAll) {
1149        n=0;
1150        for (i=ordStart;i<ordEnd;i++) {
1151          if (upper[i]-lower[i]<1.0e-5&&saveUpper[i]-saveLower[i]>1.0e-5) {
1152            n++;
1153            upper[i]=saveUpper[i];
1154            lower[i]=saveLower[i];
1155          }
1156        }
1157        delete [] saveUpper;
1158        delete [] saveLower;
1159        saveUpper=NULL;
1160        saveLower=NULL;
1161        printf("Time so far %g, %d now added from previous iterations\n",
1162               CoinCpuTime()-startTime,n);
1163      }
1164      if (presolve) {
1165        saveModel = model_;
1166        model_ = pinfo.presolvedModel(*model_,1.0e-8,false,5);
1167      } else {
1168        presolve=0;
1169      }
1170      if (!wantVector) {
1171        model_->primal(1);
1172      } else {
1173        ClpMatrixBase * matrix = model_->clpMatrix();
1174        ClpPackedMatrix * clpMatrix = dynamic_cast< ClpPackedMatrix*>(matrix);
1175        assert (clpMatrix);
1176        clpMatrix->makeSpecialColumnCopy();
1177        model_->primal(1);
1178        clpMatrix->releaseSpecialColumnCopy();
1179      }
1180      if (presolve) {
1181        pinfo.postsolve(true);
1182        delete model_;
1183        model_ = saveModel;
1184        saveModel=NULL;
1185      }
1186    }
1187    printf("Total time in crossover %g\n", CoinCpuTime()-startTime);
1188    delete [] saveUpper;
1189    delete [] saveLower;
1190  }
1191  return ;
1192}
1193#endif
1194/*****************************************************************************/
1195
1196// Default contructor
1197Idiot::Idiot()
1198{
1199  model_ = NULL;
1200  maxBigIts_ = 3;
1201  maxIts_ = 5;
1202  logLevel_ = 1; 
1203  logFreq_ = 100;
1204  maxIts2_ = 100;
1205  djTolerance_ = 1e-1;
1206  mu_ = 1e-4;
1207  drop_ = 5.0;
1208  exitDrop_=-1.0e20;
1209  muFactor_ = 0.3333;
1210  stopMu_ = 1e-12;
1211  smallInfeas_ = 1e-1;
1212  reasonableInfeas_ = 1e2;
1213  muAtExit_ =1.0e31;
1214  strategy_ =8;
1215  lambdaIterations_ =0;
1216  checkFrequency_ =100;
1217  whenUsed_ = NULL;
1218  majorIterations_ =30;
1219  exitFeasibility_ =-1.0;
1220  dropEnoughFeasibility_ =0.02;
1221  dropEnoughWeighted_ =0.01;
1222  // adjust
1223  double nrows=10000.0;
1224  int baseIts =(int) sqrt((double)nrows);
1225  baseIts =baseIts/10;
1226  baseIts *= 10;
1227  maxIts2_ =200+baseIts+5;
1228  maxIts2_=100;
1229  reasonableInfeas_ =((double) nrows)*0.05;
1230  lightWeight_=0;
1231}
1232// Constructor from model
1233Idiot::Idiot(OsiSolverInterface &model)
1234{
1235  model_ = & model;
1236  maxBigIts_ = 3;
1237  maxIts_ = 5;
1238  logLevel_ = 1; 
1239  logFreq_ = 100;
1240  maxIts2_ = 100;
1241  djTolerance_ = 1e-1;
1242  mu_ = 1e-4;
1243  drop_ = 5.0;
1244  exitDrop_=-1.0e20;
1245  muFactor_ = 0.3333;
1246  stopMu_ = 1e-12;
1247  smallInfeas_ = 1e-1;
1248  reasonableInfeas_ = 1e2;
1249  muAtExit_ =1.0e31;
1250  strategy_ =8;
1251  lambdaIterations_ =0;
1252  checkFrequency_ =100;
1253  whenUsed_ = NULL;
1254  majorIterations_ =30;
1255  exitFeasibility_ =-1.0;
1256  dropEnoughFeasibility_ =0.02;
1257  dropEnoughWeighted_ =0.01;
1258  // adjust
1259  double nrows;
1260  if (model_)
1261    nrows=model_->getNumRows();
1262  else
1263    nrows=10000.0;
1264  int baseIts =(int) sqrt((double)nrows);
1265  baseIts =baseIts/10;
1266  baseIts *= 10;
1267  maxIts2_ =200+baseIts+5;
1268  maxIts2_=100;
1269  reasonableInfeas_ =((double) nrows)*0.05;
1270  lightWeight_=0;
1271}
1272// Copy constructor.
1273Idiot::Idiot(const Idiot &rhs)
1274{
1275  model_ = rhs.model_;
1276  if (model_&&rhs.whenUsed_) {
1277    int numberColumns = model_->getNumCols();
1278    whenUsed_ = new int [numberColumns];
1279    memcpy(whenUsed_,rhs.whenUsed_,numberColumns*sizeof(int));
1280  } else {
1281    whenUsed_=NULL;
1282  }
1283  djTolerance_ = rhs.djTolerance_;
1284  mu_ = rhs.mu_;
1285  drop_ = rhs.drop_;
1286  muFactor_ = rhs.muFactor_;
1287  stopMu_ = rhs.stopMu_;
1288  smallInfeas_ = rhs.smallInfeas_;
1289  reasonableInfeas_ = rhs.reasonableInfeas_;
1290  exitDrop_ = rhs.exitDrop_;
1291  muAtExit_ = rhs.muAtExit_;
1292  exitFeasibility_ = rhs.exitFeasibility_;
1293  dropEnoughFeasibility_ = rhs.dropEnoughFeasibility_;
1294  dropEnoughWeighted_ = rhs.dropEnoughWeighted_;
1295  maxBigIts_ = rhs.maxBigIts_;
1296  maxIts_ = rhs.maxIts_;
1297  majorIterations_ = rhs.majorIterations_;
1298  logLevel_ = rhs.logLevel_;
1299  logFreq_ = rhs.logFreq_;
1300  checkFrequency_ = rhs.checkFrequency_;
1301  lambdaIterations_ = rhs.lambdaIterations_;
1302  maxIts2_ = rhs.maxIts2_;
1303  strategy_ = rhs.strategy_;
1304  lightWeight_=rhs.lightWeight_;
1305}
1306// Assignment operator. This copies the data
1307Idiot & 
1308Idiot::operator=(const Idiot & rhs)
1309{
1310  if (this != &rhs) {
1311    delete [] whenUsed_;
1312    model_ = rhs.model_;
1313    if (model_&&rhs.whenUsed_) {
1314      int numberColumns = model_->getNumCols();
1315      whenUsed_ = new int [numberColumns];
1316      memcpy(whenUsed_,rhs.whenUsed_,numberColumns*sizeof(int));
1317    } else {
1318      whenUsed_=NULL;
1319    }
1320    djTolerance_ = rhs.djTolerance_;
1321    mu_ = rhs.mu_;
1322    drop_ = rhs.drop_;
1323    muFactor_ = rhs.muFactor_;
1324    stopMu_ = rhs.stopMu_;
1325    smallInfeas_ = rhs.smallInfeas_;
1326    reasonableInfeas_ = rhs.reasonableInfeas_;
1327    exitDrop_ = rhs.exitDrop_;
1328    muAtExit_ = rhs.muAtExit_;
1329    exitFeasibility_ = rhs.exitFeasibility_;
1330    dropEnoughFeasibility_ = rhs.dropEnoughFeasibility_;
1331    dropEnoughWeighted_ = rhs.dropEnoughWeighted_;
1332    maxBigIts_ = rhs.maxBigIts_;
1333    maxIts_ = rhs.maxIts_;
1334    majorIterations_ = rhs.majorIterations_;
1335    logLevel_ = rhs.logLevel_;
1336    logFreq_ = rhs.logFreq_;
1337    checkFrequency_ = rhs.checkFrequency_;
1338    lambdaIterations_ = rhs.lambdaIterations_;
1339    maxIts2_ = rhs.maxIts2_;
1340    strategy_ = rhs.strategy_;
1341    lightWeight_=rhs.lightWeight_;
1342  }
1343  return *this;
1344}
1345Idiot::~Idiot()
1346{
1347  delete [] whenUsed_;
1348}
Note: See TracBrowser for help on using the repository browser.