flatzinc: export from google3

Author: Mizux

ortools/flatzinc/checker.cc

@@ -121,6 +121,9 @@ std::vector<int64_t> SetEvalAt(
         return domain.values;
       }
     }
+    case Argument::INT_LIST: {
+      return {arg.ValueAt(pos)};
+    }
     case Argument::VAR_REF_ARRAY: {
       return set_evaluator(arg.variables[pos]);
     }
@@ -336,6 +339,19 @@ bool CheckOrToolsArraySetElement(
   const std::vector<int64_t> element =
       SetEvalAt(ct.arguments[2], index - min_index, set_evaluator);
   const std::vector<int64_t> target = SetEval(ct.arguments[3], set_evaluator);
+  if (element != target) {
+    LOG(INFO) << "CheckOrToolsArraySetElement: element: ["
+              << absl::StrJoin(element, ",") << "], target: ["
+              << absl::StrJoin(target, ",") << "]";
+    LOG(INFO) << "index: " << ct.arguments[0].DebugString() << " "
+              << ct.arguments[0].TypeString();
+    LOG(INFO) << "index_set: " << ct.arguments[1].DebugString() << " "
+              << ct.arguments[1].TypeString();
+    LOG(INFO) << "element: " << ct.arguments[2].DebugString() << " "
+              << ct.arguments[2].TypeString();
+    LOG(INFO) << "target: " << ct.arguments[3].DebugString() << " "
+              << ct.arguments[3].TypeString();
+  }
   return element == target;
 }
 

ortools/flatzinc/cp_model_fz_solver.cc

@@ -88,6 +88,14 @@ struct SetVariable {
     if (it == sorted_values.end() || *it != value) return -1;
     return it - sorted_values.begin();
   }
+
+  std::string DebugString() const {
+    return absl::StrCat(
+        "SetVariable(var_indices: ", absl::StrJoin(var_indices, ","),
+        ", sorted_values: ", absl::StrJoin(sorted_values, ","),
+        ", card_var_index: ", card_var_index,
+        ", fixed_card: ", fixed_card.value_or(-1), ")");
+  }
 };
 
 // Helper class to convert a flatzinc model to a CpModelProto.
@@ -533,8 +541,8 @@ std::shared_ptr<SetVariable> CpModelProtoWithMapping::LookupSetVarAt(
     }
     return result;
   } else {
-    LOG(FATAL) << "LookupSetVarAt:Unsupported argument type '" << argument.type
-               << "'";
+    LOG(FATAL) << "LookupSetVarAt:Unsupported argument type '"
+               << argument.TypeString() << "'";
   }
   return std::make_shared<SetVariable>();
 }

ortools/flatzinc/model.cc

@@ -58,6 +58,7 @@ Domain Domain::IntegerValue(int64_t value) {
 }
 
 Domain Domain::Interval(int64_t included_min, int64_t included_max) {
+  if (included_min > included_max) return Domain::EmptyDomain();
   Domain result;
   result.is_interval = true;
   result.values.push_back(included_min);
@@ -765,6 +766,32 @@ int Argument::Size() const {
   ABSL_UNREACHABLE();
 }
 
+std::string Argument::TypeString() const {
+  switch (type) {
+    case INT_VALUE:
+      return "INT_VALUE";
+    case INT_INTERVAL:
+      return "INT_INTERVAL";
+    case INT_LIST:
+      return "INT_LIST";
+    case DOMAIN_LIST:
+      return "DOMAIN_LIST";
+    case VAR_REF:
+      return "VAR_REF";
+    case VAR_REF_ARRAY:
+      return "VAR_REF_ARRAY";
+    case VOID_ARGUMENT:
+      return "VOID_ARGUMENT";
+    case FLOAT_VALUE:
+      return "FLOAT_VALUE";
+    case FLOAT_INTERVAL:
+      return "FLOAT_INTERVAL";
+    case FLOAT_LIST:
+      return "FLOAT_LIST";
+  }
+  ABSL_UNREACHABLE();
+}
+
 // ----- Variable -----
 
 Variable::Variable(absl::string_view name_, const Domain& domain_,
@@ -1037,6 +1064,14 @@ Variable* Model::AddFloatConstant(double value) {
   return var;
 }
 
+Variable* Model::AddSetConstant(const Domain& domain) {
+  Variable* const var = new Variable(domain.DebugString(), domain, true);
+  var->domain.is_a_set = true;
+  var->domain.is_fixed_set = true;
+  variables_.push_back(var);
+  return var;
+}
+
 void Model::AddConstraint(absl::string_view id, std::vector<Argument> arguments,
                           bool is_domain, bool symmetry, bool redundant) {
   Constraint* const constraint =

ortools/flatzinc/model.h

@@ -206,6 +206,8 @@ struct Argument {
   bool HasOneValueAt(int pos) const;
   // Returns the number of object in the argument.
   int Size() const;
+  // Returns the string of the type of the argument.
+  std::string TypeString() const;
 
   Type type;
   std::vector<int64_t> values;
@@ -356,6 +358,7 @@ class Model {
                         bool defined, bool set_is_fixed = false);
   Variable* AddConstant(int64_t value);
   Variable* AddFloatConstant(double value);
+  Variable* AddSetConstant(const Domain& domain);
   // Creates and add a constraint to the model.
   void AddConstraint(absl::string_view id, std::vector<Argument> arguments,
                      bool is_domain, bool symmetry, bool redundant);