| // Generated from equal.mod.py |
| // DO NOT EDIT |
| // clang-format off |
| #include "TestHarness.h" |
| |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_simple() { |
| static std::vector<::test_helper::MixedTypedExample> examples_simple = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}, {1, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {{0, {5.0f, 7.0f, 10.0f}}, {1, {10.0f, 7.0f, 5.0f}}}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_simple; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_simple_int32() { |
| static std::vector<::test_helper::MixedTypedExample> examples_simple_int32 = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}, {1, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {{0, {5, 7, 10}}, {1, {10, 7, 5}}}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_simple_int32; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_simple_float16() { |
| static std::vector<::test_helper::MixedTypedExample> examples_simple_float16 = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}, {1, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {{0, {5.0f, 7.0f, 10.0f}}, {1, {10.0f, 7.0f, 5.0f}}}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_simple_float16; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_simple_relaxed() { |
| static std::vector<::test_helper::MixedTypedExample> examples_simple_relaxed = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}, {1, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {{0, {5.0f, 7.0f, 10.0f}}, {1, {10.0f, 7.0f, 5.0f}}}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_simple_relaxed; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_simple_dynamic_output_shape() { |
| static std::vector<::test_helper::MixedTypedExample> examples_simple_dynamic_output_shape = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}, {1, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {{0, {5.0f, 7.0f, 10.0f}}, {1, {10.0f, 7.0f, 5.0f}}}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_simple_dynamic_output_shape; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_simple_dynamic_output_shape_int32() { |
| static std::vector<::test_helper::MixedTypedExample> examples_simple_dynamic_output_shape_int32 = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}, {1, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {{0, {5, 7, 10}}, {1, {10, 7, 5}}}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_simple_dynamic_output_shape_int32; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_simple_dynamic_output_shape_float16() { |
| static std::vector<::test_helper::MixedTypedExample> examples_simple_dynamic_output_shape_float16 = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}, {1, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {{0, {5.0f, 7.0f, 10.0f}}, {1, {10.0f, 7.0f, 5.0f}}}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_simple_dynamic_output_shape_float16; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_simple_dynamic_output_shape_relaxed() { |
| static std::vector<::test_helper::MixedTypedExample> examples_simple_dynamic_output_shape_relaxed = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}, {1, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {{0, {5.0f, 7.0f, 10.0f}}, {1, {10.0f, 7.0f, 5.0f}}}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_simple_dynamic_output_shape_relaxed; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_broadcast() { |
| static std::vector<::test_helper::MixedTypedExample> examples_broadcast = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {2, 1}}, {1, {2}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {{0, {5.0f, 10.0f}}, {1, {10.0f, 5.0f}}}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {2, 2}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_broadcast; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_broadcast_int32() { |
| static std::vector<::test_helper::MixedTypedExample> examples_broadcast_int32 = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {2, 1}}, {1, {2}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {{0, {5, 10}}, {1, {10, 5}}}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {2, 2}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_broadcast_int32; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_broadcast_float16() { |
| static std::vector<::test_helper::MixedTypedExample> examples_broadcast_float16 = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {2, 1}}, {1, {2}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {{0, {5.0f, 10.0f}}, {1, {10.0f, 5.0f}}}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {2, 2}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_broadcast_float16; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_broadcast_relaxed() { |
| static std::vector<::test_helper::MixedTypedExample> examples_broadcast_relaxed = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {2, 1}}, {1, {2}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {{0, {5.0f, 10.0f}}, {1, {10.0f, 5.0f}}}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {2, 2}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_broadcast_relaxed; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_broadcast_dynamic_output_shape() { |
| static std::vector<::test_helper::MixedTypedExample> examples_broadcast_dynamic_output_shape = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {2, 1}}, {1, {2}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {{0, {5.0f, 10.0f}}, {1, {10.0f, 5.0f}}}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {2, 2}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_broadcast_dynamic_output_shape; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_broadcast_dynamic_output_shape_int32() { |
| static std::vector<::test_helper::MixedTypedExample> examples_broadcast_dynamic_output_shape_int32 = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {2, 1}}, {1, {2}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {{0, {5, 10}}, {1, {10, 5}}}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {2, 2}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_broadcast_dynamic_output_shape_int32; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_broadcast_dynamic_output_shape_float16() { |
| static std::vector<::test_helper::MixedTypedExample> examples_broadcast_dynamic_output_shape_float16 = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {2, 1}}, {1, {2}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {{0, {5.0f, 10.0f}}, {1, {10.0f, 5.0f}}}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {2, 2}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_broadcast_dynamic_output_shape_float16; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_broadcast_dynamic_output_shape_relaxed() { |
| static std::vector<::test_helper::MixedTypedExample> examples_broadcast_dynamic_output_shape_relaxed = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {2, 1}}, {1, {2}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {{0, {5.0f, 10.0f}}, {1, {10.0f, 5.0f}}}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {2, 2}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_broadcast_dynamic_output_shape_relaxed; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_quantized_different_scale() { |
| static std::vector<::test_helper::MixedTypedExample> examples_quantized_different_scale = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}, {1, {1}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {{0, {129, 130, 131}}, {1, {129}}}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_quantized_different_scale; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_quantized_different_scale_dynamic_output_shape() { |
| static std::vector<::test_helper::MixedTypedExample> examples_quantized_different_scale_dynamic_output_shape = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}, {1, {1}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {{0, {129, 130, 131}}, {1, {129}}}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_quantized_different_scale_dynamic_output_shape; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_quantized_different_zero_point() { |
| static std::vector<::test_helper::MixedTypedExample> examples_quantized_different_zero_point = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}, {1, {1}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {{0, {129, 130, 131}}, {1, {131}}}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_quantized_different_zero_point; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_quantized_different_zero_point_dynamic_output_shape() { |
| static std::vector<::test_helper::MixedTypedExample> examples_quantized_different_zero_point_dynamic_output_shape = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}, {1, {1}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {{0, {129, 130, 131}}, {1, {131}}}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {3}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_quantized_different_zero_point_dynamic_output_shape; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_quantized_overflow_second_input_if_requantized() { |
| static std::vector<::test_helper::MixedTypedExample> examples_quantized_overflow_second_input_if_requantized = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {1}}, {1, {1}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {{0, {0}}, {1, {200}}}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {1}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_quantized_overflow_second_input_if_requantized; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_quantized_overflow_second_input_if_requantized_dynamic_output_shape() { |
| static std::vector<::test_helper::MixedTypedExample> examples_quantized_overflow_second_input_if_requantized_dynamic_output_shape = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {1}}, {1, {1}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {{0, {0}}, {1, {200}}}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {1}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_quantized_overflow_second_input_if_requantized_dynamic_output_shape; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_quantized_overflow_first_input_if_requantized() { |
| static std::vector<::test_helper::MixedTypedExample> examples_quantized_overflow_first_input_if_requantized = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {1}}, {1, {1}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {{0, {200}}, {1, {0}}}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {1}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_quantized_overflow_first_input_if_requantized; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_quantized_overflow_first_input_if_requantized_dynamic_output_shape() { |
| static std::vector<::test_helper::MixedTypedExample> examples_quantized_overflow_first_input_if_requantized_dynamic_output_shape = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {1}}, {1, {1}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {{0, {200}}, {1, {0}}}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {1}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_quantized_overflow_first_input_if_requantized_dynamic_output_shape; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_boolean() { |
| static std::vector<::test_helper::MixedTypedExample> examples_boolean = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {4}}, {1, {4}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, false, true}}, {1, {false, false, true, true}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {4}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {true, false, false, true}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_boolean; |
| }; |
| |
| } // namespace generated_tests::equal |
| namespace generated_tests::equal { |
| |
| std::vector<::test_helper::MixedTypedExample>& get_examples_boolean_dynamic_output_shape() { |
| static std::vector<::test_helper::MixedTypedExample> examples_boolean_dynamic_output_shape = { |
| // Begin of an example |
| { |
| .operands = { |
| //Input(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {4}}, {1, {4}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {false, true, false, true}}, {1, {false, false, true, true}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| }, |
| //Output(s) |
| { // See tools/test_generator/include/TestHarness.h:MixedTyped |
| // int -> Dimensions map |
| .operandDimensions = {{0, {4}}}, |
| // int -> FLOAT32 map |
| .float32Operands = {}, |
| // int -> INT32 map |
| .int32Operands = {}, |
| // int -> QUANT8_ASYMM map |
| .quant8AsymmOperands = {}, |
| // int -> QUANT16_SYMM map |
| .quant16SymmOperands = {}, |
| // int -> FLOAT16 map |
| .float16Operands = {}, |
| // int -> BOOL8 map |
| .bool8Operands = {{0, {true, false, false, true}}}, |
| // int -> QUANT8_SYMM_PER_CHANNEL map |
| .quant8ChannelOperands = {}, |
| // int -> QUANT16_ASYMM map |
| .quant16AsymmOperands = {}, |
| // int -> QUANT8_SYMM map |
| .quant8SymmOperands = {}, |
| } |
| }, |
| }, // End of an example |
| }; |
| return examples_boolean_dynamic_output_shape; |
| }; |
| |
| } // namespace generated_tests::equal |
