source: stable/2.8/Cbc/src/CbcHeuristicFPump.hpp @ 2165

Last change on this file since 2165 was 1573, checked in by lou, 9 years ago

Change to EPL license notice.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 11.3 KB
Line 
1/* $Id: CbcHeuristicFPump.hpp 1573 2011-01-05 01:12:36Z forrest $ */
2// Copyright (C) 2004, International Business Machines
3// Corporation and others.  All Rights Reserved.
4// This code is licensed under the terms of the Eclipse Public License (EPL).
5
6#ifndef CbcHeuristicFeasibilityPump_H
7#define CbcHeuristicFeasibilityPump_H
8
9#include "CbcHeuristic.hpp"
10#include "OsiClpSolverInterface.hpp"
11
12/** Feasibility Pump class
13 */
14
15class CbcHeuristicFPump : public CbcHeuristic {
16public:
17
18    // Default Constructor
19    CbcHeuristicFPump ();
20
21    // Constructor with model - assumed before cuts
22    CbcHeuristicFPump (CbcModel & model,
23                       double downValue = 0.5, bool roundExpensive = false);
24
25    // Copy constructor
26    CbcHeuristicFPump ( const CbcHeuristicFPump &);
27
28    // Destructor
29    ~CbcHeuristicFPump ();
30
31    /// Assignment operator
32    CbcHeuristicFPump & operator=(const CbcHeuristicFPump& rhs);
33    /// Clone
34    virtual CbcHeuristic * clone() const;
35    /// Create C++ lines to get to current state
36    virtual void generateCpp( FILE * fp) ;
37
38    /// Resets stuff if model changes
39    virtual void resetModel(CbcModel * model);
40
41    /// update model (This is needed if cliques update matrix etc)
42    virtual void setModel(CbcModel * model);
43
44    using CbcHeuristic::solution ;
45    /** returns 0 if no solution, 1 if valid solution
46        with better objective value than one passed in
47        Sets solution values if good, sets objective value (only if good)
48        This is called after cuts have been added - so can not add cuts.
49
50        It may make sense for user to call this outside Branch and Cut to
51        get solution.  Or normally is just at root node.
52
53        * new meanings for when_ - on first try then set back to 1
54          11 - at end fix all integers at same bound throughout
55          12 - also fix all integers staying at same internal integral value throughout
56          13 - also fix all continuous variables staying at same bound throughout
57          14 - also fix all continuous variables staying at same internal value throughout
58          15 - as 13 but no internal integers
59      And beyond that, it's apparently possible for the range to be between 21
60      and 25, in which case it's reduced on entry to solution() to be between
61      11 and 15 and allSlack is set to true. Then, if we're not processing
62      general integers, we'll use an all-slack basis to solve ... what? Don't
63      see that yet.
64    */
65    virtual int solution(double & objectiveValue,
66                         double * newSolution);
67
68    /// Set maximum Time (default off) - also sets starttime to current
69    void setMaximumTime(double value);
70    /// Get maximum Time (default 0.0 == time limit off)
71    inline double maximumTime() const {
72        return maximumTime_;
73    }
74    /// Set fake cutoff (default COIN_DBL_MAX == off)
75    inline void setFakeCutoff(double value) {
76        fakeCutoff_ = value;
77    }
78    /// Get fake cutoff (default 0.0 == off)
79    inline double fakeCutoff() const {
80        return fakeCutoff_;
81    }
82    /// Set absolute increment (default 0.0 == off)
83    inline void setAbsoluteIncrement(double value) {
84        absoluteIncrement_ = value;
85    }
86    /// Get absolute increment (default 0.0 == off)
87    inline double absoluteIncrement() const {
88        return absoluteIncrement_;
89    }
90    /// Set relative increment (default 0.0 == off)
91    inline void setRelativeIncrement(double value) {
92        relativeIncrement_ = value;
93    }
94    /// Get relative increment (default 0.0 == off)
95    inline double relativeIncrement() const {
96        return relativeIncrement_;
97    }
98    /// Set default rounding (default 0.5)
99    inline void setDefaultRounding(double value) {
100        defaultRounding_ = value;
101    }
102    /// Get default rounding (default 0.5)
103    inline double defaultRounding() const {
104        return defaultRounding_;
105    }
106    /// Set initial weight (default 0.0 == off)
107    inline void setInitialWeight(double value) {
108        initialWeight_ = value;
109    }
110    /// Get initial weight (default 0.0 == off)
111    inline double initialWeight() const {
112        return initialWeight_;
113    }
114    /// Set weight factor (default 0.1)
115    inline void setWeightFactor(double value) {
116        weightFactor_ = value;
117    }
118    /// Get weight factor (default 0.1)
119    inline double weightFactor() const {
120        return weightFactor_;
121    }
122    /// Set threshold cost for using original cost - even on continuous (default infinity)
123    inline void setArtificialCost(double value) {
124        artificialCost_ = value;
125    }
126    /// Get threshold cost for using original cost - even on continuous (default infinity)
127    inline double artificialCost() const {
128        return artificialCost_;
129    }
130    /// Get iteration to size ratio
131    inline double iterationRatio() const {
132        return iterationRatio_;
133    }
134    /// Set iteration to size ratio
135    inline void setIterationRatio(double value) {
136        iterationRatio_ = value;
137    }
138    /// Set maximum passes (default 100)
139    inline void setMaximumPasses(int value) {
140        maximumPasses_ = value;
141    }
142    /// Get maximum passes (default 100)
143    inline int maximumPasses() const {
144        return maximumPasses_;
145    }
146    /// Set maximum retries (default 1)
147    inline void setMaximumRetries(int value) {
148        maximumRetries_ = value;
149    }
150    /// Get maximum retries (default 1)
151    inline int maximumRetries() const {
152        return maximumRetries_;
153    }
154    /**  Set use of multiple solutions and solves
155         0 - do not reuse solves, do not accumulate integer solutions for local search
156         1 - do not reuse solves, accumulate integer solutions for local search
157         2 - reuse solves, do not accumulate integer solutions for local search
158         3 - reuse solves, accumulate integer solutions for local search
159         If we add 4 then use second form of problem (with extra rows and variables for general integers)
160       At some point (date?), I added
161
162       And then there are a few bit fields:
163       4 - something about general integers
164       So my (lh) guess for 4 was at least in the ballpark, but I'll have to
165       rethink 8 entirely (and it may well not mean the same thing as it did
166       when I added that comment.
167       8 - determines whether we process general integers
168
169       And on 090831, John added
170
171       If we add 4 then use second form of problem (with extra rows and
172       variables for general integers)
173         If we add 8 then can run after initial cuts (if no solution)
174    */
175    inline void setAccumulate(int value) {
176        accumulate_ = value;
177    }
178    /// Get accumulation option
179    inline int accumulate() const {
180        return accumulate_;
181    }
182    /**  Set whether to fix variables on known solution
183         0 - do not fix
184         1 - fix integers on reduced costs
185         2 - fix integers on reduced costs but only on entry
186    */
187    inline void setFixOnReducedCosts(int value) {
188        fixOnReducedCosts_ = value;
189    }
190    /// Get reduced cost option
191    inline int fixOnReducedCosts() const {
192        return fixOnReducedCosts_;
193    }
194    /**  Set reduced cost multiplier
195         1.0 as normal
196         <1.0 (x) - pretend gap is x* actual gap - just for fixing
197    */
198    inline void setReducedCostMultiplier(double value) {
199        reducedCostMultiplier_ = value;
200    }
201    /// Get reduced cost multiplier
202    inline double reducedCostMultiplier() const {
203        return reducedCostMultiplier_;
204    }
205
206protected:
207    // Data
208    /// Start time
209    double startTime_;
210    /// Maximum Cpu seconds
211    double maximumTime_;
212    /** Fake cutoff value.
213        If set then better of real cutoff and this used to add a constraint
214    */
215    double fakeCutoff_;
216    /// If positive carry on after solution expecting gain of at least this
217    double absoluteIncrement_;
218    /// If positive carry on after solution expecting gain of at least this times objective
219    double relativeIncrement_;
220    /// Default is round up if > this
221    double defaultRounding_;
222    /// Initial weight for true objective
223    double initialWeight_;
224    /// Factor for decreasing weight
225    double weightFactor_;
226    /// Threshold cost for using original cost - even on continuous
227    double artificialCost_;
228    /** If iterationRatio >0 use instead of maximumPasses_
229        test is iterations > ratio*(2*nrow+ncol) */
230    double iterationRatio_;
231    /**  Reduced cost multiplier
232         1.0 as normal
233         <1.0 (x) - pretend gap is x* actual gap - just for fixing
234    */
235    double reducedCostMultiplier_;
236    /// Maximum number of passes
237    int maximumPasses_;
238    /** Maximum number of retries if we find a solution.
239        If negative we clean out used array
240    */
241    int maximumRetries_;
242    /**  Set use of multiple solutions and solves
243         0 - do not reuse solves, do not accumulate integer solutions for local search
244         1 - do not reuse solves, accumulate integer solutions for local search
245         2 - reuse solves, do not accumulate integer solutions for local search
246         3 - reuse solves, accumulate integer solutions for local search
247         If we add 4 then use second form of problem (with extra rows and variables for general integers)
248         If we do not accumulate solutions then no mini branch and bounds will be done
249         reuse - refers to initial solve after adding in new "cut"
250         If we add 8 then can run after initial cuts (if no solution)
251    */
252    int accumulate_;
253    /**  Set whether to fix variables on known solution
254         0 - do not fix
255         1 - fix integers on reduced costs
256         2 - fix integers on reduced costs but only on entry
257    */
258    int fixOnReducedCosts_;
259    /// If true round to expensive
260    bool roundExpensive_;
261
262private:
263    /** Rounds solution - down if < downValue
264        If roundExpensive then always to more expnsive.
265        returns 0 if current is solution
266    */
267    int rounds(OsiSolverInterface * solver, double * solution,
268               /*const double * objective, */
269               int numberIntegers, const int * integerVariable,
270               /*char * pumpPrint,*/int passNumber,
271               /*bool roundExpensive=false,*/
272               double downValue = 0.5, int *flip = 0);
273    /* note for eagle eyed readers.
274       when_ can now be exotic -
275       <=10 normal
276    */
277};
278
279# ifdef COIN_HAS_CLP
280
281class CbcDisasterHandler : public OsiClpDisasterHandler {
282public:
283    /**@name Virtual methods that the derived classe should provide.
284    */
285    //@{
286#ifdef JJF_ZERO
287    /// Into simplex
288    virtual void intoSimplex();
289    /// Checks if disaster
290    virtual bool check() const ;
291    /// saves information for next attempt
292    virtual void saveInfo();
293#endif
294    /// Type of disaster 0 can fix, 1 abort
295    virtual int typeOfDisaster();
296    //@}
297
298
299    /**@name Constructors, destructor */
300
301    //@{
302    /** Default constructor. */
303    CbcDisasterHandler(CbcModel * model = NULL);
304    /** Destructor */
305    virtual ~CbcDisasterHandler();
306    // Copy
307    CbcDisasterHandler(const CbcDisasterHandler&);
308    // Assignment
309    CbcDisasterHandler& operator=(const CbcDisasterHandler&);
310    /// Clone
311    virtual ClpDisasterHandler * clone() const;
312
313    //@}
314
315    /**@name Sets/gets */
316
317    //@{
318    /** set model. */
319    void setCbcModel(CbcModel * model);
320    /// Get model
321    inline CbcModel * cbcModel() const {
322        return cbcModel_;
323    }
324
325    //@}
326
327
328protected:
329    /**@name Data members
330       The data members are protected to allow access for derived classes. */
331    //@{
332    /// Pointer to model
333    CbcModel * cbcModel_;
334
335    //@}
336};
337#endif
338
339#endif
340
Note: See TracBrowser for help on using the repository browser.