julia: export from google3

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)

ortools/julia/ORTools.jl/src/moi_wrapper/MOI_wrapper.jl

@@ -1,6 +1,3 @@
-import MathOptInterface as MOI
-include("Type_wrappers.jl")
-
 const PARAM_SPLITTER = "__"
 const PARAM_FIELD_NAME_TO_INSTANCE_DICT = Dict(
     "gscip" => GScipParameters(),
@@ -53,6 +50,10 @@ mutable struct Optimizer <: MOI.AbstractOptimizer
     # Indicator of whether an objective has been set
     objective_set::Bool
 
+    # Store solve results
+    # This structure is update after running the optimize! function
+    solve_result::Union{SolveResultProto,Nothing}
+
     # Constructor with optional parameters
     function Optimizer(;
         model_name::String = "",
@@ -81,6 +82,7 @@ mutable struct Optimizer <: MOI.AbstractOptimizer
             Set{Tuple{Type,Type}}(),
             constraint_indices_dict,
             false,
+            nothing,
         )
     end
 end
@@ -103,6 +105,7 @@ function MOI.empty!(model::Optimizer)
     model.constraint_types_present = Set{Tuple{Type,Type}}()
     model.constraint_indices_dict = Dict()
     model.objective_set = false
+    model.solve_result = nothing
 
     return nothing
 end
@@ -111,7 +114,8 @@ function MOI.is_empty(model::Optimizer)
     return isnothing(model.model) &&
            isnothing(model.parameters) &&
            model.solver_type == SolverType.SOLVER_TYPE_UNSPECIFIED &&
-           !model.objective_set
+           !model.objective_set &&
+           isnothing(model.solve_result)
 end
 
 """
@@ -1166,20 +1170,21 @@ end
 # Helper function to create a dictionary of terms to combine coefficients 
 # of terms(variables) if they are repeated.
 # For example: 3x + 5x <= 10 will be combined to 8x <= 10.
-function get_terms_dict(
+function get_terms_pairs(
     terms::Vector{MOI.ScalarAffineTerm{T}},
-)::Dict{Int64,Float64} where {T<:Real}
-    terms_dict = Dict{Int64,Float64}()
+)::Vector{Pair{Int64,Float64}} where {T<:Real}
+    terms_pairs = Dict{Int64,Float64}()
 
     for term in terms
-        if !haskey(terms_dict, term.variable.value)
-            terms_dict[term.variable.value] = term.coefficient
+        if !haskey(terms_pairs, term.variable.value)
+            terms_pairs[term.variable.value] = term.coefficient
         else
-            terms_dict[term.variable.value] += term.coefficient
+            terms_pairs[term.variable.value] += term.coefficient
         end
     end
 
-    return terms_dict
+    sorted_pairs = sort(collect(terms_pairs), by = x -> x[1])
+    return sorted_pairs
 end
 
 function MOI.add_constraint(
@@ -1204,17 +1209,17 @@ function MOI.add_constraint(
         push!(model.model.linear_constraints.upper_bounds, upper_bound)
         push!(model.model.linear_constraints.names, "")
 
-        terms_dict = get_terms_dict(terms)
+        terms_pairs = get_terms_pairs(terms)
 
         # Update the LinearConstaintMatrix (SparseDoubleVectorProto)
         # linear_constraint_matrix.row_ids are elements of linear_constraints.ids.
         # linear_constraint_matrix.column_ids are elements of variables.ids.
         # Matrix entries not specified are zero.
         # linear_constraint_matrix.coefficients must all be finite.
-        for term_index in keys(terms_dict)
+        for term_index in terms_pairs
             push!(model.model.linear_constraint_matrix.row_ids, constraint_index)
-            push!(model.model.linear_constraint_matrix.column_ids, term_index)
-            push!(model.model.linear_constraint_matrix.coefficients, terms_dict[term_index])
+            push!(model.model.linear_constraint_matrix.column_ids, term_index[1])
+            push!(model.model.linear_constraint_matrix.coefficients, term_index[2])
         end
 
         # Update the associated metadata.
@@ -1316,7 +1321,7 @@ end
 function MOI.get(
     model::Optimizer,
     ::MOI.ConstraintFunction,
-    c::MOI.ConstraintIndex{MOI.VariableIndex,Any},
+    c::MOI.ConstraintIndex{MOI.VariableIndex,<:Any},
 )
     if !MOI.is_empty(model)
         return MOI.VariableIndex(c.value)
@@ -1406,12 +1411,12 @@ function MOI.set(
         )
     end
 
-    terms_dict = get_terms_dict(terms)
+    terms_pairs = get_terms_pairs(terms)
 
-    for term_index in keys(terms_dict)
+    for term_index in terms_pairs
         push!(model.model.linear_constraint_matrix.row_ids, c.value)
-        push!(model.model.linear_constraint_matrix.column_ids, term_index)
-        push!(model.model.linear_constraint_matrix.coefficients, terms_dict[term_index])
+        push!(model.model.linear_constraint_matrix.column_ids, term_index[1])
+        push!(model.model.linear_constraint_matrix.coefficients, term_index[2])
     end
 
     return nothing
@@ -1810,11 +1815,11 @@ function MOI.set(
 
     terms = objective_function.terms
 
-    terms_dict = get_terms_dict(terms)
+    terms_pairs = get_terms_pairs(terms)
 
-    for term in keys(terms_dict)
-        push!(model.model.objective.linear_coefficients.ids, term)
-        push!(model.model.objective.linear_coefficients.values, terms_dict[term])
+    for term in terms_pairs
+        push!(model.model.objective.linear_coefficients.ids, term[1])
+        push!(model.model.objective.linear_coefficients.values, term[2])
     end
 
     model.model.objective.offset = Float64(objective_function.constant)
@@ -1880,6 +1885,42 @@ function MOI.supports(
 end
 
 function MOI.optimize!(model::Optimizer)
-    # TODO: b/384662497 implement this
+    status_msg = Ref(pointer(zeros(Int8, 1)))
+
+    # Serialize the model
+    io = IOBuffer()
+    e = PB.ProtoEncoder(io)
+    PB.encode(e, to_proto_struct(model.model))
+    model_proto = take!(io)
+    model_size = encoded_model_size(model.model)[1]
+
+    # Result proto with its accompanying size
+    solve_result_proto = Ref{Ptr{Cvoid}}()
+    result_size = Ref{Csize_t}(0)
+
+    result = MathOptSolve(
+        model_proto,
+        model_size,
+        Int(model.solver_type),
+        MathOptNewInterrupter(),
+        solve_result_proto,
+        result_size,
+        status_msg,
+    )
+
+    # A non-null status_msg indicates a failure in executing the solve call.
+    if status_msg[] != C_NULL
+        failure_status_message = unsafe_string(status_msg[])
+        # TODO: b/407544202 - Add error to SolveResult instead of printing it.
+        @error "The following failure was encountered when executing the solve call: $failure_status_message"
+        return
+    end
+
+    solve_result_proto =
+        unsafe_wrap(Vector{UInt8}, Ptr{UInt8}(solve_result_proto[]), result_size[])
+    io = IOBuffer(solve_result_proto)
+    d = PB.ProtoDecoder(io)
+    model.solve_result = PB.decode(d, SolveResultProto)
+
     return nothing
 end

ortools/julia/ORTools.jl/src/moi_wrapper/Type_wrappers.jl

@@ -2,6 +2,8 @@ using ORToolsGenerated
 const OperationsResearch = ORToolsGenerated.Proto.operations_research
 const MathOpt = OperationsResearch.math_opt
 const SolverType = MathOpt.SolverTypeProto
+const SolveResultProto = MathOpt.SolveResultProto
+const PB = MathOpt.PB
 
 """
 Given the nature of the fields, we are using an alias for the VariablesProto struct.
@@ -379,11 +381,11 @@ function to_proto_struct(model::Model)::MathOpt.ModelProto
 
     return MathOpt.ModelProto(
         model.name,
-        to_proto_struct(model.variables),
+        model.variables,
         to_proto_struct(model.objective),
         auxiliary_objectives,
-        to_proto_struct(model.linear_constraints),
-        to_proto_struct(model.linear_constraint_matrix),
+        model.linear_constraints,
+        model.linear_constraint_matrix,
         quadratic_constraints,
         second_order_cone_constraints,
         sos1_constraints,
@@ -392,6 +394,9 @@ function to_proto_struct(model::Model)::MathOpt.ModelProto
     )
 end
 
+# The size of the encoded model
+encoded_model_size(model::Model) = PB._encoded_size(to_proto_struct(model))
+
 """
   Mutable wrapper struct for the GscipParameters struct.
 """