Remove Wirtinger

Author: YingboMa

docs/src/index.md

@@ -233,7 +233,6 @@ The most important `AbstractDifferential`s when getting started are the ones abo
  - `One`, `Zero`: There are special representations of `1` and `0`. They do great things around avoiding expanding `Thunks` in multiplication and (for `Zero`) addition.
 
 #### Other `AbstractDifferential`s: don't worry about them right now
- - `Wirtinger`: it is complex. The docs need to be better. [Read the links in this issue](https://github.com/JuliaDiff/ChainRulesCore.jl/issues/40).
  - `Casted`: it implements broadcasting mechanics. See [#10](https://github.com/JuliaDiff/ChainRulesCore.jl/issues/10)
  - `InplaceableThunk`: it is like a Thunk but it can do `store!` and `accumulate!` in-place.
 

src/rulesets/Base/base.jl

@@ -2,7 +2,7 @@
 @scalar_rule(zero(x), Zero())
 @scalar_rule(sign(x), Zero())
 
-@scalar_rule(abs2(x), Wirtinger(x', x))
+@scalar_rule(abs2(x), 2x)
 @scalar_rule(log(x), inv(x))
 @scalar_rule(log10(x), inv(x) / log(oftype(x, 10)))
 @scalar_rule(log2(x), inv(x) / log(oftype(x, 2)))
@@ -50,14 +50,10 @@
 @scalar_rule(deg2rad(x), π / oftype(x, 180))
 @scalar_rule(rad2deg(x), oftype(x, 180) / π)
 
-@scalar_rule(conj(x), Wirtinger(Zero(), One()))
-@scalar_rule(adjoint(x), Wirtinger(Zero(), One()))
 @scalar_rule(transpose(x), One())
 
 @scalar_rule(abs(x::Real), sign(x))
-@scalar_rule(abs(x::Complex), Wirtinger(x' / 2Ω, x / 2Ω))
 @scalar_rule(hypot(x::Real), sign(x))
-@scalar_rule(hypot(x::Complex), Wirtinger(x' / 2Ω, x / 2Ω))
 @scalar_rule(rem2pi(x, r::RoundingMode), (One(), DoesNotExist()))
 
 @scalar_rule(+(x), One())
@@ -98,11 +94,8 @@
              (ifelse(isint, nan, one(u)), ifelse(isint, nan, -trunc(u))))
 @scalar_rule(fma(x, y, z), (y, x, One()))
 @scalar_rule(muladd(x, y, z), (y, x, One()))
-@scalar_rule(angle(x::Complex), @setup(u = abs2(x)), Wirtinger(-im//2 * x' / u, im//2 * x / u))
 @scalar_rule(angle(x::Real), Zero())
-@scalar_rule(real(x::Complex), Wirtinger(1//2, 1//2))
 @scalar_rule(real(x::Real), One())
-@scalar_rule(imag(x::Complex), Wirtinger(-im//2, im//2))
 @scalar_rule(imag(x::Real), Zero())
 
 # product rule requires special care for arguments where `mul` is non-commutative

test/rulesets/Base/base.jl

@@ -62,7 +62,7 @@
     end  # Trig
 
     @testset "math" begin
-        for x in (-0.1, 6.4, 1.0+0.5im, -10.0+0im)
+        for x in (-0.1, 6.4)
             test_scalar(deg2rad, x)
             test_scalar(rad2deg, x)
 
@@ -73,30 +73,6 @@
             test_scalar(exp10, x)
 
             x isa Real && test_scalar(cbrt, x)
-            if (x isa Real && x >= 0) || x isa Complex
-                # this check is needed because these have discontinuities between
-                # `-10 + im*eps()` and `-10 - im*eps()`
-                should_test_wirtinger = imag(x) != 0 && real(x) < 0
-                test_scalar(sqrt, x; test_wirtinger=should_test_wirtinger)
-                test_scalar(log, x; test_wirtinger=should_test_wirtinger)
-                test_scalar(log2, x; test_wirtinger=should_test_wirtinger)
-                test_scalar(log10, x; test_wirtinger=should_test_wirtinger)
-                test_scalar(log1p, x; test_wirtinger=should_test_wirtinger)
-            end
-        end
-    end
-
-    @testset "Unary complex functions" begin
-        for x in (-4.1, 6.4, 1.0+0.5im, -10.0+1.5im)
-            test_scalar(real, x)
-            test_scalar(imag, x)
-
-            test_scalar(abs, x)
-            test_scalar(hypot, x)
-
-            test_scalar(angle, x)
-            test_scalar(abs2, x)
-            test_scalar(conj, x)
         end
     end
 

test/runtests.jl

@@ -11,7 +11,6 @@ using Test
 
 # For testing purposes we use a lot of
 using ChainRulesCore: extern, accumulate, accumulate!, store!, @scalar_rule,
-    Wirtinger, wirtinger_primal, wirtinger_conjugate,
     Zero, One, DoesNotExist, Thunk, AbstractDifferential
 
 Random.seed!(1) # Set seed that all testsets should reset to.

test/test_util.jl

@@ -7,7 +7,7 @@ const _fdm = central_fdm(5, 1)
 
 
 """
-    test_scalar(f, x; rtol=1e-9, atol=1e-9, fdm=central_fdm(5, 1), test_wirtinger=x isa Complex, kwargs...)
+    test_scalar(f, x; rtol=1e-9, atol=1e-9, fdm=central_fdm(5, 1), kwargs...)
 
 Given a function `f` with scalar input an scalar output, perform finite differencing checks,
 at input point `x` to confirm that there are correct ChainRules provided.
@@ -16,49 +16,22 @@ at input point `x` to confirm that there are correct ChainRules provided.
 - `f`: Function for which the `frule` and `rrule` should be tested.
 - `x`: input at which to evaluate `f` (should generally be set to an arbitary point in the domain).
 
-- `test_wirtinger`: test whether the wirtinger derivative is correct, too
-
-All keyword arguments except for `fdm` and `test_wirtinger` are passed to `isapprox`.
+All keyword arguments except for `fdm` is passed to `isapprox`.
 """
-function test_scalar(f, x; rtol=1e-9, atol=1e-9, fdm=_fdm, test_wirtinger=x isa Complex, kwargs...)
+function test_scalar(f, x; rtol=1e-9, atol=1e-9, fdm=_fdm, kwargs...)
     ensure_not_running_on_functor(f, "test_scalar")
 
-    @testset "$f at $x, $(nameof(rule))" for rule in (rrule, frule)
-        res = rule(f, x)
-        @test res !== nothing  # Check the rule was defined
-        fx,  prop_rule = res
+    r_res = rrule(f, x)
+    f_res = frule(f, x, Zero(), 1)
+    @test r_res !== f_res !== nothing  # Check the rule was defined
+    r_fx, prop_rule = r_res
+    f_fx, f_∂x = f_res
+    @testset "$f at $x, $(nameof(rule))" for (rule, fx, ∂x) in ((rrule, r_fx, prop_rule(1)), (frule, f_fx, f_∂x))
         @test fx == f(x)  # Check we still get the normal value, right
 
         if rule == rrule
-            ∂self, ∂x = prop_rule(1)
+            ∂self, ∂x = ∂x
             @test ∂self === NO_FIELDS
-        else # rule == frule
-            # Got to input extra first aguement for internals
-            # But it is only a dummy since this is not a functor
-            ∂x = prop_rule(NamedTuple(), 1)
-        end
-
-
-        # Check that we get the derivative right:
-        if !test_wirtinger
-            @test isapprox(
-                ∂x, fdm(f, x);
-                rtol=rtol, atol=atol, kwargs...
-            )
-        else
-            # For complex arguments, also check if the wirtinger derivative is correct
-            ∂Re = fdm(ϵ -> f(x + ϵ), 0)
-            ∂Im = fdm(ϵ -> f(x + im*ϵ), 0)
-            ∂ = 0.5(∂Re - im*∂Im)
-            ∂̅ = 0.5(∂Re + im*∂Im)
-            @test isapprox(
-                wirtinger_primal(∂x), ∂;
-                rtol=rtol, atol=atol, kwargs...
-            )
-            @test isapprox(
-                wirtinger_conjugate(∂x), ∂̅;
-                rtol=rtol, atol=atol, kwargs...
-            )
         end
     end
 end
@@ -92,7 +65,9 @@ end
 function frule_test(f, xẋs::Tuple{Any, Any}...; rtol=1e-9, atol=1e-9, fdm=_fdm, kwargs...)
     ensure_not_running_on_functor(f, "frule_test")
     xs, ẋs = collect(zip(xẋs...))
-    Ω, pushforward = ChainRules.frule(f, xs...)
+    dself = Zero()
+    Ω, dΩ_ad = ChainRules.frule(f, xs..., dself, ẋs...)
+    dΩ_ad = dΩ_ad .+ 0
     @test f(xs...) == Ω
     dΩ_ad = pushforward(NamedTuple(), ẋs...)
 
@@ -204,10 +179,6 @@ function rrule_test(f, ȳ, xx̄s::Tuple{Any, Any}...; rtol=1e-9, atol=1e-9, fdm
     end
 end
 
-function Base.isapprox(ad::Wirtinger, fd; kwargs...)
-    error("Finite differencing with Wirtinger rules not implemented")
-end
-
 function Base.isapprox(d_ad::DoesNotExist, d_fd; kwargs...)
     error("Tried to differentiate w.r.t. a `DoesNotExist`")
 end