Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / 7790dc6531034778d92ba264fd61174bcff7051e / . / delegate / test / ElementwiseBinaryTest.cpp
blob: a36708d42ea117d02579ed8d3b02dd4e37c80eb4 [file] [log] [blame]
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]1//
Ryan OSheaa544f0f2023-01-25 18:10:20 +0000[diff] [blame]2// Copyright © 2020-2021, 2023 Arm Ltd and Contributors. All rights reserved.
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]3// SPDX-License-Identifier: MIT
4//
5
6#include "ElementwiseBinaryTestHelper.hpp"
7
8#include <armnn_delegate.hpp>
9
10#include <flatbuffers/flatbuffers.h>
11#include <tensorflow/lite/interpreter.h>
12#include <tensorflow/lite/kernels/register.h>
13#include <tensorflow/lite/model.h>
Colm Donelan5ea6e3f2023-12-08 15:49:54 +0000[diff] [blame]14
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]15#include <tensorflow/lite/version.h>
16
17#include <doctest/doctest.h>
18
19namespace armnnDelegate
20{
21
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]22void AddFP32Test(std::vector<armnn::BackendId>& backends)
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]23{
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]24 std::vector<int32_t> input0Shape { 2, 2, 2, 3 };
25 std::vector<int32_t> input1Shape { 2, 2, 2, 3 };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]26 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 3 };
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]27
28 std::vector<float> input0Values =
29 {
30 0.0f, 2.0f, 1.0f,
31 0.2f, 1.0f, 2.0f,
32
33 1.0f, 2.0f, 1.0f,
34 0.2f, 1.0f, 2.0f,
35
36 0.0f, 2.0f, 1.0f,
37 4.2f, 1.0f, 2.0f,
38
39 0.0f, 0.0f, 1.0f,
40 0.2f, 1.0f, 2.0f,
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]41 };
42
43 std::vector<float> input1Values =
44 {
45 1.0f, 2.0f, 1.0f,
46 0.0f, 1.0f, 2.0f,
47
48 1.0f, 2.0f, -2.0f,
49 0.2f, 1.0f, 2.0f,
50
51 0.0f, 2.0f, 1.0f,
52 4.2f, 0.0f, -3.0f,
53
54 0.0f, 0.0f, 1.0f,
55 0.7f, 1.0f, 5.0f,
56 };
57
58 std::vector<float> expectedOutputValues =
59 {
60 1.0f, 4.0f, 2.0f,
61 0.2f, 2.0f, 4.0f,
62
63 2.0f, 4.0f, -1.0f,
64 0.4f, 2.0f, 4.0f,
65
66 0.0f, 4.0f, 2.0f,
67 8.4f, 1.0f, -1.0f,
68
69 0.0f, 0.0f, 2.0f,
70 0.9f, 2.0f, 7.0f,
71 };
72
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]73 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_ADD,
74 tflite::ActivationFunctionType_NONE,
75 ::tflite::TensorType_FLOAT32,
76 backends,
77 input0Shape,
78 input1Shape,
79 expectedOutputShape,
80 input0Values,
81 input1Values,
82 expectedOutputValues);
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]83}
84
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]85void AddBroadcastTest(std::vector<armnn::BackendId>& backends)
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]86{
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]87 std::vector<int32_t> input0Shape { 1, 3, 2, 1 };
88 std::vector<int32_t> input1Shape { 1, 1, 2, 3 };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]89 std::vector<int32_t> expectedOutputShape { 1, 3, 2, 3 };
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]90
91 std::vector<float> input0Values
92 {
93 0.0f,
94 1.0f,
95
96 2.0f,
97 3.0f,
98
99 4.0f,
100 5.0f,
101 };
102 std::vector<float> input1Values
103 {
104 0.5f, 1.5f, 2.5f,
105 3.5f, 4.5f, 5.5f,
106 };
107 // Set output data
108 std::vector<float> expectedOutputValues
109 {
110 0.5f, 1.5f, 2.5f,
111 4.5f, 5.5f, 6.5f,
112
113 2.5f, 3.5f, 4.5f,
114 6.5f, 7.5f, 8.5f,
115
116 4.5f, 5.5f, 6.5f,
117 8.5f, 9.5f, 10.5f,
118 };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]119
120 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_ADD,
121 tflite::ActivationFunctionType_NONE,
122 ::tflite::TensorType_FLOAT32,
123 backends,
124 input0Shape,
125 input1Shape,
126 expectedOutputShape,
127 input0Values,
128 input1Values,
129 expectedOutputValues);
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]130}
131
Sadik Armaganf7ac72c2021-05-05 15:03:50 +0100[diff] [blame]132void AddConstInputTest(std::vector<armnn::BackendId>& backends)
133{
134 std::vector<int32_t> input0Shape { 1, 3, 2, 1 };
135 std::vector<int32_t> input1Shape { 1 };
136 std::vector<int32_t> expectedOutputShape { 1, 3, 2, 1 };
137
138 std::vector<float> input0Values
139 {
140 0.0f,
141 1.0f,
142
143 2.0f,
144 3.0f,
145
146 4.0f,
147 5.0f,
148 };
149 std::vector<float> input1Values
150 {
151 0.5f
152 };
153 // Set output data
154 std::vector<float> expectedOutputValues
155 {
156 0.5f,
157 1.5f,
158
159 2.5f,
160 3.5f,
161
162 4.5f,
163 5.5f,
164 };
165
166 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_ADD,
167 tflite::ActivationFunctionType_NONE,
168 ::tflite::TensorType_FLOAT32,
169 backends,
170 input0Shape,
171 input1Shape,
172 expectedOutputShape,
173 input0Values,
174 input1Values,
175 expectedOutputValues,
176 1.0f,
177 0,
178 true);
179}
180
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]181void AddActivationTest(std::vector<armnn::BackendId>& backends)
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]182{
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]183 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
184 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]185 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]186
187 std::vector<float> input0Values { 4.0f, 0.8f, 0.7f, -0.8f };
188 std::vector<float> input1Values { 0.7f, -1.2f, 0.8f, 0.5f };
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]189 std::vector<float> expectedOutputValues { 4.7f, 0.0f, 1.5f, 0.0f };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]190
191 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_ADD,
192 tflite::ActivationFunctionType_RELU,
193 ::tflite::TensorType_FLOAT32,
194 backends,
195 input0Shape,
196 input1Shape,
197 expectedOutputShape,
198 input0Values,
199 input1Values,
200 expectedOutputValues);
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]201}
202
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]203void AddUint8Test(std::vector<armnn::BackendId>& backends)
204{
205 std::vector<int32_t> input0Shape { 1, 2, 2, 3 };
206 std::vector<int32_t> input1Shape { 1, 2, 2, 3 };
207 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 3 };
208
209 std::vector<uint8_t> input0Values =
210 {
211 63, 35, 77, 70, 56, 112,
212 203, 28, 252, 168, 245, 91
213 };
214
215 std::vector<uint8_t> input1Values =
216 {
217 21, 7, 175, 231, 175, 210,
218 126, 161, 63, 21, 105, 126
219 };
220
221 std::vector<uint8_t> expectedOutputValues =
222 {
223 81, 39, 249, 255, 228, 255,
224 255, 186, 255, 186, 255, 214,
225 };
226
227 ElementwiseBinaryTest<uint8_t>(tflite::BuiltinOperator_ADD,
228 tflite::ActivationFunctionType_NONE,
229 ::tflite::TensorType_UINT8,
230 backends,
231 input0Shape,
232 input1Shape,
233 expectedOutputShape,
234 input0Values,
235 input1Values,
236 expectedOutputValues, 7.0f, 3);
Sadik Armagan67e95f22020-10-29 16:14:54 +0000[diff] [blame]237}
238
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]239void DivFP32Test(std::vector<armnn::BackendId>& backends)
240{
241 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
242 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
243 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
244
245 std::vector<float> input0Values =
246 {
247 2.f, 2.f, 2.f, 2.f, 3.f, 3.f, 3.f, 3.f,
248 4.f, 4.f, 4.f, 4.f, 5.f, 5.f, 5.f, 5.f
249
250 };
251
252 std::vector<float> input1Values =
253 {
254 1.f, 1.f, 1.f, 1.f, 2.f, 2.f, 2.f, 2.f,
255 4.f, 4.f, 4.f, 4.f, 4.f, 4.f, 4.f, 4.f
256 };
257
258 std::vector<float> expectedOutputValues =
259 {
260 2.f, 2.f, 2.f, 2.f, 1.50f, 1.50f, 1.50f, 1.50f,
261 1.f, 1.f, 1.f, 1.f, 1.25f, 1.25f, 1.25f, 1.25f
262 };
263
264 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_DIV,
265 tflite::ActivationFunctionType_NONE,
266 ::tflite::TensorType_FLOAT32,
267 backends,
268 input0Shape,
269 input1Shape,
270 expectedOutputShape,
271 input0Values,
272 input1Values,
273 expectedOutputValues);
274}
275
276void DivBroadcastTest(std::vector<armnn::BackendId>& backends)
277{
278 std::vector<int32_t> input0Shape { 1, 2, 2, 2 };
279 std::vector<int32_t> input1Shape { 1, 1, 1, 1 };
280 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 2 };
281
282 std::vector<float> input0Values = { 2, 4, 6, 8, 10, 12, 14, 16 };
283 std::vector<float> input1Values = { 2 };
284 std::vector<float> expectedOutputValues = { 1, 2, 3, 4, 5, 6, 7, 8 };
285
286 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_DIV,
287 tflite::ActivationFunctionType_NONE,
288 ::tflite::TensorType_FLOAT32,
289 backends,
290 input0Shape,
291 input1Shape,
292 expectedOutputShape,
293 input0Values,
294 input1Values,
295 expectedOutputValues);
296}
297
298void DivUint8Test(std::vector<armnn::BackendId>& backends)
299{
300 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
301 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
302 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
303
304 std::vector<uint8_t> input0Values =
305 {
306 2, 2, 2, 2, 3, 3, 3, 3,
307 4, 4, 4, 4, 5, 5, 5, 5
308
309 };
310
311 std::vector<uint8_t> input1Values =
312 {
313 1, 1, 1, 1, 2, 2, 2, 2,
314 4, 4, 4, 4, 4, 4, 4, 4
315 };
316
317 std::vector<uint8_t> expectedOutputValues =
318 {
319 8, 8, 8, 8, 6, 6, 6, 6,
320 4, 4, 4, 4, 5, 5, 5, 5
321 };
322
323 ElementwiseBinaryTest<uint8_t>(tflite::BuiltinOperator_DIV,
324 tflite::ActivationFunctionType_NONE,
325 ::tflite::TensorType_UINT8,
326 backends,
327 input0Shape,
328 input1Shape,
329 expectedOutputShape,
330 input0Values,
331 input1Values,
332 expectedOutputValues, 0.25f, 0);
333}
334
Jim Flynn4b2f3472021-10-13 21:20:07 +0100[diff] [blame]335void FloorDivFP32Test(std::vector<armnn::BackendId>& backends)
336{
337 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
338 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
339 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
340
341 std::vector<float> input0Values =
342 {
343 -37.5f, -15.2f, -8.76f, -2.0f, -2.6f, -1.0f, -0.8f, 0.0f,
344 4.0f, 1.6f, 2.0f, 5.2f, 6.0f, 35.04f, 60.8f, 150.0f
345 };
346
347 std::vector<float> input1Values =
348 {
349 1.f, 1.f, 1.f, 1.f, 2.f, 2.f, 2.f, 2.f,
350 4.f, 4.f, 4.f, 4.f, 4.f, 4.f, 4.f, 4.f
351 };
352
353 std::vector<float> expectedOutputValues =
354 {
355 -38.0f, -16.0f, -9.0f, -2.0f, -2.0f, -1.0f, -1.0f, 0.0f,
356 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 8.0f, 15.0f, 37.0f
357 };
358
359 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_FLOOR_DIV,
360 tflite::ActivationFunctionType_NONE,
361 ::tflite::TensorType_FLOAT32,
362 backends,
363 input0Shape,
364 input1Shape,
365 expectedOutputShape,
366 input0Values,
367 input1Values,
368 expectedOutputValues);
369
370}
371
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]372void MaxFP32Test(std::vector<armnn::BackendId>& backends)
373{
374 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
375 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
376 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
377
378 std::vector<float> input0Values =
379 {
380 1.f, 1.f, 5.f, 1.f, 2.f, 2.f, 7.f, 2.f,
381 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
382
383 };
384
385 std::vector<float> input1Values =
386 {
387 2.f, 2.f, 2.f, 2.f, 3.f, 3.f, 3.f, 3.f,
388 4.f, 4.f, 4.f, 4.f, 5.f, 5.f, 5.f, 5.f
389 };
390
391 std::vector<float> expectedOutputValues =
392 {
393 2.f, 2.f, 5.f, 2.f, 3.f, 3.f, 7.f, 3.f,
394 4.f, 4.f, 4.f, 4.f, 5.f, 5.f, 5.f, 5.f
395 };
396
397 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MAXIMUM,
398 tflite::ActivationFunctionType_NONE,
399 ::tflite::TensorType_FLOAT32,
400 backends,
401 input0Shape,
402 input1Shape,
403 expectedOutputShape,
404 input0Values,
405 input1Values,
406 expectedOutputValues);
407}
408
409void MaxBroadcastTest(std::vector<armnn::BackendId>& backends)
410{
411 std::vector<int32_t> input0Shape { 1, 2, 2, 2 };
412 std::vector<int32_t> input1Shape { 1, 1, 1, 1 };
413 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 2 };
414
415 std::vector<float> input0Values = { 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f };
416 std::vector<float> input1Values = { 4.f };
417 std::vector<float> expectedOutputValues = { 4.f, 4.f, 4.f, 4.f, 5.f, 6.f, 7.f, 8.f };
418
419 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MAXIMUM,
420 tflite::ActivationFunctionType_NONE,
421 ::tflite::TensorType_FLOAT32,
422 backends,
423 input0Shape,
424 input1Shape,
425 expectedOutputShape,
426 input0Values,
427 input1Values,
428 expectedOutputValues);
429}
430
431void MaxUint8Test(std::vector<armnn::BackendId>& backends)
432{
433 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
434 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
435 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
436
437 std::vector<uint8_t> input0Values =
438 {
439 1, 1, 1, 1, 7, 8, 9, 9,
440 3, 3, 3, 3, 4, 4, 4, 4
441
442 };
443
444 std::vector<uint8_t> input1Values =
445 {
446 2, 2, 2, 2, 3, 3, 3, 3,
447 4, 4, 4, 4, 5, 5, 5, 5
448 };
449
450 std::vector<uint8_t> expectedOutputValues =
451 {
452 2, 2, 2, 2, 7, 8, 9, 9,
453 4, 4, 4, 4, 5, 5, 5, 5
454 };
455
456 ElementwiseBinaryTest<uint8_t>(tflite::BuiltinOperator_MAXIMUM,
457 tflite::ActivationFunctionType_NONE,
458 ::tflite::TensorType_UINT8,
459 backends,
460 input0Shape,
461 input1Shape,
462 expectedOutputShape,
463 input0Values,
464 input1Values,
465 expectedOutputValues, 1.0f, 0);
466}
467
468void MinFP32Test(std::vector<armnn::BackendId>& backends)
469{
470 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
471 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
472 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
473
474 std::vector<float> input0Values =
475 {
476 1.f, 1.f, 5.f, 1.f, 2.f, 2.f, 7.f, 2.f,
477 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
478
479 };
480
481 std::vector<float> input1Values =
482 {
483 2.f, 2.f, 2.f, 2.f, 3.f, 3.f, 3.f, 3.f,
484 1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f
485 };
486
487 std::vector<float> expectedOutputValues =
488 {
489 1.f, 1.f, 2.f, 1.f, 2.f, 2.f, 3.f, 2.f,
490 1.f, 1.f, 1.f, 1.f, 4.f, 4.f, 4.f, 4.f
491 };
492
493 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MINIMUM,
494 tflite::ActivationFunctionType_NONE,
495 ::tflite::TensorType_FLOAT32,
496 backends,
497 input0Shape,
498 input1Shape,
499 expectedOutputShape,
500 input0Values,
501 input1Values,
502 expectedOutputValues);
503}
504
505void MinBroadcastTest(std::vector<armnn::BackendId>& backends)
506{
507 std::vector<int32_t> input0Shape { 1, 2, 2, 2 };
508 std::vector<int32_t> input1Shape { 1, 1, 1, 1 };
509 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 2 };
510
511 std::vector<float> input0Values = { 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f };
512
513 std::vector<float> input1Values = { 4.f };
514
515 std::vector<float> expectedOutputValues = { 1.f, 2.f, 3.f, 4.f, 4.f, 4.f, 4.f, 4.f };
516
517 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MINIMUM,
518 tflite::ActivationFunctionType_NONE,
519 ::tflite::TensorType_FLOAT32,
520 backends,
521 input0Shape,
522 input1Shape,
523 expectedOutputShape,
524 input0Values,
525 input1Values,
526 expectedOutputValues);
527}
528
529void MinUint8Test(std::vector<armnn::BackendId>& backends)
530{
531 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
532 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
533 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
534
535 std::vector<uint8_t> input0Values =
536 {
537 1, 1, 1, 1, 7, 8, 9, 9,
538 3, 3, 3, 3, 4, 4, 4, 4
539
540 };
541
542 std::vector<uint8_t> input1Values =
543 {
544 2, 2, 2, 2, 3, 3, 3, 3,
545 4, 4, 4, 4, 5, 5, 5, 5
546 };
547
548 std::vector<uint8_t> expectedOutputValues =
549 {
550 1, 1, 1, 1, 3, 3, 3, 3,
551 3, 3, 3, 3, 4, 4, 4, 4
552 };
553
554 ElementwiseBinaryTest<uint8_t>(tflite::BuiltinOperator_MINIMUM,
555 tflite::ActivationFunctionType_NONE,
556 ::tflite::TensorType_UINT8,
557 backends,
558 input0Shape,
559 input1Shape,
560 expectedOutputShape,
561 input0Values,
562 input1Values,
563 expectedOutputValues, 1.0f, 0);
564}
565
566void MulFP32Test(std::vector<armnn::BackendId>& backends)
567{
568 std::vector<int32_t> input0Shape { 2, 2, 2, 2 };
569 std::vector<int32_t> input1Shape { 2, 2, 2, 2 };
570 std::vector<int32_t> expectedOutputShape { 2, 2, 2, 2 };
571
572 std::vector<float> input0Values =
573 {
574 1.f, 1.f, 1.f, 1.f, 2.f, 2.f, 2.f, 2.f,
575 3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
576
577 };
578
579 std::vector<float> input1Values =
580 {
581 2.f, 2.f, 2.f, 2.f, 3.f, 3.f, 3.f, 3.f,
582 4.f, 4.f, 4.f, 4.f, 5.f, 5.f, 5.f, 5.f
583 };
584
585 std::vector<float> expectedOutputValues =
586 {
587 2.f, 2.f, 2.f, 2.f, 6.f, 6.f, 6.f, 6.f,
588 12.f, 12.f, 12.f, 12.f, 20.f, 20.f, 20.f, 20.f
589 };
590
591 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MUL,
592 tflite::ActivationFunctionType_NONE,
593 ::tflite::TensorType_FLOAT32,
594 backends,
595 input0Shape,
596 input1Shape,
597 expectedOutputShape,
598 input0Values,
599 input1Values,
600 expectedOutputValues);
601}
602
603void MulBroadcastTest(std::vector<armnn::BackendId>& backends)
604{
605 std::vector<int32_t> input0Shape { 1, 2, 2, 2 };
606 std::vector<int32_t> input1Shape { 1, 1, 1, 1 };
607 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 2 };
608
609 std::vector<float> input0Values = { 2, 4, 6, 8, 10, 12, 14, 16 };
610 std::vector<float> input1Values = { 2 };
611 std::vector<float> expectedOutputValues = { 4, 8, 12, 16, 20, 24, 28, 32 };
612
613 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MUL,
614 tflite::ActivationFunctionType_NONE,
615 ::tflite::TensorType_FLOAT32,
616 backends,
617 input0Shape,
618 input1Shape,
619 expectedOutputShape,
620 input0Values,
621 input1Values,
622 expectedOutputValues);
623}
624
625void MulUint8Test(std::vector<armnn::BackendId>& backends)
626{
627 std::vector<int32_t> input0Shape { 1, 2, 2, 3 };
628 std::vector<int32_t> input1Shape { 1, 1, 1, 3 };
629 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 3 };
630
631 std::vector<uint8_t> input0Values =
632 {
633 1, 2, 3, 4, 5, 6,
634 7, 8, 9, 10, 11, 12
635
636 };
637
638 std::vector<uint8_t> input1Values = { 1, 2, 3 };
639
640 std::vector<uint8_t> expectedOutputValues =
641 {
642 1, 4, 9, 4, 10, 18,
643 7, 16, 27, 10, 22, 36
644 };
645
646 ElementwiseBinaryTest<uint8_t>(tflite::BuiltinOperator_MUL,
647 tflite::ActivationFunctionType_NONE,
648 ::tflite::TensorType_UINT8,
649 backends,
650 input0Shape,
651 input1Shape,
652 expectedOutputShape,
653 input0Values,
654 input1Values,
655 expectedOutputValues, 1.0f, 0);
656}
657
658void MulActivationTest(std::vector<armnn::BackendId>& backends)
659{
660 std::vector<int32_t> input0Shape { 1, 2, 2, 1 };
661 std::vector<int32_t> input1Shape { 1, 2, 2, 1 };
662 std::vector<int32_t> expectedOutputShape { 1, 2, 2, 1 };
663
664 std::vector<float> input0Values { 4.0f, 0.0f, 1.0f, 0.5f };
665 std::vector<float> input1Values { -2.0f, -1.2f, 2.5f, 2.0f };
666 std::vector<float> expectedOutputValues { 0.0f, 0.0f, 2.5f, 1.0f };
667
668 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_MUL,
669 tflite::ActivationFunctionType_RELU,
670 ::tflite::TensorType_FLOAT32,
671 backends,
672 input0Shape,
673 input1Shape,
674 expectedOutputShape,
675 input0Values,
676 input1Values,
677 expectedOutputValues);
678}
679
680void SubFP32Test(std::vector<armnn::BackendId>& backends)
681{
682 std::vector<int32_t> input0Shape { 1, 1, 2, 2 };
683 std::vector<int32_t> input1Shape { 1, 1, 2, 2 };
684 std::vector<int32_t> expectedOutputShape { 1, 1, 2, 2 };
685
686 std::vector<float> input0Values = { 1, 3, 3, -7 };
687 std::vector<float> input1Values = { 1, -1, 0, -2 };
688 std::vector<float> expectedOutputValues = { 0, 4, 3, -5 };
689
690 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_SUB,
691 tflite::ActivationFunctionType_NONE,
692 ::tflite::TensorType_FLOAT32,
693 backends,
694 input0Shape,
695 input1Shape,
696 expectedOutputShape,
697 input0Values,
698 input1Values,
699 expectedOutputValues);
700}
701
John Mcloughlin0ec00872023-05-15 17:03:49 +0100[diff] [blame]702void PowerFP32Test(std::vector<armnn::BackendId>& backends)
703{
704 std::vector<int32_t> input0Shape { 1, 1, 2, 2 };
705 std::vector<int32_t> input1Shape { 1, 1, 2, 2 };
706 std::vector<int32_t> expectedOutputShape { 1, 1, 2, 2 };
707
708 std::vector<float> input0Values = { 1, 3, 3, -7 };
709 std::vector<float> input1Values = { 1, 1, 0, 2 };
710 std::vector<float> expectedOutputValues = { 1, 3, 1, 49 };
711
712 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_POW,
713 tflite::ActivationFunctionType_NONE,
714 ::tflite::TensorType_FLOAT32,
715 backends,
716 input0Shape,
717 input1Shape,
718 expectedOutputShape,
719 input0Values,
720 input1Values,
721 expectedOutputValues);
722}
723
724void SqDiffFP32Test(std::vector<armnn::BackendId>& backends)
725{
726 std::vector<int32_t> input0Shape { 1, 1, 2, 2 };
727 std::vector<int32_t> input1Shape { 1, 1, 2, 2 };
728 std::vector<int32_t> expectedOutputShape { 1, 1, 2, 2 };
729
730 std::vector<float> input0Values = { 1, 3, 3, -7 };
731 std::vector<float> input1Values = { 1, -1, 0, -2 };
732 std::vector<float> expectedOutputValues = { 0, 16, 9, 25 };
733
734 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_SQUARED_DIFFERENCE,
735 tflite::ActivationFunctionType_NONE,
736 ::tflite::TensorType_FLOAT32,
737 backends,
738 input0Shape,
739 input1Shape,
740 expectedOutputShape,
741 input0Values,
742 input1Values,
743 expectedOutputValues);
744}
745
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]746void SubBroadcastTest(std::vector<armnn::BackendId>& backends)
747{
748 std::vector<int32_t> input0Shape { 1, 1, 2, 2 };
749 std::vector<int32_t> input1Shape { 1, 1, 1, 1 };
750 std::vector<int32_t> expectedOutputShape { 1, 1, 2, 2 };
751
752 std::vector<float> input0Values = { 2, 3, 4, 5};
753 std::vector<float> input1Values = { 10 };
754 std::vector<float> expectedOutputValues = { -8, -7, -6, -5 };
755
756 ElementwiseBinaryTest<float>(tflite::BuiltinOperator_SUB,
757 tflite::ActivationFunctionType_NONE,
758 ::tflite::TensorType_FLOAT32,
759 backends,
760 input0Shape,
761 input1Shape,
762 expectedOutputShape,
763 input0Values,
764 input1Values,
765 expectedOutputValues);
766}
767
768void SubUint8Test(std::vector<armnn::BackendId>& backends)
769{
770 std::vector<int32_t> input0Shape { 1, 1, 2, 2 };
771 std::vector<int32_t> input1Shape { 1, 1, 1, 1 };
772 std::vector<int32_t> expectedOutputShape { 1, 1, 2, 2 };
773
774 std::vector<uint8_t> input0Values = { 10, 12, 14, 16 };
775 std::vector<uint8_t> input1Values = { 2 };
776 std::vector<uint8_t> expectedOutputValues = { 8, 10, 12, 14 };
777
778 ElementwiseBinaryTest<uint8_t>(tflite::BuiltinOperator_SUB,
779 tflite::ActivationFunctionType_NONE,
780 ::tflite::TensorType_UINT8,
781 backends,
782 input0Shape,
783 input1Shape,
784 expectedOutputShape,
785 input0Values,
786 input1Values,
787 expectedOutputValues, 1.0f, 0);
788}
789
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]790TEST_SUITE("ElementwiseBinary_GpuAccTests")
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]791{
792
793TEST_CASE ("ADD_FP32_GpuAcc_Test")
794{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]795 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]796 AddFP32Test(backends);
797}
798
799TEST_CASE ("ADD_Broadcast_GpuAcc_Test")
800{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]801 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]802 AddBroadcastTest(backends);
803}
804
805TEST_CASE ("ADD_Activation_GpuAcc_Test")
806{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]807 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]808 AddActivationTest(backends);
809}
810
811TEST_CASE ("ADD_UINT8_GpuAcc_Test")
812{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]813 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]814 AddUint8Test(backends);
815}
816
817TEST_CASE ("DIV_FP32_GpuAcc_Test")
818{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]819 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]820 DivFP32Test(backends);
821}
822
823TEST_CASE ("DIV_Broadcast_GpuAcc_Test")
824{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]825 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]826 DivBroadcastTest(backends);
827}
828
Jim Flynn4b2f3472021-10-13 21:20:07 +0100[diff] [blame]829TEST_CASE ("FLOORDIV_FP32_GpuAcc_Test")
830{
831 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
832 FloorDivFP32Test(backends);
833}
834
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]835TEST_CASE ("MAX_FP32_GpuAcc_Test")
836{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]837 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]838 MaxFP32Test(backends);
839}
840
841TEST_CASE ("MAX_Broadcast_GpuAcc_Test")
842{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]843 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]844 MaxBroadcastTest(backends);
845}
846
847TEST_CASE ("MAX_UINT8_GpuAcc_Test")
848{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]849 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]850 MaxUint8Test(backends);
851}
852
853TEST_CASE ("MIN_FP32_GpuAcc_Test")
854{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]855 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]856 MinFP32Test(backends);
857}
858
859TEST_CASE ("MIN_Broadcast_GpuAcc_Test")
860{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]861 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]862 MinBroadcastTest(backends);
863}
864
865TEST_CASE ("MIN_UINT8_GpuAcc_Test")
866{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]867 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]868 MinUint8Test(backends);
869}
870
871TEST_CASE ("MUL_FP32_GpuAcc_Test")
872{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]873 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]874 MulFP32Test(backends);
875}
876
877TEST_CASE ("MUL_Broadcast_GpuAcc_Test")
878{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]879 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]880 MulBroadcastTest(backends);
881}
882
883TEST_CASE ("MUL_Activation_GpuAcc_Test")
884{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]885 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]886 MulActivationTest(backends);
887}
888
889TEST_CASE ("MUL_UINT8_GpuAcc_Test")
890{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]891 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]892 MulUint8Test(backends);
893}
894
895TEST_CASE ("SUB_FP32_GpuAcc_Test")
896{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]897 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]898 SubFP32Test(backends);
899}
900
901TEST_CASE ("SUB_Broadcast_GpuAcc_Test")
902{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]903 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]904 SubBroadcastTest(backends);
905}
906
907TEST_CASE ("SUB_UINT8_GpuAcc_Test")
908{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]909 std::vector<armnn::BackendId> backends = { armnn::Compute::GpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]910 SubUint8Test(backends);
911}
912
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]913} //TEST_SUITE("ElementwiseBinary_GpuAccTests")
914
915
916
917TEST_SUITE("ElementwiseBinary_CpuAccTests")
918{
919
920TEST_CASE ("ADD_FP32_CpuAcc_Test")
921{
922 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
923 AddFP32Test(backends);
924}
925
926TEST_CASE ("ADD_Broadcast_CpuAcc_Test")
927{
928 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
929 AddBroadcastTest(backends);
930}
931
Ryan OSheaa544f0f2023-01-25 18:10:20 +0000[diff] [blame]932TEST_CASE ("ADD_Activation_CpuAcc_Test")
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]933{
934 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
935 AddActivationTest(backends);
936}
937
938TEST_CASE ("ADD_UINT8_CpuAcc_Test")
939{
940 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
941 AddUint8Test(backends);
942}
943
944TEST_CASE ("DIV_FP32_CpuAcc_Test")
945{
946 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
947 DivFP32Test(backends);
948}
949
950TEST_CASE ("DIV_Broadcast_CpuAcc_Test")
951{
952 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
953 DivBroadcastTest(backends);
954}
955
Jim Flynn4b2f3472021-10-13 21:20:07 +0100[diff] [blame]956TEST_CASE ("FLOORDIV_FP32_CpuAcc_Test")
957{
958 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
959 FloorDivFP32Test(backends);
960}
961
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]962TEST_CASE ("MAX_FP32_CpuAcc_Test")
963{
964 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
965 MaxFP32Test(backends);
966}
967
968TEST_CASE ("MAX_Broadcast_CpuAcc_Test")
969{
970 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
971 MaxBroadcastTest(backends);
972}
973
974TEST_CASE ("MAX_UINT8_CpuAcc_Test")
975{
976 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
977 MaxUint8Test(backends);
978}
979
980TEST_CASE ("MIN_FP32_CpuAcc_Test")
981{
982 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
983 MinFP32Test(backends);
984}
985
986TEST_CASE ("MIN_Broadcast_CpuAcc_Test")
987{
988 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
989 MinBroadcastTest(backends);
990}
991
992TEST_CASE ("MIN_UINT8_CpuAcc_Test")
993{
994 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
995 MinUint8Test(backends);
996}
997
998TEST_CASE ("MUL_FP32_CpuAcc_Test")
999{
1000 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
1001 MulFP32Test(backends);
1002}
1003
1004TEST_CASE ("MUL_Broadcast_CpuAcc_Test")
1005{
1006 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
1007 MulBroadcastTest(backends);
1008}
1009
1010TEST_CASE ("MUL_Actiation_CpuAcc_Test")
1011{
1012 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
1013 MulActivationTest(backends);
1014}
1015
1016TEST_CASE ("MUL_UINT8_CpuAcc_Test")
1017{
1018 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
1019 MulUint8Test(backends);
1020}
1021
1022TEST_CASE ("SUB_FP32_CpuAcc_Test")
1023{
1024 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
1025 SubFP32Test(backends);
1026}
1027
1028TEST_CASE ("SUB_Broadcast_CpuAcc_Test")
1029{
1030 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
1031 SubBroadcastTest(backends);
1032}
1033
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]1034TEST_CASE ("SUB_UINT8_CpuAcc_Test")
1035{
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]1036 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuAcc };
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]1037 SubUint8Test(backends);
1038}
1039
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]1040} // TEST_SUITE("ElementwiseBinary_CpuAccTests")
1041
1042
1043TEST_SUITE("ElementwiseBinary_CpuRefTests")
1044{
1045
1046TEST_CASE ("ADD_FP32_CpuRef_Test")
1047{
1048 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1049 AddFP32Test(backends);
1050}
1051
1052TEST_CASE ("ADD_Broadcast_CpuRef_Test")
1053{
1054 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1055 AddBroadcastTest(backends);
1056}
1057
Sadik Armaganf7ac72c2021-05-05 15:03:50 +0100[diff] [blame]1058TEST_CASE ("ADD_Constant_Input_CpuRef_Test")
1059{
1060 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1061 AddConstInputTest(backends);
1062}
1063
Ryan OSheaa544f0f2023-01-25 18:10:20 +0000[diff] [blame]1064TEST_CASE ("ADD_Activation_CpuRef_Test")
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]1065{
1066 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1067 AddActivationTest(backends);
1068}
1069
1070TEST_CASE ("ADD_UINT8_CpuRef_Test")
1071{
1072 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1073 AddUint8Test(backends);
1074}
1075
1076TEST_CASE ("DIV_FP32_CpuRef_Test")
1077{
1078 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1079 DivFP32Test(backends);
1080}
1081
1082TEST_CASE ("DIV_Broadcast_CpuRef_Test")
1083{
1084 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1085 DivBroadcastTest(backends);
1086}
1087
Jim Flynn4b2f3472021-10-13 21:20:07 +0100[diff] [blame]1088TEST_CASE ("FLOORDIV_FP32_CpuRef_Test")
1089{
1090 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1091 FloorDivFP32Test(backends);
1092}
1093
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]1094TEST_CASE ("DIV_UINT8_CpuRef_Test")
1095{
1096 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1097 DivUint8Test(backends);
1098}
1099
1100TEST_CASE ("MAX_FP32_CpuRef_Test")
1101{
1102 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1103 MaxFP32Test(backends);
1104}
1105
1106TEST_CASE ("MAX_Broadcast_CpuRef_Test")
1107{
1108 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1109 MaxBroadcastTest(backends);
1110}
1111
1112TEST_CASE ("MAX_UINT8_CpuRef_Test")
1113{
1114 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1115 MaxUint8Test(backends);
1116}
1117
1118TEST_CASE ("MIN_FP32_CpuRef_Test")
1119{
1120 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1121 MinFP32Test(backends);
1122}
1123
1124TEST_CASE ("MIN_Broadcast_CpuRef_Test")
1125{
1126 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1127 MinBroadcastTest(backends);
1128}
1129
1130TEST_CASE ("MIN_UINT8_CpuRef_Test")
1131{
1132 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1133 MinUint8Test(backends);
1134}
1135
1136TEST_CASE ("MUL_FP32_CpuRef_Test")
1137{
1138 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1139 MulFP32Test(backends);
1140}
1141
1142TEST_CASE ("MUL_Broadcast_CpuRef_Test")
1143{
1144 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1145 MulBroadcastTest(backends);
1146}
1147
1148TEST_CASE ("MUL_Actiation_CpuRef_Test")
1149{
1150 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1151 MulActivationTest(backends);
1152}
1153
1154TEST_CASE ("MUL_UINT8_CpuRef_Test")
1155{
1156 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1157 MulUint8Test(backends);
1158}
1159
1160TEST_CASE ("SUB_FP32_CpuRef_Test")
1161{
1162 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1163 SubFP32Test(backends);
1164}
1165
1166TEST_CASE ("SUB_Broadcast_CpuRef_Test")
1167{
1168 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1169 SubBroadcastTest(backends);
1170}
1171
1172TEST_CASE ("SUB_UINT8_CpuRef_Test")
1173{
1174 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1175 SubUint8Test(backends);
1176}
1177
John Mcloughlin0ec00872023-05-15 17:03:49 +0100[diff] [blame]1178TEST_CASE ("SqDiffFP32_CpuRef_Test")
1179{
1180 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1181 SqDiffFP32Test(backends);
1182}
1183
1184TEST_CASE ("PowerFP32_CpuRef_Test")
1185{
1186 std::vector<armnn::BackendId> backends = { armnn::Compute::CpuRef };
1187 PowerFP32Test(backends);
1188}
1189
Jan Eilers187b3a72020-11-19 17:50:34 +0000[diff] [blame]1190} // TEST_SUITE("ElementwiseBinary_CpuRefTests")
Sadik Armagan21a94ff2020-11-09 08:38:30 +0000[diff] [blame]1191
Jim Flynn4b2f3472021-10-13 21:20:07 +0100[diff] [blame]1192} // namespace armnnDelegate