Fix code coverage issues (#133)

* Fix code coverage issues

* Double benchmark

* Remove test from docs

Author: gdalle

docs/src/tutorial.md

@@ -8,8 +8,8 @@ We present a typical workflow with DifferentiationInterface.jl and showcase its
 
 ```@repl tuto
 using DifferentiationInterface
-using BenchmarkTools
-import ForwardDiff, Enzyme, DataFrames
+import ForwardDiff, Enzyme
+using BenchmarkTools, DataFrames
 ```
 
 ## Computing a gradient

ext/DifferentiationInterfaceEnzymeExt/DifferentiationInterfaceEnzymeExt.jl

@@ -56,7 +56,7 @@ end
 
 function zero_sametype!!(x_target, x)
     x_sametype = convert(typeof(x), x_target)
-    x_sametype .= zero(eltype(x))
+    x_sametype .= zero(eltype(x_sametype))
     return x_sametype
 end
 

ext/DifferentiationInterfaceEnzymeExt/reverse_allocating.jl

@@ -57,7 +57,7 @@ end
 
 ## Gradient
 
-DI.prepare_gradient(f, ::AutoReverseEnzyme) = NoGradientExtras()
+DI.prepare_gradient(f, ::AutoReverseEnzyme, x) = NoGradientExtras()
 
 function DI.gradient(f, ::AutoReverseEnzyme, x::AbstractArray, ::NoGradientExtras)
     return gradient(Reverse, f, x)

ext/DifferentiationInterfaceForwardDiffExt/utils.jl

@@ -4,24 +4,18 @@ choose_chunk(::AnyAutoForwardDiff{C}, x) where {C} = Chunk{C}()
 
 tag_type(::F, x::Number) where {F} = Tag{F,typeof(x)}
 tag_type(::F, x::AbstractArray) where {F} = Tag{F,eltype(x)}
-tag_type(::F, x) where {F} = Tag{F,typeof(x)}
 
 make_dual(::Type{T}, x::Number, dx::Number) where {T} = Dual{T}(x, dx)
 make_dual(::Type{T}, x::AbstractArray, dx) where {T} = Dual{T}.(x, dx)
 
 myvalue(::Type{T}, ydual::Number) where {T} = value(T, ydual)
 myvalue(::Type{T}, ydual::AbstractArray) where {T} = value.(T, ydual)
 
-myvalue!!(::Type{T}, y::Number, ydual::Number) where {T} = value(T, ydual)
 myvalue!!(::Type{T}, y::AbstractArray, ydual) where {T} = y .= value.(T, ydual)
 
 myderivative(::Type{T}, ydual::Number) where {T} = extract_derivative(T, ydual)
 myderivative(::Type{T}, ydual::AbstractArray) where {T} = extract_derivative(T, ydual)
 
-function myderivative!!(::Type{T}, dy::Number, ydual::Number) where {T}
-    return extract_derivative(T, ydual)
-end
-
 function myderivative!!(::Type{T}, dy::AbstractArray, ydual::AbstractArray) where {T}
     return extract_derivative!(T, dy, ydual)
 end

ext/DifferentiationInterfaceTrackerExt/DifferentiationInterfaceTrackerExt.jl

@@ -30,16 +30,6 @@ function DI.gradient(f, ::AutoTracker, x, ::NoGradientExtras)
     return data(only(grad))
 end
 
-function DI.value_and_gradient(f, ::AutoTracker, x::Number, ::NoGradientExtras)
-    # fix for https://github.com/FluxML/Tracker.jl/issues/165
-    return f(x), data(only(gradient(f, x)))
-end
-
-function DI.gradient(f, ::AutoTracker, x::Number, ::NoGradientExtras)
-    # fix for https://github.com/FluxML/Tracker.jl/issues/165
-    return data(only(gradient(f, x)))
-end
-
 function DI.value_and_gradient!!(f, grad, backend::AutoTracker, x, extras::NoGradientExtras)
     return DI.value_and_gradient(f, backend, x, extras)
 end

ext/DifferentiationInterfaceZygoteExt/DifferentiationInterfaceZygoteExt.jl

@@ -75,7 +75,7 @@ function DI.hessian(f, ::AnyAutoZygote, x, ::NoHessianExtras)
     return hessian(f, x)
 end
 
-function DI.hessian!!(f, hess, backend::AnyAutoZygote, x, ::NoHessianExtras)
+function DI.hessian!!(f, hess, backend::AnyAutoZygote, x, extras::NoHessianExtras)
     return DI.hessian(f, backend, x, extras)
 end
 

lib/DifferentiationInterfaceTest/src/scenarios/default.jl

@@ -17,8 +17,6 @@ num_to_num_derivative(x) = cos(x)
 num_to_num_second_derivative(x) = -sin(x)
 num_to_num_pushforward(x, dx) = num_to_num_derivative(x) * dx
 num_to_num_pullback(x, dy) = num_to_num_derivative(x) * dy
-num_to_num_gradient(x) = num_to_num_derivative(x)
-num_to_num_hvp(x, v) = num_to_num_second_derivative(x) * v
 
 function num_to_num_scenarios_allocating(x::Number)
     return [
@@ -95,7 +93,7 @@ arr_to_num_gradient(x) = cos.(x)
 arr_to_num_hvp(x, v) = -sin.(x) .* v
 arr_to_num_pushforward(x, dx) = dot(arr_to_num_gradient(x), dx)
 arr_to_num_pullback(x, dy) = arr_to_num_gradient(x) .* dy
-arr_to_num_hessian(x) = Diagonal(-sin.(vec(x)))
+arr_to_num_hessian(x) = Matrix(Diagonal(-sin.(vec(x))))
 
 function arr_to_num_scenarios_allocating(x::AbstractArray)
     return [

lib/DifferentiationInterfaceTest/src/tests/benchmark.jl

@@ -72,7 +72,9 @@ function run_benchmark!(
     (; f, x, y, dx) = deepcopy(scen)
     extras = prepare_pushforward(f, ba, x)
     bench1 = @be mysimilar(y) value_and_pushforward!!(f, _, ba, x, dx, extras)
+    bench2 = @be mysimilar(y) pushforward!!(f, _, ba, x, dx, extras)
     record!(data, ba, value_and_pushforward!!, scen, bench1)
+    record!(data, ba, pushforward!!, scen, bench2)
     return nothing
 end
 
@@ -97,7 +99,9 @@ function run_benchmark!(
     (; f, x, y, dy) = deepcopy(scen)
     extras = prepare_pullback(f, ba, x)
     bench1 = @be mysimilar(x) value_and_pullback!!(f, _, ba, x, dy, extras)
+    bench2 = @be mysimilar(x) pullback!!(f, _, ba, x, dy, extras)
     record!(data, ba, value_and_pullback!!, scen, bench1)
+    record!(data, ba, pullback!!, scen, bench2)
     return nothing
 end
 
@@ -122,7 +126,9 @@ function run_benchmark!(
     (; f, x, y) = deepcopy(scen)
     extras = prepare_derivative(f, ba, x)
     bench1 = @be mysimilar(y) value_and_derivative!!(f, _, ba, x, extras)
+    bench2 = @be mysimilar(y) derivative!!(f, _, ba, x, extras)
     record!(data, ba, value_and_derivative!!, scen, bench1)
+    record!(data, ba, derivative!!, scen, bench2)
     return nothing
 end
 
@@ -147,7 +153,9 @@ function run_benchmark!(
     (; f, x) = deepcopy(scen)
     extras = prepare_gradient(f, ba, x)
     bench1 = @be mysimilar(x) value_and_gradient!!(f, _, ba, x, extras)
+    bench2 = @be mysimilar(x) gradient!!(f, _, ba, x, extras)
     record!(data, ba, value_and_gradient!!, scen, bench1)
+    record!(data, ba, gradient!!, scen, bench2)
     return nothing
 end
 
@@ -160,7 +168,9 @@ function run_benchmark!(
     extras = prepare_jacobian(f, ba, x)
     jac_template = Matrix{eltype(y)}(undef, length(y), length(x))
     bench1 = @be mysimilar(jac_template) value_and_jacobian!!(f, _, ba, x, extras)
+    bench2 = @be mysimilar(jac_template) jacobian!!(f, _, ba, x, extras)
     record!(data, ba, value_and_jacobian!!, scen, bench1)
+    record!(data, ba, jacobian!!, scen, bench2)
     return nothing
 end
 

src/second_derivative.jl

@@ -11,7 +11,6 @@ struct NoSecondDerivativeExtras <: SecondDerivativeExtras end
 
 """
     prepare_second_derivative([other_extras], f, backend, x) -> extras
-    prepare_second_derivative([other_extras], f!, backend, y, x) -> extras
 
 Create an `extras` object subtyping [`SecondDerivativeExtras`](@ref) that can be given to second derivative operators.
 """
@@ -20,7 +19,6 @@ function prepare_second_derivative(::Extras, f_or_f!, backend::AbstractADType, a
 end
 
 prepare_second_derivative(f, ::AbstractADType, x) = NoSecondDerivativeExtras()
-prepare_second_derivative(f!, ::AbstractADType, y, x) = NoSecondDerivativeExtras()
 
 ## Allocating
 

test/first_order.jl

@@ -8,7 +8,7 @@ all_backends = [
     AutoFiniteDifferences(FiniteDifferences.central_fdm(3, 1)),
     AutoForwardDiff(),
     AutoPolyesterForwardDiff(; chunksize=2),
-    AutoReverseDiff(),
+    AutoReverseDiff(; compile=true),
     AutoTapir(),
     AutoTracker(),
     AutoZygote(),