Merge pull request #54 from thomvet/thomvet-patch-1

Bring back exported dualcache

Author: ChrisRackauckas

Project.toml

@@ -1,7 +1,7 @@
 name = "PreallocationTools"
 uuid = "d236fae5-4411-538c-8e31-a6e3d9e00b46"
 authors = ["Chris Rackauckas <[email protected]>"]
-version = "0.4.5"
+version = "0.4.6"
 
 [deps]
 Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"

src/PreallocationTools.jl

@@ -21,7 +21,7 @@ end
 
 `FixedSizeDiffCache(u::AbstractArray, N = Val{default_cache_size(length(u))})`
 
-Builds a `DualCache` object that stores both a version of the cache for `u`
+Builds a `FixedSizeDiffCache` object that stores both a version of the cache for `u`
 and for the `Dual` version of `u`, allowing use of pre-cached vectors with
 forward-mode automatic differentiation.
 """
@@ -100,7 +100,7 @@ DiffCache(u::AbstractArray, N::AbstractArray{<:Int}) = DiffCache(u, size(u), N)
 function DiffCache(u::AbstractArray, ::Type{Val{N}}; levels::Int = 1) where {N}
     DiffCache(u, N; levels)
 end
-DiffCache(u::AbstractArray, ::Val{N}; levels::Int = 1) where {N} = dualcache(u, N; levels)
+DiffCache(u::AbstractArray, ::Val{N}; levels::Int = 1) where {N} = DiffCache(u, N; levels)
 
 # Legacy deprecate later
 const dualcache = DiffCache
@@ -115,15 +115,15 @@ Returns the `Dual` or normal cache array stored in `dc` based on the type of `u`
 function get_tmp(dc::DiffCache, u::T) where {T <: ForwardDiff.Dual}
     nelem = div(sizeof(T), sizeof(eltype(dc.dual_du))) * length(dc.du)
     if nelem > length(dc.dual_du)
-        enlargedualcache!(dc, nelem)
+        enlargediffcache!(dc, nelem)
     end
     _restructure(dc.du, reinterpret(T, view(dc.dual_du, 1:nelem)))
 end
 
 function get_tmp(dc::DiffCache, u::AbstractArray{T}) where {T <: ForwardDiff.Dual}
     nelem = div(sizeof(T), sizeof(eltype(dc.dual_du))) * length(dc.du)
     if nelem > length(dc.dual_du)
-        enlargedualcache!(dc, nelem)
+        enlargediffcache!(dc, nelem)
     end
     _restructure(dc.du, reinterpret(T, view(dc.dual_du, 1:nelem)))
 end
@@ -150,11 +150,11 @@ function _restructure(normal_cache::AbstractArray, duals)
     ArrayInterfaceCore.restructure(normal_cache, duals)
 end
 
-function enlargedualcache!(dc, nelem) #warning comes only once per dualcache.
+function enlargediffcache!(dc, nelem) #warning comes only once per DiffCache.
     chunksize = div(nelem, length(dc.du)) - 1
-    @warn "The supplied dualcache was too small and was enlarged. This incurs allocations
+    @warn "The supplied DiffCache was too small and was enlarged. This incurs allocations
     on the first call to `get_tmp`. If few calls to `get_tmp` occur and optimal performance is essential,
-    consider changing 'N'/chunk size of this dualcache to $chunksize."
+    consider changing 'N'/chunk size of this DiffCache to $chunksize."
     resize!(dc.dual_du, nelem)
 end
 
@@ -183,7 +183,7 @@ function Base.getindex(b::LazyBufferCache, u::T) where {T <: AbstractArray}
     return buf
 end
 
-export FixedSizeDiffCache, DiffCache, LazyBufferCache
+export FixedSizeDiffCache, DiffCache, LazyBufferCache, dualcache
 export get_tmp
 
 end

test/core_dispatch.jl

@@ -16,6 +16,15 @@ function test(u0, dual, chunk_size)
            result_dual2
 end
 
+function structequal(struct1, struct2)
+    if typeof(struct1) == typeof(struct2)
+        fn = fieldnames(typeof(struct1))
+        all(getfield(a, fn[i]) == getfield(b, fn[i]) for i in eachindex(fn))
+    else
+        return false
+    end
+end
+
 #Setup Base Array tests
 chunk_size = 5
 u0 = ones(5, 5)
@@ -140,3 +149,9 @@ tmp_dual_du_APN = get_tmp(cache_AP, dual_AP[1])
 @test size(tmp_dual_du_APN) == size(u0_AP)
 @test_broken typeof(tmp_dual_du_APN) == typeof(dual_AP)
 @test eltype(tmp_dual_du_APN) == eltype(dual_AP)
+
+a = PreallocationTools.DiffCache(zeros(4), 4)
+b = PreallocationTools.DiffCache(zeros(4), Val{4}())
+c = PreallocationTools.DiffCache(zeros(4), Val{4})
+@test structequal(a, b)
+@test structequal(a, b)