julia: backport from main

Author: Mizux

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)