Drop T from public structs, orchestrators, and easy precision-defensive sites

Author: KookiesNKareem

KomaMRIBase/src/datatypes/Phantom.jl

@@ -29,25 +29,25 @@ julia> obj = Phantom(x=[0.0])
 julia> obj.ρ
 ```
 """
-@with_kw mutable struct Phantom{T<:Real}
-    name::String           = "spins"
-    x::AbstractVector{T}   = @isdefined(T) ? T[] : Float64[]
-    y::AbstractVector{T}   = zeros(eltype(x), size(x))
-    z::AbstractVector{T}   = zeros(eltype(x), size(x))
-    ρ::AbstractVector{T}   = ones(eltype(x), size(x))
-    T1::AbstractVector{T}  = ones(eltype(x), size(x)) * 1_000_000
-    T2::AbstractVector{T}  = ones(eltype(x), size(x)) * 1_000_000
-    T2s::AbstractVector{T} = ones(eltype(x), size(x)) * 1_000_000
+@with_kw mutable struct Phantom
+    name::String          = "spins"
+    x::AbstractVector     = Float64[]
+    y::AbstractVector     = zeros(eltype(x), size(x))
+    z::AbstractVector     = zeros(eltype(x), size(x))
+    ρ::AbstractVector     = ones(eltype(x), size(x))
+    T1::AbstractVector    = ones(eltype(x), size(x)) * 1_000_000
+    T2::AbstractVector    = ones(eltype(x), size(x)) * 1_000_000
+    T2s::AbstractVector   = ones(eltype(x), size(x)) * 1_000_000
     #Off-resonance related
-    Δw::AbstractVector{T} = zeros(eltype(x), size(x))
+    Δw::AbstractVector    = zeros(eltype(x), size(x))
     #χ::Vector{SusceptibilityModel}
     #Diffusion
-    Dλ1::AbstractVector{T} = zeros(eltype(x), size(x))
-    Dλ2::AbstractVector{T} = zeros(eltype(x), size(x))
-    Dθ::AbstractVector{T}  = zeros(eltype(x), size(x))
+    Dλ1::AbstractVector   = zeros(eltype(x), size(x))
+    Dλ2::AbstractVector   = zeros(eltype(x), size(x))
+    Dθ::AbstractVector    = zeros(eltype(x), size(x))
     #Diff::Vector{DiffusionModel}  #Diffusion map
     #Motion
-    motion::Union{NoMotion, Motion{T}, MotionList{T}} = NoMotion()
+    motion::Union{NoMotion, Motion, MotionList} = NoMotion()
 end
 
 const NON_STRING_PHANTOM_FIELDS = Iterators.filter(x -> fieldtype(Phantom, x) != String,         fieldnames(Phantom))

KomaMRIBase/src/datatypes/sequence/extensions/QuaternionRot.jl

@@ -13,9 +13,9 @@ struct QuaternionRot <: Extension
     qz::Float64
 end
 
-function QuaternionRot(R::AbstractMatrix{T}) where {T<:Real}
+function QuaternionRot(R::AbstractMatrix)
     size(R) == (3, 3) || throw(DimensionMismatch("Rotation matrix must be 3x3."))
-    R = copyto!(similar(R, typeof(float(one(T)))), R)
+    R = copyto!(similar(R, typeof(float(one(eltype(R))))), R)
     all(iszero, R) && throw(ArgumentError("Empty matrix provided in place of a rotation matrix."))
 
     qs = sqrt(max(0, R[1, 1] + R[2, 2] + R[3, 3] + 1)) / 2

KomaMRIBase/src/motion/Action.jl

@@ -1,4 +1,4 @@
-abstract type AbstractAction{T<:Real} end
+abstract type AbstractAction end
 
 Base.:(==)(a1::AbstractAction, a2::AbstractAction) = (typeof(a1) == typeof(a2)) & reduce(&, [getfield(a1, field) == getfield(a2, field) for field in fieldnames(typeof(a1))])
 Base.:(≈)(a1::AbstractAction,  a2::AbstractAction) = (typeof(a1) == typeof(a2)) & reduce(&, [getfield(a1, field)  ≈ getfield(a2, field) for field in fieldnames(typeof(a1))])

KomaMRIBase/src/motion/Motion.jl

@@ -26,25 +26,16 @@ julia> motion =  Motion(
        )
 ```
 """
-@with_kw mutable struct Motion{T<:Real}
-    action::AbstractAction{T}
-    time  ::TimeCurve{T}      = TimeRange(t_start=zero(typeof(action).parameters[1]), t_end=eps(typeof(action).parameters[1]))
+@with_kw mutable struct Motion
+    action::AbstractAction
+    time  ::TimeCurve         = TimeRange(t_start=0.0, t_end=eps(Float64))
     spins ::AbstractSpinSpan  = AllSpins()
 end
 
 # Main constructors
-function Motion(action) 
-    T = first(typeof(action).parameters)
-    return Motion(action, TimeRange(t_start=zero(T), t_end=eps(T)), AllSpins())
-end
-function Motion(action, time::TimeCurve)
-    T = first(typeof(action).parameters)
-    return Motion(action, time, AllSpins())
-end
-function Motion(action, spins::AbstractSpinSpan)
-    T = first(typeof(action).parameters)
-    return Motion(action, TimeRange(t_start=zero(T), t_end=eps(T)), spins)
-end
+Motion(action) = Motion(action, TimeRange(t_start=0.0, t_end=eps(Float64)), AllSpins())
+Motion(action, time::TimeCurve)         = Motion(action, time, AllSpins())
+Motion(action, spins::AbstractSpinSpan) = Motion(action, TimeRange(t_start=0.0, t_end=eps(Float64)), spins)
 
 # Custom constructors
 """
@@ -205,8 +196,8 @@ For each dimension (x, y, z), the output matrix has ``N_{\t{spins}}`` rows and `
 - `x, y, z`: (`::Tuple{AbstractArray, AbstractArray, AbstractArray}`) spin positions over time
 """
 function get_spin_coords(
-    m::Motion{T}, x::AbstractVector{T}, y::AbstractVector{T}, z::AbstractVector{T}, t
-) where {T<:Real}
+    m::Motion, x::AbstractVector, y::AbstractVector, z::AbstractVector, t
+)
     ux, uy, uz = x .* (0*t), y .* (0*t), z .* (0*t) # Buffers for displacements
     t_unit = unit_time(t, m.time)
     idx = get_indexing_range(m.spins)

KomaMRIBase/src/motion/MotionList.jl

@@ -33,8 +33,8 @@ julia>  motionlist = MotionList(
         )
 ```
 """
-struct MotionList{T<:Real}
-    motions::Vector{<:Motion{T}}
+struct MotionList
+    motions::Vector{<:Motion}
 end
 
 # NOTE: this constructor must be simplified once the Vector{<:Motion} approach is accomplished: 
@@ -52,10 +52,10 @@ end
 
 # NOTE: these vcat methods must be simplified once the Vector{<:Motion} approach is accomplished: 
 # https://github.com/JuliaHealth/KomaMRI.jl/issues/480
-""" Addition of MotionLists """ 
+""" Addition of MotionLists """
 # MotionList + MotionList
-function Base.vcat(m1::MotionList{T}, m2::MotionList{T}, Ns1, Ns2) where {T<:Real}
-    mv_aux = Motion{T}[]
+function Base.vcat(m1::MotionList, m2::MotionList, Ns1, Ns2)
+    mv_aux = Motion[]
     for m in m1.motions
         m_aux = deepcopy(m)
         m_aux.spins = expand(m_aux.spins, Ns1)
@@ -70,8 +70,8 @@ function Base.vcat(m1::MotionList{T}, m2::MotionList{T}, Ns1, Ns2) where {T<:Rea
     return MotionList(mv_aux...)
 end
 # Motion + Motion
-function Base.vcat(m1::Motion{T}, m2::Motion{T}, Ns1, Ns2) where {T<:Real}
-    mv_aux = Motion{T}[]
+function Base.vcat(m1::Motion, m2::Motion, Ns1, Ns2)
+    mv_aux = Motion[]
     m_aux = deepcopy(m1)
     m_aux.spins = expand(m_aux.spins, Ns1)
     push!(mv_aux, m_aux)
@@ -82,9 +82,9 @@ function Base.vcat(m1::Motion{T}, m2::Motion{T}, Ns1, Ns2) where {T<:Real}
     return MotionList(mv_aux...)
 end
 # Motion + MotionList
-Base.vcat(m1::MotionList{T}, m2::Motion{T}, Ns1, Ns2) where {T<:Real} = vcat(m2, m1, Ns2, Ns1)
-function Base.vcat(m1::Motion{T}, m2::MotionList{T}, Ns1, Ns2) where {T<:Real}
-    mv_aux = Motion{T}[]
+Base.vcat(m1::MotionList, m2::Motion, Ns1, Ns2) = vcat(m2, m1, Ns2, Ns1)
+function Base.vcat(m1::Motion, m2::MotionList, Ns1, Ns2)
+    mv_aux = Motion[]
     m_aux = deepcopy(m1)
     m_aux.spins = expand(m_aux.spins, Ns1)
     push!(mv_aux, m_aux)
@@ -98,29 +98,29 @@ function Base.vcat(m1::Motion{T}, m2::MotionList{T}, Ns1, Ns2) where {T<:Real}
 end
 
 """ MotionList sub-group """
-function Base.getindex(mv::MotionList{T}, p) where {T<:Real}
-    motion_array_aux = Motion{T}[]
+function Base.getindex(mv::MotionList, p)
+    motion_array_aux = Motion[]
     for m in mv.motions
         m[p] isa NoMotion ? nothing : push!(motion_array_aux, m[p])
     end
     return MotionList(motion_array_aux...)
 end
-function Base.view(mv::MotionList{T}, p) where {T<:Real}
-    motion_array_aux = Motion{T}[]
+function Base.view(mv::MotionList, p)
+    motion_array_aux = Motion[]
     for m in mv.motions
         @view(m[p]) isa NoMotion ? nothing : push!(motion_array_aux, @view(m[p]))
     end
     return MotionList(motion_array_aux...)
 end
 
 """ Compare two MotionLists """
-function Base.:(==)(mv1::MotionList{T}, mv2::MotionList{T}) where {T<:Real}
+function Base.:(==)(mv1::MotionList, mv2::MotionList)
     if length(mv1) != length(mv2) return false end
     sort_motions!(mv1)
     sort_motions!(mv2)
     return reduce(&, mv1.motions .== mv2.motions)
 end
-function Base.:(≈)(mv1::MotionList{T}, mv2::MotionList{T}) where {T<:Real} 
+function Base.:(≈)(mv1::MotionList, mv2::MotionList)
     if length(mv1) != length(mv2) return false end
     sort_motions!(mv1)
     sort_motions!(mv2)
@@ -131,14 +131,14 @@ end
 Base.length(m::MotionList) = length(m.motions)
 
 function get_spin_coords(
-    ml::MotionList{T}, x::AbstractVector{T}, y::AbstractVector{T}, z::AbstractVector{T}, t
-) where {T<:Real}
+    ml::MotionList, x::AbstractVector, y::AbstractVector, z::AbstractVector, t
+)
     # Sort motions
     sort_motions!(ml)
     # Buffers for positions:
     xt, yt, zt = x .+ 0*t, y .+ 0*t, z .+ 0*t
     # Buffers for displacements:
-    ux, uy, uz = xt .* zero(T), yt .* zero(T), zt .* zero(T)
+    ux, uy, uz = zero.(xt), zero.(yt), zero.(zt)
     # Composable motions: they need to be run sequentially. Note that they depend on xt, yt, and zt
     for m in Iterators.filter(is_composable, ml.motions)
         t_unit = unit_time(t, m.time)
@@ -147,7 +147,7 @@ function get_spin_coords(
         displacement_y!(@view(uy[idx, :]), m.action, @view(xt[idx, :]), @view(yt[idx, :]), @view(zt[idx, :]), t_unit)
         displacement_z!(@view(uz[idx, :]), m.action, @view(xt[idx, :]), @view(yt[idx, :]), @view(zt[idx, :]), t_unit)
         xt .+= ux; yt .+= uy; zt .+= uz
-        ux .*= zero(T); uy .*= zero(T); uz .*= zero(T)
+        fill!(ux, 0); fill!(uy, 0); fill!(uz, 0)
     end
     # Additive motions: these motions can be run in parallel
     for m in Iterators.filter(!is_composable, ml.motions)
@@ -157,7 +157,7 @@ function get_spin_coords(
         displacement_y!(@view(uy[idx, :]), m.action, @view(x[idx]), @view(y[idx]), @view(z[idx]), t_unit)
         displacement_z!(@view(uz[idx, :]), m.action, @view(x[idx]), @view(y[idx]), @view(z[idx]), t_unit)
         xt .+= ux; yt .+= uy; zt .+= uz
-        ux .*= zero(T); uy .*= zero(T); uz .*= zero(T)
+        fill!(ux, 0); fill!(uy, 0); fill!(uz, 0)
     end
     return xt, yt, zt
 end

KomaMRIBase/src/motion/NoMotion.jl

@@ -21,8 +21,8 @@ Base.view(mv::NoMotion, p)     = mv
 Base.vcat(m1::NoMotion,   m2::NoMotion, Ns1, Ns2) = m1
 # NoMotion + MotionList
 Base.vcat(m1::MotionList, m2::NoMotion, Ns1, Ns2) = vcat(m2, m1, 0, Ns1)
-function Base.vcat(m1::NoMotion, m2::MotionList{T}, Ns1, Ns2) where {T}
-    mv_aux = Motion{T}[]
+function Base.vcat(m1::NoMotion, m2::MotionList, Ns1, Ns2)
+    mv_aux = Motion[]
     for m in m2.motions
         m_aux = deepcopy(m)
         m_aux.spins = expand(m_aux.spins, Ns2)
@@ -33,7 +33,7 @@ function Base.vcat(m1::NoMotion, m2::MotionList{T}, Ns1, Ns2) where {T}
 end
 # NoMotion + Motion
 Base.vcat(m1::Motion, m2::NoMotion, Ns1, Ns2) = vcat(m2, m1, 0, Ns1)
-function Base.vcat(m1::NoMotion, m2::Motion{T}, Ns1, Ns2) where {T}
+function Base.vcat(m1::NoMotion, m2::Motion, Ns1, Ns2)
     m_aux = deepcopy(m2)
     m_aux.spins = expand(m_aux.spins, Ns2)
     m_aux.spins = SpinRange(m_aux.spins.range .+ Ns1)
@@ -44,9 +44,5 @@ end
 Base.:(==)(m1::NoMotion, m2::NoMotion) = true
 Base.:(≈)(m1::NoMotion, m2::NoMotion)   = true
 
-function get_spin_coords(
-    mv::NoMotion, x::AbstractVector{T}, y::AbstractVector{T}, z::AbstractVector{T}, t
-) where {T<:Real}
-    return x, y, z
-end
+get_spin_coords(::NoMotion, x::AbstractVector, y::AbstractVector, z::AbstractVector, t) = (x, y, z)
 add_key_time_points!(t, ::NoMotion) = nothing

KomaMRIBase/src/motion/TimeCurve.jl

@@ -51,13 +51,13 @@ julia> timecurve = TimeCurve(t=[0.0, 0.2, 0.4, 0.6], t_unit=[0.0, 1.0, 1.0, 0.0]
 ```
 ![Time Curve 4](../assets/time-curve-4.svg)
 """
-@with_kw struct TimeCurve{T<:Real}
-    t::AbstractVector{T}
-    t_unit::AbstractVector{T}
-    periodic::Bool                       = false
-    periods::Union{T,AbstractVector{T}} = oneunit(eltype(t))
-    t_start::T                           = t[1]
-    t_end::T                             = t[end]
+@with_kw struct TimeCurve
+    t::AbstractVector
+    t_unit::AbstractVector
+    periodic::Bool                              = false
+    periods::Union{Real, AbstractVector{<:Real}} = oneunit(eltype(t))
+    t_start::Real                               = t[1]
+    t_end::Real                                 = t[end]
     @assert check_unique(t) "Vector t=$(t) contains duplicate elements. Please ensure all elements in t are unique and try again"
 end
 
@@ -88,8 +88,8 @@ julia> timerange = TimeRange(t_start=0.6, t_end=1.4)
 ```
 ![Time Range](../assets/time-range.svg)
 """
-TimeRange(t_start::T, t_end::T) where T = TimeCurve(t=[t_start, t_end], t_unit=[zero(T), oneunit(T)])
-TimeRange(; t_start=0.0, t_end=1.0)     = TimeRange(t_start, t_end)
+TimeRange(t_start::Real, t_end::Real) = TimeCurve(t=[t_start, t_end], t_unit=[zero(t_start), oneunit(t_start)])
+TimeRange(; t_start=0.0, t_end=1.0)   = TimeRange(t_start, t_end)
 
 # Define our own Periodic function to avoid extending Periodic from Interpolations.jl (required since Julia 1.12)
 function Periodic end 
@@ -113,13 +113,13 @@ julia> periodic = Periodic(period=1.0, asymmetry=0.2)
 ```
 ![Periodic](../assets/periodic.svg)
 """
-function Periodic(period::T, asymmetry::T) where T 
-    if asymmetry == oneunit(T)
-        return TimeCurve(t=[zero(T), period], t_unit=[zero(T), oneunit(T)], periodic=true)
-    elseif asymmetry == zero(T)
-        return TimeCurve(t=[zero(T), period], t_unit=[oneunit(T), zero(T)], periodic=true)
+function Periodic(period::Real, asymmetry::Real)
+    if asymmetry == oneunit(period)
+        return TimeCurve(t=[zero(period), period], t_unit=[zero(period), oneunit(period)], periodic=true)
+    elseif asymmetry == zero(period)
+        return TimeCurve(t=[zero(period), period], t_unit=[oneunit(period), zero(period)], periodic=true)
     else
-        return TimeCurve(t=[zero(T), period*asymmetry, period], t_unit=[zero(T), oneunit(T), zero(T)], periodic=true)
+        return TimeCurve(t=[zero(period), period*asymmetry, period], t_unit=[zero(period), oneunit(period), zero(period)], periodic=true)
     end
 end
 Periodic(; period=1.0, asymmetry=0.5) = Periodic(period, asymmetry)

KomaMRIBase/src/motion/actions/ArbitraryAction.jl

@@ -1,4 +1,4 @@
-abstract type ArbitraryAction{T<:Real} <: AbstractAction{T} end
+abstract type ArbitraryAction <: AbstractAction end
 
 function Base.getindex(action::ArbitraryAction, p)
     return typeof(action)([getfield(action, d)[p,:] for d in fieldnames(typeof(action))]...)

KomaMRIBase/src/motion/actions/SimpleAction.jl

@@ -1,4 +1,4 @@
-abstract type SimpleAction{T<:Real} <: AbstractAction{T} end
+abstract type SimpleAction <: AbstractAction end
 
 Base.getindex(action::SimpleAction, p) = action
 Base.view(action::SimpleAction, p)     = action

KomaMRIBase/src/motion/actions/arbitraryactions/FlowPath.jl

@@ -29,14 +29,14 @@ julia> f = FlowPath(
        )
 ```
 """
-@with_kw struct FlowPath{T<:Real} <: ArbitraryAction{T}
-    dx::AbstractArray{T}
-    dy::AbstractArray{T}
-    dz::AbstractArray{T}
+@with_kw struct FlowPath <: ArbitraryAction
+    dx::AbstractArray
+    dy::AbstractArray
+    dz::AbstractArray
     spin_reset::AbstractArray{Bool}
 end
 
-FlowPath(dx::AbstractArray{T}, dy::AbstractArray{T}, dz::AbstractArray{T}, spin_reset::BitMatrix) where T<:Real = FlowPath(dx, dy, dz, collect(spin_reset))
+FlowPath(dx::AbstractArray, dy::AbstractArray, dz::AbstractArray, spin_reset::BitMatrix) = FlowPath(dx, dy, dz, collect(spin_reset))
 
 function add_reset_times!(t, a::FlowPath, t_start, t_end, periods)
     aux = t_start .+ (t_end - t_start)/(size(a.spin_reset)[2]-1) * (getindex.(findall(a.spin_reset .== 1), 2) .- 1)