Consistency in order of properties

.github/workflows/ci.yml

@@ -11,9 +11,16 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        version: ['1.6', '1']
-        os: [ubuntu-latest, macOS-latest]
-        arch: [x64]
+        include:
+          - version: '1'
+            os: ubuntu-latest
+            arch: x64
+          - version: '1.6'
+            os: ubuntu-latest
+            arch: x64
+          - version: '1'
+            os: mac-latest
+            arch: x64
     steps:
       - uses: actions/checkout@v2
       - uses: julia-actions/setup-julia@v1

examples/nonlinear.jl

@@ -40,7 +40,7 @@ ubs = ones(n)
 
 sblmo = Boscia.CubeSimpleBLMO(lbs, ubs, int_vars)
 # wrap the sblmo into a bound manager
-lmo = Boscia.ManagedBoundedLMO(sblmo, lbs[int_vars], ubs[int_vars], n, int_vars)
+lmo = Boscia.ManagedBoundedLMO(sblmo, lbs[int_vars], ubs[int_vars], int_vars, n)
 
 const A = let
     A = randn(n, n)

examples/strong_branching_portfolio.jl

@@ -11,10 +11,9 @@ import HiGHS
 
 
 # For bug hunting:
-seed = rand(UInt64)
-@show seed
-#seed = 0xeadb922ca734998b  
-Random.seed!(seed)
+#seed = rand(UInt64)
+#@show seed
+#Random.seed!(seed)
 
 # TROUBLESOME SEED seed = 0x8750860d6fd5025f -> NEEDS TO BE CHECK AGAIN!
 

examples/worst-case.jl

@@ -53,7 +53,7 @@ n = 10
 
     sblmo = Boscia.CubeSimpleBLMO(lbs, ubs, int_vars)
     # wrap the sblmo into a bound manager
-    lmo = Boscia.ManagedBoundedLMO(sblmo, lbs[int_vars], ubs[int_vars], n, int_vars)
+    lmo = Boscia.ManagedBoundedLMO(sblmo, lbs[int_vars], ubs[int_vars], int_vars, n)
 
     function f(x)
         return 0.5 * sum((x .- diff_point) .^ 2)

src/interface.jl

@@ -134,7 +134,7 @@
     else
         @assert FrankWolfe.active_set_validate(active_set)
         for a in active_set.atoms
-            @assert is_linear_feasible(blmo.o, a)
+            @assert is_linear_feasible(blmo, a)
         end
         v = active_set.atoms[1]
     end

src/managed_blmo.jl

@@ -34,12 +34,12 @@ mutable struct ManagedBoundedLMO{SBLMO<:SimpleBoundableLMO} <: BoundedLinearMini
     simple_lmo::SBLMO
     lower_bounds::Vector{Float64}
     upper_bounds::Vector{Float64}
-    n::Int
     int_vars::Vector{Int}
+    n::Int
     solving_time::Float64
 end
 
-function ManagedBoundedLMO(simple_lmo, lb, ub, n, int_vars)
+function ManagedBoundedLMO(simple_lmo, lb, ub, int_vars::Vector{Int}, n::Int)
     if length(lb) != length(ub) || length(ub) != length(int_vars) || length(lb) != length(int_vars)
         error(
             "Supply lower and upper bounds for all integer variables. If there are no explicit bounds, set entry to Inf and -Inf, respectively. The entries have to match the entries of int_vars!",
@@ -50,7 +50,7 @@ function ManagedBoundedLMO(simple_lmo, lb, ub, n, int_vars)
         @assert isapprox(lb[i], round(lb[i]), atol=1e-6, rtol=1e-2)
         @assert isapprox(ub[i], round(ub[i]), atol=1e-6, rtol=1e-2)
     end
-    return ManagedBoundedLMO(simple_lmo, lb, ub, n, int_vars, 0.0)
+    return ManagedBoundedLMO(simple_lmo, lb, ub, int_vars, n, 0.0)
 end
 
 #ManagedBoundedLMO(simple_lmo, lb, ub, n, int_vars) = ManagedBoundedLMO(simple_lmo, lb, ub, n, int_vars, 0.0)
@@ -262,7 +262,7 @@ function solve(
     use_shadow_set=true,
     kwargs...,
 )
-    blmo = ManagedBoundedLMO(sblmo, lower_bounds, upper_bounds, n, int_vars)
+    blmo = ManagedBoundedLMO(sblmo, lower_bounds, upper_bounds, int_vars, n)
     return solve(
         f,
         grad!,

src/node.jl

@@ -300,7 +300,7 @@ function Bonobo.evaluate_node!(tree::Bonobo.BnBTree, node::FrankWolfeNode)
     elseif node.id == 1
         @debug "Lower bound of root node: $(lower_bound)"
         @debug "Current incumbent: $(tree.incumbent)"
-        @assert lower_bound <= tree.incumbent + 1e-5
+        @assert lower_bound <= tree.incumbent + 1e-5 "lower_bound <= tree.incumbent + 1e-5 : $(lower_bound) <= $(tree.incumbent)"
     end
 
     return lower_bound, NaN

test/LMO_test.jl

@@ -91,7 +91,7 @@ end
         ubs = ones(n)
 
         sblmo = Boscia.CubeSimpleBLMO(lbs, ubs, int_vars)
-        blmo = Boscia.ManagedBoundedLMO(sblmo, lbs[int_vars], ubs[int_vars], n, int_vars)
+        blmo = Boscia.ManagedBoundedLMO(sblmo, lbs[int_vars], ubs[int_vars], int_vars, n)
 
         branching_strategy = Boscia.PartialStrongBranching(10, 1e-3, blmo)
 
@@ -107,7 +107,7 @@ end
         ubs = ones(n)
 
         sblmo = Boscia.CubeSimpleBLMO(lbs, ubs, int_vars)
-        blmo = Boscia.ManagedBoundedLMO(sblmo, lbs[int_vars], ubs[int_vars], n, int_vars)
+        blmo = Boscia.ManagedBoundedLMO(sblmo, lbs[int_vars], ubs[int_vars], int_vars, n)
 
         function perform_strong_branch(tree, node)
             return node.level <= length(tree.root.problem.integer_variables) / 3