Ignore:
Timestamp:
Jan 6, 2019 2:43:06 PM (4 months ago)
Author:
unxusr
Message:

formatting

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/src/ClpSimplexPrimal.hpp

    r1665 r2385  
    2424
    2525public:
    26 
    27      /**@name Description of algorithm */
    28      //@{
    29      /** Primal algorithm
     26  /**@name Description of algorithm */
     27  //@{
     28  /** Primal algorithm
    3029
    3130         Method
     
    113112     */
    114113
    115      int primal(int ifValuesPass = 0, int startFinishOptions = 0);
    116      //@}
    117 
    118      /**@name For advanced users */
    119      //@{
    120      /// Do not change infeasibility cost and always say optimal
    121      void alwaysOptimal(bool onOff);
    122      bool alwaysOptimal() const;
    123      /** Normally outgoing variables can go out to slightly negative
     114  int primal(int ifValuesPass = 0, int startFinishOptions = 0);
     115  //@}
     116
     117  /**@name For advanced users */
     118  //@{
     119  /// Do not change infeasibility cost and always say optimal
     120  void alwaysOptimal(bool onOff);
     121  bool alwaysOptimal() const;
     122  /** Normally outgoing variables can go out to slightly negative
    124123         values (but within tolerance) - this is to help stability and
    125124         and degeneracy.  This can be switched off
    126125     */
    127      void exactOutgoing(bool onOff);
    128      bool exactOutgoing() const;
    129      //@}
    130 
    131      /**@name Functions used in primal */
    132      //@{
    133      /** This has the flow between re-factorizations
     126  void exactOutgoing(bool onOff);
     127  bool exactOutgoing() const;
     128  //@}
     129
     130  /**@name Functions used in primal */
     131  //@{
     132  /** This has the flow between re-factorizations
    134133
    135134         Returns a code to say where decision to exit was made
     
    143142         valuesOption has original value of valuesPass
    144143      */
    145      int whileIterating(int valuesOption);
    146 
    147      /** Do last half of an iteration.  This is split out so people can
     144  int whileIterating(int valuesOption);
     145
     146  /** Do last half of an iteration.  This is split out so people can
    148147         force incoming variable.  If solveType_ is 2 then this may
    149148         re-factorize while normally it would exit to re-factorize.
     
    163162         Returns ray in ray_
    164163     */
    165      int pivotResult(int ifValuesPass = 0);
    166 
    167 
    168      /** The primals are updated by the given array.
     164  int pivotResult(int ifValuesPass = 0);
     165
     166  /** The primals are updated by the given array.
    169167         Returns number of infeasibilities.
    170168         After rowArray will have cost changes for use next iteration
    171169     */
    172      int updatePrimalsInPrimal(CoinIndexedVector * rowArray,
    173                                double theta,
    174                                double & objectiveChange,
    175                                int valuesPass);
    176      /**
     170  int updatePrimalsInPrimal(CoinIndexedVector *rowArray,
     171    double theta,
     172    double &objectiveChange,
     173    int valuesPass);
     174  /**
    177175         Row array has pivot column
    178176         This chooses pivot row.
     
    182180         If valuesPass non-zero then compute dj for direction
    183181     */
    184      void primalRow(CoinIndexedVector * rowArray,
    185                     CoinIndexedVector * rhsArray,
    186                     CoinIndexedVector * spareArray,
    187                     int valuesPass);
    188      /**
     182  void primalRow(CoinIndexedVector *rowArray,
     183    CoinIndexedVector *rhsArray,
     184    CoinIndexedVector *spareArray,
     185    int valuesPass);
     186  /**
    189187         Chooses primal pivot column
    190188         updateArray has cost updates (also use pivotRow_ from last iteration)
     
    193191         For easy problems we can just choose one of the first columns we look at
    194192     */
    195      void primalColumn(CoinIndexedVector * updateArray,
    196                        CoinIndexedVector * spareRow1,
    197                        CoinIndexedVector * spareRow2,
    198                        CoinIndexedVector * spareColumn1,
    199                        CoinIndexedVector * spareColumn2);
    200 
    201      /** Checks if tentative optimal actually means unbounded in primal
     193  void primalColumn(CoinIndexedVector *updateArray,
     194    CoinIndexedVector *spareRow1,
     195    CoinIndexedVector *spareRow2,
     196    CoinIndexedVector *spareColumn1,
     197    CoinIndexedVector *spareColumn2);
     198
     199  /** Checks if tentative optimal actually means unbounded in primal
    202200         Returns -3 if not, 2 if is unbounded */
    203      int checkUnbounded(CoinIndexedVector * ray, CoinIndexedVector * spare,
    204                         double changeCost);
    205      /**  Refactorizes if necessary
     201  int checkUnbounded(CoinIndexedVector *ray, CoinIndexedVector *spare,
     202    double changeCost);
     203  /**  Refactorizes if necessary
    206204          Checks if finished.  Updates status.
    207205          lastCleaned refers to iteration at which some objective/feasibility
     
    213211          saveModel is normally NULL but may not be if doing Sprint
    214212     */
    215      void statusOfProblemInPrimal(int & lastCleaned, int type,
    216                                   ClpSimplexProgress * progress,
    217                                   bool doFactorization,
    218                                   int ifValuesPass,
    219                                   ClpSimplex * saveModel = NULL);
    220      /// Perturbs problem (method depends on perturbation())
    221      void perturb(int type);
    222      /// Take off effect of perturbation and say whether to try dual
    223      bool unPerturb();
    224      /// Unflag all variables and return number unflagged
    225      int unflag();
    226      /** Get next superbasic -1 if none,
     213  void statusOfProblemInPrimal(int &lastCleaned, int type,
     214    ClpSimplexProgress *progress,
     215    bool doFactorization,
     216    int ifValuesPass,
     217    ClpSimplex *saveModel = NULL);
     218  /// Perturbs problem (method depends on perturbation())
     219  void perturb(int type);
     220  /// Take off effect of perturbation and say whether to try dual
     221  bool unPerturb();
     222  /// Unflag all variables and return number unflagged
     223  int unflag();
     224  /** Get next superbasic -1 if none,
    227225         Normal type is 1
    228226         If type is 3 then initializes sorted list
    229227         if 2 uses list.
    230228     */
    231      int nextSuperBasic(int superBasicType, CoinIndexedVector * columnArray);
    232 
    233      /// Create primal ray
    234      void primalRay(CoinIndexedVector * rowArray);
    235      /// Clears all bits and clears rowArray[1] etc
    236      void clearAll();
    237 
    238      /// Sort of lexicographic resolve
    239      int lexSolve();
    240 
    241      //@}
     229  int nextSuperBasic(int superBasicType, CoinIndexedVector *columnArray);
     230
     231  /// Create primal ray
     232  void primalRay(CoinIndexedVector *rowArray);
     233  /// Clears all bits and clears rowArray[1] etc
     234  void clearAll();
     235
     236  /// Sort of lexicographic resolve
     237  int lexSolve();
     238
     239  //@}
    242240};
    243241#endif
    244242
     243/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
     244*/
Note: See TracChangeset for help on using the changeset viewer.