Merge pull request #2 from nickrobinson251/npr/decide-name

oxinabox · web-flow · commit cbbf4bc157c3 · 2019-08-02T14:43:18.000-05:00
Name package `ChainRulesCore.jl`
diff --git a/LICENSE.md b/LICENSE.md
@@ -1,6 +1,7 @@
-The AbstractChainRules.jl package is licensed under the MIT "Expat" License:
+The ChainRulesCore.jl package is licensed under the MIT "Expat" License:
 
-> Copyright (c) 2018: Jarrett Revels.
+> Copyright (c) 2018-2019: Jarrett Revels, and other JuliaDiff Contributors:
+> https://github.com/JuliaDiff/ChainRulesCore.jl/contributors
 >
 > Permission is hereby granted, free of charge, to any person obtaining a copy
 > of this software and associated documentation files (the "Software"), to deal
diff --git a/Project.toml b/Project.toml
@@ -1,11 +1,10 @@
-name = "AbstractChainRules"
+name = "ChainRulesCore"
 uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"
 version = "0.1.0"
 
 [deps]
 Cassette = "7057c7e9-c182-5462-911a-8362d720325c"
 
-
 [compat]
 Cassette = "^0.2"
 julia = "^1.0"
diff --git a/README.md b/README.md
@@ -1,10 +1,10 @@
-# AbstractChainRules
+# ChainRulesCore
 
-[![Travis](https://travis-ci.org/JuliaDiff/AbstractChainRules.jl.svg?branch=master)](https://travis-ci.org/JuliaDiff/AbstractChainRules.jl)
-[![Coveralls](https://coveralls.io/repos/github/JuliaDiff/AbstractChainRules.jl/badge.svg?branch=master)](https://coveralls.io/github/JuliaDiff/AbstractChainRules.jl?branch=master)
-[![](https://img.shields.io/badge/docs-latest-blue.svg)](https://JuliaDiff.github.io/AbstractChainRules.jl/latest)
+[![Travis](https://travis-ci.org/JuliaDiff/ChainRulesCore.jl.svg?branch=master)](https://travis-ci.org/JuliaDiff/ChainRulesCore.jl)
+[![Coveralls](https://coveralls.io/repos/github/JuliaDiff/ChainRulesCore.jl/badge.svg?branch=master)](https://coveralls.io/github/JuliaDiff/ChainRulesCore.jl?branch=master)
+[![](https://img.shields.io/badge/docs-latest-blue.svg)](https://JuliaDiff.github.io/ChainRulesCore.jl/latest)
 
-The AbstractChainRules package provides a variety of common utilities that can be used by downstream automatic differentiation (AD) tools to define and execute forward-, reverse-, and mixed-mode primitives.
+The ChainRulesCore package provides a variety of common utilities that can be used by downstream automatic differentiation (AD) tools to define and execute forward-, reverse-, and mixed-mode primitives.
 
 This package is a WIP; the framework is essentially there, but there are a bunch of TODOs, virtually no tests, etc. PRs welcome! Documentation is incoming, which should help if you'd like to contribute.
 
@@ -18,4 +18,4 @@ Here are some of the basic goals for the package:
 
 - Control-inverted design: rule authors can fully specify derivatives in a concise manner while naturally allowing the caller to compute only what they need.
 
-The AbstractChainRules source code follows the [YASGuide](https://github.com/jrevels/YASGuide).
+The ChainRulesCore source code follows the [YASGuide](https://github.com/jrevels/YASGuide).
diff --git a/docs/Project.toml b/docs/Project.toml
@@ -1,4 +1,5 @@
 [deps]
+ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 
 [compat]
diff --git a/docs/make.jl b/docs/make.jl
@@ -1,11 +1,11 @@
-using AbstractChainRules
+using ChainRulesCore
 using Documenter
 
-makedocs(modules=[AbstractChainRules],
-         sitename="AbstractChainRules",
+makedocs(modules=[ChainRulesCore],
+         sitename="ChainRulesCore",
          authors="Jarrett Revels and other contributors",
          pages=["Introduction" => "index.md",
                 "Getting Started" => "getting_started.md",
-                "AbstractChainRules API Documentation" => "api.md"])
+                "ChainRulesCore API Documentation" => "api.md"])
 
-deploydocs(repo="github.com/JuliaDiff/AbstractChainRules.jl.git")
+deploydocs(repo="github.com/JuliaDiff/ChainRulesCore.jl.git")
diff --git a/docs/src/api.md b/docs/src/api.md
@@ -1,24 +1,24 @@
-# AbstractChainRules API Documentation
+# ChainRulesCore API Documentation
 
 ```@docs
-AbstractChainRules.frule
-AbstractChainRules.rrule
-AbstractChainRules.AbstractRule
-AbstractChainRules.Rule
-AbstractChainRules.DNERule
-AbstractChainRules.WirtingerRule
-AbstractChainRules.accumulate
-AbstractChainRules.accumulate!
-AbstractChainRules.store!
+ChainRulesCore.frule
+ChainRulesCore.rrule
+ChainRulesCore.AbstractRule
+ChainRulesCore.Rule
+ChainRulesCore.DNERule
+ChainRulesCore.WirtingerRule
+ChainRulesCore.accumulate
+ChainRulesCore.accumulate!
+ChainRulesCore.store!
 ```
 
 ```@docs
-AbstractChainRules.AbstractDifferential
-AbstractChainRules.extern
-AbstractChainRules.Casted
-AbstractChainRules.Wirtinger
-AbstractChainRules.Thunk
-AbstractChainRules.Zero
-AbstractChainRules.DNE
-AbstractChainRules.One
+ChainRulesCore.AbstractDifferential
+ChainRulesCore.extern
+ChainRulesCore.Casted
+ChainRulesCore.Wirtinger
+ChainRulesCore.Thunk
+ChainRulesCore.Zero
+ChainRulesCore.DNE
+ChainRulesCore.One
 ```
diff --git a/docs/src/index.md b/docs/src/index.md
@@ -1,10 +1,10 @@
 ```@meta
-DocTestSetup = :(using AbstractChainRules)
-CurrentModule = AbstractChainRules
+DocTestSetup = :(using ChainRulesCore)
+CurrentModule = ChainRulesCore
 ```
 
-# AbstractChainRules
+# ChainRulesCore
 
-Hello! Welcome to AbstractChainRules's documentation.
+Hello! Welcome to ChainRulesCore's documentation.
 
-For an initial overview of AbstractChainRules, please see the README. Otherwise, feel free to peruse available documentation via the sidebar.
+For an initial overview of ChainRulesCore, please see the README. Otherwise, feel free to peruse available documentation via the sidebar.
diff --git a/src/ChainRulesCore.jl b/src/ChainRulesCore.jl
@@ -1,4 +1,4 @@
-module AbstractChainRules
+module ChainRulesCore
 using Cassette
 using Base.Broadcast: materialize, materialize!, broadcasted, Broadcasted, broadcastable
 
diff --git a/src/differentials.jl b/src/differentials.jl
@@ -140,7 +140,7 @@ function mul_wirtinger(a::Wirtinger, b::Wirtinger)
           such that we assume the chain rule application is of the form `f_a ∘ f_b`
           instead of `f_b ∘ f_a`. However, picking such a convention is likely to
           lead to silently incorrect derivatives due to commutativity assumptions
-          in downstream generic code that deals with the reals. Thus, AbstractChainRules
+          in downstream generic code that deals with the reals. Thus, ChainRulesCore
           makes this operation an error instead.
           """)
 end
diff --git a/src/rules.jl b/src/rules.jl
@@ -12,7 +12,7 @@ return that calculated differential value.
 For example:
 
 ```julia-repl
-julia> using AbstractChainRules: frule, rrule, AbstractRule
+julia> using ChainRulesCore: frule, rrule, AbstractRule
 
 julia> x, y = rand(2);
 
@@ -61,7 +61,7 @@ Base.getindex(rule::AbstractRule, i::Integer) = i == 1 ? rule : throw(BoundsErro
 """
     accumulate(Δ, rule::AbstractRule, args...)
 
-Return `Δ + rule(args...)` evaluated in a manner that supports AbstractChainRules'
+Return `Δ + rule(args...)` evaluated in a manner that supports ChainRulesCore'
 various `AbstractDifferential` types.
 
 This method intended to be customizable for specific rules/input types. For
@@ -206,7 +206,7 @@ rules, where e.g. `frule` is used within a `rrule` definition. For example,
 broadcasted functions may not themselves be forward-mode *primitives*, but are
 often forward-mode *differentiable*.
 
-AbstractChainRules, by design, is decoupled from any specific AD implementation. How,
+ChainRulesCore, by design, is decoupled from any specific AD implementation. How,
 then, do we know which AD to fall back to when there isn't a primitive defined?
 
 Well, if you're a greedy AD implementation, you can just overload `frule` and/or
@@ -218,12 +218,12 @@ It turns out, Cassette solves this problem nicely by allowing AD authors to
 overload the fallbacks w.r.t. their own context. Example using ForwardDiff:
 
 ```
-using AbstractChainRules, ForwardDiff, Cassette
+using ChainRulesCore, ForwardDiff, Cassette
 
 Cassette.@context MyChainRuleCtx
 
 # ForwardDiff, itself, can call `my_frule` instead of
-# `frule` to utilize the ForwardDiff-injected AbstractChainRules
+# `frule` to utilize the ForwardDiff-injected ChainRulesCore
 # infrastructure
 my_frule(args...) = Cassette.overdub(MyChainRuleCtx(), frule, args...)
 
@@ -367,15 +367,15 @@ A convenience macro that generates simple scalar forward or reverse rules using
 the provided partial derivatives. Specifically, generates the corresponding
 methods for `frule` and `rrule`:
 
-    function AbstractChainRules.frule(::typeof(f), x₁::Number, x₂::Number, ...)
+    function ChainRulesCore.frule(::typeof(f), x₁::Number, x₂::Number, ...)
         Ω = f(x₁, x₂, ...)
         \$(statement₁, statement₂, ...)
         return Ω, (Rule((Δx₁, Δx₂, ...) -> ∂f₁_∂x₁ * Δx₁ + ∂f₁_∂x₂ * Δx₂ + ...),
                    Rule((Δx₁, Δx₂, ...) -> ∂f₂_∂x₁ * Δx₁ + ∂f₂_∂x₂ * Δx₂ + ...),
                    ...)
     end
 
-    function AbstractChainRules.rrule(::typeof(f), x₁::Number, x₂::Number, ...)
+    function ChainRulesCore.rrule(::typeof(f), x₁::Number, x₂::Number, ...)
         Ω = f(x₁, x₂, ...)
         \$(statement₁, statement₂, ...)
         return Ω, (Rule((ΔΩ₁, ΔΩ₂, ...) -> ∂f₁_∂x₁ * ΔΩ₁ + ∂f₂_∂x₁ * ΔΩ₂ + ...),
@@ -410,7 +410,7 @@ is equivalent to:
                  (∂f₂_∂x₁, ∂f₂_∂x₂, ...),
                  ...)
 
-For examples, see AbstractChainRules' `rules` directory.
+For examples, see ChainRulesCore' `rules` directory.
 
 See also: [`frule`](@ref), [`rrule`](@ref), [`AbstractRule`](@ref)
 """
@@ -450,12 +450,12 @@ macro scalar_rule(call, maybe_setup, partials...)
     forward_rules = length(forward_rules) == 1 ? forward_rules[1] : Expr(:tuple, forward_rules...)
     reverse_rules = length(reverse_rules) == 1 ? reverse_rules[1] : Expr(:tuple, reverse_rules...)
     return quote
-        function AbstractChainRules.frule(::typeof($f), $(inputs...))
+        function ChainRulesCore.frule(::typeof($f), $(inputs...))
             $(esc(:Ω)) = $call
             $(setup_stmts...)
             return $(esc(:Ω)), $forward_rules
         end
-        function AbstractChainRules.rrule(::typeof($f), $(inputs...))
+        function ChainRulesCore.rrule(::typeof($f), $(inputs...))
             $(esc(:Ω)) = $call
             $(setup_stmts...)
             return $(esc(:Ω)), $reverse_rules
diff --git a/test/rules.jl b/test/rules.jl
@@ -14,9 +14,9 @@ dummy_identity(x) = x
         @test rrule(cool, 1) === nothing
         @test rrule(cool, 1; iscool=true) === nothing
 
-        AbstractChainRules.@scalar_rule(Main.cool(x), one(x))
+        ChainRulesCore.@scalar_rule(Main.cool(x), one(x))
         @test hasmethod(rrule, Tuple{typeof(cool),Number})
-        AbstractChainRules.@scalar_rule(Main.cool(x::String), "wow such dfdx")
+        ChainRulesCore.@scalar_rule(Main.cool(x::String), "wow such dfdx")
         @test hasmethod(rrule, Tuple{typeof(cool),String})
         # Ensure those are the *only* methods that have been defined
         cool_methods = Set(m.sig for m in methods(rrule) if _second(m.sig) == typeof(cool))
diff --git a/test/runtests.jl b/test/runtests.jl
@@ -1,16 +1,16 @@
 # TODO: more tests!
 
-using AbstractChainRules, Test
+using ChainRulesCore, Test
 using LinearAlgebra: Diagonal
-using AbstractChainRules: extern, accumulate, accumulate!, store!, @scalar_rule,
+using ChainRulesCore: extern, accumulate, accumulate!, store!, @scalar_rule,
     Wirtinger, wirtinger_primal, wirtinger_conjugate, add_wirtinger, mul_wirtinger,
     Zero, add_zero, mul_zero, One, add_one, mul_one, Casted, cast, add_casted, mul_casted,
     DNE, Thunk, Casted, DNERule
 using Base.Broadcast: broadcastable
 
 #include("test_util.jl")
 
-@testset "AbstractChainRules" begin
+@testset "ChainRulesCore" begin
     include("differentials.jl")
     include("rules.jl")
 end
diff --git a/test/test_util.jl b/test/test_util.jl
@@ -18,7 +18,7 @@ end
 
 function frule_test(f, xẋs::Tuple{Any, Any}...; rtol=1e-9, atol=1e-9, fdm=_fdm, kwargs...)
     xs, ẋs = collect(zip(xẋs...))
-    Ω, dΩ_rule = AbstractChainRules.frule(f, xs...)
+    Ω, dΩ_rule = ChainRulesCore.frule(f, xs...)
     @test f(xs...) == Ω
 
     dΩ_ad, dΩ_fd = dΩ_rule(ẋs...), jvp(fdm, xs->f(xs...), (xs, ẋs))
@@ -38,14 +38,14 @@ All keyword arguments except for `fdm` are passed to `isapprox`.
 """
 function rrule_test(f, ȳ, (x, x̄)::Tuple{Any, Any}; rtol=1e-9, atol=1e-9, fdm=_fdm, kwargs...)
     # Check correctness of evaluation.
-    fx, dx = AbstractChainRules.rrule(f, x)
+    fx, dx = ChainRulesCore.rrule(f, x)
     @test fx ≈ f(x)
 
     # Correctness testing via finite differencing.
     x̄_ad, x̄_fd = dx(ȳ), j′vp(fdm, f, ȳ, x)
     @test isapprox(x̄_ad, x̄_fd; rtol=rtol, atol=atol, kwargs...)
 
-    # Assuming x̄_ad to be correct, check that other AbstractChainRules mechanisms are correct.
+    # Assuming x̄_ad to be correct, check that other ChainRulesCore mechanisms are correct.
     test_accumulation(x̄, dx, ȳ, x̄_ad)
     test_accumulation(Zero(), dx, ȳ, x̄_ad)
 end
@@ -97,7 +97,7 @@ function rrule_test(f, ȳ, xx̄s::Tuple{Any, Any}...; rtol=1e-9, atol=1e-9, fdm
         end
     end
 
-    # Assuming the above to be correct, check that other AbstractChainRules mechanisms are correct.
+    # Assuming the above to be correct, check that other ChainRulesCore mechanisms are correct.
     for (x̄, rule, x̄_ad) in zip(x̄s, rules, x̄s_ad)
         x̄ === nothing && continue
         test_accumulation(x̄, rule, ȳ, x̄_ad)
@@ -119,7 +119,7 @@ function Base.isapprox(d_ad::Thunk, d_fd; kwargs...)
 end
 
 function test_accumulation(x̄, dx, ȳ, partial)
-    @test all(extern(AbstractChainRules.add(x̄, partial)) .≈ extern(x̄) .+ extern(partial))
+    @test all(extern(ChainRulesCore.add(x̄, partial)) .≈ extern(x̄) .+ extern(partial))
     test_accumulate(x̄, dx, ȳ, partial)
     test_accumulate!(x̄, dx, ȳ, partial)
     test_store!(x̄, dx, ȳ, partial)

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`		`-The AbstractChainRules.jl package is licensed under the MIT "Expat" License:`
	`1`	`+The ChainRulesCore.jl package is licensed under the MIT "Expat" License:`
`2`	`2`
`3`		`-> Copyright (c) 2018: Jarrett Revels.`
	`3`	`+> Copyright (c) 2018-2019: Jarrett Revels, and other JuliaDiff Contributors:`
	`4`	`+> https://github.com/JuliaDiff/ChainRulesCore.jl/contributors`
`4`	`5`	`>`
`5`	`6`	`> Permission is hereby granted, free of charge, to any person obtaining a copy`
`6`	`7`	`> of this software and associated documentation files (the "Software"), to deal`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`[deps]`
	`2`	`+ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"`
`2`	`3`	`Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"`
`3`	`4`
`4`	`5`	`[compat]`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-module AbstractChainRules`
	`1`	`+module ChainRulesCore`
`2`	`2`	`using Cassette`
`3`	`3`	`using Base.Broadcast: materialize, materialize!, broadcasted, Broadcasted, broadcastable`
`4`	`4`