OR-Tools  8.1
sched_expr.cc
Go to the documentation of this file.
1 // Copyright 2010-2018 Google LLC
2 // Licensed under the Apache License, Version 2.0 (the "License");
3 // you may not use this file except in compliance with the License.
4 // You may obtain a copy of the License at
5 //
6 // http://www.apache.org/licenses/LICENSE-2.0
7 //
8 // Unless required by applicable law or agreed to in writing, software
9 // distributed under the License is distributed on an "AS IS" BASIS,
10 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 // See the License for the specific language governing permissions and
12 // limitations under the License.
13 
14 #include <string>
15 #include <vector>
16 
17 #include "absl/strings/str_format.h"
19 #include "ortools/base/logging.h"
20 #include "ortools/base/macros.h"
23 
24 #if defined(_MSC_VER)
25 #pragma warning(disable : 4351 4355 4804 4805)
26 #endif
27 
28 namespace operations_research {
29 namespace {
30 class IntervalVarStartExpr : public BaseIntExpr {
31  public:
32  explicit IntervalVarStartExpr(IntervalVar* const i)
33  : BaseIntExpr(i->solver()), interval_(i) {}
34  ~IntervalVarStartExpr() override {}
35 
36  int64 Min() const override { return interval_->StartMin(); }
37 
38  void SetMin(int64 m) override { interval_->SetStartMin(m); }
39 
40  int64 Max() const override { return interval_->StartMax(); }
41 
42  void SetMax(int64 m) override { interval_->SetStartMax(m); }
43 
44  void SetRange(int64 l, int64 u) override { interval_->SetStartRange(l, u); }
45 
46  void SetValue(int64 v) override { interval_->SetStartRange(v, v); }
47 
48  bool Bound() const override {
49  return interval_->StartMin() == interval_->StartMax();
50  }
51 
52  void WhenRange(Demon* d) override { interval_->WhenStartRange(d); }
53 
54  std::string DebugString() const override {
55  return absl::StrFormat("start(%s)", interval_->DebugString());
56  }
57 
58  void Accept(ModelVisitor* const visitor) const override {
59  visitor->BeginVisitIntegerExpression(ModelVisitor::kStartExpr, this);
60  visitor->VisitIntervalArgument(ModelVisitor::kIntervalArgument, interval_);
61  visitor->EndVisitIntegerExpression(ModelVisitor::kStartExpr, this);
62  }
63 
64  private:
65  IntervalVar* interval_;
66  DISALLOW_COPY_AND_ASSIGN(IntervalVarStartExpr);
67 };
68 
69 class IntervalVarEndExpr : public BaseIntExpr {
70  public:
71  explicit IntervalVarEndExpr(IntervalVar* const i)
72  : BaseIntExpr(i->solver()), interval_(i) {}
73  ~IntervalVarEndExpr() override {}
74 
75  int64 Min() const override { return interval_->EndMin(); }
76 
77  void SetMin(int64 m) override { interval_->SetEndMin(m); }
78 
79  int64 Max() const override { return interval_->EndMax(); }
80 
81  void SetMax(int64 m) override { interval_->SetEndMax(m); }
82 
83  void SetRange(int64 l, int64 u) override { interval_->SetEndRange(l, u); }
84 
85  void SetValue(int64 v) override { interval_->SetEndRange(v, v); }
86 
87  bool Bound() const override {
88  return interval_->EndMin() == interval_->EndMax();
89  }
90 
91  void WhenRange(Demon* d) override { interval_->WhenEndRange(d); }
92 
93  std::string DebugString() const override {
94  return absl::StrFormat("end(%s)", interval_->DebugString());
95  }
96 
97  void Accept(ModelVisitor* const visitor) const override {
98  visitor->BeginVisitIntegerExpression(ModelVisitor::kEndExpr, this);
99  visitor->VisitIntervalArgument(ModelVisitor::kIntervalArgument, interval_);
100  visitor->EndVisitIntegerExpression(ModelVisitor::kEndExpr, this);
101  }
102 
103  private:
104  IntervalVar* interval_;
105  DISALLOW_COPY_AND_ASSIGN(IntervalVarEndExpr);
106 };
107 
108 class IntervalVarDurationExpr : public BaseIntExpr {
109  public:
110  explicit IntervalVarDurationExpr(IntervalVar* const i)
111  : BaseIntExpr(i->solver()), interval_(i) {}
112  ~IntervalVarDurationExpr() override {}
113 
114  int64 Min() const override { return interval_->DurationMin(); }
115 
116  void SetMin(int64 m) override { interval_->SetDurationMin(m); }
117 
118  int64 Max() const override { return interval_->DurationMax(); }
119 
120  void SetMax(int64 m) override { interval_->SetDurationMax(m); }
121 
122  void SetRange(int64 l, int64 u) override {
123  interval_->SetDurationRange(l, u);
124  }
125 
126  void SetValue(int64 v) override { interval_->SetDurationRange(v, v); }
127 
128  bool Bound() const override {
129  return interval_->DurationMin() == interval_->DurationMax();
130  }
131 
132  void WhenRange(Demon* d) override { interval_->WhenDurationRange(d); }
133 
134  std::string DebugString() const override {
135  return absl::StrFormat("duration(%s)", interval_->DebugString());
136  }
137 
138  void Accept(ModelVisitor* const visitor) const override {
139  visitor->BeginVisitIntegerExpression(ModelVisitor::kDurationExpr, this);
140  visitor->VisitIntervalArgument(ModelVisitor::kIntervalArgument, interval_);
141  visitor->EndVisitIntegerExpression(ModelVisitor::kDurationExpr, this);
142  }
143 
144  private:
145  IntervalVar* interval_;
146  DISALLOW_COPY_AND_ASSIGN(IntervalVarDurationExpr);
147 };
148 } // namespace
149 
150 // ----- API -----
151 
153  Solver* const s = var->solver();
154  IntExpr* const expr =
155  s->RegisterIntExpr(s->RevAlloc(new IntervalVarStartExpr(var)));
156  if (var->HasName()) {
157  expr->set_name(absl::StrFormat("start<%s>", var->name()));
158  }
159  return expr;
160 }
161 
163  Solver* const s = var->solver();
164  IntExpr* const expr =
165  s->RegisterIntExpr(s->RevAlloc(new IntervalVarDurationExpr(var)));
166  if (var->HasName()) {
167  expr->set_name(absl::StrFormat("duration<%s>", var->name()));
168  }
169  return expr;
170 }
171 
173  Solver* const s = var->solver();
174  IntExpr* const expr =
175  s->RegisterIntExpr(s->RevAlloc(new IntervalVarEndExpr(var)));
176  if (var->HasName()) {
177  expr->set_name(absl::StrFormat("end<%s>", var->name()));
178  }
179  return expr;
180 }
181 
184  var->PerformedExpr()->Var(), var->StartExpr(), unperformed_value);
185 }
186 
189  var->PerformedExpr()->Var(), var->DurationExpr(), unperformed_value);
190 }
191 
194  var->PerformedExpr()->Var(), var->EndExpr(), unperformed_value);
195 }
196 } // namespace operations_research
var
IntVar * var
Definition: expr_array.cc:1858
operations_research::BuildEndExpr
IntExpr * BuildEndExpr(IntervalVar *var)
Definition: sched_expr.cc:172
integral_types.h
operations_research::PropagationBaseObject::name
virtual std::string name() const
Object naming.
Definition: constraint_solver.cc:2505
operations_research::ModelVisitor::kStartExpr
static const char kStartExpr[]
Definition: constraint_solver.h:3404
operations_research::BuildSafeStartExpr
IntExpr * BuildSafeStartExpr(IntervalVar *var, int64 unperformed_value)
Definition: sched_expr.cc:182
operations_research::Solver::RevAlloc
T * RevAlloc(T *object)
Registers the given object as being reversible.
Definition: constraint_solver.h:791
logging.h
operations_research::BuildSafeDurationExpr
IntExpr * BuildSafeDurationExpr(IntervalVar *var, int64 unperformed_value)
Definition: sched_expr.cc:187
macros.h
operations_research
The vehicle routing library lets one model and solve generic vehicle routing problems ranging from th...
Definition: dense_doubly_linked_list.h:21
operations_research::ModelVisitor::kEndExpr
static const char kEndExpr[]
Definition: constraint_solver.h:3353
operations_research::BuildStartExpr
IntExpr * BuildStartExpr(IntervalVar *var)
Definition: sched_expr.cc:152
int64
int64_t int64
Definition: integral_types.h:34
constraint_solveri.h
operations_research::PropagationBaseObject::HasName
bool HasName() const
Returns whether the object has been named or not.
Definition: constraint_solver.cc:2513
constraint_solver.h
operations_research::ModelVisitor::kIntervalArgument
static const char kIntervalArgument[]
Definition: constraint_solver.h:3454
operations_research::IntervalVar
Interval variables are often used in scheduling.
Definition: constraint_solver.h:4389
operations_research::Solver::MakeConditionalExpression
IntExpr * MakeConditionalExpression(IntVar *const condition, IntExpr *const expr, int64 unperformed_value)
Conditional Expr condition ? expr : unperformed_value.
Definition: expressions.cc:7216
operations_research::Solver
Solver Class.
Definition: constraint_solver.h:248
operations_research::BuildSafeEndExpr
IntExpr * BuildSafeEndExpr(IntervalVar *var, int64 unperformed_value)
Definition: sched_expr.cc:192
operations_research::PropagationBaseObject::set_name
void set_name(const std::string &name)
Definition: constraint_solver.cc:2509
DISALLOW_COPY_AND_ASSIGN
#define DISALLOW_COPY_AND_ASSIGN(TypeName)
Definition: macros.h:29
operations_research::IntExpr
The class IntExpr is the base of all integer expressions in constraint programming.
Definition: constraint_solver.h:3831
operations_research::BuildDurationExpr
IntExpr * BuildDurationExpr(IntervalVar *var)
Definition: sched_expr.cc:162
operations_research::ModelVisitor::kDurationExpr
static const char kDurationExpr[]
Definition: constraint_solver.h:3350
operations_research::PropagationBaseObject::solver
Solver * solver() const
Definition: constraint_solver.h:3174
operations_research::IntVar::Var
IntVar * Var() override
Creates a variable from the expression.
Definition: constraint_solver.h:3999
operations_research::Solver::RegisterIntExpr
IntExpr * RegisterIntExpr(IntExpr *const expr)
Registers a new IntExpr and wraps it inside a TraceIntExpr if necessary.
Definition: trace.cc:844