Merge branch 'main' of github.com:google/or-tools

Author: lperron

ortools/algorithms/README.md

@@ -2,69 +2,6 @@
 
 This directory contains data structures and algorithms for various problems.
 
-## Set covering
-
-An instance of set covering is composed of two entities: elements and sets; sets
-cover a series of elements. The problem of set covering is about finding the
-cheapest combination of sets that cover all the elements.
-
-[More information on Wikipedia](https://en.wikipedia.org/wiki/Set_cover_problem).
-
-*   Solver: [`set_cover_heuristics.h`](set_cover_heuristics.h).
-*   Instance representation: [`set_cover_model.h`](set_cover_model.h).
-*   Instance parser: [`set_cover_reader.h`](set_cover_reader.h).
-
-Create an instance:
-
-```cpp
-// If the elements are integers, a subset can be a std::vector<int> (in a pair
-// along its cost).
-std::vector<std::pair<std::vector<int>, int>> subsets = ...;
-
-SetCoverModel model;
-for (const auto [subset, subset_cost] : subsets) {
-  model.AddEmptySubset(subset_cost)
-  for (const int element : subset) {
-    model.AddElementToLastSubset(element);
-  }
-}
-SetCoverLedger ledger(&model);
-```
-
-Solve it using a MIP solver (guarantees to yield the optimum solution if it has
-enough time to run):
-
-```cpp
-SetCoverMip mip(&ledger);
-mip.SetTimeLimitInSeconds(10);
-mip.NextSolution();
-SubsetBoolVector best_choices = ledger.GetSolution();
-LOG(INFO) << "Cost: " << ledger.cost();
-```
-
-A custom combination of heuristics (10,000 iterations of: clearing 10% of the
-variables, running a Chvatal greedy descent, using steepest local search):
-
-```cpp
-Cost best_cost = std::numeric_limits<Cost>::max();
-SubsetBoolVector best_choices = ledger.GetSolution();
-for (int i = 0; i < 10000; ++i) {
-  ledger.LoadSolution(best_choices);
-  ClearRandomSubsets(0.1 * model.num_subsets().value(), &ledger);
-
-  GreedySolutionGenerator greedy(&ledger);
-  CHECK(greedy.NextSolution());
-
-  SteepestSearch steepest(&ledger);
-  CHECK(steepest.NextSolution(10000));
-
-  EXPECT_TRUE(ledger.CheckSolution());
-  if (ledger.cost() < best_cost) {
-    best_cost = ledger.cost();
-    best_choices = ledger.GetSolution();
-    LOG(INFO) << "Better cost: " << best_cost << " at iteration = " << i;
-  }
-}
-ledger.LoadSolution(best_choices);
-LOG(INFO) << "Best cost: " << ledger.cost();
-```
+It used to contain a solver for set covering, which has moved to the
+[set_cover](../set_cover)
+folder.

ortools/julia/ORTools.jl/Project.toml

@@ -4,6 +4,7 @@ version = "1.0.0-DEV"
 
 [deps]
 MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee"
+ORTools_jll = "717719f8-c30c-5086-8f3c-70cd6a1e3a46"
 ORToolsGenerated = "6b269722-41d3-11ee-be56-0242ac120002"
 ProtoBuf = "3349acd9-ac6a-5e09-bcdb-63829b23a429"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

ortools/julia/ORTools.jl/src/ORTools.jl

@@ -1,5 +1,11 @@
 module ORTools
-# TODO: b/384496822 - Run formatter across entire package
+
+import MathOptInterface as MOI
+using ORTools_jll
+
+include("moi_wrapper/Type_wrappers.jl")
+include("c_wrapper/c_wrapper.jl")
 include("moi_wrapper/MOI_wrapper.jl")
 
+
 end

ortools/julia/ORTools.jl/src/c_wrapper/c_wrapper.jl

@@ -1,3 +1,5 @@
+using ORTools_jll
+
 libortools = ORTools_jll.libortools
 
 # Keep this file in sync with math_opt/core/c_api/solver.h.
@@ -6,54 +8,52 @@ libortools = ORTools_jll.libortools
 # on the Julia side, as it's only an opaque pointer for this API.
 
 function MathOptNewInterrupter()
-  return ccall((:MathOptNewInterrupter, libortools),
-               Ptr{Cvoid},
-               ())
+    return ccall((:MathOptNewInterrupter, libortools), Ptr{Cvoid}, ())
 end
 
 function MathOptFreeInterrupter(ptr)
-  return ccall((:MathOptFreeInterrupter, libortools),
-               Cvoid,
-               (Ptr{Cvoid},),
-               ptr)
+    return ccall((:MathOptFreeInterrupter, libortools), Cvoid, (Ptr{Cvoid},), ptr)
 end
 
 function MathOptInterrupt(ptr)
-  return ccall((:MathOptInterrupt, libortools),
-               Cvoid,
-               (Ptr{Cvoid},),
-               ptr)
+    return ccall((:MathOptInterrupt, libortools), Cvoid, (Ptr{Cvoid},), ptr)
 end
 
 function MathOptIsInterrupted(ptr)
-  return ccall((:MathOptIsInterrupted, libortools),
-               Cint,
-               (Ptr{Cvoid},),
-               ptr)
+    return ccall((:MathOptIsInterrupted, libortools), Cint, (Ptr{Cvoid},), ptr)
 end
 
 function MathOptFree(ptr)
-  return ccall((:MathOptFree, libortools),
-               Cvoid,
-               (Ptr{Cvoid},),
-               ptr)
+    return ccall((:MathOptFree, libortools), Cvoid, (Ptr{Cvoid},), ptr)
 end
 
-function MathOptSolve(model, model_size, solver_type, interrupter, solve_result, solve_result_size, status_msg)
-  return ccall((:MathOptSolve, libortools),
-               Cint,
-               (Ptr{Cvoid},
-                Csize_t,
-                Cint,
-                Ptr{Cvoid},
-                Ptr{Ptr{Cvoid}},
-                Ptr{Csize_t},
-                Ptr{Ptr{Cchar}}),
-               model,
-               model_size,
-               solver_type,
-               interrupter,
-               solve_result,
-               solve_result_size,
-               status_msg)
+function MathOptSolve(
+    model,
+    model_size,
+    solver_type,
+    interrupter,
+    solve_result,
+    solve_result_size,
+    status_msg,
+)
+    return ccall(
+        (:MathOptSolve, libortools),
+        Cint,
+        (
+            Ptr{Cvoid},
+            Csize_t,
+            Cint,
+            Ptr{Cvoid},
+            Ptr{Ptr{Cvoid}},
+            Ptr{Csize_t},
+            Ptr{Ptr{Cchar}},
+        ),
+        model,
+        model_size,
+        solver_type,
+        interrupter,
+        solve_result,
+        solve_result_size,
+        status_msg,
+    )
 end

ortools/julia/ORTools.jl/src/example.jl

@@ -0,0 +1,63 @@
+# TODO: b/407034730 - remove this file.
+import MathOptInterface as MOI
+include("ORTools.jl")
+
+"""
+Solving the following optimization problem:
+
+  max x + 2⋅y
+  
+  subject to: x + y ≤ 1.5
+              -1 ≤ x ≤ 1.5
+              0 ≤ y ≤ 1
+"""
+
+function main(ARGS)
+    optimizer = ORTools.Optimizer()
+    c = [1.0, 2.0]
+
+    # Variables definition
+    x = MOI.add_variables(optimizer, length(c))
+
+    # Set the objective
+    MOI.set(
+        optimizer,
+        MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}(),
+        MOI.ScalarAffineFunction(MOI.ScalarAffineTerm.(c, x), 0.0),
+    )
+
+    MOI.set(optimizer, MOI.ObjectiveSense(), MOI.MAX_SENSE)
+
+    # The first constraint (x + y <= 1.5)
+    C1 = 1.5
+    MOI.add_constraint(
+        optimizer,
+        MOI.ScalarAffineFunction(
+            [MOI.ScalarAffineTerm(1.0, x[1]), MOI.ScalarAffineTerm(1.0, x[2])],
+            0.0,
+        ),
+        MOI.LessThan(C1),
+    )
+
+    ## The second constraint (-1 <= x <= 1.5)
+    MOI.add_constraint(optimizer, MOI.VariableIndex(1), MOI.Interval(-1.0, 1.5))
+
+    ## The third constraint (0 <= y <= 1)
+    MOI.add_constraint(optimizer, MOI.VariableIndex(2), MOI.Interval(0.0, 1.0))
+
+    print(optimizer)
+
+    # Optimize the model
+    MOI.optimize!(optimizer)
+
+    # Print the solution
+    print(optimizer.solve_result)
+
+    return 0
+end
+
+# TODO: Understand why the solver stopped.
+# TODO: Understand what solution was returned.
+# TODO: Query the objective.
+# TODO: Query the primal solution.
+main(ARGS)