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

speed up IsDifferentVar

Browse Source
This commit is contained in:
lperron@google.com
2012-06-29 05:23:58 +00:00
parent 8284956154
commit 3313aca838
6 changed files with 355 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
examples/flatzinc/calvin_puzzle.fzn
View File

@@ -1378,5 +1378,11 @@ constraint set_in(b____00584, {-3, -2, 0, 2, 3});
constraint set_in(b____00613, {-3, -2, 0, 2, 3});
constraint set_in(b____00642, {-3, -2, 0, 2, 3});
constraint set_in(b____00671, {-3, -2, 0, 2, 3});
constraint int_eq(x[1], 1);
%constraint int_eq(x[1], 1);
%constraint int_eq(x[2], 16);
%constraint int_eq(x[3], 6);
%constraint int_eq(x[4], 23);
%constraint int_eq(x[5], 13);
solve :: int_search([x[1], x[2], x[3], x[4], x[5], x[6], x[7], x[8], x[9], x[10], x[11], x[12], x[13], x[14], x[15], x[16], x[17], x[18], x[19], x[20], x[21], x[22], x[23], x[24], x[25]], occurrence, indomain_median, complete) satisfy;

162
examples/flatzinc/optimal_picking_elements_from_each_list.fzn Normal file
View File

@@ -0,0 +1,162 @@
predicate all_different_int(array [int] of var int: x);
predicate count(array [int] of var int: x, var int: y, var int: c);
predicate fixed_cumulative(array [int] of var int: s, array [int] of int: d, array [int] of int: r, int: b);
predicate global_cardinality(array [int] of var int: x, array [int] of int: cover, array [int] of var int: counts);
predicate maximum_int(var int: m, array [int] of var int: x);
predicate minimum_int(var int: m, array [int] of var int: x);
predicate sort(array [int] of var int: x, array [int] of var int: y);
predicate table_bool(array [int] of var bool: x, array [int, int] of bool: t);
predicate table_int(array [int] of var int: x, array [int, int] of int: t);
predicate var_cumulative(array [int] of var int: s, array [int] of int: d, array [int] of int: r, var int: b);
array [1..30] of set of int: s = [{4, 6, 15, 18}, {1, 2, 7, 9, 14, 16, 20}, {3, 12, 15}, {3, 6, 10, 13, 17, 19}, {1, 2, 15, 19}, {3, 5, 6, 14, 17}, {5, 9, 17}, {8, 9, 13, 15, 19, 20}, {5, 13, 18}, {1, 2, 5, 11, 12}, {4, 7, 10}, {1, 2, 3, 9, 12, 14}, {5, 8, 9, 19}, {1, 3, 4, 9, 14}, {1, 5, 11, 13}, {3, 7, 9, 12, 14, 16}, {4, 6, 7, 17, 18}, {9, 17, 19}, {3, 7, 12, 15}, {5, 8, 12, 14, 19}, {1, 8, 10, 12}, {14, 16, 18, 19}, {2, 7, 10}, {2, 3, 5, 19}, {3, 16, 17}, {1, 2, 3, 6, 16, 20}, {11, 12, 17, 18, 19}, {4, 9, 12, 16, 20}, {9, 10, 11, 12, 19, 20}, {5, 6, 10, 12, 17, 19}];
var bool: BOOL____00001 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00003 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00005 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00007 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00009 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00011 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00013 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00015 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00017 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00019 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00021 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00023 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00025 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00027 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00029 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00031 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00033 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00035 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00037 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00039 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00041 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00043 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00045 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00047 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00049 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00051 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00053 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00055 :: is_defined_var :: var_is_introduced;
var bool: BOOL____00057 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00002 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00004 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00006 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00008 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00010 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00012 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00014 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00016 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00018 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00020 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00022 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00024 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00026 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00028 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00030 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00032 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00034 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00036 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00038 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00040 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00042 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00044 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00046 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00048 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00050 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00052 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00054 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00056 :: is_defined_var :: var_is_introduced;
var 0..1: INT____00058 :: is_defined_var :: var_is_introduced;
var 0..29: INT____00059 :: is_defined_var :: var_is_introduced;
var 0..29: sum_diffs :: output_var = INT____00059;
array [1..30] of var 1..20: x :: output_array([1..30]);
constraint bool2int(BOOL____00001, INT____00002) :: defines_var(INT____00002);
constraint bool2int(BOOL____00003, INT____00004) :: defines_var(INT____00004);
constraint bool2int(BOOL____00005, INT____00006) :: defines_var(INT____00006);
constraint bool2int(BOOL____00007, INT____00008) :: defines_var(INT____00008);
constraint bool2int(BOOL____00009, INT____00010) :: defines_var(INT____00010);
constraint bool2int(BOOL____00011, INT____00012) :: defines_var(INT____00012);
constraint bool2int(BOOL____00013, INT____00014) :: defines_var(INT____00014);
constraint bool2int(BOOL____00015, INT____00016) :: defines_var(INT____00016);
constraint bool2int(BOOL____00017, INT____00018) :: defines_var(INT____00018);
constraint bool2int(BOOL____00019, INT____00020) :: defines_var(INT____00020);
constraint bool2int(BOOL____00021, INT____00022) :: defines_var(INT____00022);
constraint bool2int(BOOL____00023, INT____00024) :: defines_var(INT____00024);
constraint bool2int(BOOL____00025, INT____00026) :: defines_var(INT____00026);
constraint bool2int(BOOL____00027, INT____00028) :: defines_var(INT____00028);
constraint bool2int(BOOL____00029, INT____00030) :: defines_var(INT____00030);
constraint bool2int(BOOL____00031, INT____00032) :: defines_var(INT____00032);
constraint bool2int(BOOL____00033, INT____00034) :: defines_var(INT____00034);
constraint bool2int(BOOL____00035, INT____00036) :: defines_var(INT____00036);
constraint bool2int(BOOL____00037, INT____00038) :: defines_var(INT____00038);
constraint bool2int(BOOL____00039, INT____00040) :: defines_var(INT____00040);
constraint bool2int(BOOL____00041, INT____00042) :: defines_var(INT____00042);
constraint bool2int(BOOL____00043, INT____00044) :: defines_var(INT____00044);
constraint bool2int(BOOL____00045, INT____00046) :: defines_var(INT____00046);
constraint bool2int(BOOL____00047, INT____00048) :: defines_var(INT____00048);
constraint bool2int(BOOL____00049, INT____00050) :: defines_var(INT____00050);
constraint bool2int(BOOL____00051, INT____00052) :: defines_var(INT____00052);
constraint bool2int(BOOL____00053, INT____00054) :: defines_var(INT____00054);
constraint bool2int(BOOL____00055, INT____00056) :: defines_var(INT____00056);
constraint bool2int(BOOL____00057, INT____00058) :: defines_var(INT____00058);
constraint int_lin_eq([-1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [INT____00059, INT____00002, INT____00004, INT____00006, INT____00008, INT____00010, INT____00012, INT____00014, INT____00016, INT____00018, INT____00020, INT____00022, INT____00024, INT____00026, INT____00028, INT____00030, INT____00032, INT____00034, INT____00036, INT____00038, INT____00040, INT____00042, INT____00044, INT____00046, INT____00048, INT____00050, INT____00052, INT____00054, INT____00056, INT____00058], 0) :: defines_var(INT____00059);
constraint int_ne_reif(x[2], x[1], BOOL____00001) :: defines_var(BOOL____00001);
constraint int_ne_reif(x[3], x[2], BOOL____00003) :: defines_var(BOOL____00003);
constraint int_ne_reif(x[4], x[3], BOOL____00005) :: defines_var(BOOL____00005);
constraint int_ne_reif(x[5], x[4], BOOL____00007) :: defines_var(BOOL____00007);
constraint int_ne_reif(x[6], x[5], BOOL____00009) :: defines_var(BOOL____00009);
constraint int_ne_reif(x[7], x[6], BOOL____00011) :: defines_var(BOOL____00011);
constraint int_ne_reif(x[8], x[7], BOOL____00013) :: defines_var(BOOL____00013);
constraint int_ne_reif(x[9], x[8], BOOL____00015) :: defines_var(BOOL____00015);
constraint int_ne_reif(x[10], x[9], BOOL____00017) :: defines_var(BOOL____00017);
constraint int_ne_reif(x[11], x[10], BOOL____00019) :: defines_var(BOOL____00019);
constraint int_ne_reif(x[12], x[11], BOOL____00021) :: defines_var(BOOL____00021);
constraint int_ne_reif(x[13], x[12], BOOL____00023) :: defines_var(BOOL____00023);
constraint int_ne_reif(x[14], x[13], BOOL____00025) :: defines_var(BOOL____00025);
constraint int_ne_reif(x[15], x[14], BOOL____00027) :: defines_var(BOOL____00027);
constraint int_ne_reif(x[16], x[15], BOOL____00029) :: defines_var(BOOL____00029);
constraint int_ne_reif(x[17], x[16], BOOL____00031) :: defines_var(BOOL____00031);
constraint int_ne_reif(x[18], x[17], BOOL____00033) :: defines_var(BOOL____00033);
constraint int_ne_reif(x[19], x[18], BOOL____00035) :: defines_var(BOOL____00035);
constraint int_ne_reif(x[20], x[19], BOOL____00037) :: defines_var(BOOL____00037);
constraint int_ne_reif(x[21], x[20], BOOL____00039) :: defines_var(BOOL____00039);
constraint int_ne_reif(x[22], x[21], BOOL____00041) :: defines_var(BOOL____00041);
constraint int_ne_reif(x[23], x[22], BOOL____00043) :: defines_var(BOOL____00043);
constraint int_ne_reif(x[24], x[23], BOOL____00045) :: defines_var(BOOL____00045);
constraint int_ne_reif(x[25], x[24], BOOL____00047) :: defines_var(BOOL____00047);
constraint int_ne_reif(x[26], x[25], BOOL____00049) :: defines_var(BOOL____00049);
constraint int_ne_reif(x[27], x[26], BOOL____00051) :: defines_var(BOOL____00051);
constraint int_ne_reif(x[28], x[27], BOOL____00053) :: defines_var(BOOL____00053);
constraint int_ne_reif(x[29], x[28], BOOL____00055) :: defines_var(BOOL____00055);
constraint int_ne_reif(x[30], x[29], BOOL____00057) :: defines_var(BOOL____00057);
constraint set_in(x[1], {4, 6, 15, 18});
constraint set_in(x[2], {1, 2, 7, 9, 14, 16, 20});
constraint set_in(x[3], {3, 12, 15});
constraint set_in(x[4], {3, 6, 10, 13, 17, 19});
constraint set_in(x[5], {1, 2, 15, 19});
constraint set_in(x[6], {3, 5, 6, 14, 17});
constraint set_in(x[7], {5, 9, 17});
constraint set_in(x[8], {8, 9, 13, 15, 19, 20});
constraint set_in(x[9], {5, 13, 18});
constraint set_in(x[10], {1, 2, 5, 11, 12});
constraint set_in(x[11], {4, 7, 10});
constraint set_in(x[12], {1, 2, 3, 9, 12, 14});
constraint set_in(x[13], {5, 8, 9, 19});
constraint set_in(x[14], {1, 3, 4, 9, 14});
constraint set_in(x[15], {1, 5, 11, 13});
constraint set_in(x[16], {3, 7, 9, 12, 14, 16});
constraint set_in(x[17], {4, 6, 7, 17, 18});
constraint set_in(x[18], {9, 17, 19});
constraint set_in(x[19], {3, 7, 12, 15});
constraint set_in(x[20], {5, 8, 12, 14, 19});
constraint set_in(x[21], {1, 8, 10, 12});
constraint set_in(x[22], {14, 16, 18, 19});
constraint set_in(x[23], {2, 7, 10});
constraint set_in(x[24], {2, 3, 5, 19});
constraint set_in(x[25], {3, 16, 17});
constraint set_in(x[26], {1, 2, 3, 6, 16, 20});
constraint set_in(x[27], {11, 12, 17, 18, 19});
constraint set_in(x[28], {4, 9, 12, 16, 20});
constraint set_in(x[29], {9, 10, 11, 12, 19, 20});
constraint set_in(x[30], {5, 6, 10, 12, 17, 19});
solve minimize INT____00059;

6
makefiles/Makefile.cpp.mk
View File

@@ -718,6 +718,12 @@ $(BIN_DIR)/tsp$E: $(ROUTING_DEPS) $(OBJ_DIR)/tsp.$O
# CP tests.
$(OBJ_DIR)/bug_pack.$O:$(EX_DIR)/tests/bug_pack.cc $(SRC_DIR)/constraint_solver/constraint_solver.h
$(CCC) $(CFLAGS) -c $(EX_DIR)$Stests/bug_pack.cc $(OBJ_OUT)bug_pack.$O
$(BIN_DIR)/bug_pack$E: $(CP_DEPS) $(OBJ_DIR)/bug_pack.$O
$(CCC) $(CFLAGS) $(OBJ_DIR)/bug_pack.$O $(CP_LNK) $(LDFLAGS) $(EXEOUT)bug_pack$E
$(OBJ_DIR)/mtsearch_test.$O:$(EX_DIR)/tests/mtsearch_test.cc $(SRC_DIR)/constraint_solver/constraint_solver.h
$(CCC) $(CFLAGS) -c $(EX_DIR)$Stests/mtsearch_test.cc $(OBJ_OUT)mtsearch_test.$O

37
src/constraint_solver/expr_cst.cc
View File

@@ -438,42 +438,7 @@ class IsDiffCstCt : public CastConstraint {
} // namespace
IntVar* Solver::MakeIsDifferentCstVar(IntVar* const var, int64 value) {
if (value == var->Min()) {
return MakeIsGreaterOrEqualCstVar(var, value + 1);
}
if (value == var->Max()) {
return MakeIsLessOrEqualCstVar(var, value - 1);
}
if (!var->Contains(value)) {
return MakeIntConst(1LL);
}
if (var->Bound() && var->Value() == value) {
return MakeIntConst(0LL);
}
IntExpr* const cache = model_cache_->FindVarConstantExpression(
var,
value,
ModelCache::VAR_CONSTANT_IS_NOT_EQUAL);
if (cache != NULL) {
return cache->Var();
} else {
string name = var->name();
if (name.empty()) {
name = var->DebugString();
}
IntVar* const boolvar = MakeBoolVar(
StringPrintf("Var<%s != %" GG_LL_FORMAT "d>",
name.c_str(), value));
CastConstraint* const maintain =
RevAlloc(new IsDiffCstCt(this, var, value, boolvar));
AddConstraint(maintain);
model_cache_->InsertVarConstantExpression(
boolvar,
var,
value,
ModelCache::VAR_CONSTANT_IS_NOT_EQUAL);
return boolvar;
}
return var->IsDifferent(value);
}
Constraint* Solver::MakeIsDifferentCstCt(IntVar* const var,

203
src/constraint_solver/expressions.cc
View File

@@ -549,7 +549,8 @@ class DomainIntVar : public IntVar {
}
virtual IntVar* IsDifferent(int64 constant) {
return NULL; // IMPLEMENT ME
Solver* const s = solver();
return s->MakeDifference(1, IsEqual(constant))->Var();
}
void Process();
@@ -5478,18 +5479,7 @@ class IsEqualCt : public CastConstraint {
void PropagateDomain() {
if (target_var_->Bound()) {
if (target_var_->Min() == 0) {
if (left_->Bound()) {
domain_demon_->inhibit(solver());
right_->RemoveValue(left_->Min());
} else if (right_->Bound()) {
domain_demon_->inhibit(solver());
left_->RemoveValue(right_->Min());
}
} else { // target var is true.
left_->SetRange(right_->Min(), right_->Max());
right_->SetRange(left_->Min(), left_->Max());
}
PropagateTarget();
return;
}
const int64 support = support_.Value();
@@ -5507,18 +5497,7 @@ class IsEqualCt : public CastConstraint {
void PropagateRange() {
if (target_var_->Bound()) {
if (target_var_->Min() == 0) {
if (left_->Bound()) {
range_demon_->inhibit(solver());
right_->RemoveValue(left_->Min());
} else if (right_->Bound()) {
range_demon_->inhibit(solver());
left_->RemoveValue(right_->Min());
}
} else { // target var is true.
left_->SetRange(right_->Min(), right_->Max());
right_->SetRange(left_->Min(), left_->Max());
}
PropagateTarget();
return;
}
if (left_->Size() <= 32 || right_->Size() <= 32) {
@@ -5549,7 +5528,7 @@ class IsEqualCt : public CastConstraint {
}
string DebugString() const {
return StringPrintf("IsEqualCstCt(%s, %s, %s)",
return StringPrintf("IsEqualCt(%s, %s, %s)",
left_->DebugString().c_str(),
right_->DebugString().c_str(),
target_var_->DebugString().c_str());
@@ -5607,6 +5586,171 @@ class IsEqualCt : public CastConstraint {
Demon* range_demon_;
Rev<int64> support_;
};
// IsDifferentCt
class IsDifferentCt : public CastConstraint {
public:
IsDifferentCt(Solver* const s,
IntVar* const l,
IntVar* const r,
IntVar* const b)
: CastConstraint(s, b),
left_(l),
right_(r),
left_iterator_(l->MakeDomainIterator(true)),
right_iterator_(r->MakeDomainIterator(true)),
range_demon_(NULL),
domain_demon_(NULL),
support_(l->Min() - 1) {}
virtual ~IsDifferentCt() {}
virtual void Post() {
range_demon_ =
MakeConstraintDemon0(solver(),
this,
&IsDifferentCt::PropagateRange,
"PropagateRange");
domain_demon_ =
MakeConstraintDemon0(solver(),
this,
&IsDifferentCt::PropagateDomain,
"PropagateDomain");
if (left_->Size() > 32 && right_->Size() > 32) {
domain_demon_->inhibit(solver());
} else {
range_demon_->inhibit(solver());
}
left_->WhenDomain(domain_demon_);
right_->WhenDomain(domain_demon_);
left_->WhenRange(range_demon_);
right_->WhenRange(range_demon_);
Demon* const target_demon =
MakeConstraintDemon0(solver(),
this,
&IsDifferentCt::PropagateTarget,
"PropagateTarget");
target_var_->WhenBound(target_demon);
}
virtual void InitialPropagate() {
if (left_->Size() > 32 && right_->Size() > 32) {
PropagateRange();
} else {
PropagateDomain();
}
}
void PropagateDomain() {
if (target_var_->Bound()) {
PropagateTarget();
return;
}
const int64 support = support_.Value();
if (!left_->Contains(support) || !right_->Contains(support)) {
if (!FindSupport()) {
domain_demon_->inhibit(solver());
target_var_->SetValue(1);
} else if (left_->Bound() && right_->Bound()) {
target_var_->SetValue(0);
}
} else if (left_->Bound() && right_->Bound()) {
target_var_->SetValue(0);
}
}
void PropagateRange() {
if (target_var_->Bound()) {
PropagateTarget();
return;
}
if (left_->Size() <= 32 || right_->Size() <= 32) {
range_demon_->inhibit(solver());
domain_demon_->desinhibit(solver());
PropagateDomain();
} else if (left_->Min() > right_->Max() || left_->Max() < right_->Min()) {
target_var_->SetValue(1);
range_demon_->inhibit(solver());
}
}
void PropagateTarget() {
if (target_var_->Min() == 0) {
left_->SetRange(right_->Min(), right_->Max());
right_->SetRange(left_->Min(), left_->Max());
} else { // Var is true.
if (left_->Bound()) {
range_demon_->inhibit(solver());
domain_demon_->inhibit(solver());
right_->RemoveValue(left_->Min());
} else if (right_->Bound()) {
range_demon_->inhibit(solver());
domain_demon_->inhibit(solver());
left_->RemoveValue(right_->Min());
}
}
}
string DebugString() const {
return StringPrintf("IsDifferentCt(%s, %s, %s)",
left_->DebugString().c_str(),
right_->DebugString().c_str(),
target_var_->DebugString().c_str());
}
void Accept(ModelVisitor* const visitor) const {
visitor->BeginVisitConstraint(ModelVisitor::kIsDifferent, this);
visitor->VisitIntegerExpressionArgument(ModelVisitor::kExpressionArgument,
left_);
visitor->VisitIntegerExpressionArgument(ModelVisitor::kValueArgument,
right_);
visitor->VisitIntegerExpressionArgument(ModelVisitor::kTargetArgument,
target_var_);
visitor->EndVisitConstraint(ModelVisitor::kIsDifferent, this);
}
private:
bool FindSupport() {
bool found = false;
if (left_->Max() < right_->Min() || left_->Min() > right_->Max()) {
return false;
}
// Find new support.
if (left_->Size() <= right_->Size()) {
for (left_iterator_->Init();
left_iterator_->Ok();
left_iterator_->Next()) {
const int64 value = left_iterator_->Value();
if (right_->Contains(value)) {
found = true;
support_.SetValue(solver(), value);
break;
}
}
} else {
for (right_iterator_->Init();
right_iterator_->Ok();
right_iterator_->Next()) {
const int64 value = right_iterator_->Value();
if (left_->Contains(value)) {
found = true;
support_.SetValue(solver(), value);
break;
}
}
}
return found;
}
IntVar* const left_;
IntVar* const right_;
IntVarIterator* const left_iterator_;
IntVarIterator* const right_iterator_;
Demon* domain_demon_;
Demon* range_demon_;
Rev<int64> support_;
};
} // namespace
Action* NewDomainIntVarCleaner() {
@@ -5928,8 +6072,9 @@ IntVar* Solver::MakeIsDifferentVar(IntExpr* const v1, IntExpr* const v2) {
if (name2.empty()) {
name2 = var2->DebugString();
}
IntVar* const boolvar =
MakeIsDifferentCstVar(MakeDifference(v1, v2)->Var(), 0);
IntVar* const boolvar = MakeBoolVar(
StringPrintf("IsDifferentVar(%s, %s)", name1.c_str(), name2.c_str()));
AddConstraint(MakeIsDifferentCt(v1, v2, boolvar));
model_cache_->InsertVarVarExpression(
boolvar,
var1,
@@ -5949,7 +6094,7 @@ Constraint* Solver::MakeIsDifferentCt(IntExpr* const v1,
} else if (v2->Bound()) {
return MakeIsDifferentCstCt(v1->Var(), v2->Min(), b);
}
return MakeIsDifferentCstCt(MakeDifference(v1, v2)->Var(), 0, b);
return RevAlloc(new IsDifferentCt(this, v1->Var(), v2->Var(), b));
}
IntVar* Solver::MakeIsLessOrEqualVar(

12
src/flatzinc/registry.cc
View File

@@ -214,27 +214,25 @@ void p_int_eq_reif(FlatZincModel* const model, CtSpec* const spec) {
void p_int_ne_reif(FlatZincModel* const model, CtSpec* const spec) {
Solver* const solver = model->solver();
IntVar* const left = model->GetIntVar(spec->Arg(0));
IntVar* const right = model->GetIntVar(spec->Arg(1));
AST::Node* const node_right = spec->Arg(1);
AST::Node* const node_boolvar = spec->Arg(2);
if (node_boolvar->isBoolVar() &&
node_boolvar->getBoolVar() + model->IntVarCount() == spec->defines()) {
IntVar* const boolvar = solver->MakeIsDifferentVar(left, right);
IntVar* const boolvar = node_right->isInt() ?
solver->MakeIsDifferentCstVar(left, node_right->getInt()) :
solver->MakeIsDifferentVar(left, model->GetIntVar(node_right));
VLOG(1) << " - creating " << node_boolvar->DebugString() << " := "
<< boolvar->DebugString();
CHECK(model->BooleanVariable(node_boolvar->getBoolVar()) == NULL);
model->SetBooleanVariable(node_boolvar->getBoolVar(), boolvar);
CHECK_NOTNULL(boolvar);
} else {
IntVar* const right = model->GetIntVar(spec->Arg(1));
IntVar* const boolvar = model->GetIntVar(node_boolvar);
Constraint* const ct = solver->MakeIsDifferentCt(left, right, boolvar);
VLOG(1) << " - posted " << ct->DebugString();
solver->AddConstraint(ct);
}
IntVar* const boolvar = model->GetIntVar(spec->Arg(2));
Constraint* const ct = solver->MakeIsDifferentCt(left, right, boolvar);
VLOG(1) << " - posted " << ct->DebugString();
solver->AddConstraint(ct);
}
void p_int_ge_reif(FlatZincModel* const model, CtSpec* const spec) {