DifferentiationInterface.jl/DifferentiationInterface/test/Core/Internals/signature.jl at d970dafaf09c39d8f9b8cbbb0a3475a7e6b6753b · JuliaDiff/DifferentiationInterface.jl · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
using DifferentiationInterface
using DifferentiationInterface: AutoZeroReverse, AutoZeroForward
using Test

backend = AutoZeroForward()
other_backend = AutoZeroReverse()
f(x, c) = x + c
f!(y, x) = y .= x
x = 1.0
y = zeros(2)
c = 2.0

@testset "Out of place, no tangents" begin
    prep = prepare_derivative(f, backend, x, Constant(c); strict=Val(true))
    prep_chill = prepare_derivative(f, backend, x, Constant(c); strict=Val(false))

    @test_throws MethodError derivative(nothing, prep_chill, backend, x, Constant(c))

    @test_throws """
    PreparationMismatchError (inconsistent types between preparation and execution):
      - f: ❌
        - prep: typeof(f)
        - exec: Nothing
      - backend: ✅
      - x: ✅
      - contexts: ✅
    """ derivative(nothing, prep, backend, x, Constant(c))

    @test_throws """
    PreparationMismatchError (inconsistent types between preparation and execution):
      - f: ✅
      - backend: ❌
        - prep: AutoZeroForward
        - exec: AutoZeroReverse
      - x: ✅
      - contexts: ✅
    """ derivative(f, prep, other_backend, x, Constant(c))

    @test_throws """
    PreparationMismatchError (inconsistent types between preparation and execution):
      - f: ✅
      - backend: ✅
      - x: ❌
        - prep: Float64
        - exec: Int64
      - contexts: ✅
    """ derivative(f, prep, backend, 1, Constant(c))

    @test_throws """
    PreparationMismatchError (inconsistent types between preparation and execution):
      - f: ✅
      - backend: ✅
      - x: ✅
      - contexts: ❌
        - prep: Tuple{Constant{Float64}}
        - exec: Tuple{Constant{Int64}}
    """ derivative(f, prep, backend, x, Constant(2))

    @test_throws """
    PreparationMismatchError (inconsistent types between preparation and execution):
      - f: ✅
      - backend: ✅
      - x: ✅
      - contexts: ❌
        - prep: Tuple{Constant{Float64}}
        - exec: Tuple{Constant{Int64}, Constant{Int64}}
    """ derivative(f, prep, backend, x, Constant(2), Constant(3))
end

@testset "In place, no tangents" begin
    prep = prepare_derivative(f!, y, backend, x; strict=Val(true))
    prep_chill = prepare_derivative(f!, y, backend, x; strict=Val(false))

    @test_throws MethodError derivative(nothing, y, prep_chill, backend, x, Constant(c))

    @test_throws """
    PreparationMismatchError (inconsistent types between preparation and execution):
      - f!: ❌
        - prep: typeof(f!)
        - exec: Nothing
      - y: ✅
      - backend: ✅
      - x: ✅
      - contexts: ✅
    """ derivative(nothing, y, prep, backend, x)
end

@testset "Out of place, with tangents" begin
    prep = prepare_pushforward(f, backend, x, (x,), Constant(c); strict=Val(true))
    prep_chill = prepare_pushforward(f, backend, x, (x,), Constant(c); strict=Val(false))

    @test_throws MethodError pushforward(nothing, prep_chill, backend, x, (x,))

    @test_throws """
    PreparationMismatchError (inconsistent types between preparation and execution):
      - f: ❌
        - prep: typeof(f)
        - exec: Nothing
      - backend: ✅
      - x: ✅
      - t: ✅
      - contexts: ✅
    """ pushforward(nothing, prep, backend, x, (x,), Constant(c))
end

@testset "In place, with tangents" begin
    prep = prepare_pushforward(f!, y, backend, x, (x,); strict=Val(true))
    prep_chill = prepare_pushforward(
        f!, y, backend, x, (x,), Constant(c); strict=Val(false)
    )

    @test_throws MethodError pushforward(nothing, y, prep_chill, backend, x, (x,))

    @test_throws """
    PreparationMismatchError (inconsistent types between preparation and execution):
      - f!: ❌
        - prep: typeof(f!)
        - exec: Nothing
      - y: ✅
      - backend: ✅
      - x: ✅
      - t: ✅
      - contexts: ✅
    """ pushforward(nothing, y, prep, backend, x, (x,))
end