Skip to content

Commit 7ec9ed0

Browse files
gjkennedygjkennedy
committed
tried to fix formatting check
1 parent 12dd6a9 commit 7ec9ed0

8 files changed

Lines changed: 270 additions & 272 deletions

File tree

‎include/ad/a2dhadamard.h‎

Lines changed: 22 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -10,8 +10,8 @@
1010
namespace A2D {
1111

1212
template <typename T, int N>
13-
A2D_FUNCTION void VecHadamard(const Vec<T, N> &x, const Vec<T, N> &y,
14-
Vec<T, N> &z) {
13+
A2D_FUNCTION void VecHadamard(const Vec<T, N>& x, const Vec<T, N>& y,
14+
Vec<T, N>& z) {
1515
VecHadamardCore<T, N>(get_data(x), get_data(y), get_data(z));
1616
}
1717

@@ -34,7 +34,7 @@ class VecHadamardExpr {
3434
static_assert((N == M && M == K), "Vector sizes must agree");
3535

3636
A2D_FUNCTION
37-
VecHadamardExpr(xtype &x, ytype &y, ztype &z) : x(x), y(y), z(z) {}
37+
VecHadamardExpr(xtype& x, ytype& y, ztype& z) : x(x), y(y), z(z) {}
3838

3939
A2D_FUNCTION void eval() {
4040
VecHadamardCore<T, N>(get_data(x), get_data(y), get_data(z));
@@ -93,44 +93,44 @@ class VecHadamardExpr {
9393
}
9494
}
9595

96-
xtype &x;
97-
ytype &y;
98-
ztype &z;
96+
xtype& x;
97+
ytype& y;
98+
ztype& z;
9999
};
100100

101101
template <class xtype, class ytype, class ztype>
102-
A2D_FUNCTION auto VecHadamard(ADObj<xtype> &x, ADObj<ytype> &y,
103-
ADObj<ztype> &z) {
102+
A2D_FUNCTION auto VecHadamard(ADObj<xtype>& x, ADObj<ytype>& y,
103+
ADObj<ztype>& z) {
104104
return VecHadamardExpr<ADObj<xtype>, ADObj<ytype>, ADObj<ztype>>(x, y, z);
105105
}
106106

107107
template <class xtype, class ytype, class ztype>
108-
A2D_FUNCTION auto VecHadamard(A2DObj<xtype> &x, A2DObj<ytype> &y,
109-
A2DObj<ztype> &z) {
108+
A2D_FUNCTION auto VecHadamard(A2DObj<xtype>& x, A2DObj<ytype>& y,
109+
A2DObj<ztype>& z) {
110110
return VecHadamardExpr<A2DObj<xtype>, A2DObj<ytype>, A2DObj<ztype>>(x, y, z);
111111
}
112112

113113
template <class xtype, class ytype, class ztype>
114-
A2D_FUNCTION auto VecHadamard(const xtype &x, ADObj<ytype> &y,
115-
ADObj<ztype> &z) {
114+
A2D_FUNCTION auto VecHadamard(const xtype& x, ADObj<ytype>& y,
115+
ADObj<ztype>& z) {
116116
return VecHadamardExpr<const xtype, ADObj<ytype>, ADObj<ztype>>(x, y, z);
117117
}
118118

119119
template <class xtype, class ytype, class ztype>
120-
A2D_FUNCTION auto VecHadamard(const xtype &x, A2DObj<ytype> &y,
121-
A2DObj<ztype> &z) {
120+
A2D_FUNCTION auto VecHadamard(const xtype& x, A2DObj<ytype>& y,
121+
A2DObj<ztype>& z) {
122122
return VecHadamardExpr<const xtype, A2DObj<ytype>, A2DObj<ztype>>(x, y, z);
123123
}
124124

125125
template <class xtype, class ytype, class ztype>
126-
A2D_FUNCTION auto VecHadamard(ADObj<xtype> &x, const ytype &y,
127-
ADObj<ztype> &z) {
126+
A2D_FUNCTION auto VecHadamard(ADObj<xtype>& x, const ytype& y,
127+
ADObj<ztype>& z) {
128128
return VecHadamardExpr<ADObj<xtype>, const ytype, ADObj<ztype>>(x, y, z);
129129
}
130130

131131
template <class xtype, class ytype, class ztype>
132-
A2D_FUNCTION auto VecHadamard(A2DObj<xtype> &x, const ytype &y,
133-
A2DObj<ztype> &z) {
132+
A2D_FUNCTION auto VecHadamard(A2DObj<xtype>& x, const ytype& y,
133+
A2DObj<ztype>& z) {
134134
return VecHadamardExpr<A2DObj<xtype>, const ytype, A2DObj<ztype>>(x, y, z);
135135
}
136136

@@ -150,15 +150,15 @@ class VecHadamardTest : public A2DTest<T, Vec<T, N>, Vec<T, N>, Vec<T, N>> {
150150
}
151151

152152
// Evaluate the operation
153-
Output eval(const Input &x) {
153+
Output eval(const Input& x) {
154154
Vec<T, N> A, B, C;
155155
x.get_values(A, B);
156156
VecHadamard(A, B, C);
157157
return MakeVarTuple<T>(C);
158158
}
159159

160160
// Compute the derivative
161-
void deriv(const Output &seed, const Input &x, Input &g) {
161+
void deriv(const Output& seed, const Input& x, Input& g) {
162162
ADObj<Vec<T, N>> A, B, C;
163163
x.get_values(A.value(), B.value());
164164
auto stack = MakeStack(VecHadamard(A, B, C));
@@ -168,8 +168,8 @@ class VecHadamardTest : public A2DTest<T, Vec<T, N>, Vec<T, N>, Vec<T, N>> {
168168
}
169169

170170
// Compute the second-derivative
171-
void hprod(const Output &seed, const Output &hval, const Input &x,
172-
const Input &p, Input &h) {
171+
void hprod(const Output& seed, const Output& hval, const Input& x,
172+
const Input& p, Input& h) {
173173
A2DObj<Vec<T, N>> A, B, C;
174174
x.get_values(A.value(), B.value());
175175
p.get_values(A.pvalue(), B.pvalue());

‎include/ad/a2dmatinv.h‎

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -22,11 +22,11 @@ namespace A2D {
2222
*/
2323

2424
template <typename T, int N>
25-
A2D_FUNCTION void MatInv(const Mat<T, N, N> &A, Mat<T, N, N> &Ainv) {
25+
A2D_FUNCTION void MatInv(const Mat<T, N, N>& A, Mat<T, N, N>& Ainv) {
2626
MatInvCore<T, N>(get_data(A), get_data(Ainv));
2727
}
2828
template <typename T, int N>
29-
A2D_FUNCTION void MatInv(const SymMat<T, N> &S, SymMat<T, N> &Sinv) {
29+
A2D_FUNCTION void MatInv(const SymMat<T, N>& S, SymMat<T, N>& Sinv) {
3030
SymMatInvCore<T, N>(get_data(S), get_data(Sinv));
3131
}
3232

@@ -56,7 +56,7 @@ class MatInvExpr {
5656
static constexpr MatOp NORMAL = MatOp::NORMAL;
5757
static constexpr MatOp TRANSPOSE = MatOp::TRANSPOSE;
5858

59-
A2D_FUNCTION MatInvExpr(Atype &A, Btype &Ainv) : A(A), Ainv(Ainv) {}
59+
A2D_FUNCTION MatInvExpr(Atype& A, Btype& Ainv) : A(A), Ainv(Ainv) {}
6060

6161
A2D_FUNCTION void eval() { MatInvCore<T, N>(get_data(A), get_data(Ainv)); }
6262

@@ -120,17 +120,17 @@ class MatInvExpr {
120120
T(-1.0), temp, get_data(Ainv), GetSeed<ADseed::h>::get_data(A));
121121
}
122122

123-
Atype &A;
124-
Btype &Ainv;
123+
Atype& A;
124+
Btype& Ainv;
125125
};
126126

127127
template <class Atype, class Btype>
128-
A2D_FUNCTION auto MatInv(ADObj<Atype> &A, ADObj<Btype> &Ainv) {
128+
A2D_FUNCTION auto MatInv(ADObj<Atype>& A, ADObj<Btype>& Ainv) {
129129
return MatInvExpr<ADObj<Atype>, ADObj<Btype>>(A, Ainv);
130130
}
131131

132132
template <class Atype, class Btype>
133-
A2D_FUNCTION auto MatInv(A2DObj<Atype> &A, A2DObj<Btype> &Ainv) {
133+
A2D_FUNCTION auto MatInv(A2DObj<Atype>& A, A2DObj<Btype>& Ainv) {
134134
return MatInvExpr<A2DObj<Atype>, A2DObj<Btype>>(A, Ainv);
135135
}
136136

@@ -150,7 +150,7 @@ class MatInvTest : public A2DTest<T, Mat<T, N, N>, Mat<T, N, N>> {
150150
}
151151

152152
// Evaluate the matrix-matrix product
153-
Output eval(const Input &x) {
153+
Output eval(const Input& x) {
154154
Mat<T, N, N> A;
155155
Mat<T, N, N> B;
156156
x.get_values(A);
@@ -159,7 +159,7 @@ class MatInvTest : public A2DTest<T, Mat<T, N, N>, Mat<T, N, N>> {
159159
}
160160

161161
// Compute the derivative
162-
void deriv(const Output &seed, const Input &x, Input &g) {
162+
void deriv(const Output& seed, const Input& x, Input& g) {
163163
ADObj<Mat<T, N, N>> A;
164164
ADObj<Mat<T, N, N>> B;
165165

@@ -171,8 +171,8 @@ class MatInvTest : public A2DTest<T, Mat<T, N, N>, Mat<T, N, N>> {
171171
}
172172

173173
// Compute the second-derivative
174-
void hprod(const Output &seed, const Output &hval, const Input &x,
175-
const Input &p, Input &h) {
174+
void hprod(const Output& seed, const Output& hval, const Input& x,
175+
const Input& p, Input& h) {
176176
A2DObj<Mat<T, N, N>> A;
177177
A2DObj<Mat<T, N, N>> B;
178178

‎include/ad/a2dmatsum.h‎

Lines changed: 41 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -12,26 +12,26 @@
1212
namespace A2D {
1313

1414
template <typename T, int N, int M>
15-
A2D_FUNCTION void MatSum(const Mat<T, N, M> &A, const Mat<T, N, M> &B,
16-
Mat<T, N, M> &C) {
15+
A2D_FUNCTION void MatSum(const Mat<T, N, M>& A, const Mat<T, N, M>& B,
16+
Mat<T, N, M>& C) {
1717
VecSumCore<T, N * M>(get_data(A), get_data(B), get_data(C));
1818
}
1919

2020
template <typename T, int N, int M>
21-
A2D_FUNCTION void MatSum(const T alpha, const Mat<T, N, M> &A, const T beta,
22-
const Mat<T, N, M> &B, Mat<T, N, M> &C) {
21+
A2D_FUNCTION void MatSum(const T alpha, const Mat<T, N, M>& A, const T beta,
22+
const Mat<T, N, M>& B, Mat<T, N, M>& C) {
2323
VecSumCore<T, N * M>(alpha, get_data(A), beta, get_data(B), get_data(C));
2424
}
2525

2626
template <typename T, int N>
27-
A2D_FUNCTION void MatSum(const SymMat<T, N> &A, const SymMat<T, N> &B,
28-
SymMat<T, N> &C) {
27+
A2D_FUNCTION void MatSum(const SymMat<T, N>& A, const SymMat<T, N>& B,
28+
SymMat<T, N>& C) {
2929
VecSumCore<T, (N * (N + 1)) / 2>(get_data(A), get_data(B), get_data(C));
3030
}
3131

3232
template <typename T, int N>
33-
A2D_FUNCTION void MatSum(const T alpha, const SymMat<T, N> &A, const T beta,
34-
const SymMat<T, N> &B, SymMat<T, N> &C) {
33+
A2D_FUNCTION void MatSum(const T alpha, const SymMat<T, N>& A, const T beta,
34+
const SymMat<T, N>& B, SymMat<T, N>& C) {
3535
VecSumCore<T, (N * (N + 1)) / 2>(alpha, get_data(A), beta, get_data(B),
3636
get_data(C));
3737
}
@@ -61,7 +61,7 @@ class MatSumExpr {
6161
"Matrix sizes must agree");
6262

6363
A2D_FUNCTION
64-
MatSumExpr(Atype &A, Btype &B, Ctype &C) : A(A), B(B), C(C) {}
64+
MatSumExpr(Atype& A, Btype& B, Ctype& C) : A(A), B(B), C(C) {}
6565

6666
A2D_FUNCTION void eval() {
6767
VecSumCore<T, size>(get_data(A), get_data(B), get_data(C));
@@ -112,39 +112,39 @@ class MatSumExpr {
112112
}
113113
}
114114

115-
Atype &A;
116-
Btype &B;
117-
Ctype &C;
115+
Atype& A;
116+
Btype& B;
117+
Ctype& C;
118118
};
119119

120120
// Full active variants
121121
template <class Atype, class Btype, class Ctype>
122-
A2D_FUNCTION auto MatSum(ADObj<Atype> &A, ADObj<Btype> &B, ADObj<Ctype> &C) {
122+
A2D_FUNCTION auto MatSum(ADObj<Atype>& A, ADObj<Btype>& B, ADObj<Ctype>& C) {
123123
return MatSumExpr<ADObj<Atype>, ADObj<Btype>, ADObj<Ctype>>(A, B, C);
124124
}
125125

126126
template <class Atype, class Btype, class Ctype>
127-
A2D_FUNCTION auto MatSum(A2DObj<Atype> &A, A2DObj<Btype> &B, A2DObj<Ctype> &C) {
127+
A2D_FUNCTION auto MatSum(A2DObj<Atype>& A, A2DObj<Btype>& B, A2DObj<Ctype>& C) {
128128
return MatSumExpr<A2DObj<Atype>, A2DObj<Btype>, A2DObj<Ctype>>(A, B, C);
129129
}
130130

131131
template <class Atype, class Btype, class Ctype>
132-
A2D_FUNCTION auto MatSum(const Atype &A, ADObj<Btype> &B, ADObj<Ctype> &C) {
132+
A2D_FUNCTION auto MatSum(const Atype& A, ADObj<Btype>& B, ADObj<Ctype>& C) {
133133
return MatSumExpr<const Atype, ADObj<Btype>, ADObj<Ctype>>(A, B, C);
134134
}
135135

136136
template <class Atype, class Btype, class Ctype>
137-
A2D_FUNCTION auto MatSum(const Atype &A, A2DObj<Btype> &B, A2DObj<Ctype> &C) {
137+
A2D_FUNCTION auto MatSum(const Atype& A, A2DObj<Btype>& B, A2DObj<Ctype>& C) {
138138
return MatSumExpr<const Atype, A2DObj<Btype>, A2DObj<Ctype>>(A, B, C);
139139
}
140140

141141
template <class Atype, class Btype, class Ctype>
142-
A2D_FUNCTION auto MatSum(ADObj<Atype> &A, const Btype &B, ADObj<Ctype> &C) {
142+
A2D_FUNCTION auto MatSum(ADObj<Atype>& A, const Btype& B, ADObj<Ctype>& C) {
143143
return MatSumExpr<ADObj<Atype>, const Btype, ADObj<Ctype>>(A, B, C);
144144
}
145145

146146
template <class Atype, class Btype, class Ctype>
147-
A2D_FUNCTION auto MatSum(A2DObj<Atype> &A, const Btype &B, A2DObj<Ctype> &C) {
147+
A2D_FUNCTION auto MatSum(A2DObj<Atype>& A, const Btype& B, A2DObj<Ctype>& C) {
148148
return MatSumExpr<A2DObj<Atype>, const Btype, A2DObj<Ctype>>(A, B, C);
149149
}
150150

@@ -175,7 +175,7 @@ class MatSumScaleExpr {
175175
"Matrix sizes must agree");
176176

177177
A2D_FUNCTION
178-
MatSumScaleExpr(atype alpha, Atype &A, btype beta, Btype &B, Ctype &C)
178+
MatSumScaleExpr(atype alpha, Atype& A, btype beta, Btype& B, Ctype& C)
179179
: alpha(alpha), A(A), beta(beta), B(B), C(C) {}
180180

181181
A2D_FUNCTION void eval() {
@@ -276,39 +276,39 @@ class MatSumScaleExpr {
276276
}
277277

278278
atype alpha;
279-
Atype &A;
279+
Atype& A;
280280
btype beta;
281-
Btype &B;
282-
Ctype &C;
281+
Btype& B;
282+
Ctype& C;
283283
};
284284

285285
// Fully AD
286286
template <class atype, class Atype, class btype, class Btype, class Ctype>
287-
A2D_FUNCTION auto MatSum(ADObj<atype> &alpha, ADObj<Atype> &A,
288-
ADObj<btype> &beta, ADObj<Btype> &B, ADObj<Ctype> &C) {
289-
return MatSumScaleExpr<ADObj<atype> &, ADObj<Atype>, ADObj<btype> &,
287+
A2D_FUNCTION auto MatSum(ADObj<atype>& alpha, ADObj<Atype>& A,
288+
ADObj<btype>& beta, ADObj<Btype>& B, ADObj<Ctype>& C) {
289+
return MatSumScaleExpr<ADObj<atype>&, ADObj<Atype>, ADObj<btype>&,
290290
ADObj<Btype>, ADObj<Ctype>>(alpha, A, beta, B, C);
291291
}
292292

293293
template <class atype, class Atype, class btype, class Btype, class Ctype>
294-
A2D_FUNCTION auto MatSum(A2DObj<atype> &alpha, A2DObj<Atype> &A,
295-
A2DObj<btype> &beta, A2DObj<Btype> &B,
296-
A2DObj<Ctype> &C) {
297-
return MatSumScaleExpr<A2DObj<atype> &, A2DObj<Atype>, A2DObj<btype> &,
294+
A2D_FUNCTION auto MatSum(A2DObj<atype>& alpha, A2DObj<Atype>& A,
295+
A2DObj<btype>& beta, A2DObj<Btype>& B,
296+
A2DObj<Ctype>& C) {
297+
return MatSumScaleExpr<A2DObj<atype>&, A2DObj<Atype>, A2DObj<btype>&,
298298
A2DObj<Btype>, A2DObj<Ctype>>(alpha, A, beta, B, C);
299299
}
300300

301301
// Fully AD
302302
template <class atype, class Atype, class btype, class Btype, class Ctype>
303-
A2D_FUNCTION auto MatSum(const atype alpha, ADObj<Atype> &A, const btype beta,
304-
ADObj<Btype> &B, ADObj<Ctype> &C) {
303+
A2D_FUNCTION auto MatSum(const atype alpha, ADObj<Atype>& A, const btype beta,
304+
ADObj<Btype>& B, ADObj<Ctype>& C) {
305305
return MatSumScaleExpr<const atype, ADObj<Atype>, const btype, ADObj<Btype>,
306306
ADObj<Ctype>>(alpha, A, beta, B, C);
307307
}
308308

309309
template <class atype, class Atype, class btype, class Btype, class Ctype>
310-
A2D_FUNCTION auto MatSum(const atype alpha, A2DObj<Atype> &A, const btype beta,
311-
A2DObj<Btype> &B, A2DObj<Ctype> &C) {
310+
A2D_FUNCTION auto MatSum(const atype alpha, A2DObj<Atype>& A, const btype beta,
311+
A2DObj<Btype>& B, A2DObj<Ctype>& C) {
312312
return MatSumScaleExpr<const atype, A2DObj<Atype>, const btype, A2DObj<Btype>,
313313
A2DObj<Ctype>>(alpha, A, beta, B, C);
314314
}
@@ -329,15 +329,15 @@ class MatSumTest : public A2DTest<T, Mat<T, N, M>, Mat<T, N, M>, Mat<T, N, M>> {
329329
}
330330

331331
// Evaluate the matrix-matrix product
332-
Output eval(const Input &x) {
332+
Output eval(const Input& x) {
333333
Mat<T, N, M> A, B, C;
334334
x.get_values(A, B);
335335
MatSum(A, B, C);
336336
return MakeVarTuple<T>(C);
337337
}
338338

339339
// Compute the derivative
340-
void deriv(const Output &seed, const Input &x, Input &g) {
340+
void deriv(const Output& seed, const Input& x, Input& g) {
341341
ADObj<Mat<T, N, M>> A, B, C;
342342
x.get_values(A.value(), B.value());
343343
auto stack = MakeStack(MatSum(A, B, C));
@@ -347,8 +347,8 @@ class MatSumTest : public A2DTest<T, Mat<T, N, M>, Mat<T, N, M>, Mat<T, N, M>> {
347347
}
348348

349349
// Compute the second-derivative
350-
void hprod(const Output &seed, const Output &hval, const Input &x,
351-
const Input &p, Input &h) {
350+
void hprod(const Output& seed, const Output& hval, const Input& x,
351+
const Input& p, Input& h) {
352352
A2DObj<Mat<T, N, M>> A, B, C;
353353
x.get_values(A.value(), B.value());
354354
p.get_values(A.pvalue(), B.pvalue());
@@ -375,7 +375,7 @@ class MatSumScaleTest
375375
}
376376

377377
// Evaluate the matrix-matrix product
378-
Output eval(const Input &x) {
378+
Output eval(const Input& x) {
379379
T alpha, beta;
380380
Mat<T, N, M> A, B, C;
381381
x.get_values(alpha, A, beta, B);
@@ -384,7 +384,7 @@ class MatSumScaleTest
384384
}
385385

386386
// Compute the derivative
387-
void deriv(const Output &seed, const Input &x, Input &g) {
387+
void deriv(const Output& seed, const Input& x, Input& g) {
388388
ADObj<T> alpha, beta;
389389
ADObj<Mat<T, N, M>> A, B, C;
390390
x.get_values(alpha.value(), A.value(), beta.value(), B.value());
@@ -395,8 +395,8 @@ class MatSumScaleTest
395395
}
396396

397397
// Compute the second-derivative
398-
void hprod(const Output &seed, const Output &hval, const Input &x,
399-
const Input &p, Input &h) {
398+
void hprod(const Output& seed, const Output& hval, const Input& x,
399+
const Input& p, Input& h) {
400400
A2DObj<T> alpha, beta;
401401
A2DObj<Mat<T, N, M>> A, B, C;
402402
x.get_values(alpha.value(), A.value(), beta.value(), B.value());

0 commit comments

Comments
 (0)