- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

AbcSimplex.hpp
Go to the documentation of this file.
1 /* $Id: AbcSimplex.hpp 2070 2014-11-18 11:12:54Z forrest $ */
2 // Copyright (C) 2002, International Business Machines
3 // Corporation and others, Copyright (C) 2012, FasterCoin. All Rights Reserved.
4 // This code is licensed under the terms of the Eclipse Public License (EPL).
5 /*
6 Authors
7
8 John Forrest
9
10 */
11 #ifndef AbcSimplex_H
12 #define AbcSimplex_H
13
14 #include <iostream>
15 #include <cfloat>
16 #include "ClpModel.hpp"
17 #include "ClpMatrixBase.hpp"
18 #include "CoinIndexedVector.hpp"
19 #include "AbcCommon.hpp"
20 class AbcSimplex;
21 #include "ClpSolve.hpp"
22 #include "CoinAbcCommon.hpp"
23 #include "ClpSimplex.hpp"
24 class AbcDualRowPivot;
25 class AbcPrimalColumnPivot;
26 class AbcSimplexFactorization;
27 class AbcNonLinearCost;
28 class OsiAbcSolverInterface;
29 class CoinWarmStartBasis;
30 class ClpDisasterHandler;
31 class AbcSimplexProgress;
32 class AbcMatrix;
33 class AbcTolerancesEtc;
34
52 #define PAN
53 #if ABC_NORMAL_DEBUG>0
54 #define PRINT_PAN 1
55 #endif
56 #define TRY_ABC_GUS
57 #define HEAVY_PERTURBATION 57
58 #if ABC_PARALLEL==1
59 // Use pthreads
60 #include <pthread.h>
61 #endif
62 class AbcSimplex : public ClpSimplex {
63 friend void AbcSimplexUnitTest(const std::string & mpsDir);
64
65 public:
74 enum Status {
75 atLowerBound = 0x00, // so we can use bottom two bits to sort and swap signs
76 atUpperBound = 0x01,
77 isFree = 0x04,
78 superBasic = 0x05,
79 basic = 0x06,
80 isFixed = 0x07
81 };
82 // For Dual
83 enum FakeBound {
84 noFake = 0x00,
85 lowerFake = 0x01,
86 upperFake = 0x02,
87 bothFake = 0x03
88 };
89
92 AbcSimplex (bool emptyMessages = false );
94
97 AbcSimplex(const AbcSimplex & rhs);
100 AbcSimplex(const ClpSimplex & rhs);
107 AbcSimplex (const ClpSimplex * wholeModel,
108 int numberRows, const int * whichRows,
109 int numberColumns, const int * whichColumns,
110 bool dropNames = true, bool dropIntegers = true,
111 bool fixOthers = false);
118 AbcSimplex (const AbcSimplex * wholeModel,
119 int numberRows, const int * whichRows,
120 int numberColumns, const int * whichColumns,
121 bool dropNames = true, bool dropIntegers = true,
122 bool fixOthers = false);
126 AbcSimplex (AbcSimplex * wholeModel,
127 int numberColumns, const int * whichColumns);
130 void originalModel(AbcSimplex * miniModel);
132 AbcSimplex (const ClpSimplex * clpSimplex);
134 void putBackSolution(ClpSimplex * simplex);
140 //void setPersistenceFlag(int value);
142 void makeBaseModel();
144 void deleteBaseModel();
146 inline AbcSimplex * baseModel() const {
147 return abcBaseModel_;
148 }
152 void setToBaseModel(AbcSimplex * model = NULL);
154 AbcSimplex & operator=(const AbcSimplex & rhs);
156 ~AbcSimplex ( );
158
163 int dual();
164 int doAbcDual();
167 int primal(int ifValuesPass);
168 int doAbcPrimal(int ifValuesPass);
170 CoinWarmStartBasis * getBasis() const;
172 void setFactorization( AbcSimplexFactorization & factorization);
174 AbcSimplexFactorization * swapFactorization( AbcSimplexFactorization * factorization);
176 AbcSimplexFactorization * getEmptyFactorization();
186 int tightenPrimalBounds();
188 void setDualRowPivotAlgorithm(AbcDualRowPivot & choice);
190 void setPrimalColumnPivotAlgorithm(AbcPrimalColumnPivot & choice);
192 void defaultFactorizationFrequency();
195
198 inline AbcSimplexFactorization * factorization() const {
200 return reinterpret_cast<AbcSimplexFactorization *>(abcFactorization_);
201 }
202 #ifdef EARLY_FACTORIZE
203 inline AbcSimplexFactorization * earlyFactorization() const {
205 return reinterpret_cast<AbcSimplexFactorization *>(abcEarlyFactorization_);
206 }
207 #endif
208 int factorizationFrequency() const;
210 void setFactorizationFrequency(int value);
212 inline int maximumAbcNumberRows() const
213 { return maximumAbcNumberRows_;}
215 inline int maximumNumberTotal() const
216 { return maximumNumberTotal_;}
217 inline int maximumTotal() const
218 { return maximumNumberTotal_;}
220 bool isObjectiveLimitTestValid() const ;
222 inline int numberTotal() const
223 { return numberTotal_;}
225 inline int numberTotalWithoutFixed() const
226 { return numberTotalWithoutFixed_;}
228 inline CoinPartitionedVector * usefulArray(int index) {
229 return & usefulArray_[index];
230 }
231 inline CoinPartitionedVector * usefulArray(int index) const {
232 return const_cast<CoinPartitionedVector *>(&usefulArray_[index]);
233 }
235
236 /******************** End of most useful part **************/
242 int getSolution ();
244 void setClpSimplexObjectiveValue();
250 void setupDualValuesPass(const double * fakeDuals,
251 const double * fakePrimals,
252 int type);
254 inline double minimizationObjectiveValue() const
255 { return objectiveValue_-dblParam_[ClpObjOffset];}
257 inline double currentDualTolerance() const
258 { return currentDualTolerance_;}
259 inline void setCurrentDualTolerance(double value) {
260 currentDualTolerance_ = value;
261 }
263 inline AbcNonLinearCost * abcNonLinearCost() const {
264 return abcNonLinearCost_;
265 }
267 double * perturbationSaved() const
268 { return perturbationSaved_;}
270 inline double acceptablePivot() const
271 { return acceptablePivot_;}
273 inline int ordinaryVariables() const
274 { return ordinaryVariables_;}
276 inline int numberOrdinary() const
277 { return numberOrdinary_;}
279 inline void setNumberOrdinary(int number)
280 { numberOrdinary_=number;}
282 inline double currentDualBound() const
283 { return currentDualBound_;}
285 inline AbcDualRowPivot * dualRowPivot() const {
286 return abcDualRowPivot_;
287 }
289 inline AbcPrimalColumnPivot * primalColumnPivot() const {
290 return abcPrimalColumnPivot_;
291 }
293 inline AbcMatrix * abcMatrix() const {
294 return abcMatrix_;
295 }
305 int internalFactorize(int solveType);
321 void permuteIn();
323 void permuteBasis();
325 void permuteOut(int whatsWanted);
327 ClpDataSave saveData() ;
329 void restoreData(ClpDataSave saved);
331 void cleanStatus(bool valuesPass=false);
334 int computeDuals(double * givenDjs, CoinIndexedVector * array1, CoinIndexedVector * array2);
336 int computePrimals (CoinIndexedVector * array1, CoinIndexedVector * array2);
338 void computeObjective ();
340 void setMultipleSequenceIn(int sequenceIn[4]);
345 inline void unpack(CoinIndexedVector & rowArray) const
346 {unpack(rowArray,sequenceIn_);}
350 void unpack(CoinIndexedVector & rowArray, int sequence) const;
355 int housekeeping(/*double objectiveChange*/);
358 void checkPrimalSolution(bool justBasic);
361 void checkDualSolution();
364 void checkDualSolutionPlusFake();
366 void checkBothSolutions();
368 int gutsOfSolution(int type);
370 int gutsOfPrimalSolution(int type);
372 void saveGoodStatus();
374 void restoreGoodStatus(int type);
375 #define rowUseScale_ scaleFromExternal_
376 #define inverseRowUseScale_ scaleToExternal_
377 void refreshCosts();
379 void refreshLower(unsigned int type=~(ROW_LOWER_SAME|COLUMN_UPPER_SAME));
380 void refreshUpper(unsigned int type=~(ROW_LOWER_SAME|COLUMN_LOWER_SAME));
382 void setupPointers(int maxRows,int maxColumns);
384 void copyFromSaved(int type=31);
386 void fillPerturbation(int start, int number);
388 void checkArrays(int ignoreEmpty=0) const;
390 void checkDjs(int type=1) const;
392 void checkSolutionBasic() const;
394 void checkMoveBack(bool checkDuals);
395 public:
406 void setValuesPassAction(double incomingInfeasibility,
407 double allowedInfeasibility);
410 int cleanFactorization(int ifValuesPass);
412 void moveStatusToClp(ClpSimplex * clpModel);
414 void moveStatusFromClp(ClpSimplex * clpModel);
416
418 public:
419
421 inline double clpObjectiveValue() const {
422 return (objectiveValue_+objectiveOffset_-bestPossibleImprovement_)*optimizationDirection_ - dblParam_[ClpObjOffset];
423 }
426 inline int * pivotVariable() const {
427 return abcPivotVariable_;
428 }
430 inline int stateOfProblem() const
431 { return stateOfProblem_;}
433 inline void setStateOfProblem(int value)
434 { stateOfProblem_=value;}
436 //inline int * fromExternal() const
437 //{ return fromExternal_;}
439 //inline int * toExternal() const
440 //{return toExternal_;}
443 inline double * scaleFromExternal() const
444 {return scaleFromExternal_;}
447 inline double * scaleToExternal() const
448 {return scaleToExternal_;}
450 inline double * rowScale2() const
451 {return rowUseScale_;}
452 inline double * inverseRowScale2() const
453 {return inverseRowUseScale_;}
454 inline double * inverseColumnScale2() const
455 {return inverseColumnUseScale_;}
456 inline double * columnScale2() const
457 {return columnUseScale_;}
458 inline int arrayForDualColumn() const
459 {return arrayForDualColumn_;}
461 inline double upperTheta() const
462 {return upperTheta_;}
463 inline int arrayForReplaceColumn() const
464 { return arrayForReplaceColumn_;}
465 inline int arrayForFlipBounds() const
466 { return arrayForFlipBounds_;}
467 inline int arrayForFlipRhs() const
468 { return arrayForFlipRhs_;}
469 inline int arrayForBtran() const
470 { return arrayForBtran_;}
471 inline int arrayForFtran() const
472 { return arrayForFtran_;}
473 inline int arrayForTableauRow() const
474 { return arrayForTableauRow_;}
476 double valueIncomingDual() const;
478 const double * getColSolution() const;
479
481 const double * getRowPrice() const;
482
484 const double * getReducedCost() const;
485
488 const double * getRowActivity() const;
490
496 int gutsOfSolution ( double * givenDuals,
497 const double * givenPrimals,
498 bool valuesPass = false);
500 void gutsOfDelete(int type);
502 void gutsOfCopy(const AbcSimplex & rhs);
504 void gutsOfInitialize(int numberRows,int numberColumns,bool doMore);
506 void gutsOfResize(int numberRows,int numberColumns);
510 void translate(int type);
512 void moveToBasic(int which=15);
514 public:
517 inline double * solutionRegion() const {
519 return abcSolution_;
520 }
521 inline double * djRegion() const {
522 return abcDj_;
523 }
524 inline double * lowerRegion() const {
525 return abcLower_;
526 }
527 inline double * upperRegion() const {
528 return abcUpper_;
529 }
530 inline double * costRegion() const {
531 return abcCost_;
532 }
534 inline double * solutionRegion(int which) const {
535 return abcSolution_+which*maximumAbcNumberRows_;
536 }
537 inline double * djRegion(int which) const {
538 return abcDj_+which*maximumAbcNumberRows_;
539 }
540 inline double * lowerRegion(int which) const {
541 return abcLower_+which*maximumAbcNumberRows_;
542 }
543 inline double * upperRegion(int which) const {
544 return abcUpper_+which*maximumAbcNumberRows_;
545 }
546 inline double * costRegion(int which) const {
547 return abcCost_+which*maximumAbcNumberRows_;
548 }
550 inline double * solutionBasic() const {
551 return solutionBasic_;
552 }
553 inline double * djBasic() const {
554 return djBasic_;
555 }
556 inline double * lowerBasic() const {
557 return lowerBasic_;
558 }
559 inline double * upperBasic() const {
560 return upperBasic_;
561 }
562 inline double * costBasic() const {
563 return costBasic_;
564 }
566 inline double * abcPerturbation() const
567 { return abcPerturbation_;}
569 inline double * fakeDjs() const
570 { return djSaved_;}
571 inline unsigned char * internalStatus() const
572 { return internalStatus_;}
573 inline AbcSimplex::Status getInternalStatus(int sequence) const {
574 return static_cast<Status> (internalStatus_[sequence] & 7);
575 }
576 inline AbcSimplex::Status getInternalColumnStatus(int sequence) const {
577 return static_cast<Status> (internalStatus_[sequence+maximumAbcNumberRows_] & 7);
578 }
579 inline void setInternalStatus(int sequence, AbcSimplex::Status newstatus) {
580 unsigned char & st_byte = internalStatus_[sequence];
581 st_byte = static_cast<unsigned char>(st_byte & ~7);
582 st_byte = static_cast<unsigned char>(st_byte | newstatus);
583 }
584 inline void setInternalColumnStatus(int sequence, AbcSimplex::Status newstatus) {
585 unsigned char & st_byte = internalStatus_[sequence+maximumAbcNumberRows_];
586 st_byte = static_cast<unsigned char>(st_byte & ~7);
587 st_byte = static_cast<unsigned char>(st_byte | newstatus);
588 }
593 void setInitialDenseFactorization(bool onOff);
594 bool initialDenseFactorization() const;
596 inline int sequenceIn() const {
597 return sequenceIn_;
598 }
599 inline int sequenceOut() const {
600 return sequenceOut_;
601 }
603 inline void setSequenceIn(int sequence) {
604 sequenceIn_ = sequence;
605 }
606 inline void setSequenceOut(int sequence) {
607 sequenceOut_ = sequence;
608 }
609 #if 0
610
611 inline int sequenceInternalIn() const {
612 return sequenceInternalIn_;
613 }
614 inline int sequenceInternalOut() const {
615 return sequenceInternalOut_;
616 }
618 inline void setSequenceInternalIn(int sequence) {
619 sequenceInternalIn_ = sequence;
620 }
621 inline void setSequenceInternalOut(int sequence) {
622 sequenceInternalOut_ = sequence;
623 }
624 #endif
625 inline int isColumn(int sequence) const {
627 return sequence >= maximumAbcNumberRows_ ? 1 : 0;
628 }
630 inline int sequenceWithin(int sequence) const {
631 return sequence < maximumAbcNumberRows_ ? sequence : sequence - maximumAbcNumberRows_;
632 }
634 inline int lastPivotRow() const
635 { return lastPivotRow_;}
637 inline int firstFree() const
638 { return firstFree_;}
640 inline int lastFirstFree() const
641 { return lastFirstFree_;}
643 inline int freeSequenceIn() const
644 { return freeSequenceIn_;}
646 inline double currentAcceptablePivot() const
647 { return currentAcceptablePivot_;}
648 #ifdef PAN
649
655 inline int fakeSuperBasic(int iSequence) {
656 if ((internalStatus_[iSequence]&7)==4)
657 return 0; // free
658 if ((internalStatus_[iSequence]&7)!=5)
659 return -2;
660 double value=abcSolution_[iSequence];
661 if (value<abcLower_[iSequence]+primalTolerance_) {
662 if(abcDj_[iSequence]>=-currentDualTolerance_) {
663 setInternalStatus(iSequence,atLowerBound);
664 #if PRINT_PAN>1
665 printf("Pansetting %d to lb\n",iSequence);
666 #endif
667 return -1;
668 } else {
669 return 1;
670 }
671 } else if (value>abcUpper_[iSequence]-primalTolerance_) {
672 if (abcDj_[iSequence]<=currentDualTolerance_) {
673 setInternalStatus(iSequence,atUpperBound);
674 #if PRINT_PAN>1
675 printf("Pansetting %d to ub\n",iSequence);
676 #endif
677 return -1;
678 } else {
679 return 1;
680 }
681 } else {
682 return 0;
683 }
684 }
685 #endif
686 inline double solution(int sequence) {
688 return abcSolution_[sequence];
689 }
691 inline double & solutionAddress(int sequence) {
692 return abcSolution_[sequence];
693 }
694 inline double reducedCost(int sequence) {
695 return abcDj_[sequence];
696 }
697 inline double & reducedCostAddress(int sequence) {
698 return abcDj_[sequence];
699 }
700 inline double lower(int sequence) {
701 return abcLower_[sequence];
702 }
704 inline double & lowerAddress(int sequence) {
705 return abcLower_[sequence];
706 }
707 inline double upper(int sequence) {
708 return abcUpper_[sequence];
709 }
711 inline double & upperAddress(int sequence) {
712 return abcUpper_[sequence];
713 }
714 inline double cost(int sequence) {
715 return abcCost_[sequence];
716 }
718 inline double & costAddress(int sequence) {
719 return abcCost_[sequence];
720 }
722 inline double originalLower(int iSequence) const {
723 if (iSequence < numberColumns_) return columnLower_[iSequence];
724 else
725 return rowLower_[iSequence-numberColumns_];
726 }
728 inline double originalUpper(int iSequence) const {
729 if (iSequence < numberColumns_) return columnUpper_[iSequence];
730 else
731 return rowUpper_[iSequence-numberColumns_];
732 }
734 inline AbcSimplexProgress * abcProgress()
735 { return &abcProgress_;}
736 #ifdef ABC_SPRINT
737 AbcSimplex * createSubProblem(int numberColumns,const int * whichColumn);
740 void restoreFromSubProblem(AbcSimplex * fullProblem, const int * whichColumn);
741 #endif
742 public:
745 inline void clearArraysPublic(int which)
746 { clearArrays(which);}
749 inline int getAvailableArrayPublic() const
750 { return getAvailableArray();}
751 #if ABC_PARALLEL
752 inline int parallelMode() const
754 { return parallelMode_;}
756 inline void setParallelMode(int value)
757 { parallelMode_=value;}
759 inline int numberCpus() const
760 { return parallelMode_+1;}
761 #if ABC_PARALLEL==1
762 inline void setStopStart(int value)
764 { stopStart_=value;}
765 #endif
766 #endif
767 //protected:
769 void clearArrays(int which);
771 void clearArrays(CoinPartitionedVector * which);
773 int getAvailableArray() const;
775 inline void setUsedArray(int which) const
776 {int check=1<<which;assert ((stateOfProblem_&check)==0);stateOfProblem_|=check;}
778 inline void setAvailableArray(int which) const
779 {int check=1<<which;assert ((stateOfProblem_&check)!=0);
780 assert (!usefulArray_[which].getNumElements());stateOfProblem_&=~check;}
782 void swapPrimalStuff();
784 void swapDualStuff(int lastSequenceOut,int lastDirectionOut);
785 protected:
787
789 void swap(int pivotRow,int nonBasicPosition,Status newStatus);
791 inline void setFakeBound(int sequence, FakeBound fakeBound) {
792 unsigned char & st_byte = internalStatus_[sequence];
793 st_byte = static_cast<unsigned char>(st_byte & ~24);
794 st_byte = static_cast<unsigned char>(st_byte | (fakeBound << 3));
795 }
796 inline FakeBound getFakeBound(int sequence) const {
797 return static_cast<FakeBound> ((internalStatus_[sequence] >> 3) & 3);
798 }
799 bool atFakeBound(int sequence) const;
800 inline void setPivoted( int sequence) {
801 internalStatus_[sequence] = static_cast<unsigned char>(internalStatus_[sequence] | 32);
802 }
803 inline void clearPivoted( int sequence) {
804 internalStatus_[sequence] = static_cast<unsigned char>(internalStatus_[sequence] & ~32);
805 }
806 inline bool pivoted(int sequence) const {
807 return (((internalStatus_[sequence] >> 5) & 1) != 0);
808 }
809 public:
811 void swap(int pivotRow,int nonBasicPosition);
813 void setFlagged( int sequence);
814 inline void clearFlagged( int sequence) {
815 internalStatus_[sequence] = static_cast<unsigned char>(internalStatus_[sequence] & ~64);
816 }
817 inline bool flagged(int sequence) const {
818 return ((internalStatus_[sequence] & 64) != 0);
819 }
820 protected:
822 inline void setActive( int iRow) {
823 internalStatus_[iRow] = static_cast<unsigned char>(internalStatus_[iRow] | 128);
824 }
825 inline void clearActive( int iRow) {
826 internalStatus_[iRow] = static_cast<unsigned char>(internalStatus_[iRow] & ~128);
827 }
828 inline bool active(int iRow) const {
829 return ((internalStatus_[iRow] & 128) != 0);
830 }
831 public:
834 void createStatus() ;
836 void crash(int type);
841 void putStuffInBasis(int type);
844 void allSlackBasis();
846 void checkConsistentPivots() const;
848 void printStuff() const;
850 int startup(int ifValuesPass);
851
853 inline double rawObjectiveValue() const {
854 return objectiveValue_;
855 }
857 void computeObjectiveValue(bool useWorkingSolution = false);
859 double computeInternalObjectiveValue();
861 void moveInfo(const AbcSimplex & rhs, bool justStatus = false);
862 #ifndef NUMBER_THREADS
863 #define NUMBER_THREADS 3
864 #endif
865 #if ABC_PARALLEL==1
866 // For waking up thread
867 inline pthread_mutex_t * mutexPointer(int which,int thread=0)
868 { return mutex_+which+3*thread;}
869 inline pthread_barrier_t * barrierPointer()
870 { return &barrier_;}
871 inline int whichLocked(int thread=0) const
872 { return locked_[thread];}
873 inline CoinThreadInfo * threadInfoPointer(int thread=0)
874 { return threadInfo_+thread;}
875 void startParallelStuff(int type);
876 int stopParallelStuff(int type);
878 int whichThread() const;
879 #elif ABC_PARALLEL==2
880 //inline CoinThreadInfo * threadInfoPointer(int thread=0)
881 //{ return threadInfo_+thread;}
882 #endif
883
884
885 //-------------------------------------------------------------------------
889 void setObjectiveCoefficient( int elementIndex, double elementValue );
891 inline void setObjCoeff( int elementIndex, double elementValue ) {
892 setObjectiveCoefficient( elementIndex, elementValue);
893 }
894
897 void setColumnLower( int elementIndex, double elementValue );
898
901 void setColumnUpper( int elementIndex, double elementValue );
902
904 void setColumnBounds( int elementIndex,
905 double lower, double upper );
906
915 void setColumnSetBounds(const int* indexFirst,
916 const int* indexLast,
917 const double* boundList);
918
921 inline void setColLower( int elementIndex, double elementValue ) {
922 setColumnLower(elementIndex, elementValue);
923 }
926 inline void setColUpper( int elementIndex, double elementValue ) {
927 setColumnUpper(elementIndex, elementValue);
928 }
929
931 inline void setColBounds( int elementIndex,
932 double newlower, double newupper ) {
933 setColumnBounds(elementIndex, newlower, newupper);
934 }
935
942 inline void setColSetBounds(const int* indexFirst,
943 const int* indexLast,
944 const double* boundList) {
945 setColumnSetBounds(indexFirst, indexLast, boundList);
946 }
947
950 void setRowLower( int elementIndex, double elementValue );
951
954 void setRowUpper( int elementIndex, double elementValue ) ;
955
957 void setRowBounds( int elementIndex,
958 double lower, double upper ) ;
959
966 void setRowSetBounds(const int* indexFirst,
967 const int* indexLast,
968 const double* boundList);
970 void resize (int newNumberRows, int newNumberColumns);
971
973
975 protected:
976
983 double sumNonBasicCosts_;
986 double rawObjectiveValue_;
988 double objectiveOffset_;
993 double perturbationFactor_;
995 double currentDualTolerance_;
997 double currentDualBound_;
999 double largestGap_;
1001 double lastDualBound_;
1003 double sumFakeInfeasibilities_;
1005 double lastPrimalError_;
1007 double lastDualError_;
1009 double currentAcceptablePivot_;
1011 double movement_;
1013 double objectiveChange_;
1015 double btranAlpha_;
1017 #ifdef ABC_LONG_FACTORIZATION
1018 long
1019 #endif
1020 double ftAlpha_;
1022 double minimumThetaMovement_;
1024 double initialSumInfeasibilities_;
1025 public:
1027 int stateOfIteration_;
1028 protected:
1030 int lastFirstFree_;
1032 int freeSequenceIn_;
1034 int maximumAbcNumberRows_;
1036 int maximumAbcNumberColumns_;
1038 int maximumNumberTotal_;
1040 int numberFlagged_;
1042 int normalDualColumnIteration_;
1048 int stateDualColumn_;
1049 /*
1050 May want to put some arrays into struct
1051 Two arrays point to/from external
1052 Order is basic,unused basic, at lower, at upper, superbasic, free, fixed with starts
1053 */
1055 int numberTotal_;
1057 int numberTotalWithoutFixed_;
1059 #define startAtLowerNoOther_ maximumAbcNumberRows_
1060 int startAtLowerOther_;
1063 int startAtUpperNoOther_;
1065 int startAtUpperOther_;
1067 int startOther_;
1069 int startFixed_;
1070 #ifdef EARLY_FACTORIZE
1071 int numberEarly_;
1073 #endif
1074
1091 #define ALL_STATUS_OK 2048
1092 #define ROW_PRIMAL_OK 4096
1093 #define ROW_DUAL_OK 8192
1094 #define COLUMN_PRIMAL_OK 16384
1095 #define COLUMN_DUAL_OK 32768
1096 #define PESSIMISTIC 65536
1097 #define ADD_A_BIT 131072
1098 #define DO_SCALE_AND_MATRIX 262144
1099 #define DO_BASIS_AND_ORDER 524288
1100 #define DO_STATUS 1048576
1101 #define DO_SOLUTION 2097152
1102 #define DO_JUST_BOUNDS 0x400000
1103 #define NEED_BASIS_SORT 0x800000
1104 #define FAKE_SUPERBASIC 0x1000000
1105 #define VALUES_PASS 0x2000000
1106 #define VALUES_PASS2 0x4000000
1107 mutable int stateOfProblem_;
1108 #if ABC_PARALLEL
1109 public:
1111 int parallelMode_;
1112 protected:
1113 #endif
1114 int numberOrdinary_;
1117 int ordinaryVariables_;
1119 int numberFreeNonBasic_;
1121 int lastCleaned_;
1123 int lastPivotRow_;
1125 int swappedAlgorithm_;
1127 int initialNumberInfeasibilities_;
1129 //int * fromExternal_;
1131 //int * toExternal_;
1134 double * scaleFromExternal_;
1137 double * scaleToExternal_;
1139 double * columnUseScale_;
1141 double * inverseColumnUseScale_;
1145 double * offset_;
1147 double * offsetRhs_;
1149 double * tempArray_;
1154 unsigned char * internalStatus_;
1156 unsigned char * internalStatusSaved_;
1159 double * abcPerturbation_;
1161 double * perturbationSaved_;
1163 double * perturbationBasic_;
1165 AbcMatrix * abcMatrix_;
1168 double * abcLower_;
1171 double * abcUpper_;
1177 double * abcCost_;
1180 double * abcSolution_;
1183 double * abcDj_;
1185 double * lowerSaved_;
1187 double * upperSaved_;
1189 double * costSaved_;
1191 double * solutionSaved_;
1193 double * djSaved_;
1195 double * lowerBasic_;
1197 double * upperBasic_;
1199 double * costBasic_;
1201 double * solutionBasic_;
1203 double * djBasic_;
1205 AbcDualRowPivot * abcDualRowPivot_;
1207 AbcPrimalColumnPivot * abcPrimalColumnPivot_;
1211 int * abcPivotVariable_;
1213 int * reversePivotVariable_;
1215 AbcSimplexFactorization * abcFactorization_;
1216 #ifdef EARLY_FACTORIZE
1217 AbcSimplexFactorization * abcEarlyFactorization_;
1219 #endif
1220 #ifdef TEMPORARY_FACTORIZATION
1221 AbcSimplexFactorization * abcOtherFactorization_;
1223 #endif
1224 //double * savedSolution_;
1227 AbcSimplex * abcBaseModel_;
1229 ClpSimplex * clpModel_;
1234 AbcNonLinearCost * abcNonLinearCost_;
1236 /* has secondary offset and counts so row goes first then column
1237 Probably back to CoinPartitionedVector as AbcMatrix has slacks
1238 also says if in use - so we can just get next available one */
1239 #define ABC_NUMBER_USEFUL 8
1240 mutable CoinPartitionedVector usefulArray_[ABC_NUMBER_USEFUL];
1242 AbcSimplexProgress abcProgress_;
1244 ClpDataSave saveData_;
1246 double upperTheta_;
1248 int multipleSequenceIn_[4];
1249 public:
1250 int arrayForDualColumn_;
1251 int arrayForReplaceColumn_;
1252 int arrayForFlipBounds_; //2
1253 int arrayForFlipRhs_; // if sequential can re-use
1254 int arrayForBtran_; // 0
1255 int arrayForFtran_; // 1
1256 int arrayForTableauRow_; //3
1257 protected:
1258 int numberFlipped_;
1259 int numberDisasters_;
1260 //int nextCleanNonBasicIteration_;
1261 #if ABC_PARALLEL==1
1262 // For waking up thread
1263 pthread_mutex_t mutex_[3*NUMBER_THREADS];
1264 pthread_barrier_t barrier_;
1265 CoinThreadInfo threadInfo_[NUMBER_THREADS];
1266 pthread_t abcThread_[NUMBER_THREADS];
1267 int locked_[NUMBER_THREADS];
1268 int stopStart_;
1269 #elif ABC_PARALLEL==2
1270 //CoinThreadInfo threadInfo_[NUMBER_THREADS];
1271 #endif
1272
1273 };
1274 //#############################################################################
1283 void
1284 AbcSimplexUnitTest(const std::string & mpsDir);
1285 #endif
AbcSimplex::numberTotal
int numberTotal() const
Number of variables (includes spare rows)
Definition: AbcSimplex.hpp:222
AbcSimplex::objectiveChange_
double objectiveChange_
Objective change.
Definition: AbcSimplex.hpp:1013
AbcSimplex::maximumNumberTotal
int maximumNumberTotal() const
Maximum Total.
Definition: AbcSimplex.hpp:215
AbcSimplex::abcDualRowPivot_
AbcDualRowPivot * abcDualRowPivot_
dual row pivot choice
Definition: AbcSimplex.hpp:1205
ROW_LOWER_SAME
#define ROW_LOWER_SAME
Whats changed since last solve.
Definition: ClpModel.hpp:1206
AbcSimplex::solution
double solution(int sequence)
Return row or column values.
Definition: AbcSimplex.hpp:687
AbcSimplex::computePrimals
int computePrimals(CoinIndexedVector *array1, CoinIndexedVector *array2)
Computes primals from scratch. Returns number of refinements.
AbcSimplex::solutionAddress
double & solutionAddress(int sequence)
Return address of row or column values.
Definition: AbcSimplex.hpp:691
AbcSimplex::usefulArray
CoinPartitionedVector * usefulArray(int index) const
factorization
Definition: AbcSimplex.hpp:231
AbcSimplex::sumNonBasicCosts_
double sumNonBasicCosts_
Sum of nonbasic costs.
Definition: AbcSimplex.hpp:984
AbcSimplex::defaultFactorizationFrequency
void defaultFactorizationFrequency()
If user left factorization frequency then compute.
AbcSimplex::lowerRegion
double * lowerRegion(int which) const
Return region.
Definition: AbcSimplex.hpp:540
AbcSimplex::~AbcSimplex
~AbcSimplex()
Destructor.
AbcSimplex
Definition: AbcSimplex.hpp:62
AbcSimplex::setRowSetBounds
void setRowSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of rows simultaneously
AbcSimplex::getRowPrice
const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
AbcSimplex::acceptablePivot
double acceptablePivot() const
Acceptable pivot for this iteration.
Definition: AbcSimplex.hpp:270
AbcSimplex::usefulArray
CoinPartitionedVector * usefulArray(int index)
Useful arrays (0,1,2,3,4,5,6,7)
Definition: AbcSimplex.hpp:228
AbcSimplex::valueIncomingDual
double valueIncomingDual() const
value of incoming variable (in Dual)
AbcSimplex::refreshLower
void refreshLower(unsigned int type=~(ROW_LOWER_SAME|COLUMN_UPPER_SAME))
Given an existing factorization computes and checks primal and dual solutions.
AbcSimplex::arrayForBtran
int arrayForBtran() const
factorization
Definition: AbcSimplex.hpp:469
AbcSimplex::ordinaryVariables
int ordinaryVariables() const
Set to 1 if no free or super basic.
Definition: AbcSimplex.hpp:273
AbcSimplex::arrayForFtran_
int arrayForFtran_
Sum of nonbasic costs.
Definition: AbcSimplex.hpp:1255
AbcSimplex::setClpSimplexObjectiveValue
void setClpSimplexObjectiveValue()
Sets objectiveValue_ from rawObjectiveValue_.
AbcSimplex::clearArraysPublic
void clearArraysPublic(int which)
Clears an array and says available (-1 does all) when no possibility of going parallel.
Definition: AbcSimplex.hpp:745
AbcSimplex::scaleToExternal_
double * scaleToExternal_
Scale from primal internal to external (in external order) Or other way for dual. ...
Definition: AbcSimplex.hpp:1137
AbcSimplex::arrayForFlipBounds
int arrayForFlipBounds() const
factorization
Definition: AbcSimplex.hpp:465
AbcSimplex::freeSequenceIn_
int freeSequenceIn_
Free chosen vector.
Definition: AbcSimplex.hpp:1032
AbcSimplex::numberOrdinary_
int numberOrdinary_
Number of ordinary (lo/up) in tableau row.
Definition: AbcSimplex.hpp:1115
AbcSimplex::bothFake
Definition: AbcSimplex.hpp:87
AbcSimplex::moveStatusToClp
void moveStatusToClp(ClpSimplex *clpModel)
Move status and solution to ClpSimplex.
AbcSimplex::startAtLowerOther_
int startAtLowerOther_
Start of variables at lower bound with upper.
Definition: AbcSimplex.hpp:1061
AbcSimplex::abcPrimalColumnPivot_
AbcPrimalColumnPivot * abcPrimalColumnPivot_
primal column pivot choice
Definition: AbcSimplex.hpp:1207
AbcSimplex::abcNonLinearCost_
AbcNonLinearCost * abcNonLinearCost_
Very wasteful way of dealing with infeasibilities in primal.
Definition: AbcSimplex.hpp:1234
AbcSimplex::computeObjective
void computeObjective()
Computes nonbasic cost and total cost.
AbcSimplex::isFixed
Definition: AbcSimplex.hpp:80
ClpDataSave
This is a tiny class where data can be saved round calls.
Definition: ClpModel.hpp:1269
AbcSimplex::setFakeBound
void setFakeBound(int sequence, FakeBound fakeBound)
Swaps two variables.
Definition: AbcSimplex.hpp:791
ClpModel::numberColumns_
int numberColumns_
Number of columns.
Definition: ClpModel.hpp:1126
AbcSimplex::numberFlagged_
int numberFlagged_
Current number of variables flagged.
Definition: AbcSimplex.hpp:1040
ClpModel::rowUpper_
double * rowUpper_
Row upper.
Definition: ClpModel.hpp:1138
AbcSimplex::AbcSimplexUnitTest
friend void AbcSimplexUnitTest(const std::string &mpsDir)
A function that tests the methods in the AbcSimplex class.
AbcSimplex::checkDualSolutionPlusFake
void checkDualSolutionPlusFake()
This sets largest infeasibility and most infeasible and sum and number of infeasibilities AND sumFake...
AbcSimplex::solutionBasic
double * solutionBasic() const
Return region.
Definition: AbcSimplex.hpp:550
AbcSimplex::perturbationBasic_
double * perturbationBasic_
basic perturbation
Definition: AbcSimplex.hpp:1163
CoinPartitionedVector
Definition: CoinIndexedVector.hpp:1057
AbcSimplex::lowerBasic
double * lowerBasic() const
Return region.
Definition: AbcSimplex.hpp:556
AbcSimplex::originalLower
double originalLower(int iSequence) const
Return original lower bound.
Definition: AbcSimplex.hpp:722
AbcSimplex::setRowUpper
void setRowUpper(int elementIndex, double elementValue)
Set a single row upper bound Use DBL_MAX for infinity.
AbcSimplex::abcPerturbation
double * abcPerturbation() const
Perturbation.
Definition: AbcSimplex.hpp:566
AbcSimplex::upperRegion
double * upperRegion(int which) const
Return region.
Definition: AbcSimplex.hpp:543
AbcSimplex::deleteBaseModel
void deleteBaseModel()
Switch off base model.
AbcSimplex::lastDualBound_
double lastDualBound_
Last dual bound.
Definition: AbcSimplex.hpp:1001
AbcSimplex::arrayForFlipRhs
int arrayForFlipRhs() const
factorization
Definition: AbcSimplex.hpp:467
AbcSimplex::atFakeBound
bool atFakeBound(int sequence) const
Swaps two variables.
AbcSimplex::abcMatrix
AbcMatrix * abcMatrix() const
Abc Matrix.
Definition: AbcSimplex.hpp:293
AbcSimplex::upperBasic
double * upperBasic() const
Return region.
Definition: AbcSimplex.hpp:559
AbcSimplex::setFactorization
void setFactorization(AbcSimplexFactorization &factorization)
Passes in factorization.
ClpModel::solveType
int solveType() const
Solve type - 1 simplex, 2 simplex interface, 3 Interior.
Definition: ClpModel.hpp:373
AbcSimplex::initialDenseFactorization
bool initialDenseFactorization() const
Return region.
AbcSimplex::numberTotalWithoutFixed
int numberTotalWithoutFixed() const
Number of variables without fixed to zero (includes spare rows)
Definition: AbcSimplex.hpp:225
AbcSimplex::arrayForTableauRow_
int arrayForTableauRow_
Sum of nonbasic costs.
Definition: AbcSimplex.hpp:1256
AbcSimplex::currentDualBound
double currentDualBound() const
Current dualBound (will end up as dualBound_)
Definition: AbcSimplex.hpp:282
AbcSimplex::maximumAbcNumberColumns_
int maximumAbcNumberColumns_
Maximum number columns.
Definition: AbcSimplex.hpp:1036
AbcSimplex::internalStatus_
unsigned char * internalStatus_
Working status ? may be signed ? link pi_ to an indexed array? may have saved from last factorization...
Definition: AbcSimplex.hpp:1154
AbcSimplex::getRowActivity
const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
AbcNonLinearCost
Definition: AbcNonLinearCost.hpp:72
AbcSimplex::numberDisasters_
int numberDisasters_
Sum of nonbasic costs.
Definition: AbcSimplex.hpp:1259
AbcSimplex::saveGoodStatus
void saveGoodStatus()
Saves good status etc.
AbcSimplex::tightenPrimalBounds
int tightenPrimalBounds()
Tightens primal bounds to make dual faster.
AbcSimplex::doAbcDual
int doAbcDual()
Dual algorithm - see AbcSimplexDual.hpp for method.
AbcSimplex::reversePivotVariable_
int * reversePivotVariable_
Reverse abcPivotVariable_ for moving around.
Definition: AbcSimplex.hpp:1213
AbcSimplex::baseModel
AbcSimplex * baseModel() const
See if we have base model.
Definition: AbcSimplex.hpp:146
AbcSimplex::solutionSaved_
double * solutionSaved_
Saved scaled primal solution.
Definition: AbcSimplex.hpp:1191
AbcCommon.hpp
AbcSimplex::inverseRowScale2
double * inverseRowScale2() const
factorization
Definition: AbcSimplex.hpp:452
AbcSimplex::reducedCost
double reducedCost(int sequence)
Return region.
Definition: AbcSimplex.hpp:694
AbcSimplex::abcMatrix_
AbcMatrix * abcMatrix_
Working matrix.
Definition: AbcSimplex.hpp:1165
AbcSimplex::rawObjectiveValue
double rawObjectiveValue() const
Raw objective value (so always minimize in primal)
Definition: AbcSimplex.hpp:853
AbcSimplex::currentDualBound_
double currentDualBound_
Current dualBound (will end up as dualBound_)
Definition: AbcSimplex.hpp:997
AbcSimplex::putBackSolution
void putBackSolution(ClpSimplex *simplex)
Put back solution into ClpSimplex.
ClpSimplex.hpp
AbcSimplex::getInternalStatus
AbcSimplex::Status getInternalStatus(int sequence) const
Return region.
Definition: AbcSimplex.hpp:573
AbcSimplex::setPrimalColumnPivotAlgorithm
void setPrimalColumnPivotAlgorithm(AbcPrimalColumnPivot &choice)
Sets column pivot choice algorithm in primal.
AbcSimplex::costBasic_
double * costBasic_
Working scaled copy of basic objective.
Definition: AbcSimplex.hpp:1199
AbcSimplex::scaleFromExternal
double * scaleFromExternal() const
Points from external to internal.
Definition: AbcSimplex.hpp:443
AbcSimplex::costRegion
double * costRegion() const
Return region.
Definition: AbcSimplex.hpp:530
ClpModel::numberRows
int numberRows() const
Number of rows.
Definition: ClpModel.hpp:315
AbcSimplex::restoreData
void restoreData(ClpDataSave saved)
Restore data.
AbcSimplex::abcDj_
double * abcDj_
Working scaled dual solution may have saved from last factorization at end.
Definition: AbcSimplex.hpp:1183
AbcSimplex::getFakeBound
FakeBound getFakeBound(int sequence) const
Swaps two variables.
Definition: AbcSimplex.hpp:796
AbcSimplex::getReducedCost
const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
AbcSimplex::inverseColumnUseScale_
double * inverseColumnUseScale_
use this instead of inverseColumnScale
Definition: AbcSimplex.hpp:1141
AbcSimplex::initialNumberInfeasibilities_
int initialNumberInfeasibilities_
Initial number of infeasibilities.
Definition: AbcSimplex.hpp:1127
AbcSimplex::getAvailableArray
int getAvailableArray() const
Returns first available empty array (and sets flag)
ClpModel::optimizationDirection_
double optimizationDirection_
Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
Definition: ClpModel.hpp:1112
AbcSimplex::lastFirstFree_
int lastFirstFree_
Last firstFree_.
Definition: AbcSimplex.hpp:1030
AbcSimplex::lowerAddress
double & lowerAddress(int sequence)
Return address of row or column lower bound.
Definition: AbcSimplex.hpp:704
AbcSimplex::costRegion
double * costRegion(int which) const
Return region.
Definition: AbcSimplex.hpp:546
AbcMatrix
Definition: AbcMatrix.hpp:22
AbcSimplex::housekeeping
int housekeeping()
This does basis housekeeping and does values for in/out variables.
ClpSimplex::firstFree_
int firstFree_
First free/super-basic variable (-1 if none)
Definition: ClpSimplex.hpp:1666
AbcSimplex::getInternalColumnStatus
AbcSimplex::Status getInternalColumnStatus(int sequence) const
Return region.
Definition: AbcSimplex.hpp:576
AbcSimplex::isObjectiveLimitTestValid
bool isObjectiveLimitTestValid() const
Return true if the objective limit test can be relied upon.
AbcSimplex::primalColumnPivot
AbcPrimalColumnPivot * primalColumnPivot() const
primal column pivot choice
Definition: AbcSimplex.hpp:289
AbcSimplex::permuteIn
void permuteIn()
Permutes in from ClpModel data - assumes scale factors done and AbcMatrix exists but is in original o...
AbcSimplex::clpModel_
ClpSimplex * clpModel_
A copy of model as ClpSimplex with certain state.
Definition: AbcSimplex.hpp:1229
AbcSimplex::solutionRegion
double * solutionRegion(int which) const
Return region.
Definition: AbcSimplex.hpp:534
AbcSimplex::setPivoted
void setPivoted(int sequence)
Swaps two variables.
Definition: AbcSimplex.hpp:800
AbcSimplex::setDualRowPivotAlgorithm
void setDualRowPivotAlgorithm(AbcDualRowPivot &choice)
Sets row pivot choice algorithm in dual.
AbcSimplex::setActive
void setActive(int iRow)
To say row active in primal pivot row choice.
Definition: AbcSimplex.hpp:822
AbcSimplex::doAbcPrimal
int doAbcPrimal(int ifValuesPass)
Dual algorithm - see AbcSimplexDual.hpp for method.
AbcSimplex::clearPivoted
void clearPivoted(int sequence)
Swaps two variables.
Definition: AbcSimplex.hpp:803
AbcSimplex::abcLower_
double * abcLower_
Working scaled copy of lower bounds has original scaled copy at end.
Definition: AbcSimplex.hpp:1168
AbcSimplex::fakeSuperBasic
int fakeSuperBasic(int iSequence)
Returns 1 if fake superbasic 0 if free or true superbasic -1 if was fake but has cleaned itself up (s...
Definition: AbcSimplex.hpp:655
AbcSimplex::checkArrays
void checkArrays(int ignoreEmpty=0) const
For debug - prints summary of arrays which are out of kilter.
ClpModel::columnUpper_
double * columnUpper_
Column Upper.
Definition: ClpModel.hpp:1146
AbcSimplex::refreshCosts
void refreshCosts()
After modifying first copy refreshes second copy and marks as updated.
AbcSimplex::abcProgress
AbcSimplexProgress * abcProgress()
For dealing with all issues of cycling etc.
Definition: AbcSimplex.hpp:734
AbcSimplex::setStateOfProblem
void setStateOfProblem(int value)
State of problem.
Definition: AbcSimplex.hpp:433
AbcSimplex::scaleToExternal
double * scaleToExternal() const
Scale from primal internal to external (in external order) Or other way for dual. ...
Definition: AbcSimplex.hpp:447
AbcSimplex::numberFreeNonBasic_
int numberFreeNonBasic_
Number of free nonbasic variables.
Definition: AbcSimplex.hpp:1119
AbcSimplex::djBasic_
double * djBasic_
Working scaled basic dual solution (want it to be zero)
Definition: AbcSimplex.hpp:1203
AbcSimplex::checkBothSolutions
void checkBothSolutions()
This sets sum and number of infeasibilities (Dual and Primal)
AbcSimplex::abcProgress_
AbcSimplexProgress abcProgress_
For dealing with all issues of cycling etc.
Definition: AbcSimplex.hpp:1242
AbcSimplex::perturbationSaved
double * perturbationSaved() const
Perturbation (fixed) - is just scaled random numbers.
Definition: AbcSimplex.hpp:267
AbcSimplex::startAtUpperOther_
int startAtUpperOther_
Start of variables at upper bound with lower.
Definition: AbcSimplex.hpp:1065
AbcSimplex::basic
Definition: AbcSimplex.hpp:79
AbcSimplex::offset_
double * offset_
Primal offset (in external order) So internal value is (external-offset)*scaleFromExternal.
Definition: AbcSimplex.hpp:1145
AbcSimplex::arrayForFlipRhs_
int arrayForFlipRhs_
Sum of nonbasic costs.
Definition: AbcSimplex.hpp:1253
AbcSimplex::arrayForFlipBounds_
int arrayForFlipBounds_
Sum of nonbasic costs.
Definition: AbcSimplex.hpp:1252
AbcSimplex::swapFactorization
AbcSimplexFactorization * swapFactorization(AbcSimplexFactorization *factorization)
Swaps factorization.
AbcSimplex::swap
void swap(int pivotRow, int nonBasicPosition, Status newStatus)
Swaps two variables and does status.
AbcSimplex::currentDualTolerance
double currentDualTolerance() const
Current dualTolerance (will end up as dualTolerance_)
Definition: AbcSimplex.hpp:257
AbcSimplex::minimumThetaMovement_
double minimumThetaMovement_
Minimum theta movement.
Definition: AbcSimplex.hpp:1022
AbcSimplex::setSequenceOut
void setSequenceOut(int sequence)
Return region.
Definition: AbcSimplex.hpp:606
AbcSimplex::largestGap_
double largestGap_
Largest gap.
Definition: AbcSimplex.hpp:999
AbcSimplex::setColumnUpper
void setColumnUpper(int elementIndex, double elementValue)
Set a single column upper bound Use DBL_MAX for infinity.
ClpMatrixBase.hpp
AbcSimplex::arrayForFtran
int arrayForFtran() const
factorization
Definition: AbcSimplex.hpp:471
ClpSimplex::acceptablePivot_
double acceptablePivot_
Acceptable pivot value just after factorization.
Definition: ClpSimplex.hpp:1559
AbcSimplex::cost
double cost(int sequence)
Return region.
Definition: AbcSimplex.hpp:714
AbcSimplex::tempArray_
double * tempArray_
Useful array of numberTotal length.
Definition: AbcSimplex.hpp:1149
ClpModel::columnLower_
double * columnLower_
Column Lower.
Definition: ClpModel.hpp:1144
AbcSimplex::upperSaved_
double * upperSaved_
Saved scaled copy of upper bounds.
Definition: AbcSimplex.hpp:1187
AbcSimplex::operator=
AbcSimplex & operator=(const AbcSimplex &rhs)
Assignment operator. This copies the data.
AbcSimplex::abcPerturbation_
double * abcPerturbation_
Perturbation (fixed) - is just scaled random numbers If perturbationFactor_&lt;0 then virtual perturbati...
Definition: AbcSimplex.hpp:1159
AbcSimplex::saveData
ClpDataSave saveData()
Save data.
AbcSimplex::restoreGoodStatus
void restoreGoodStatus(int type)
Restores previous good status and says trouble.
AbcSimplex::sequenceOut
int sequenceOut() const
Return region.
Definition: AbcSimplex.hpp:599
AbcSimplex::superBasic
Definition: AbcSimplex.hpp:78
AbcSimplex::setAvailableArray
void setAvailableArray(int which) const
Say array going available.
Definition: AbcSimplex.hpp:778
AbcSimplex::noFake
Definition: AbcSimplex.hpp:84
AbcTolerancesEtc
Definition: CoinAbcCommon.hpp:256
AbcSimplex::setupDualValuesPass
void setupDualValuesPass(const double *fakeDuals, const double *fakePrimals, int type)
Sets dual values pass djs using unscaled duals type 1 - values pass type 2 - just use as infeasibilit...
AbcSimplex::permuteBasis
void permuteBasis()
deals with new basis and puts in abcPivotVariable_
AbcSimplex::arrayForDualColumn_
int arrayForDualColumn_
Sum of nonbasic costs.
Definition: AbcSimplex.hpp:1250
AbcSimplex::movement_
double movement_
Movement of variable.
Definition: AbcSimplex.hpp:1011
AbcSimplex::stateOfProblem
int stateOfProblem() const
State of problem.
Definition: AbcSimplex.hpp:430
AbcSimplex::reducedCostAddress
double & reducedCostAddress(int sequence)
Return region.
Definition: AbcSimplex.hpp:697
AbcSimplex::getAvailableArrayPublic
int getAvailableArrayPublic() const
Returns first available empty array (and sets flag) when no possibility of going parallel.
Definition: AbcSimplex.hpp:749
AbcSimplex::gutsOfSolution
int gutsOfSolution(int type)
Computes solutions - 1 do duals, 2 do primals, 3 both (returns number of refinements) ...
AbcSimplex::setInternalColumnStatus
void setInternalColumnStatus(int sequence, AbcSimplex::Status newstatus)
Return region.
Definition: AbcSimplex.hpp:584
AbcSimplex::setupPointers
void setupPointers(int maxRows, int maxColumns)
Sets up all extra pointers.
AbcSimplex::abcCost_
double * abcCost_
Working scaled copy of objective ? where perturbed copy or can we always work with perturbed copy (in...
Definition: AbcSimplex.hpp:1177
ClpModel::numberColumns
int numberColumns() const
Number of rows.
Definition: ClpModel.hpp:325
AbcSimplex::costAddress
double & costAddress(int sequence)
Return address of row or column cost.
Definition: AbcSimplex.hpp:718
AbcSimplex::translate
void translate(int type)
Translates ClpModel to AbcSimplex See DO_ bits in stateOfProblem_ for type e.g.
AbcSimplex::rawObjectiveValue_
double rawObjectiveValue_
Sum of costs (raw objective value)
Definition: AbcSimplex.hpp:986
AbcSimplex::columnUseScale_
double * columnUseScale_
use this instead of columnScale
Definition: AbcSimplex.hpp:1139
AbcSimplex::gutsOfResize
void gutsOfResize(int numberRows, int numberColumns)
resizes arrays
AbcSimplex::moveStatusFromClp
void moveStatusFromClp(ClpSimplex *clpModel)
Move status and solution from ClpSimplex.
AbcSimplex::setToBaseModel
void setToBaseModel(AbcSimplex *model=NULL)
Reset to base model (just size and arrays needed) If model NULL use internal copy.
AbcSimplex::columnScale2
double * columnScale2() const
factorization
Definition: AbcSimplex.hpp:456
AbcSimplex::setCurrentDualTolerance
void setCurrentDualTolerance(double value)
Given an existing factorization computes and checks primal and dual solutions.
Definition: AbcSimplex.hpp:259
AbcSimplex::clearArrays
void clearArrays(int which)
Clears an array and says available (-1 does all)
AbcSimplex::maximumAbcNumberRows
int maximumAbcNumberRows() const
Maximum rows.
Definition: AbcSimplex.hpp:212
AbcSimplex::maximumTotal
int maximumTotal() const
factorization
Definition: AbcSimplex.hpp:217
AbcSimplex::abcSolution_
double * abcSolution_
Working scaled primal solution may have saved from last factorization at end.
Definition: AbcSimplex.hpp:1180
AbcSimplex::startAtUpperNoOther_
int startAtUpperNoOther_
Start of variables at upper bound with no lower.
Definition: AbcSimplex.hpp:1063
AbcPrimalColumnPivot
Primal Column Pivot Abstract Base Class.
Definition: AbcPrimalColumnPivot.hpp:26
CoinIndexedVector.hpp
AbcSimplex::clearActive
void clearActive(int iRow)
Swaps two variables.
Definition: AbcSimplex.hpp:825
ClpDisasterHandler
Base class for Clp disaster handling.
Definition: ClpEventHandler.hpp:134
AbcSimplex::checkSolutionBasic
void checkSolutionBasic() const
For debug - checks solutionBasic.
AbcSimplex::allSlackBasis
void allSlackBasis()
Sets up all slack basis and resets solution to as it was after initial load or readMps.
AbcSimplex::abcPivotVariable_
int * abcPivotVariable_
Basic variables pivoting on which rows followed by atLo/atUp then free/superbasic then fixed...
Definition: AbcSimplex.hpp:1211
AbcSimplex::internalStatusSaved_
unsigned char * internalStatusSaved_
Saved status.
Definition: AbcSimplex.hpp:1156
AbcSimplex::getColSolution
const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
ClpModel::getNumElements
int getNumElements() const
Number of elements in matrix.
Definition: ClpModel.hpp:702
AbcSimplex::abcNonLinearCost
AbcNonLinearCost * abcNonLinearCost() const
Return pointer to details of costs.
Definition: AbcSimplex.hpp:263
ClpModel::objectiveValue_
double objectiveValue_
Objective value.
Definition: ClpModel.hpp:1116
AbcSimplex::arrayForReplaceColumn_
int arrayForReplaceColumn_
Sum of nonbasic costs.
Definition: AbcSimplex.hpp:1251
ClpSimplex::sequenceIn_
int sequenceIn_
Sequence of In variable.
Definition: ClpSimplex.hpp:1588
AbcSimplex::checkPrimalSolution
void checkPrimalSolution(bool justBasic)
This sets largest infeasibility and most infeasible and sum and number of infeasibilities (Primal) ...
COLUMN_UPPER_SAME
#define COLUMN_UPPER_SAME
Whats changed since last solve.
Definition: ClpModel.hpp:1210
AbcSimplex::clearFlagged
void clearFlagged(int sequence)
Swaps two variables.
Definition: AbcSimplex.hpp:814
CoinIndexedVector
Indexed Vector.
Definition: CoinIndexedVector.hpp:104
AbcSimplex::saveData_
ClpDataSave saveData_
For saving stuff at beginning.
Definition: AbcSimplex.hpp:1244
AbcSimplex::multipleSequenceIn_
int multipleSequenceIn_[4]
Multiple sequence in.
Definition: AbcSimplex.hpp:1248
AbcSimplex::checkDjs
void checkDjs(int type=1) const
For debug - summarizes dj situation (1 recomputes duals first, 2 checks duals as well) ...
AbcSimplex::copyFromSaved
void copyFromSaved(int type=31)
Copies all saved versions to working versions and may do something for perturbation.
AbcSimplex::btranAlpha_
double btranAlpha_
Btran alpha.
Definition: AbcSimplex.hpp:1015
AbcSimplex::normalDualColumnIteration_
int normalDualColumnIteration_
Iteration at which to do relaxed dualColumn.
Definition: AbcSimplex.hpp:1042
AbcSimplex::perturbationFactor_
double perturbationFactor_
Perturbation factor If &lt;0.0 then virtual if 0.0 none if &gt;0.0 use this as factor.
Definition: AbcSimplex.hpp:993
AbcSimplex::internalStatus
unsigned char * internalStatus() const
Return region.
Definition: AbcSimplex.hpp:571
rowUseScale_
#define rowUseScale_
Definition: AbcSimplex.hpp:375
AbcSimplex::ordinaryVariables_
int ordinaryVariables_
Set to 1 if no free or super basic.
Definition: AbcSimplex.hpp:1117
AbcSimplex::scaleFromExternal_
double * scaleFromExternal_
Points from external to internal.
Definition: AbcSimplex.hpp:1134
ClpSimplex
This solves LPs using the simplex method.
Definition: ClpSimplex.hpp:70
AbcSimplex::offsetRhs_
double * offsetRhs_
Offset for accumulated offsets*matrix.
Definition: AbcSimplex.hpp:1147
AbcSimplex::lower
double lower(int sequence)
Return region.
Definition: AbcSimplex.hpp:700
AbcSimplex::gutsOfCopy
void gutsOfCopy(const AbcSimplex &rhs)
Does most of copying.
AbcSimplex::numberTotalWithoutFixed_
int numberTotalWithoutFixed_
Number of variables without fixed to zero (includes spare rows)
Definition: AbcSimplex.hpp:1057
AbcSimplex::setColUpper
void setColUpper(int elementIndex, double elementValue)
Set a single column upper bound Use DBL_MAX for infinity.
Definition: AbcSimplex.hpp:926
AbcSimplex::isFree
Definition: AbcSimplex.hpp:77
AbcSimplex::arrayForDualColumn
int arrayForDualColumn() const
factorization
Definition: AbcSimplex.hpp:458
AbcSimplex::lowerFake
Definition: AbcSimplex.hpp:85
AbcSimplex::permuteOut
void permuteOut(int whatsWanted)
Permutes out - bit settings same as stateOfProblem.
AbcSimplex::lastPivotRow
int lastPivotRow() const
Current/last pivot row (set after END of choosing pivot row in dual)
Definition: AbcSimplex.hpp:634
AbcSimplex::dual
int dual()
Dual algorithm - see AbcSimplexDual.hpp for method.
AbcSimplex::inverseColumnScale2
double * inverseColumnScale2() const
factorization
Definition: AbcSimplex.hpp:454
AbcSimplex::getBasis
CoinWarmStartBasis * getBasis() const
Returns a basis (to be deleted by user)
AbcSimplex::primal
int primal(int ifValuesPass)
Primal algorithm - see AbcSimplexPrimal.hpp for method.
AbcSimplex::numberFlipped_
int numberFlipped_
Sum of nonbasic costs.
Definition: AbcSimplex.hpp:1258
AbcSimplex::computeDuals
int computeDuals(double *givenDjs, CoinIndexedVector *array1, CoinIndexedVector *array2)
Computes duals from scratch.
AbcSimplex::crash
void crash(int type)
Does sort of crash.
AbcSimplex::Status
Status
enums for status of various sorts.
Definition: AbcSimplex.hpp:74
AbcSimplex::upperTheta_
double upperTheta_
upper theta from dual column
Definition: AbcSimplex.hpp:1246
AbcSimplex::initialSumInfeasibilities_
double initialSumInfeasibilities_
Initial sum of infeasibilities.
Definition: AbcSimplex.hpp:1024
AbcSimplex::createStatus
void createStatus()
Set up status array (can be used by OsiAbc).
AbcSimplex::numberOrdinary
int numberOrdinary() const
Number of ordinary (lo/up) in tableau row.
Definition: AbcSimplex.hpp:276
AbcDualRowPivot
Dual Row Pivot Abstract Base Class.
Definition: AbcDualRowPivot.hpp:23
AbcSimplex::objectiveOffset_
double objectiveOffset_
Objective offset (from offset_)
Definition: AbcSimplex.hpp:988
AbcSimplex::factorizationFrequency
int factorizationFrequency() const
Factorization frequency.
AbcSimplex::active
bool active(int iRow) const
Swaps two variables.
Definition: AbcSimplex.hpp:828
AbcSimplex::setValuesPassAction
void setValuesPassAction(double incomingInfeasibility, double allowedInfeasibility)
For advanced use.
AbcSimplex::upperFake
Definition: AbcSimplex.hpp:86
AbcSimplex::isColumn
int isColumn(int sequence) const
Returns 1 if sequence indicates column.
Definition: AbcSimplex.hpp:626
AbcSimplex::setFlagged
void setFlagged(int sequence)
To flag a variable.
AbcSimplex::upperRegion
double * upperRegion() const
Return region.
Definition: AbcSimplex.hpp:527
AbcSimplex::originalUpper
double originalUpper(int iSequence) const
Return original lower bound.
Definition: AbcSimplex.hpp:728
AbcSimplexFactorization
This just implements AbcFactorization when an AbcMatrix object is passed.
Definition: AbcSimplexFactorization.hpp:27
AbcSimplex::setColSetBounds
void setColSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of columns simultaneously
Definition: AbcSimplex.hpp:942
AbcSimplex::unpack
void unpack(CoinIndexedVector &rowArray) const
Unpacks one column of the matrix into indexed array Uses sequenceIn_.
Definition: AbcSimplex.hpp:345
AbcSimplex::setObjCoeff
void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.
Definition: AbcSimplex.hpp:891
AbcSimplex::upperTheta
double upperTheta() const
upper theta from dual column
Definition: AbcSimplex.hpp:461
AbcSimplex::djSaved_
double * djSaved_
Saved scaled dual solution.
Definition: AbcSimplex.hpp:1193
AbcSimplex::gutsOfDelete
void gutsOfDelete(int type)
Does most of deletion for arrays etc(0 just null arrays, 1 delete first)
AbcSimplex::checkMoveBack
void checkMoveBack(bool checkDuals)
For debug - moves solution back to external and computes stuff (always checks djs) ...
AbcSimplex::pivotVariable
int * pivotVariable() const
Basic variables pivoting on which rows may be same as toExternal but may be as at invert...
Definition: AbcSimplex.hpp:426
AbcSimplex::abcFactorization_
AbcSimplexFactorization * abcFactorization_
factorization
Definition: AbcSimplex.hpp:1215
AbcSimplex::djBasic
double * djBasic() const
Return region.
Definition: AbcSimplex.hpp:553
ClpModel.hpp
AbcSimplex::pivoted
bool pivoted(int sequence) const
Swaps two variables.
Definition: AbcSimplex.hpp:806
ClpModel::dropNames
void dropNames()
Drops names - makes lengthnames 0 and names empty.
ClpModel::rowLower_
double * rowLower_
Row lower.
Definition: ClpModel.hpp:1136
AbcSimplex::dualRowPivot
AbcDualRowPivot * dualRowPivot() const
dual row pivot choice
Definition: AbcSimplex.hpp:285
AbcSimplex::setUsedArray
void setUsedArray(int which) const
Say array going to be used.
Definition: AbcSimplex.hpp:775
AbcSimplex::lastFirstFree
int lastFirstFree() const
Last firstFree_.
Definition: AbcSimplex.hpp:640
AbcSimplex::setNumberOrdinary
void setNumberOrdinary(int number)
Set number of ordinary (lo/up) in tableau row.
Definition: AbcSimplex.hpp:279
ClpSimplex::rowArray
CoinIndexedVector * rowArray(int index) const
Useful row length arrays (0,1,2,3,4,5)
Definition: ClpSimplex.hpp:727
AbcSimplex::upper
double upper(int sequence)
Return region.
Definition: AbcSimplex.hpp:707
AbcSimplex::upperAddress
double & upperAddress(int sequence)
Return address of row or column upper bound.
Definition: AbcSimplex.hpp:711
AbcSimplex::atUpperBound
Definition: AbcSimplex.hpp:76
AbcSimplexUnitTest
void AbcSimplexUnitTest(const std::string &mpsDir)
A function that tests the methods in the AbcSimplex class.
AbcSimplex::resize
void resize(int newNumberRows, int newNumberColumns)
Resizes rim part of model.
AbcSimplex::makeBaseModel
void makeBaseModel()
Array persistence flag If 0 then as now (delete/new) 1 then only do arrays if bigger needed 2 as 1 bu...
AbcSimplex::setColLower
void setColLower(int elementIndex, double elementValue)
Set a single column lower bound Use -DBL_MAX for -infinity.
Definition: AbcSimplex.hpp:921
AbcSimplex::refreshUpper
void refreshUpper(unsigned int type=~(ROW_LOWER_SAME|COLUMN_LOWER_SAME))
Given an existing factorization computes and checks primal and dual solutions.
AbcSimplex::setMultipleSequenceIn
void setMultipleSequenceIn(int sequenceIn[4])
set multiple sequence in
AbcSimplex::checkConsistentPivots
void checkConsistentPivots() const
For debug - check pivotVariable consistent.
ClpSimplex::pivotRow
int pivotRow() const
Pivot Row for use by classes e.g. steepestedge.
Definition: ClpSimplex.hpp:962
AbcSimplex::getEmptyFactorization
AbcSimplexFactorization * getEmptyFactorization()
Gets clean and emptyish factorization.
AbcSimplex::fakeDjs
double * fakeDjs() const
Fake djs.
Definition: AbcSimplex.hpp:569
AbcSimplex::setSequenceIn
void setSequenceIn(int sequence)
Set sequenceIn or Out.
Definition: AbcSimplex.hpp:603
AbcSimplex::startFixed_
int startFixed_
Start of fixed variables.
Definition: AbcSimplex.hpp:1069
AbcSimplex::printStuff
void printStuff() const
Print stuff.
AbcSimplex::moveInfo
void moveInfo(const AbcSimplex &rhs, bool justStatus=false)
Move status and solution across.
AbcSimplex::arrayForReplaceColumn
int arrayForReplaceColumn() const
factorization
Definition: AbcSimplex.hpp:463
AbcSimplex::usefulArray_
CoinPartitionedVector usefulArray_[ABC_NUMBER_USEFUL]
Sum of nonbasic costs.
Definition: AbcSimplex.hpp:1240
AbcSimplex::originalModel
void originalModel(AbcSimplex *miniModel)
This copies back stuff from miniModel and then deletes miniModel.
AbcSimplex::factorization
AbcSimplexFactorization * factorization() const
factorization
Definition: AbcSimplex.hpp:199
AbcSimplex::solutionBasic_
double * solutionBasic_
Working scaled basic primal solution.
Definition: AbcSimplex.hpp:1201
AbcSimplex::firstFree
int firstFree() const
First Free_.
Definition: AbcSimplex.hpp:637
ClpSimplex::sequenceOut_
int sequenceOut_
Sequence of Out variable.
Definition: ClpSimplex.hpp:1592
AbcSimplex::stateDualColumn_
int stateDualColumn_
State of dual waffle -2 - in initial large tolerance phase -1 - in medium tolerance phase n - in corr...
Definition: AbcSimplex.hpp:1048
AbcSimplex::startup
int startup(int ifValuesPass)
Common bits of coding for dual and primal.
AbcSimplex::setRowLower
void setRowLower(int elementIndex, double elementValue)
Set a single row lower bound Use -DBL_MAX for -infinity.
AbcSimplex::cleanFactorization
int cleanFactorization(int ifValuesPass)
Get a clean factorization - i.e.
AbcSimplex::currentDualTolerance_
double currentDualTolerance_
Current dualTolerance (will end up as dualTolerance_)
Definition: AbcSimplex.hpp:995
COLUMN_LOWER_SAME
#define COLUMN_LOWER_SAME
Whats changed since last solve.
Definition: ClpModel.hpp:1209
ClpSimplex::bestPossibleImprovement_
double bestPossibleImprovement_
Best possible improvement using djs (primal) or obj change by flipping bounds to make dual feasible (...
Definition: ClpSimplex.hpp:1499
AbcSimplex::stateOfIteration_
int stateOfIteration_
Where we are in iteration.
Definition: AbcSimplex.hpp:1027
ClpObjOffset
Objective function constant.
Definition: ClpParameters.hpp:60
ClpSimplex::cleanStatus
void cleanStatus()
Clean up status.
AbcSimplex::setColumnSetBounds
void setColumnSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of columns simultaneously The default implementation just invokes setColL...
AbcSimplex::setColumnLower
void setColumnLower(int elementIndex, double elementValue)
Set a single column lower bound Use -DBL_MAX for -infinity.
ABC_NUMBER_USEFUL
#define ABC_NUMBER_USEFUL
Useful arrays (all of row+column+2 length)
Definition: AbcSimplex.hpp:1239
AbcSimplex::lowerRegion
double * lowerRegion() const
Return region.
Definition: AbcSimplex.hpp:524
AbcSimplex::atLowerBound
Definition: AbcSimplex.hpp:75
AbcSimplex::internalFactorize
int internalFactorize(int solveType)
Factorizes using current basis.
AbcSimplex::swapDualStuff
void swapDualStuff(int lastSequenceOut, int lastDirectionOut)
Swaps dual stuff.
ClpModel::dblParam_
double dblParam_[ClpLastDblParam]
Array of double parameters.
Definition: ClpModel.hpp:1114
AbcSimplex::maximumAbcNumberRows_
int maximumAbcNumberRows_
Maximum number rows.
Definition: AbcSimplex.hpp:1034
AbcSimplex::ftAlpha_
double ftAlpha_
FT alpha.
Definition: AbcSimplex.hpp:1020
AbcSimplex::setInternalStatus
void setInternalStatus(int sequence, AbcSimplex::Status newstatus)
Return region.
Definition: AbcSimplex.hpp:579
AbcSimplex::djRegion
double * djRegion(int which) const
Return region.
Definition: AbcSimplex.hpp:537
AbcSimplex::putStuffInBasis
void putStuffInBasis(int type)
Puts more stuff in basis 1 bit set - do even if basis exists 2 bit set - don&#39;t bother staying triangu...
AbcSimplex::arrayForBtran_
int arrayForBtran_
Sum of nonbasic costs.
Definition: AbcSimplex.hpp:1254
inverseRowUseScale_
#define inverseRowUseScale_
Definition: AbcSimplex.hpp:376
AbcSimplex::computeInternalObjectiveValue
double computeInternalObjectiveValue()
Compute minimization objective value from internal solution without perturbation. ...
AbcSimplex::costBasic
double * costBasic() const
Return region.
Definition: AbcSimplex.hpp:562
AbcSimplex::numberTotal_
int numberTotal_
Number of variables (includes spare rows)
Definition: AbcSimplex.hpp:1055
AbcSimplex::solutionRegion
double * solutionRegion() const
Return region.
Definition: AbcSimplex.hpp:518
AbcSimplex::freeSequenceIn
int freeSequenceIn() const
Free chosen vector.
Definition: AbcSimplex.hpp:643
AbcSimplex::perturbationSaved_
double * perturbationSaved_
saved perturbation
Definition: AbcSimplex.hpp:1161
AbcSimplex::abcBaseModel_
AbcSimplex * abcBaseModel_
Saved version of solution.
Definition: AbcSimplex.hpp:1227
AbcSimplex::computeObjectiveValue
void computeObjectiveValue(bool useWorkingSolution=false)
Compute objective value from solution and put in objectiveValue_.
AbcSimplex::lastCleaned_
int lastCleaned_
Last time cleaned up.
Definition: AbcSimplex.hpp:1121
AbcSimplex::gutsOfInitialize
void gutsOfInitialize(int numberRows, int numberColumns, bool doMore)
Initializes arrays.
AbcSimplex::abcUpper_
double * abcUpper_
Working scaled copy of upper bounds has original scaled copy at end.
Definition: AbcSimplex.hpp:1171
AbcSimplex::lowerBasic_
double * lowerBasic_
Working scaled copy of basic lower bounds.
Definition: AbcSimplex.hpp:1195
AbcSimplex::setRowBounds
void setRowBounds(int elementIndex, double lower, double upper)
Set a single row lower and upper bound.
AbcSimplex::sumFakeInfeasibilities_
double sumFakeInfeasibilities_
Sum of infeasibilities when using fake perturbation tolerance.
Definition: AbcSimplex.hpp:1003
AbcSimplex::AbcSimplex
AbcSimplex(bool emptyMessages=false)
Default constructor.
AbcSimplex::stateOfProblem_
int stateOfProblem_
Sum of nonbasic costs.
Definition: AbcSimplex.hpp:1107
AbcSimplex::setFactorizationFrequency
void setFactorizationFrequency(int value)
factorization
AbcSimplex::swappedAlgorithm_
int swappedAlgorithm_
Nonzero (probably 10) if swapped algorithms.
Definition: AbcSimplex.hpp:1125
ClpSolve.hpp
AbcSimplex::fillPerturbation
void fillPerturbation(int start, int number)
fills in perturbationSaved_ from start with 0.5+random
AbcSimplex::swapPrimalStuff
void swapPrimalStuff()
Swaps primal stuff.
AbcSimplex::sequenceIn
int sequenceIn() const
Return sequence In or Out.
Definition: AbcSimplex.hpp:596
AbcSimplex::lastPrimalError_
double lastPrimalError_
Last primal error.
Definition: AbcSimplex.hpp:1005
NUMBER_THREADS
#define NUMBER_THREADS
Definition: AbcSimplex.hpp:863
AbcSimplex::startOther_
int startOther_
Start of superBasic, free or awkward bounds variables.
Definition: AbcSimplex.hpp:1067
AbcSimplex::rowScale2
double * rowScale2() const
corresponds to rowScale etc
Definition: AbcSimplex.hpp:450
CoinWarmStartBasis
The default COIN simplex (basis-oriented) warm start class.
Definition: CoinWarmStartBasis.hpp:40
CoinAbcCommon.hpp
AbcSimplex::sequenceWithin
int sequenceWithin(int sequence) const
Returns sequence number within section.
Definition: AbcSimplex.hpp:630
AbcSimplex::setColumnBounds
void setColumnBounds(int elementIndex, double lower, double upper)
Set a single column lower and upper bound.
AbcSimplex::costSaved_
double * costSaved_
Saved scaled copy of objective.
Definition: AbcSimplex.hpp:1189
AbcSimplex::currentAcceptablePivot
double currentAcceptablePivot() const
Acceptable pivot for this iteration.
Definition: AbcSimplex.hpp:646
AbcSimplex::setColBounds
void setColBounds(int elementIndex, double newlower, double newupper)
Set a single column lower and upper bound.
Definition: AbcSimplex.hpp:931
AbcSimplex::arrayForTableauRow
int arrayForTableauRow() const
factorization
Definition: AbcSimplex.hpp:473
AbcSimplex::clpObjectiveValue
double clpObjectiveValue() const
Objective value.
Definition: AbcSimplex.hpp:421
AbcSimplex::lastPivotRow_
int lastPivotRow_
Current/last pivot row (set after END of choosing pivot row in dual)
Definition: AbcSimplex.hpp:1123
AbcSimplex::minimizationObjectiveValue
double minimizationObjectiveValue() const
Gets objective value with all offsets but as for minimization.
Definition: AbcSimplex.hpp:254
AbcSimplex::checkDualSolution
void checkDualSolution()
This sets largest infeasibility and most infeasible and sum and number of infeasibilities (Dual) ...
AbcSimplex::getSolution
int getSolution()
Given an existing factorization computes and checks primal and dual solutions.
AbcSimplex::lowerSaved_
double * lowerSaved_
Saved scaled copy of lower bounds.
Definition: AbcSimplex.hpp:1185
AbcSimplex::moveToBasic
void moveToBasic(int which=15)
Moves basic stuff to basic area.
AbcSimplex::lastDualError_
double lastDualError_
Last dual error.
Definition: AbcSimplex.hpp:1007
AbcSimplex::upperBasic_
double * upperBasic_
Working scaled copy of basic upper bounds.
Definition: AbcSimplex.hpp:1197
AbcSimplex::FakeBound
FakeBound
Definition: AbcSimplex.hpp:83
AbcSimplex::setInitialDenseFactorization
void setInitialDenseFactorization(bool onOff)
Normally the first factorization does sparse coding because the factorization could be singular...
AbcSimplex::djRegion
double * djRegion() const
Return region.
Definition: AbcSimplex.hpp:521
AbcSimplex::setObjectiveCoefficient
void setObjectiveCoefficient(int elementIndex, double elementValue)
Set an objective function coefficient.
ClpSimplex::primalTolerance_
double primalTolerance_
Current primal tolerance for algorithm.
Definition: ClpSimplex.hpp:1547
AbcSimplex::maximumNumberTotal_
int maximumNumberTotal_
Maximum numberTotal.
Definition: AbcSimplex.hpp:1038
AbcSimplex::currentAcceptablePivot_
double currentAcceptablePivot_
Acceptable pivot for this iteration.
Definition: AbcSimplex.hpp:1009
AbcSimplex::flagged
bool flagged(int sequence) const
Swaps two variables.
Definition: AbcSimplex.hpp:817
AbcSimplex::gutsOfPrimalSolution
int gutsOfPrimalSolution(int type)
Computes solutions - 1 do duals, 2 do primals, 3 both (returns number of refinements) ...