Update to IntervalArithmetic v0.22 (#71)

Author: OlivierHnt

.github/workflows/CI.yml

@@ -29,7 +29,7 @@ jobs:
         with:
           version: ${{ matrix.version }}
           arch: ${{ matrix.arch }}
-      - uses: actions/cache@v1
+      - uses: actions/cache@v4
         env:
           cache-name: cache-artifacts
         with:

NEWS.md

@@ -1,13 +1,13 @@
 name = "IntervalOptimisation"
 uuid = "c7c68f13-a4a2-5b9a-b424-07d005f8d9d2"
-version = "0.4.6"
+version = "0.5.0"
 
 [deps]
 IntervalArithmetic = "d1acc4aa-44c8-5952-acd4-ba5d80a2a253"
 
 [compat]
-IntervalArithmetic = "0.15, 0.16, 0.17, 0.18, 0.19, 0.20"
-julia = "1.0"
+IntervalArithmetic = "0.22"
+julia = "1.9"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

Project.toml

@@ -1,91 +1,70 @@
-# `IntervalOptimisation.jl`
+<h1 align="center">
+IntervalOptimisation
 
-[![github badge][gh_badge]][gh_url]
-[![doc badge][doc_badge]][doc_url]
-[![codecov badge][codecov_badge]][codecov_url]
+[![Stable](https://img.shields.io/badge/docs-stable-blue.svg)](https://juliaintervals.github.io/IntervalOptimisation.jl/stable)
+[![Build Status](https://github.com/JuliaIntervals/IntervalOptimisation.jl/workflows/CI/badge.svg)](https://github.com/JuliaIntervals/IntervalOptimisation.jl/actions/workflows/CI.yml)
+[![coverage](https://codecov.io/gh/JuliaIntervals/IntervalOptimisation.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/JuliaIntervals/IntervalOptimisation.jl)
+</h1>
 
-[gh_badge]: https://github.com/JuliaIntervals/IntervalOptimisation.jl/workflows/CI/badge.svg
-[gh_url]: https://github.com/JuliaIntervals/IntervalOptimisation.jl/actions/workflows/CI.yml
-
-
-[codecov_badge]: http://codecov.io/github/JuliaIntervals/IntervalOptimisation.jl/coverage.svg?branch=master
-[codecov_url]: http://codecov.io/github/JuliaIntervals/IntervalOptimisation.jl?branch=master
-
-[doc_badge]: https://img.shields.io/badge/docs-stable-blue.svg
-[doc_url]: https://juliaintervals.github.io/pages/packages/intervaloptimisation/
-
-
-## Rigorous global optimisation using Julia
-
-This package provides rigorous global optimisation routines written in pure Julia, using interval arithmetic provided by the author's [IntervalArithmetic.jl](https://github.com/JuliaIntervals/IntervalArithmetic.jl) package.
+IntervalOptimisation.jl is a Julia package for rigorous global optimisation routines, using interval arithmetic provided by the [IntervalArithmetic.jl](https://github.com/JuliaIntervals/IntervalArithmetic.jl) package.
 
 Currently, the package uses an implementation of the Moore-Skelboe algorithm.
 
 ## Documentation
-Documentation for the package is available [here][doc_url].
 
-The best way to learn how to use the package is to look at the tutorial, available in the organisation webpage [here](https://juliaintervals.github.io/pages/tutorials/tutorialOptimisation/).
+The official documentation is available online: https://juliaintervals.github.io/IntervalOptimisation.jl/stable.
 
-## Usage  
+## Usage
 
-Functions `minimise` and `maximise` are provided to find the **global** minimum or maximum, respectively, of a standard Julia function `f` of one or several variables.
+Functions `minimise` and `maximise` are provided to find the **global** minimum or maximum, respectively, of a function `f` of one or several variables.
 
-They return an `Interval` that is guaranteed to contain the global minimum (maximum), and a `Vector` of `Interval`s or `IntervalBox`es whose union contains all the minimisers.
+They return an `Interval` that is guaranteed to contain the global minimum (maximum), and a `Vector` of `Interval`s whose union contains all the minimisers.
 
 ### Examples
 
 #### 1D
+
 ```julia
 using IntervalArithmetic, IntervalOptimisation
 
-julia> @time global_min, minimisers = minimise(x -> (x^2 - 2)^2, -10..11);
-  0.046620 seconds (36.07 k allocations: 1.586 MiB)
+julia> global_min, minimisers = minimise(x -> (x^2 - interval(2))^2, interval(-10, 11));
 
 julia> global_min
-[0, 1.50881e-09]
+[0, 1.50881e-09]_com
 
 julia> minimisers
-2-element Array{IntervalArithmetic.Interval{Float64},1}:
-  [1.41387, 1.41453]
- [-1.41428, -1.41363]
+2-element Vector{Interval{Float64}}:
+ [-1.41428, -1.41363]_com
+  [1.41387, 1.41453]_com
 ```
 
 #### 2D
 
 ```julia
-julia> @time global_min, minimisers = minimise(  X -> ( (x,y) = X; x^2 + y^2 ),
-                                                        (-10000..10001) × (-10000..10001) );
-  0.051122 seconds (46.80 k allocations: 2.027 MiB)
+julia> global_min, minimisers = minimise(X -> ( (x,y) = X; x^2 + y^2 ), [interval(-10000, 10001), interval(-10000, 10001)]);
 
 julia> global_min
-[0, 2.33167e-08]
+[0.0, 3.63963e-08]_com
 
 julia> minimisers
-3-element Array{IntervalArithmetic.IntervalBox{2,Float64},1}:
- [-0.000107974, 0.000488103] × [-0.000107974, 0.000488103]
- [-0.000107974, 0.000488103] × [-0.000704051, -0.000107973]
- [-0.000704051, -0.000107973] × [-0.000107974, 0.000488103]
+3-element Vector{Vector{Interval{Float64}}}:
+ [[-0.000412491, 0.00014269]_com, [-0.000412491, 0.00014269]_com]
+ [[-0.000412491, 0.00014269]_com, [0.000142689, 0.000706613]_com]
+ [[0.000142689, 0.000706613]_com, [-0.000412491, 0.00014269]_com]
 ```
-Note that the last two `IntervalBox`es do not actually contain the global minimum;
+
+Note that the last two `Vector` of `Interval`s do not actually contain the global minimum;
 decreasing the tolerance (maximum allowed box diameter) removes them:
 
 ```
-julia> @time global_min, minimisers = minimise(  X -> ( (x,y) = X; x^2 + y^2 ),
-                                                               (-10000..10001) × (-10000..10001), 1e-5 );
-  0.047196 seconds (50.72 k allocations: 2.180 MiB)
+julia> global_min, minimisers = minimise(X -> ( (x,y) = X; x^2 + y^2 ), [interval(-10000, 10001), interval(-10000, 10001)]; tol = 1e-8);
 
 julia> minimisers
-1-element Array{IntervalArithmetic.IntervalBox{2,Float64},1}:
- [-5.52321e-06, 3.79049e-06] × [-5.52321e-06, 3.79049e-06]
+1-element Vector{Vector{Interval{Float64}}}:
+ [[-4.74512e-09, 4.41017e-09]_com, [-4.74512e-09, 4.41017e-09]_com]
  ```
 
-## Author
-
-- [David P. Sanders](http://sistemas.fciencias.unam.mx/~dsanders),
-Departamento de Física, Facultad de Ciencias, Universidad Nacional Autónoma de México (UNAM)
-
-
-## References:
+## References
 
 - *Validated Numerics: A Short Introduction to Rigorous Computations*, W. Tucker, Princeton University Press (2010)
 
@@ -94,6 +73,3 @@ Departamento de Física, Facultad de Ciencias, Universidad Nacional Autónoma de
 - van Emden M.H., Moa B. (2004). Termination Criteria in the Moore-Skelboe Algorithm for Global Optimization by Interval Arithmetic. In: Floudas C.A., Pardalos P. (eds), *Frontiers in Global Optimization. Nonconvex Optimization and Its Applications*, vol. 74. Springer, Boston, MA. [Preprint](http://webhome.cs.uvic.ca/~vanemden/Publications/mooreSkelb.pdf)
 
 - H. Ratschek and J. Rokne, [*New Computer Methods for Global Optimization*](http://pages.cpsc.ucalgary.ca/~rokne/global_book.pdf)
-
-## Acknowledements
-Financial support is acknowledged from DGAPA-UNAM PAPIIT grant IN-117117.

README.md

@@ -1,4 +1,5 @@
 using IntervalArithmetic, IntervalOptimisation
+using IntervalArithmetic.Symbols
 
 G(X) = 1 + sum(abs2, X) / 4000 - prod( cos(X[i] / √i) for i in 1:length(X) )
 
@@ -7,6 +8,6 @@ G(X) = 1 + sum(abs2, X) / 4000 - prod( cos(X[i] / √i) for i in 1:length(X) )
 
 for N in (10, 30, 50)
     @show N
-    @time minimise(G, IntervalBox(-600..600, N))
-    @time minimise(G, IntervalBox(-600..600, N))
+    @time minimise(G, fill(-600..600, N))
+    @time minimise(G, fill(-600..600, N))
 end

examples/griewank.jl

@@ -1,5 +1,18 @@
-numeric_type(::Interval{T}) where {T} = T
-numeric_type(::IntervalBox{N, T}) where {N, T} = T
+numeric_type(x::Interval) = IntervalArithmetic.numtype(x)
+numeric_type(v::AbstractVector{<:Interval}) = mapreduce(IntervalArithmetic.numtype, IntervalArithmetic.promote_numtype, v)
+
+_bisect(X::Interval) = bisect(X, 0.49609375)
+
+function _bisect(X::AbstractVector{<:Interval}) # bisect along the largest dimension
+    i = argmax(diam.(X)) # find longest side
+
+    x1, x2 = _bisect(X[i])
+
+    X1 = copy(X); X1[i] = x1
+    X2 = copy(X); X2[i] = x2
+
+    return (X1, X2)
+end
 
 """
     minimise(f, X, structure = SortedVector, tol=1e-3)
@@ -8,7 +21,7 @@ numeric_type(::IntervalBox{N, T}) where {N, T} = T
     or
     minimise(f, X, tol=1e-3) in this case the default value of "structure" is "HeapedVector"
 
-Find the global minimum of the function `f` over the `Interval` or `IntervalBox` `X`
+Find the global minimum of the function `f` over the `Interval` or `AbstractVector{<:Interval}` `X`
 using the Moore-Skelboe algorithm. The way in which vector elements are
 kept arranged can be either a heaped array or a sorted array.
 If you not specify any particular strategy to keep vector elements arranged then
@@ -20,11 +33,11 @@ Returns an interval containing the global minimum, and a list of boxes that cont
 """
 function minimise(f, X::T; structure = HeapedVector, tol=1e-3) where {T}
     nT = numeric_type(X)
-    
+
     # list of boxes with corresponding lower bound, arranged according to selected structure :
-    working = structure([(X, nT(∞))], x->x[2])
+    working = structure([(X, nT(Inf))], x->x[2])
     minimizers = T[]
-    global_min = nT(∞)  # upper bound
+    global_min = nT(Inf)  # upper bound
 
     num_bisections = 0
 
@@ -37,19 +50,19 @@ function minimise(f, X::T; structure = HeapedVector, tol=1e-3) where {T}
         end
 
         # find candidate for upper bound of global minimum by just evaluating a point in the interval:
-        m = sup(f(Interval.(mid.(X))))   # evaluate at midpoint of current interval
+        m = sup(f(interval.(mid.(X))))   # evaluate at midpoint of current interval
 
         if m < global_min
             global_min = m
         end
 
         # Remove all boxes whose lower bound is greater than the current one:
-        filter_elements!(working , (X, global_min) )
+        filter_elements!(working, (X, global_min))
 
-        if diam(X) < tol
+        if maximum(diam, X) < tol
             push!(minimizers, X)
         else
-            X1, X2 = bisect(X)
+            X1, X2 = _bisect(X)
             push!( working, (X1, inf(f(X1))) )
             push!( working, (X2, inf(f(X2))) )
             num_bisections += 1
@@ -59,7 +72,7 @@ function minimise(f, X::T; structure = HeapedVector, tol=1e-3) where {T}
 
     lower_bound = minimum(inf.(f.(minimizers)))
 
-    return Interval(lower_bound, global_min), minimizers
+    return interval(lower_bound, global_min), minimizers
 end
 
 """
@@ -69,7 +82,7 @@ end
     or
     maximise(f, X, tol=1e-3) in this case the default value of "structure" is "HeapedVector"
 
-Find the global maximum of the function `f` over the `Interval` or `IntervalBox` `X`
+Find the global maximum of the function `f` over the `Interval` or `AbstractVector{<:Interval}` `X`
 using the Moore-Skelboe algorithm. See [`minimise`](@ref) for a description
 of the available options.
 """