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
126
127
128
129
130
131
132
133
134
135
136
137
138
|
/// Modifer to mark a function for forward-mode differentiation.
/// i.e. the compiler will automatically generate a new function
/// that computes the jacobian-vector product of the original.
__attributeTarget(FunctionDeclBase)
attribute_syntax [ForwardDifferentiable] : ForwardDifferentiableAttribute;
// Custom Forward Derivative Function reference
__attributeTarget(FunctionDeclBase)
attribute_syntax [ForwardDerivative(function)] : ForwardDerivativeAttribute;
__attributeTarget(FunctionDeclBase)
attribute_syntax [BackwardDifferentiable] : BackwardDifferentiableAttribute;
__attributeTarget(FunctionDeclBase)
attribute_syntax [ForwardDerivativeOf(function)] : ForwardDerivativeOfAttribute;
__attributeTarget(DeclBase)
attribute_syntax [DerivativeMember(memberName)] : DerivativeMemberAttribute;
/// Pair type that serves to wrap the primal and
/// differential types of an arbitrary type T.
__generic<T : IDifferentiable>
__magic_type(DifferentialPairType)
__intrinsic_type($(kIROp_DifferentialPairType))
struct DifferentialPair : IDifferentiable
{
typedef DifferentialPair<T.Differential> Differential;
typedef T.Differential DifferentialElementType;
__intrinsic_op($(kIROp_MakeDifferentialPair))
__init(T _primal, T.Differential _differential);
property p : T
{
__intrinsic_op($(kIROp_DifferentialPairGetPrimal))
get;
}
property v : T
{
__intrinsic_op($(kIROp_DifferentialPairGetPrimal))
get;
}
property d : T.Differential
{
__intrinsic_op($(kIROp_DifferentialPairGetDifferential))
get;
}
[__unsafeForceInlineEarly]
T.Differential getDifferential()
{
return d;
}
[__unsafeForceInlineEarly]
T getPrimal()
{
return p;
}
[__unsafeForceInlineEarly]
static Differential dzero()
{
return Differential(T.dzero(), T.Differential.dzero());
}
[__unsafeForceInlineEarly]
static Differential dadd(Differential a, Differential b)
{
return Differential(
T.dadd(
a.p,
b.p
),
T.Differential.dadd(a.d, b.d));
}
[__unsafeForceInlineEarly]
static Differential dmul(This a, Differential b)
{
return Differential(
T.dmul(a.p, b.p),
T.Differential.dmul(a.d, b.d));
}
};
#define VECTOR_MAP_UNARY(TYPE, COUNT, FUNC, VALUE) \
vector<TYPE,COUNT> result; for(int i = 0; i < COUNT; ++i) { result[i] = FUNC(VALUE[i]); } return result
// Natural Exponent
__generic<T : __BuiltinFloatingPointType>
[ForwardDerivativeOf(exp)]
DifferentialPair<T> __d_exp(DifferentialPair<T> dpx)
{
return DifferentialPair<T>(
exp(dpx.p),
T.dmul(exp(dpx.p), dpx.d));
}
__generic<T:__BuiltinFloatingPointType, let N : int>
[ForwardDerivativeOf(exp)]
DifferentialPair<vector<T, N>> __d_exp_vector(DifferentialPair<vector<T, N>> dpx)
{
vector<T, N> result;
vector<T, N>.Differential d_result;
for(int i = 0; i < N; ++i)
{
DifferentialPair<T> dpexp = __d_exp(DifferentialPair<T>(dpx.p[i], __slang_noop_cast<T.Differential>(dpx.d[i])));
result[i] = dpexp.p;
d_result[i] = __slang_noop_cast<T>(dpexp.d);
}
return DifferentialPair<vector<T, N>>(result, d_result);
}
__generic<T : __BuiltinFloatingPointType>
[ForwardDerivativeOf(sin)]
DifferentialPair<T> d_sin(DifferentialPair<T> dpx)
{
return DifferentialPair<T>(
sin(dpx.p),
T.dmul(cos(dpx.p), dpx.d));
}
__generic<T : __BuiltinFloatingPointType>
[ForwardDerivativeOf(cos)]
DifferentialPair<T> d_cos(DifferentialPair<T> dpx)
{
return DifferentialPair<T>(
cos(dpx.p),
T.dmul(-sin(dpx.p), dpx.d));
}
|
