1 // clang-format off
2 // Generated file (from: pow.mod.py). Do not edit
CreateModel(Model * model)3 void CreateModel(Model *model) {
4 OperandType type0(Type::TENSOR_FLOAT32, {2, 1});
5 OperandType type1(Type::TENSOR_FLOAT32, {1});
6 // Phase 1, operands
7 auto base = model->addOperand(&type0);
8 auto exponent = model->addOperand(&type1);
9 auto output = model->addOperand(&type0);
10 // Phase 2, operations
11 model->addOperation(ANEURALNETWORKS_POW, {base, exponent}, {output});
12 // Phase 3, inputs and outputs
13 model->identifyInputsAndOutputs(
14 {base, exponent},
15 {output});
16 assert(model->isValid());
17 }
18
is_ignored(int i)19 inline bool is_ignored(int i) {
20 static std::set<int> ignore = {};
21 return ignore.find(i) != ignore.end();
22 }
23
CreateModel_relaxed(Model * model)24 void CreateModel_relaxed(Model *model) {
25 OperandType type0(Type::TENSOR_FLOAT32, {2, 1});
26 OperandType type1(Type::TENSOR_FLOAT32, {1});
27 // Phase 1, operands
28 auto base = model->addOperand(&type0);
29 auto exponent = model->addOperand(&type1);
30 auto output = model->addOperand(&type0);
31 // Phase 2, operations
32 model->addOperation(ANEURALNETWORKS_POW, {base, exponent}, {output});
33 // Phase 3, inputs and outputs
34 model->identifyInputsAndOutputs(
35 {base, exponent},
36 {output});
37 // Phase 4: set relaxed execution
38 model->relaxComputationFloat32toFloat16(true);
39 assert(model->isValid());
40 }
41
is_ignored_relaxed(int i)42 inline bool is_ignored_relaxed(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 type6(Type::TENSOR_FLOAT16, {2, 1});
49 OperandType type7(Type::TENSOR_FLOAT16, {1});
50 // Phase 1, operands
51 auto base = model->addOperand(&type6);
52 auto exponent = model->addOperand(&type7);
53 auto output = model->addOperand(&type6);
54 // Phase 2, operations
55 model->addOperation(ANEURALNETWORKS_POW, {base, exponent}, {output});
56 // Phase 3, inputs and outputs
57 model->identifyInputsAndOutputs(
58 {base, exponent},
59 {output});
60 assert(model->isValid());
61 }
62
is_ignored_float16(int i)63 inline bool is_ignored_float16(int i) {
64 static std::set<int> ignore = {};
65 return ignore.find(i) != ignore.end();
66 }
67
CreateModel_dynamic_output_shape(Model * model)68 void CreateModel_dynamic_output_shape(Model *model) {
69 OperandType type0(Type::TENSOR_FLOAT32, {2, 1});
70 OperandType type1(Type::TENSOR_FLOAT32, {1});
71 OperandType type8(Type::TENSOR_FLOAT32, {0, 0});
72 // Phase 1, operands
73 auto base = model->addOperand(&type0);
74 auto exponent = model->addOperand(&type1);
75 auto output = model->addOperand(&type8);
76 // Phase 2, operations
77 model->addOperation(ANEURALNETWORKS_POW, {base, exponent}, {output});
78 // Phase 3, inputs and outputs
79 model->identifyInputsAndOutputs(
80 {base, exponent},
81 {output});
82 assert(model->isValid());
83 }
84
is_ignored_dynamic_output_shape(int i)85 inline bool is_ignored_dynamic_output_shape(int i) {
86 static std::set<int> ignore = {};
87 return ignore.find(i) != ignore.end();
88 }
89
CreateModel_dynamic_output_shape_relaxed(Model * model)90 void CreateModel_dynamic_output_shape_relaxed(Model *model) {
91 OperandType type0(Type::TENSOR_FLOAT32, {2, 1});
92 OperandType type1(Type::TENSOR_FLOAT32, {1});
93 OperandType type8(Type::TENSOR_FLOAT32, {0, 0});
94 // Phase 1, operands
95 auto base = model->addOperand(&type0);
96 auto exponent = model->addOperand(&type1);
97 auto output = model->addOperand(&type8);
98 // Phase 2, operations
99 model->addOperation(ANEURALNETWORKS_POW, {base, exponent}, {output});
100 // Phase 3, inputs and outputs
101 model->identifyInputsAndOutputs(
102 {base, exponent},
103 {output});
104 // Phase 4: set relaxed execution
105 model->relaxComputationFloat32toFloat16(true);
106 assert(model->isValid());
107 }
108
is_ignored_dynamic_output_shape_relaxed(int i)109 inline bool is_ignored_dynamic_output_shape_relaxed(int i) {
110 static std::set<int> ignore = {};
111 return ignore.find(i) != ignore.end();
112 }
113
CreateModel_dynamic_output_shape_float16(Model * model)114 void CreateModel_dynamic_output_shape_float16(Model *model) {
115 OperandType type6(Type::TENSOR_FLOAT16, {2, 1});
116 OperandType type7(Type::TENSOR_FLOAT16, {1});
117 OperandType type9(Type::TENSOR_FLOAT16, {0, 0});
118 // Phase 1, operands
119 auto base = model->addOperand(&type6);
120 auto exponent = model->addOperand(&type7);
121 auto output = model->addOperand(&type9);
122 // Phase 2, operations
123 model->addOperation(ANEURALNETWORKS_POW, {base, exponent}, {output});
124 // Phase 3, inputs and outputs
125 model->identifyInputsAndOutputs(
126 {base, exponent},
127 {output});
128 assert(model->isValid());
129 }
130
is_ignored_dynamic_output_shape_float16(int i)131 inline bool is_ignored_dynamic_output_shape_float16(int i) {
132 static std::set<int> ignore = {};
133 return ignore.find(i) != ignore.end();
134 }
135
CreateModel_2(Model * model)136 void CreateModel_2(Model *model) {
137 OperandType type0(Type::TENSOR_FLOAT32, {2, 1});
138 OperandType type2(Type::TENSOR_FLOAT32, {1, 2});
139 OperandType type4(Type::TENSOR_FLOAT32, {2, 2});
140 // Phase 1, operands
141 auto base = model->addOperand(&type0);
142 auto exponent1 = model->addOperand(&type2);
143 auto output1 = model->addOperand(&type4);
144 // Phase 2, operations
145 model->addOperation(ANEURALNETWORKS_POW, {base, exponent1}, {output1});
146 // Phase 3, inputs and outputs
147 model->identifyInputsAndOutputs(
148 {base, exponent1},
149 {output1});
150 assert(model->isValid());
151 }
152
is_ignored_2(int i)153 inline bool is_ignored_2(int i) {
154 static std::set<int> ignore = {};
155 return ignore.find(i) != ignore.end();
156 }
157
CreateModel_relaxed_2(Model * model)158 void CreateModel_relaxed_2(Model *model) {
159 OperandType type0(Type::TENSOR_FLOAT32, {2, 1});
160 OperandType type2(Type::TENSOR_FLOAT32, {1, 2});
161 OperandType type4(Type::TENSOR_FLOAT32, {2, 2});
162 // Phase 1, operands
163 auto base = model->addOperand(&type0);
164 auto exponent1 = model->addOperand(&type2);
165 auto output1 = model->addOperand(&type4);
166 // Phase 2, operations
167 model->addOperation(ANEURALNETWORKS_POW, {base, exponent1}, {output1});
168 // Phase 3, inputs and outputs
169 model->identifyInputsAndOutputs(
170 {base, exponent1},
171 {output1});
172 // Phase 4: set relaxed execution
173 model->relaxComputationFloat32toFloat16(true);
174 assert(model->isValid());
175 }
176
is_ignored_relaxed_2(int i)177 inline bool is_ignored_relaxed_2(int i) {
178 static std::set<int> ignore = {};
179 return ignore.find(i) != ignore.end();
180 }
181
CreateModel_float16_2(Model * model)182 void CreateModel_float16_2(Model *model) {
183 OperandType type10(Type::TENSOR_FLOAT16, {1, 2});
184 OperandType type11(Type::TENSOR_FLOAT16, {2, 2});
185 OperandType type6(Type::TENSOR_FLOAT16, {2, 1});
186 // Phase 1, operands
187 auto base = model->addOperand(&type6);
188 auto exponent1 = model->addOperand(&type10);
189 auto output1 = model->addOperand(&type11);
190 // Phase 2, operations
191 model->addOperation(ANEURALNETWORKS_POW, {base, exponent1}, {output1});
192 // Phase 3, inputs and outputs
193 model->identifyInputsAndOutputs(
194 {base, exponent1},
195 {output1});
196 assert(model->isValid());
197 }
198
is_ignored_float16_2(int i)199 inline bool is_ignored_float16_2(int i) {
200 static std::set<int> ignore = {};
201 return ignore.find(i) != ignore.end();
202 }
203
CreateModel_dynamic_output_shape_2(Model * model)204 void CreateModel_dynamic_output_shape_2(Model *model) {
205 OperandType type0(Type::TENSOR_FLOAT32, {2, 1});
206 OperandType type2(Type::TENSOR_FLOAT32, {1, 2});
207 OperandType type8(Type::TENSOR_FLOAT32, {0, 0});
208 // Phase 1, operands
209 auto base = model->addOperand(&type0);
210 auto exponent1 = model->addOperand(&type2);
211 auto output1 = model->addOperand(&type8);
212 // Phase 2, operations
213 model->addOperation(ANEURALNETWORKS_POW, {base, exponent1}, {output1});
214 // Phase 3, inputs and outputs
215 model->identifyInputsAndOutputs(
216 {base, exponent1},
217 {output1});
218 assert(model->isValid());
219 }
220
is_ignored_dynamic_output_shape_2(int i)221 inline bool is_ignored_dynamic_output_shape_2(int i) {
222 static std::set<int> ignore = {};
223 return ignore.find(i) != ignore.end();
224 }
225
CreateModel_dynamic_output_shape_relaxed_2(Model * model)226 void CreateModel_dynamic_output_shape_relaxed_2(Model *model) {
227 OperandType type0(Type::TENSOR_FLOAT32, {2, 1});
228 OperandType type2(Type::TENSOR_FLOAT32, {1, 2});
229 OperandType type8(Type::TENSOR_FLOAT32, {0, 0});
230 // Phase 1, operands
231 auto base = model->addOperand(&type0);
232 auto exponent1 = model->addOperand(&type2);
233 auto output1 = model->addOperand(&type8);
234 // Phase 2, operations
235 model->addOperation(ANEURALNETWORKS_POW, {base, exponent1}, {output1});
236 // Phase 3, inputs and outputs
237 model->identifyInputsAndOutputs(
238 {base, exponent1},
239 {output1});
240 // Phase 4: set relaxed execution
241 model->relaxComputationFloat32toFloat16(true);
242 assert(model->isValid());
243 }
244
is_ignored_dynamic_output_shape_relaxed_2(int i)245 inline bool is_ignored_dynamic_output_shape_relaxed_2(int i) {
246 static std::set<int> ignore = {};
247 return ignore.find(i) != ignore.end();
248 }
249
CreateModel_dynamic_output_shape_float16_2(Model * model)250 void CreateModel_dynamic_output_shape_float16_2(Model *model) {
251 OperandType type10(Type::TENSOR_FLOAT16, {1, 2});
252 OperandType type6(Type::TENSOR_FLOAT16, {2, 1});
253 OperandType type9(Type::TENSOR_FLOAT16, {0, 0});
254 // Phase 1, operands
255 auto base = model->addOperand(&type6);
256 auto exponent1 = model->addOperand(&type10);
257 auto output1 = model->addOperand(&type9);
258 // Phase 2, operations
259 model->addOperation(ANEURALNETWORKS_POW, {base, exponent1}, {output1});
260 // Phase 3, inputs and outputs
261 model->identifyInputsAndOutputs(
262 {base, exponent1},
263 {output1});
264 assert(model->isValid());
265 }
266
is_ignored_dynamic_output_shape_float16_2(int i)267 inline bool is_ignored_dynamic_output_shape_float16_2(int i) {
268 static std::set<int> ignore = {};
269 return ignore.find(i) != ignore.end();
270 }
271
CreateModel_3(Model * model)272 void CreateModel_3(Model *model) {
273 OperandType type0(Type::TENSOR_FLOAT32, {2, 1});
274 OperandType type3(Type::TENSOR_FLOAT32, {3, 1, 2});
275 OperandType type5(Type::TENSOR_FLOAT32, {3, 2, 2});
276 // Phase 1, operands
277 auto base = model->addOperand(&type0);
278 auto exponent2 = model->addOperand(&type3);
279 auto output2 = model->addOperand(&type5);
280 // Phase 2, operations
281 model->addOperation(ANEURALNETWORKS_POW, {base, exponent2}, {output2});
282 // Phase 3, inputs and outputs
283 model->identifyInputsAndOutputs(
284 {base, exponent2},
285 {output2});
286 assert(model->isValid());
287 }
288
is_ignored_3(int i)289 inline bool is_ignored_3(int i) {
290 static std::set<int> ignore = {};
291 return ignore.find(i) != ignore.end();
292 }
293
CreateModel_relaxed_3(Model * model)294 void CreateModel_relaxed_3(Model *model) {
295 OperandType type0(Type::TENSOR_FLOAT32, {2, 1});
296 OperandType type3(Type::TENSOR_FLOAT32, {3, 1, 2});
297 OperandType type5(Type::TENSOR_FLOAT32, {3, 2, 2});
298 // Phase 1, operands
299 auto base = model->addOperand(&type0);
300 auto exponent2 = model->addOperand(&type3);
301 auto output2 = model->addOperand(&type5);
302 // Phase 2, operations
303 model->addOperation(ANEURALNETWORKS_POW, {base, exponent2}, {output2});
304 // Phase 3, inputs and outputs
305 model->identifyInputsAndOutputs(
306 {base, exponent2},
307 {output2});
308 // Phase 4: set relaxed execution
309 model->relaxComputationFloat32toFloat16(true);
310 assert(model->isValid());
311 }
312
is_ignored_relaxed_3(int i)313 inline bool is_ignored_relaxed_3(int i) {
314 static std::set<int> ignore = {};
315 return ignore.find(i) != ignore.end();
316 }
317
CreateModel_float16_3(Model * model)318 void CreateModel_float16_3(Model *model) {
319 OperandType type12(Type::TENSOR_FLOAT16, {3, 1, 2});
320 OperandType type13(Type::TENSOR_FLOAT16, {3, 2, 2});
321 OperandType type6(Type::TENSOR_FLOAT16, {2, 1});
322 // Phase 1, operands
323 auto base = model->addOperand(&type6);
324 auto exponent2 = model->addOperand(&type12);
325 auto output2 = model->addOperand(&type13);
326 // Phase 2, operations
327 model->addOperation(ANEURALNETWORKS_POW, {base, exponent2}, {output2});
328 // Phase 3, inputs and outputs
329 model->identifyInputsAndOutputs(
330 {base, exponent2},
331 {output2});
332 assert(model->isValid());
333 }
334
is_ignored_float16_3(int i)335 inline bool is_ignored_float16_3(int i) {
336 static std::set<int> ignore = {};
337 return ignore.find(i) != ignore.end();
338 }
339
CreateModel_dynamic_output_shape_3(Model * model)340 void CreateModel_dynamic_output_shape_3(Model *model) {
341 OperandType type0(Type::TENSOR_FLOAT32, {2, 1});
342 OperandType type14(Type::TENSOR_FLOAT32, {0, 0, 0});
343 OperandType type3(Type::TENSOR_FLOAT32, {3, 1, 2});
344 // Phase 1, operands
345 auto base = model->addOperand(&type0);
346 auto exponent2 = model->addOperand(&type3);
347 auto output2 = model->addOperand(&type14);
348 // Phase 2, operations
349 model->addOperation(ANEURALNETWORKS_POW, {base, exponent2}, {output2});
350 // Phase 3, inputs and outputs
351 model->identifyInputsAndOutputs(
352 {base, exponent2},
353 {output2});
354 assert(model->isValid());
355 }
356
is_ignored_dynamic_output_shape_3(int i)357 inline bool is_ignored_dynamic_output_shape_3(int i) {
358 static std::set<int> ignore = {};
359 return ignore.find(i) != ignore.end();
360 }
361
CreateModel_dynamic_output_shape_relaxed_3(Model * model)362 void CreateModel_dynamic_output_shape_relaxed_3(Model *model) {
363 OperandType type0(Type::TENSOR_FLOAT32, {2, 1});
364 OperandType type14(Type::TENSOR_FLOAT32, {0, 0, 0});
365 OperandType type3(Type::TENSOR_FLOAT32, {3, 1, 2});
366 // Phase 1, operands
367 auto base = model->addOperand(&type0);
368 auto exponent2 = model->addOperand(&type3);
369 auto output2 = model->addOperand(&type14);
370 // Phase 2, operations
371 model->addOperation(ANEURALNETWORKS_POW, {base, exponent2}, {output2});
372 // Phase 3, inputs and outputs
373 model->identifyInputsAndOutputs(
374 {base, exponent2},
375 {output2});
376 // Phase 4: set relaxed execution
377 model->relaxComputationFloat32toFloat16(true);
378 assert(model->isValid());
379 }
380
is_ignored_dynamic_output_shape_relaxed_3(int i)381 inline bool is_ignored_dynamic_output_shape_relaxed_3(int i) {
382 static std::set<int> ignore = {};
383 return ignore.find(i) != ignore.end();
384 }
385
CreateModel_dynamic_output_shape_float16_3(Model * model)386 void CreateModel_dynamic_output_shape_float16_3(Model *model) {
387 OperandType type12(Type::TENSOR_FLOAT16, {3, 1, 2});
388 OperandType type15(Type::TENSOR_FLOAT16, {0, 0, 0});
389 OperandType type6(Type::TENSOR_FLOAT16, {2, 1});
390 // Phase 1, operands
391 auto base = model->addOperand(&type6);
392 auto exponent2 = model->addOperand(&type12);
393 auto output2 = model->addOperand(&type15);
394 // Phase 2, operations
395 model->addOperation(ANEURALNETWORKS_POW, {base, exponent2}, {output2});
396 // Phase 3, inputs and outputs
397 model->identifyInputsAndOutputs(
398 {base, exponent2},
399 {output2});
400 assert(model->isValid());
401 }
402
is_ignored_dynamic_output_shape_float16_3(int i)403 inline bool is_ignored_dynamic_output_shape_float16_3(int i) {
404 static std::set<int> ignore = {};
405 return ignore.find(i) != ignore.end();
406 }
407
408