1 | // This file is MACHINE GENERATED! Do not edit. |
2 | |
3 | |
4 | #include "tensorflow/cc/ops/const_op.h" |
5 | #include "tensorflow/cc/ops/linalg_ops.h" |
6 | |
7 | namespace tensorflow { |
8 | namespace ops { |
9 | |
10 | Cholesky::Cholesky(const ::tensorflow::Scope& scope, ::tensorflow::Input input) { |
11 | if (!scope.ok()) return; |
12 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
13 | if (!scope.ok()) return; |
14 | ::tensorflow::Node* ret; |
15 | const auto unique_name = scope.GetUniqueNameForOp("Cholesky" ); |
16 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Cholesky" ) |
17 | .Input(_input) |
18 | ; |
19 | scope.UpdateBuilder(&builder); |
20 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
21 | if (!scope.ok()) return; |
22 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
23 | this->operation = Operation(ret); |
24 | this->output = Output(ret, 0); |
25 | } |
26 | |
27 | CholeskyGrad::CholeskyGrad(const ::tensorflow::Scope& scope, |
28 | ::tensorflow::Input l, ::tensorflow::Input grad) { |
29 | if (!scope.ok()) return; |
30 | auto _l = ::tensorflow::ops::AsNodeOut(scope, l); |
31 | if (!scope.ok()) return; |
32 | auto _grad = ::tensorflow::ops::AsNodeOut(scope, grad); |
33 | if (!scope.ok()) return; |
34 | ::tensorflow::Node* ret; |
35 | const auto unique_name = scope.GetUniqueNameForOp("CholeskyGrad" ); |
36 | auto builder = ::tensorflow::NodeBuilder(unique_name, "CholeskyGrad" ) |
37 | .Input(_l) |
38 | .Input(_grad) |
39 | ; |
40 | scope.UpdateBuilder(&builder); |
41 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
42 | if (!scope.ok()) return; |
43 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
44 | this->operation = Operation(ret); |
45 | this->output = Output(ret, 0); |
46 | } |
47 | |
48 | Eig::Eig(const ::tensorflow::Scope& scope, ::tensorflow::Input input, DataType |
49 | Tout, const Eig::Attrs& attrs) { |
50 | if (!scope.ok()) return; |
51 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
52 | if (!scope.ok()) return; |
53 | ::tensorflow::Node* ret; |
54 | const auto unique_name = scope.GetUniqueNameForOp("Eig" ); |
55 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Eig" ) |
56 | .Input(_input) |
57 | .Attr("compute_v" , attrs.compute_v_) |
58 | .Attr("Tout" , Tout) |
59 | ; |
60 | scope.UpdateBuilder(&builder); |
61 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
62 | if (!scope.ok()) return; |
63 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
64 | this->operation = Operation(ret); |
65 | ::tensorflow::NameRangeMap _outputs_range; |
66 | ::tensorflow::Status _status_ = ::tensorflow::NameRangesForNode(*ret, ret->op_def(), nullptr, &_outputs_range); |
67 | if (!_status_.ok()) { |
68 | scope.UpdateStatus(_status_); |
69 | return; |
70 | } |
71 | |
72 | this->e = Output(ret, _outputs_range["e" ].first); |
73 | this->v = Output(ret, _outputs_range["v" ].first); |
74 | } |
75 | |
76 | Eig::Eig(const ::tensorflow::Scope& scope, ::tensorflow::Input input, DataType |
77 | Tout) |
78 | : Eig(scope, input, Tout, Eig::Attrs()) {} |
79 | |
80 | Einsum::Einsum(const ::tensorflow::Scope& scope, ::tensorflow::InputList |
81 | inputs, StringPiece equation) { |
82 | if (!scope.ok()) return; |
83 | auto _inputs = ::tensorflow::ops::AsNodeOutList(scope, inputs); |
84 | if (!scope.ok()) return; |
85 | ::tensorflow::Node* ret; |
86 | const auto unique_name = scope.GetUniqueNameForOp("Einsum" ); |
87 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Einsum" ) |
88 | .Input(_inputs) |
89 | .Attr("equation" , equation) |
90 | ; |
91 | scope.UpdateBuilder(&builder); |
92 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
93 | if (!scope.ok()) return; |
94 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
95 | this->operation = Operation(ret); |
96 | this->output = Output(ret, 0); |
97 | } |
98 | |
99 | LogMatrixDeterminant::LogMatrixDeterminant(const ::tensorflow::Scope& scope, |
100 | ::tensorflow::Input input) { |
101 | if (!scope.ok()) return; |
102 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
103 | if (!scope.ok()) return; |
104 | ::tensorflow::Node* ret; |
105 | const auto unique_name = scope.GetUniqueNameForOp("LogMatrixDeterminant" ); |
106 | auto builder = ::tensorflow::NodeBuilder(unique_name, "LogMatrixDeterminant" ) |
107 | .Input(_input) |
108 | ; |
109 | scope.UpdateBuilder(&builder); |
110 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
111 | if (!scope.ok()) return; |
112 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
113 | this->operation = Operation(ret); |
114 | ::tensorflow::NameRangeMap _outputs_range; |
115 | ::tensorflow::Status _status_ = ::tensorflow::NameRangesForNode(*ret, ret->op_def(), nullptr, &_outputs_range); |
116 | if (!_status_.ok()) { |
117 | scope.UpdateStatus(_status_); |
118 | return; |
119 | } |
120 | |
121 | this->sign = Output(ret, _outputs_range["sign" ].first); |
122 | this->log_abs_determinant = Output(ret, _outputs_range["log_abs_determinant" ].first); |
123 | } |
124 | |
125 | Lu::Lu(const ::tensorflow::Scope& scope, ::tensorflow::Input input, const |
126 | Lu::Attrs& attrs) { |
127 | if (!scope.ok()) return; |
128 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
129 | if (!scope.ok()) return; |
130 | ::tensorflow::Node* ret; |
131 | const auto unique_name = scope.GetUniqueNameForOp("Lu" ); |
132 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Lu" ) |
133 | .Input(_input) |
134 | .Attr("output_idx_type" , attrs.output_idx_type_) |
135 | ; |
136 | scope.UpdateBuilder(&builder); |
137 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
138 | if (!scope.ok()) return; |
139 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
140 | this->operation = Operation(ret); |
141 | ::tensorflow::NameRangeMap _outputs_range; |
142 | ::tensorflow::Status _status_ = ::tensorflow::NameRangesForNode(*ret, ret->op_def(), nullptr, &_outputs_range); |
143 | if (!_status_.ok()) { |
144 | scope.UpdateStatus(_status_); |
145 | return; |
146 | } |
147 | |
148 | this->lu = Output(ret, _outputs_range["lu" ].first); |
149 | this->p = Output(ret, _outputs_range["p" ].first); |
150 | } |
151 | |
152 | Lu::Lu(const ::tensorflow::Scope& scope, ::tensorflow::Input input) |
153 | : Lu(scope, input, Lu::Attrs()) {} |
154 | |
155 | MatrixDeterminant::MatrixDeterminant(const ::tensorflow::Scope& scope, |
156 | ::tensorflow::Input input) { |
157 | if (!scope.ok()) return; |
158 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
159 | if (!scope.ok()) return; |
160 | ::tensorflow::Node* ret; |
161 | const auto unique_name = scope.GetUniqueNameForOp("MatrixDeterminant" ); |
162 | auto builder = ::tensorflow::NodeBuilder(unique_name, "MatrixDeterminant" ) |
163 | .Input(_input) |
164 | ; |
165 | scope.UpdateBuilder(&builder); |
166 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
167 | if (!scope.ok()) return; |
168 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
169 | this->operation = Operation(ret); |
170 | this->output = Output(ret, 0); |
171 | } |
172 | |
173 | MatrixInverse::MatrixInverse(const ::tensorflow::Scope& scope, |
174 | ::tensorflow::Input input, const |
175 | MatrixInverse::Attrs& attrs) { |
176 | if (!scope.ok()) return; |
177 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
178 | if (!scope.ok()) return; |
179 | ::tensorflow::Node* ret; |
180 | const auto unique_name = scope.GetUniqueNameForOp("MatrixInverse" ); |
181 | auto builder = ::tensorflow::NodeBuilder(unique_name, "MatrixInverse" ) |
182 | .Input(_input) |
183 | .Attr("adjoint" , attrs.adjoint_) |
184 | ; |
185 | scope.UpdateBuilder(&builder); |
186 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
187 | if (!scope.ok()) return; |
188 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
189 | this->operation = Operation(ret); |
190 | this->output = Output(ret, 0); |
191 | } |
192 | |
193 | MatrixInverse::MatrixInverse(const ::tensorflow::Scope& scope, |
194 | ::tensorflow::Input input) |
195 | : MatrixInverse(scope, input, MatrixInverse::Attrs()) {} |
196 | |
197 | MatrixSolve::MatrixSolve(const ::tensorflow::Scope& scope, ::tensorflow::Input |
198 | matrix, ::tensorflow::Input rhs, const |
199 | MatrixSolve::Attrs& attrs) { |
200 | if (!scope.ok()) return; |
201 | auto _matrix = ::tensorflow::ops::AsNodeOut(scope, matrix); |
202 | if (!scope.ok()) return; |
203 | auto _rhs = ::tensorflow::ops::AsNodeOut(scope, rhs); |
204 | if (!scope.ok()) return; |
205 | ::tensorflow::Node* ret; |
206 | const auto unique_name = scope.GetUniqueNameForOp("MatrixSolve" ); |
207 | auto builder = ::tensorflow::NodeBuilder(unique_name, "MatrixSolve" ) |
208 | .Input(_matrix) |
209 | .Input(_rhs) |
210 | .Attr("adjoint" , attrs.adjoint_) |
211 | ; |
212 | scope.UpdateBuilder(&builder); |
213 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
214 | if (!scope.ok()) return; |
215 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
216 | this->operation = Operation(ret); |
217 | this->output = Output(ret, 0); |
218 | } |
219 | |
220 | MatrixSolve::MatrixSolve(const ::tensorflow::Scope& scope, ::tensorflow::Input |
221 | matrix, ::tensorflow::Input rhs) |
222 | : MatrixSolve(scope, matrix, rhs, MatrixSolve::Attrs()) {} |
223 | |
224 | MatrixSolveLs::MatrixSolveLs(const ::tensorflow::Scope& scope, |
225 | ::tensorflow::Input matrix, ::tensorflow::Input |
226 | rhs, ::tensorflow::Input l2_regularizer, const |
227 | MatrixSolveLs::Attrs& attrs) { |
228 | if (!scope.ok()) return; |
229 | auto _matrix = ::tensorflow::ops::AsNodeOut(scope, matrix); |
230 | if (!scope.ok()) return; |
231 | auto _rhs = ::tensorflow::ops::AsNodeOut(scope, rhs); |
232 | if (!scope.ok()) return; |
233 | auto _l2_regularizer = ::tensorflow::ops::AsNodeOut(scope, l2_regularizer); |
234 | if (!scope.ok()) return; |
235 | ::tensorflow::Node* ret; |
236 | const auto unique_name = scope.GetUniqueNameForOp("MatrixSolveLs" ); |
237 | auto builder = ::tensorflow::NodeBuilder(unique_name, "MatrixSolveLs" ) |
238 | .Input(_matrix) |
239 | .Input(_rhs) |
240 | .Input(_l2_regularizer) |
241 | .Attr("fast" , attrs.fast_) |
242 | ; |
243 | scope.UpdateBuilder(&builder); |
244 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
245 | if (!scope.ok()) return; |
246 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
247 | this->operation = Operation(ret); |
248 | this->output = Output(ret, 0); |
249 | } |
250 | |
251 | MatrixSolveLs::MatrixSolveLs(const ::tensorflow::Scope& scope, |
252 | ::tensorflow::Input matrix, ::tensorflow::Input |
253 | rhs, ::tensorflow::Input l2_regularizer) |
254 | : MatrixSolveLs(scope, matrix, rhs, l2_regularizer, MatrixSolveLs::Attrs()) {} |
255 | |
256 | MatrixSquareRoot::MatrixSquareRoot(const ::tensorflow::Scope& scope, |
257 | ::tensorflow::Input input) { |
258 | if (!scope.ok()) return; |
259 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
260 | if (!scope.ok()) return; |
261 | ::tensorflow::Node* ret; |
262 | const auto unique_name = scope.GetUniqueNameForOp("MatrixSquareRoot" ); |
263 | auto builder = ::tensorflow::NodeBuilder(unique_name, "MatrixSquareRoot" ) |
264 | .Input(_input) |
265 | ; |
266 | scope.UpdateBuilder(&builder); |
267 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
268 | if (!scope.ok()) return; |
269 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
270 | this->operation = Operation(ret); |
271 | this->output = Output(ret, 0); |
272 | } |
273 | |
274 | MatrixTriangularSolve::MatrixTriangularSolve(const ::tensorflow::Scope& scope, |
275 | ::tensorflow::Input matrix, |
276 | ::tensorflow::Input rhs, const |
277 | MatrixTriangularSolve::Attrs& |
278 | attrs) { |
279 | if (!scope.ok()) return; |
280 | auto _matrix = ::tensorflow::ops::AsNodeOut(scope, matrix); |
281 | if (!scope.ok()) return; |
282 | auto _rhs = ::tensorflow::ops::AsNodeOut(scope, rhs); |
283 | if (!scope.ok()) return; |
284 | ::tensorflow::Node* ret; |
285 | const auto unique_name = scope.GetUniqueNameForOp("MatrixTriangularSolve" ); |
286 | auto builder = ::tensorflow::NodeBuilder(unique_name, "MatrixTriangularSolve" ) |
287 | .Input(_matrix) |
288 | .Input(_rhs) |
289 | .Attr("lower" , attrs.lower_) |
290 | .Attr("adjoint" , attrs.adjoint_) |
291 | ; |
292 | scope.UpdateBuilder(&builder); |
293 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
294 | if (!scope.ok()) return; |
295 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
296 | this->operation = Operation(ret); |
297 | this->output = Output(ret, 0); |
298 | } |
299 | |
300 | MatrixTriangularSolve::MatrixTriangularSolve(const ::tensorflow::Scope& scope, |
301 | ::tensorflow::Input matrix, |
302 | ::tensorflow::Input rhs) |
303 | : MatrixTriangularSolve(scope, matrix, rhs, MatrixTriangularSolve::Attrs()) {} |
304 | |
305 | Qr::Qr(const ::tensorflow::Scope& scope, ::tensorflow::Input input, const |
306 | Qr::Attrs& attrs) { |
307 | if (!scope.ok()) return; |
308 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
309 | if (!scope.ok()) return; |
310 | ::tensorflow::Node* ret; |
311 | const auto unique_name = scope.GetUniqueNameForOp("Qr" ); |
312 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Qr" ) |
313 | .Input(_input) |
314 | .Attr("full_matrices" , attrs.full_matrices_) |
315 | ; |
316 | scope.UpdateBuilder(&builder); |
317 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
318 | if (!scope.ok()) return; |
319 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
320 | this->operation = Operation(ret); |
321 | ::tensorflow::NameRangeMap _outputs_range; |
322 | ::tensorflow::Status _status_ = ::tensorflow::NameRangesForNode(*ret, ret->op_def(), nullptr, &_outputs_range); |
323 | if (!_status_.ok()) { |
324 | scope.UpdateStatus(_status_); |
325 | return; |
326 | } |
327 | |
328 | this->q = Output(ret, _outputs_range["q" ].first); |
329 | this->r = Output(ret, _outputs_range["r" ].first); |
330 | } |
331 | |
332 | Qr::Qr(const ::tensorflow::Scope& scope, ::tensorflow::Input input) |
333 | : Qr(scope, input, Qr::Attrs()) {} |
334 | |
335 | SelfAdjointEig::SelfAdjointEig(const ::tensorflow::Scope& scope, |
336 | ::tensorflow::Input input, const |
337 | SelfAdjointEig::Attrs& attrs) { |
338 | if (!scope.ok()) return; |
339 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
340 | if (!scope.ok()) return; |
341 | ::tensorflow::Node* ret; |
342 | const auto unique_name = scope.GetUniqueNameForOp("SelfAdjointEig" ); |
343 | auto builder = ::tensorflow::NodeBuilder(unique_name, "SelfAdjointEigV2" ) |
344 | .Input(_input) |
345 | .Attr("compute_v" , attrs.compute_v_) |
346 | ; |
347 | scope.UpdateBuilder(&builder); |
348 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
349 | if (!scope.ok()) return; |
350 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
351 | this->operation = Operation(ret); |
352 | ::tensorflow::NameRangeMap _outputs_range; |
353 | ::tensorflow::Status _status_ = ::tensorflow::NameRangesForNode(*ret, ret->op_def(), nullptr, &_outputs_range); |
354 | if (!_status_.ok()) { |
355 | scope.UpdateStatus(_status_); |
356 | return; |
357 | } |
358 | |
359 | this->e = Output(ret, _outputs_range["e" ].first); |
360 | this->v = Output(ret, _outputs_range["v" ].first); |
361 | } |
362 | |
363 | SelfAdjointEig::SelfAdjointEig(const ::tensorflow::Scope& scope, |
364 | ::tensorflow::Input input) |
365 | : SelfAdjointEig(scope, input, SelfAdjointEig::Attrs()) {} |
366 | |
367 | Svd::Svd(const ::tensorflow::Scope& scope, ::tensorflow::Input input, const |
368 | Svd::Attrs& attrs) { |
369 | if (!scope.ok()) return; |
370 | auto _input = ::tensorflow::ops::AsNodeOut(scope, input); |
371 | if (!scope.ok()) return; |
372 | ::tensorflow::Node* ret; |
373 | const auto unique_name = scope.GetUniqueNameForOp("Svd" ); |
374 | auto builder = ::tensorflow::NodeBuilder(unique_name, "Svd" ) |
375 | .Input(_input) |
376 | .Attr("compute_uv" , attrs.compute_uv_) |
377 | .Attr("full_matrices" , attrs.full_matrices_) |
378 | ; |
379 | scope.UpdateBuilder(&builder); |
380 | scope.UpdateStatus(builder.Finalize(scope.graph(), &ret)); |
381 | if (!scope.ok()) return; |
382 | scope.UpdateStatus(scope.DoShapeInference(ret)); |
383 | this->operation = Operation(ret); |
384 | ::tensorflow::NameRangeMap _outputs_range; |
385 | ::tensorflow::Status _status_ = ::tensorflow::NameRangesForNode(*ret, ret->op_def(), nullptr, &_outputs_range); |
386 | if (!_status_.ok()) { |
387 | scope.UpdateStatus(_status_); |
388 | return; |
389 | } |
390 | |
391 | this->s = Output(ret, _outputs_range["s" ].first); |
392 | this->u = Output(ret, _outputs_range["u" ].first); |
393 | this->v = Output(ret, _outputs_range["v" ].first); |
394 | } |
395 | |
396 | Svd::Svd(const ::tensorflow::Scope& scope, ::tensorflow::Input input) |
397 | : Svd(scope, input, Svd::Attrs()) {} |
398 | |
399 | /// @} |
400 | |
401 | } // namespace ops |
402 | } // namespace tensorflow |
403 | |