OR-Tools  8.2
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"
20#include "ortools/base/macros.h"
23
24#if defined(_MSC_VER)
25#pragma warning(disable : 4351 4355 4804 4805)
26#endif
27
28namespace operations_research {
29namespace {
30class 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
69class 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
108class 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
The class IntExpr is the base of all integer expressions in constraint programming.
IntVar * Var() override
Creates a variable from the expression.
Interval variables are often used in scheduling.
virtual std::string name() const
Object naming.
bool HasName() const
Returns whether the object has been named or not.
IntExpr * RegisterIntExpr(IntExpr *const expr)
Registers a new IntExpr and wraps it inside a TraceIntExpr if necessary.
Definition: trace.cc:844
IntExpr * MakeConditionalExpression(IntVar *const condition, IntExpr *const expr, int64 unperformed_value)
Conditional Expr condition ? expr : unperformed_value.
T * RevAlloc(T *object)
Registers the given object as being reversible.
IntVar * var
Definition: expr_array.cc:1858
int64_t int64
#define DISALLOW_COPY_AND_ASSIGN(TypeName)
Definition: macros.h:29
The vehicle routing library lets one model and solve generic vehicle routing problems ranging from th...
IntExpr * BuildEndExpr(IntervalVar *var)
Definition: sched_expr.cc:172
IntExpr * BuildStartExpr(IntervalVar *var)
Definition: sched_expr.cc:152
IntExpr * BuildSafeEndExpr(IntervalVar *var, int64 unperformed_value)
Definition: sched_expr.cc:192
IntExpr * BuildSafeStartExpr(IntervalVar *var, int64 unperformed_value)
Definition: sched_expr.cc:182
IntExpr * BuildSafeDurationExpr(IntervalVar *var, int64 unperformed_value)
Definition: sched_expr.cc:187
IntExpr * BuildDurationExpr(IntervalVar *var)
Definition: sched_expr.cc:162