Update IntervalArithmetic and ForwardDiff dependencies (#73)

- Update `IntervalArithmetic` and `ForwardDiff` dependencies to v1.0
- Change `NaN` behavior of `MC` objects to use intervals from `IntervalArithmetic`

Author: DimitriAlston

.github/workflows/ci.yml

@@ -7,46 +7,30 @@ on:
     branches:
       - master
     tags: '*'
+permissions:
+  actions: write
+  contents: read
 jobs:
   test:
     name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }} - ${{ github.event_name }}
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
-
-        include:
-          - version: '1.6'
-            os: ubuntu-latest
-            arch: x64
-          - version: '1.6'
-            os: windows-latest
-            arch: x64
-          - version: '1.9'
-            os: ubuntu-latest
-            arch: x64
-          - version: '1.9'
-            os: windows-latest
-            arch: x64
+        version: ['1.10', '1']
+        os: [ubuntu-latest, windows-latest]
+        arch: [x64]
     steps:
-      - uses: actions/checkout@v2
-      - uses: julia-actions/setup-julia@v1
+      - uses: actions/checkout@v4
+      - uses: julia-actions/setup-julia@v2
         with:
           version: ${{ matrix.version }}
           arch: ${{ matrix.arch }}
-      - uses: actions/cache@v4
-        env:
-          cache-name: cache-artifacts
-        with:
-          path: ~/.julia/artifacts
-          key: ${{ runner.os }}-test-${{ env.cache-name }}-${{ hashFiles('**/Project.toml') }}
-          restore-keys: |
-            ${{ runner.os }}-test-${{ env.cache-name }}-
-            ${{ runner.os }}-test-
-            ${{ runner.os }}-
+      - uses: julia-actions/cache@v1
       - uses: julia-actions/julia-buildpkg@v1
       - uses: julia-actions/julia-runtest@v1
       - uses: julia-actions/julia-processcoverage@v1
-      - uses: codecov/codecov-action@v1
+      - uses: codecov/codecov-action@v5
         with:
-          file: lcov.info
+          files: lcov.info
+          token: ${{ secrets.CODECOV_TOKEN }}

Project.toml

@@ -1,7 +1,7 @@
 name = "McCormick"
 uuid = "53c679d3-6890-5091-8386-c291e8c8aaa1"
 authors = ["Matthew Wilhelm <matthew.wilhelm@uconn.edu>"]
-version = "0.13.11"
+version = "0.14.0"
 
 [deps]
 DiffRules = "b552c78f-8df3-52c6-915a-8e097449b14b"
@@ -20,16 +20,16 @@ UnPack = "3a884ed6-31ef-47d7-9d2a-63182c4928ed"
 [compat]
 DiffRules = "1.5"
 DocStringExtensions = "~0.8, ~0.9"
-ForwardDiff = "~0.10"
-IntervalArithmetic = "~0.20"
-IntervalRootFinding = "~0.5"
+ForwardDiff = "1"
+IntervalArithmetic = "1"
+IntervalRootFinding = "~0.6"
 NaNMath = "0.3.5, 1.0"
 NNlib = "~0.8, ~0.9"
 Reexport = "~0.2, ~1"
 StaticArrays = "~1"
 SpecialFunctions = "~1, ~2"
 UnPack = "~1"
-julia = "1.6"
+julia = "1.10"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

README.md

@@ -62,7 +62,7 @@ using McCormick
 f(x) = x*(x - 5.0)*sin(x)
 
 x = 2.0                          # Value of independent variable x
-Intv = Interval(1.0, 4.0)        # Define interval to relax over
+Intv = interval(1.0, 4.0)        # Define interval to relax over
                                  # Note that McCormick.jl reexports IntervalArithmetic.jl
                                  # and StaticArrays. So no using statement for these is
                                  # necessary.
@@ -104,10 +104,10 @@ f(x, y) = (4.0 - 2.1*x^2 + (x^4)/6.0)*x^2 + x*y + (-4.0 + 4.0*y^2)*y^2
 
 # Define intervals for independent variables
 n = 30
-X = Interval{Float64}(-2, 0)
-Y = Interval{Float64}(-0.5, 0.5)
-xrange = range(X.lo, stop=X.hi, length=n)
-yrange = range(Y.lo, stop=Y.hi, length=n)
+X = interval(-2, 0)
+Y = interval(-0.5, 0.5)
+xrange = range(X.bareinterval.lo, stop=X.bareinterval.hi, length=n)
+yrange = range(Y.bareinterval.lo, stop=Y.bareinterval.hi, length=n)
 
 # Calculate differentiable McCormick relaxation
 for (i,x) in enumerate(xrange)

src/McCormick.jl

@@ -32,24 +32,16 @@ import NNlib: relu, selu, leakyrelu, sigmoid, swish, gelu, elu, softsign, logcos
 
 using IntervalArithmetic
 using IntervalArithmetic: @round
-if isdefined(IntervalArithmetic, :big53)
-    big_val(x) = IntervalArithmetic.big53(x)
-else
-    big_val(x) = IntervalArithmetic.bigequiv(x)
-end
 
 using IntervalRootFinding
-import IntervalArithmetic: dist, mid, pow, +, -, *, /, convert, in, isempty,
+import IntervalArithmetic: dist, mid, pow, +, -, *, /, convert,
                            one, zero, real, eps, max, min, abs, exp,
-                           expm1, log, log2, log10, log1p, sqrt, ^,
-                           sin, cos, tan, min, max, sec, csc, cot, step, sech,
-                           csch, coth, acsch, acoth, asech,
-                           sign, dist, mid, pow, Interval, interval, sinh, cosh,
-                           ∩, IntervalBox, bisect, isdisjoint, length,
-                           atan, asin, acos, AbstractInterval, atomic,
-                           sind, cosd, tand, asind, acosd, atand,
-                           secd, cscd, cotd, asecd, acscd, acotd, half_pi,
-                           setrounding, diam, isthin, abs2
+                           expm1, log, log2, log10, log1p, sqrt, ^, sin,
+                           cos, tan, min, max, sec, csc, cot, step, sech,
+                           csch, coth, acsch, acoth, asech, sign, dist, mid,
+                           pow, interval, sinh, cosh, length, atan, asin, acos,
+                           atomic, sind, cosd, tand, asind, acosd, atand, secd, cscd,
+                           cotd, asecd, acscd, acotd, setrounding, diam, isthin, abs2
 
 import SpecialFunctions: erf, erfc, erfinv, erfcinv
 export erf, erfinv, erfc, erfcinv, erf_kernel, erfinv_kernel, erfc_kernel, erfcinv_kernel
@@ -134,18 +126,6 @@ const MC_MV_TOL = 1E-8
 const MC_DEGEN_TOL = 1E-14
 const MC_DOMAIN_TOL = 1E-10
 
-const IntervalConstr = interval
-const Half64 = Float64(0.5)
-const Two64 = Float64(2.0)
-const Three64 = Float64(3.0)
-const EqualityTolerance = Float64(1E-12)
-const DegToRadIntv = atomic(Interval{Float64}, pi)/Interval(180.0)
-const one_intv = one(Interval{Float64})
-const half_intv = Interval{Float64}(0.5)
-const two_intv = Interval{Float64}(2.0)
-const log2_intv = log(Interval{Float64}(2.0))
-const log10_intv = log(Interval{Float64}(10.0))
-
 const NumberNotRelax = Union{Bool, Float16, Float32, Signed, Unsigned, BigFloat,
                              Int8, Int64, Int32, Int16, Int128}
 
@@ -289,14 +269,14 @@ function cut(xL::Float64, xU::Float64, cv::Float64, cc::Float64,
     return cvo, cco, cv_grado, cc_grado
 end
 
-lo(x::Interval{Float64}) = x.lo
-hi(x::Interval{Float64}) = x.hi
+lo(x::Interval{Float64}) = x.bareinterval.lo
+hi(x::Interval{Float64}) = x.bareinterval.hi
 
 function step(x::Interval{Float64})
-     isempty(x) && return emptyinterval(x)
-     xmin::Float64 = ((x.lo) < 0.0) ? 0.0 : 1.0
-     xmax::Float64 = ((x.hi) >= 0.0) ? 1.0 : 0.0
-     return Interval{Float64}(xmin,xmax)
+     isempty_interval(x) && return x
+     xmin::Float64 = ((x.bareinterval.lo) < 0.0) ? 0.0 : 1.0
+     xmax::Float64 = ((x.bareinterval.hi) >= 0.0) ? 1.0 : 0.0
+     return interval(xmin, xmax)
 end
 
 
@@ -333,11 +313,11 @@ end
 """
 MC{N,T}(y::Interval{Float64})
 
-Constructs a McCormick relaxation with the convex relaxation equal to `y.lo` and
-concave relaxation equal to `y.hi`.
+Constructs a McCormick relaxation with the convex relaxation equal to `y.bareinterval.lo` and
+concave relaxation equal to `y.bareinterval.hi`.
 """
 function MC{N,T}(y::Interval{Float64}) where {N, T <: RelaxTag}
-    MC{N,T}(y.lo, y.hi, y, zero(SVector{N,Float64}),
+    MC{N,T}(y.bareinterval.lo, y.bareinterval.hi, y, zero(SVector{N,Float64}),
                            zero(SVector{N,Float64}), true)
 end
 
@@ -347,11 +327,11 @@ MC{N,T}(y::Float64)
 Constructs a McCormick relaxation with the convex relaxation equal to `y` and
 concave relaxation equal to `y`.
 """
-MC{N,T}(y::Float64) where {N, T <: RelaxTag} = MC{N,T}(Interval{Float64}(y))
+MC{N,T}(y::Float64) where {N, T <: RelaxTag} = MC{N,T}(interval(y))
 function MC{N,T}(y::Y) where {N, T <: RelaxTag, Y <: AbstractIrrational}
-    MC{N,T}(Interval{Float64}(y))
+    MC{N,T}(interval(y))
 end
-MC{N,T}(y::Q) where {N, T <: RelaxTag, Q <: NumberNotRelax} = MC{N,T}(Interval{Float64}(y))
+MC{N,T}(y::Q) where {N, T <: RelaxTag, Q <: NumberNotRelax} = MC{N,T}(interval(y))
 
 """
 MC{N,T}(cv::Float64, cc::Float64)
@@ -360,7 +340,7 @@ Constructs a McCormick relaxation with the convex relaxation equal to `cv` and
 concave relaxation equal to `cc`.
 """
 function MC{N,T}(cv::Float64, cc::Float64) where {N, T <: RelaxTag}
-    MC{N,T}(cv, cc, Interval{Float64}(cv, cc), zero(SVector{N,Float64}),
+    MC{N,T}(cv, cc, interval(cv, cc), zero(SVector{N,Float64}),
                                                zero(SVector{N,Float64}), true)
 end
 MC{N,T}(cv::Q, cc::R) where {N, T <: RelaxTag, Q <: NumberNotRelax, R <: NumberNotRelax} = MC{N,T}(Float64(cv), Float64(cc))
@@ -393,8 +373,8 @@ function MC{N,T}(x::MC{N,T}) where {N, T <: RelaxTag}
 end
 
 Intv(x::MC) = x.Intv
-lo(x::MC) = x.Intv.lo
-hi(x::MC) = x.Intv.hi
+lo(x::MC) = x.Intv.bareinterval.lo
+hi(x::MC) = x.Intv.bareinterval.hi
 cc(x::MC) = x.cc
 cv(x::MC) = x.cv
 cc_grad(x::MC) = x.cc_grad
@@ -407,8 +387,8 @@ isthin(x::MC) = isthin(x.Intv)
 
 function isone(x::MC)
     flag = true
-    flag &= (x.Intv.lo == 1.0)
-    flag &= (x.Intv.hi == 1.0)
+    flag &= (x.Intv.bareinterval.lo == 1.0)
+    flag &= (x.Intv.bareinterval.hi == 1.0)
     flag &= x.cnst
     return flag
 end
@@ -453,11 +433,11 @@ end
 """
 MCNoGrad(y::Interval{Float64})
 
-Constructs McCormick relaxation with convex relaxation equal to `y.lo` and
-concave relaxation equal to `y.hi`.
+Constructs McCormick relaxation with convex relaxation equal to `y.bareinterval.lo` and
+concave relaxation equal to `y.bareinterval.hi`.
 """
 function MCNoGrad(y::Interval{Float64})
-    MCNoGrad(y.lo, y.hi, y, true)
+    MCNoGrad(y.bareinterval.lo, y.bareinterval.hi, y, true)
 end
 
 """
@@ -466,11 +446,11 @@ MCNoGrad(y::Float64)
 Constructs McCormick relaxation with convex relaxation equal to `y` and
 concave relaxation equal to `y`.
 """
-MCNoGrad(y::Float64) = MCNoGrad(Interval{Float64}(y))
+MCNoGrad(y::Float64) = MCNoGrad(interval(y))
 function MCNoGrad(y::Y) where Y <: AbstractIrrational
-    MCNoGrad(Interval{Float64}(y))
+    MCNoGrad(interval(y))
 end
-MCNoGrad(y::Q) where Q <: NumberNotRelax = MCNoGrad(Interval{Float64}(y))
+MCNoGrad(y::Q) where Q <: NumberNotRelax = MCNoGrad(interval(y))
 
 """
 MCNoGrad(cv::Float64, cc::Float64)
@@ -479,12 +459,12 @@ Constructs McCormick relaxation with convex relaxation equal to `cv` and
 concave relaxation equal to `cc`.
 """
 function MCNoGrad(cv::Float64, cc::Float64)
-    MC{N,T}(cv, cc, Interval{Float64}(cv, cc), true)
+    MC{N,T}(cv, cc, interval(cv, cc), true)
 end
 
 Intv(x::MCNoGrad) = x.Intv
-lo(x::MCNoGrad) = x.Intv.lo
-hi(x::MCNoGrad) = x.Intv.hi
+lo(x::MCNoGrad) = x.Intv.bareinterval.lo
+hi(x::MCNoGrad) = x.Intv.bareinterval.hi
 cc(x::MCNoGrad) = x.cc
 cv(x::MCNoGrad) = x.cv
 cnst(x::MCNoGrad) = x.cnst
@@ -494,8 +474,8 @@ isthin(x::MCNoGrad) = isthin(x.Intv)
 
 function isone(x::MCNoGrad)
     flag = true
-    flag &= (x.Intv.lo == 1.0)
-    flag &= (x.Intv.hi == 1.0)
+    flag &= (x.Intv.bareinterval.lo == 1.0)
+    flag &= (x.Intv.bareinterval.hi == 1.0)
     flag &= x.cnst
     return flag
 end