Use Type instead of DataType

Author: amontoison

.buildkite/pipeline.yml

@@ -2,7 +2,7 @@ steps:
   - label: "Nvidia GPUs -- LinearOperators.jl"
     plugins:
       - JuliaCI/julia#v1:
-          version: 1.8
+          version: "1.10"
     agents:
       queue: "juliagpu"
       cuda: "*"
@@ -31,4 +31,3 @@ steps:
       include("test/gpu/test_S_kwarg.jl")
       include("test/gpu/amdgpu.jl")'
     timeout_in_minutes: 30
-

.github/workflows/CI.yml

@@ -10,24 +10,28 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        version: ['1.10', '1']
+        version: ['lts', '1']
         os: [ubuntu-latest, macos-latest, windows-latest]
         arch: [x64]
         allow_failure: [false]
         include:
+          - version: '1'
+            os: ubuntu-24.04-arm
+            arch: arm64
+            allow_failure: false
           - version: '1'
             os: macos-latest
             arch: arm64
             allow_failure: false
-          - version: 'nightly'
+          - version: 'pre'
             os: ubuntu-latest
             arch: x64
             allow_failure: true
-          - version: 'nightly'
+          - version: 'pre'
             os: macos-latest
             arch: x64
             allow_failure: true
-          - version: 'nightly'
+          - version: 'pre'
             os: windows-latest
             arch: x64
             allow_failure: true

src/abstract.jl

@@ -72,7 +72,7 @@ function LinearOperator{T}(
   nprod::I,
   ntprod::I,
   nctprod::I;
-  S::DataType = Vector{T},
+  S::Type = Vector{T},
 ) where {T, I <: Integer, F, Ft, Fct}
   Mv5, Mtu5 = S(undef, 0), S(undef, 0)
   nargs = get_nargs(prod!)
@@ -107,13 +107,13 @@ LinearOperator{T}(
   prod!,
   tprod!,
   ctprod!;
-  S::DataType = Vector{T},
+  S::Type = Vector{T},
 ) where {T, I <: Integer} =
   LinearOperator{T}(nrow, ncol, symmetric, hermitian, prod!, tprod!, ctprod!, 0, 0, 0, S = S)
 
 # create operator from other operators with +, *, vcat,...
 function CompositeLinearOperator(
-  T::DataType,
+  T::Type,
   nrow::I,
   ncol::I,
   symmetric::Bool,
@@ -122,7 +122,7 @@ function CompositeLinearOperator(
   tprod!::Ft,
   ctprod!::Fct,
   args5::Bool;
-  S::DataType = Vector{T},
+  S::Type = Vector{T},
 ) where {I <: Integer, F, Ft, Fct}
   Mv5, Mtu5 = S(undef, 0), S(undef, 0)
   allocated5 = true

src/deprecated.jl

@@ -1,12 +1,12 @@
 # Deprecated use of positional argument mem
-@deprecate LBFGSOperator(T::DataType, n::Int, mem::Int; kwargs...) LBFGSOperator(
+@deprecate LBFGSOperator(T::Type, n::Int, mem::Int; kwargs...) LBFGSOperator(
   T,
   n;
   mem = mem,
   kwargs...,
 ) false
 @deprecate LBFGSOperator(n::Int, mem::Int; kwargs...) LBFGSOperator(n; mem = mem, kwargs...) false
-@deprecate InverseLBFGSOperator(T::DataType, n::Int, mem::Int; kwargs...) InverseLBFGSOperator(
+@deprecate InverseLBFGSOperator(T::Type, n::Int, mem::Int; kwargs...) InverseLBFGSOperator(
   T,
   n;
   mem = mem,
@@ -17,7 +17,7 @@
   mem = mem,
   kwargs...,
 ) false
-@deprecate LSR1Operator(T::DataType, n::Int, mem::Int; kwargs...) LSR1Operator(
+@deprecate LSR1Operator(T::Type, n::Int, mem::Int; kwargs...) LSR1Operator(
   T,
   n;
   mem = mem,

src/lbfgs.jl

@@ -22,7 +22,7 @@ mutable struct LBFGSData{T, I <: Integer}
 end
 
 function LBFGSData(
-  T::DataType,
+  T::Type,
   n::I;
   mem::I = 5,
   scaling::Bool = true,
@@ -106,7 +106,7 @@ storage_type(op::LBFGSOperator{T}) where {T} = Vector{T}
 Construct a limited-memory BFGS approximation in inverse form. If the type `T`
 is omitted, then `Float64` is used.
 """
-function InverseLBFGSOperator(T::DataType, n::I; kwargs...) where {I <: Integer}
+function InverseLBFGSOperator(T::Type, n::I; kwargs...) where {I <: Integer}
   kwargs = Dict(kwargs)
   delete!(kwargs, :inverse)
   lbfgs_data = LBFGSData(T, n; inverse = true, kwargs...)
@@ -166,7 +166,7 @@ InverseLBFGSOperator(n::Int; kwargs...) = InverseLBFGSOperator(Float64, n; kwarg
 Construct a limited-memory BFGS approximation in forward form. If the type `T`
 is omitted, then `Float64` is used.
 """
-function LBFGSOperator(T::DataType, n::I; kwargs...) where {I <: Integer}
+function LBFGSOperator(T::Type, n::I; kwargs...) where {I <: Integer}
   kwargs = Dict(kwargs)
   delete!(kwargs, :inverse)
   lbfgs_data = LBFGSData(T, n; inverse = false, kwargs...)

src/lsr1.jl

@@ -16,7 +16,7 @@ mutable struct LSR1Data{T, I <: Integer}
 end
 
 function LSR1Data(
-  T::DataType,
+  T::Type,
   n::I;
   mem::I = 5,
   scaling::Bool = true,
@@ -92,7 +92,7 @@ storage_type(op::LSR1Operator{T}) where {T} = Vector{T}
 Construct a limited-memory SR1 approximation in forward form. If the type `T` is
 omitted, then `Float64` is used.
 """
-function LSR1Operator(T::DataType, n::I; kwargs...) where {I <: Integer}
+function LSR1Operator(T::Type, n::I; kwargs...) where {I <: Integer}
   lsr1_data = LSR1Data(T, n; kwargs...)
 
   function lsr1_multiply(q::AbstractVector, data::LSR1Data, x::AbstractArray, α, β::T2) where {T2}

src/special-operators.jl

@@ -50,7 +50,7 @@ end
 Identity operator of order `n` and of data type `T` (defaults to `Float64`).
 Change `S` to use LinearOperators on GPU.
 """
-function opEye(T::DataType, n::Int; S = Vector{T})
+function opEye(T::Type, n::Int; S = Vector{T})
   prod! = @closure (res, v, α, β) -> mulOpEye!(res, v, α, β, n)
   LinearOperator{T}(n, n, true, true, prod!, prod!, prod!, S = S)
 end
@@ -66,7 +66,7 @@ Rectangular identity operator of size `nrow`x`ncol` and of data type `T`
 (defaults to `Float64`).
 Change `S` to use LinearOperators on GPU.
 """
-function opEye(T::DataType, nrow::I, ncol::I; S = Vector{T}) where {I <: Integer}
+function opEye(T::Type, nrow::I, ncol::I; S = Vector{T}) where {I <: Integer}
   if nrow == ncol
     return opEye(T, nrow; S = S)
   end
@@ -92,7 +92,7 @@ Operator of all ones of size `nrow`-by-`ncol` of data type `T` (defaults to
 `Float64`).
 Change `S` to use LinearOperators on GPU.
 """
-function opOnes(T::DataType, nrow::I, ncol::I; S = Vector{T}) where {I <: Integer}
+function opOnes(T::Type, nrow::I, ncol::I; S = Vector{T}) where {I <: Integer}
   prod! = @closure (res, v, α, β) -> mulOpOnes!(res, v, α, β)
   LinearOperator{T}(nrow, ncol, nrow == ncol, nrow == ncol, prod!, prod!, prod!, S = S)
 end
@@ -115,7 +115,7 @@ Zero operator of size `nrow`-by-`ncol`, of data type `T` (defaults to
 `Float64`).
 Change `S` to use LinearOperators on GPU.
 """
-function opZeros(T::DataType, nrow::I, ncol::I; S = Vector{T}) where {I <: Integer}
+function opZeros(T::Type, nrow::I, ncol::I; S = Vector{T}) where {I <: Integer}
   prod! = @closure (res, v, α, β) -> mulOpZeros!(res, v, α, β)
   LinearOperator{T}(nrow, ncol, nrow == ncol, nrow == ncol, prod!, prod!, prod!, S = S)
 end