fix import issues

Author: schillic

src/IntervalMatrices.jl

@@ -1,17 +1,14 @@
 module IntervalMatrices
 
-using LinearAlgebra
-using LinearAlgebra: checksquare
-
-using Random: AbstractRNG, GLOBAL_RNG, seed!
-import Random: rand
-
-import Base: copy,
+import Base: copy, rand,
              +, -, *, /, \,
              size, IndexStyle, getindex, setindex!,
              similar, ∈, ⊆, ∩, ∪, real, imag
 
-using Reexport
+import LinearAlgebra
+using LinearAlgebra: Diagonal, I, UniformScaling, checksquare, opnorm
+using Random: AbstractRNG, GLOBAL_RNG
+using Reexport: @reexport
 
 # =================================
 # Interface with IntervalArithmetic

src/exponential.jl

@@ -80,7 +80,7 @@ end
 function _exp_remainder(A::IntervalMatrix{T}, t, p; n=checksquare(A)) where {T}
     C = max.(abs.(inf(A)), abs.(sup(A)))
     # compute Q = I + Ct + (Ct)^2/2! + ... + (Ct)^p/p!
-    Q = Matrix(LinearAlgebra.Diagonal(ones(T, n)))
+    Q = Matrix(Diagonal(ones(T, n)))
 
     tⁱ = 1
     i! = 1

src/matrix.jl

@@ -173,19 +173,20 @@ julia> [1 2; 3 4] ± [1 2; 4 5]
 """
 function ±(C::MT, S::MT) where {T,MT<:AbstractMatrix{T}}
     size(C) == size(S) || throw(ArgumentError("the sizes of the center matrix and the " *
-                                              "radii matrix should match, but they are $(size(C)) " *
-                                              "and $(size(S)) respectively"))
+                                              "radii matrix should match, but they are " *
+                                              "$(size(C)) and $(size(S)) respectively"))
 
     return IntervalMatrix(map((x, y) -> interval(x - y, x + y), C, S))
 end
 
-for op in (:Adjoint, :Bidiagonal, :Diagonal, :Hermitian,
-           :SymTridiagonal, :Symmetric, :Transpose, :Tridiagonal)
-    @eval LinearAlgebra.$op(A::IntervalMatrix) = IntervalMatrix($op(A.mat))
+for op in (:Adjoint, :Bidiagonal, :Diagonal, :Hermitian, :SymTridiagonal, :Symmetric, :Transpose,
+           :Tridiagonal)
+    @eval LinearAlgebra.$op(A::IntervalMatrix) = IntervalMatrix(LinearAlgebra.$op(A.mat))
 end
 
 if VERSION >= v"1.3"
-    LinearAlgebra.UpperHessenberg(A::IntervalMatrix) = IntervalMatrix(UpperHessenberg(A.mat))
+    LinearAlgebra.UpperHessenberg(A::IntervalMatrix) =
+        IntervalMatrix(LinearAlgebra.UpperHessenberg(A.mat))
 end
 
 @static if vIA >= v"0.22"

src/operations/arithmetic.jl

@@ -34,24 +34,26 @@
 # (there exist more precise approaches but are currently not implemented here)
 \(M1::IntervalMatrix, M2::IntervalMatrix) = IntervalMatrix(M1.mat \ M2.mat)
 # COV_EXCL_START
-for T in (:AbstractMatrix, :Diagonal, :(Union{UpperTriangular,LowerTriangular}),
-          :(Union{UnitUpperTriangular,UnitLowerTriangular}), :SymTridiagonal, :Bidiagonal,
-          :(LinearAlgebra.HermOrSym), :(LinearAlgebra.AdjOrTrans{<:Any,<:Bidiagonal}))
+for T in (:AbstractMatrix, :(LinearAlgebra.Diagonal),
+          :(Union{LinearAlgebra.UpperTriangular,LinearAlgebra.LowerTriangular}),
+          :(Union{LinearAlgebra.UnitUpperTriangular,LinearAlgebra.UnitLowerTriangular}),
+          :(LinearAlgebra.SymTridiagonal), :(LinearAlgebra.Bidiagonal), :(LinearAlgebra.HermOrSym),
+          :(LinearAlgebra.AdjOrTrans{<:Any,<:LinearAlgebra.Bidiagonal}))  # NOTE: these are internal functions
     @eval begin
         \(M1::IntervalMatrix, M2::$T) = IntervalMatrix(M1.mat \ M2)
         \(M1::$T, M2::IntervalMatrix) = IntervalMatrix(M1 \ M2.mat)
     end
 end
 @static if VERSION >= v"1.3"
-    for T in [:(Union{LinearAlgebra.Adjoint{T,
-                                            S} where {T,
-                                                      S<:(LinearAlgebra.UpperHessenberg{T,
-                                                                                        S} where {S<:AbstractMatrix{T}})},
-                      LinearAlgebra.Transpose{T,
-                                              S} where {T,
-                                                        S<:(LinearAlgebra.UpperHessenberg{T,
-                                                                                          S} where {S<:AbstractMatrix{T}})},
-                      LinearAlgebra.UpperHessenberg})]
+    for T in [:(LinearAlgebra.Adjoint{T,
+                                      S} where {T,
+                                               S<:(LinearAlgebra.UpperHessenberg{T,
+                                                                                 S} where {S<:AbstractMatrix{T}})}),
+              :(LinearAlgebra.Transpose{T,
+                                        S} where {T,
+                                                 S<:(LinearAlgebra.UpperHessenberg{T,
+                                                                                   S} where {S<:AbstractMatrix{T}})}),
+              :(LinearAlgebra.UpperHessenberg)]
         @eval begin
             \(M1::IntervalMatrix, M2::$T) = IntervalMatrix(M1.mat \ M2)
             \(M1::$T, M2::IntervalMatrix) = IntervalMatrix(M1 \ M2.mat)

src/operations/mult.jl

@@ -38,7 +38,7 @@ function set_multiplication_mode(multype)
 
     # AbstractMatrix, incl. disambiguations
     for T in (:AbstractMatrix, :(LinearAlgebra.AbstractTriangular),  # COV_EXCL_LINE
-              :(Transpose{T,<:AbstractVector} where {T}), :Diagonal,
+              :(LinearAlgebra.Transpose{T,<:AbstractVector} where {T}), :Diagonal,
               :(LinearAlgebra.Adjoint{T,<:AbstractVector} where {T}))
         @eval begin  # COV_EXCL_LINE
             *(A::IntervalMatrix, B::$T) = *($type, A, B)

test/constructors.jl

@@ -48,15 +48,15 @@ end
     A = rand(IntervalMatrix)
     @test A isa IntervalMatrix
 
-    Aₛ = Symmetric(A)
+    Aₛ = LinearAlgebra.Symmetric(A)
     @test Aₛ isa IntervalMatrix
-    @test Aₛ.mat isa Symmetric
+    @test Aₛ.mat isa LinearAlgebra.Symmetric
     @test Matrix(Aₛ) isa Matrix
 
     @static if VERSION >= v"1.3"
-        Aₕ = UpperHessenberg(A)
+        Aₕ = LinearAlgebra.UpperHessenberg(A)
         @test Aₕ isa IntervalMatrix
-        @test Aₕ.mat isa UpperHessenberg
+        @test Aₕ.mat isa LinearAlgebra.UpperHessenberg
         @test Matrix(Aₕ) isa Matrix
     end
 end