Rename second_derivative -> secondderivative

docs/src/implementer_guide.md

@@ -34,9 +34,9 @@ They are just listed here to help readers figure out the code structure:
   - `value_and_derivative` calls `value_and_jacobian`
   - `value_and_gradient` calls `value_and_jacobian`
   - `value_and_hessian` calls `jacobian` and `gradient`
-  - `value_and_second_derivative` calls `second_derivative`
+  - `value_and_second_derivative` calls `secondderivative`
   - `value_gradient_and_hessian` calls `value_and_jacobian` and `gradient`
-  - `value_derivative_and_second_derivative` calls `value_and_derivative` and `second_derivative`
+  - `value_derivative_and_second_derivative` calls `value_and_derivative` and `secondderivative`
   - `pushforward_function` calls `jacobian`
   - `value_and_pushforward_function` calls `pushforward_function`
   - `pullback_function` calls `value_and_pullback_function`

docs/src/user_guide.md

@@ -59,7 +59,7 @@ The following list of functions can be used to request the derivative, gradient,
 AbstractDifferentiation.derivative
 AbstractDifferentiation.gradient
 AbstractDifferentiation.jacobian
-AbstractDifferentiation.second_derivative
+AbstractDifferentiation.secondderivative
 AbstractDifferentiation.hessian
 ```
 

src/AbstractDifferentiation.jl

@@ -86,13 +86,13 @@ function jacobian(ab::HigherOrderBackend, f, xs...)
 end
 
 """
-    AD.second_derivative(ab::AD.AbstractBackend, f, xs...)
+    AD.secondderivative(ab::AD.AbstractBackend, f, xs...)
 
 Compute the second derivative of `f` with respect to the input `x` using the backend `ab`.
 
-The function returns a single value because `second_derivative` currently only supports a single input.
+The function returns a single value because `secondderivative` currently only supports a single input.
 """
-function second_derivative(ab::AbstractBackend, f, x)
+function secondderivative(ab::AbstractBackend, f, x)
     if x isa Tuple
         # only support computation of second derivative for functions with single input argument
         x = only(x)
@@ -162,10 +162,10 @@ end
 
 Return the tuple `(v, d2)` of the function value `v = f(x)` and the second derivatives `d = AD.derivative(ab, f, x)` and `d2 = AD.hessian(ab, f, x)`.
 
-See also [`AbstractDifferentiation.second_derivative`](@ref)
+See also [`AbstractDifferentiation.secondderivative`](@ref)
 """
 function value_and_second_derivative(ab::AbstractBackend, f, x)
-    return f(x), second_derivative(ab, f, x)
+    return f(x), secondderivative(ab, f, x)
 end
 
 """
@@ -208,7 +208,7 @@ end
 """
     AD.value_and_derivatives(ab::AD.AbstractBackend, f, x)
 
-Return the tuple `(v, d, d2)` of the function value `v = f(x)` and the first and second derivatives `d = AD.derivative(ab, f, x)` and `d2 = AD.second_derivative(ab, f, x)`.
+Return the tuple `(v, d, d2)` of the function value `v = f(x)` and the first and second derivatives `d = AD.derivative(ab, f, x)` and `d2 = AD.secondderivative(ab, f, x)`.
 """
 function value_and_derivatives(ab::AbstractBackend, f, x)
     if x isa Tuple
@@ -217,14 +217,14 @@ function value_and_derivatives(ab::AbstractBackend, f, x)
     end
 
     value = f(x)
-    deriv, second_deriv = value_and_derivative(
+    deriv, secondderiv = value_and_derivative(
         second_lowest(ab), _x -> begin
             d = derivative(lowest(ab), f, _x)
             return d[1] # derivative returns a tuple
         end, x
     )
 
-    return value, (deriv,), second_deriv
+    return value, (deriv,), secondderiv
 end
 
 """

test/test_utils.jl

@@ -151,16 +151,16 @@ function test_second_derivatives(backend; multiple_inputs=false, test_types=true
     else
         # explicit test that AbstractDifferentiation throws an error
         # don't support tuple of second derivatives
-        @test_throws ArgumentError AD.second_derivative(
+        @test_throws ArgumentError AD.secondderivative(
             backend, x -> fder(x, yscalar), (xscalar, yscalar)
         )
-        @test_throws MethodError AD.second_derivative(
+        @test_throws MethodError AD.secondderivative(
             backend, x -> fder(x, yscalar), xscalar, yscalar
         )
     end
 
     # test if single input (no tuple works)
-    dder1 = AD.second_derivative(backend, x -> fder(x, yscalar), xscalar)
+    dder1 = AD.secondderivative(backend, x -> fder(x, yscalar), xscalar)
     if test_types
         @test dder1[1] isa Float64
     end