always-cautious/ortools-clone
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

prepare c++ code for int64 = int64_t

Browse Source
This commit is contained in:
Laurent Perron
2018-12-07 19:43:46 +01:00
parent b241cc07cc
commit c36ac046f7
7 changed files with 45 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
examples/cpp/weighted_tardiness_sat.cc
View File

@@ -63,7 +63,7 @@ void Solve(const std::vector<int64>& durations,
int64 next_cost;
for (int j = 0; j < num_tasks; ++j) {
if (is_taken[j]) continue;
const int64 cost = weights[j] * std::max(0LL, end - due_dates[j]);
const int64 cost = weights[j] * std::max<int64>(0, end - due_dates[j]);
if (next_task == -1 || cost < next_cost) {
next_task = j;
next_cost = cost;
@@ -97,7 +97,7 @@ void Solve(const std::vector<int64>& durations,
tardiness_vars[i] = task_ends[i];
} else {
tardiness_vars[i] =
cp_model.NewIntVar(Domain(0, std::max(0LL, horizon - due_dates[i])));
cp_model.NewIntVar(Domain(0, std::max<int64>(0, horizon - due_dates[i])));
// tardiness_vars >= end - due_date
cp_model.AddGreaterOrEqual(tardiness_vars[i],

4
ortools/constraint_solver/diffn.cc
View File

@@ -62,8 +62,8 @@ class Diffn : public Constraint {
delayed_demon_ = MakeDelayedConstraintDemon0(s, this, &Diffn::PropagateAll,
"PropagateAll");
if (solver()->parameters().diffn_use_cumulative() &&
IsArrayInRange(x_, 0LL, kint64max) &&
IsArrayInRange(y_, 0LL, kint64max)) {
IsArrayInRange<int64>(x_, 0, kint64max) &&
IsArrayInRange<int64>(y_, 0, kint64max)) {
Constraint* ct1 = nullptr;
Constraint* ct2 = nullptr;
{

31
ortools/constraint_solver/element.cc
View File

@@ -336,9 +336,9 @@ class IntExprElement : public BaseIntExprElement {
DCHECK_LT(index, values_.size());
return values_[index];
}
int64 ExprMin() const override { return std::max(int64{0}, expr_->Min()); }
int64 ExprMin() const override { return std::max<int64>(0, expr_->Min()); }
int64 ExprMax() const override {
return std::min(static_cast<int64>(values_.size()) - 1, expr_->Max());
return std::min<int64>(values_.size() - 1, expr_->Max());
}
private:
@@ -381,10 +381,9 @@ class RangeMinimumQueryExprElement : public BaseIntExpr {
}
private:
int64 IndexMin() const { return std::max(int64{0}, index_->Min()); }
int64 IndexMin() const { return std::max<int64>(0, index_->Min()); }
int64 IndexMax() const {
return std::min(static_cast<int64>(min_rmq_.array().size()) - 1,
index_->Max());
return std::min<int64>(min_rmq_.array().size() - 1, index_->Max());
}
IntVar* const index_;
@@ -504,15 +503,14 @@ IncreasingIntExprElement::IncreasingIntExprElement(
}
int64 IncreasingIntExprElement::Min() const {
const int64 expression_min = std::max(int64{0}, index_->Min());
const int64 expression_min = std::max<int64>(0, index_->Min());
return (expression_min < values_.size() ? values_[expression_min]
: kint64max);
}
void IncreasingIntExprElement::SetMin(int64 m) {
const int64 index_min = std::max(int64{0}, index_->Min());
const int64 index_max =
std::min(static_cast<int64>(values_.size()) - 1LL, index_->Max());
const int64 index_min = std::max<int64>(0, index_->Min());
const int64 index_max = std::min<int64>(values_.size() - 1, index_->Max());
if (index_min > index_max || m > values_[index_max]) {
solver()->Fail();
@@ -526,12 +524,12 @@ void IncreasingIntExprElement::SetMin(int64 m) {
int64 IncreasingIntExprElement::Max() const {
const int64 expression_max =
std::min(static_cast<int64>(values_.size()) - 1LL, index_->Max());
std::min<int64>(values_.size() - 1, index_->Max());
return (expression_max >= 0 ? values_[expression_max] : kint64max);
}
void IncreasingIntExprElement::SetMax(int64 m) {
int64 index_min = std::max(int64{0}, index_->Min());
int64 index_min = std::max<int64>(0, index_->Min());
if (m < values_[index_min]) {
solver()->Fail();
}
@@ -546,9 +544,8 @@ void IncreasingIntExprElement::SetRange(int64 mi, int64 ma) {
if (mi > ma) {
solver()->Fail();
}
const int64 index_min = std::max(int64{0}, index_->Min());
const int64 index_max =
std::min(static_cast<int64>(values_.size()) - 1LL, index_->Max());
const int64 index_min = std::max<int64>(0, index_->Min());
const int64 index_max = std::min<int64>(values_.size() - 1, index_->Max());
if (mi > ma || ma < values_[index_min] || mi > values_[index_max]) {
solver()->Fail();
@@ -581,14 +578,14 @@ IntExpr* BuildElement(Solver* const solver, const std::vector<int64>& values,
std::vector<int64> ones;
int first_zero = -1;
for (int i = 0; i < values.size(); ++i) {
if (values[i] == 1LL) {
if (values[i] == 1) {
ones.push_back(i);
} else {
first_zero = i;
}
}
if (ones.size() == 1) {
DCHECK_EQ(1LL, values[ones.back()]);
DCHECK_EQ(GG_LONGLONG(1), values[ones.back()]);
solver->AddConstraint(solver->MakeBetweenCt(index, 0, values.size() - 1));
return solver->MakeIsEqualCstVar(index, ones.back());
} else if (ones.size() == values.size() - 1) {
@@ -1251,7 +1248,7 @@ void IntExprEvaluatorElementCt::InitialPropagate() { Propagate(); }
void IntExprEvaluatorElementCt::Propagate() {
const int64 emin = std::max(range_start_, index_->Min());
const int64 emax = std::min(range_end_ - 1LL, index_->Max());
const int64 emax = std::min<int64>(range_end_ - 1, index_->Max());
const int64 vmin = target_var_->Min();
const int64 vmax = target_var_->Max();
if (emin == emax) {

2
ortools/constraint_solver/expr_cst.cc
View File

@@ -595,7 +595,7 @@ Constraint* Solver::MakeIsDifferentCstCt(IntExpr* const var, int64 value,
return MakeIsLessOrEqualCstCt(var, value - 1, boolvar);
}
if (var->IsVar() && !var->Var()->Contains(value)) {
return MakeEquality(boolvar, 1LL);
return MakeEquality(boolvar, GG_LONGLONG(1));
}
if (var->Bound() && var->Min() == value) {
return MakeEquality(boolvar, Zero());

29
ortools/constraint_solver/routing.cc
View File

@@ -4754,11 +4754,11 @@ void RoutingDimension::InitializeCumuls() {
const int64 min_capacity = *capacity_range.first;
CHECK_GE(min_capacity, 0);
const int64 max_capacity = *capacity_range.second;
solver->MakeIntVarArray(size, 0LL, max_capacity, name_, &cumuls_);
solver->MakeIntVarArray(size, 0, max_capacity, name_, &cumuls_);
forbidden_intervals_.resize(size);
capacity_vars_.clear();
if (min_capacity != max_capacity) {
solver->MakeIntVarArray(size, 0LL, kint64max, &capacity_vars_);
solver->MakeIntVarArray(size, 0, kint64max, &capacity_vars_);
for (int i = 0; i < size; ++i) {
IntVar* const capacity_var = capacity_vars_[i];
if (i < model_->Size()) {
@@ -5068,13 +5068,12 @@ void GlobalVehicleBreaksConstraint::PropagateVehicle(int vehicle) {
tasks_.forbidden_intervals.clear();
task_translators_.clear();
// Translate route to tasks: visits are nonpreemptible, transits are.
int64 group_delay = 0LL;
int64 group_delay = 0;
current = model_->Start(vehicle);
while (true) {
// Tasks from visits.
const bool node_is_last = current == model_->End(vehicle);
const int64 visit_duration =
node_is_last ? 0LL : node_visit_transit[current];
const int64 visit_duration = node_is_last ? 0 : node_visit_transit[current];
tasks_.start_min.push_back(
CapSub(dimension_->CumulVar(current)->Min(), group_delay));
tasks_.duration_min.push_back(CapAdd(group_delay, visit_duration));
@@ -5092,12 +5091,12 @@ void GlobalVehicleBreaksConstraint::PropagateVehicle(int vehicle) {
tasks_.start_min.push_back(
CapAdd(CapAdd(tasks_.start_min.back(), group_delay), visit_duration));
group_delay =
next_is_bound ? dimension_->GetGroupDelay(vehicle, current, next) : 0LL;
next_is_bound ? dimension_->GetGroupDelay(vehicle, current, next) : 0;
DCHECK_GE(group_delay, 0);
tasks_.duration_min.push_back(
std::max(0LL, CapSub(CapSub(dimension_->FixedTransitVar(current)->Min(),
visit_duration),
group_delay)));
tasks_.duration_min.push_back(std::max<int64>(
0, CapSub(CapSub(dimension_->FixedTransitVar(current)->Min(),
visit_duration),
group_delay)));
DCHECK_GE(tasks_.duration_min.back(), 0);
tasks_.end_max.push_back(
CapSub(dimension_->CumulVar(next)->Max(), group_delay));
@@ -5360,7 +5359,7 @@ void RoutingDimension::CloseModel(bool use_light_propagation) {
IntVar* const fixed_transit = fixed_transits_[i];
const auto transit_vehicle_evaluator = [this, i](int64 to,
int64 eval_index) {
return eval_index >= 0 ? transit_evaluator(eval_index)(i, to) : 0LL;
return eval_index >= 0 ? transit_evaluator(eval_index)(i, to) : 0;
};
if (use_light_propagation) {
if (class_evaluators_.size() == 1) {
@@ -5671,7 +5670,7 @@ void RoutingDimension::SetBreakIntervalsOfVehicle(
std::vector<int64> node_visit_transits) {
SetBreakIntervalsOfVehicle(std::move(breaks), vehicle,
std::move(node_visit_transits),
[](int64, int64) { return 0LL; });
[](int64, int64) { return 0; });
}
void RoutingDimension::SetBreakIntervalsOfVehicle(
@@ -5688,7 +5687,7 @@ void RoutingDimension::SetBreakIntervalsOfVehicle(
vehicle_node_visit_transits_.resize(model_->vehicles());
vehicle_break_intervals_.resize(model_->vehicles());
vehicle_group_delays_.resize(model_->vehicles(),
[](int64, int64) { return 0LL; });
[](int64, int64) { return 0; });
}
DCHECK_EQ(0, vehicle_node_visit_transits_[vehicle].size());
vehicle_node_visit_transits_[vehicle] = std::move(node_visit_transits);
@@ -5813,8 +5812,8 @@ void RoutingDimension::SetupSlackAndDependentTransitCosts(
solver
->MakeElement(
[this](int index) {
return IthElementOrValue<0LL>(
vehicle_span_cost_coefficients_, index);
return IthElementOrValue<0>(vehicle_span_cost_coefficients_,
index);
},
model_->VehicleVar(var_index))
->Var();

21
ortools/constraint_solver/search.cc
View File

@@ -63,7 +63,7 @@ SearchLog::SearchLog(Solver* const s, OptimizeVar* const obj, IntVar* const var,
scaling_factor_(scaling_factor),
display_callback_(std::move(display_callback)),
nsol_(0),
tick_(0LL),
tick_(0),
objective_min_(kint64max),
objective_max_(kint64min),
min_right_depth_(kint32max),
@@ -231,7 +231,7 @@ void SearchLog::Maintain() {
void SearchLog::BeginInitialPropagation() { tick_ = timer_->GetInMs(); }
void SearchLog::EndInitialPropagation() {
const int64 delta = std::max(timer_->GetInMs() - tick_, int64{0});
const int64 delta = std::max<int64>(timer_->GetInMs() - tick_, 0);
const std::string buffer = absl::StrFormat(
"Root node processed (time = %d ms, constraints = %d, %s)", delta,
solver()->constraints(), MemoryUsage());
@@ -1177,7 +1177,7 @@ int64 SelectRandomValue(const IntVar* v, int64 id) {
CHECK_LE(index, 0);
}
}
return 0LL;
return 0;
}
// ----- Select center -----
@@ -1202,7 +1202,7 @@ int64 SelectCenterValue(const IntVar* v, int64 id) {
return mid + i;
}
}
return 0LL;
return 0;
}
// ----- Select center -----
@@ -1489,7 +1489,7 @@ int64 StaticEvaluatorSelector::ChooseVariable() {
}
// Sort is stable here given the tie-breaking rules in comp_.
std::sort(elements_.begin(), elements_.end(), comp_);
solver_->SaveAndSetValue(&first_, 0LL);
solver_->SaveAndSetValue(&first_, GG_LONGLONG(0));
}
for (int64 i = first_; i < elements_.size(); ++i) {
const Element& element = elements_[i];
@@ -2989,7 +2989,8 @@ void TabuSearch::ApplyDecision(Decision* const d) {
IntVar* const tabu = s->MakeBoolVar();
s->AddConstraint(s->MakeIsGreaterOrEqualCstCt(
s->MakeSum(tabu_vars)->Var(), tabu_vars.size() * tabu_factor_, tabu));
s->AddConstraint(s->MakeGreaterOrEqual(s->MakeSum(aspiration, tabu), 1LL));
s->AddConstraint(
s->MakeGreaterOrEqual(s->MakeSum(aspiration, tabu), GG_LONGLONG(1)));
}
// Go downhill to the next local optimum
@@ -3282,7 +3283,7 @@ void GuidedLocalSearchPenaltiesTable::Increment(const Arc& arc) {
std::vector<int64>& first_penalties = penalties_[arc.first];
const int64 second = arc.second;
if (second >= first_penalties.size()) {
first_penalties.resize(second + 1, 0LL);
first_penalties.resize(second + 1, 0);
}
++first_penalties[second];
has_values_ = true;
@@ -3299,7 +3300,7 @@ int64 GuidedLocalSearchPenaltiesTable::Value(const Arc& arc) const {
const std::vector<int64>& first_penalties = penalties_[arc.first];
const int64 second = arc.second;
if (second >= first_penalties.size()) {
return 0LL;
return 0;
} else {
return first_penalties[second];
}
@@ -3335,9 +3336,9 @@ void GuidedLocalSearchPenaltiesMap::Reset() {
int64 GuidedLocalSearchPenaltiesMap::Value(const Arc& arc) const {
if (penalized_.Get(arc.first)) {
return gtl::FindWithDefault(penalties_, arc, 0LL);
return gtl::FindWithDefault(penalties_, arc, 0);
}
return 0LL;
return 0;
}
class GuidedLocalSearch : public Metaheuristic {

2
ortools/flatzinc/constraints.cc
View File

@@ -2152,7 +2152,7 @@ void ExtractIntLinLeReif(fz::SolverData* data, fz::Constraint* ct) {
// Special case. this is or(vars) = not(boolvar).
PostIsBooleanSumInRange(data->Sat(), solver, vars, 0, 0, boolvar);
} else if (rhs < 0 && AreAllPositive(coeffs) &&
IsArrayInRange(vars, 0LL, kint64max)) {
IsArrayInRange<int64>(vars, 0, kint64max)) {
// Trivial failure.
boolvar->SetValue(0);
FZVLOG << " - set target to 0" << FZENDL;