util: update sorted_interval_list

Author: Mizux

ortools/util/python/proto.i

@@ -57,15 +57,9 @@ namespace operations_research {
 %typemap(argout) CppType* const, CppType* {
   std::string encoded_protobuf;
   $1->SerializeToString(&encoded_protobuf);
-#if defined(PY3)
   PyObject* const python_encoded_protobuf =
       PyBytes_FromStringAndSize(encoded_protobuf.c_str(),
                                 encoded_protobuf.size());
-#else  // PY3
-  PyObject* const python_encoded_protobuf =
-      PyString_FromStringAndSize(encoded_protobuf.c_str(),
-                                 encoded_protobuf.size());
-#endif  // PY3
   if (python_encoded_protobuf != nullptr) {
     PyObject* const result = PyObject_CallMethod(
         $input, const_cast<char*>("ParseFromString"),
@@ -84,13 +78,8 @@ namespace operations_research {
       if (clss != nullptr) {
         std::string encoded_protobuf;
         $1.SerializeToString(&encoded_protobuf);
-#if defined(PY3)
         PyObject* const python_encoded_protobuf = PyBytes_FromStringAndSize(
             encoded_protobuf.c_str(), encoded_protobuf.size());
-#else  // PY3
-        PyObject* const python_encoded_protobuf = PyString_FromStringAndSize(
-            encoded_protobuf.c_str(), encoded_protobuf.size());
-#endif  // PY3
         PyObject* const result = PyObject_CallMethod(
               clss, const_cast<char*>("FromString"),
               const_cast<char*>("(O)"),

ortools/util/python/sorted_interval_list_doc.h

@@ -336,6 +336,14 @@ R"doc(Returns a compact string of a vector of intervals like
 
 static const char *mkd_doc_operations_research_Domain_UnionWith = R"doc(Returns the union of D and domain.)doc";
 
+static const char *mkd_doc_operations_research_Domain_UniqueValueNotIn =
+R"doc(If this \minus other is a singleton, returns it. Returns nullopt
+otherwise.
+
+This is similar to checking if
+this.IntersectionWith(other.Complement()) is non-empty and fixed, but
+avoid allocating memory.)doc";
+
 static const char *mkd_doc_operations_research_Domain_ValueAtOrAfter = R"doc()doc";
 
 static const char *mkd_doc_operations_research_Domain_ValueAtOrBefore =

ortools/util/sorted_interval_list.cc

@@ -18,6 +18,7 @@
 #include <cstdint>
 #include <cstdlib>
 #include <limits>
+#include <optional>
 #include <ostream>
 #include <string>
 #include <utility>
@@ -454,6 +455,42 @@ Domain Domain::IntersectionWith(const Domain& domain) const {
   return result;
 }
 
+std::optional<int64_t> Domain::UniqueValueNotIn(const Domain& other) const {
+  std::optional<int64_t> result;
+  int i = 0;
+  const auto& to_exclude = other.intervals_;
+  for (auto [start, end] : intervals_) {
+    while (start <= end) {
+      // find the first interval with to_exclude[i].end >= start.
+      while (i < to_exclude.size() && to_exclude[i].end < start) ++i;
+      if (i < to_exclude.size()) {
+        DCHECK_GE(to_exclude[i].end, start);
+        if (to_exclude[i].start <= start) {
+          if (to_exclude[i].end == kint64max) return result;
+          start = to_exclude[i].end + 1;
+          continue;
+        }
+        // Notice that if end > start, there will be no overflow here.
+        if (end == start || to_exclude[i].start == start + 1) {
+          if (result != std::nullopt) return std::nullopt;
+          result = start;
+          if (to_exclude[i].end == kint64max) return result;
+          start = to_exclude[i].end + 1;
+          continue;
+        }
+        return std::nullopt;
+      } else if (end == start) {
+        if (result != std::nullopt) return std::nullopt;
+        result = start;
+        break;  // Next interval.
+      } else {
+        return std::nullopt;
+      }
+    }
+  }
+  return result;
+}
+
 Domain Domain::UnionWith(const Domain& domain) const {
   Domain result;
   const auto& a = intervals_;

ortools/util/sorted_interval_list.h

@@ -506,6 +506,14 @@ class Domain {
   ABSL_MUST_USE_RESULT Domain
   SimplifyUsingImpliedDomain(const Domain& implied_domain) const;
 
+  /**
+   * If this \minus other is a singleton, returns it. Returns nullopt otherwise.
+   *
+   * This is similar to checking if this.IntersectionWith(other.Complement()) is
+   * non-empty and fixed, but avoid allocating memory.
+   */
+  std::optional<int64_t> UniqueValueNotIn(const Domain& other) const;
+
   /**
    * Returns a compact string of a vector of intervals like "[1,4][6][10,20]".
    */

ortools/util/testing_utils.h

@@ -17,12 +17,13 @@
 namespace operations_research {
 
 inline constexpr bool kAsanEnabled = false;
+inline constexpr bool kHwAsanEnabled = false;
 inline constexpr bool kMsanEnabled = false;
 inline constexpr bool kTsanEnabled = false;
 inline bool ProbablyRunningInsideUnitTest() { return false; }
 
 inline constexpr bool kAnyXsanEnabled =
-    kAsanEnabled || kMsanEnabled || kTsanEnabled;
+    kAsanEnabled || kMsanEnabled || kTsanEnabled || kHwAsanEnabled;
 
 }  // namespace operations_research