• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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