cherry-picked improvements + fixes from jr/mnist (including compat fixes for v0.6) (#47)

* minor broadcast improvements

* refactor code for cleanliness + add some reduction methods

* v0.6 broadcast dispatch compat fix

* circumvent world-age problems in v0.6  tests

* fix accidental method overwrites and NTuple usage in v0.6

* bump dependency versions to include v0.6 fixes

* add docs note mentioning world-age restriction for compiled tapes

* fix v0.6 method ambiguities

* use isapprox instead test_approx_eq_eps

* fix typo

* remove unused type parameter

* test only against tagged versions of DiffBase (ref JuliaDiff/ForwardDiff.jl#185)

* get tests passing on v0.5 again

* add PkgEval badges to README

Author: jrevels

.travis.yml

@@ -9,7 +9,7 @@ notifications:
   email: false
 script:
  - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
- - julia -e 'Pkg.clone(pwd()); Pkg.build("ReverseDiff"); Pkg.checkout("DiffBase"); Pkg.test("ReverseDiff"; coverage=true)'
+ - julia -e 'Pkg.clone(pwd()); Pkg.build("ReverseDiff"); Pkg.test("ReverseDiff"; coverage=true)'
 after_success:
   # push coverage results to Coveralls
   - julia -e 'cd(Pkg.dir("ReverseDiff")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(Coveralls.process_folder())'

README.md

@@ -1,6 +1,8 @@
 # ReverseDiff
 
 [![Build Status](https://travis-ci.org/JuliaDiff/ReverseDiff.jl.svg?branch=master)](https://travis-ci.org/JuliaDiff/ReverseDiff.jl)
+[![ReverseDiff](http://pkg.julialang.org/badges/ReverseDiff_0.5.svg)](http://pkg.julialang.org/?pkg=ReverseDiff)
+[![ReverseDiff](http://pkg.julialang.org/badges/ReverseDiff_0.6.svg)](http://pkg.julialang.org/?pkg=ReverseDiff)
 [![Coverage Status](https://coveralls.io/repos/github/JuliaDiff/ReverseDiff.jl/badge.svg?branch=master)](https://coveralls.io/github/JuliaDiff/ReverseDiff.jl?branch=master)
 
 [**Go To ReverseDiff's Documentation**](http://www.juliadiff.org/ReverseDiff.jl/)

REQUIRE

@@ -1,4 +1,4 @@
 julia 0.5
-DiffBase 0.0.2
-ForwardDiff 0.3.2
-Calculus 0.1.15
+DiffBase 0.0.3
+ForwardDiff 0.3.4
+Calculus 0.2.0

src/ReverseDiff.jl

@@ -30,9 +30,12 @@ const SKIPPED_BINARY_SCALAR_FUNCS = (:isequal, :isless, :<, :>, :(==), :(!=), :(
 include("tape.jl")
 include("tracked.jl")
 include("macros.jl")
+include("derivatives/propagation.jl")
 include("derivatives/scalars.jl")
-include("derivatives/linalg.jl")
 include("derivatives/elementwise.jl")
+include("derivatives/linalg/arithmetic.jl")
+include("derivatives/linalg/reductions.jl")
+include("derivatives/linalg/special.jl")
 include("api/utils.jl")
 include("api/Config.jl")
 include("api/tape.jl")

src/api/Config.jl

@@ -105,6 +105,7 @@ function JacobianConfig{D}(output::AbstractArray{D}, input::Tuple, tp::RawTape =
     return _JacobianConfig(cfg_input, cfg_output, tp)
 end
 
+# we dispatch on V<:Real here because RawTape is actually also an AbstractArray
 function JacobianConfig{D,V<:Real}(output::AbstractArray{D}, input::AbstractArray{V}, tp::RawTape = RawTape())
     cfg_input = track(similar(input), D, tp)
     cfg_output = track!(similar(output, TrackedReal{D,D,Void}), output, tp)

src/api/gradients.jl

@@ -44,9 +44,9 @@ function gradient!(result, f, input, cfg::GradientConfig = GradientConfig(input)
     return result
 end
 
-#############################
+###########################
 # Executing GradientTapes #
-#############################
+###########################
 
 """
     ReverseDiff.gradient!(tape::Union{GradientTape,CompiledGradient}, input)

src/api/hessians.jl

@@ -56,9 +56,9 @@ function hessian!(result::DiffResult, f, input::AbstractArray,
     return result
 end
 
-############################
+##########################
 # Executing HessianTapes #
-############################
+##########################
 
 """
     ReverseDiff.hessian!(tape::Union{HessianTape,CompiledHessian}, input)

src/api/jacobians.jl

@@ -80,9 +80,9 @@ function jacobian!(result, f!, output, input, cfg::JacobianConfig = JacobianConf
     return result
 end
 
-#############################
+###########################
 # Executing JacobianTapes #
-#############################
+###########################
 
 """
     ReverseDiff.jacobian!(tape::Union{JacobianTape,CompiledJacobian}, input)

src/api/tape.jl

@@ -73,6 +73,11 @@ object can be passed to any API methods that accept `t`.
 In many cases, compiling `t` can significantly speed up execution time. Note that the longer
 the tape, the more time compilation may take. Very long tapes (i.e. when `length(t)` is on
 the order of 10000 elements) can take a very long time to compile.
+
+Note that this function calls `eval` in the `current_module()` to generate functions
+from `t`. Thus, the returned `Compiled*` type will only be useable once the world-age
+counter has caught up with the world-age of the `eval`'d functions (i.e. once the call
+stack has bubbled up to top level).
 """
 function compile(t::AbstractTape)
     return Compiled(typeof(t), t.func, t.input, t.output,
@@ -93,7 +98,7 @@ The arguments to `ReverseDiff.compile_gradient` are the same as the arguments to
 
 The usage restrictions on the returned function are the same as the usage restrictions
 for calling `gradient!(result, tape, input)` where `tape` is a compiled `GradientTape`;
-see `ReverseDiff.compile` for details.
+see `ReverseDiff.compile` for details (including an important note on world-age).
 """
 function compile_gradient(f, args...)
     tape = compile(GradientTape(f, args...))
@@ -115,7 +120,7 @@ this means `ReverseDiff.compile_jacobian` also supports target functions of the
 
 The usage restrictions on the returned function are the same as the usage restrictions
 for calling `jacobian!(result, tape, input)` where `tape` is a compiled `JacobianTape`;
-see `ReverseDiff.compile` for details.
+see `ReverseDiff.compile` for details (including an important note on world-age).
 """
 function compile_jacobian(f, args...)
     tape = compile(JacobianTape(f, args...))
@@ -135,7 +140,7 @@ The arguments to `ReverseDiff.compile_hessian` are the same as the arguments to
 
 The usage restrictions on the returned function are the same as the usage restrictions
 for calling `hessian!(result, tape, input)` where `tape` is a compiled `HessianTape`;
-see `ReverseDiff.compile` for details.
+see `ReverseDiff.compile` for details (including an important note on world-age).
 """
 function compile_hessian(f, args...)
     tape = compile(HessianTape(f, args...))