add unitfulvalue

Author: ChrisRackauckas

ext/DiffEqBaseForwardDiffExt.jl

@@ -497,6 +497,9 @@ end
 value(x::Type{ForwardDiff.Dual{T, V, N}}) where {T, V, N} = V
 value(x::ForwardDiff.Dual) = value(ForwardDiff.value(x))
 
+unitfulvalue(x::Type{ForwardDiff.Dual{T, V, N}}) where {T, V, N} = V
+unitfulvalue(x::ForwardDiff.Dual) = unitfulvalue(ForwardDiff.unitfulvalue(x))
+
 sse(x::Number) = abs2(x)
 sse(x::ForwardDiff.Dual) = sse(ForwardDiff.value(x)) + sum(sse, ForwardDiff.partials(x))
 totallength(x::Number) = 1

ext/DiffEqBaseGTPSAExt.jl

@@ -13,6 +13,9 @@ end
 value(x::TPS) = scalar(x)
 value(::Type{<:TPS{T}}) where {T} = T
 
+unitfulvalue(x::TPS) = scalar(x)
+unitfulvalue(::Type{<:TPS{T}}) where {T} = T
+
 ODE_DEFAULT_NORM(u::TPS, t) = normTPS(u)
 ODE_DEFAULT_NORM(f::F, u::TPS, t) where {F} = normTPS(f(u))
 

ext/DiffEqBaseMeasurementsExt.jl

@@ -19,6 +19,9 @@ DiffEqBase.promote_u0(u0, p::AbstractArray{<:Measurements.Measurement}, t0) = el
 value(x::Type{Measurements.Measurement{T}}) where {T} = T
 value(x::Measurements.Measurement) = Measurements.value(x)
 
+unitfulvalue(x::Type{Measurements.Measurement{T}}) where {T} = T
+unitfulvalue(x::Measurements.Measurement) = Measurements.value(x)
+
 # Support adaptive steps should be errorless
 @inline function DiffEqBase.ODE_DEFAULT_NORM(
         u::AbstractArray{

ext/DiffEqBaseMonteCarloMeasurementsExt.jl

@@ -26,6 +26,8 @@ end
 
 DiffEqBase.value(x::Type{MonteCarloMeasurements.AbstractParticles{T, N}}) where {T, N} = T
 DiffEqBase.value(x::MonteCarloMeasurements.AbstractParticles) = mean(x.particles)
+DiffEqBase.unitfulvalue(x::Type{MonteCarloMeasurements.AbstractParticles{T, N}}) where {T, N} = T
+DiffEqBase.unitfulvalue(x::MonteCarloMeasurements.AbstractParticles) = mean(x.particles)
 
 # Support adaptive steps should be errorless
 @inline function DiffEqBase.ODE_DEFAULT_NORM(

ext/DiffEqBaseReverseDiffExt.jl

@@ -23,6 +23,18 @@ end
 DiffEqBase.value(x::ReverseDiff.TrackedReal) = x.value
 DiffEqBase.value(x::ReverseDiff.TrackedArray) = x.value
 
+
+DiffEqBase.unitfulvalue(x::Type{ReverseDiff.TrackedReal{V, D, O}}) where {V, D, O} = V
+function DiffEqBase.unitfulvalue(x::Type{
+        ReverseDiff.TrackedArray{V, D, N, VA, DA},
+}) where {V, D,
+        N, VA,
+        DA}
+    Array{V, N}
+end
+DiffEqBase.unitfulvalue(x::ReverseDiff.TrackedReal) = x.value
+DiffEqBase.unitfulvalue(x::ReverseDiff.TrackedArray) = x.value
+
 # Force TrackedArray from TrackedReal when reshaping W\b
 DiffEqBase._reshape(v::AbstractVector{<:ReverseDiff.TrackedReal}, siz) = reduce(vcat, v)
 

ext/DiffEqBaseTrackerExt.jl

@@ -15,6 +15,11 @@ DiffEqBase.value(x::Type{Tracker.TrackedArray{T, N, A}}) where {T, N, A} = Array
 DiffEqBase.value(x::Tracker.TrackedReal) = x.data
 DiffEqBase.value(x::Tracker.TrackedArray) = x.data
 
+DiffEqBase.unitfulvalue(x::Type{Tracker.TrackedReal{T}}) where {T} = T
+DiffEqBase.unitfulvalue(x::Type{Tracker.TrackedArray{T, N, A}}) where {T, N, A} = Array{T, N}
+DiffEqBase.unitfulvalue(x::Tracker.TrackedReal) = x.data
+DiffEqBase.unitfulvalue(x::Tracker.TrackedArray) = x.data
+
 DiffEqBase.promote_u0(u0::Tracker.TrackedArray, p::Tracker.TrackedArray, t0) = u0
 function DiffEqBase.promote_u0(u0::AbstractArray{<:Tracker.TrackedReal},
         p::Tracker.TrackedArray, t0)

ext/DiffEqBaseUnitfulExt.jl

@@ -12,6 +12,10 @@ end
 # Support adaptive errors should be errorless for exponentiation
 value(x::Type{Unitful.AbstractQuantity{T, D, U}}) where {T, D, U} = T
 value(x::Unitful.AbstractQuantity) = x.val
+
+unitfulvalue(x::Type{T}) where {T <: Unitful.AbstractQuantity} = T
+unitfulvalue(x::Unitful.AbstractQuantity) = x
+
 @inline function DiffEqBase.ODE_DEFAULT_NORM(
         u::AbstractArray{
             <:Unitful.AbstractQuantity,

src/utils.jl

@@ -1,5 +1,6 @@
 # Handled in Extensions
 value(x) = x
+unitfulvalue(x) = x
 isdistribution(u0) = false
 
 _vec(v) = vec(v)