1 // clang-format off
2 // Generated file (from: select_v1_2.mod.py). Do not edit
CreateModel(Model * model)3 void CreateModel(Model *model) {
4 OperandType type0(Type::TENSOR_BOOL8, {3});
5 OperandType type1(Type::TENSOR_FLOAT32, {3});
6 // Phase 1, operands
7 auto input0 = model->addOperand(&type0);
8 auto input1 = model->addOperand(&type1);
9 auto input2 = model->addOperand(&type1);
10 auto output0 = model->addOperand(&type1);
11 // Phase 2, operations
12 model->addOperation(ANEURALNETWORKS_SELECT, {input0, input1, input2}, {output0});
13 // Phase 3, inputs and outputs
14 model->identifyInputsAndOutputs(
15 {input0, input1, input2},
16 {output0});
17 assert(model->isValid());
18 }
19
is_ignored(int i)20 inline bool is_ignored(int i) {
21 static std::set<int> ignore = {};
22 return ignore.find(i) != ignore.end();
23 }
24
CreateModel_int32(Model * model)25 void CreateModel_int32(Model *model) {
26 OperandType type0(Type::TENSOR_BOOL8, {3});
27 OperandType type6(Type::TENSOR_INT32, {3});
28 // Phase 1, operands
29 auto input0 = model->addOperand(&type0);
30 auto input1 = model->addOperand(&type6);
31 auto input2 = model->addOperand(&type6);
32 auto output0 = model->addOperand(&type6);
33 // Phase 2, operations
34 model->addOperation(ANEURALNETWORKS_SELECT, {input0, input1, input2}, {output0});
35 // Phase 3, inputs and outputs
36 model->identifyInputsAndOutputs(
37 {input0, input1, input2},
38 {output0});
39 assert(model->isValid());
40 }
41
is_ignored_int32(int i)42 inline bool is_ignored_int32(int i) {
43 static std::set<int> ignore = {};
44 return ignore.find(i) != ignore.end();
45 }
46
CreateModel_float16(Model * model)47 void CreateModel_float16(Model *model) {
48 OperandType type0(Type::TENSOR_BOOL8, {3});
49 OperandType type7(Type::TENSOR_FLOAT16, {3});
50 // Phase 1, operands
51 auto input0 = model->addOperand(&type0);
52 auto input1 = model->addOperand(&type7);
53 auto input2 = model->addOperand(&type7);
54 auto output0 = model->addOperand(&type7);
55 // Phase 2, operations
56 model->addOperation(ANEURALNETWORKS_SELECT, {input0, input1, input2}, {output0});
57 // Phase 3, inputs and outputs
58 model->identifyInputsAndOutputs(
59 {input0, input1, input2},
60 {output0});
61 assert(model->isValid());
62 }
63
is_ignored_float16(int i)64 inline bool is_ignored_float16(int i) {
65 static std::set<int> ignore = {};
66 return ignore.find(i) != ignore.end();
67 }
68
CreateModel_relaxed(Model * model)69 void CreateModel_relaxed(Model *model) {
70 OperandType type0(Type::TENSOR_BOOL8, {3});
71 OperandType type1(Type::TENSOR_FLOAT32, {3});
72 // Phase 1, operands
73 auto input0 = model->addOperand(&type0);
74 auto input1 = model->addOperand(&type1);
75 auto input2 = model->addOperand(&type1);
76 auto output0 = model->addOperand(&type1);
77 // Phase 2, operations
78 model->addOperation(ANEURALNETWORKS_SELECT, {input0, input1, input2}, {output0});
79 // Phase 3, inputs and outputs
80 model->identifyInputsAndOutputs(
81 {input0, input1, input2},
82 {output0});
83 // Phase 4: set relaxed execution
84 model->relaxComputationFloat32toFloat16(true);
85 assert(model->isValid());
86 }
87
is_ignored_relaxed(int i)88 inline bool is_ignored_relaxed(int i) {
89 static std::set<int> ignore = {};
90 return ignore.find(i) != ignore.end();
91 }
92
CreateModel_quant8(Model * model)93 void CreateModel_quant8(Model *model) {
94 OperandType type0(Type::TENSOR_BOOL8, {3});
95 OperandType type10(Type::TENSOR_QUANT8_ASYMM, {3}, 1.0f, 128);
96 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {3}, 1.5f, 129);
97 OperandType type9(Type::TENSOR_QUANT8_ASYMM, {3}, 0.5f, 127);
98 // Phase 1, operands
99 auto input0 = model->addOperand(&type0);
100 auto input1 = model->addOperand(&type8);
101 auto input2 = model->addOperand(&type9);
102 auto output0 = model->addOperand(&type10);
103 // Phase 2, operations
104 model->addOperation(ANEURALNETWORKS_SELECT, {input0, input1, input2}, {output0});
105 // Phase 3, inputs and outputs
106 model->identifyInputsAndOutputs(
107 {input0, input1, input2},
108 {output0});
109 assert(model->isValid());
110 }
111
is_ignored_quant8(int i)112 inline bool is_ignored_quant8(int i) {
113 static std::set<int> ignore = {};
114 return ignore.find(i) != ignore.end();
115 }
116
CreateModel_dynamic_output_shape(Model * model)117 void CreateModel_dynamic_output_shape(Model *model) {
118 OperandType type0(Type::TENSOR_BOOL8, {3});
119 OperandType type1(Type::TENSOR_FLOAT32, {3});
120 OperandType type11(Type::TENSOR_FLOAT32, {0});
121 // Phase 1, operands
122 auto input0 = model->addOperand(&type0);
123 auto input1 = model->addOperand(&type1);
124 auto input2 = model->addOperand(&type1);
125 auto output0 = model->addOperand(&type11);
126 // Phase 2, operations
127 model->addOperation(ANEURALNETWORKS_SELECT, {input0, input1, input2}, {output0});
128 // Phase 3, inputs and outputs
129 model->identifyInputsAndOutputs(
130 {input0, input1, input2},
131 {output0});
132 assert(model->isValid());
133 }
134
is_ignored_dynamic_output_shape(int i)135 inline bool is_ignored_dynamic_output_shape(int i) {
136 static std::set<int> ignore = {};
137 return ignore.find(i) != ignore.end();
138 }
139
CreateModel_dynamic_output_shape_int32(Model * model)140 void CreateModel_dynamic_output_shape_int32(Model *model) {
141 OperandType type0(Type::TENSOR_BOOL8, {3});
142 OperandType type12(Type::TENSOR_INT32, {0});
143 OperandType type6(Type::TENSOR_INT32, {3});
144 // Phase 1, operands
145 auto input0 = model->addOperand(&type0);
146 auto input1 = model->addOperand(&type6);
147 auto input2 = model->addOperand(&type6);
148 auto output0 = model->addOperand(&type12);
149 // Phase 2, operations
150 model->addOperation(ANEURALNETWORKS_SELECT, {input0, input1, input2}, {output0});
151 // Phase 3, inputs and outputs
152 model->identifyInputsAndOutputs(
153 {input0, input1, input2},
154 {output0});
155 assert(model->isValid());
156 }
157
is_ignored_dynamic_output_shape_int32(int i)158 inline bool is_ignored_dynamic_output_shape_int32(int i) {
159 static std::set<int> ignore = {};
160 return ignore.find(i) != ignore.end();
161 }
162
CreateModel_dynamic_output_shape_float16(Model * model)163 void CreateModel_dynamic_output_shape_float16(Model *model) {
164 OperandType type0(Type::TENSOR_BOOL8, {3});
165 OperandType type13(Type::TENSOR_FLOAT16, {0});
166 OperandType type7(Type::TENSOR_FLOAT16, {3});
167 // Phase 1, operands
168 auto input0 = model->addOperand(&type0);
169 auto input1 = model->addOperand(&type7);
170 auto input2 = model->addOperand(&type7);
171 auto output0 = model->addOperand(&type13);
172 // Phase 2, operations
173 model->addOperation(ANEURALNETWORKS_SELECT, {input0, input1, input2}, {output0});
174 // Phase 3, inputs and outputs
175 model->identifyInputsAndOutputs(
176 {input0, input1, input2},
177 {output0});
178 assert(model->isValid());
179 }
180
is_ignored_dynamic_output_shape_float16(int i)181 inline bool is_ignored_dynamic_output_shape_float16(int i) {
182 static std::set<int> ignore = {};
183 return ignore.find(i) != ignore.end();
184 }
185
CreateModel_dynamic_output_shape_relaxed(Model * model)186 void CreateModel_dynamic_output_shape_relaxed(Model *model) {
187 OperandType type0(Type::TENSOR_BOOL8, {3});
188 OperandType type1(Type::TENSOR_FLOAT32, {3});
189 OperandType type11(Type::TENSOR_FLOAT32, {0});
190 // Phase 1, operands
191 auto input0 = model->addOperand(&type0);
192 auto input1 = model->addOperand(&type1);
193 auto input2 = model->addOperand(&type1);
194 auto output0 = model->addOperand(&type11);
195 // Phase 2, operations
196 model->addOperation(ANEURALNETWORKS_SELECT, {input0, input1, input2}, {output0});
197 // Phase 3, inputs and outputs
198 model->identifyInputsAndOutputs(
199 {input0, input1, input2},
200 {output0});
201 // Phase 4: set relaxed execution
202 model->relaxComputationFloat32toFloat16(true);
203 assert(model->isValid());
204 }
205
is_ignored_dynamic_output_shape_relaxed(int i)206 inline bool is_ignored_dynamic_output_shape_relaxed(int i) {
207 static std::set<int> ignore = {};
208 return ignore.find(i) != ignore.end();
209 }
210
CreateModel_dynamic_output_shape_quant8(Model * model)211 void CreateModel_dynamic_output_shape_quant8(Model *model) {
212 OperandType type0(Type::TENSOR_BOOL8, {3});
213 OperandType type14(Type::TENSOR_QUANT8_ASYMM, {0}, 1.0f, 128);
214 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {3}, 1.5f, 129);
215 OperandType type9(Type::TENSOR_QUANT8_ASYMM, {3}, 0.5f, 127);
216 // Phase 1, operands
217 auto input0 = model->addOperand(&type0);
218 auto input1 = model->addOperand(&type8);
219 auto input2 = model->addOperand(&type9);
220 auto output0 = model->addOperand(&type14);
221 // Phase 2, operations
222 model->addOperation(ANEURALNETWORKS_SELECT, {input0, input1, input2}, {output0});
223 // Phase 3, inputs and outputs
224 model->identifyInputsAndOutputs(
225 {input0, input1, input2},
226 {output0});
227 assert(model->isValid());
228 }
229
is_ignored_dynamic_output_shape_quant8(int i)230 inline bool is_ignored_dynamic_output_shape_quant8(int i) {
231 static std::set<int> ignore = {};
232 return ignore.find(i) != ignore.end();
233 }
234
CreateModel_2(Model * model)235 void CreateModel_2(Model *model) {
236 OperandType type2(Type::TENSOR_BOOL8, {2, 2});
237 OperandType type3(Type::TENSOR_FLOAT32, {2, 2});
238 // Phase 1, operands
239 auto input01 = model->addOperand(&type2);
240 auto input11 = model->addOperand(&type3);
241 auto input21 = model->addOperand(&type3);
242 auto output01 = model->addOperand(&type3);
243 // Phase 2, operations
244 model->addOperation(ANEURALNETWORKS_SELECT, {input01, input11, input21}, {output01});
245 // Phase 3, inputs and outputs
246 model->identifyInputsAndOutputs(
247 {input01, input11, input21},
248 {output01});
249 assert(model->isValid());
250 }
251
is_ignored_2(int i)252 inline bool is_ignored_2(int i) {
253 static std::set<int> ignore = {};
254 return ignore.find(i) != ignore.end();
255 }
256
CreateModel_int32_2(Model * model)257 void CreateModel_int32_2(Model *model) {
258 OperandType type15(Type::TENSOR_INT32, {2, 2});
259 OperandType type2(Type::TENSOR_BOOL8, {2, 2});
260 // Phase 1, operands
261 auto input01 = model->addOperand(&type2);
262 auto input11 = model->addOperand(&type15);
263 auto input21 = model->addOperand(&type15);
264 auto output01 = model->addOperand(&type15);
265 // Phase 2, operations
266 model->addOperation(ANEURALNETWORKS_SELECT, {input01, input11, input21}, {output01});
267 // Phase 3, inputs and outputs
268 model->identifyInputsAndOutputs(
269 {input01, input11, input21},
270 {output01});
271 assert(model->isValid());
272 }
273
is_ignored_int32_2(int i)274 inline bool is_ignored_int32_2(int i) {
275 static std::set<int> ignore = {};
276 return ignore.find(i) != ignore.end();
277 }
278
CreateModel_float16_2(Model * model)279 void CreateModel_float16_2(Model *model) {
280 OperandType type16(Type::TENSOR_FLOAT16, {2, 2});
281 OperandType type2(Type::TENSOR_BOOL8, {2, 2});
282 // Phase 1, operands
283 auto input01 = model->addOperand(&type2);
284 auto input11 = model->addOperand(&type16);
285 auto input21 = model->addOperand(&type16);
286 auto output01 = model->addOperand(&type16);
287 // Phase 2, operations
288 model->addOperation(ANEURALNETWORKS_SELECT, {input01, input11, input21}, {output01});
289 // Phase 3, inputs and outputs
290 model->identifyInputsAndOutputs(
291 {input01, input11, input21},
292 {output01});
293 assert(model->isValid());
294 }
295
is_ignored_float16_2(int i)296 inline bool is_ignored_float16_2(int i) {
297 static std::set<int> ignore = {};
298 return ignore.find(i) != ignore.end();
299 }
300
CreateModel_relaxed_2(Model * model)301 void CreateModel_relaxed_2(Model *model) {
302 OperandType type2(Type::TENSOR_BOOL8, {2, 2});
303 OperandType type3(Type::TENSOR_FLOAT32, {2, 2});
304 // Phase 1, operands
305 auto input01 = model->addOperand(&type2);
306 auto input11 = model->addOperand(&type3);
307 auto input21 = model->addOperand(&type3);
308 auto output01 = model->addOperand(&type3);
309 // Phase 2, operations
310 model->addOperation(ANEURALNETWORKS_SELECT, {input01, input11, input21}, {output01});
311 // Phase 3, inputs and outputs
312 model->identifyInputsAndOutputs(
313 {input01, input11, input21},
314 {output01});
315 // Phase 4: set relaxed execution
316 model->relaxComputationFloat32toFloat16(true);
317 assert(model->isValid());
318 }
319
is_ignored_relaxed_2(int i)320 inline bool is_ignored_relaxed_2(int i) {
321 static std::set<int> ignore = {};
322 return ignore.find(i) != ignore.end();
323 }
324
CreateModel_quant8_2(Model * model)325 void CreateModel_quant8_2(Model *model) {
326 OperandType type17(Type::TENSOR_QUANT8_ASYMM, {2, 2}, 1.5f, 129);
327 OperandType type18(Type::TENSOR_QUANT8_ASYMM, {2, 2}, 0.5f, 127);
328 OperandType type19(Type::TENSOR_QUANT8_ASYMM, {2, 2}, 1.0f, 128);
329 OperandType type2(Type::TENSOR_BOOL8, {2, 2});
330 // Phase 1, operands
331 auto input01 = model->addOperand(&type2);
332 auto input11 = model->addOperand(&type17);
333 auto input21 = model->addOperand(&type18);
334 auto output01 = model->addOperand(&type19);
335 // Phase 2, operations
336 model->addOperation(ANEURALNETWORKS_SELECT, {input01, input11, input21}, {output01});
337 // Phase 3, inputs and outputs
338 model->identifyInputsAndOutputs(
339 {input01, input11, input21},
340 {output01});
341 assert(model->isValid());
342 }
343
is_ignored_quant8_2(int i)344 inline bool is_ignored_quant8_2(int i) {
345 static std::set<int> ignore = {};
346 return ignore.find(i) != ignore.end();
347 }
348
CreateModel_dynamic_output_shape_2(Model * model)349 void CreateModel_dynamic_output_shape_2(Model *model) {
350 OperandType type2(Type::TENSOR_BOOL8, {2, 2});
351 OperandType type20(Type::TENSOR_FLOAT32, {0, 0});
352 OperandType type3(Type::TENSOR_FLOAT32, {2, 2});
353 // Phase 1, operands
354 auto input01 = model->addOperand(&type2);
355 auto input11 = model->addOperand(&type3);
356 auto input21 = model->addOperand(&type3);
357 auto output01 = model->addOperand(&type20);
358 // Phase 2, operations
359 model->addOperation(ANEURALNETWORKS_SELECT, {input01, input11, input21}, {output01});
360 // Phase 3, inputs and outputs
361 model->identifyInputsAndOutputs(
362 {input01, input11, input21},
363 {output01});
364 assert(model->isValid());
365 }
366
is_ignored_dynamic_output_shape_2(int i)367 inline bool is_ignored_dynamic_output_shape_2(int i) {
368 static std::set<int> ignore = {};
369 return ignore.find(i) != ignore.end();
370 }
371
CreateModel_dynamic_output_shape_int32_2(Model * model)372 void CreateModel_dynamic_output_shape_int32_2(Model *model) {
373 OperandType type15(Type::TENSOR_INT32, {2, 2});
374 OperandType type2(Type::TENSOR_BOOL8, {2, 2});
375 OperandType type21(Type::TENSOR_INT32, {0, 0});
376 // Phase 1, operands
377 auto input01 = model->addOperand(&type2);
378 auto input11 = model->addOperand(&type15);
379 auto input21 = model->addOperand(&type15);
380 auto output01 = model->addOperand(&type21);
381 // Phase 2, operations
382 model->addOperation(ANEURALNETWORKS_SELECT, {input01, input11, input21}, {output01});
383 // Phase 3, inputs and outputs
384 model->identifyInputsAndOutputs(
385 {input01, input11, input21},
386 {output01});
387 assert(model->isValid());
388 }
389
is_ignored_dynamic_output_shape_int32_2(int i)390 inline bool is_ignored_dynamic_output_shape_int32_2(int i) {
391 static std::set<int> ignore = {};
392 return ignore.find(i) != ignore.end();
393 }
394
CreateModel_dynamic_output_shape_float16_2(Model * model)395 void CreateModel_dynamic_output_shape_float16_2(Model *model) {
396 OperandType type16(Type::TENSOR_FLOAT16, {2, 2});
397 OperandType type2(Type::TENSOR_BOOL8, {2, 2});
398 OperandType type22(Type::TENSOR_FLOAT16, {0, 0});
399 // Phase 1, operands
400 auto input01 = model->addOperand(&type2);
401 auto input11 = model->addOperand(&type16);
402 auto input21 = model->addOperand(&type16);
403 auto output01 = model->addOperand(&type22);
404 // Phase 2, operations
405 model->addOperation(ANEURALNETWORKS_SELECT, {input01, input11, input21}, {output01});
406 // Phase 3, inputs and outputs
407 model->identifyInputsAndOutputs(
408 {input01, input11, input21},
409 {output01});
410 assert(model->isValid());
411 }
412
is_ignored_dynamic_output_shape_float16_2(int i)413 inline bool is_ignored_dynamic_output_shape_float16_2(int i) {
414 static std::set<int> ignore = {};
415 return ignore.find(i) != ignore.end();
416 }
417
CreateModel_dynamic_output_shape_relaxed_2(Model * model)418 void CreateModel_dynamic_output_shape_relaxed_2(Model *model) {
419 OperandType type2(Type::TENSOR_BOOL8, {2, 2});
420 OperandType type20(Type::TENSOR_FLOAT32, {0, 0});
421 OperandType type3(Type::TENSOR_FLOAT32, {2, 2});
422 // Phase 1, operands
423 auto input01 = model->addOperand(&type2);
424 auto input11 = model->addOperand(&type3);
425 auto input21 = model->addOperand(&type3);
426 auto output01 = model->addOperand(&type20);
427 // Phase 2, operations
428 model->addOperation(ANEURALNETWORKS_SELECT, {input01, input11, input21}, {output01});
429 // Phase 3, inputs and outputs
430 model->identifyInputsAndOutputs(
431 {input01, input11, input21},
432 {output01});
433 // Phase 4: set relaxed execution
434 model->relaxComputationFloat32toFloat16(true);
435 assert(model->isValid());
436 }
437
is_ignored_dynamic_output_shape_relaxed_2(int i)438 inline bool is_ignored_dynamic_output_shape_relaxed_2(int i) {
439 static std::set<int> ignore = {};
440 return ignore.find(i) != ignore.end();
441 }
442
CreateModel_dynamic_output_shape_quant8_2(Model * model)443 void CreateModel_dynamic_output_shape_quant8_2(Model *model) {
444 OperandType type17(Type::TENSOR_QUANT8_ASYMM, {2, 2}, 1.5f, 129);
445 OperandType type18(Type::TENSOR_QUANT8_ASYMM, {2, 2}, 0.5f, 127);
446 OperandType type2(Type::TENSOR_BOOL8, {2, 2});
447 OperandType type23(Type::TENSOR_QUANT8_ASYMM, {0, 0}, 1.0f, 128);
448 // Phase 1, operands
449 auto input01 = model->addOperand(&type2);
450 auto input11 = model->addOperand(&type17);
451 auto input21 = model->addOperand(&type18);
452 auto output01 = model->addOperand(&type23);
453 // Phase 2, operations
454 model->addOperation(ANEURALNETWORKS_SELECT, {input01, input11, input21}, {output01});
455 // Phase 3, inputs and outputs
456 model->identifyInputsAndOutputs(
457 {input01, input11, input21},
458 {output01});
459 assert(model->isValid());
460 }
461
is_ignored_dynamic_output_shape_quant8_2(int i)462 inline bool is_ignored_dynamic_output_shape_quant8_2(int i) {
463 static std::set<int> ignore = {};
464 return ignore.find(i) != ignore.end();
465 }
466
CreateModel_3(Model * model)467 void CreateModel_3(Model *model) {
468 OperandType type4(Type::TENSOR_BOOL8, {2, 1, 2, 1, 2});
469 OperandType type5(Type::TENSOR_FLOAT32, {2, 1, 2, 1, 2});
470 // Phase 1, operands
471 auto input02 = model->addOperand(&type4);
472 auto input12 = model->addOperand(&type5);
473 auto input22 = model->addOperand(&type5);
474 auto output02 = model->addOperand(&type5);
475 // Phase 2, operations
476 model->addOperation(ANEURALNETWORKS_SELECT, {input02, input12, input22}, {output02});
477 // Phase 3, inputs and outputs
478 model->identifyInputsAndOutputs(
479 {input02, input12, input22},
480 {output02});
481 assert(model->isValid());
482 }
483
is_ignored_3(int i)484 inline bool is_ignored_3(int i) {
485 static std::set<int> ignore = {};
486 return ignore.find(i) != ignore.end();
487 }
488
CreateModel_int32_3(Model * model)489 void CreateModel_int32_3(Model *model) {
490 OperandType type24(Type::TENSOR_INT32, {2, 1, 2, 1, 2});
491 OperandType type4(Type::TENSOR_BOOL8, {2, 1, 2, 1, 2});
492 // Phase 1, operands
493 auto input02 = model->addOperand(&type4);
494 auto input12 = model->addOperand(&type24);
495 auto input22 = model->addOperand(&type24);
496 auto output02 = model->addOperand(&type24);
497 // Phase 2, operations
498 model->addOperation(ANEURALNETWORKS_SELECT, {input02, input12, input22}, {output02});
499 // Phase 3, inputs and outputs
500 model->identifyInputsAndOutputs(
501 {input02, input12, input22},
502 {output02});
503 assert(model->isValid());
504 }
505
is_ignored_int32_3(int i)506 inline bool is_ignored_int32_3(int i) {
507 static std::set<int> ignore = {};
508 return ignore.find(i) != ignore.end();
509 }
510
CreateModel_float16_3(Model * model)511 void CreateModel_float16_3(Model *model) {
512 OperandType type25(Type::TENSOR_FLOAT16, {2, 1, 2, 1, 2});
513 OperandType type4(Type::TENSOR_BOOL8, {2, 1, 2, 1, 2});
514 // Phase 1, operands
515 auto input02 = model->addOperand(&type4);
516 auto input12 = model->addOperand(&type25);
517 auto input22 = model->addOperand(&type25);
518 auto output02 = model->addOperand(&type25);
519 // Phase 2, operations
520 model->addOperation(ANEURALNETWORKS_SELECT, {input02, input12, input22}, {output02});
521 // Phase 3, inputs and outputs
522 model->identifyInputsAndOutputs(
523 {input02, input12, input22},
524 {output02});
525 assert(model->isValid());
526 }
527
is_ignored_float16_3(int i)528 inline bool is_ignored_float16_3(int i) {
529 static std::set<int> ignore = {};
530 return ignore.find(i) != ignore.end();
531 }
532
CreateModel_relaxed_3(Model * model)533 void CreateModel_relaxed_3(Model *model) {
534 OperandType type4(Type::TENSOR_BOOL8, {2, 1, 2, 1, 2});
535 OperandType type5(Type::TENSOR_FLOAT32, {2, 1, 2, 1, 2});
536 // Phase 1, operands
537 auto input02 = model->addOperand(&type4);
538 auto input12 = model->addOperand(&type5);
539 auto input22 = model->addOperand(&type5);
540 auto output02 = model->addOperand(&type5);
541 // Phase 2, operations
542 model->addOperation(ANEURALNETWORKS_SELECT, {input02, input12, input22}, {output02});
543 // Phase 3, inputs and outputs
544 model->identifyInputsAndOutputs(
545 {input02, input12, input22},
546 {output02});
547 // Phase 4: set relaxed execution
548 model->relaxComputationFloat32toFloat16(true);
549 assert(model->isValid());
550 }
551
is_ignored_relaxed_3(int i)552 inline bool is_ignored_relaxed_3(int i) {
553 static std::set<int> ignore = {};
554 return ignore.find(i) != ignore.end();
555 }
556
CreateModel_quant8_3(Model * model)557 void CreateModel_quant8_3(Model *model) {
558 OperandType type26(Type::TENSOR_QUANT8_ASYMM, {2, 1, 2, 1, 2}, 1.5f, 129);
559 OperandType type27(Type::TENSOR_QUANT8_ASYMM, {2, 1, 2, 1, 2}, 0.5f, 127);
560 OperandType type28(Type::TENSOR_QUANT8_ASYMM, {2, 1, 2, 1, 2}, 1.0f, 128);
561 OperandType type4(Type::TENSOR_BOOL8, {2, 1, 2, 1, 2});
562 // Phase 1, operands
563 auto input02 = model->addOperand(&type4);
564 auto input12 = model->addOperand(&type26);
565 auto input22 = model->addOperand(&type27);
566 auto output02 = model->addOperand(&type28);
567 // Phase 2, operations
568 model->addOperation(ANEURALNETWORKS_SELECT, {input02, input12, input22}, {output02});
569 // Phase 3, inputs and outputs
570 model->identifyInputsAndOutputs(
571 {input02, input12, input22},
572 {output02});
573 assert(model->isValid());
574 }
575
is_ignored_quant8_3(int i)576 inline bool is_ignored_quant8_3(int i) {
577 static std::set<int> ignore = {};
578 return ignore.find(i) != ignore.end();
579 }
580
CreateModel_dynamic_output_shape_3(Model * model)581 void CreateModel_dynamic_output_shape_3(Model *model) {
582 OperandType type29(Type::TENSOR_FLOAT32, {0, 0, 0, 0, 0});
583 OperandType type4(Type::TENSOR_BOOL8, {2, 1, 2, 1, 2});
584 OperandType type5(Type::TENSOR_FLOAT32, {2, 1, 2, 1, 2});
585 // Phase 1, operands
586 auto input02 = model->addOperand(&type4);
587 auto input12 = model->addOperand(&type5);
588 auto input22 = model->addOperand(&type5);
589 auto output02 = model->addOperand(&type29);
590 // Phase 2, operations
591 model->addOperation(ANEURALNETWORKS_SELECT, {input02, input12, input22}, {output02});
592 // Phase 3, inputs and outputs
593 model->identifyInputsAndOutputs(
594 {input02, input12, input22},
595 {output02});
596 assert(model->isValid());
597 }
598
is_ignored_dynamic_output_shape_3(int i)599 inline bool is_ignored_dynamic_output_shape_3(int i) {
600 static std::set<int> ignore = {};
601 return ignore.find(i) != ignore.end();
602 }
603
CreateModel_dynamic_output_shape_int32_3(Model * model)604 void CreateModel_dynamic_output_shape_int32_3(Model *model) {
605 OperandType type24(Type::TENSOR_INT32, {2, 1, 2, 1, 2});
606 OperandType type30(Type::TENSOR_INT32, {0, 0, 0, 0, 0});
607 OperandType type4(Type::TENSOR_BOOL8, {2, 1, 2, 1, 2});
608 // Phase 1, operands
609 auto input02 = model->addOperand(&type4);
610 auto input12 = model->addOperand(&type24);
611 auto input22 = model->addOperand(&type24);
612 auto output02 = model->addOperand(&type30);
613 // Phase 2, operations
614 model->addOperation(ANEURALNETWORKS_SELECT, {input02, input12, input22}, {output02});
615 // Phase 3, inputs and outputs
616 model->identifyInputsAndOutputs(
617 {input02, input12, input22},
618 {output02});
619 assert(model->isValid());
620 }
621
is_ignored_dynamic_output_shape_int32_3(int i)622 inline bool is_ignored_dynamic_output_shape_int32_3(int i) {
623 static std::set<int> ignore = {};
624 return ignore.find(i) != ignore.end();
625 }
626
CreateModel_dynamic_output_shape_float16_3(Model * model)627 void CreateModel_dynamic_output_shape_float16_3(Model *model) {
628 OperandType type25(Type::TENSOR_FLOAT16, {2, 1, 2, 1, 2});
629 OperandType type31(Type::TENSOR_FLOAT16, {0, 0, 0, 0, 0});
630 OperandType type4(Type::TENSOR_BOOL8, {2, 1, 2, 1, 2});
631 // Phase 1, operands
632 auto input02 = model->addOperand(&type4);
633 auto input12 = model->addOperand(&type25);
634 auto input22 = model->addOperand(&type25);
635 auto output02 = model->addOperand(&type31);
636 // Phase 2, operations
637 model->addOperation(ANEURALNETWORKS_SELECT, {input02, input12, input22}, {output02});
638 // Phase 3, inputs and outputs
639 model->identifyInputsAndOutputs(
640 {input02, input12, input22},
641 {output02});
642 assert(model->isValid());
643 }
644
is_ignored_dynamic_output_shape_float16_3(int i)645 inline bool is_ignored_dynamic_output_shape_float16_3(int i) {
646 static std::set<int> ignore = {};
647 return ignore.find(i) != ignore.end();
648 }
649
CreateModel_dynamic_output_shape_relaxed_3(Model * model)650 void CreateModel_dynamic_output_shape_relaxed_3(Model *model) {
651 OperandType type29(Type::TENSOR_FLOAT32, {0, 0, 0, 0, 0});
652 OperandType type4(Type::TENSOR_BOOL8, {2, 1, 2, 1, 2});
653 OperandType type5(Type::TENSOR_FLOAT32, {2, 1, 2, 1, 2});
654 // Phase 1, operands
655 auto input02 = model->addOperand(&type4);
656 auto input12 = model->addOperand(&type5);
657 auto input22 = model->addOperand(&type5);
658 auto output02 = model->addOperand(&type29);
659 // Phase 2, operations
660 model->addOperation(ANEURALNETWORKS_SELECT, {input02, input12, input22}, {output02});
661 // Phase 3, inputs and outputs
662 model->identifyInputsAndOutputs(
663 {input02, input12, input22},
664 {output02});
665 // Phase 4: set relaxed execution
666 model->relaxComputationFloat32toFloat16(true);
667 assert(model->isValid());
668 }
669
is_ignored_dynamic_output_shape_relaxed_3(int i)670 inline bool is_ignored_dynamic_output_shape_relaxed_3(int i) {
671 static std::set<int> ignore = {};
672 return ignore.find(i) != ignore.end();
673 }
674
CreateModel_dynamic_output_shape_quant8_3(Model * model)675 void CreateModel_dynamic_output_shape_quant8_3(Model *model) {
676 OperandType type26(Type::TENSOR_QUANT8_ASYMM, {2, 1, 2, 1, 2}, 1.5f, 129);
677 OperandType type27(Type::TENSOR_QUANT8_ASYMM, {2, 1, 2, 1, 2}, 0.5f, 127);
678 OperandType type32(Type::TENSOR_QUANT8_ASYMM, {0, 0, 0, 0, 0}, 1.0f, 128);
679 OperandType type4(Type::TENSOR_BOOL8, {2, 1, 2, 1, 2});
680 // Phase 1, operands
681 auto input02 = model->addOperand(&type4);
682 auto input12 = model->addOperand(&type26);
683 auto input22 = model->addOperand(&type27);
684 auto output02 = model->addOperand(&type32);
685 // Phase 2, operations
686 model->addOperation(ANEURALNETWORKS_SELECT, {input02, input12, input22}, {output02});
687 // Phase 3, inputs and outputs
688 model->identifyInputsAndOutputs(
689 {input02, input12, input22},
690 {output02});
691 assert(model->isValid());
692 }
693
is_ignored_dynamic_output_shape_quant8_3(int i)694 inline bool is_ignored_dynamic_output_shape_quant8_3(int i) {
695 static std::set<int> ignore = {};
696 return ignore.find(i) != ignore.end();
697 }
698
699