1 // clang-format off 2 // Generated file (from: greater_equal.mod.py). Do not edit 3 void CreateModel(Model *model) { 4 OperandType type0(Type::TENSOR_FLOAT32, {3}); 5 OperandType type1(Type::TENSOR_BOOL8, {3}); 6 // Phase 1, operands 7 auto input0 = model->addOperand(&type0); 8 auto input1 = model->addOperand(&type0); 9 auto output0 = model->addOperand(&type1); 10 // Phase 2, operations 11 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input0, input1}, {output0}); 12 // Phase 3, inputs and outputs 13 model->identifyInputsAndOutputs( 14 {input0, input1}, 15 {output0}); 16 assert(model->isValid()); 17 } 18 19 inline bool is_ignored(int i) { 20 static std::set<int> ignore = {}; 21 return ignore.find(i) != ignore.end(); 22 } 23 24 void CreateModel_int32(Model *model) { 25 OperandType type1(Type::TENSOR_BOOL8, {3}); 26 OperandType type12(Type::TENSOR_INT32, {3}); 27 // Phase 1, operands 28 auto input0 = model->addOperand(&type12); 29 auto input1 = model->addOperand(&type12); 30 auto output0 = model->addOperand(&type1); 31 // Phase 2, operations 32 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input0, input1}, {output0}); 33 // Phase 3, inputs and outputs 34 model->identifyInputsAndOutputs( 35 {input0, input1}, 36 {output0}); 37 assert(model->isValid()); 38 } 39 40 inline bool is_ignored_int32(int i) { 41 static std::set<int> ignore = {}; 42 return ignore.find(i) != ignore.end(); 43 } 44 45 void CreateModel_float16(Model *model) { 46 OperandType type1(Type::TENSOR_BOOL8, {3}); 47 OperandType type13(Type::TENSOR_FLOAT16, {3}); 48 // Phase 1, operands 49 auto input0 = model->addOperand(&type13); 50 auto input1 = model->addOperand(&type13); 51 auto output0 = model->addOperand(&type1); 52 // Phase 2, operations 53 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input0, input1}, {output0}); 54 // Phase 3, inputs and outputs 55 model->identifyInputsAndOutputs( 56 {input0, input1}, 57 {output0}); 58 assert(model->isValid()); 59 } 60 61 inline bool is_ignored_float16(int i) { 62 static std::set<int> ignore = {}; 63 return ignore.find(i) != ignore.end(); 64 } 65 66 void CreateModel_relaxed(Model *model) { 67 OperandType type0(Type::TENSOR_FLOAT32, {3}); 68 OperandType type1(Type::TENSOR_BOOL8, {3}); 69 // Phase 1, operands 70 auto input0 = model->addOperand(&type0); 71 auto input1 = model->addOperand(&type0); 72 auto output0 = model->addOperand(&type1); 73 // Phase 2, operations 74 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input0, input1}, {output0}); 75 // Phase 3, inputs and outputs 76 model->identifyInputsAndOutputs( 77 {input0, input1}, 78 {output0}); 79 // Phase 4: set relaxed execution 80 model->relaxComputationFloat32toFloat16(true); 81 assert(model->isValid()); 82 } 83 84 inline bool is_ignored_relaxed(int i) { 85 static std::set<int> ignore = {}; 86 return ignore.find(i) != ignore.end(); 87 } 88 89 void CreateModel_dynamic_output_shape(Model *model) { 90 OperandType type0(Type::TENSOR_FLOAT32, {3}); 91 OperandType type14(Type::TENSOR_BOOL8, {0}); 92 // Phase 1, operands 93 auto input0 = model->addOperand(&type0); 94 auto input1 = model->addOperand(&type0); 95 auto output0 = model->addOperand(&type14); 96 // Phase 2, operations 97 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input0, input1}, {output0}); 98 // Phase 3, inputs and outputs 99 model->identifyInputsAndOutputs( 100 {input0, input1}, 101 {output0}); 102 assert(model->isValid()); 103 } 104 105 inline bool is_ignored_dynamic_output_shape(int i) { 106 static std::set<int> ignore = {}; 107 return ignore.find(i) != ignore.end(); 108 } 109 110 void CreateModel_dynamic_output_shape_int32(Model *model) { 111 OperandType type12(Type::TENSOR_INT32, {3}); 112 OperandType type14(Type::TENSOR_BOOL8, {0}); 113 // Phase 1, operands 114 auto input0 = model->addOperand(&type12); 115 auto input1 = model->addOperand(&type12); 116 auto output0 = model->addOperand(&type14); 117 // Phase 2, operations 118 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input0, input1}, {output0}); 119 // Phase 3, inputs and outputs 120 model->identifyInputsAndOutputs( 121 {input0, input1}, 122 {output0}); 123 assert(model->isValid()); 124 } 125 126 inline bool is_ignored_dynamic_output_shape_int32(int i) { 127 static std::set<int> ignore = {}; 128 return ignore.find(i) != ignore.end(); 129 } 130 131 void CreateModel_dynamic_output_shape_float16(Model *model) { 132 OperandType type13(Type::TENSOR_FLOAT16, {3}); 133 OperandType type14(Type::TENSOR_BOOL8, {0}); 134 // Phase 1, operands 135 auto input0 = model->addOperand(&type13); 136 auto input1 = model->addOperand(&type13); 137 auto output0 = model->addOperand(&type14); 138 // Phase 2, operations 139 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input0, input1}, {output0}); 140 // Phase 3, inputs and outputs 141 model->identifyInputsAndOutputs( 142 {input0, input1}, 143 {output0}); 144 assert(model->isValid()); 145 } 146 147 inline bool is_ignored_dynamic_output_shape_float16(int i) { 148 static std::set<int> ignore = {}; 149 return ignore.find(i) != ignore.end(); 150 } 151 152 void CreateModel_dynamic_output_shape_relaxed(Model *model) { 153 OperandType type0(Type::TENSOR_FLOAT32, {3}); 154 OperandType type14(Type::TENSOR_BOOL8, {0}); 155 // Phase 1, operands 156 auto input0 = model->addOperand(&type0); 157 auto input1 = model->addOperand(&type0); 158 auto output0 = model->addOperand(&type14); 159 // Phase 2, operations 160 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input0, input1}, {output0}); 161 // Phase 3, inputs and outputs 162 model->identifyInputsAndOutputs( 163 {input0, input1}, 164 {output0}); 165 // Phase 4: set relaxed execution 166 model->relaxComputationFloat32toFloat16(true); 167 assert(model->isValid()); 168 } 169 170 inline bool is_ignored_dynamic_output_shape_relaxed(int i) { 171 static std::set<int> ignore = {}; 172 return ignore.find(i) != ignore.end(); 173 } 174 175 void CreateModel_2(Model *model) { 176 OperandType type2(Type::TENSOR_FLOAT32, {2, 1}); 177 OperandType type3(Type::TENSOR_FLOAT32, {2}); 178 OperandType type4(Type::TENSOR_BOOL8, {2, 2}); 179 // Phase 1, operands 180 auto input01 = model->addOperand(&type2); 181 auto input11 = model->addOperand(&type3); 182 auto output01 = model->addOperand(&type4); 183 // Phase 2, operations 184 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input01, input11}, {output01}); 185 // Phase 3, inputs and outputs 186 model->identifyInputsAndOutputs( 187 {input01, input11}, 188 {output01}); 189 assert(model->isValid()); 190 } 191 192 inline bool is_ignored_2(int i) { 193 static std::set<int> ignore = {}; 194 return ignore.find(i) != ignore.end(); 195 } 196 197 void CreateModel_int32_2(Model *model) { 198 OperandType type15(Type::TENSOR_INT32, {2, 1}); 199 OperandType type16(Type::TENSOR_INT32, {2}); 200 OperandType type4(Type::TENSOR_BOOL8, {2, 2}); 201 // Phase 1, operands 202 auto input01 = model->addOperand(&type15); 203 auto input11 = model->addOperand(&type16); 204 auto output01 = model->addOperand(&type4); 205 // Phase 2, operations 206 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input01, input11}, {output01}); 207 // Phase 3, inputs and outputs 208 model->identifyInputsAndOutputs( 209 {input01, input11}, 210 {output01}); 211 assert(model->isValid()); 212 } 213 214 inline bool is_ignored_int32_2(int i) { 215 static std::set<int> ignore = {}; 216 return ignore.find(i) != ignore.end(); 217 } 218 219 void CreateModel_float16_2(Model *model) { 220 OperandType type17(Type::TENSOR_FLOAT16, {2, 1}); 221 OperandType type18(Type::TENSOR_FLOAT16, {2}); 222 OperandType type4(Type::TENSOR_BOOL8, {2, 2}); 223 // Phase 1, operands 224 auto input01 = model->addOperand(&type17); 225 auto input11 = model->addOperand(&type18); 226 auto output01 = model->addOperand(&type4); 227 // Phase 2, operations 228 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input01, input11}, {output01}); 229 // Phase 3, inputs and outputs 230 model->identifyInputsAndOutputs( 231 {input01, input11}, 232 {output01}); 233 assert(model->isValid()); 234 } 235 236 inline bool is_ignored_float16_2(int i) { 237 static std::set<int> ignore = {}; 238 return ignore.find(i) != ignore.end(); 239 } 240 241 void CreateModel_relaxed_2(Model *model) { 242 OperandType type2(Type::TENSOR_FLOAT32, {2, 1}); 243 OperandType type3(Type::TENSOR_FLOAT32, {2}); 244 OperandType type4(Type::TENSOR_BOOL8, {2, 2}); 245 // Phase 1, operands 246 auto input01 = model->addOperand(&type2); 247 auto input11 = model->addOperand(&type3); 248 auto output01 = model->addOperand(&type4); 249 // Phase 2, operations 250 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input01, input11}, {output01}); 251 // Phase 3, inputs and outputs 252 model->identifyInputsAndOutputs( 253 {input01, input11}, 254 {output01}); 255 // Phase 4: set relaxed execution 256 model->relaxComputationFloat32toFloat16(true); 257 assert(model->isValid()); 258 } 259 260 inline bool is_ignored_relaxed_2(int i) { 261 static std::set<int> ignore = {}; 262 return ignore.find(i) != ignore.end(); 263 } 264 265 void CreateModel_dynamic_output_shape_2(Model *model) { 266 OperandType type19(Type::TENSOR_BOOL8, {0, 0}); 267 OperandType type2(Type::TENSOR_FLOAT32, {2, 1}); 268 OperandType type3(Type::TENSOR_FLOAT32, {2}); 269 // Phase 1, operands 270 auto input01 = model->addOperand(&type2); 271 auto input11 = model->addOperand(&type3); 272 auto output01 = model->addOperand(&type19); 273 // Phase 2, operations 274 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input01, input11}, {output01}); 275 // Phase 3, inputs and outputs 276 model->identifyInputsAndOutputs( 277 {input01, input11}, 278 {output01}); 279 assert(model->isValid()); 280 } 281 282 inline bool is_ignored_dynamic_output_shape_2(int i) { 283 static std::set<int> ignore = {}; 284 return ignore.find(i) != ignore.end(); 285 } 286 287 void CreateModel_dynamic_output_shape_int32_2(Model *model) { 288 OperandType type15(Type::TENSOR_INT32, {2, 1}); 289 OperandType type16(Type::TENSOR_INT32, {2}); 290 OperandType type19(Type::TENSOR_BOOL8, {0, 0}); 291 // Phase 1, operands 292 auto input01 = model->addOperand(&type15); 293 auto input11 = model->addOperand(&type16); 294 auto output01 = model->addOperand(&type19); 295 // Phase 2, operations 296 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input01, input11}, {output01}); 297 // Phase 3, inputs and outputs 298 model->identifyInputsAndOutputs( 299 {input01, input11}, 300 {output01}); 301 assert(model->isValid()); 302 } 303 304 inline bool is_ignored_dynamic_output_shape_int32_2(int i) { 305 static std::set<int> ignore = {}; 306 return ignore.find(i) != ignore.end(); 307 } 308 309 void CreateModel_dynamic_output_shape_float16_2(Model *model) { 310 OperandType type17(Type::TENSOR_FLOAT16, {2, 1}); 311 OperandType type18(Type::TENSOR_FLOAT16, {2}); 312 OperandType type19(Type::TENSOR_BOOL8, {0, 0}); 313 // Phase 1, operands 314 auto input01 = model->addOperand(&type17); 315 auto input11 = model->addOperand(&type18); 316 auto output01 = model->addOperand(&type19); 317 // Phase 2, operations 318 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input01, input11}, {output01}); 319 // Phase 3, inputs and outputs 320 model->identifyInputsAndOutputs( 321 {input01, input11}, 322 {output01}); 323 assert(model->isValid()); 324 } 325 326 inline bool is_ignored_dynamic_output_shape_float16_2(int i) { 327 static std::set<int> ignore = {}; 328 return ignore.find(i) != ignore.end(); 329 } 330 331 void CreateModel_dynamic_output_shape_relaxed_2(Model *model) { 332 OperandType type19(Type::TENSOR_BOOL8, {0, 0}); 333 OperandType type2(Type::TENSOR_FLOAT32, {2, 1}); 334 OperandType type3(Type::TENSOR_FLOAT32, {2}); 335 // Phase 1, operands 336 auto input01 = model->addOperand(&type2); 337 auto input11 = model->addOperand(&type3); 338 auto output01 = model->addOperand(&type19); 339 // Phase 2, operations 340 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input01, input11}, {output01}); 341 // Phase 3, inputs and outputs 342 model->identifyInputsAndOutputs( 343 {input01, input11}, 344 {output01}); 345 // Phase 4: set relaxed execution 346 model->relaxComputationFloat32toFloat16(true); 347 assert(model->isValid()); 348 } 349 350 inline bool is_ignored_dynamic_output_shape_relaxed_2(int i) { 351 static std::set<int> ignore = {}; 352 return ignore.find(i) != ignore.end(); 353 } 354 355 void CreateModel_3(Model *model) { 356 OperandType type1(Type::TENSOR_BOOL8, {3}); 357 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {3}, 1.0f, 128); 358 OperandType type6(Type::TENSOR_QUANT8_ASYMM, {1}, 2.0f, 128); 359 // Phase 1, operands 360 auto input02 = model->addOperand(&type5); 361 auto input12 = model->addOperand(&type6); 362 auto output02 = model->addOperand(&type1); 363 // Phase 2, operations 364 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input02, input12}, {output02}); 365 // Phase 3, inputs and outputs 366 model->identifyInputsAndOutputs( 367 {input02, input12}, 368 {output02}); 369 assert(model->isValid()); 370 } 371 372 inline bool is_ignored_3(int i) { 373 static std::set<int> ignore = {}; 374 return ignore.find(i) != ignore.end(); 375 } 376 377 void CreateModel_dynamic_output_shape_3(Model *model) { 378 OperandType type14(Type::TENSOR_BOOL8, {0}); 379 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {3}, 1.0f, 128); 380 OperandType type6(Type::TENSOR_QUANT8_ASYMM, {1}, 2.0f, 128); 381 // Phase 1, operands 382 auto input02 = model->addOperand(&type5); 383 auto input12 = model->addOperand(&type6); 384 auto output02 = model->addOperand(&type14); 385 // Phase 2, operations 386 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input02, input12}, {output02}); 387 // Phase 3, inputs and outputs 388 model->identifyInputsAndOutputs( 389 {input02, input12}, 390 {output02}); 391 assert(model->isValid()); 392 } 393 394 inline bool is_ignored_dynamic_output_shape_3(int i) { 395 static std::set<int> ignore = {}; 396 return ignore.find(i) != ignore.end(); 397 } 398 399 void CreateModel_4(Model *model) { 400 OperandType type1(Type::TENSOR_BOOL8, {3}); 401 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {3}, 1.0f, 128); 402 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {1}, 1.0f, 129); 403 // Phase 1, operands 404 auto input03 = model->addOperand(&type5); 405 auto input13 = model->addOperand(&type7); 406 auto output03 = model->addOperand(&type1); 407 // Phase 2, operations 408 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input03, input13}, {output03}); 409 // Phase 3, inputs and outputs 410 model->identifyInputsAndOutputs( 411 {input03, input13}, 412 {output03}); 413 assert(model->isValid()); 414 } 415 416 inline bool is_ignored_4(int i) { 417 static std::set<int> ignore = {}; 418 return ignore.find(i) != ignore.end(); 419 } 420 421 void CreateModel_dynamic_output_shape_4(Model *model) { 422 OperandType type14(Type::TENSOR_BOOL8, {0}); 423 OperandType type5(Type::TENSOR_QUANT8_ASYMM, {3}, 1.0f, 128); 424 OperandType type7(Type::TENSOR_QUANT8_ASYMM, {1}, 1.0f, 129); 425 // Phase 1, operands 426 auto input03 = model->addOperand(&type5); 427 auto input13 = model->addOperand(&type7); 428 auto output03 = model->addOperand(&type14); 429 // Phase 2, operations 430 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input03, input13}, {output03}); 431 // Phase 3, inputs and outputs 432 model->identifyInputsAndOutputs( 433 {input03, input13}, 434 {output03}); 435 assert(model->isValid()); 436 } 437 438 inline bool is_ignored_dynamic_output_shape_4(int i) { 439 static std::set<int> ignore = {}; 440 return ignore.find(i) != ignore.end(); 441 } 442 443 void CreateModel_5(Model *model) { 444 OperandType type10(Type::TENSOR_BOOL8, {1}); 445 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1}, 1.64771f, 31); 446 OperandType type9(Type::TENSOR_QUANT8_ASYMM, {1}, 1.49725f, 240); 447 // Phase 1, operands 448 auto input04 = model->addOperand(&type8); 449 auto input14 = model->addOperand(&type9); 450 auto output04 = model->addOperand(&type10); 451 // Phase 2, operations 452 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input04, input14}, {output04}); 453 // Phase 3, inputs and outputs 454 model->identifyInputsAndOutputs( 455 {input04, input14}, 456 {output04}); 457 assert(model->isValid()); 458 } 459 460 inline bool is_ignored_5(int i) { 461 static std::set<int> ignore = {}; 462 return ignore.find(i) != ignore.end(); 463 } 464 465 void CreateModel_dynamic_output_shape_5(Model *model) { 466 OperandType type14(Type::TENSOR_BOOL8, {0}); 467 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1}, 1.64771f, 31); 468 OperandType type9(Type::TENSOR_QUANT8_ASYMM, {1}, 1.49725f, 240); 469 // Phase 1, operands 470 auto input04 = model->addOperand(&type8); 471 auto input14 = model->addOperand(&type9); 472 auto output04 = model->addOperand(&type14); 473 // Phase 2, operations 474 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input04, input14}, {output04}); 475 // Phase 3, inputs and outputs 476 model->identifyInputsAndOutputs( 477 {input04, input14}, 478 {output04}); 479 assert(model->isValid()); 480 } 481 482 inline bool is_ignored_dynamic_output_shape_5(int i) { 483 static std::set<int> ignore = {}; 484 return ignore.find(i) != ignore.end(); 485 } 486 487 void CreateModel_6(Model *model) { 488 OperandType type10(Type::TENSOR_BOOL8, {1}); 489 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1}, 1.64771f, 31); 490 OperandType type9(Type::TENSOR_QUANT8_ASYMM, {1}, 1.49725f, 240); 491 // Phase 1, operands 492 auto input05 = model->addOperand(&type9); 493 auto input15 = model->addOperand(&type8); 494 auto output05 = model->addOperand(&type10); 495 // Phase 2, operations 496 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input05, input15}, {output05}); 497 // Phase 3, inputs and outputs 498 model->identifyInputsAndOutputs( 499 {input05, input15}, 500 {output05}); 501 assert(model->isValid()); 502 } 503 504 inline bool is_ignored_6(int i) { 505 static std::set<int> ignore = {}; 506 return ignore.find(i) != ignore.end(); 507 } 508 509 void CreateModel_dynamic_output_shape_6(Model *model) { 510 OperandType type14(Type::TENSOR_BOOL8, {0}); 511 OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1}, 1.64771f, 31); 512 OperandType type9(Type::TENSOR_QUANT8_ASYMM, {1}, 1.49725f, 240); 513 // Phase 1, operands 514 auto input05 = model->addOperand(&type9); 515 auto input15 = model->addOperand(&type8); 516 auto output05 = model->addOperand(&type14); 517 // Phase 2, operations 518 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input05, input15}, {output05}); 519 // Phase 3, inputs and outputs 520 model->identifyInputsAndOutputs( 521 {input05, input15}, 522 {output05}); 523 assert(model->isValid()); 524 } 525 526 inline bool is_ignored_dynamic_output_shape_6(int i) { 527 static std::set<int> ignore = {}; 528 return ignore.find(i) != ignore.end(); 529 } 530 531 void CreateModel_7(Model *model) { 532 OperandType type11(Type::TENSOR_BOOL8, {4}); 533 // Phase 1, operands 534 auto input06 = model->addOperand(&type11); 535 auto input16 = model->addOperand(&type11); 536 auto output06 = model->addOperand(&type11); 537 // Phase 2, operations 538 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input06, input16}, {output06}); 539 // Phase 3, inputs and outputs 540 model->identifyInputsAndOutputs( 541 {input06, input16}, 542 {output06}); 543 assert(model->isValid()); 544 } 545 546 inline bool is_ignored_7(int i) { 547 static std::set<int> ignore = {}; 548 return ignore.find(i) != ignore.end(); 549 } 550 551 void CreateModel_dynamic_output_shape_7(Model *model) { 552 OperandType type11(Type::TENSOR_BOOL8, {4}); 553 OperandType type14(Type::TENSOR_BOOL8, {0}); 554 // Phase 1, operands 555 auto input06 = model->addOperand(&type11); 556 auto input16 = model->addOperand(&type11); 557 auto output06 = model->addOperand(&type14); 558 // Phase 2, operations 559 model->addOperation(ANEURALNETWORKS_GREATER_EQUAL, {input06, input16}, {output06}); 560 // Phase 3, inputs and outputs 561 model->identifyInputsAndOutputs( 562 {input06, input16}, 563 {output06}); 564 assert(model->isValid()); 565 } 566 567 inline bool is_ignored_dynamic_output_shape_7(int i) { 568 static std::set<int> ignore = {}; 569 return ignore.find(i) != ignore.end(); 570 } 571 572
