1 // Generated from pow.mod.py
2 // DO NOT EDIT
3 // clang-format off
4 #include "TestHarness.h"
5 using namespace test_helper; // NOLINT(google-build-using-namespace)
6
7 namespace generated_tests::pow {
8
get_test_model()9 const TestModel& get_test_model() {
10 static TestModel model = {
11 .main = {
12 .operands = {{ // base
13 .type = TestOperandType::TENSOR_FLOAT32,
14 .dimensions = {2, 1},
15 .numberOfConsumers = 1,
16 .scale = 0.0f,
17 .zeroPoint = 0,
18 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
19 .channelQuant = {},
20 .isIgnored = false,
21 .data = TestBuffer::createFromVector<float>({2.0f, 3.0f})
22 }, { // exponent
23 .type = TestOperandType::TENSOR_FLOAT32,
24 .dimensions = {1},
25 .numberOfConsumers = 1,
26 .scale = 0.0f,
27 .zeroPoint = 0,
28 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
29 .channelQuant = {},
30 .isIgnored = false,
31 .data = TestBuffer::createFromVector<float>({2.0f})
32 }, { // output
33 .type = TestOperandType::TENSOR_FLOAT32,
34 .dimensions = {2, 1},
35 .numberOfConsumers = 0,
36 .scale = 0.0f,
37 .zeroPoint = 0,
38 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
39 .channelQuant = {},
40 .isIgnored = false,
41 .data = TestBuffer::createFromVector<float>({4.0f, 9.0f})
42 }},
43 .operations = {{
44 .type = TestOperationType::POW,
45 .inputs = {0, 1},
46 .outputs = {2}
47 }},
48 .inputIndexes = {0, 1},
49 .outputIndexes = {2}
50 },
51 .referenced = {},
52 .isRelaxed = false,
53 .expectedMultinomialDistributionTolerance = 0,
54 .expectFailure = false,
55 .minSupportedVersion = TestHalVersion::V1_2
56 };
57 return model;
58 }
59
60 const auto dummy_test_model = TestModelManager::get().add("pow", get_test_model());
61
62 } // namespace generated_tests::pow
63
64 namespace generated_tests::pow {
65
get_test_model_all_inputs_as_internal()66 const TestModel& get_test_model_all_inputs_as_internal() {
67 static TestModel model = {
68 .main = {
69 .operands = {{ // base
70 .type = TestOperandType::TENSOR_FLOAT32,
71 .dimensions = {2, 1},
72 .numberOfConsumers = 1,
73 .scale = 0.0f,
74 .zeroPoint = 0,
75 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
76 .channelQuant = {},
77 .isIgnored = false,
78 .data = TestBuffer::createFromVector<float>({})
79 }, { // exponent
80 .type = TestOperandType::TENSOR_FLOAT32,
81 .dimensions = {1},
82 .numberOfConsumers = 1,
83 .scale = 0.0f,
84 .zeroPoint = 0,
85 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
86 .channelQuant = {},
87 .isIgnored = false,
88 .data = TestBuffer::createFromVector<float>({})
89 }, { // output
90 .type = TestOperandType::TENSOR_FLOAT32,
91 .dimensions = {2, 1},
92 .numberOfConsumers = 0,
93 .scale = 0.0f,
94 .zeroPoint = 0,
95 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
96 .channelQuant = {},
97 .isIgnored = false,
98 .data = TestBuffer::createFromVector<float>({4.0f, 9.0f})
99 }, { // base_new
100 .type = TestOperandType::TENSOR_FLOAT32,
101 .dimensions = {2, 1},
102 .numberOfConsumers = 1,
103 .scale = 0.0f,
104 .zeroPoint = 0,
105 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
106 .channelQuant = {},
107 .isIgnored = false,
108 .data = TestBuffer::createFromVector<float>({2.0f, 3.0f})
109 }, { // placeholder
110 .type = TestOperandType::TENSOR_FLOAT32,
111 .dimensions = {1},
112 .numberOfConsumers = 1,
113 .scale = 0.0f,
114 .zeroPoint = 0,
115 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
116 .channelQuant = {},
117 .isIgnored = false,
118 .data = TestBuffer::createFromVector<float>({0.0f})
119 }, { // param
120 .type = TestOperandType::INT32,
121 .dimensions = {},
122 .numberOfConsumers = 1,
123 .scale = 0.0f,
124 .zeroPoint = 0,
125 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
126 .channelQuant = {},
127 .isIgnored = false,
128 .data = TestBuffer::createFromVector<int32_t>({0})
129 }, { // exponent_new
130 .type = TestOperandType::TENSOR_FLOAT32,
131 .dimensions = {1},
132 .numberOfConsumers = 1,
133 .scale = 0.0f,
134 .zeroPoint = 0,
135 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
136 .channelQuant = {},
137 .isIgnored = false,
138 .data = TestBuffer::createFromVector<float>({2.0f})
139 }, { // placeholder1
140 .type = TestOperandType::TENSOR_FLOAT32,
141 .dimensions = {1},
142 .numberOfConsumers = 1,
143 .scale = 0.0f,
144 .zeroPoint = 0,
145 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
146 .channelQuant = {},
147 .isIgnored = false,
148 .data = TestBuffer::createFromVector<float>({0.0f})
149 }, { // param1
150 .type = TestOperandType::INT32,
151 .dimensions = {},
152 .numberOfConsumers = 1,
153 .scale = 0.0f,
154 .zeroPoint = 0,
155 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
156 .channelQuant = {},
157 .isIgnored = false,
158 .data = TestBuffer::createFromVector<int32_t>({0})
159 }},
160 .operations = {{
161 .type = TestOperationType::ADD,
162 .inputs = {3, 4, 5},
163 .outputs = {0}
164 }, {
165 .type = TestOperationType::ADD,
166 .inputs = {6, 7, 8},
167 .outputs = {1}
168 }, {
169 .type = TestOperationType::POW,
170 .inputs = {0, 1},
171 .outputs = {2}
172 }},
173 .inputIndexes = {3, 6},
174 .outputIndexes = {2}
175 },
176 .referenced = {},
177 .isRelaxed = false,
178 .expectedMultinomialDistributionTolerance = 0,
179 .expectFailure = false,
180 .minSupportedVersion = TestHalVersion::V1_2
181 };
182 return model;
183 }
184
185 const auto dummy_test_model_all_inputs_as_internal = TestModelManager::get().add("pow_all_inputs_as_internal", get_test_model_all_inputs_as_internal());
186
187 } // namespace generated_tests::pow
188
189 namespace generated_tests::pow {
190
get_test_model_relaxed()191 const TestModel& get_test_model_relaxed() {
192 static TestModel model = {
193 .main = {
194 .operands = {{ // base
195 .type = TestOperandType::TENSOR_FLOAT32,
196 .dimensions = {2, 1},
197 .numberOfConsumers = 1,
198 .scale = 0.0f,
199 .zeroPoint = 0,
200 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
201 .channelQuant = {},
202 .isIgnored = false,
203 .data = TestBuffer::createFromVector<float>({2.0f, 3.0f})
204 }, { // exponent
205 .type = TestOperandType::TENSOR_FLOAT32,
206 .dimensions = {1},
207 .numberOfConsumers = 1,
208 .scale = 0.0f,
209 .zeroPoint = 0,
210 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
211 .channelQuant = {},
212 .isIgnored = false,
213 .data = TestBuffer::createFromVector<float>({2.0f})
214 }, { // output
215 .type = TestOperandType::TENSOR_FLOAT32,
216 .dimensions = {2, 1},
217 .numberOfConsumers = 0,
218 .scale = 0.0f,
219 .zeroPoint = 0,
220 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
221 .channelQuant = {},
222 .isIgnored = false,
223 .data = TestBuffer::createFromVector<float>({4.0f, 9.0f})
224 }},
225 .operations = {{
226 .type = TestOperationType::POW,
227 .inputs = {0, 1},
228 .outputs = {2}
229 }},
230 .inputIndexes = {0, 1},
231 .outputIndexes = {2}
232 },
233 .referenced = {},
234 .isRelaxed = true,
235 .expectedMultinomialDistributionTolerance = 0,
236 .expectFailure = false,
237 .minSupportedVersion = TestHalVersion::UNKNOWN
238 };
239 return model;
240 }
241
242 const auto dummy_test_model_relaxed = TestModelManager::get().add("pow_relaxed", get_test_model_relaxed());
243
244 } // namespace generated_tests::pow
245
246 namespace generated_tests::pow {
247
get_test_model_relaxed_all_inputs_as_internal()248 const TestModel& get_test_model_relaxed_all_inputs_as_internal() {
249 static TestModel model = {
250 .main = {
251 .operands = {{ // base
252 .type = TestOperandType::TENSOR_FLOAT32,
253 .dimensions = {2, 1},
254 .numberOfConsumers = 1,
255 .scale = 0.0f,
256 .zeroPoint = 0,
257 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
258 .channelQuant = {},
259 .isIgnored = false,
260 .data = TestBuffer::createFromVector<float>({})
261 }, { // exponent
262 .type = TestOperandType::TENSOR_FLOAT32,
263 .dimensions = {1},
264 .numberOfConsumers = 1,
265 .scale = 0.0f,
266 .zeroPoint = 0,
267 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
268 .channelQuant = {},
269 .isIgnored = false,
270 .data = TestBuffer::createFromVector<float>({})
271 }, { // output
272 .type = TestOperandType::TENSOR_FLOAT32,
273 .dimensions = {2, 1},
274 .numberOfConsumers = 0,
275 .scale = 0.0f,
276 .zeroPoint = 0,
277 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
278 .channelQuant = {},
279 .isIgnored = false,
280 .data = TestBuffer::createFromVector<float>({4.0f, 9.0f})
281 }, { // base_new
282 .type = TestOperandType::TENSOR_FLOAT32,
283 .dimensions = {2, 1},
284 .numberOfConsumers = 1,
285 .scale = 0.0f,
286 .zeroPoint = 0,
287 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
288 .channelQuant = {},
289 .isIgnored = false,
290 .data = TestBuffer::createFromVector<float>({2.0f, 3.0f})
291 }, { // placeholder2
292 .type = TestOperandType::TENSOR_FLOAT32,
293 .dimensions = {1},
294 .numberOfConsumers = 1,
295 .scale = 0.0f,
296 .zeroPoint = 0,
297 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
298 .channelQuant = {},
299 .isIgnored = false,
300 .data = TestBuffer::createFromVector<float>({0.0f})
301 }, { // param2
302 .type = TestOperandType::INT32,
303 .dimensions = {},
304 .numberOfConsumers = 1,
305 .scale = 0.0f,
306 .zeroPoint = 0,
307 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
308 .channelQuant = {},
309 .isIgnored = false,
310 .data = TestBuffer::createFromVector<int32_t>({0})
311 }, { // exponent_new
312 .type = TestOperandType::TENSOR_FLOAT32,
313 .dimensions = {1},
314 .numberOfConsumers = 1,
315 .scale = 0.0f,
316 .zeroPoint = 0,
317 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
318 .channelQuant = {},
319 .isIgnored = false,
320 .data = TestBuffer::createFromVector<float>({2.0f})
321 }, { // placeholder3
322 .type = TestOperandType::TENSOR_FLOAT32,
323 .dimensions = {1},
324 .numberOfConsumers = 1,
325 .scale = 0.0f,
326 .zeroPoint = 0,
327 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
328 .channelQuant = {},
329 .isIgnored = false,
330 .data = TestBuffer::createFromVector<float>({0.0f})
331 }, { // param3
332 .type = TestOperandType::INT32,
333 .dimensions = {},
334 .numberOfConsumers = 1,
335 .scale = 0.0f,
336 .zeroPoint = 0,
337 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
338 .channelQuant = {},
339 .isIgnored = false,
340 .data = TestBuffer::createFromVector<int32_t>({0})
341 }},
342 .operations = {{
343 .type = TestOperationType::ADD,
344 .inputs = {3, 4, 5},
345 .outputs = {0}
346 }, {
347 .type = TestOperationType::ADD,
348 .inputs = {6, 7, 8},
349 .outputs = {1}
350 }, {
351 .type = TestOperationType::POW,
352 .inputs = {0, 1},
353 .outputs = {2}
354 }},
355 .inputIndexes = {3, 6},
356 .outputIndexes = {2}
357 },
358 .referenced = {},
359 .isRelaxed = true,
360 .expectedMultinomialDistributionTolerance = 0,
361 .expectFailure = false,
362 .minSupportedVersion = TestHalVersion::UNKNOWN
363 };
364 return model;
365 }
366
367 const auto dummy_test_model_relaxed_all_inputs_as_internal = TestModelManager::get().add("pow_relaxed_all_inputs_as_internal", get_test_model_relaxed_all_inputs_as_internal());
368
369 } // namespace generated_tests::pow
370
371 namespace generated_tests::pow {
372
get_test_model_float16()373 const TestModel& get_test_model_float16() {
374 static TestModel model = {
375 .main = {
376 .operands = {{ // base
377 .type = TestOperandType::TENSOR_FLOAT16,
378 .dimensions = {2, 1},
379 .numberOfConsumers = 1,
380 .scale = 0.0f,
381 .zeroPoint = 0,
382 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
383 .channelQuant = {},
384 .isIgnored = false,
385 .data = TestBuffer::createFromVector<_Float16>({2.0f, 3.0f})
386 }, { // exponent
387 .type = TestOperandType::TENSOR_FLOAT16,
388 .dimensions = {1},
389 .numberOfConsumers = 1,
390 .scale = 0.0f,
391 .zeroPoint = 0,
392 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
393 .channelQuant = {},
394 .isIgnored = false,
395 .data = TestBuffer::createFromVector<_Float16>({2.0f})
396 }, { // output
397 .type = TestOperandType::TENSOR_FLOAT16,
398 .dimensions = {2, 1},
399 .numberOfConsumers = 0,
400 .scale = 0.0f,
401 .zeroPoint = 0,
402 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
403 .channelQuant = {},
404 .isIgnored = false,
405 .data = TestBuffer::createFromVector<_Float16>({4.0f, 9.0f})
406 }},
407 .operations = {{
408 .type = TestOperationType::POW,
409 .inputs = {0, 1},
410 .outputs = {2}
411 }},
412 .inputIndexes = {0, 1},
413 .outputIndexes = {2}
414 },
415 .referenced = {},
416 .isRelaxed = false,
417 .expectedMultinomialDistributionTolerance = 0,
418 .expectFailure = false,
419 .minSupportedVersion = TestHalVersion::V1_2
420 };
421 return model;
422 }
423
424 const auto dummy_test_model_float16 = TestModelManager::get().add("pow_float16", get_test_model_float16());
425
426 } // namespace generated_tests::pow
427
428 namespace generated_tests::pow {
429
get_test_model_float16_all_inputs_as_internal()430 const TestModel& get_test_model_float16_all_inputs_as_internal() {
431 static TestModel model = {
432 .main = {
433 .operands = {{ // base
434 .type = TestOperandType::TENSOR_FLOAT16,
435 .dimensions = {2, 1},
436 .numberOfConsumers = 1,
437 .scale = 0.0f,
438 .zeroPoint = 0,
439 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
440 .channelQuant = {},
441 .isIgnored = false,
442 .data = TestBuffer::createFromVector<_Float16>({})
443 }, { // exponent
444 .type = TestOperandType::TENSOR_FLOAT16,
445 .dimensions = {1},
446 .numberOfConsumers = 1,
447 .scale = 0.0f,
448 .zeroPoint = 0,
449 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
450 .channelQuant = {},
451 .isIgnored = false,
452 .data = TestBuffer::createFromVector<_Float16>({})
453 }, { // output
454 .type = TestOperandType::TENSOR_FLOAT16,
455 .dimensions = {2, 1},
456 .numberOfConsumers = 0,
457 .scale = 0.0f,
458 .zeroPoint = 0,
459 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
460 .channelQuant = {},
461 .isIgnored = false,
462 .data = TestBuffer::createFromVector<_Float16>({4.0f, 9.0f})
463 }, { // base_new
464 .type = TestOperandType::TENSOR_FLOAT16,
465 .dimensions = {2, 1},
466 .numberOfConsumers = 1,
467 .scale = 0.0f,
468 .zeroPoint = 0,
469 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
470 .channelQuant = {},
471 .isIgnored = false,
472 .data = TestBuffer::createFromVector<_Float16>({2.0f, 3.0f})
473 }, { // placeholder4
474 .type = TestOperandType::TENSOR_FLOAT16,
475 .dimensions = {1},
476 .numberOfConsumers = 1,
477 .scale = 0.0f,
478 .zeroPoint = 0,
479 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
480 .channelQuant = {},
481 .isIgnored = false,
482 .data = TestBuffer::createFromVector<_Float16>({0.0f})
483 }, { // param4
484 .type = TestOperandType::INT32,
485 .dimensions = {},
486 .numberOfConsumers = 1,
487 .scale = 0.0f,
488 .zeroPoint = 0,
489 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
490 .channelQuant = {},
491 .isIgnored = false,
492 .data = TestBuffer::createFromVector<int32_t>({0})
493 }, { // exponent_new
494 .type = TestOperandType::TENSOR_FLOAT16,
495 .dimensions = {1},
496 .numberOfConsumers = 1,
497 .scale = 0.0f,
498 .zeroPoint = 0,
499 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
500 .channelQuant = {},
501 .isIgnored = false,
502 .data = TestBuffer::createFromVector<_Float16>({2.0f})
503 }, { // placeholder5
504 .type = TestOperandType::TENSOR_FLOAT16,
505 .dimensions = {1},
506 .numberOfConsumers = 1,
507 .scale = 0.0f,
508 .zeroPoint = 0,
509 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
510 .channelQuant = {},
511 .isIgnored = false,
512 .data = TestBuffer::createFromVector<_Float16>({0.0f})
513 }, { // param5
514 .type = TestOperandType::INT32,
515 .dimensions = {},
516 .numberOfConsumers = 1,
517 .scale = 0.0f,
518 .zeroPoint = 0,
519 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
520 .channelQuant = {},
521 .isIgnored = false,
522 .data = TestBuffer::createFromVector<int32_t>({0})
523 }},
524 .operations = {{
525 .type = TestOperationType::ADD,
526 .inputs = {3, 4, 5},
527 .outputs = {0}
528 }, {
529 .type = TestOperationType::ADD,
530 .inputs = {6, 7, 8},
531 .outputs = {1}
532 }, {
533 .type = TestOperationType::POW,
534 .inputs = {0, 1},
535 .outputs = {2}
536 }},
537 .inputIndexes = {3, 6},
538 .outputIndexes = {2}
539 },
540 .referenced = {},
541 .isRelaxed = false,
542 .expectedMultinomialDistributionTolerance = 0,
543 .expectFailure = false,
544 .minSupportedVersion = TestHalVersion::V1_2
545 };
546 return model;
547 }
548
549 const auto dummy_test_model_float16_all_inputs_as_internal = TestModelManager::get().add("pow_float16_all_inputs_as_internal", get_test_model_float16_all_inputs_as_internal());
550
551 } // namespace generated_tests::pow
552
553 namespace generated_tests::pow {
554
get_test_model_2()555 const TestModel& get_test_model_2() {
556 static TestModel model = {
557 .main = {
558 .operands = {{ // base
559 .type = TestOperandType::TENSOR_FLOAT32,
560 .dimensions = {2, 1},
561 .numberOfConsumers = 1,
562 .scale = 0.0f,
563 .zeroPoint = 0,
564 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
565 .channelQuant = {},
566 .isIgnored = false,
567 .data = TestBuffer::createFromVector<float>({2.0f, 3.0f})
568 }, { // exponent1
569 .type = TestOperandType::TENSOR_FLOAT32,
570 .dimensions = {1, 2},
571 .numberOfConsumers = 1,
572 .scale = 0.0f,
573 .zeroPoint = 0,
574 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
575 .channelQuant = {},
576 .isIgnored = false,
577 .data = TestBuffer::createFromVector<float>({2.0f, 3.0f})
578 }, { // output1
579 .type = TestOperandType::TENSOR_FLOAT32,
580 .dimensions = {2, 2},
581 .numberOfConsumers = 0,
582 .scale = 0.0f,
583 .zeroPoint = 0,
584 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
585 .channelQuant = {},
586 .isIgnored = false,
587 .data = TestBuffer::createFromVector<float>({4.0f, 8.0f, 9.0f, 27.0f})
588 }},
589 .operations = {{
590 .type = TestOperationType::POW,
591 .inputs = {0, 1},
592 .outputs = {2}
593 }},
594 .inputIndexes = {0, 1},
595 .outputIndexes = {2}
596 },
597 .referenced = {},
598 .isRelaxed = false,
599 .expectedMultinomialDistributionTolerance = 0,
600 .expectFailure = false,
601 .minSupportedVersion = TestHalVersion::V1_2
602 };
603 return model;
604 }
605
606 const auto dummy_test_model_2 = TestModelManager::get().add("pow_2", get_test_model_2());
607
608 } // namespace generated_tests::pow
609
610 namespace generated_tests::pow {
611
get_test_model_all_inputs_as_internal_2()612 const TestModel& get_test_model_all_inputs_as_internal_2() {
613 static TestModel model = {
614 .main = {
615 .operands = {{ // base
616 .type = TestOperandType::TENSOR_FLOAT32,
617 .dimensions = {2, 1},
618 .numberOfConsumers = 1,
619 .scale = 0.0f,
620 .zeroPoint = 0,
621 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
622 .channelQuant = {},
623 .isIgnored = false,
624 .data = TestBuffer::createFromVector<float>({})
625 }, { // exponent1
626 .type = TestOperandType::TENSOR_FLOAT32,
627 .dimensions = {1, 2},
628 .numberOfConsumers = 1,
629 .scale = 0.0f,
630 .zeroPoint = 0,
631 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
632 .channelQuant = {},
633 .isIgnored = false,
634 .data = TestBuffer::createFromVector<float>({})
635 }, { // output1
636 .type = TestOperandType::TENSOR_FLOAT32,
637 .dimensions = {2, 2},
638 .numberOfConsumers = 0,
639 .scale = 0.0f,
640 .zeroPoint = 0,
641 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
642 .channelQuant = {},
643 .isIgnored = false,
644 .data = TestBuffer::createFromVector<float>({4.0f, 8.0f, 9.0f, 27.0f})
645 }, { // base_new
646 .type = TestOperandType::TENSOR_FLOAT32,
647 .dimensions = {2, 1},
648 .numberOfConsumers = 1,
649 .scale = 0.0f,
650 .zeroPoint = 0,
651 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
652 .channelQuant = {},
653 .isIgnored = false,
654 .data = TestBuffer::createFromVector<float>({2.0f, 3.0f})
655 }, { // placeholder6
656 .type = TestOperandType::TENSOR_FLOAT32,
657 .dimensions = {1},
658 .numberOfConsumers = 1,
659 .scale = 0.0f,
660 .zeroPoint = 0,
661 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
662 .channelQuant = {},
663 .isIgnored = false,
664 .data = TestBuffer::createFromVector<float>({0.0f})
665 }, { // param6
666 .type = TestOperandType::INT32,
667 .dimensions = {},
668 .numberOfConsumers = 1,
669 .scale = 0.0f,
670 .zeroPoint = 0,
671 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
672 .channelQuant = {},
673 .isIgnored = false,
674 .data = TestBuffer::createFromVector<int32_t>({0})
675 }, { // exponent1_new
676 .type = TestOperandType::TENSOR_FLOAT32,
677 .dimensions = {1, 2},
678 .numberOfConsumers = 1,
679 .scale = 0.0f,
680 .zeroPoint = 0,
681 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
682 .channelQuant = {},
683 .isIgnored = false,
684 .data = TestBuffer::createFromVector<float>({2.0f, 3.0f})
685 }, { // placeholder7
686 .type = TestOperandType::TENSOR_FLOAT32,
687 .dimensions = {1},
688 .numberOfConsumers = 1,
689 .scale = 0.0f,
690 .zeroPoint = 0,
691 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
692 .channelQuant = {},
693 .isIgnored = false,
694 .data = TestBuffer::createFromVector<float>({0.0f})
695 }, { // param7
696 .type = TestOperandType::INT32,
697 .dimensions = {},
698 .numberOfConsumers = 1,
699 .scale = 0.0f,
700 .zeroPoint = 0,
701 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
702 .channelQuant = {},
703 .isIgnored = false,
704 .data = TestBuffer::createFromVector<int32_t>({0})
705 }},
706 .operations = {{
707 .type = TestOperationType::ADD,
708 .inputs = {3, 4, 5},
709 .outputs = {0}
710 }, {
711 .type = TestOperationType::ADD,
712 .inputs = {6, 7, 8},
713 .outputs = {1}
714 }, {
715 .type = TestOperationType::POW,
716 .inputs = {0, 1},
717 .outputs = {2}
718 }},
719 .inputIndexes = {3, 6},
720 .outputIndexes = {2}
721 },
722 .referenced = {},
723 .isRelaxed = false,
724 .expectedMultinomialDistributionTolerance = 0,
725 .expectFailure = false,
726 .minSupportedVersion = TestHalVersion::V1_2
727 };
728 return model;
729 }
730
731 const auto dummy_test_model_all_inputs_as_internal_2 = TestModelManager::get().add("pow_all_inputs_as_internal_2", get_test_model_all_inputs_as_internal_2());
732
733 } // namespace generated_tests::pow
734
735 namespace generated_tests::pow {
736
get_test_model_relaxed_2()737 const TestModel& get_test_model_relaxed_2() {
738 static TestModel model = {
739 .main = {
740 .operands = {{ // base
741 .type = TestOperandType::TENSOR_FLOAT32,
742 .dimensions = {2, 1},
743 .numberOfConsumers = 1,
744 .scale = 0.0f,
745 .zeroPoint = 0,
746 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
747 .channelQuant = {},
748 .isIgnored = false,
749 .data = TestBuffer::createFromVector<float>({2.0f, 3.0f})
750 }, { // exponent1
751 .type = TestOperandType::TENSOR_FLOAT32,
752 .dimensions = {1, 2},
753 .numberOfConsumers = 1,
754 .scale = 0.0f,
755 .zeroPoint = 0,
756 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
757 .channelQuant = {},
758 .isIgnored = false,
759 .data = TestBuffer::createFromVector<float>({2.0f, 3.0f})
760 }, { // output1
761 .type = TestOperandType::TENSOR_FLOAT32,
762 .dimensions = {2, 2},
763 .numberOfConsumers = 0,
764 .scale = 0.0f,
765 .zeroPoint = 0,
766 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
767 .channelQuant = {},
768 .isIgnored = false,
769 .data = TestBuffer::createFromVector<float>({4.0f, 8.0f, 9.0f, 27.0f})
770 }},
771 .operations = {{
772 .type = TestOperationType::POW,
773 .inputs = {0, 1},
774 .outputs = {2}
775 }},
776 .inputIndexes = {0, 1},
777 .outputIndexes = {2}
778 },
779 .referenced = {},
780 .isRelaxed = true,
781 .expectedMultinomialDistributionTolerance = 0,
782 .expectFailure = false,
783 .minSupportedVersion = TestHalVersion::UNKNOWN
784 };
785 return model;
786 }
787
788 const auto dummy_test_model_relaxed_2 = TestModelManager::get().add("pow_relaxed_2", get_test_model_relaxed_2());
789
790 } // namespace generated_tests::pow
791
792 namespace generated_tests::pow {
793
get_test_model_relaxed_all_inputs_as_internal_2()794 const TestModel& get_test_model_relaxed_all_inputs_as_internal_2() {
795 static TestModel model = {
796 .main = {
797 .operands = {{ // base
798 .type = TestOperandType::TENSOR_FLOAT32,
799 .dimensions = {2, 1},
800 .numberOfConsumers = 1,
801 .scale = 0.0f,
802 .zeroPoint = 0,
803 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
804 .channelQuant = {},
805 .isIgnored = false,
806 .data = TestBuffer::createFromVector<float>({})
807 }, { // exponent1
808 .type = TestOperandType::TENSOR_FLOAT32,
809 .dimensions = {1, 2},
810 .numberOfConsumers = 1,
811 .scale = 0.0f,
812 .zeroPoint = 0,
813 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
814 .channelQuant = {},
815 .isIgnored = false,
816 .data = TestBuffer::createFromVector<float>({})
817 }, { // output1
818 .type = TestOperandType::TENSOR_FLOAT32,
819 .dimensions = {2, 2},
820 .numberOfConsumers = 0,
821 .scale = 0.0f,
822 .zeroPoint = 0,
823 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
824 .channelQuant = {},
825 .isIgnored = false,
826 .data = TestBuffer::createFromVector<float>({4.0f, 8.0f, 9.0f, 27.0f})
827 }, { // base_new
828 .type = TestOperandType::TENSOR_FLOAT32,
829 .dimensions = {2, 1},
830 .numberOfConsumers = 1,
831 .scale = 0.0f,
832 .zeroPoint = 0,
833 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
834 .channelQuant = {},
835 .isIgnored = false,
836 .data = TestBuffer::createFromVector<float>({2.0f, 3.0f})
837 }, { // placeholder8
838 .type = TestOperandType::TENSOR_FLOAT32,
839 .dimensions = {1},
840 .numberOfConsumers = 1,
841 .scale = 0.0f,
842 .zeroPoint = 0,
843 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
844 .channelQuant = {},
845 .isIgnored = false,
846 .data = TestBuffer::createFromVector<float>({0.0f})
847 }, { // param8
848 .type = TestOperandType::INT32,
849 .dimensions = {},
850 .numberOfConsumers = 1,
851 .scale = 0.0f,
852 .zeroPoint = 0,
853 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
854 .channelQuant = {},
855 .isIgnored = false,
856 .data = TestBuffer::createFromVector<int32_t>({0})
857 }, { // exponent1_new
858 .type = TestOperandType::TENSOR_FLOAT32,
859 .dimensions = {1, 2},
860 .numberOfConsumers = 1,
861 .scale = 0.0f,
862 .zeroPoint = 0,
863 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
864 .channelQuant = {},
865 .isIgnored = false,
866 .data = TestBuffer::createFromVector<float>({2.0f, 3.0f})
867 }, { // placeholder9
868 .type = TestOperandType::TENSOR_FLOAT32,
869 .dimensions = {1},
870 .numberOfConsumers = 1,
871 .scale = 0.0f,
872 .zeroPoint = 0,
873 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
874 .channelQuant = {},
875 .isIgnored = false,
876 .data = TestBuffer::createFromVector<float>({0.0f})
877 }, { // param9
878 .type = TestOperandType::INT32,
879 .dimensions = {},
880 .numberOfConsumers = 1,
881 .scale = 0.0f,
882 .zeroPoint = 0,
883 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
884 .channelQuant = {},
885 .isIgnored = false,
886 .data = TestBuffer::createFromVector<int32_t>({0})
887 }},
888 .operations = {{
889 .type = TestOperationType::ADD,
890 .inputs = {3, 4, 5},
891 .outputs = {0}
892 }, {
893 .type = TestOperationType::ADD,
894 .inputs = {6, 7, 8},
895 .outputs = {1}
896 }, {
897 .type = TestOperationType::POW,
898 .inputs = {0, 1},
899 .outputs = {2}
900 }},
901 .inputIndexes = {3, 6},
902 .outputIndexes = {2}
903 },
904 .referenced = {},
905 .isRelaxed = true,
906 .expectedMultinomialDistributionTolerance = 0,
907 .expectFailure = false,
908 .minSupportedVersion = TestHalVersion::UNKNOWN
909 };
910 return model;
911 }
912
913 const auto dummy_test_model_relaxed_all_inputs_as_internal_2 = TestModelManager::get().add("pow_relaxed_all_inputs_as_internal_2", get_test_model_relaxed_all_inputs_as_internal_2());
914
915 } // namespace generated_tests::pow
916
917 namespace generated_tests::pow {
918
get_test_model_float16_2()919 const TestModel& get_test_model_float16_2() {
920 static TestModel model = {
921 .main = {
922 .operands = {{ // base
923 .type = TestOperandType::TENSOR_FLOAT16,
924 .dimensions = {2, 1},
925 .numberOfConsumers = 1,
926 .scale = 0.0f,
927 .zeroPoint = 0,
928 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
929 .channelQuant = {},
930 .isIgnored = false,
931 .data = TestBuffer::createFromVector<_Float16>({2.0f, 3.0f})
932 }, { // exponent1
933 .type = TestOperandType::TENSOR_FLOAT16,
934 .dimensions = {1, 2},
935 .numberOfConsumers = 1,
936 .scale = 0.0f,
937 .zeroPoint = 0,
938 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
939 .channelQuant = {},
940 .isIgnored = false,
941 .data = TestBuffer::createFromVector<_Float16>({2.0f, 3.0f})
942 }, { // output1
943 .type = TestOperandType::TENSOR_FLOAT16,
944 .dimensions = {2, 2},
945 .numberOfConsumers = 0,
946 .scale = 0.0f,
947 .zeroPoint = 0,
948 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
949 .channelQuant = {},
950 .isIgnored = false,
951 .data = TestBuffer::createFromVector<_Float16>({4.0f, 8.0f, 9.0f, 27.0f})
952 }},
953 .operations = {{
954 .type = TestOperationType::POW,
955 .inputs = {0, 1},
956 .outputs = {2}
957 }},
958 .inputIndexes = {0, 1},
959 .outputIndexes = {2}
960 },
961 .referenced = {},
962 .isRelaxed = false,
963 .expectedMultinomialDistributionTolerance = 0,
964 .expectFailure = false,
965 .minSupportedVersion = TestHalVersion::V1_2
966 };
967 return model;
968 }
969
970 const auto dummy_test_model_float16_2 = TestModelManager::get().add("pow_float16_2", get_test_model_float16_2());
971
972 } // namespace generated_tests::pow
973
974 namespace generated_tests::pow {
975
get_test_model_float16_all_inputs_as_internal_2()976 const TestModel& get_test_model_float16_all_inputs_as_internal_2() {
977 static TestModel model = {
978 .main = {
979 .operands = {{ // base
980 .type = TestOperandType::TENSOR_FLOAT16,
981 .dimensions = {2, 1},
982 .numberOfConsumers = 1,
983 .scale = 0.0f,
984 .zeroPoint = 0,
985 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
986 .channelQuant = {},
987 .isIgnored = false,
988 .data = TestBuffer::createFromVector<_Float16>({})
989 }, { // exponent1
990 .type = TestOperandType::TENSOR_FLOAT16,
991 .dimensions = {1, 2},
992 .numberOfConsumers = 1,
993 .scale = 0.0f,
994 .zeroPoint = 0,
995 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
996 .channelQuant = {},
997 .isIgnored = false,
998 .data = TestBuffer::createFromVector<_Float16>({})
999 }, { // output1
1000 .type = TestOperandType::TENSOR_FLOAT16,
1001 .dimensions = {2, 2},
1002 .numberOfConsumers = 0,
1003 .scale = 0.0f,
1004 .zeroPoint = 0,
1005 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1006 .channelQuant = {},
1007 .isIgnored = false,
1008 .data = TestBuffer::createFromVector<_Float16>({4.0f, 8.0f, 9.0f, 27.0f})
1009 }, { // base_new
1010 .type = TestOperandType::TENSOR_FLOAT16,
1011 .dimensions = {2, 1},
1012 .numberOfConsumers = 1,
1013 .scale = 0.0f,
1014 .zeroPoint = 0,
1015 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1016 .channelQuant = {},
1017 .isIgnored = false,
1018 .data = TestBuffer::createFromVector<_Float16>({2.0f, 3.0f})
1019 }, { // placeholder10
1020 .type = TestOperandType::TENSOR_FLOAT16,
1021 .dimensions = {1},
1022 .numberOfConsumers = 1,
1023 .scale = 0.0f,
1024 .zeroPoint = 0,
1025 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1026 .channelQuant = {},
1027 .isIgnored = false,
1028 .data = TestBuffer::createFromVector<_Float16>({0.0f})
1029 }, { // param10
1030 .type = TestOperandType::INT32,
1031 .dimensions = {},
1032 .numberOfConsumers = 1,
1033 .scale = 0.0f,
1034 .zeroPoint = 0,
1035 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1036 .channelQuant = {},
1037 .isIgnored = false,
1038 .data = TestBuffer::createFromVector<int32_t>({0})
1039 }, { // exponent1_new
1040 .type = TestOperandType::TENSOR_FLOAT16,
1041 .dimensions = {1, 2},
1042 .numberOfConsumers = 1,
1043 .scale = 0.0f,
1044 .zeroPoint = 0,
1045 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1046 .channelQuant = {},
1047 .isIgnored = false,
1048 .data = TestBuffer::createFromVector<_Float16>({2.0f, 3.0f})
1049 }, { // placeholder11
1050 .type = TestOperandType::TENSOR_FLOAT16,
1051 .dimensions = {1},
1052 .numberOfConsumers = 1,
1053 .scale = 0.0f,
1054 .zeroPoint = 0,
1055 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1056 .channelQuant = {},
1057 .isIgnored = false,
1058 .data = TestBuffer::createFromVector<_Float16>({0.0f})
1059 }, { // param11
1060 .type = TestOperandType::INT32,
1061 .dimensions = {},
1062 .numberOfConsumers = 1,
1063 .scale = 0.0f,
1064 .zeroPoint = 0,
1065 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1066 .channelQuant = {},
1067 .isIgnored = false,
1068 .data = TestBuffer::createFromVector<int32_t>({0})
1069 }},
1070 .operations = {{
1071 .type = TestOperationType::ADD,
1072 .inputs = {3, 4, 5},
1073 .outputs = {0}
1074 }, {
1075 .type = TestOperationType::ADD,
1076 .inputs = {6, 7, 8},
1077 .outputs = {1}
1078 }, {
1079 .type = TestOperationType::POW,
1080 .inputs = {0, 1},
1081 .outputs = {2}
1082 }},
1083 .inputIndexes = {3, 6},
1084 .outputIndexes = {2}
1085 },
1086 .referenced = {},
1087 .isRelaxed = false,
1088 .expectedMultinomialDistributionTolerance = 0,
1089 .expectFailure = false,
1090 .minSupportedVersion = TestHalVersion::V1_2
1091 };
1092 return model;
1093 }
1094
1095 const auto dummy_test_model_float16_all_inputs_as_internal_2 = TestModelManager::get().add("pow_float16_all_inputs_as_internal_2", get_test_model_float16_all_inputs_as_internal_2());
1096
1097 } // namespace generated_tests::pow
1098
1099 namespace generated_tests::pow {
1100
get_test_model_3()1101 const TestModel& get_test_model_3() {
1102 static TestModel model = {
1103 .main = {
1104 .operands = {{ // base
1105 .type = TestOperandType::TENSOR_FLOAT32,
1106 .dimensions = {2, 1},
1107 .numberOfConsumers = 1,
1108 .scale = 0.0f,
1109 .zeroPoint = 0,
1110 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1111 .channelQuant = {},
1112 .isIgnored = false,
1113 .data = TestBuffer::createFromVector<float>({2.0f, 3.0f})
1114 }, { // exponent2
1115 .type = TestOperandType::TENSOR_FLOAT32,
1116 .dimensions = {3, 1, 2},
1117 .numberOfConsumers = 1,
1118 .scale = 0.0f,
1119 .zeroPoint = 0,
1120 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1121 .channelQuant = {},
1122 .isIgnored = false,
1123 .data = TestBuffer::createFromVector<float>({0.0f, 0.5f, 1.0f, 2.0f, 3.0f, 4.0f})
1124 }, { // output2
1125 .type = TestOperandType::TENSOR_FLOAT32,
1126 .dimensions = {3, 2, 2},
1127 .numberOfConsumers = 0,
1128 .scale = 0.0f,
1129 .zeroPoint = 0,
1130 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1131 .channelQuant = {},
1132 .isIgnored = false,
1133 .data = TestBuffer::createFromVector<float>({1.0f, 1.4142135623730951f, 1.0f, 1.7320508075688772f, 2.0f, 4.0f, 3.0f, 9.0f, 8.0f, 16.0f, 27.0f, 81.0f})
1134 }},
1135 .operations = {{
1136 .type = TestOperationType::POW,
1137 .inputs = {0, 1},
1138 .outputs = {2}
1139 }},
1140 .inputIndexes = {0, 1},
1141 .outputIndexes = {2}
1142 },
1143 .referenced = {},
1144 .isRelaxed = false,
1145 .expectedMultinomialDistributionTolerance = 0,
1146 .expectFailure = false,
1147 .minSupportedVersion = TestHalVersion::V1_2
1148 };
1149 return model;
1150 }
1151
1152 const auto dummy_test_model_3 = TestModelManager::get().add("pow_3", get_test_model_3());
1153
1154 } // namespace generated_tests::pow
1155
1156 namespace generated_tests::pow {
1157
get_test_model_all_inputs_as_internal_3()1158 const TestModel& get_test_model_all_inputs_as_internal_3() {
1159 static TestModel model = {
1160 .main = {
1161 .operands = {{ // base
1162 .type = TestOperandType::TENSOR_FLOAT32,
1163 .dimensions = {2, 1},
1164 .numberOfConsumers = 1,
1165 .scale = 0.0f,
1166 .zeroPoint = 0,
1167 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1168 .channelQuant = {},
1169 .isIgnored = false,
1170 .data = TestBuffer::createFromVector<float>({})
1171 }, { // exponent2
1172 .type = TestOperandType::TENSOR_FLOAT32,
1173 .dimensions = {3, 1, 2},
1174 .numberOfConsumers = 1,
1175 .scale = 0.0f,
1176 .zeroPoint = 0,
1177 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1178 .channelQuant = {},
1179 .isIgnored = false,
1180 .data = TestBuffer::createFromVector<float>({})
1181 }, { // output2
1182 .type = TestOperandType::TENSOR_FLOAT32,
1183 .dimensions = {3, 2, 2},
1184 .numberOfConsumers = 0,
1185 .scale = 0.0f,
1186 .zeroPoint = 0,
1187 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1188 .channelQuant = {},
1189 .isIgnored = false,
1190 .data = TestBuffer::createFromVector<float>({1.0f, 1.4142135623730951f, 1.0f, 1.7320508075688772f, 2.0f, 4.0f, 3.0f, 9.0f, 8.0f, 16.0f, 27.0f, 81.0f})
1191 }, { // base_new
1192 .type = TestOperandType::TENSOR_FLOAT32,
1193 .dimensions = {2, 1},
1194 .numberOfConsumers = 1,
1195 .scale = 0.0f,
1196 .zeroPoint = 0,
1197 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1198 .channelQuant = {},
1199 .isIgnored = false,
1200 .data = TestBuffer::createFromVector<float>({2.0f, 3.0f})
1201 }, { // placeholder12
1202 .type = TestOperandType::TENSOR_FLOAT32,
1203 .dimensions = {1},
1204 .numberOfConsumers = 1,
1205 .scale = 0.0f,
1206 .zeroPoint = 0,
1207 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1208 .channelQuant = {},
1209 .isIgnored = false,
1210 .data = TestBuffer::createFromVector<float>({0.0f})
1211 }, { // param12
1212 .type = TestOperandType::INT32,
1213 .dimensions = {},
1214 .numberOfConsumers = 1,
1215 .scale = 0.0f,
1216 .zeroPoint = 0,
1217 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1218 .channelQuant = {},
1219 .isIgnored = false,
1220 .data = TestBuffer::createFromVector<int32_t>({0})
1221 }, { // exponent2_new
1222 .type = TestOperandType::TENSOR_FLOAT32,
1223 .dimensions = {3, 1, 2},
1224 .numberOfConsumers = 1,
1225 .scale = 0.0f,
1226 .zeroPoint = 0,
1227 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1228 .channelQuant = {},
1229 .isIgnored = false,
1230 .data = TestBuffer::createFromVector<float>({0.0f, 0.5f, 1.0f, 2.0f, 3.0f, 4.0f})
1231 }, { // placeholder13
1232 .type = TestOperandType::TENSOR_FLOAT32,
1233 .dimensions = {1},
1234 .numberOfConsumers = 1,
1235 .scale = 0.0f,
1236 .zeroPoint = 0,
1237 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1238 .channelQuant = {},
1239 .isIgnored = false,
1240 .data = TestBuffer::createFromVector<float>({0.0f})
1241 }, { // param13
1242 .type = TestOperandType::INT32,
1243 .dimensions = {},
1244 .numberOfConsumers = 1,
1245 .scale = 0.0f,
1246 .zeroPoint = 0,
1247 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1248 .channelQuant = {},
1249 .isIgnored = false,
1250 .data = TestBuffer::createFromVector<int32_t>({0})
1251 }},
1252 .operations = {{
1253 .type = TestOperationType::ADD,
1254 .inputs = {3, 4, 5},
1255 .outputs = {0}
1256 }, {
1257 .type = TestOperationType::ADD,
1258 .inputs = {6, 7, 8},
1259 .outputs = {1}
1260 }, {
1261 .type = TestOperationType::POW,
1262 .inputs = {0, 1},
1263 .outputs = {2}
1264 }},
1265 .inputIndexes = {3, 6},
1266 .outputIndexes = {2}
1267 },
1268 .referenced = {},
1269 .isRelaxed = false,
1270 .expectedMultinomialDistributionTolerance = 0,
1271 .expectFailure = false,
1272 .minSupportedVersion = TestHalVersion::V1_2
1273 };
1274 return model;
1275 }
1276
1277 const auto dummy_test_model_all_inputs_as_internal_3 = TestModelManager::get().add("pow_all_inputs_as_internal_3", get_test_model_all_inputs_as_internal_3());
1278
1279 } // namespace generated_tests::pow
1280
1281 namespace generated_tests::pow {
1282
get_test_model_relaxed_3()1283 const TestModel& get_test_model_relaxed_3() {
1284 static TestModel model = {
1285 .main = {
1286 .operands = {{ // base
1287 .type = TestOperandType::TENSOR_FLOAT32,
1288 .dimensions = {2, 1},
1289 .numberOfConsumers = 1,
1290 .scale = 0.0f,
1291 .zeroPoint = 0,
1292 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1293 .channelQuant = {},
1294 .isIgnored = false,
1295 .data = TestBuffer::createFromVector<float>({2.0f, 3.0f})
1296 }, { // exponent2
1297 .type = TestOperandType::TENSOR_FLOAT32,
1298 .dimensions = {3, 1, 2},
1299 .numberOfConsumers = 1,
1300 .scale = 0.0f,
1301 .zeroPoint = 0,
1302 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1303 .channelQuant = {},
1304 .isIgnored = false,
1305 .data = TestBuffer::createFromVector<float>({0.0f, 0.5f, 1.0f, 2.0f, 3.0f, 4.0f})
1306 }, { // output2
1307 .type = TestOperandType::TENSOR_FLOAT32,
1308 .dimensions = {3, 2, 2},
1309 .numberOfConsumers = 0,
1310 .scale = 0.0f,
1311 .zeroPoint = 0,
1312 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1313 .channelQuant = {},
1314 .isIgnored = false,
1315 .data = TestBuffer::createFromVector<float>({1.0f, 1.4142135623730951f, 1.0f, 1.7320508075688772f, 2.0f, 4.0f, 3.0f, 9.0f, 8.0f, 16.0f, 27.0f, 81.0f})
1316 }},
1317 .operations = {{
1318 .type = TestOperationType::POW,
1319 .inputs = {0, 1},
1320 .outputs = {2}
1321 }},
1322 .inputIndexes = {0, 1},
1323 .outputIndexes = {2}
1324 },
1325 .referenced = {},
1326 .isRelaxed = true,
1327 .expectedMultinomialDistributionTolerance = 0,
1328 .expectFailure = false,
1329 .minSupportedVersion = TestHalVersion::UNKNOWN
1330 };
1331 return model;
1332 }
1333
1334 const auto dummy_test_model_relaxed_3 = TestModelManager::get().add("pow_relaxed_3", get_test_model_relaxed_3());
1335
1336 } // namespace generated_tests::pow
1337
1338 namespace generated_tests::pow {
1339
get_test_model_relaxed_all_inputs_as_internal_3()1340 const TestModel& get_test_model_relaxed_all_inputs_as_internal_3() {
1341 static TestModel model = {
1342 .main = {
1343 .operands = {{ // base
1344 .type = TestOperandType::TENSOR_FLOAT32,
1345 .dimensions = {2, 1},
1346 .numberOfConsumers = 1,
1347 .scale = 0.0f,
1348 .zeroPoint = 0,
1349 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1350 .channelQuant = {},
1351 .isIgnored = false,
1352 .data = TestBuffer::createFromVector<float>({})
1353 }, { // exponent2
1354 .type = TestOperandType::TENSOR_FLOAT32,
1355 .dimensions = {3, 1, 2},
1356 .numberOfConsumers = 1,
1357 .scale = 0.0f,
1358 .zeroPoint = 0,
1359 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1360 .channelQuant = {},
1361 .isIgnored = false,
1362 .data = TestBuffer::createFromVector<float>({})
1363 }, { // output2
1364 .type = TestOperandType::TENSOR_FLOAT32,
1365 .dimensions = {3, 2, 2},
1366 .numberOfConsumers = 0,
1367 .scale = 0.0f,
1368 .zeroPoint = 0,
1369 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1370 .channelQuant = {},
1371 .isIgnored = false,
1372 .data = TestBuffer::createFromVector<float>({1.0f, 1.4142135623730951f, 1.0f, 1.7320508075688772f, 2.0f, 4.0f, 3.0f, 9.0f, 8.0f, 16.0f, 27.0f, 81.0f})
1373 }, { // base_new
1374 .type = TestOperandType::TENSOR_FLOAT32,
1375 .dimensions = {2, 1},
1376 .numberOfConsumers = 1,
1377 .scale = 0.0f,
1378 .zeroPoint = 0,
1379 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1380 .channelQuant = {},
1381 .isIgnored = false,
1382 .data = TestBuffer::createFromVector<float>({2.0f, 3.0f})
1383 }, { // placeholder14
1384 .type = TestOperandType::TENSOR_FLOAT32,
1385 .dimensions = {1},
1386 .numberOfConsumers = 1,
1387 .scale = 0.0f,
1388 .zeroPoint = 0,
1389 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1390 .channelQuant = {},
1391 .isIgnored = false,
1392 .data = TestBuffer::createFromVector<float>({0.0f})
1393 }, { // param14
1394 .type = TestOperandType::INT32,
1395 .dimensions = {},
1396 .numberOfConsumers = 1,
1397 .scale = 0.0f,
1398 .zeroPoint = 0,
1399 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1400 .channelQuant = {},
1401 .isIgnored = false,
1402 .data = TestBuffer::createFromVector<int32_t>({0})
1403 }, { // exponent2_new
1404 .type = TestOperandType::TENSOR_FLOAT32,
1405 .dimensions = {3, 1, 2},
1406 .numberOfConsumers = 1,
1407 .scale = 0.0f,
1408 .zeroPoint = 0,
1409 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1410 .channelQuant = {},
1411 .isIgnored = false,
1412 .data = TestBuffer::createFromVector<float>({0.0f, 0.5f, 1.0f, 2.0f, 3.0f, 4.0f})
1413 }, { // placeholder15
1414 .type = TestOperandType::TENSOR_FLOAT32,
1415 .dimensions = {1},
1416 .numberOfConsumers = 1,
1417 .scale = 0.0f,
1418 .zeroPoint = 0,
1419 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1420 .channelQuant = {},
1421 .isIgnored = false,
1422 .data = TestBuffer::createFromVector<float>({0.0f})
1423 }, { // param15
1424 .type = TestOperandType::INT32,
1425 .dimensions = {},
1426 .numberOfConsumers = 1,
1427 .scale = 0.0f,
1428 .zeroPoint = 0,
1429 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1430 .channelQuant = {},
1431 .isIgnored = false,
1432 .data = TestBuffer::createFromVector<int32_t>({0})
1433 }},
1434 .operations = {{
1435 .type = TestOperationType::ADD,
1436 .inputs = {3, 4, 5},
1437 .outputs = {0}
1438 }, {
1439 .type = TestOperationType::ADD,
1440 .inputs = {6, 7, 8},
1441 .outputs = {1}
1442 }, {
1443 .type = TestOperationType::POW,
1444 .inputs = {0, 1},
1445 .outputs = {2}
1446 }},
1447 .inputIndexes = {3, 6},
1448 .outputIndexes = {2}
1449 },
1450 .referenced = {},
1451 .isRelaxed = true,
1452 .expectedMultinomialDistributionTolerance = 0,
1453 .expectFailure = false,
1454 .minSupportedVersion = TestHalVersion::UNKNOWN
1455 };
1456 return model;
1457 }
1458
1459 const auto dummy_test_model_relaxed_all_inputs_as_internal_3 = TestModelManager::get().add("pow_relaxed_all_inputs_as_internal_3", get_test_model_relaxed_all_inputs_as_internal_3());
1460
1461 } // namespace generated_tests::pow
1462
1463 namespace generated_tests::pow {
1464
get_test_model_float16_3()1465 const TestModel& get_test_model_float16_3() {
1466 static TestModel model = {
1467 .main = {
1468 .operands = {{ // base
1469 .type = TestOperandType::TENSOR_FLOAT16,
1470 .dimensions = {2, 1},
1471 .numberOfConsumers = 1,
1472 .scale = 0.0f,
1473 .zeroPoint = 0,
1474 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1475 .channelQuant = {},
1476 .isIgnored = false,
1477 .data = TestBuffer::createFromVector<_Float16>({2.0f, 3.0f})
1478 }, { // exponent2
1479 .type = TestOperandType::TENSOR_FLOAT16,
1480 .dimensions = {3, 1, 2},
1481 .numberOfConsumers = 1,
1482 .scale = 0.0f,
1483 .zeroPoint = 0,
1484 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1485 .channelQuant = {},
1486 .isIgnored = false,
1487 .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.5f, 1.0f, 2.0f, 3.0f, 4.0f})
1488 }, { // output2
1489 .type = TestOperandType::TENSOR_FLOAT16,
1490 .dimensions = {3, 2, 2},
1491 .numberOfConsumers = 0,
1492 .scale = 0.0f,
1493 .zeroPoint = 0,
1494 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1495 .channelQuant = {},
1496 .isIgnored = false,
1497 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.4142135381698608f, 1.0f, 1.7320507764816284f, 2.0f, 4.0f, 3.0f, 9.0f, 8.0f, 16.0f, 27.0f, 81.0f})
1498 }},
1499 .operations = {{
1500 .type = TestOperationType::POW,
1501 .inputs = {0, 1},
1502 .outputs = {2}
1503 }},
1504 .inputIndexes = {0, 1},
1505 .outputIndexes = {2}
1506 },
1507 .referenced = {},
1508 .isRelaxed = false,
1509 .expectedMultinomialDistributionTolerance = 0,
1510 .expectFailure = false,
1511 .minSupportedVersion = TestHalVersion::V1_2
1512 };
1513 return model;
1514 }
1515
1516 const auto dummy_test_model_float16_3 = TestModelManager::get().add("pow_float16_3", get_test_model_float16_3());
1517
1518 } // namespace generated_tests::pow
1519
1520 namespace generated_tests::pow {
1521
get_test_model_float16_all_inputs_as_internal_3()1522 const TestModel& get_test_model_float16_all_inputs_as_internal_3() {
1523 static TestModel model = {
1524 .main = {
1525 .operands = {{ // base
1526 .type = TestOperandType::TENSOR_FLOAT16,
1527 .dimensions = {2, 1},
1528 .numberOfConsumers = 1,
1529 .scale = 0.0f,
1530 .zeroPoint = 0,
1531 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1532 .channelQuant = {},
1533 .isIgnored = false,
1534 .data = TestBuffer::createFromVector<_Float16>({})
1535 }, { // exponent2
1536 .type = TestOperandType::TENSOR_FLOAT16,
1537 .dimensions = {3, 1, 2},
1538 .numberOfConsumers = 1,
1539 .scale = 0.0f,
1540 .zeroPoint = 0,
1541 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1542 .channelQuant = {},
1543 .isIgnored = false,
1544 .data = TestBuffer::createFromVector<_Float16>({})
1545 }, { // output2
1546 .type = TestOperandType::TENSOR_FLOAT16,
1547 .dimensions = {3, 2, 2},
1548 .numberOfConsumers = 0,
1549 .scale = 0.0f,
1550 .zeroPoint = 0,
1551 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1552 .channelQuant = {},
1553 .isIgnored = false,
1554 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.4142135381698608f, 1.0f, 1.7320507764816284f, 2.0f, 4.0f, 3.0f, 9.0f, 8.0f, 16.0f, 27.0f, 81.0f})
1555 }, { // base_new
1556 .type = TestOperandType::TENSOR_FLOAT16,
1557 .dimensions = {2, 1},
1558 .numberOfConsumers = 1,
1559 .scale = 0.0f,
1560 .zeroPoint = 0,
1561 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1562 .channelQuant = {},
1563 .isIgnored = false,
1564 .data = TestBuffer::createFromVector<_Float16>({2.0f, 3.0f})
1565 }, { // placeholder16
1566 .type = TestOperandType::TENSOR_FLOAT16,
1567 .dimensions = {1},
1568 .numberOfConsumers = 1,
1569 .scale = 0.0f,
1570 .zeroPoint = 0,
1571 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1572 .channelQuant = {},
1573 .isIgnored = false,
1574 .data = TestBuffer::createFromVector<_Float16>({0.0f})
1575 }, { // param16
1576 .type = TestOperandType::INT32,
1577 .dimensions = {},
1578 .numberOfConsumers = 1,
1579 .scale = 0.0f,
1580 .zeroPoint = 0,
1581 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1582 .channelQuant = {},
1583 .isIgnored = false,
1584 .data = TestBuffer::createFromVector<int32_t>({0})
1585 }, { // exponent2_new
1586 .type = TestOperandType::TENSOR_FLOAT16,
1587 .dimensions = {3, 1, 2},
1588 .numberOfConsumers = 1,
1589 .scale = 0.0f,
1590 .zeroPoint = 0,
1591 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1592 .channelQuant = {},
1593 .isIgnored = false,
1594 .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.5f, 1.0f, 2.0f, 3.0f, 4.0f})
1595 }, { // placeholder17
1596 .type = TestOperandType::TENSOR_FLOAT16,
1597 .dimensions = {1},
1598 .numberOfConsumers = 1,
1599 .scale = 0.0f,
1600 .zeroPoint = 0,
1601 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1602 .channelQuant = {},
1603 .isIgnored = false,
1604 .data = TestBuffer::createFromVector<_Float16>({0.0f})
1605 }, { // param17
1606 .type = TestOperandType::INT32,
1607 .dimensions = {},
1608 .numberOfConsumers = 1,
1609 .scale = 0.0f,
1610 .zeroPoint = 0,
1611 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1612 .channelQuant = {},
1613 .isIgnored = false,
1614 .data = TestBuffer::createFromVector<int32_t>({0})
1615 }},
1616 .operations = {{
1617 .type = TestOperationType::ADD,
1618 .inputs = {3, 4, 5},
1619 .outputs = {0}
1620 }, {
1621 .type = TestOperationType::ADD,
1622 .inputs = {6, 7, 8},
1623 .outputs = {1}
1624 }, {
1625 .type = TestOperationType::POW,
1626 .inputs = {0, 1},
1627 .outputs = {2}
1628 }},
1629 .inputIndexes = {3, 6},
1630 .outputIndexes = {2}
1631 },
1632 .referenced = {},
1633 .isRelaxed = false,
1634 .expectedMultinomialDistributionTolerance = 0,
1635 .expectFailure = false,
1636 .minSupportedVersion = TestHalVersion::V1_2
1637 };
1638 return model;
1639 }
1640
1641 const auto dummy_test_model_float16_all_inputs_as_internal_3 = TestModelManager::get().add("pow_float16_all_inputs_as_internal_3", get_test_model_float16_all_inputs_as_internal_3());
1642
1643 } // namespace generated_tests::pow
1644
1645