switch DiffBase dependency over to DiffRules/DiffTests/DiffResults, remove RealInterface dependency (#262)

Author: jrevels

REQUIRE

@@ -1,8 +1,8 @@
 julia 0.6.0
 Compat 0.31.0
 StaticArrays 0.5.0
-DiffBase 0.3.2 0.4.0
+DiffResults 0.0.1
+DiffRules 0.0.1
 NaNMath 0.2.2
 SpecialFunctions 0.1.0
-RealInterface 0.0.2
 CommonSubexpressions 0.0.1

appveyor.yml

@@ -1,6 +1,7 @@
 environment:
   matrix:
-  - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x64/julia-latest-win64.exe"
+  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.6/julia-0.6-latest-win32.exe"
+  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.6/julia-0.6-latest-win64.exe"
 
 branches:
   only:

benchmarks/benchmarks.jl

@@ -1,4 +1,4 @@
-using ForwardDiff, DiffBase
+using ForwardDiff, DiffTests, DiffResults
 using BenchmarkTools
 
 include(joinpath(dirname(dirname(@__FILE__)), "test", "utils.jl"))
@@ -16,44 +16,44 @@ const gradient_group = addgroup!(SUITE, "gradient")
 const jacobian_group = addgroup!(SUITE, "jacobian")
 const hessian_group = addgroup!(SUITE, "hessian")
 
-for f in (DiffBase.NUMBER_TO_NUMBER_FUNCS..., DiffBase.NUMBER_TO_ARRAY_FUNCS...)
+for f in (DiffTests.NUMBER_TO_NUMBER_FUNCS..., DiffTests.NUMBER_TO_ARRAY_FUNCS...)
     x = 1.0
     y = f(x)
 
     value_group[name(f)] = @benchmarkable $(f)($x)
 
-    out = isa(y, Number) ? DiffBase.DiffResult(y, y) : DiffBase.DiffResult(similar(y), similar(y))
+    out = isa(y, Number) ? DiffResults.DiffResult(y, y) : DiffResults.DiffResult(similar(y), similar(y))
     derivative_group[name(f)] = @benchmarkable ForwardDiff.derivative!($out, $f, $x)
 end
 
-for f in (DiffBase.VECTOR_TO_NUMBER_FUNCS..., DiffBase.MATRIX_TO_NUMBER_FUNCS...)
+for f in (DiffTests.VECTOR_TO_NUMBER_FUNCS..., DiffTests.MATRIX_TO_NUMBER_FUNCS...)
     fval = addgroup!(value_group, name(f))
     fgrad = addgroup!(gradient_group, name(f))
     fhess = addgroup!(hessian_group, name(f))
-    arrs = in(f, DiffBase.VECTOR_TO_NUMBER_FUNCS) ? vecs : mats
+    arrs = in(f, DiffTests.VECTOR_TO_NUMBER_FUNCS) ? vecs : mats
     for x in arrs
         y = f(x)
 
         fval[length(x)] = @benchmarkable $(f)($x)
 
-        gout = DiffBase.DiffResult(y, similar(x, typeof(y)))
+        gout = DiffResults.DiffResult(y, similar(x, typeof(y)))
         gcfg = ForwardDiff.GradientConfig(nothing, x)
         fgrad[length(x)] = @benchmarkable ForwardDiff.gradient!($gout, $f, $x, $gcfg)
 
-        hout = DiffBase.DiffResult(y, similar(x, typeof(y)), similar(x, typeof(y), length(x), length(x)))
+        hout = DiffResults.DiffResult(y, similar(x, typeof(y)), similar(x, typeof(y), length(x), length(x)))
         hcfg = ForwardDiff.HessianConfig(nothing, hout, x)
         fhess[length(x)] = @benchmarkable ForwardDiff.hessian!($hout, $f, $x, $hcfg)
     end
 end
 
-for f in DiffBase.ARRAY_TO_ARRAY_FUNCS
+for f in DiffTests.ARRAY_TO_ARRAY_FUNCS
     fval = addgroup!(value_group, name(f))
     fjac = addgroup!(jacobian_group, name(f))
     for x in mats
         y = f(x)
         fval[length(x)] = @benchmarkable $(f)($x)
 
-        out = DiffBase.JacobianResult(y, x)
+        out = DiffResults.JacobianResult(y, x)
         cfg = ForwardDiff.JacobianConfig(nothing, y, x)
         fjac[length(x)] = @benchmarkable ForwardDiff.jacobian!($out, $f, $y, $x, $cfg)
     end

docs/src/dev/contributing.md

@@ -14,19 +14,15 @@ If you're new GitHub, here's an outline of the workflow you should use:
 ## Adding New Derivative Definitions
 
 In general, new derivative implementations for `Dual` are automatically defined via simple
-symbolic rules. ForwardDiff accomplishes this by looping over the [the function names listed
-in the RealInterface package](https://github.com/jrevels/RealInterface.jl), and for every
-function (and relevant arity), it attempts to generate a `Dual` definition by applying the
-[symbolic rules provided by the DiffBase package](https://github.com/JuliaDiff/DiffBase.jl/blob/master/src/rules.jl).
-Conveniently, these auto-generated definitions are also automatically tested.
-
-Thus, in order to add a new derivative implementation for `Dual`, you should do the
-following:
-
-1. Make sure the name of the function is appropriately listed in the RealInterface package
-2. Define the appropriate derivative rule(s) in DiffBase
-3. Check that calling the function on `Dual` instances delivers the desired result.
-
-Depending on the arity of your function and its category in RealInterface, ForwardDiff's
-auto-definition mechanism might need to be expanded to include it. If this is the case,
-ForwardDiff's maintainers can help you out.
+symbolic rules. ForwardDiff accomplishes this by looping over the rules provided by
+[the DiffRules package](https://github.com/JuliaDiff/DiffRules.jl) and using them to
+auto-generate `Dual` definitions. Conveniently, these auto-generated definitions are also
+automatically tested.
+
+Thus, in order to add a new derivative implementation for `Dual`, you should define the
+appropriate derivative rule(s) in DiffRules, and then check that calling the function on
+`Dual` instances delivers the desired result.
+
+Depending on your function, ForwardDiff's auto-definition mechanism might need to be
+expanded to support it. If this is the case, file an issue/PR so that ForwardDiff's
+maintainers can help you out.

docs/src/user/advanced.md

@@ -12,14 +12,11 @@ this task!**
 
 In the course of calculating higher-order derivatives, ForwardDiff ends up calculating all
 the lower-order derivatives and primal value `f(x)`. To retrieve these results in one fell
-swoop, you can utilize the DiffResult API provided by the DiffBase package. To learn how to
-use this functionality, please consult the [relevant DiffBase
-documentation](http://www.juliadiff.org/DiffBase.jl/stable/diffresultapi.html).
+swoop, you can utilize the [DiffResults](https://github.com/JuliaDiff/DiffResults.jl) API.
 
-Note that running `using ForwardDiff` will automatically bring the `DiffBase` module
-into scope, and that all mutating ForwardDiff API methods support the DiffResult API.
-In other words, API methods of the form `ForwardDiff.method!(out, args...)` will
-work appropriately if `isa(out, DiffResult)`.
+All mutating ForwardDiff API methods support the DiffResults API. In other words, API
+methods of the form `ForwardDiff.method!(out, args...)` will work appropriately if
+`isa(out, DiffResults.DiffResult)`.
 
 ## Configuring Chunk Size
 
@@ -141,9 +138,8 @@ decrease performance (~5%-10% on our benchmarks).
 
 In order to preserve performance in the majority of use cases, ForwardDiff disables this
 check by default. If your code is affected by this `NaN` behvaior, you can enable
-ForwardDiff's `NaN`-safe mode by setting `NANSAFE_MODE_ENABLED` to `true` in
-ForwardDiff's source. This constant is located in `src/ForwardDiff.jl` in the
-package's directory.
+ForwardDiff's `NaN`-safe mode by setting the `NANSAFE_MODE_ENABLED` constant to `true` in
+ForwardDiff's source.
 
 In the future, we plan on allowing users and downstream library authors to dynamically
 enable [NaN`-safe mode via the `AbstractConfig`

docs/src/user/upgrade.md

@@ -80,6 +80,14 @@ out = ForwardDiff.hessian!(out, f, x) # re-alias output!
 v = DiffBase.value(out)
 g = DiffBase.gradient(out)
 h = DiffBase.hessian(out)
+
+# ForwardDiff v0.7 & above
+using DiffResults
+out = DiffResults.HessianResult(x)
+out = ForwardDiff.hessian!(out, f, x) # re-alias output!
+v = DiffResults.value(out)
+g = DiffResults.gradient(out)
+h = DiffResults.hessian(out)
 ```
 
 ## Higher-Order Differentiation

src/ForwardDiff.jl

@@ -2,63 +2,29 @@ __precompile__()
 
 module ForwardDiff
 
-using DiffBase
-using DiffBase: DiffResult, MutableDiffResult, ImmutableDiffResult
+using DiffRules, DiffResults
+using DiffResults: DiffResult, MutableDiffResult, ImmutableDiffResult
 using StaticArrays
 using Compat
 
 import NaNMath
 import SpecialFunctions
-import RealInterface
 import CommonSubexpressions
 
-#############################
-# types/functions/constants #
-#############################
-
-const NANSAFE_MODE_ENABLED = false
-
-const REAL_TYPES = (AbstractFloat, Irrational, Integer, Rational, Real, Irrational{:e}, Irrational{:π})
-
-const DEFAULT_CHUNK_THRESHOLD = 10
-
-struct Chunk{N} end
-
-function Chunk(input_length::Integer, threshold::Integer = DEFAULT_CHUNK_THRESHOLD)
-    N = pickchunksize(input_length, threshold)
-    return Chunk{N}()
-end
-
-function Chunk(x::AbstractArray, threshold::Integer = DEFAULT_CHUNK_THRESHOLD)
-    return Chunk(length(x), threshold)
-end
-
-# Constrained to `N <= threshold`, minimize (in order of priority):
-#   1. the number of chunks that need to be computed
-#   2. the number of "left over" perturbations in the final chunk
-function pickchunksize(input_length, threshold = DEFAULT_CHUNK_THRESHOLD)
-    if input_length <= threshold
-        return input_length
-    else
-        nchunks = round(Int, input_length / DEFAULT_CHUNK_THRESHOLD, RoundUp)
-        return round(Int, input_length / nchunks, RoundUp)
-    end
-end
-
-############
-# includes #
-############
-
+include("prelude.jl")
 include("partials.jl")
 include("dual.jl")
 include("config.jl")
-include("utils.jl")
+include("apiutils.jl")
 include("derivative.jl")
 include("gradient.jl")
 include("jacobian.jl")
 include("hessian.jl")
 include("deprecated.jl")
 
-export DiffBase
+# This is a deprecation binding and should be removed in the next minor release.
+const DiffBase = DiffResults
+
+export DiffBase, DiffResults
 
 end # module

src/utils.jl renamed to src/apiutils.jl

@@ -2,15 +2,15 @@
 # value extraction #
 ####################
 
-@inline extract_value!(out::DiffResult, ydual) = DiffBase.value!(value, out, ydual)
+@inline extract_value!(out::DiffResult, ydual) = DiffResults.value!(value, out, ydual)
 @inline extract_value!(out, ydual) = out
 
 @inline function extract_value!(out, y, ydual)
     map!(value, y, ydual)
     copy_value!(out, y)
 end
 
-@inline copy_value!(out::DiffResult, y) = DiffBase.value!(out, y)
+@inline copy_value!(out::DiffResult, y) = DiffResults.value!(out, y)
 @inline copy_value!(out, y) = out
 
 ###################################

src/config.jl

@@ -233,7 +233,7 @@ function HessianConfig(f::F,
                        x::AbstractArray{V},
                        chunk::Chunk = Chunk(x),
                        tag::Tag = Tag(F, Dual{Void,V,0})) where {F,V}
-    jacobian_config = JacobianConfig(nothing, DiffBase.gradient(result), x, chunk)
+    jacobian_config = JacobianConfig(nothing, DiffResults.gradient(result), x, chunk)
     gradient_config = GradientConfig(f, jacobian_config.duals[2], chunk, tag)
     return HessianConfig(jacobian_config, gradient_config)
 end

src/derivative.jl

@@ -83,4 +83,4 @@ end
 #----------#
 
 extract_derivative!(result::AbstractArray, y::AbstractArray) = map!(extract_derivative, result, y)
-extract_derivative!(result::DiffResult, y) = DiffBase.derivative!(extract_derivative, result, y)
+extract_derivative!(result::DiffResult, y) = DiffResults.derivative!(extract_derivative, result, y)