1// This file is MACHINE GENERATED! Do not edit.
2
3
4#include "tensorflow/cc/ops/const_op.h"
5#include "tensorflow/cc/ops/math_ops.h"
6
7namespace tensorflow {
8namespace ops {
9
10Abs::Abs(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
11 if (!scope.ok()) return;
12 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
13 if (!scope.ok()) return;
14 ::tensorflow::Node* ret;
15 const auto unique_name = scope.GetUniqueNameForOp("Abs");
16 auto builder = ::tensorflow::NodeBuilder(unique_name, "Abs")
17 .Input(_x)
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->y = Output(ret, 0);
25}
26
27AccumulateNV2::AccumulateNV2(const ::tensorflow::Scope& scope,
28 ::tensorflow::InputList inputs, PartialTensorShape
29 shape) {
30 if (!scope.ok()) return;
31 auto _inputs = ::tensorflow::ops::AsNodeOutList(scope, inputs);
32 if (!scope.ok()) return;
33 ::tensorflow::Node* ret;
34 const auto unique_name = scope.GetUniqueNameForOp("AccumulateNV2");
35 auto builder = ::tensorflow::NodeBuilder(unique_name, "AccumulateNV2")
36 .Input(_inputs)
37 .Attr("shape", shape)
38 ;
39 scope.UpdateBuilder(&builder);
40 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
41 if (!scope.ok()) return;
42 scope.UpdateStatus(scope.DoShapeInference(ret));
43 this->operation = Operation(ret);
44 this->sum = Output(ret, 0);
45}
46
47Acos::Acos(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
48 if (!scope.ok()) return;
49 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
50 if (!scope.ok()) return;
51 ::tensorflow::Node* ret;
52 const auto unique_name = scope.GetUniqueNameForOp("Acos");
53 auto builder = ::tensorflow::NodeBuilder(unique_name, "Acos")
54 .Input(_x)
55 ;
56 scope.UpdateBuilder(&builder);
57 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
58 if (!scope.ok()) return;
59 scope.UpdateStatus(scope.DoShapeInference(ret));
60 this->operation = Operation(ret);
61 this->y = Output(ret, 0);
62}
63
64Acosh::Acosh(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
65 if (!scope.ok()) return;
66 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
67 if (!scope.ok()) return;
68 ::tensorflow::Node* ret;
69 const auto unique_name = scope.GetUniqueNameForOp("Acosh");
70 auto builder = ::tensorflow::NodeBuilder(unique_name, "Acosh")
71 .Input(_x)
72 ;
73 scope.UpdateBuilder(&builder);
74 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
75 if (!scope.ok()) return;
76 scope.UpdateStatus(scope.DoShapeInference(ret));
77 this->operation = Operation(ret);
78 this->y = Output(ret, 0);
79}
80
81Add::Add(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
82 ::tensorflow::Input y) {
83 if (!scope.ok()) return;
84 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
85 if (!scope.ok()) return;
86 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
87 if (!scope.ok()) return;
88 ::tensorflow::Node* ret;
89 const auto unique_name = scope.GetUniqueNameForOp("Add");
90 auto builder = ::tensorflow::NodeBuilder(unique_name, "Add")
91 .Input(_x)
92 .Input(_y)
93 ;
94 scope.UpdateBuilder(&builder);
95 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
96 if (!scope.ok()) return;
97 scope.UpdateStatus(scope.DoShapeInference(ret));
98 this->operation = Operation(ret);
99 this->z = Output(ret, 0);
100}
101
102AddN::AddN(const ::tensorflow::Scope& scope, ::tensorflow::InputList inputs) {
103 if (!scope.ok()) return;
104 auto _inputs = ::tensorflow::ops::AsNodeOutList(scope, inputs);
105 if (!scope.ok()) return;
106 ::tensorflow::Node* ret;
107 const auto unique_name = scope.GetUniqueNameForOp("AddN");
108 auto builder = ::tensorflow::NodeBuilder(unique_name, "AddN")
109 .Input(_inputs)
110 ;
111 scope.UpdateBuilder(&builder);
112 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
113 if (!scope.ok()) return;
114 scope.UpdateStatus(scope.DoShapeInference(ret));
115 this->operation = Operation(ret);
116 this->sum = Output(ret, 0);
117}
118
119AddV2::AddV2(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
120 ::tensorflow::Input y) {
121 if (!scope.ok()) return;
122 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
123 if (!scope.ok()) return;
124 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
125 if (!scope.ok()) return;
126 ::tensorflow::Node* ret;
127 const auto unique_name = scope.GetUniqueNameForOp("AddV2");
128 auto builder = ::tensorflow::NodeBuilder(unique_name, "AddV2")
129 .Input(_x)
130 .Input(_y)
131 ;
132 scope.UpdateBuilder(&builder);
133 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
134 if (!scope.ok()) return;
135 scope.UpdateStatus(scope.DoShapeInference(ret));
136 this->operation = Operation(ret);
137 this->z = Output(ret, 0);
138}
139
140All::All(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
141 ::tensorflow::Input axis, const All::Attrs& attrs) {
142 if (!scope.ok()) return;
143 auto _input = ::tensorflow::ops::AsNodeOut(scope, input);
144 if (!scope.ok()) return;
145 auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis);
146 if (!scope.ok()) return;
147 ::tensorflow::Node* ret;
148 const auto unique_name = scope.GetUniqueNameForOp("All");
149 auto builder = ::tensorflow::NodeBuilder(unique_name, "All")
150 .Input(_input)
151 .Input(_axis)
152 .Attr("keep_dims", attrs.keep_dims_)
153 ;
154 scope.UpdateBuilder(&builder);
155 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
156 if (!scope.ok()) return;
157 scope.UpdateStatus(scope.DoShapeInference(ret));
158 this->operation = Operation(ret);
159 this->output = Output(ret, 0);
160}
161
162All::All(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
163 ::tensorflow::Input axis)
164 : All(scope, input, axis, All::Attrs()) {}
165
166Angle::Angle(const ::tensorflow::Scope& scope, ::tensorflow::Input input, const
167 Angle::Attrs& attrs) {
168 if (!scope.ok()) return;
169 auto _input = ::tensorflow::ops::AsNodeOut(scope, input);
170 if (!scope.ok()) return;
171 ::tensorflow::Node* ret;
172 const auto unique_name = scope.GetUniqueNameForOp("Angle");
173 auto builder = ::tensorflow::NodeBuilder(unique_name, "Angle")
174 .Input(_input)
175 .Attr("Tout", attrs.Tout_)
176 ;
177 scope.UpdateBuilder(&builder);
178 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
179 if (!scope.ok()) return;
180 scope.UpdateStatus(scope.DoShapeInference(ret));
181 this->operation = Operation(ret);
182 this->output = Output(ret, 0);
183}
184
185Angle::Angle(const ::tensorflow::Scope& scope, ::tensorflow::Input input)
186 : Angle(scope, input, Angle::Attrs()) {}
187
188Any::Any(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
189 ::tensorflow::Input axis, const Any::Attrs& attrs) {
190 if (!scope.ok()) return;
191 auto _input = ::tensorflow::ops::AsNodeOut(scope, input);
192 if (!scope.ok()) return;
193 auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis);
194 if (!scope.ok()) return;
195 ::tensorflow::Node* ret;
196 const auto unique_name = scope.GetUniqueNameForOp("Any");
197 auto builder = ::tensorflow::NodeBuilder(unique_name, "Any")
198 .Input(_input)
199 .Input(_axis)
200 .Attr("keep_dims", attrs.keep_dims_)
201 ;
202 scope.UpdateBuilder(&builder);
203 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
204 if (!scope.ok()) return;
205 scope.UpdateStatus(scope.DoShapeInference(ret));
206 this->operation = Operation(ret);
207 this->output = Output(ret, 0);
208}
209
210Any::Any(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
211 ::tensorflow::Input axis)
212 : Any(scope, input, axis, Any::Attrs()) {}
213
214ApproximateEqual::ApproximateEqual(const ::tensorflow::Scope& scope,
215 ::tensorflow::Input x, ::tensorflow::Input
216 y, const ApproximateEqual::Attrs& attrs) {
217 if (!scope.ok()) return;
218 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
219 if (!scope.ok()) return;
220 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
221 if (!scope.ok()) return;
222 ::tensorflow::Node* ret;
223 const auto unique_name = scope.GetUniqueNameForOp("ApproximateEqual");
224 auto builder = ::tensorflow::NodeBuilder(unique_name, "ApproximateEqual")
225 .Input(_x)
226 .Input(_y)
227 .Attr("tolerance", attrs.tolerance_)
228 ;
229 scope.UpdateBuilder(&builder);
230 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
231 if (!scope.ok()) return;
232 scope.UpdateStatus(scope.DoShapeInference(ret));
233 this->operation = Operation(ret);
234 this->z = Output(ret, 0);
235}
236
237ApproximateEqual::ApproximateEqual(const ::tensorflow::Scope& scope,
238 ::tensorflow::Input x, ::tensorflow::Input
239 y)
240 : ApproximateEqual(scope, x, y, ApproximateEqual::Attrs()) {}
241
242ArgMax::ArgMax(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
243 ::tensorflow::Input dimension, const ArgMax::Attrs& attrs) {
244 if (!scope.ok()) return;
245 auto _input = ::tensorflow::ops::AsNodeOut(scope, input);
246 if (!scope.ok()) return;
247 auto _dimension = ::tensorflow::ops::AsNodeOut(scope, dimension);
248 if (!scope.ok()) return;
249 ::tensorflow::Node* ret;
250 const auto unique_name = scope.GetUniqueNameForOp("ArgMax");
251 auto builder = ::tensorflow::NodeBuilder(unique_name, "ArgMax")
252 .Input(_input)
253 .Input(_dimension)
254 .Attr("output_type", attrs.output_type_)
255 ;
256 scope.UpdateBuilder(&builder);
257 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
258 if (!scope.ok()) return;
259 scope.UpdateStatus(scope.DoShapeInference(ret));
260 this->operation = Operation(ret);
261 this->output = Output(ret, 0);
262}
263
264ArgMax::ArgMax(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
265 ::tensorflow::Input dimension)
266 : ArgMax(scope, input, dimension, ArgMax::Attrs()) {}
267
268ArgMin::ArgMin(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
269 ::tensorflow::Input dimension, const ArgMin::Attrs& attrs) {
270 if (!scope.ok()) return;
271 auto _input = ::tensorflow::ops::AsNodeOut(scope, input);
272 if (!scope.ok()) return;
273 auto _dimension = ::tensorflow::ops::AsNodeOut(scope, dimension);
274 if (!scope.ok()) return;
275 ::tensorflow::Node* ret;
276 const auto unique_name = scope.GetUniqueNameForOp("ArgMin");
277 auto builder = ::tensorflow::NodeBuilder(unique_name, "ArgMin")
278 .Input(_input)
279 .Input(_dimension)
280 .Attr("output_type", attrs.output_type_)
281 ;
282 scope.UpdateBuilder(&builder);
283 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
284 if (!scope.ok()) return;
285 scope.UpdateStatus(scope.DoShapeInference(ret));
286 this->operation = Operation(ret);
287 this->output = Output(ret, 0);
288}
289
290ArgMin::ArgMin(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
291 ::tensorflow::Input dimension)
292 : ArgMin(scope, input, dimension, ArgMin::Attrs()) {}
293
294Asin::Asin(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
295 if (!scope.ok()) return;
296 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
297 if (!scope.ok()) return;
298 ::tensorflow::Node* ret;
299 const auto unique_name = scope.GetUniqueNameForOp("Asin");
300 auto builder = ::tensorflow::NodeBuilder(unique_name, "Asin")
301 .Input(_x)
302 ;
303 scope.UpdateBuilder(&builder);
304 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
305 if (!scope.ok()) return;
306 scope.UpdateStatus(scope.DoShapeInference(ret));
307 this->operation = Operation(ret);
308 this->y = Output(ret, 0);
309}
310
311Asinh::Asinh(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
312 if (!scope.ok()) return;
313 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
314 if (!scope.ok()) return;
315 ::tensorflow::Node* ret;
316 const auto unique_name = scope.GetUniqueNameForOp("Asinh");
317 auto builder = ::tensorflow::NodeBuilder(unique_name, "Asinh")
318 .Input(_x)
319 ;
320 scope.UpdateBuilder(&builder);
321 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
322 if (!scope.ok()) return;
323 scope.UpdateStatus(scope.DoShapeInference(ret));
324 this->operation = Operation(ret);
325 this->y = Output(ret, 0);
326}
327
328Atan::Atan(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
329 if (!scope.ok()) return;
330 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
331 if (!scope.ok()) return;
332 ::tensorflow::Node* ret;
333 const auto unique_name = scope.GetUniqueNameForOp("Atan");
334 auto builder = ::tensorflow::NodeBuilder(unique_name, "Atan")
335 .Input(_x)
336 ;
337 scope.UpdateBuilder(&builder);
338 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
339 if (!scope.ok()) return;
340 scope.UpdateStatus(scope.DoShapeInference(ret));
341 this->operation = Operation(ret);
342 this->y = Output(ret, 0);
343}
344
345Atan2::Atan2(const ::tensorflow::Scope& scope, ::tensorflow::Input y,
346 ::tensorflow::Input x) {
347 if (!scope.ok()) return;
348 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
349 if (!scope.ok()) return;
350 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
351 if (!scope.ok()) return;
352 ::tensorflow::Node* ret;
353 const auto unique_name = scope.GetUniqueNameForOp("Atan2");
354 auto builder = ::tensorflow::NodeBuilder(unique_name, "Atan2")
355 .Input(_y)
356 .Input(_x)
357 ;
358 scope.UpdateBuilder(&builder);
359 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
360 if (!scope.ok()) return;
361 scope.UpdateStatus(scope.DoShapeInference(ret));
362 this->operation = Operation(ret);
363 this->z = Output(ret, 0);
364}
365
366Atanh::Atanh(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
367 if (!scope.ok()) return;
368 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
369 if (!scope.ok()) return;
370 ::tensorflow::Node* ret;
371 const auto unique_name = scope.GetUniqueNameForOp("Atanh");
372 auto builder = ::tensorflow::NodeBuilder(unique_name, "Atanh")
373 .Input(_x)
374 ;
375 scope.UpdateBuilder(&builder);
376 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
377 if (!scope.ok()) return;
378 scope.UpdateStatus(scope.DoShapeInference(ret));
379 this->operation = Operation(ret);
380 this->y = Output(ret, 0);
381}
382
383BatchMatMul::BatchMatMul(const ::tensorflow::Scope& scope, ::tensorflow::Input
384 x, ::tensorflow::Input y, const BatchMatMul::Attrs&
385 attrs) {
386 if (!scope.ok()) return;
387 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
388 if (!scope.ok()) return;
389 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
390 if (!scope.ok()) return;
391 ::tensorflow::Node* ret;
392 const auto unique_name = scope.GetUniqueNameForOp("BatchMatMul");
393 auto builder = ::tensorflow::NodeBuilder(unique_name, "BatchMatMul")
394 .Input(_x)
395 .Input(_y)
396 .Attr("adj_x", attrs.adj_x_)
397 .Attr("adj_y", attrs.adj_y_)
398 ;
399 scope.UpdateBuilder(&builder);
400 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
401 if (!scope.ok()) return;
402 scope.UpdateStatus(scope.DoShapeInference(ret));
403 this->operation = Operation(ret);
404 this->output = Output(ret, 0);
405}
406
407BatchMatMul::BatchMatMul(const ::tensorflow::Scope& scope, ::tensorflow::Input
408 x, ::tensorflow::Input y)
409 : BatchMatMul(scope, x, y, BatchMatMul::Attrs()) {}
410
411BatchMatMulV2::BatchMatMulV2(const ::tensorflow::Scope& scope,
412 ::tensorflow::Input x, ::tensorflow::Input y,
413 const BatchMatMulV2::Attrs& attrs) {
414 if (!scope.ok()) return;
415 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
416 if (!scope.ok()) return;
417 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
418 if (!scope.ok()) return;
419 ::tensorflow::Node* ret;
420 const auto unique_name = scope.GetUniqueNameForOp("BatchMatMulV2");
421 auto builder = ::tensorflow::NodeBuilder(unique_name, "BatchMatMulV2")
422 .Input(_x)
423 .Input(_y)
424 .Attr("adj_x", attrs.adj_x_)
425 .Attr("adj_y", attrs.adj_y_)
426 ;
427 scope.UpdateBuilder(&builder);
428 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
429 if (!scope.ok()) return;
430 scope.UpdateStatus(scope.DoShapeInference(ret));
431 this->operation = Operation(ret);
432 this->output = Output(ret, 0);
433}
434
435BatchMatMulV2::BatchMatMulV2(const ::tensorflow::Scope& scope,
436 ::tensorflow::Input x, ::tensorflow::Input y)
437 : BatchMatMulV2(scope, x, y, BatchMatMulV2::Attrs()) {}
438
439BatchMatMulV3::BatchMatMulV3(const ::tensorflow::Scope& scope,
440 ::tensorflow::Input x, ::tensorflow::Input y,
441 DataType Tout, const BatchMatMulV3::Attrs& attrs) {
442 if (!scope.ok()) return;
443 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
444 if (!scope.ok()) return;
445 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
446 if (!scope.ok()) return;
447 ::tensorflow::Node* ret;
448 const auto unique_name = scope.GetUniqueNameForOp("BatchMatMulV3");
449 auto builder = ::tensorflow::NodeBuilder(unique_name, "BatchMatMulV3")
450 .Input(_x)
451 .Input(_y)
452 .Attr("Tout", Tout)
453 .Attr("adj_x", attrs.adj_x_)
454 .Attr("adj_y", attrs.adj_y_)
455 ;
456 scope.UpdateBuilder(&builder);
457 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
458 if (!scope.ok()) return;
459 scope.UpdateStatus(scope.DoShapeInference(ret));
460 this->operation = Operation(ret);
461 this->output = Output(ret, 0);
462}
463
464BatchMatMulV3::BatchMatMulV3(const ::tensorflow::Scope& scope,
465 ::tensorflow::Input x, ::tensorflow::Input y,
466 DataType Tout)
467 : BatchMatMulV3(scope, x, y, Tout, BatchMatMulV3::Attrs()) {}
468
469Betainc::Betainc(const ::tensorflow::Scope& scope, ::tensorflow::Input a,
470 ::tensorflow::Input b, ::tensorflow::Input x) {
471 if (!scope.ok()) return;
472 auto _a = ::tensorflow::ops::AsNodeOut(scope, a);
473 if (!scope.ok()) return;
474 auto _b = ::tensorflow::ops::AsNodeOut(scope, b);
475 if (!scope.ok()) return;
476 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
477 if (!scope.ok()) return;
478 ::tensorflow::Node* ret;
479 const auto unique_name = scope.GetUniqueNameForOp("Betainc");
480 auto builder = ::tensorflow::NodeBuilder(unique_name, "Betainc")
481 .Input(_a)
482 .Input(_b)
483 .Input(_x)
484 ;
485 scope.UpdateBuilder(&builder);
486 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
487 if (!scope.ok()) return;
488 scope.UpdateStatus(scope.DoShapeInference(ret));
489 this->operation = Operation(ret);
490 this->z = Output(ret, 0);
491}
492
493Bincount::Bincount(const ::tensorflow::Scope& scope, ::tensorflow::Input arr,
494 ::tensorflow::Input size, ::tensorflow::Input weights) {
495 if (!scope.ok()) return;
496 auto _arr = ::tensorflow::ops::AsNodeOut(scope, arr);
497 if (!scope.ok()) return;
498 auto _size = ::tensorflow::ops::AsNodeOut(scope, size);
499 if (!scope.ok()) return;
500 auto _weights = ::tensorflow::ops::AsNodeOut(scope, weights);
501 if (!scope.ok()) return;
502 ::tensorflow::Node* ret;
503 const auto unique_name = scope.GetUniqueNameForOp("Bincount");
504 auto builder = ::tensorflow::NodeBuilder(unique_name, "Bincount")
505 .Input(_arr)
506 .Input(_size)
507 .Input(_weights)
508 ;
509 scope.UpdateBuilder(&builder);
510 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
511 if (!scope.ok()) return;
512 scope.UpdateStatus(scope.DoShapeInference(ret));
513 this->operation = Operation(ret);
514 this->bins = Output(ret, 0);
515}
516
517Bucketize::Bucketize(const ::tensorflow::Scope& scope, ::tensorflow::Input
518 input, const gtl::ArraySlice<float>& boundaries) {
519 if (!scope.ok()) return;
520 auto _input = ::tensorflow::ops::AsNodeOut(scope, input);
521 if (!scope.ok()) return;
522 ::tensorflow::Node* ret;
523 const auto unique_name = scope.GetUniqueNameForOp("Bucketize");
524 auto builder = ::tensorflow::NodeBuilder(unique_name, "Bucketize")
525 .Input(_input)
526 .Attr("boundaries", boundaries)
527 ;
528 scope.UpdateBuilder(&builder);
529 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
530 if (!scope.ok()) return;
531 scope.UpdateStatus(scope.DoShapeInference(ret));
532 this->operation = Operation(ret);
533 this->output = Output(ret, 0);
534}
535
536Cast::Cast(const ::tensorflow::Scope& scope, ::tensorflow::Input x, DataType
537 DstT, const Cast::Attrs& attrs) {
538 if (!scope.ok()) return;
539 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
540 if (!scope.ok()) return;
541 ::tensorflow::Node* ret;
542 const auto unique_name = scope.GetUniqueNameForOp("Cast");
543 auto builder = ::tensorflow::NodeBuilder(unique_name, "Cast")
544 .Input(_x)
545 .Attr("DstT", DstT)
546 .Attr("Truncate", attrs.Truncate_)
547 ;
548 scope.UpdateBuilder(&builder);
549 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
550 if (!scope.ok()) return;
551 scope.UpdateStatus(scope.DoShapeInference(ret));
552 this->operation = Operation(ret);
553 this->y = Output(ret, 0);
554}
555
556Cast::Cast(const ::tensorflow::Scope& scope, ::tensorflow::Input x, DataType
557 DstT)
558 : Cast(scope, x, DstT, Cast::Attrs()) {}
559
560Ceil::Ceil(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
561 if (!scope.ok()) return;
562 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
563 if (!scope.ok()) return;
564 ::tensorflow::Node* ret;
565 const auto unique_name = scope.GetUniqueNameForOp("Ceil");
566 auto builder = ::tensorflow::NodeBuilder(unique_name, "Ceil")
567 .Input(_x)
568 ;
569 scope.UpdateBuilder(&builder);
570 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
571 if (!scope.ok()) return;
572 scope.UpdateStatus(scope.DoShapeInference(ret));
573 this->operation = Operation(ret);
574 this->y = Output(ret, 0);
575}
576
577ClipByValue::ClipByValue(const ::tensorflow::Scope& scope, ::tensorflow::Input
578 t, ::tensorflow::Input clip_value_min,
579 ::tensorflow::Input clip_value_max) {
580 if (!scope.ok()) return;
581 auto _t = ::tensorflow::ops::AsNodeOut(scope, t);
582 if (!scope.ok()) return;
583 auto _clip_value_min = ::tensorflow::ops::AsNodeOut(scope, clip_value_min);
584 if (!scope.ok()) return;
585 auto _clip_value_max = ::tensorflow::ops::AsNodeOut(scope, clip_value_max);
586 if (!scope.ok()) return;
587 ::tensorflow::Node* ret;
588 const auto unique_name = scope.GetUniqueNameForOp("ClipByValue");
589 auto builder = ::tensorflow::NodeBuilder(unique_name, "ClipByValue")
590 .Input(_t)
591 .Input(_clip_value_min)
592 .Input(_clip_value_max)
593 ;
594 scope.UpdateBuilder(&builder);
595 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
596 if (!scope.ok()) return;
597 scope.UpdateStatus(scope.DoShapeInference(ret));
598 this->operation = Operation(ret);
599 this->output = Output(ret, 0);
600}
601
602Complex::Complex(const ::tensorflow::Scope& scope, ::tensorflow::Input real,
603 ::tensorflow::Input imag, const Complex::Attrs& attrs) {
604 if (!scope.ok()) return;
605 auto _real = ::tensorflow::ops::AsNodeOut(scope, real);
606 if (!scope.ok()) return;
607 auto _imag = ::tensorflow::ops::AsNodeOut(scope, imag);
608 if (!scope.ok()) return;
609 ::tensorflow::Node* ret;
610 const auto unique_name = scope.GetUniqueNameForOp("Complex");
611 auto builder = ::tensorflow::NodeBuilder(unique_name, "Complex")
612 .Input(_real)
613 .Input(_imag)
614 .Attr("Tout", attrs.Tout_)
615 ;
616 scope.UpdateBuilder(&builder);
617 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
618 if (!scope.ok()) return;
619 scope.UpdateStatus(scope.DoShapeInference(ret));
620 this->operation = Operation(ret);
621 this->out = Output(ret, 0);
622}
623
624Complex::Complex(const ::tensorflow::Scope& scope, ::tensorflow::Input real,
625 ::tensorflow::Input imag)
626 : Complex(scope, real, imag, Complex::Attrs()) {}
627
628ComplexAbs::ComplexAbs(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
629 const ComplexAbs::Attrs& attrs) {
630 if (!scope.ok()) return;
631 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
632 if (!scope.ok()) return;
633 ::tensorflow::Node* ret;
634 const auto unique_name = scope.GetUniqueNameForOp("ComplexAbs");
635 auto builder = ::tensorflow::NodeBuilder(unique_name, "ComplexAbs")
636 .Input(_x)
637 .Attr("Tout", attrs.Tout_)
638 ;
639 scope.UpdateBuilder(&builder);
640 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
641 if (!scope.ok()) return;
642 scope.UpdateStatus(scope.DoShapeInference(ret));
643 this->operation = Operation(ret);
644 this->y = Output(ret, 0);
645}
646
647ComplexAbs::ComplexAbs(const ::tensorflow::Scope& scope, ::tensorflow::Input x)
648 : ComplexAbs(scope, x, ComplexAbs::Attrs()) {}
649
650Conj::Conj(const ::tensorflow::Scope& scope, ::tensorflow::Input input) {
651 if (!scope.ok()) return;
652 auto _input = ::tensorflow::ops::AsNodeOut(scope, input);
653 if (!scope.ok()) return;
654 ::tensorflow::Node* ret;
655 const auto unique_name = scope.GetUniqueNameForOp("Conj");
656 auto builder = ::tensorflow::NodeBuilder(unique_name, "Conj")
657 .Input(_input)
658 ;
659 scope.UpdateBuilder(&builder);
660 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
661 if (!scope.ok()) return;
662 scope.UpdateStatus(scope.DoShapeInference(ret));
663 this->operation = Operation(ret);
664 this->output = Output(ret, 0);
665}
666
667Cos::Cos(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
668 if (!scope.ok()) return;
669 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
670 if (!scope.ok()) return;
671 ::tensorflow::Node* ret;
672 const auto unique_name = scope.GetUniqueNameForOp("Cos");
673 auto builder = ::tensorflow::NodeBuilder(unique_name, "Cos")
674 .Input(_x)
675 ;
676 scope.UpdateBuilder(&builder);
677 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
678 if (!scope.ok()) return;
679 scope.UpdateStatus(scope.DoShapeInference(ret));
680 this->operation = Operation(ret);
681 this->y = Output(ret, 0);
682}
683
684Cosh::Cosh(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
685 if (!scope.ok()) return;
686 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
687 if (!scope.ok()) return;
688 ::tensorflow::Node* ret;
689 const auto unique_name = scope.GetUniqueNameForOp("Cosh");
690 auto builder = ::tensorflow::NodeBuilder(unique_name, "Cosh")
691 .Input(_x)
692 ;
693 scope.UpdateBuilder(&builder);
694 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
695 if (!scope.ok()) return;
696 scope.UpdateStatus(scope.DoShapeInference(ret));
697 this->operation = Operation(ret);
698 this->y = Output(ret, 0);
699}
700
701Cross::Cross(const ::tensorflow::Scope& scope, ::tensorflow::Input a,
702 ::tensorflow::Input b) {
703 if (!scope.ok()) return;
704 auto _a = ::tensorflow::ops::AsNodeOut(scope, a);
705 if (!scope.ok()) return;
706 auto _b = ::tensorflow::ops::AsNodeOut(scope, b);
707 if (!scope.ok()) return;
708 ::tensorflow::Node* ret;
709 const auto unique_name = scope.GetUniqueNameForOp("Cross");
710 auto builder = ::tensorflow::NodeBuilder(unique_name, "Cross")
711 .Input(_a)
712 .Input(_b)
713 ;
714 scope.UpdateBuilder(&builder);
715 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
716 if (!scope.ok()) return;
717 scope.UpdateStatus(scope.DoShapeInference(ret));
718 this->operation = Operation(ret);
719 this->product = Output(ret, 0);
720}
721
722Cumprod::Cumprod(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
723 ::tensorflow::Input axis, const Cumprod::Attrs& attrs) {
724 if (!scope.ok()) return;
725 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
726 if (!scope.ok()) return;
727 auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis);
728 if (!scope.ok()) return;
729 ::tensorflow::Node* ret;
730 const auto unique_name = scope.GetUniqueNameForOp("Cumprod");
731 auto builder = ::tensorflow::NodeBuilder(unique_name, "Cumprod")
732 .Input(_x)
733 .Input(_axis)
734 .Attr("exclusive", attrs.exclusive_)
735 .Attr("reverse", attrs.reverse_)
736 ;
737 scope.UpdateBuilder(&builder);
738 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
739 if (!scope.ok()) return;
740 scope.UpdateStatus(scope.DoShapeInference(ret));
741 this->operation = Operation(ret);
742 this->out = Output(ret, 0);
743}
744
745Cumprod::Cumprod(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
746 ::tensorflow::Input axis)
747 : Cumprod(scope, x, axis, Cumprod::Attrs()) {}
748
749Cumsum::Cumsum(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
750 ::tensorflow::Input axis, const Cumsum::Attrs& attrs) {
751 if (!scope.ok()) return;
752 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
753 if (!scope.ok()) return;
754 auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis);
755 if (!scope.ok()) return;
756 ::tensorflow::Node* ret;
757 const auto unique_name = scope.GetUniqueNameForOp("Cumsum");
758 auto builder = ::tensorflow::NodeBuilder(unique_name, "Cumsum")
759 .Input(_x)
760 .Input(_axis)
761 .Attr("exclusive", attrs.exclusive_)
762 .Attr("reverse", attrs.reverse_)
763 ;
764 scope.UpdateBuilder(&builder);
765 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
766 if (!scope.ok()) return;
767 scope.UpdateStatus(scope.DoShapeInference(ret));
768 this->operation = Operation(ret);
769 this->out = Output(ret, 0);
770}
771
772Cumsum::Cumsum(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
773 ::tensorflow::Input axis)
774 : Cumsum(scope, x, axis, Cumsum::Attrs()) {}
775
776DenseBincount::DenseBincount(const ::tensorflow::Scope& scope,
777 ::tensorflow::Input input, ::tensorflow::Input
778 size, ::tensorflow::Input weights, const
779 DenseBincount::Attrs& attrs) {
780 if (!scope.ok()) return;
781 auto _input = ::tensorflow::ops::AsNodeOut(scope, input);
782 if (!scope.ok()) return;
783 auto _size = ::tensorflow::ops::AsNodeOut(scope, size);
784 if (!scope.ok()) return;
785 auto _weights = ::tensorflow::ops::AsNodeOut(scope, weights);
786 if (!scope.ok()) return;
787 ::tensorflow::Node* ret;
788 const auto unique_name = scope.GetUniqueNameForOp("DenseBincount");
789 auto builder = ::tensorflow::NodeBuilder(unique_name, "DenseBincount")
790 .Input(_input)
791 .Input(_size)
792 .Input(_weights)
793 .Attr("binary_output", attrs.binary_output_)
794 ;
795 scope.UpdateBuilder(&builder);
796 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
797 if (!scope.ok()) return;
798 scope.UpdateStatus(scope.DoShapeInference(ret));
799 this->operation = Operation(ret);
800 this->output = Output(ret, 0);
801}
802
803DenseBincount::DenseBincount(const ::tensorflow::Scope& scope,
804 ::tensorflow::Input input, ::tensorflow::Input
805 size, ::tensorflow::Input weights)
806 : DenseBincount(scope, input, size, weights, DenseBincount::Attrs()) {}
807
808Digamma::Digamma(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
809 if (!scope.ok()) return;
810 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
811 if (!scope.ok()) return;
812 ::tensorflow::Node* ret;
813 const auto unique_name = scope.GetUniqueNameForOp("Digamma");
814 auto builder = ::tensorflow::NodeBuilder(unique_name, "Digamma")
815 .Input(_x)
816 ;
817 scope.UpdateBuilder(&builder);
818 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
819 if (!scope.ok()) return;
820 scope.UpdateStatus(scope.DoShapeInference(ret));
821 this->operation = Operation(ret);
822 this->y = Output(ret, 0);
823}
824
825Div::Div(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
826 ::tensorflow::Input y) {
827 if (!scope.ok()) return;
828 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
829 if (!scope.ok()) return;
830 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
831 if (!scope.ok()) return;
832 ::tensorflow::Node* ret;
833 const auto unique_name = scope.GetUniqueNameForOp("Div");
834 auto builder = ::tensorflow::NodeBuilder(unique_name, "Div")
835 .Input(_x)
836 .Input(_y)
837 ;
838 scope.UpdateBuilder(&builder);
839 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
840 if (!scope.ok()) return;
841 scope.UpdateStatus(scope.DoShapeInference(ret));
842 this->operation = Operation(ret);
843 this->z = Output(ret, 0);
844}
845
846DivNoNan::DivNoNan(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
847 ::tensorflow::Input y) {
848 if (!scope.ok()) return;
849 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
850 if (!scope.ok()) return;
851 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
852 if (!scope.ok()) return;
853 ::tensorflow::Node* ret;
854 const auto unique_name = scope.GetUniqueNameForOp("DivNoNan");
855 auto builder = ::tensorflow::NodeBuilder(unique_name, "DivNoNan")
856 .Input(_x)
857 .Input(_y)
858 ;
859 scope.UpdateBuilder(&builder);
860 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
861 if (!scope.ok()) return;
862 scope.UpdateStatus(scope.DoShapeInference(ret));
863 this->operation = Operation(ret);
864 this->z = Output(ret, 0);
865}
866
867Equal::Equal(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
868 ::tensorflow::Input y, const Equal::Attrs& attrs) {
869 if (!scope.ok()) return;
870 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
871 if (!scope.ok()) return;
872 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
873 if (!scope.ok()) return;
874 ::tensorflow::Node* ret;
875 const auto unique_name = scope.GetUniqueNameForOp("Equal");
876 auto builder = ::tensorflow::NodeBuilder(unique_name, "Equal")
877 .Input(_x)
878 .Input(_y)
879 .Attr("incompatible_shape_error", attrs.incompatible_shape_error_)
880 ;
881 scope.UpdateBuilder(&builder);
882 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
883 if (!scope.ok()) return;
884 scope.UpdateStatus(scope.DoShapeInference(ret));
885 this->operation = Operation(ret);
886 this->z = Output(ret, 0);
887}
888
889Equal::Equal(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
890 ::tensorflow::Input y)
891 : Equal(scope, x, y, Equal::Attrs()) {}
892
893Erf::Erf(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
894 if (!scope.ok()) return;
895 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
896 if (!scope.ok()) return;
897 ::tensorflow::Node* ret;
898 const auto unique_name = scope.GetUniqueNameForOp("Erf");
899 auto builder = ::tensorflow::NodeBuilder(unique_name, "Erf")
900 .Input(_x)
901 ;
902 scope.UpdateBuilder(&builder);
903 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
904 if (!scope.ok()) return;
905 scope.UpdateStatus(scope.DoShapeInference(ret));
906 this->operation = Operation(ret);
907 this->y = Output(ret, 0);
908}
909
910Erfc::Erfc(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
911 if (!scope.ok()) return;
912 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
913 if (!scope.ok()) return;
914 ::tensorflow::Node* ret;
915 const auto unique_name = scope.GetUniqueNameForOp("Erfc");
916 auto builder = ::tensorflow::NodeBuilder(unique_name, "Erfc")
917 .Input(_x)
918 ;
919 scope.UpdateBuilder(&builder);
920 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
921 if (!scope.ok()) return;
922 scope.UpdateStatus(scope.DoShapeInference(ret));
923 this->operation = Operation(ret);
924 this->y = Output(ret, 0);
925}
926
927Erfinv::Erfinv(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
928 if (!scope.ok()) return;
929 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
930 if (!scope.ok()) return;
931 ::tensorflow::Node* ret;
932 const auto unique_name = scope.GetUniqueNameForOp("Erfinv");
933 auto builder = ::tensorflow::NodeBuilder(unique_name, "Erfinv")
934 .Input(_x)
935 ;
936 scope.UpdateBuilder(&builder);
937 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
938 if (!scope.ok()) return;
939 scope.UpdateStatus(scope.DoShapeInference(ret));
940 this->operation = Operation(ret);
941 this->y = Output(ret, 0);
942}
943
944EuclideanNorm::EuclideanNorm(const ::tensorflow::Scope& scope,
945 ::tensorflow::Input input, ::tensorflow::Input
946 axis, const EuclideanNorm::Attrs& attrs) {
947 if (!scope.ok()) return;
948 auto _input = ::tensorflow::ops::AsNodeOut(scope, input);
949 if (!scope.ok()) return;
950 auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis);
951 if (!scope.ok()) return;
952 ::tensorflow::Node* ret;
953 const auto unique_name = scope.GetUniqueNameForOp("EuclideanNorm");
954 auto builder = ::tensorflow::NodeBuilder(unique_name, "EuclideanNorm")
955 .Input(_input)
956 .Input(_axis)
957 .Attr("keep_dims", attrs.keep_dims_)
958 ;
959 scope.UpdateBuilder(&builder);
960 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
961 if (!scope.ok()) return;
962 scope.UpdateStatus(scope.DoShapeInference(ret));
963 this->operation = Operation(ret);
964 this->output = Output(ret, 0);
965}
966
967EuclideanNorm::EuclideanNorm(const ::tensorflow::Scope& scope,
968 ::tensorflow::Input input, ::tensorflow::Input
969 axis)
970 : EuclideanNorm(scope, input, axis, EuclideanNorm::Attrs()) {}
971
972Exp::Exp(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
973 if (!scope.ok()) return;
974 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
975 if (!scope.ok()) return;
976 ::tensorflow::Node* ret;
977 const auto unique_name = scope.GetUniqueNameForOp("Exp");
978 auto builder = ::tensorflow::NodeBuilder(unique_name, "Exp")
979 .Input(_x)
980 ;
981 scope.UpdateBuilder(&builder);
982 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
983 if (!scope.ok()) return;
984 scope.UpdateStatus(scope.DoShapeInference(ret));
985 this->operation = Operation(ret);
986 this->y = Output(ret, 0);
987}
988
989Expm1::Expm1(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
990 if (!scope.ok()) return;
991 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
992 if (!scope.ok()) return;
993 ::tensorflow::Node* ret;
994 const auto unique_name = scope.GetUniqueNameForOp("Expm1");
995 auto builder = ::tensorflow::NodeBuilder(unique_name, "Expm1")
996 .Input(_x)
997 ;
998 scope.UpdateBuilder(&builder);
999 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1000 if (!scope.ok()) return;
1001 scope.UpdateStatus(scope.DoShapeInference(ret));
1002 this->operation = Operation(ret);
1003 this->y = Output(ret, 0);
1004}
1005
1006Floor::Floor(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
1007 if (!scope.ok()) return;
1008 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1009 if (!scope.ok()) return;
1010 ::tensorflow::Node* ret;
1011 const auto unique_name = scope.GetUniqueNameForOp("Floor");
1012 auto builder = ::tensorflow::NodeBuilder(unique_name, "Floor")
1013 .Input(_x)
1014 ;
1015 scope.UpdateBuilder(&builder);
1016 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1017 if (!scope.ok()) return;
1018 scope.UpdateStatus(scope.DoShapeInference(ret));
1019 this->operation = Operation(ret);
1020 this->y = Output(ret, 0);
1021}
1022
1023FloorDiv::FloorDiv(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
1024 ::tensorflow::Input y) {
1025 if (!scope.ok()) return;
1026 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1027 if (!scope.ok()) return;
1028 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
1029 if (!scope.ok()) return;
1030 ::tensorflow::Node* ret;
1031 const auto unique_name = scope.GetUniqueNameForOp("FloorDiv");
1032 auto builder = ::tensorflow::NodeBuilder(unique_name, "FloorDiv")
1033 .Input(_x)
1034 .Input(_y)
1035 ;
1036 scope.UpdateBuilder(&builder);
1037 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1038 if (!scope.ok()) return;
1039 scope.UpdateStatus(scope.DoShapeInference(ret));
1040 this->operation = Operation(ret);
1041 this->z = Output(ret, 0);
1042}
1043
1044FloorMod::FloorMod(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
1045 ::tensorflow::Input y) {
1046 if (!scope.ok()) return;
1047 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1048 if (!scope.ok()) return;
1049 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
1050 if (!scope.ok()) return;
1051 ::tensorflow::Node* ret;
1052 const auto unique_name = scope.GetUniqueNameForOp("FloorMod");
1053 auto builder = ::tensorflow::NodeBuilder(unique_name, "FloorMod")
1054 .Input(_x)
1055 .Input(_y)
1056 ;
1057 scope.UpdateBuilder(&builder);
1058 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1059 if (!scope.ok()) return;
1060 scope.UpdateStatus(scope.DoShapeInference(ret));
1061 this->operation = Operation(ret);
1062 this->z = Output(ret, 0);
1063}
1064
1065Greater::Greater(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
1066 ::tensorflow::Input y) {
1067 if (!scope.ok()) return;
1068 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1069 if (!scope.ok()) return;
1070 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
1071 if (!scope.ok()) return;
1072 ::tensorflow::Node* ret;
1073 const auto unique_name = scope.GetUniqueNameForOp("Greater");
1074 auto builder = ::tensorflow::NodeBuilder(unique_name, "Greater")
1075 .Input(_x)
1076 .Input(_y)
1077 ;
1078 scope.UpdateBuilder(&builder);
1079 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1080 if (!scope.ok()) return;
1081 scope.UpdateStatus(scope.DoShapeInference(ret));
1082 this->operation = Operation(ret);
1083 this->z = Output(ret, 0);
1084}
1085
1086GreaterEqual::GreaterEqual(const ::tensorflow::Scope& scope,
1087 ::tensorflow::Input x, ::tensorflow::Input y) {
1088 if (!scope.ok()) return;
1089 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1090 if (!scope.ok()) return;
1091 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
1092 if (!scope.ok()) return;
1093 ::tensorflow::Node* ret;
1094 const auto unique_name = scope.GetUniqueNameForOp("GreaterEqual");
1095 auto builder = ::tensorflow::NodeBuilder(unique_name, "GreaterEqual")
1096 .Input(_x)
1097 .Input(_y)
1098 ;
1099 scope.UpdateBuilder(&builder);
1100 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1101 if (!scope.ok()) return;
1102 scope.UpdateStatus(scope.DoShapeInference(ret));
1103 this->operation = Operation(ret);
1104 this->z = Output(ret, 0);
1105}
1106
1107HistogramFixedWidth::HistogramFixedWidth(const ::tensorflow::Scope& scope,
1108 ::tensorflow::Input values,
1109 ::tensorflow::Input value_range,
1110 ::tensorflow::Input nbins, const
1111 HistogramFixedWidth::Attrs& attrs) {
1112 if (!scope.ok()) return;
1113 auto _values = ::tensorflow::ops::AsNodeOut(scope, values);
1114 if (!scope.ok()) return;
1115 auto _value_range = ::tensorflow::ops::AsNodeOut(scope, value_range);
1116 if (!scope.ok()) return;
1117 auto _nbins = ::tensorflow::ops::AsNodeOut(scope, nbins);
1118 if (!scope.ok()) return;
1119 ::tensorflow::Node* ret;
1120 const auto unique_name = scope.GetUniqueNameForOp("HistogramFixedWidth");
1121 auto builder = ::tensorflow::NodeBuilder(unique_name, "HistogramFixedWidth")
1122 .Input(_values)
1123 .Input(_value_range)
1124 .Input(_nbins)
1125 .Attr("dtype", attrs.dtype_)
1126 ;
1127 scope.UpdateBuilder(&builder);
1128 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1129 if (!scope.ok()) return;
1130 scope.UpdateStatus(scope.DoShapeInference(ret));
1131 this->operation = Operation(ret);
1132 this->out = Output(ret, 0);
1133}
1134
1135HistogramFixedWidth::HistogramFixedWidth(const ::tensorflow::Scope& scope,
1136 ::tensorflow::Input values,
1137 ::tensorflow::Input value_range,
1138 ::tensorflow::Input nbins)
1139 : HistogramFixedWidth(scope, values, value_range, nbins, HistogramFixedWidth::Attrs()) {}
1140
1141Igamma::Igamma(const ::tensorflow::Scope& scope, ::tensorflow::Input a,
1142 ::tensorflow::Input x) {
1143 if (!scope.ok()) return;
1144 auto _a = ::tensorflow::ops::AsNodeOut(scope, a);
1145 if (!scope.ok()) return;
1146 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1147 if (!scope.ok()) return;
1148 ::tensorflow::Node* ret;
1149 const auto unique_name = scope.GetUniqueNameForOp("Igamma");
1150 auto builder = ::tensorflow::NodeBuilder(unique_name, "Igamma")
1151 .Input(_a)
1152 .Input(_x)
1153 ;
1154 scope.UpdateBuilder(&builder);
1155 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1156 if (!scope.ok()) return;
1157 scope.UpdateStatus(scope.DoShapeInference(ret));
1158 this->operation = Operation(ret);
1159 this->z = Output(ret, 0);
1160}
1161
1162Igammac::Igammac(const ::tensorflow::Scope& scope, ::tensorflow::Input a,
1163 ::tensorflow::Input x) {
1164 if (!scope.ok()) return;
1165 auto _a = ::tensorflow::ops::AsNodeOut(scope, a);
1166 if (!scope.ok()) return;
1167 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1168 if (!scope.ok()) return;
1169 ::tensorflow::Node* ret;
1170 const auto unique_name = scope.GetUniqueNameForOp("Igammac");
1171 auto builder = ::tensorflow::NodeBuilder(unique_name, "Igammac")
1172 .Input(_a)
1173 .Input(_x)
1174 ;
1175 scope.UpdateBuilder(&builder);
1176 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1177 if (!scope.ok()) return;
1178 scope.UpdateStatus(scope.DoShapeInference(ret));
1179 this->operation = Operation(ret);
1180 this->z = Output(ret, 0);
1181}
1182
1183Imag::Imag(const ::tensorflow::Scope& scope, ::tensorflow::Input input, const
1184 Imag::Attrs& attrs) {
1185 if (!scope.ok()) return;
1186 auto _input = ::tensorflow::ops::AsNodeOut(scope, input);
1187 if (!scope.ok()) return;
1188 ::tensorflow::Node* ret;
1189 const auto unique_name = scope.GetUniqueNameForOp("Imag");
1190 auto builder = ::tensorflow::NodeBuilder(unique_name, "Imag")
1191 .Input(_input)
1192 .Attr("Tout", attrs.Tout_)
1193 ;
1194 scope.UpdateBuilder(&builder);
1195 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1196 if (!scope.ok()) return;
1197 scope.UpdateStatus(scope.DoShapeInference(ret));
1198 this->operation = Operation(ret);
1199 this->output = Output(ret, 0);
1200}
1201
1202Imag::Imag(const ::tensorflow::Scope& scope, ::tensorflow::Input input)
1203 : Imag(scope, input, Imag::Attrs()) {}
1204
1205Inv::Inv(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
1206 if (!scope.ok()) return;
1207 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1208 if (!scope.ok()) return;
1209 ::tensorflow::Node* ret;
1210 const auto unique_name = scope.GetUniqueNameForOp("Inv");
1211 auto builder = ::tensorflow::NodeBuilder(unique_name, "Inv")
1212 .Input(_x)
1213 ;
1214 scope.UpdateBuilder(&builder);
1215 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1216 if (!scope.ok()) return;
1217 scope.UpdateStatus(scope.DoShapeInference(ret));
1218 this->operation = Operation(ret);
1219 this->y = Output(ret, 0);
1220}
1221
1222IsFinite::IsFinite(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
1223 if (!scope.ok()) return;
1224 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1225 if (!scope.ok()) return;
1226 ::tensorflow::Node* ret;
1227 const auto unique_name = scope.GetUniqueNameForOp("IsFinite");
1228 auto builder = ::tensorflow::NodeBuilder(unique_name, "IsFinite")
1229 .Input(_x)
1230 ;
1231 scope.UpdateBuilder(&builder);
1232 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1233 if (!scope.ok()) return;
1234 scope.UpdateStatus(scope.DoShapeInference(ret));
1235 this->operation = Operation(ret);
1236 this->y = Output(ret, 0);
1237}
1238
1239IsInf::IsInf(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
1240 if (!scope.ok()) return;
1241 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1242 if (!scope.ok()) return;
1243 ::tensorflow::Node* ret;
1244 const auto unique_name = scope.GetUniqueNameForOp("IsInf");
1245 auto builder = ::tensorflow::NodeBuilder(unique_name, "IsInf")
1246 .Input(_x)
1247 ;
1248 scope.UpdateBuilder(&builder);
1249 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1250 if (!scope.ok()) return;
1251 scope.UpdateStatus(scope.DoShapeInference(ret));
1252 this->operation = Operation(ret);
1253 this->y = Output(ret, 0);
1254}
1255
1256IsNan::IsNan(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
1257 if (!scope.ok()) return;
1258 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1259 if (!scope.ok()) return;
1260 ::tensorflow::Node* ret;
1261 const auto unique_name = scope.GetUniqueNameForOp("IsNan");
1262 auto builder = ::tensorflow::NodeBuilder(unique_name, "IsNan")
1263 .Input(_x)
1264 ;
1265 scope.UpdateBuilder(&builder);
1266 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1267 if (!scope.ok()) return;
1268 scope.UpdateStatus(scope.DoShapeInference(ret));
1269 this->operation = Operation(ret);
1270 this->y = Output(ret, 0);
1271}
1272
1273Less::Less(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
1274 ::tensorflow::Input y) {
1275 if (!scope.ok()) return;
1276 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1277 if (!scope.ok()) return;
1278 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
1279 if (!scope.ok()) return;
1280 ::tensorflow::Node* ret;
1281 const auto unique_name = scope.GetUniqueNameForOp("Less");
1282 auto builder = ::tensorflow::NodeBuilder(unique_name, "Less")
1283 .Input(_x)
1284 .Input(_y)
1285 ;
1286 scope.UpdateBuilder(&builder);
1287 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1288 if (!scope.ok()) return;
1289 scope.UpdateStatus(scope.DoShapeInference(ret));
1290 this->operation = Operation(ret);
1291 this->z = Output(ret, 0);
1292}
1293
1294LessEqual::LessEqual(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
1295 ::tensorflow::Input y) {
1296 if (!scope.ok()) return;
1297 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1298 if (!scope.ok()) return;
1299 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
1300 if (!scope.ok()) return;
1301 ::tensorflow::Node* ret;
1302 const auto unique_name = scope.GetUniqueNameForOp("LessEqual");
1303 auto builder = ::tensorflow::NodeBuilder(unique_name, "LessEqual")
1304 .Input(_x)
1305 .Input(_y)
1306 ;
1307 scope.UpdateBuilder(&builder);
1308 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1309 if (!scope.ok()) return;
1310 scope.UpdateStatus(scope.DoShapeInference(ret));
1311 this->operation = Operation(ret);
1312 this->z = Output(ret, 0);
1313}
1314
1315Lgamma::Lgamma(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
1316 if (!scope.ok()) return;
1317 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1318 if (!scope.ok()) return;
1319 ::tensorflow::Node* ret;
1320 const auto unique_name = scope.GetUniqueNameForOp("Lgamma");
1321 auto builder = ::tensorflow::NodeBuilder(unique_name, "Lgamma")
1322 .Input(_x)
1323 ;
1324 scope.UpdateBuilder(&builder);
1325 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1326 if (!scope.ok()) return;
1327 scope.UpdateStatus(scope.DoShapeInference(ret));
1328 this->operation = Operation(ret);
1329 this->y = Output(ret, 0);
1330}
1331
1332Log::Log(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
1333 if (!scope.ok()) return;
1334 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1335 if (!scope.ok()) return;
1336 ::tensorflow::Node* ret;
1337 const auto unique_name = scope.GetUniqueNameForOp("Log");
1338 auto builder = ::tensorflow::NodeBuilder(unique_name, "Log")
1339 .Input(_x)
1340 ;
1341 scope.UpdateBuilder(&builder);
1342 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1343 if (!scope.ok()) return;
1344 scope.UpdateStatus(scope.DoShapeInference(ret));
1345 this->operation = Operation(ret);
1346 this->y = Output(ret, 0);
1347}
1348
1349Log1p::Log1p(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
1350 if (!scope.ok()) return;
1351 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1352 if (!scope.ok()) return;
1353 ::tensorflow::Node* ret;
1354 const auto unique_name = scope.GetUniqueNameForOp("Log1p");
1355 auto builder = ::tensorflow::NodeBuilder(unique_name, "Log1p")
1356 .Input(_x)
1357 ;
1358 scope.UpdateBuilder(&builder);
1359 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1360 if (!scope.ok()) return;
1361 scope.UpdateStatus(scope.DoShapeInference(ret));
1362 this->operation = Operation(ret);
1363 this->y = Output(ret, 0);
1364}
1365
1366LogicalAnd::LogicalAnd(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
1367 ::tensorflow::Input y) {
1368 if (!scope.ok()) return;
1369 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1370 if (!scope.ok()) return;
1371 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
1372 if (!scope.ok()) return;
1373 ::tensorflow::Node* ret;
1374 const auto unique_name = scope.GetUniqueNameForOp("LogicalAnd");
1375 auto builder = ::tensorflow::NodeBuilder(unique_name, "LogicalAnd")
1376 .Input(_x)
1377 .Input(_y)
1378 ;
1379 scope.UpdateBuilder(&builder);
1380 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1381 if (!scope.ok()) return;
1382 scope.UpdateStatus(scope.DoShapeInference(ret));
1383 this->operation = Operation(ret);
1384 this->z = Output(ret, 0);
1385}
1386
1387LogicalNot::LogicalNot(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
1388 if (!scope.ok()) return;
1389 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1390 if (!scope.ok()) return;
1391 ::tensorflow::Node* ret;
1392 const auto unique_name = scope.GetUniqueNameForOp("LogicalNot");
1393 auto builder = ::tensorflow::NodeBuilder(unique_name, "LogicalNot")
1394 .Input(_x)
1395 ;
1396 scope.UpdateBuilder(&builder);
1397 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1398 if (!scope.ok()) return;
1399 scope.UpdateStatus(scope.DoShapeInference(ret));
1400 this->operation = Operation(ret);
1401 this->y = Output(ret, 0);
1402}
1403
1404LogicalOr::LogicalOr(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
1405 ::tensorflow::Input y) {
1406 if (!scope.ok()) return;
1407 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1408 if (!scope.ok()) return;
1409 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
1410 if (!scope.ok()) return;
1411 ::tensorflow::Node* ret;
1412 const auto unique_name = scope.GetUniqueNameForOp("LogicalOr");
1413 auto builder = ::tensorflow::NodeBuilder(unique_name, "LogicalOr")
1414 .Input(_x)
1415 .Input(_y)
1416 ;
1417 scope.UpdateBuilder(&builder);
1418 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1419 if (!scope.ok()) return;
1420 scope.UpdateStatus(scope.DoShapeInference(ret));
1421 this->operation = Operation(ret);
1422 this->z = Output(ret, 0);
1423}
1424
1425MatMul::MatMul(const ::tensorflow::Scope& scope, ::tensorflow::Input a,
1426 ::tensorflow::Input b, const MatMul::Attrs& attrs) {
1427 if (!scope.ok()) return;
1428 auto _a = ::tensorflow::ops::AsNodeOut(scope, a);
1429 if (!scope.ok()) return;
1430 auto _b = ::tensorflow::ops::AsNodeOut(scope, b);
1431 if (!scope.ok()) return;
1432 ::tensorflow::Node* ret;
1433 const auto unique_name = scope.GetUniqueNameForOp("MatMul");
1434 auto builder = ::tensorflow::NodeBuilder(unique_name, "MatMul")
1435 .Input(_a)
1436 .Input(_b)
1437 .Attr("transpose_a", attrs.transpose_a_)
1438 .Attr("transpose_b", attrs.transpose_b_)
1439 ;
1440 scope.UpdateBuilder(&builder);
1441 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1442 if (!scope.ok()) return;
1443 scope.UpdateStatus(scope.DoShapeInference(ret));
1444 this->operation = Operation(ret);
1445 this->product = Output(ret, 0);
1446}
1447
1448MatMul::MatMul(const ::tensorflow::Scope& scope, ::tensorflow::Input a,
1449 ::tensorflow::Input b)
1450 : MatMul(scope, a, b, MatMul::Attrs()) {}
1451
1452Max::Max(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
1453 ::tensorflow::Input axis, const Max::Attrs& attrs) {
1454 if (!scope.ok()) return;
1455 auto _input = ::tensorflow::ops::AsNodeOut(scope, input);
1456 if (!scope.ok()) return;
1457 auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis);
1458 if (!scope.ok()) return;
1459 ::tensorflow::Node* ret;
1460 const auto unique_name = scope.GetUniqueNameForOp("Max");
1461 auto builder = ::tensorflow::NodeBuilder(unique_name, "Max")
1462 .Input(_input)
1463 .Input(_axis)
1464 .Attr("keep_dims", attrs.keep_dims_)
1465 ;
1466 scope.UpdateBuilder(&builder);
1467 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1468 if (!scope.ok()) return;
1469 scope.UpdateStatus(scope.DoShapeInference(ret));
1470 this->operation = Operation(ret);
1471 this->output = Output(ret, 0);
1472}
1473
1474Max::Max(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
1475 ::tensorflow::Input axis)
1476 : Max(scope, input, axis, Max::Attrs()) {}
1477
1478Maximum::Maximum(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
1479 ::tensorflow::Input y) {
1480 if (!scope.ok()) return;
1481 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1482 if (!scope.ok()) return;
1483 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
1484 if (!scope.ok()) return;
1485 ::tensorflow::Node* ret;
1486 const auto unique_name = scope.GetUniqueNameForOp("Maximum");
1487 auto builder = ::tensorflow::NodeBuilder(unique_name, "Maximum")
1488 .Input(_x)
1489 .Input(_y)
1490 ;
1491 scope.UpdateBuilder(&builder);
1492 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1493 if (!scope.ok()) return;
1494 scope.UpdateStatus(scope.DoShapeInference(ret));
1495 this->operation = Operation(ret);
1496 this->z = Output(ret, 0);
1497}
1498
1499Mean::Mean(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
1500 ::tensorflow::Input axis, const Mean::Attrs& attrs) {
1501 if (!scope.ok()) return;
1502 auto _input = ::tensorflow::ops::AsNodeOut(scope, input);
1503 if (!scope.ok()) return;
1504 auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis);
1505 if (!scope.ok()) return;
1506 ::tensorflow::Node* ret;
1507 const auto unique_name = scope.GetUniqueNameForOp("Mean");
1508 auto builder = ::tensorflow::NodeBuilder(unique_name, "Mean")
1509 .Input(_input)
1510 .Input(_axis)
1511 .Attr("keep_dims", attrs.keep_dims_)
1512 ;
1513 scope.UpdateBuilder(&builder);
1514 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1515 if (!scope.ok()) return;
1516 scope.UpdateStatus(scope.DoShapeInference(ret));
1517 this->operation = Operation(ret);
1518 this->output = Output(ret, 0);
1519}
1520
1521Mean::Mean(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
1522 ::tensorflow::Input axis)
1523 : Mean(scope, input, axis, Mean::Attrs()) {}
1524
1525Min::Min(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
1526 ::tensorflow::Input axis, const Min::Attrs& attrs) {
1527 if (!scope.ok()) return;
1528 auto _input = ::tensorflow::ops::AsNodeOut(scope, input);
1529 if (!scope.ok()) return;
1530 auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis);
1531 if (!scope.ok()) return;
1532 ::tensorflow::Node* ret;
1533 const auto unique_name = scope.GetUniqueNameForOp("Min");
1534 auto builder = ::tensorflow::NodeBuilder(unique_name, "Min")
1535 .Input(_input)
1536 .Input(_axis)
1537 .Attr("keep_dims", attrs.keep_dims_)
1538 ;
1539 scope.UpdateBuilder(&builder);
1540 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1541 if (!scope.ok()) return;
1542 scope.UpdateStatus(scope.DoShapeInference(ret));
1543 this->operation = Operation(ret);
1544 this->output = Output(ret, 0);
1545}
1546
1547Min::Min(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
1548 ::tensorflow::Input axis)
1549 : Min(scope, input, axis, Min::Attrs()) {}
1550
1551Minimum::Minimum(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
1552 ::tensorflow::Input y) {
1553 if (!scope.ok()) return;
1554 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1555 if (!scope.ok()) return;
1556 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
1557 if (!scope.ok()) return;
1558 ::tensorflow::Node* ret;
1559 const auto unique_name = scope.GetUniqueNameForOp("Minimum");
1560 auto builder = ::tensorflow::NodeBuilder(unique_name, "Minimum")
1561 .Input(_x)
1562 .Input(_y)
1563 ;
1564 scope.UpdateBuilder(&builder);
1565 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1566 if (!scope.ok()) return;
1567 scope.UpdateStatus(scope.DoShapeInference(ret));
1568 this->operation = Operation(ret);
1569 this->z = Output(ret, 0);
1570}
1571
1572Mod::Mod(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
1573 ::tensorflow::Input y) {
1574 if (!scope.ok()) return;
1575 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1576 if (!scope.ok()) return;
1577 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
1578 if (!scope.ok()) return;
1579 ::tensorflow::Node* ret;
1580 const auto unique_name = scope.GetUniqueNameForOp("Mod");
1581 auto builder = ::tensorflow::NodeBuilder(unique_name, "Mod")
1582 .Input(_x)
1583 .Input(_y)
1584 ;
1585 scope.UpdateBuilder(&builder);
1586 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1587 if (!scope.ok()) return;
1588 scope.UpdateStatus(scope.DoShapeInference(ret));
1589 this->operation = Operation(ret);
1590 this->z = Output(ret, 0);
1591}
1592
1593Multiply::Multiply(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
1594 ::tensorflow::Input y) {
1595 if (!scope.ok()) return;
1596 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1597 if (!scope.ok()) return;
1598 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
1599 if (!scope.ok()) return;
1600 ::tensorflow::Node* ret;
1601 const auto unique_name = scope.GetUniqueNameForOp("Multiply");
1602 auto builder = ::tensorflow::NodeBuilder(unique_name, "Mul")
1603 .Input(_x)
1604 .Input(_y)
1605 ;
1606 scope.UpdateBuilder(&builder);
1607 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1608 if (!scope.ok()) return;
1609 scope.UpdateStatus(scope.DoShapeInference(ret));
1610 this->operation = Operation(ret);
1611 this->z = Output(ret, 0);
1612}
1613
1614MulNoNan::MulNoNan(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
1615 ::tensorflow::Input y) {
1616 if (!scope.ok()) return;
1617 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1618 if (!scope.ok()) return;
1619 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
1620 if (!scope.ok()) return;
1621 ::tensorflow::Node* ret;
1622 const auto unique_name = scope.GetUniqueNameForOp("MulNoNan");
1623 auto builder = ::tensorflow::NodeBuilder(unique_name, "MulNoNan")
1624 .Input(_x)
1625 .Input(_y)
1626 ;
1627 scope.UpdateBuilder(&builder);
1628 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1629 if (!scope.ok()) return;
1630 scope.UpdateStatus(scope.DoShapeInference(ret));
1631 this->operation = Operation(ret);
1632 this->z = Output(ret, 0);
1633}
1634
1635Ndtri::Ndtri(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
1636 if (!scope.ok()) return;
1637 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1638 if (!scope.ok()) return;
1639 ::tensorflow::Node* ret;
1640 const auto unique_name = scope.GetUniqueNameForOp("Ndtri");
1641 auto builder = ::tensorflow::NodeBuilder(unique_name, "Ndtri")
1642 .Input(_x)
1643 ;
1644 scope.UpdateBuilder(&builder);
1645 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1646 if (!scope.ok()) return;
1647 scope.UpdateStatus(scope.DoShapeInference(ret));
1648 this->operation = Operation(ret);
1649 this->y = Output(ret, 0);
1650}
1651
1652Negate::Negate(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
1653 if (!scope.ok()) return;
1654 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1655 if (!scope.ok()) return;
1656 ::tensorflow::Node* ret;
1657 const auto unique_name = scope.GetUniqueNameForOp("Negate");
1658 auto builder = ::tensorflow::NodeBuilder(unique_name, "Neg")
1659 .Input(_x)
1660 ;
1661 scope.UpdateBuilder(&builder);
1662 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1663 if (!scope.ok()) return;
1664 scope.UpdateStatus(scope.DoShapeInference(ret));
1665 this->operation = Operation(ret);
1666 this->y = Output(ret, 0);
1667}
1668
1669NextAfter::NextAfter(const ::tensorflow::Scope& scope, ::tensorflow::Input x1,
1670 ::tensorflow::Input x2) {
1671 if (!scope.ok()) return;
1672 auto _x1 = ::tensorflow::ops::AsNodeOut(scope, x1);
1673 if (!scope.ok()) return;
1674 auto _x2 = ::tensorflow::ops::AsNodeOut(scope, x2);
1675 if (!scope.ok()) return;
1676 ::tensorflow::Node* ret;
1677 const auto unique_name = scope.GetUniqueNameForOp("NextAfter");
1678 auto builder = ::tensorflow::NodeBuilder(unique_name, "NextAfter")
1679 .Input(_x1)
1680 .Input(_x2)
1681 ;
1682 scope.UpdateBuilder(&builder);
1683 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1684 if (!scope.ok()) return;
1685 scope.UpdateStatus(scope.DoShapeInference(ret));
1686 this->operation = Operation(ret);
1687 this->output = Output(ret, 0);
1688}
1689
1690NotEqual::NotEqual(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
1691 ::tensorflow::Input y, const NotEqual::Attrs& attrs) {
1692 if (!scope.ok()) return;
1693 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1694 if (!scope.ok()) return;
1695 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
1696 if (!scope.ok()) return;
1697 ::tensorflow::Node* ret;
1698 const auto unique_name = scope.GetUniqueNameForOp("NotEqual");
1699 auto builder = ::tensorflow::NodeBuilder(unique_name, "NotEqual")
1700 .Input(_x)
1701 .Input(_y)
1702 .Attr("incompatible_shape_error", attrs.incompatible_shape_error_)
1703 ;
1704 scope.UpdateBuilder(&builder);
1705 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1706 if (!scope.ok()) return;
1707 scope.UpdateStatus(scope.DoShapeInference(ret));
1708 this->operation = Operation(ret);
1709 this->z = Output(ret, 0);
1710}
1711
1712NotEqual::NotEqual(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
1713 ::tensorflow::Input y)
1714 : NotEqual(scope, x, y, NotEqual::Attrs()) {}
1715
1716Polygamma::Polygamma(const ::tensorflow::Scope& scope, ::tensorflow::Input a,
1717 ::tensorflow::Input x) {
1718 if (!scope.ok()) return;
1719 auto _a = ::tensorflow::ops::AsNodeOut(scope, a);
1720 if (!scope.ok()) return;
1721 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1722 if (!scope.ok()) return;
1723 ::tensorflow::Node* ret;
1724 const auto unique_name = scope.GetUniqueNameForOp("Polygamma");
1725 auto builder = ::tensorflow::NodeBuilder(unique_name, "Polygamma")
1726 .Input(_a)
1727 .Input(_x)
1728 ;
1729 scope.UpdateBuilder(&builder);
1730 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1731 if (!scope.ok()) return;
1732 scope.UpdateStatus(scope.DoShapeInference(ret));
1733 this->operation = Operation(ret);
1734 this->z = Output(ret, 0);
1735}
1736
1737Pow::Pow(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
1738 ::tensorflow::Input y) {
1739 if (!scope.ok()) return;
1740 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1741 if (!scope.ok()) return;
1742 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
1743 if (!scope.ok()) return;
1744 ::tensorflow::Node* ret;
1745 const auto unique_name = scope.GetUniqueNameForOp("Pow");
1746 auto builder = ::tensorflow::NodeBuilder(unique_name, "Pow")
1747 .Input(_x)
1748 .Input(_y)
1749 ;
1750 scope.UpdateBuilder(&builder);
1751 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1752 if (!scope.ok()) return;
1753 scope.UpdateStatus(scope.DoShapeInference(ret));
1754 this->operation = Operation(ret);
1755 this->z = Output(ret, 0);
1756}
1757
1758Prod::Prod(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
1759 ::tensorflow::Input axis, const Prod::Attrs& attrs) {
1760 if (!scope.ok()) return;
1761 auto _input = ::tensorflow::ops::AsNodeOut(scope, input);
1762 if (!scope.ok()) return;
1763 auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis);
1764 if (!scope.ok()) return;
1765 ::tensorflow::Node* ret;
1766 const auto unique_name = scope.GetUniqueNameForOp("Prod");
1767 auto builder = ::tensorflow::NodeBuilder(unique_name, "Prod")
1768 .Input(_input)
1769 .Input(_axis)
1770 .Attr("keep_dims", attrs.keep_dims_)
1771 ;
1772 scope.UpdateBuilder(&builder);
1773 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1774 if (!scope.ok()) return;
1775 scope.UpdateStatus(scope.DoShapeInference(ret));
1776 this->operation = Operation(ret);
1777 this->output = Output(ret, 0);
1778}
1779
1780Prod::Prod(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
1781 ::tensorflow::Input axis)
1782 : Prod(scope, input, axis, Prod::Attrs()) {}
1783
1784QuantizeDownAndShrinkRange::QuantizeDownAndShrinkRange(const
1785 ::tensorflow::Scope&
1786 scope,
1787 ::tensorflow::Input
1788 input,
1789 ::tensorflow::Input
1790 input_min,
1791 ::tensorflow::Input
1792 input_max, DataType
1793 out_type) {
1794 if (!scope.ok()) return;
1795 auto _input = ::tensorflow::ops::AsNodeOut(scope, input);
1796 if (!scope.ok()) return;
1797 auto _input_min = ::tensorflow::ops::AsNodeOut(scope, input_min);
1798 if (!scope.ok()) return;
1799 auto _input_max = ::tensorflow::ops::AsNodeOut(scope, input_max);
1800 if (!scope.ok()) return;
1801 ::tensorflow::Node* ret;
1802 const auto unique_name = scope.GetUniqueNameForOp("QuantizeDownAndShrinkRange");
1803 auto builder = ::tensorflow::NodeBuilder(unique_name, "QuantizeDownAndShrinkRange")
1804 .Input(_input)
1805 .Input(_input_min)
1806 .Input(_input_max)
1807 .Attr("out_type", out_type)
1808 ;
1809 scope.UpdateBuilder(&builder);
1810 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1811 if (!scope.ok()) return;
1812 scope.UpdateStatus(scope.DoShapeInference(ret));
1813 this->operation = Operation(ret);
1814 ::tensorflow::NameRangeMap _outputs_range;
1815 ::tensorflow::Status _status_ = ::tensorflow::NameRangesForNode(*ret, ret->op_def(), nullptr, &_outputs_range);
1816 if (!_status_.ok()) {
1817 scope.UpdateStatus(_status_);
1818 return;
1819 }
1820
1821 this->output = Output(ret, _outputs_range["output"].first);
1822 this->output_min = Output(ret, _outputs_range["output_min"].first);
1823 this->output_max = Output(ret, _outputs_range["output_max"].first);
1824}
1825
1826QuantizedAdd::QuantizedAdd(const ::tensorflow::Scope& scope,
1827 ::tensorflow::Input x, ::tensorflow::Input y,
1828 ::tensorflow::Input min_x, ::tensorflow::Input
1829 max_x, ::tensorflow::Input min_y,
1830 ::tensorflow::Input max_y, const
1831 QuantizedAdd::Attrs& attrs) {
1832 if (!scope.ok()) return;
1833 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1834 if (!scope.ok()) return;
1835 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
1836 if (!scope.ok()) return;
1837 auto _min_x = ::tensorflow::ops::AsNodeOut(scope, min_x);
1838 if (!scope.ok()) return;
1839 auto _max_x = ::tensorflow::ops::AsNodeOut(scope, max_x);
1840 if (!scope.ok()) return;
1841 auto _min_y = ::tensorflow::ops::AsNodeOut(scope, min_y);
1842 if (!scope.ok()) return;
1843 auto _max_y = ::tensorflow::ops::AsNodeOut(scope, max_y);
1844 if (!scope.ok()) return;
1845 ::tensorflow::Node* ret;
1846 const auto unique_name = scope.GetUniqueNameForOp("QuantizedAdd");
1847 auto builder = ::tensorflow::NodeBuilder(unique_name, "QuantizedAdd")
1848 .Input(_x)
1849 .Input(_y)
1850 .Input(_min_x)
1851 .Input(_max_x)
1852 .Input(_min_y)
1853 .Input(_max_y)
1854 .Attr("Toutput", attrs.Toutput_)
1855 ;
1856 scope.UpdateBuilder(&builder);
1857 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1858 if (!scope.ok()) return;
1859 scope.UpdateStatus(scope.DoShapeInference(ret));
1860 this->operation = Operation(ret);
1861 ::tensorflow::NameRangeMap _outputs_range;
1862 ::tensorflow::Status _status_ = ::tensorflow::NameRangesForNode(*ret, ret->op_def(), nullptr, &_outputs_range);
1863 if (!_status_.ok()) {
1864 scope.UpdateStatus(_status_);
1865 return;
1866 }
1867
1868 this->z = Output(ret, _outputs_range["z"].first);
1869 this->min_z = Output(ret, _outputs_range["min_z"].first);
1870 this->max_z = Output(ret, _outputs_range["max_z"].first);
1871}
1872
1873QuantizedAdd::QuantizedAdd(const ::tensorflow::Scope& scope,
1874 ::tensorflow::Input x, ::tensorflow::Input y,
1875 ::tensorflow::Input min_x, ::tensorflow::Input
1876 max_x, ::tensorflow::Input min_y,
1877 ::tensorflow::Input max_y)
1878 : QuantizedAdd(scope, x, y, min_x, max_x, min_y, max_y, QuantizedAdd::Attrs()) {}
1879
1880QuantizedMatMul::QuantizedMatMul(const ::tensorflow::Scope& scope,
1881 ::tensorflow::Input a, ::tensorflow::Input b,
1882 ::tensorflow::Input min_a, ::tensorflow::Input
1883 max_a, ::tensorflow::Input min_b,
1884 ::tensorflow::Input max_b, const
1885 QuantizedMatMul::Attrs& attrs) {
1886 if (!scope.ok()) return;
1887 auto _a = ::tensorflow::ops::AsNodeOut(scope, a);
1888 if (!scope.ok()) return;
1889 auto _b = ::tensorflow::ops::AsNodeOut(scope, b);
1890 if (!scope.ok()) return;
1891 auto _min_a = ::tensorflow::ops::AsNodeOut(scope, min_a);
1892 if (!scope.ok()) return;
1893 auto _max_a = ::tensorflow::ops::AsNodeOut(scope, max_a);
1894 if (!scope.ok()) return;
1895 auto _min_b = ::tensorflow::ops::AsNodeOut(scope, min_b);
1896 if (!scope.ok()) return;
1897 auto _max_b = ::tensorflow::ops::AsNodeOut(scope, max_b);
1898 if (!scope.ok()) return;
1899 ::tensorflow::Node* ret;
1900 const auto unique_name = scope.GetUniqueNameForOp("QuantizedMatMul");
1901 auto builder = ::tensorflow::NodeBuilder(unique_name, "QuantizedMatMul")
1902 .Input(_a)
1903 .Input(_b)
1904 .Input(_min_a)
1905 .Input(_max_a)
1906 .Input(_min_b)
1907 .Input(_max_b)
1908 .Attr("Toutput", attrs.Toutput_)
1909 .Attr("transpose_a", attrs.transpose_a_)
1910 .Attr("transpose_b", attrs.transpose_b_)
1911 .Attr("Tactivation", attrs.Tactivation_)
1912 ;
1913 scope.UpdateBuilder(&builder);
1914 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1915 if (!scope.ok()) return;
1916 scope.UpdateStatus(scope.DoShapeInference(ret));
1917 this->operation = Operation(ret);
1918 ::tensorflow::NameRangeMap _outputs_range;
1919 ::tensorflow::Status _status_ = ::tensorflow::NameRangesForNode(*ret, ret->op_def(), nullptr, &_outputs_range);
1920 if (!_status_.ok()) {
1921 scope.UpdateStatus(_status_);
1922 return;
1923 }
1924
1925 this->out = Output(ret, _outputs_range["out"].first);
1926 this->min_out = Output(ret, _outputs_range["min_out"].first);
1927 this->max_out = Output(ret, _outputs_range["max_out"].first);
1928}
1929
1930QuantizedMatMul::QuantizedMatMul(const ::tensorflow::Scope& scope,
1931 ::tensorflow::Input a, ::tensorflow::Input b,
1932 ::tensorflow::Input min_a, ::tensorflow::Input
1933 max_a, ::tensorflow::Input min_b,
1934 ::tensorflow::Input max_b)
1935 : QuantizedMatMul(scope, a, b, min_a, max_a, min_b, max_b, QuantizedMatMul::Attrs()) {}
1936
1937QuantizedMul::QuantizedMul(const ::tensorflow::Scope& scope,
1938 ::tensorflow::Input x, ::tensorflow::Input y,
1939 ::tensorflow::Input min_x, ::tensorflow::Input
1940 max_x, ::tensorflow::Input min_y,
1941 ::tensorflow::Input max_y, const
1942 QuantizedMul::Attrs& attrs) {
1943 if (!scope.ok()) return;
1944 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
1945 if (!scope.ok()) return;
1946 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
1947 if (!scope.ok()) return;
1948 auto _min_x = ::tensorflow::ops::AsNodeOut(scope, min_x);
1949 if (!scope.ok()) return;
1950 auto _max_x = ::tensorflow::ops::AsNodeOut(scope, max_x);
1951 if (!scope.ok()) return;
1952 auto _min_y = ::tensorflow::ops::AsNodeOut(scope, min_y);
1953 if (!scope.ok()) return;
1954 auto _max_y = ::tensorflow::ops::AsNodeOut(scope, max_y);
1955 if (!scope.ok()) return;
1956 ::tensorflow::Node* ret;
1957 const auto unique_name = scope.GetUniqueNameForOp("QuantizedMul");
1958 auto builder = ::tensorflow::NodeBuilder(unique_name, "QuantizedMul")
1959 .Input(_x)
1960 .Input(_y)
1961 .Input(_min_x)
1962 .Input(_max_x)
1963 .Input(_min_y)
1964 .Input(_max_y)
1965 .Attr("Toutput", attrs.Toutput_)
1966 ;
1967 scope.UpdateBuilder(&builder);
1968 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
1969 if (!scope.ok()) return;
1970 scope.UpdateStatus(scope.DoShapeInference(ret));
1971 this->operation = Operation(ret);
1972 ::tensorflow::NameRangeMap _outputs_range;
1973 ::tensorflow::Status _status_ = ::tensorflow::NameRangesForNode(*ret, ret->op_def(), nullptr, &_outputs_range);
1974 if (!_status_.ok()) {
1975 scope.UpdateStatus(_status_);
1976 return;
1977 }
1978
1979 this->z = Output(ret, _outputs_range["z"].first);
1980 this->min_z = Output(ret, _outputs_range["min_z"].first);
1981 this->max_z = Output(ret, _outputs_range["max_z"].first);
1982}
1983
1984QuantizedMul::QuantizedMul(const ::tensorflow::Scope& scope,
1985 ::tensorflow::Input x, ::tensorflow::Input y,
1986 ::tensorflow::Input min_x, ::tensorflow::Input
1987 max_x, ::tensorflow::Input min_y,
1988 ::tensorflow::Input max_y)
1989 : QuantizedMul(scope, x, y, min_x, max_x, min_y, max_y, QuantizedMul::Attrs()) {}
1990
1991RaggedBincount::RaggedBincount(const ::tensorflow::Scope& scope,
1992 ::tensorflow::Input splits, ::tensorflow::Input
1993 values, ::tensorflow::Input size,
1994 ::tensorflow::Input weights, const
1995 RaggedBincount::Attrs& attrs) {
1996 if (!scope.ok()) return;
1997 auto _splits = ::tensorflow::ops::AsNodeOut(scope, splits);
1998 if (!scope.ok()) return;
1999 auto _values = ::tensorflow::ops::AsNodeOut(scope, values);
2000 if (!scope.ok()) return;
2001 auto _size = ::tensorflow::ops::AsNodeOut(scope, size);
2002 if (!scope.ok()) return;
2003 auto _weights = ::tensorflow::ops::AsNodeOut(scope, weights);
2004 if (!scope.ok()) return;
2005 ::tensorflow::Node* ret;
2006 const auto unique_name = scope.GetUniqueNameForOp("RaggedBincount");
2007 auto builder = ::tensorflow::NodeBuilder(unique_name, "RaggedBincount")
2008 .Input(_splits)
2009 .Input(_values)
2010 .Input(_size)
2011 .Input(_weights)
2012 .Attr("binary_output", attrs.binary_output_)
2013 ;
2014 scope.UpdateBuilder(&builder);
2015 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2016 if (!scope.ok()) return;
2017 scope.UpdateStatus(scope.DoShapeInference(ret));
2018 this->operation = Operation(ret);
2019 this->output = Output(ret, 0);
2020}
2021
2022RaggedBincount::RaggedBincount(const ::tensorflow::Scope& scope,
2023 ::tensorflow::Input splits, ::tensorflow::Input
2024 values, ::tensorflow::Input size,
2025 ::tensorflow::Input weights)
2026 : RaggedBincount(scope, splits, values, size, weights, RaggedBincount::Attrs()) {}
2027
2028Range::Range(const ::tensorflow::Scope& scope, ::tensorflow::Input start,
2029 ::tensorflow::Input limit, ::tensorflow::Input delta) {
2030 if (!scope.ok()) return;
2031 auto _start = ::tensorflow::ops::AsNodeOut(scope, start);
2032 if (!scope.ok()) return;
2033 auto _limit = ::tensorflow::ops::AsNodeOut(scope, limit);
2034 if (!scope.ok()) return;
2035 auto _delta = ::tensorflow::ops::AsNodeOut(scope, delta);
2036 if (!scope.ok()) return;
2037 ::tensorflow::Node* ret;
2038 const auto unique_name = scope.GetUniqueNameForOp("Range");
2039 auto builder = ::tensorflow::NodeBuilder(unique_name, "Range")
2040 .Input(_start)
2041 .Input(_limit)
2042 .Input(_delta)
2043 ;
2044 scope.UpdateBuilder(&builder);
2045 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2046 if (!scope.ok()) return;
2047 scope.UpdateStatus(scope.DoShapeInference(ret));
2048 this->operation = Operation(ret);
2049 this->output = Output(ret, 0);
2050}
2051
2052Real::Real(const ::tensorflow::Scope& scope, ::tensorflow::Input input, const
2053 Real::Attrs& attrs) {
2054 if (!scope.ok()) return;
2055 auto _input = ::tensorflow::ops::AsNodeOut(scope, input);
2056 if (!scope.ok()) return;
2057 ::tensorflow::Node* ret;
2058 const auto unique_name = scope.GetUniqueNameForOp("Real");
2059 auto builder = ::tensorflow::NodeBuilder(unique_name, "Real")
2060 .Input(_input)
2061 .Attr("Tout", attrs.Tout_)
2062 ;
2063 scope.UpdateBuilder(&builder);
2064 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2065 if (!scope.ok()) return;
2066 scope.UpdateStatus(scope.DoShapeInference(ret));
2067 this->operation = Operation(ret);
2068 this->output = Output(ret, 0);
2069}
2070
2071Real::Real(const ::tensorflow::Scope& scope, ::tensorflow::Input input)
2072 : Real(scope, input, Real::Attrs()) {}
2073
2074RealDiv::RealDiv(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
2075 ::tensorflow::Input y) {
2076 if (!scope.ok()) return;
2077 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
2078 if (!scope.ok()) return;
2079 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
2080 if (!scope.ok()) return;
2081 ::tensorflow::Node* ret;
2082 const auto unique_name = scope.GetUniqueNameForOp("RealDiv");
2083 auto builder = ::tensorflow::NodeBuilder(unique_name, "RealDiv")
2084 .Input(_x)
2085 .Input(_y)
2086 ;
2087 scope.UpdateBuilder(&builder);
2088 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2089 if (!scope.ok()) return;
2090 scope.UpdateStatus(scope.DoShapeInference(ret));
2091 this->operation = Operation(ret);
2092 this->z = Output(ret, 0);
2093}
2094
2095Reciprocal::Reciprocal(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
2096 if (!scope.ok()) return;
2097 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
2098 if (!scope.ok()) return;
2099 ::tensorflow::Node* ret;
2100 const auto unique_name = scope.GetUniqueNameForOp("Reciprocal");
2101 auto builder = ::tensorflow::NodeBuilder(unique_name, "Reciprocal")
2102 .Input(_x)
2103 ;
2104 scope.UpdateBuilder(&builder);
2105 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2106 if (!scope.ok()) return;
2107 scope.UpdateStatus(scope.DoShapeInference(ret));
2108 this->operation = Operation(ret);
2109 this->y = Output(ret, 0);
2110}
2111
2112RequantizationRange::RequantizationRange(const ::tensorflow::Scope& scope,
2113 ::tensorflow::Input input,
2114 ::tensorflow::Input input_min,
2115 ::tensorflow::Input input_max) {
2116 if (!scope.ok()) return;
2117 auto _input = ::tensorflow::ops::AsNodeOut(scope, input);
2118 if (!scope.ok()) return;
2119 auto _input_min = ::tensorflow::ops::AsNodeOut(scope, input_min);
2120 if (!scope.ok()) return;
2121 auto _input_max = ::tensorflow::ops::AsNodeOut(scope, input_max);
2122 if (!scope.ok()) return;
2123 ::tensorflow::Node* ret;
2124 const auto unique_name = scope.GetUniqueNameForOp("RequantizationRange");
2125 auto builder = ::tensorflow::NodeBuilder(unique_name, "RequantizationRange")
2126 .Input(_input)
2127 .Input(_input_min)
2128 .Input(_input_max)
2129 ;
2130 scope.UpdateBuilder(&builder);
2131 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2132 if (!scope.ok()) return;
2133 scope.UpdateStatus(scope.DoShapeInference(ret));
2134 this->operation = Operation(ret);
2135 ::tensorflow::NameRangeMap _outputs_range;
2136 ::tensorflow::Status _status_ = ::tensorflow::NameRangesForNode(*ret, ret->op_def(), nullptr, &_outputs_range);
2137 if (!_status_.ok()) {
2138 scope.UpdateStatus(_status_);
2139 return;
2140 }
2141
2142 this->output_min = Output(ret, _outputs_range["output_min"].first);
2143 this->output_max = Output(ret, _outputs_range["output_max"].first);
2144}
2145
2146Requantize::Requantize(const ::tensorflow::Scope& scope, ::tensorflow::Input
2147 input, ::tensorflow::Input input_min,
2148 ::tensorflow::Input input_max, ::tensorflow::Input
2149 requested_output_min, ::tensorflow::Input
2150 requested_output_max, DataType out_type) {
2151 if (!scope.ok()) return;
2152 auto _input = ::tensorflow::ops::AsNodeOut(scope, input);
2153 if (!scope.ok()) return;
2154 auto _input_min = ::tensorflow::ops::AsNodeOut(scope, input_min);
2155 if (!scope.ok()) return;
2156 auto _input_max = ::tensorflow::ops::AsNodeOut(scope, input_max);
2157 if (!scope.ok()) return;
2158 auto _requested_output_min = ::tensorflow::ops::AsNodeOut(scope, requested_output_min);
2159 if (!scope.ok()) return;
2160 auto _requested_output_max = ::tensorflow::ops::AsNodeOut(scope, requested_output_max);
2161 if (!scope.ok()) return;
2162 ::tensorflow::Node* ret;
2163 const auto unique_name = scope.GetUniqueNameForOp("Requantize");
2164 auto builder = ::tensorflow::NodeBuilder(unique_name, "Requantize")
2165 .Input(_input)
2166 .Input(_input_min)
2167 .Input(_input_max)
2168 .Input(_requested_output_min)
2169 .Input(_requested_output_max)
2170 .Attr("out_type", out_type)
2171 ;
2172 scope.UpdateBuilder(&builder);
2173 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2174 if (!scope.ok()) return;
2175 scope.UpdateStatus(scope.DoShapeInference(ret));
2176 this->operation = Operation(ret);
2177 ::tensorflow::NameRangeMap _outputs_range;
2178 ::tensorflow::Status _status_ = ::tensorflow::NameRangesForNode(*ret, ret->op_def(), nullptr, &_outputs_range);
2179 if (!_status_.ok()) {
2180 scope.UpdateStatus(_status_);
2181 return;
2182 }
2183
2184 this->output = Output(ret, _outputs_range["output"].first);
2185 this->output_min = Output(ret, _outputs_range["output_min"].first);
2186 this->output_max = Output(ret, _outputs_range["output_max"].first);
2187}
2188
2189Rint::Rint(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
2190 if (!scope.ok()) return;
2191 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
2192 if (!scope.ok()) return;
2193 ::tensorflow::Node* ret;
2194 const auto unique_name = scope.GetUniqueNameForOp("Rint");
2195 auto builder = ::tensorflow::NodeBuilder(unique_name, "Rint")
2196 .Input(_x)
2197 ;
2198 scope.UpdateBuilder(&builder);
2199 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2200 if (!scope.ok()) return;
2201 scope.UpdateStatus(scope.DoShapeInference(ret));
2202 this->operation = Operation(ret);
2203 this->y = Output(ret, 0);
2204}
2205
2206Round::Round(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
2207 if (!scope.ok()) return;
2208 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
2209 if (!scope.ok()) return;
2210 ::tensorflow::Node* ret;
2211 const auto unique_name = scope.GetUniqueNameForOp("Round");
2212 auto builder = ::tensorflow::NodeBuilder(unique_name, "Round")
2213 .Input(_x)
2214 ;
2215 scope.UpdateBuilder(&builder);
2216 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2217 if (!scope.ok()) return;
2218 scope.UpdateStatus(scope.DoShapeInference(ret));
2219 this->operation = Operation(ret);
2220 this->y = Output(ret, 0);
2221}
2222
2223Rsqrt::Rsqrt(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
2224 if (!scope.ok()) return;
2225 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
2226 if (!scope.ok()) return;
2227 ::tensorflow::Node* ret;
2228 const auto unique_name = scope.GetUniqueNameForOp("Rsqrt");
2229 auto builder = ::tensorflow::NodeBuilder(unique_name, "Rsqrt")
2230 .Input(_x)
2231 ;
2232 scope.UpdateBuilder(&builder);
2233 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2234 if (!scope.ok()) return;
2235 scope.UpdateStatus(scope.DoShapeInference(ret));
2236 this->operation = Operation(ret);
2237 this->y = Output(ret, 0);
2238}
2239
2240SegmentMax::SegmentMax(const ::tensorflow::Scope& scope, ::tensorflow::Input
2241 data, ::tensorflow::Input segment_ids) {
2242 if (!scope.ok()) return;
2243 auto _data = ::tensorflow::ops::AsNodeOut(scope, data);
2244 if (!scope.ok()) return;
2245 auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids);
2246 if (!scope.ok()) return;
2247 ::tensorflow::Node* ret;
2248 const auto unique_name = scope.GetUniqueNameForOp("SegmentMax");
2249 auto builder = ::tensorflow::NodeBuilder(unique_name, "SegmentMax")
2250 .Input(_data)
2251 .Input(_segment_ids)
2252 ;
2253 scope.UpdateBuilder(&builder);
2254 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2255 if (!scope.ok()) return;
2256 scope.UpdateStatus(scope.DoShapeInference(ret));
2257 this->operation = Operation(ret);
2258 this->output = Output(ret, 0);
2259}
2260
2261SegmentMean::SegmentMean(const ::tensorflow::Scope& scope, ::tensorflow::Input
2262 data, ::tensorflow::Input segment_ids) {
2263 if (!scope.ok()) return;
2264 auto _data = ::tensorflow::ops::AsNodeOut(scope, data);
2265 if (!scope.ok()) return;
2266 auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids);
2267 if (!scope.ok()) return;
2268 ::tensorflow::Node* ret;
2269 const auto unique_name = scope.GetUniqueNameForOp("SegmentMean");
2270 auto builder = ::tensorflow::NodeBuilder(unique_name, "SegmentMean")
2271 .Input(_data)
2272 .Input(_segment_ids)
2273 ;
2274 scope.UpdateBuilder(&builder);
2275 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2276 if (!scope.ok()) return;
2277 scope.UpdateStatus(scope.DoShapeInference(ret));
2278 this->operation = Operation(ret);
2279 this->output = Output(ret, 0);
2280}
2281
2282SegmentMin::SegmentMin(const ::tensorflow::Scope& scope, ::tensorflow::Input
2283 data, ::tensorflow::Input segment_ids) {
2284 if (!scope.ok()) return;
2285 auto _data = ::tensorflow::ops::AsNodeOut(scope, data);
2286 if (!scope.ok()) return;
2287 auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids);
2288 if (!scope.ok()) return;
2289 ::tensorflow::Node* ret;
2290 const auto unique_name = scope.GetUniqueNameForOp("SegmentMin");
2291 auto builder = ::tensorflow::NodeBuilder(unique_name, "SegmentMin")
2292 .Input(_data)
2293 .Input(_segment_ids)
2294 ;
2295 scope.UpdateBuilder(&builder);
2296 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2297 if (!scope.ok()) return;
2298 scope.UpdateStatus(scope.DoShapeInference(ret));
2299 this->operation = Operation(ret);
2300 this->output = Output(ret, 0);
2301}
2302
2303SegmentProd::SegmentProd(const ::tensorflow::Scope& scope, ::tensorflow::Input
2304 data, ::tensorflow::Input segment_ids) {
2305 if (!scope.ok()) return;
2306 auto _data = ::tensorflow::ops::AsNodeOut(scope, data);
2307 if (!scope.ok()) return;
2308 auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids);
2309 if (!scope.ok()) return;
2310 ::tensorflow::Node* ret;
2311 const auto unique_name = scope.GetUniqueNameForOp("SegmentProd");
2312 auto builder = ::tensorflow::NodeBuilder(unique_name, "SegmentProd")
2313 .Input(_data)
2314 .Input(_segment_ids)
2315 ;
2316 scope.UpdateBuilder(&builder);
2317 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2318 if (!scope.ok()) return;
2319 scope.UpdateStatus(scope.DoShapeInference(ret));
2320 this->operation = Operation(ret);
2321 this->output = Output(ret, 0);
2322}
2323
2324SegmentSum::SegmentSum(const ::tensorflow::Scope& scope, ::tensorflow::Input
2325 data, ::tensorflow::Input segment_ids) {
2326 if (!scope.ok()) return;
2327 auto _data = ::tensorflow::ops::AsNodeOut(scope, data);
2328 if (!scope.ok()) return;
2329 auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids);
2330 if (!scope.ok()) return;
2331 ::tensorflow::Node* ret;
2332 const auto unique_name = scope.GetUniqueNameForOp("SegmentSum");
2333 auto builder = ::tensorflow::NodeBuilder(unique_name, "SegmentSum")
2334 .Input(_data)
2335 .Input(_segment_ids)
2336 ;
2337 scope.UpdateBuilder(&builder);
2338 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2339 if (!scope.ok()) return;
2340 scope.UpdateStatus(scope.DoShapeInference(ret));
2341 this->operation = Operation(ret);
2342 this->output = Output(ret, 0);
2343}
2344
2345Where3::Where3(const ::tensorflow::Scope& scope, ::tensorflow::Input condition,
2346 ::tensorflow::Input x, ::tensorflow::Input y) {
2347 if (!scope.ok()) return;
2348 auto _condition = ::tensorflow::ops::AsNodeOut(scope, condition);
2349 if (!scope.ok()) return;
2350 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
2351 if (!scope.ok()) return;
2352 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
2353 if (!scope.ok()) return;
2354 ::tensorflow::Node* ret;
2355 const auto unique_name = scope.GetUniqueNameForOp("Where3");
2356 auto builder = ::tensorflow::NodeBuilder(unique_name, "Select")
2357 .Input(_condition)
2358 .Input(_x)
2359 .Input(_y)
2360 ;
2361 scope.UpdateBuilder(&builder);
2362 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2363 if (!scope.ok()) return;
2364 scope.UpdateStatus(scope.DoShapeInference(ret));
2365 this->operation = Operation(ret);
2366 this->output = Output(ret, 0);
2367}
2368
2369SelectV2::SelectV2(const ::tensorflow::Scope& scope, ::tensorflow::Input
2370 condition, ::tensorflow::Input t, ::tensorflow::Input e) {
2371 if (!scope.ok()) return;
2372 auto _condition = ::tensorflow::ops::AsNodeOut(scope, condition);
2373 if (!scope.ok()) return;
2374 auto _t = ::tensorflow::ops::AsNodeOut(scope, t);
2375 if (!scope.ok()) return;
2376 auto _e = ::tensorflow::ops::AsNodeOut(scope, e);
2377 if (!scope.ok()) return;
2378 ::tensorflow::Node* ret;
2379 const auto unique_name = scope.GetUniqueNameForOp("SelectV2");
2380 auto builder = ::tensorflow::NodeBuilder(unique_name, "SelectV2")
2381 .Input(_condition)
2382 .Input(_t)
2383 .Input(_e)
2384 ;
2385 scope.UpdateBuilder(&builder);
2386 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2387 if (!scope.ok()) return;
2388 scope.UpdateStatus(scope.DoShapeInference(ret));
2389 this->operation = Operation(ret);
2390 this->output = Output(ret, 0);
2391}
2392
2393Sigmoid::Sigmoid(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
2394 if (!scope.ok()) return;
2395 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
2396 if (!scope.ok()) return;
2397 ::tensorflow::Node* ret;
2398 const auto unique_name = scope.GetUniqueNameForOp("Sigmoid");
2399 auto builder = ::tensorflow::NodeBuilder(unique_name, "Sigmoid")
2400 .Input(_x)
2401 ;
2402 scope.UpdateBuilder(&builder);
2403 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2404 if (!scope.ok()) return;
2405 scope.UpdateStatus(scope.DoShapeInference(ret));
2406 this->operation = Operation(ret);
2407 this->y = Output(ret, 0);
2408}
2409
2410Sign::Sign(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
2411 if (!scope.ok()) return;
2412 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
2413 if (!scope.ok()) return;
2414 ::tensorflow::Node* ret;
2415 const auto unique_name = scope.GetUniqueNameForOp("Sign");
2416 auto builder = ::tensorflow::NodeBuilder(unique_name, "Sign")
2417 .Input(_x)
2418 ;
2419 scope.UpdateBuilder(&builder);
2420 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2421 if (!scope.ok()) return;
2422 scope.UpdateStatus(scope.DoShapeInference(ret));
2423 this->operation = Operation(ret);
2424 this->y = Output(ret, 0);
2425}
2426
2427Sin::Sin(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
2428 if (!scope.ok()) return;
2429 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
2430 if (!scope.ok()) return;
2431 ::tensorflow::Node* ret;
2432 const auto unique_name = scope.GetUniqueNameForOp("Sin");
2433 auto builder = ::tensorflow::NodeBuilder(unique_name, "Sin")
2434 .Input(_x)
2435 ;
2436 scope.UpdateBuilder(&builder);
2437 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2438 if (!scope.ok()) return;
2439 scope.UpdateStatus(scope.DoShapeInference(ret));
2440 this->operation = Operation(ret);
2441 this->y = Output(ret, 0);
2442}
2443
2444Sinh::Sinh(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
2445 if (!scope.ok()) return;
2446 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
2447 if (!scope.ok()) return;
2448 ::tensorflow::Node* ret;
2449 const auto unique_name = scope.GetUniqueNameForOp("Sinh");
2450 auto builder = ::tensorflow::NodeBuilder(unique_name, "Sinh")
2451 .Input(_x)
2452 ;
2453 scope.UpdateBuilder(&builder);
2454 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2455 if (!scope.ok()) return;
2456 scope.UpdateStatus(scope.DoShapeInference(ret));
2457 this->operation = Operation(ret);
2458 this->y = Output(ret, 0);
2459}
2460
2461SparseBincount::SparseBincount(const ::tensorflow::Scope& scope,
2462 ::tensorflow::Input indices, ::tensorflow::Input
2463 values, ::tensorflow::Input dense_shape,
2464 ::tensorflow::Input size, ::tensorflow::Input
2465 weights, const SparseBincount::Attrs& attrs) {
2466 if (!scope.ok()) return;
2467 auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices);
2468 if (!scope.ok()) return;
2469 auto _values = ::tensorflow::ops::AsNodeOut(scope, values);
2470 if (!scope.ok()) return;
2471 auto _dense_shape = ::tensorflow::ops::AsNodeOut(scope, dense_shape);
2472 if (!scope.ok()) return;
2473 auto _size = ::tensorflow::ops::AsNodeOut(scope, size);
2474 if (!scope.ok()) return;
2475 auto _weights = ::tensorflow::ops::AsNodeOut(scope, weights);
2476 if (!scope.ok()) return;
2477 ::tensorflow::Node* ret;
2478 const auto unique_name = scope.GetUniqueNameForOp("SparseBincount");
2479 auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseBincount")
2480 .Input(_indices)
2481 .Input(_values)
2482 .Input(_dense_shape)
2483 .Input(_size)
2484 .Input(_weights)
2485 .Attr("binary_output", attrs.binary_output_)
2486 ;
2487 scope.UpdateBuilder(&builder);
2488 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2489 if (!scope.ok()) return;
2490 scope.UpdateStatus(scope.DoShapeInference(ret));
2491 this->operation = Operation(ret);
2492 this->output = Output(ret, 0);
2493}
2494
2495SparseBincount::SparseBincount(const ::tensorflow::Scope& scope,
2496 ::tensorflow::Input indices, ::tensorflow::Input
2497 values, ::tensorflow::Input dense_shape,
2498 ::tensorflow::Input size, ::tensorflow::Input
2499 weights)
2500 : SparseBincount(scope, indices, values, dense_shape, size, weights, SparseBincount::Attrs()) {}
2501
2502SparseMatMul::SparseMatMul(const ::tensorflow::Scope& scope,
2503 ::tensorflow::Input a, ::tensorflow::Input b, const
2504 SparseMatMul::Attrs& attrs) {
2505 if (!scope.ok()) return;
2506 auto _a = ::tensorflow::ops::AsNodeOut(scope, a);
2507 if (!scope.ok()) return;
2508 auto _b = ::tensorflow::ops::AsNodeOut(scope, b);
2509 if (!scope.ok()) return;
2510 ::tensorflow::Node* ret;
2511 const auto unique_name = scope.GetUniqueNameForOp("SparseMatMul");
2512 auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseMatMul")
2513 .Input(_a)
2514 .Input(_b)
2515 .Attr("transpose_a", attrs.transpose_a_)
2516 .Attr("transpose_b", attrs.transpose_b_)
2517 .Attr("a_is_sparse", attrs.a_is_sparse_)
2518 .Attr("b_is_sparse", attrs.b_is_sparse_)
2519 ;
2520 scope.UpdateBuilder(&builder);
2521 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2522 if (!scope.ok()) return;
2523 scope.UpdateStatus(scope.DoShapeInference(ret));
2524 this->operation = Operation(ret);
2525 this->product = Output(ret, 0);
2526}
2527
2528SparseMatMul::SparseMatMul(const ::tensorflow::Scope& scope,
2529 ::tensorflow::Input a, ::tensorflow::Input b)
2530 : SparseMatMul(scope, a, b, SparseMatMul::Attrs()) {}
2531
2532SparseSegmentMean::SparseSegmentMean(const ::tensorflow::Scope& scope,
2533 ::tensorflow::Input data,
2534 ::tensorflow::Input indices,
2535 ::tensorflow::Input segment_ids) {
2536 if (!scope.ok()) return;
2537 auto _data = ::tensorflow::ops::AsNodeOut(scope, data);
2538 if (!scope.ok()) return;
2539 auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices);
2540 if (!scope.ok()) return;
2541 auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids);
2542 if (!scope.ok()) return;
2543 ::tensorflow::Node* ret;
2544 const auto unique_name = scope.GetUniqueNameForOp("SparseSegmentMean");
2545 auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseSegmentMean")
2546 .Input(_data)
2547 .Input(_indices)
2548 .Input(_segment_ids)
2549 ;
2550 scope.UpdateBuilder(&builder);
2551 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2552 if (!scope.ok()) return;
2553 scope.UpdateStatus(scope.DoShapeInference(ret));
2554 this->operation = Operation(ret);
2555 this->output = Output(ret, 0);
2556}
2557
2558SparseSegmentMeanGrad::SparseSegmentMeanGrad(const ::tensorflow::Scope& scope,
2559 ::tensorflow::Input grad,
2560 ::tensorflow::Input indices,
2561 ::tensorflow::Input segment_ids,
2562 ::tensorflow::Input output_dim0) {
2563 if (!scope.ok()) return;
2564 auto _grad = ::tensorflow::ops::AsNodeOut(scope, grad);
2565 if (!scope.ok()) return;
2566 auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices);
2567 if (!scope.ok()) return;
2568 auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids);
2569 if (!scope.ok()) return;
2570 auto _output_dim0 = ::tensorflow::ops::AsNodeOut(scope, output_dim0);
2571 if (!scope.ok()) return;
2572 ::tensorflow::Node* ret;
2573 const auto unique_name = scope.GetUniqueNameForOp("SparseSegmentMeanGrad");
2574 auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseSegmentMeanGrad")
2575 .Input(_grad)
2576 .Input(_indices)
2577 .Input(_segment_ids)
2578 .Input(_output_dim0)
2579 ;
2580 scope.UpdateBuilder(&builder);
2581 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2582 if (!scope.ok()) return;
2583 scope.UpdateStatus(scope.DoShapeInference(ret));
2584 this->operation = Operation(ret);
2585 this->output = Output(ret, 0);
2586}
2587
2588SparseSegmentMeanWithNumSegments::SparseSegmentMeanWithNumSegments(const
2589 ::tensorflow::Scope&
2590 scope,
2591 ::tensorflow::Input
2592 data,
2593 ::tensorflow::Input
2594 indices,
2595 ::tensorflow::Input
2596 segment_ids,
2597 ::tensorflow::Input
2598 num_segments) {
2599 if (!scope.ok()) return;
2600 auto _data = ::tensorflow::ops::AsNodeOut(scope, data);
2601 if (!scope.ok()) return;
2602 auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices);
2603 if (!scope.ok()) return;
2604 auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids);
2605 if (!scope.ok()) return;
2606 auto _num_segments = ::tensorflow::ops::AsNodeOut(scope, num_segments);
2607 if (!scope.ok()) return;
2608 ::tensorflow::Node* ret;
2609 const auto unique_name = scope.GetUniqueNameForOp("SparseSegmentMeanWithNumSegments");
2610 auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseSegmentMeanWithNumSegments")
2611 .Input(_data)
2612 .Input(_indices)
2613 .Input(_segment_ids)
2614 .Input(_num_segments)
2615 ;
2616 scope.UpdateBuilder(&builder);
2617 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2618 if (!scope.ok()) return;
2619 scope.UpdateStatus(scope.DoShapeInference(ret));
2620 this->operation = Operation(ret);
2621 this->output = Output(ret, 0);
2622}
2623
2624SparseSegmentSqrtN::SparseSegmentSqrtN(const ::tensorflow::Scope& scope,
2625 ::tensorflow::Input data,
2626 ::tensorflow::Input indices,
2627 ::tensorflow::Input segment_ids) {
2628 if (!scope.ok()) return;
2629 auto _data = ::tensorflow::ops::AsNodeOut(scope, data);
2630 if (!scope.ok()) return;
2631 auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices);
2632 if (!scope.ok()) return;
2633 auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids);
2634 if (!scope.ok()) return;
2635 ::tensorflow::Node* ret;
2636 const auto unique_name = scope.GetUniqueNameForOp("SparseSegmentSqrtN");
2637 auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseSegmentSqrtN")
2638 .Input(_data)
2639 .Input(_indices)
2640 .Input(_segment_ids)
2641 ;
2642 scope.UpdateBuilder(&builder);
2643 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2644 if (!scope.ok()) return;
2645 scope.UpdateStatus(scope.DoShapeInference(ret));
2646 this->operation = Operation(ret);
2647 this->output = Output(ret, 0);
2648}
2649
2650SparseSegmentSqrtNGrad::SparseSegmentSqrtNGrad(const ::tensorflow::Scope&
2651 scope, ::tensorflow::Input grad,
2652 ::tensorflow::Input indices,
2653 ::tensorflow::Input segment_ids,
2654 ::tensorflow::Input output_dim0) {
2655 if (!scope.ok()) return;
2656 auto _grad = ::tensorflow::ops::AsNodeOut(scope, grad);
2657 if (!scope.ok()) return;
2658 auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices);
2659 if (!scope.ok()) return;
2660 auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids);
2661 if (!scope.ok()) return;
2662 auto _output_dim0 = ::tensorflow::ops::AsNodeOut(scope, output_dim0);
2663 if (!scope.ok()) return;
2664 ::tensorflow::Node* ret;
2665 const auto unique_name = scope.GetUniqueNameForOp("SparseSegmentSqrtNGrad");
2666 auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseSegmentSqrtNGrad")
2667 .Input(_grad)
2668 .Input(_indices)
2669 .Input(_segment_ids)
2670 .Input(_output_dim0)
2671 ;
2672 scope.UpdateBuilder(&builder);
2673 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2674 if (!scope.ok()) return;
2675 scope.UpdateStatus(scope.DoShapeInference(ret));
2676 this->operation = Operation(ret);
2677 this->output = Output(ret, 0);
2678}
2679
2680SparseSegmentSqrtNWithNumSegments::SparseSegmentSqrtNWithNumSegments(const
2681 ::tensorflow::Scope&
2682 scope,
2683 ::tensorflow::Input
2684 data,
2685 ::tensorflow::Input
2686 indices,
2687 ::tensorflow::Input
2688 segment_ids,
2689 ::tensorflow::Input
2690 num_segments) {
2691 if (!scope.ok()) return;
2692 auto _data = ::tensorflow::ops::AsNodeOut(scope, data);
2693 if (!scope.ok()) return;
2694 auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices);
2695 if (!scope.ok()) return;
2696 auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids);
2697 if (!scope.ok()) return;
2698 auto _num_segments = ::tensorflow::ops::AsNodeOut(scope, num_segments);
2699 if (!scope.ok()) return;
2700 ::tensorflow::Node* ret;
2701 const auto unique_name = scope.GetUniqueNameForOp("SparseSegmentSqrtNWithNumSegments");
2702 auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseSegmentSqrtNWithNumSegments")
2703 .Input(_data)
2704 .Input(_indices)
2705 .Input(_segment_ids)
2706 .Input(_num_segments)
2707 ;
2708 scope.UpdateBuilder(&builder);
2709 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2710 if (!scope.ok()) return;
2711 scope.UpdateStatus(scope.DoShapeInference(ret));
2712 this->operation = Operation(ret);
2713 this->output = Output(ret, 0);
2714}
2715
2716SparseSegmentSum::SparseSegmentSum(const ::tensorflow::Scope& scope,
2717 ::tensorflow::Input data,
2718 ::tensorflow::Input indices,
2719 ::tensorflow::Input segment_ids) {
2720 if (!scope.ok()) return;
2721 auto _data = ::tensorflow::ops::AsNodeOut(scope, data);
2722 if (!scope.ok()) return;
2723 auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices);
2724 if (!scope.ok()) return;
2725 auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids);
2726 if (!scope.ok()) return;
2727 ::tensorflow::Node* ret;
2728 const auto unique_name = scope.GetUniqueNameForOp("SparseSegmentSum");
2729 auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseSegmentSum")
2730 .Input(_data)
2731 .Input(_indices)
2732 .Input(_segment_ids)
2733 ;
2734 scope.UpdateBuilder(&builder);
2735 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2736 if (!scope.ok()) return;
2737 scope.UpdateStatus(scope.DoShapeInference(ret));
2738 this->operation = Operation(ret);
2739 this->output = Output(ret, 0);
2740}
2741
2742SparseSegmentSumGrad::SparseSegmentSumGrad(const ::tensorflow::Scope& scope,
2743 ::tensorflow::Input grad,
2744 ::tensorflow::Input indices,
2745 ::tensorflow::Input segment_ids,
2746 ::tensorflow::Input output_dim0) {
2747 if (!scope.ok()) return;
2748 auto _grad = ::tensorflow::ops::AsNodeOut(scope, grad);
2749 if (!scope.ok()) return;
2750 auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices);
2751 if (!scope.ok()) return;
2752 auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids);
2753 if (!scope.ok()) return;
2754 auto _output_dim0 = ::tensorflow::ops::AsNodeOut(scope, output_dim0);
2755 if (!scope.ok()) return;
2756 ::tensorflow::Node* ret;
2757 const auto unique_name = scope.GetUniqueNameForOp("SparseSegmentSumGrad");
2758 auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseSegmentSumGrad")
2759 .Input(_grad)
2760 .Input(_indices)
2761 .Input(_segment_ids)
2762 .Input(_output_dim0)
2763 ;
2764 scope.UpdateBuilder(&builder);
2765 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2766 if (!scope.ok()) return;
2767 scope.UpdateStatus(scope.DoShapeInference(ret));
2768 this->operation = Operation(ret);
2769 this->output = Output(ret, 0);
2770}
2771
2772SparseSegmentSumWithNumSegments::SparseSegmentSumWithNumSegments(const
2773 ::tensorflow::Scope&
2774 scope,
2775 ::tensorflow::Input
2776 data,
2777 ::tensorflow::Input
2778 indices,
2779 ::tensorflow::Input
2780 segment_ids,
2781 ::tensorflow::Input
2782 num_segments) {
2783 if (!scope.ok()) return;
2784 auto _data = ::tensorflow::ops::AsNodeOut(scope, data);
2785 if (!scope.ok()) return;
2786 auto _indices = ::tensorflow::ops::AsNodeOut(scope, indices);
2787 if (!scope.ok()) return;
2788 auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids);
2789 if (!scope.ok()) return;
2790 auto _num_segments = ::tensorflow::ops::AsNodeOut(scope, num_segments);
2791 if (!scope.ok()) return;
2792 ::tensorflow::Node* ret;
2793 const auto unique_name = scope.GetUniqueNameForOp("SparseSegmentSumWithNumSegments");
2794 auto builder = ::tensorflow::NodeBuilder(unique_name, "SparseSegmentSumWithNumSegments")
2795 .Input(_data)
2796 .Input(_indices)
2797 .Input(_segment_ids)
2798 .Input(_num_segments)
2799 ;
2800 scope.UpdateBuilder(&builder);
2801 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2802 if (!scope.ok()) return;
2803 scope.UpdateStatus(scope.DoShapeInference(ret));
2804 this->operation = Operation(ret);
2805 this->output = Output(ret, 0);
2806}
2807
2808Sqrt::Sqrt(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
2809 if (!scope.ok()) return;
2810 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
2811 if (!scope.ok()) return;
2812 ::tensorflow::Node* ret;
2813 const auto unique_name = scope.GetUniqueNameForOp("Sqrt");
2814 auto builder = ::tensorflow::NodeBuilder(unique_name, "Sqrt")
2815 .Input(_x)
2816 ;
2817 scope.UpdateBuilder(&builder);
2818 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2819 if (!scope.ok()) return;
2820 scope.UpdateStatus(scope.DoShapeInference(ret));
2821 this->operation = Operation(ret);
2822 this->y = Output(ret, 0);
2823}
2824
2825Square::Square(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
2826 if (!scope.ok()) return;
2827 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
2828 if (!scope.ok()) return;
2829 ::tensorflow::Node* ret;
2830 const auto unique_name = scope.GetUniqueNameForOp("Square");
2831 auto builder = ::tensorflow::NodeBuilder(unique_name, "Square")
2832 .Input(_x)
2833 ;
2834 scope.UpdateBuilder(&builder);
2835 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2836 if (!scope.ok()) return;
2837 scope.UpdateStatus(scope.DoShapeInference(ret));
2838 this->operation = Operation(ret);
2839 this->y = Output(ret, 0);
2840}
2841
2842SquaredDifference::SquaredDifference(const ::tensorflow::Scope& scope,
2843 ::tensorflow::Input x, ::tensorflow::Input
2844 y) {
2845 if (!scope.ok()) return;
2846 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
2847 if (!scope.ok()) return;
2848 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
2849 if (!scope.ok()) return;
2850 ::tensorflow::Node* ret;
2851 const auto unique_name = scope.GetUniqueNameForOp("SquaredDifference");
2852 auto builder = ::tensorflow::NodeBuilder(unique_name, "SquaredDifference")
2853 .Input(_x)
2854 .Input(_y)
2855 ;
2856 scope.UpdateBuilder(&builder);
2857 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2858 if (!scope.ok()) return;
2859 scope.UpdateStatus(scope.DoShapeInference(ret));
2860 this->operation = Operation(ret);
2861 this->z = Output(ret, 0);
2862}
2863
2864Subtract::Subtract(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
2865 ::tensorflow::Input y) {
2866 if (!scope.ok()) return;
2867 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
2868 if (!scope.ok()) return;
2869 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
2870 if (!scope.ok()) return;
2871 ::tensorflow::Node* ret;
2872 const auto unique_name = scope.GetUniqueNameForOp("Subtract");
2873 auto builder = ::tensorflow::NodeBuilder(unique_name, "Sub")
2874 .Input(_x)
2875 .Input(_y)
2876 ;
2877 scope.UpdateBuilder(&builder);
2878 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2879 if (!scope.ok()) return;
2880 scope.UpdateStatus(scope.DoShapeInference(ret));
2881 this->operation = Operation(ret);
2882 this->z = Output(ret, 0);
2883}
2884
2885Sum::Sum(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
2886 ::tensorflow::Input axis, const Sum::Attrs& attrs) {
2887 if (!scope.ok()) return;
2888 auto _input = ::tensorflow::ops::AsNodeOut(scope, input);
2889 if (!scope.ok()) return;
2890 auto _axis = ::tensorflow::ops::AsNodeOut(scope, axis);
2891 if (!scope.ok()) return;
2892 ::tensorflow::Node* ret;
2893 const auto unique_name = scope.GetUniqueNameForOp("Sum");
2894 auto builder = ::tensorflow::NodeBuilder(unique_name, "Sum")
2895 .Input(_input)
2896 .Input(_axis)
2897 .Attr("keep_dims", attrs.keep_dims_)
2898 ;
2899 scope.UpdateBuilder(&builder);
2900 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2901 if (!scope.ok()) return;
2902 scope.UpdateStatus(scope.DoShapeInference(ret));
2903 this->operation = Operation(ret);
2904 this->output = Output(ret, 0);
2905}
2906
2907Sum::Sum(const ::tensorflow::Scope& scope, ::tensorflow::Input input,
2908 ::tensorflow::Input axis)
2909 : Sum(scope, input, axis, Sum::Attrs()) {}
2910
2911Tan::Tan(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
2912 if (!scope.ok()) return;
2913 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
2914 if (!scope.ok()) return;
2915 ::tensorflow::Node* ret;
2916 const auto unique_name = scope.GetUniqueNameForOp("Tan");
2917 auto builder = ::tensorflow::NodeBuilder(unique_name, "Tan")
2918 .Input(_x)
2919 ;
2920 scope.UpdateBuilder(&builder);
2921 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2922 if (!scope.ok()) return;
2923 scope.UpdateStatus(scope.DoShapeInference(ret));
2924 this->operation = Operation(ret);
2925 this->y = Output(ret, 0);
2926}
2927
2928Tanh::Tanh(const ::tensorflow::Scope& scope, ::tensorflow::Input x) {
2929 if (!scope.ok()) return;
2930 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
2931 if (!scope.ok()) return;
2932 ::tensorflow::Node* ret;
2933 const auto unique_name = scope.GetUniqueNameForOp("Tanh");
2934 auto builder = ::tensorflow::NodeBuilder(unique_name, "Tanh")
2935 .Input(_x)
2936 ;
2937 scope.UpdateBuilder(&builder);
2938 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2939 if (!scope.ok()) return;
2940 scope.UpdateStatus(scope.DoShapeInference(ret));
2941 this->operation = Operation(ret);
2942 this->y = Output(ret, 0);
2943}
2944
2945TruncateDiv::TruncateDiv(const ::tensorflow::Scope& scope, ::tensorflow::Input
2946 x, ::tensorflow::Input y) {
2947 if (!scope.ok()) return;
2948 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
2949 if (!scope.ok()) return;
2950 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
2951 if (!scope.ok()) return;
2952 ::tensorflow::Node* ret;
2953 const auto unique_name = scope.GetUniqueNameForOp("TruncateDiv");
2954 auto builder = ::tensorflow::NodeBuilder(unique_name, "TruncateDiv")
2955 .Input(_x)
2956 .Input(_y)
2957 ;
2958 scope.UpdateBuilder(&builder);
2959 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2960 if (!scope.ok()) return;
2961 scope.UpdateStatus(scope.DoShapeInference(ret));
2962 this->operation = Operation(ret);
2963 this->z = Output(ret, 0);
2964}
2965
2966TruncateMod::TruncateMod(const ::tensorflow::Scope& scope, ::tensorflow::Input
2967 x, ::tensorflow::Input y) {
2968 if (!scope.ok()) return;
2969 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
2970 if (!scope.ok()) return;
2971 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
2972 if (!scope.ok()) return;
2973 ::tensorflow::Node* ret;
2974 const auto unique_name = scope.GetUniqueNameForOp("TruncateMod");
2975 auto builder = ::tensorflow::NodeBuilder(unique_name, "TruncateMod")
2976 .Input(_x)
2977 .Input(_y)
2978 ;
2979 scope.UpdateBuilder(&builder);
2980 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
2981 if (!scope.ok()) return;
2982 scope.UpdateStatus(scope.DoShapeInference(ret));
2983 this->operation = Operation(ret);
2984 this->z = Output(ret, 0);
2985}
2986
2987UnsortedSegmentMax::UnsortedSegmentMax(const ::tensorflow::Scope& scope,
2988 ::tensorflow::Input data,
2989 ::tensorflow::Input segment_ids,
2990 ::tensorflow::Input num_segments) {
2991 if (!scope.ok()) return;
2992 auto _data = ::tensorflow::ops::AsNodeOut(scope, data);
2993 if (!scope.ok()) return;
2994 auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids);
2995 if (!scope.ok()) return;
2996 auto _num_segments = ::tensorflow::ops::AsNodeOut(scope, num_segments);
2997 if (!scope.ok()) return;
2998 ::tensorflow::Node* ret;
2999 const auto unique_name = scope.GetUniqueNameForOp("UnsortedSegmentMax");
3000 auto builder = ::tensorflow::NodeBuilder(unique_name, "UnsortedSegmentMax")
3001 .Input(_data)
3002 .Input(_segment_ids)
3003 .Input(_num_segments)
3004 ;
3005 scope.UpdateBuilder(&builder);
3006 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
3007 if (!scope.ok()) return;
3008 scope.UpdateStatus(scope.DoShapeInference(ret));
3009 this->operation = Operation(ret);
3010 this->output = Output(ret, 0);
3011}
3012
3013UnsortedSegmentMin::UnsortedSegmentMin(const ::tensorflow::Scope& scope,
3014 ::tensorflow::Input data,
3015 ::tensorflow::Input segment_ids,
3016 ::tensorflow::Input num_segments) {
3017 if (!scope.ok()) return;
3018 auto _data = ::tensorflow::ops::AsNodeOut(scope, data);
3019 if (!scope.ok()) return;
3020 auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids);
3021 if (!scope.ok()) return;
3022 auto _num_segments = ::tensorflow::ops::AsNodeOut(scope, num_segments);
3023 if (!scope.ok()) return;
3024 ::tensorflow::Node* ret;
3025 const auto unique_name = scope.GetUniqueNameForOp("UnsortedSegmentMin");
3026 auto builder = ::tensorflow::NodeBuilder(unique_name, "UnsortedSegmentMin")
3027 .Input(_data)
3028 .Input(_segment_ids)
3029 .Input(_num_segments)
3030 ;
3031 scope.UpdateBuilder(&builder);
3032 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
3033 if (!scope.ok()) return;
3034 scope.UpdateStatus(scope.DoShapeInference(ret));
3035 this->operation = Operation(ret);
3036 this->output = Output(ret, 0);
3037}
3038
3039UnsortedSegmentProd::UnsortedSegmentProd(const ::tensorflow::Scope& scope,
3040 ::tensorflow::Input data,
3041 ::tensorflow::Input segment_ids,
3042 ::tensorflow::Input num_segments) {
3043 if (!scope.ok()) return;
3044 auto _data = ::tensorflow::ops::AsNodeOut(scope, data);
3045 if (!scope.ok()) return;
3046 auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids);
3047 if (!scope.ok()) return;
3048 auto _num_segments = ::tensorflow::ops::AsNodeOut(scope, num_segments);
3049 if (!scope.ok()) return;
3050 ::tensorflow::Node* ret;
3051 const auto unique_name = scope.GetUniqueNameForOp("UnsortedSegmentProd");
3052 auto builder = ::tensorflow::NodeBuilder(unique_name, "UnsortedSegmentProd")
3053 .Input(_data)
3054 .Input(_segment_ids)
3055 .Input(_num_segments)
3056 ;
3057 scope.UpdateBuilder(&builder);
3058 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
3059 if (!scope.ok()) return;
3060 scope.UpdateStatus(scope.DoShapeInference(ret));
3061 this->operation = Operation(ret);
3062 this->output = Output(ret, 0);
3063}
3064
3065UnsortedSegmentSum::UnsortedSegmentSum(const ::tensorflow::Scope& scope,
3066 ::tensorflow::Input data,
3067 ::tensorflow::Input segment_ids,
3068 ::tensorflow::Input num_segments) {
3069 if (!scope.ok()) return;
3070 auto _data = ::tensorflow::ops::AsNodeOut(scope, data);
3071 if (!scope.ok()) return;
3072 auto _segment_ids = ::tensorflow::ops::AsNodeOut(scope, segment_ids);
3073 if (!scope.ok()) return;
3074 auto _num_segments = ::tensorflow::ops::AsNodeOut(scope, num_segments);
3075 if (!scope.ok()) return;
3076 ::tensorflow::Node* ret;
3077 const auto unique_name = scope.GetUniqueNameForOp("UnsortedSegmentSum");
3078 auto builder = ::tensorflow::NodeBuilder(unique_name, "UnsortedSegmentSum")
3079 .Input(_data)
3080 .Input(_segment_ids)
3081 .Input(_num_segments)
3082 ;
3083 scope.UpdateBuilder(&builder);
3084 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
3085 if (!scope.ok()) return;
3086 scope.UpdateStatus(scope.DoShapeInference(ret));
3087 this->operation = Operation(ret);
3088 this->output = Output(ret, 0);
3089}
3090
3091Xdivy::Xdivy(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
3092 ::tensorflow::Input y) {
3093 if (!scope.ok()) return;
3094 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
3095 if (!scope.ok()) return;
3096 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
3097 if (!scope.ok()) return;
3098 ::tensorflow::Node* ret;
3099 const auto unique_name = scope.GetUniqueNameForOp("Xdivy");
3100 auto builder = ::tensorflow::NodeBuilder(unique_name, "Xdivy")
3101 .Input(_x)
3102 .Input(_y)
3103 ;
3104 scope.UpdateBuilder(&builder);
3105 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
3106 if (!scope.ok()) return;
3107 scope.UpdateStatus(scope.DoShapeInference(ret));
3108 this->operation = Operation(ret);
3109 this->z = Output(ret, 0);
3110}
3111
3112Xlog1py::Xlog1py(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
3113 ::tensorflow::Input y) {
3114 if (!scope.ok()) return;
3115 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
3116 if (!scope.ok()) return;
3117 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
3118 if (!scope.ok()) return;
3119 ::tensorflow::Node* ret;
3120 const auto unique_name = scope.GetUniqueNameForOp("Xlog1py");
3121 auto builder = ::tensorflow::NodeBuilder(unique_name, "Xlog1py")
3122 .Input(_x)
3123 .Input(_y)
3124 ;
3125 scope.UpdateBuilder(&builder);
3126 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
3127 if (!scope.ok()) return;
3128 scope.UpdateStatus(scope.DoShapeInference(ret));
3129 this->operation = Operation(ret);
3130 this->z = Output(ret, 0);
3131}
3132
3133Xlogy::Xlogy(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
3134 ::tensorflow::Input y) {
3135 if (!scope.ok()) return;
3136 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
3137 if (!scope.ok()) return;
3138 auto _y = ::tensorflow::ops::AsNodeOut(scope, y);
3139 if (!scope.ok()) return;
3140 ::tensorflow::Node* ret;
3141 const auto unique_name = scope.GetUniqueNameForOp("Xlogy");
3142 auto builder = ::tensorflow::NodeBuilder(unique_name, "Xlogy")
3143 .Input(_x)
3144 .Input(_y)
3145 ;
3146 scope.UpdateBuilder(&builder);
3147 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
3148 if (!scope.ok()) return;
3149 scope.UpdateStatus(scope.DoShapeInference(ret));
3150 this->operation = Operation(ret);
3151 this->z = Output(ret, 0);
3152}
3153
3154Zeta::Zeta(const ::tensorflow::Scope& scope, ::tensorflow::Input x,
3155 ::tensorflow::Input q) {
3156 if (!scope.ok()) return;
3157 auto _x = ::tensorflow::ops::AsNodeOut(scope, x);
3158 if (!scope.ok()) return;
3159 auto _q = ::tensorflow::ops::AsNodeOut(scope, q);
3160 if (!scope.ok()) return;
3161 ::tensorflow::Node* ret;
3162 const auto unique_name = scope.GetUniqueNameForOp("Zeta");
3163 auto builder = ::tensorflow::NodeBuilder(unique_name, "Zeta")
3164 .Input(_x)
3165 .Input(_q)
3166 ;
3167 scope.UpdateBuilder(&builder);
3168 scope.UpdateStatus(builder.Finalize(scope.graph(), &ret));
3169 if (!scope.ok()) return;
3170 scope.UpdateStatus(scope.DoShapeInference(ret));
3171 this->operation = Operation(ret);
3172 this->z = Output(ret, 0);
3173}
3174
3175/// @}
3176
3177} // namespace ops
3178} // namespace tensorflow
3179