math_opt: export from google3

* CMake has not been updated yet
* bazel was compiling at least last week

Author: Mizux

ortools/math_opt/CMakeLists.txt

@@ -18,6 +18,7 @@ endif()
 add_subdirectory(core)
 add_subdirectory(constraints)
 add_subdirectory(cpp)
+add_subdirectory(elemental)
 add_subdirectory(io)
 add_subdirectory(labs)
 add_subdirectory(solver_tests)
@@ -31,6 +32,7 @@ target_sources(${NAME} PUBLIC
   $<TARGET_OBJECTS:${NAME}_core>
   $<TARGET_OBJECTS:${NAME}_core_c_api>
   $<TARGET_OBJECTS:${NAME}_cpp>
+  $<TARGET_OBJECTS:${NAME}_elemental>
   $<TARGET_OBJECTS:${NAME}_io>
   $<TARGET_OBJECTS:${NAME}_labs>
   $<TARGET_OBJECTS:${NAME}_solvers>

ortools/math_opt/README.md

@@ -0,0 +1,18 @@
+# math_opt
+
+The code in this directory provides a generic way of accessing mathematical
+optimization solvers (sometimes called mathematical programming solvers), such
+as GLOP, CP-SAT, SCIP and Gurobi. In particular, a single API is provided to
+make these solvers largely interoperable.
+
+New code should prefer MathOpt to `MPSolver`, as defined in
+[linear_solver.h](../linear_solver/linear_solver.h)
+when possible.
+
+MathOpt has client libraries in C++, Python, and Java that most users should use
+to build and solve their models. A proto API is also provided, but this is not
+recommended for most users.
+
+See
+[parameters.proto](../math_opt/parameters.proto?q=SolverTypeProto)
+for the list of supported solvers.

ortools/math_opt/callback.proto

@@ -158,7 +158,17 @@ message CallbackResultProto {
     bool is_lazy = 4;
   }
 
-  // Ends the solve early.
+  // When true it tells the solver to interrupt the solve as soon as possible.
+  //
+  // It can be set from any event. This is equivalent to using a
+  // SolveInterrupter and triggering it from the callback.
+  //
+  // Some solvers don't support interruption, in that case this is simply
+  // ignored and the solve terminates as usual. On top of that solvers may not
+  // immediately stop the solve. Thus the user should expect the callback to
+  // still be called after they set `terminate` to true in a previous
+  // call. Returning with `terminate` false after having previously returned
+  // true won't cancel the interruption.
   bool terminate = 1;
 
   // TODO(b/172214608): SCIP allows to reject a feasible solution without

ortools/math_opt/constraints/indicator/BUILD.bazel

@@ -18,10 +18,11 @@ cc_library(
     srcs = ["indicator_constraint.cc"],
     hdrs = ["indicator_constraint.h"],
     deps = [
-        "//ortools/base:intops",
         "//ortools/math_opt/constraints/util:model_util",
         "//ortools/math_opt/cpp:variable_and_expressions",
+        "//ortools/math_opt/elemental:elements",
         "//ortools/math_opt/storage:model_storage",
+        "//ortools/math_opt/storage:model_storage_item",
         "@abseil-cpp//absl/strings",
     ],
 )
@@ -51,6 +52,7 @@ cc_library(
         "//ortools/math_opt:model_update_cc_proto",
         "//ortools/math_opt:sparse_containers_cc_proto",
         "//ortools/math_opt/core:sorted",
+        "//ortools/math_opt/elemental:elements",
         "//ortools/math_opt/storage:atomic_constraint_storage",
         "//ortools/math_opt/storage:sparse_coefficient_map",
         "@abseil-cpp//absl/container:flat_hash_set",

ortools/math_opt/constraints/indicator/indicator_constraint.cc

@@ -18,31 +18,29 @@
 #include <string>
 #include <utility>
 
-#include "absl/strings/string_view.h"
-#include "ortools/base/strong_int.h"
 #include "ortools/math_opt/constraints/util/model_util.h"
 #include "ortools/math_opt/cpp/variable_and_expressions.h"
 #include "ortools/math_opt/storage/model_storage.h"
 
 namespace operations_research::math_opt {
 
 BoundedLinearExpression IndicatorConstraint::ImpliedConstraint() const {
-  const IndicatorConstraintData& data = storage()->constraint_data(id_);
+  const IndicatorConstraintData& data = storage()->constraint_data(typed_id());
   // NOTE: The following makes a copy of `data.linear_terms`. This can be made
   // more efficient if the need arises.
   LinearExpression expr = ToLinearExpression(
-      *storage_, {.coeffs = data.linear_terms, .offset = 0.0});
+      *storage(), {.coeffs = data.linear_terms, .offset = 0.0});
   return data.lower_bound <= std::move(expr) <= data.upper_bound;
 }
 
 std::string IndicatorConstraint::ToString() const {
-  if (!storage()->has_constraint(id_)) {
+  if (!storage()->has_constraint(typed_id())) {
     return std::string(kDeletedConstraintDefaultDescription);
   }
-  const IndicatorConstraintData& data = storage()->constraint_data(id_);
+  const IndicatorConstraintData& data = storage()->constraint_data(typed_id());
   std::stringstream str;
   if (data.indicator.has_value()) {
-    str << Variable(storage_, *data.indicator)
+    str << Variable(storage(), *data.indicator)
         << (data.activate_on_zero ? " = 0" : " = 1");
   } else {
     str << "[unset indicator variable]";

ortools/math_opt/constraints/indicator/indicator_constraint.h

@@ -16,38 +16,28 @@
 #ifndef OR_TOOLS_MATH_OPT_CONSTRAINTS_INDICATOR_INDICATOR_CONSTRAINT_H_
 #define OR_TOOLS_MATH_OPT_CONSTRAINTS_INDICATOR_INDICATOR_CONSTRAINT_H_
 
-#include <cstdint>
 #include <optional>
-#include <ostream>
 #include <string>
 #include <vector>
 
 #include "absl/strings/string_view.h"
-#include "ortools/base/strong_int.h"
 #include "ortools/math_opt/constraints/util/model_util.h"
 #include "ortools/math_opt/cpp/variable_and_expressions.h"
+#include "ortools/math_opt/elemental/elements.h"
 #include "ortools/math_opt/storage/model_storage.h"
+#include "ortools/math_opt/storage/model_storage_item.h"
 
 namespace operations_research::math_opt {
 
 // A value type that references an indicator constraint from ModelStorage.
 // Usually this type is passed by copy.
-//
-// This type implements https://abseil.io/docs/cpp/guides/hash.
-class IndicatorConstraint {
+class IndicatorConstraint final
+    : public ModelStorageElement<ElementType::kIndicatorConstraint,
+                                 IndicatorConstraint> {
  public:
-  // The typed integer used for ids.
-  using IdType = IndicatorConstraintId;
-
-  inline IndicatorConstraint(const ModelStorage* storage,
-                             IndicatorConstraintId id);
-
-  inline int64_t id() const;
+  using ModelStorageElement::ModelStorageElement;
 
-  inline IndicatorConstraintId typed_id() const;
-  inline const ModelStorage* storage() const;
-
-  inline absl::string_view name() const;
+  absl::string_view name() const;
 
   // Returns nullopt if the indicator variable is unset (this is a valid state,
   // in which the constraint is functionally ignored).
@@ -65,91 +55,36 @@ class IndicatorConstraint {
   // Returns a detailed string description of the contents of the constraint
   // (not its name, use `<<` for that instead).
   std::string ToString() const;
-
-  friend inline bool operator==(const IndicatorConstraint& lhs,
-                                const IndicatorConstraint& rhs);
-  friend inline bool operator!=(const IndicatorConstraint& lhs,
-                                const IndicatorConstraint& rhs);
-  template <typename H>
-  friend H AbslHashValue(H h, const IndicatorConstraint& constraint);
-  friend std::ostream& operator<<(std::ostream& ostr,
-                                  const IndicatorConstraint& constraint);
-
- private:
-  const ModelStorage* storage_;
-  IndicatorConstraintId id_;
 };
 
-// Streams the name of the constraint, as registered upon constraint creation,
-// or a short default if none was provided.
-inline std::ostream& operator<<(std::ostream& ostr,
-                                const IndicatorConstraint& constraint);
-
 ////////////////////////////////////////////////////////////////////////////////
 // Inline function implementations
 ////////////////////////////////////////////////////////////////////////////////
 
-int64_t IndicatorConstraint::id() const { return id_.value(); }
-
-IndicatorConstraintId IndicatorConstraint::typed_id() const { return id_; }
-
-const ModelStorage* IndicatorConstraint::storage() const { return storage_; }
-
-absl::string_view IndicatorConstraint::name() const {
-  if (storage_->has_constraint(id_)) {
-    return storage_->constraint_data(id_).name;
+inline absl::string_view IndicatorConstraint::name() const {
+  if (storage()->has_constraint(typed_id())) {
+    return storage()->constraint_data(typed_id()).name;
   }
   return kDeletedConstraintDefaultDescription;
 }
 
 std::optional<Variable> IndicatorConstraint::indicator_variable() const {
   const std::optional<VariableId> maybe_indicator =
-      storage_->constraint_data(id_).indicator;
+      storage()->constraint_data(typed_id()).indicator;
   if (!maybe_indicator.has_value()) {
     return std::nullopt;
   }
-  return Variable(storage_, *maybe_indicator);
+  return Variable(storage(), *maybe_indicator);
 }
 
 bool IndicatorConstraint::activate_on_zero() const {
-  return storage_->constraint_data(id_).activate_on_zero;
+  return storage()->constraint_data(typed_id()).activate_on_zero;
 }
 
 std::vector<Variable> IndicatorConstraint::NonzeroVariables() const {
-  return AtomicConstraintNonzeroVariables(*storage_, id_);
+  return AtomicConstraintNonzeroVariables(*storage(), typed_id());
 }
 
-bool operator==(const IndicatorConstraint& lhs,
-                const IndicatorConstraint& rhs) {
-  return lhs.id_ == rhs.id_ && lhs.storage_ == rhs.storage_;
-}
-
-bool operator!=(const IndicatorConstraint& lhs,
-                const IndicatorConstraint& rhs) {
-  return !(lhs == rhs);
-}
-
-template <typename H>
-H AbslHashValue(H h, const IndicatorConstraint& constraint) {
-  return H::combine(std::move(h), constraint.id_.value(), constraint.storage_);
-}
-
-std::ostream& operator<<(std::ostream& ostr,
-                         const IndicatorConstraint& constraint) {
-  // TODO(b/170992529): handle quoting of invalid characters in the name.
-  const absl::string_view name = constraint.name();
-  if (name.empty()) {
-    ostr << "__indic_con#" << constraint.id() << "__";
-  } else {
-    ostr << name;
-  }
-  return ostr;
-}
-
-IndicatorConstraint::IndicatorConstraint(const ModelStorage* const storage,
-                                         const IndicatorConstraintId id)
-    : storage_(storage), id_(id) {}
-
 }  // namespace operations_research::math_opt
 
 #endif  // OR_TOOLS_MATH_OPT_CONSTRAINTS_INDICATOR_INDICATOR_CONSTRAINT_H_

ortools/math_opt/constraints/indicator/storage.h

@@ -19,6 +19,7 @@
 #include <string>
 #include <vector>
 
+#include "ortools/math_opt/elemental/elements.h"
 #include "ortools/math_opt/model.pb.h"
 #include "ortools/math_opt/model_update.pb.h"
 #include "ortools/math_opt/storage/atomic_constraint_storage.h"
@@ -34,6 +35,8 @@ struct IndicatorConstraintData {
   using IdType = IndicatorConstraintId;
   using ProtoType = IndicatorConstraintProto;
   using UpdatesProtoType = IndicatorConstraintUpdatesProto;
+  static constexpr ElementType kElementType = ElementType::kIndicatorConstraint;
+  static constexpr bool kSupportsElemental = true;
 
   // The `in_proto` must be in a valid state; see the inline comments on
   // `IndicatorConstraintProto` for details.
@@ -55,6 +58,8 @@ struct IndicatorConstraintData {
 template <>
 struct AtomicConstraintTraits<IndicatorConstraintId> {
   using ConstraintData = IndicatorConstraintData;
+  static constexpr ElementType kElementType = ElementType::kIndicatorConstraint;
+  static constexpr bool kSupportsElemental = true;
 };
 
 }  // namespace operations_research::math_opt

ortools/math_opt/constraints/quadratic/BUILD.bazel

@@ -22,7 +22,9 @@ cc_library(
         "//ortools/math_opt/constraints/util:model_util",
         "//ortools/math_opt/cpp:key_types",
         "//ortools/math_opt/cpp:variable_and_expressions",
+        "//ortools/math_opt/elemental:elements",
         "//ortools/math_opt/storage:model_storage",
+        "//ortools/math_opt/storage:model_storage_item",
         "//ortools/math_opt/storage:sparse_coefficient_map",
         "//ortools/math_opt/storage:sparse_matrix",
         "@abseil-cpp//absl/log:check",
@@ -54,6 +56,7 @@ cc_library(
         "//ortools/math_opt:model_cc_proto",
         "//ortools/math_opt:model_update_cc_proto",
         "//ortools/math_opt:sparse_containers_cc_proto",
+        "//ortools/math_opt/elemental:elements",
         "//ortools/math_opt/storage:atomic_constraint_storage",
         "//ortools/math_opt/storage:model_storage_types",
         "//ortools/math_opt/storage:sparse_coefficient_map",

ortools/math_opt/constraints/quadratic/quadratic_constraint.cc

@@ -26,7 +26,7 @@ namespace operations_research::math_opt {
 BoundedQuadraticExpression QuadraticConstraint::AsBoundedQuadraticExpression()
     const {
   QuadraticExpression expression;
-  const QuadraticConstraintData& data = storage()->constraint_data(id_);
+  const QuadraticConstraintData& data = storage()->constraint_data(typed_id());
   for (const auto [var, coeff] : data.linear_terms.terms()) {
     expression += coeff * Variable(storage(), var);
   }