Huawei_Technology
/
mindspore
Not watched
1
0
Fork 0
Code
Releases 13 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 561ab2b473
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '561ab2b473'
${ noResults }
mindspore/mindspore/lite/nnacl/fp16/arithmetic_fp16.c

1291 lines
43 kB
Raw Blame History 

  1. /**

  2.  * Copyright 2020 Huawei Technologies Co., Ltd

  3.  *

  4.  * Licensed under the Apache License, Version 2.0 (the "License");

  5.  * you may not use this file except in compliance with the License.

  6.  * You may obtain a copy of the License at

  7.  *

  8.  * http://www.apache.org/licenses/LICENSE-2.0

  9.  *

  10.  * Unless required by applicable law or agreed to in writing, software

  11.  * distributed under the License is distributed on an "AS IS" BASIS,

  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  13.  * See the License for the specific language governing permissions and

  14.  * limitations under the License.

  15.  */

  16. 

  17. #include "nnacl/fp16/arithmetic_fp16.h"

  18. #include <math.h>

  19. #include "nnacl/arithmetic_common.h"

  20. #include "nnacl/nnacl_utils.h"

  21. 

  22. void TileOneDimensionFp16(float16_t *inData, float16_t *outData, int dim, size_t ndim, int *inShape, int *inStrides,

  23.                           int *outStrides, int *multiple) {

  24.   int srcDimSize = inShape[dim];

  25.   if (dim == ndim - 1) {

  26.     for (int i = 0; i < multiple[dim]; i++) {

  27.       memcpy(outData, inData, srcDimSize * sizeof(float16_t));

  28.       outData += srcDimSize;

  29.     }

  30.     return;

  31.   }

  32.   for (size_t i = 0; i < srcDimSize; i++) {

  33.     for (size_t j = 0; j < multiple[dim]; j++) {

  34.       TileOneDimensionFp16(inData + inStrides[dim] * i, outData + outStrides[dim] * (i + j * srcDimSize), dim + 1, ndim,

  35.                            inShape, inStrides, outStrides, multiple);

  36.     }

  37.   }

  38. }

  39. 

  40. void TileDimensionsFp16(float16_t *data0, float16_t *data1, float16_t *tile_data0, float16_t *tile_data1,

  41.                         ArithmeticParameter *param) {

  42.   CalcMultiplesAndStrides(param);

  43.   TileOneDimensionFp16(data0, tile_data0, 0, param->ndim_, param->in_shape0_, param->in_strides0_, param->out_strides_,

  44.                        param->multiples0_);

  45.   TileOneDimensionFp16(data1, tile_data1, 0, param->ndim_, param->in_shape1_, param->in_strides1_, param->out_strides_,

  46.                        param->multiples1_);

  47. }

  48. 

  49. int ElementMulFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size) {

  50.   int index = 0;

  51. #ifdef ENABLE_NEON

  52.   for (; index <= element_size - 8; index += C8NUM) {

  53.     float16x8_t vin0 = vld1q_f16(input0 + index);

  54.     float16x8_t vin1 = vld1q_f16(input1 + index);

  55.     float16x8_t vout = vmulq_f16(vin0, vin1);

  56.     vst1q_f16(output + index, vout);

  57.   }

  58. #endif

  59.   for (; index < element_size; index++) {

  60.     output[index] = input0[index] * input1[index];

  61.   }

  62.   return NNACL_OK;

  63. }

  64. 

  65. int ElementOptMulFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size,

  66.                       ArithmeticParameter *param) {

  67. #ifdef ENABLE_NEON

  68.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  69.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  70. #endif

  71.   int index = 0;

  72.   if (param->in_elements_num0_ == 1) {

  73. #ifdef ENABLE_NEON

  74.     for (; index <= element_size - 8; index += C8NUM) {

  75.       float16x8_t vin1 = vld1q_f16(input1 + index);

  76.       float16x8_t vout = vmulq_f16(vin0_opt, vin1);

  77.       vst1q_f16(output + index, vout);

  78.     }

  79. #endif

  80.     for (; index < element_size; index++) {

  81.       output[index] = input0[0] * input1[index];

  82.     }

  83.   } else {

  84. #ifdef ENABLE_NEON

  85.     for (; index <= element_size - 8; index += C8NUM) {

  86.       float16x8_t vin0 = vld1q_f16(input0 + index);

  87.       float16x8_t vout = vmulq_f16(vin0, vin1_opt);

  88.       vst1q_f16(output + index, vout);

  89.     }

  90. #endif

  91.     for (; index < element_size; index++) {

  92.       output[index] = input0[index] * input1[0];

  93.     }

  94.   }

  95.   return NNACL_OK;

  96. }

  97. 

  98. int ElementMulReluFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size) {

  99. #ifdef ENABLE_NEON

  100.   float16x8_t zeros = vdupq_n_f16(0.0);

  101. #endif

  102.   int index = 0;

  103. #ifdef ENABLE_NEON

  104.   for (; index <= element_size - 8; index += C8NUM) {

  105.     float16x8_t vin0 = vld1q_f16(input0 + index);

  106.     float16x8_t vin1 = vld1q_f16(input1 + index);

  107.     float16x8_t vout = vmulq_f16(vin0, vin1);

  108.     vout = vmaxq_f16(vout, zeros);

  109.     vst1q_f16(output + index, vout);

  110.   }

  111. #endif

  112.   for (; index < element_size; index++) {

  113.     float16_t res = input0[index] * input1[index];

  114.     output[index] = res > 0 ? res : 0;

  115.   }

  116.   return NNACL_OK;

  117. }

  118. 

  119. int ElementOptMulReluFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size,

  120.                           ArithmeticParameter *param) {

  121. #ifdef ENABLE_NEON

  122.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  123.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  124.   float16x8_t zeros = vdupq_n_f16(0.0);

  125. #endif

  126.   int index = 0;

  127.   if (param->in_elements_num0_ == 1) {

  128. #ifdef ENABLE_NEON

  129.     for (; index <= element_size - 8; index += C8NUM) {

  130.       float16x8_t vin1 = vld1q_f16(input1 + index);

  131.       float16x8_t vout = vmulq_f16(vin0_opt, vin1);

  132.       vout = vmaxq_f16(vout, zeros);

  133.       vst1q_f16(output + index, vout);

  134.     }

  135. #endif

  136.     for (; index < element_size; index++) {

  137.       float16_t res = input0[0] * input1[index];

  138.       output[index] = res > 0 ? res : 0;

  139.     }

  140.   } else {

  141. #ifdef ENABLE_NEON

  142.     for (; index <= element_size - 8; index += C8NUM) {

  143.       float16x8_t vin0 = vld1q_f16(input0 + index);

  144.       float16x8_t vout = vmulq_f16(vin0, vin1_opt);

  145.       vout = vmaxq_f16(vout, zeros);

  146.       vst1q_f16(output + index, vout);

  147.     }

  148. #endif

  149.     for (; index < element_size; index++) {

  150.       float16_t res = input0[index] * input1[0];

  151.       output[index] = res > 0 ? res : 0;

  152.     }

  153.   }

  154.   return NNACL_OK;

  155. }

  156. 

  157. int ElementMulRelu6Fp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size) {

  158.   int index = 0;

  159. #ifdef ENABLE_NEON

  160.   float16x8_t zeros = vdupq_n_f16(0.0);

  161.   float16x8_t bounds = vdupq_n_f16(6.0);

  162.   for (; index <= element_size - 8; index += C8NUM) {

  163.     float16x8_t vin0 = vld1q_f16(input0 + index);

  164.     float16x8_t vin1 = vld1q_f16(input1 + index);

  165.     float16x8_t vout = vmulq_f16(vin0, vin1);

  166.     vout = vminq_f16(vmaxq_f16(vout, zeros), bounds);

  167.     vst1q_f16(output + index, vout);

  168.   }

  169. #endif

  170.   for (; index < element_size; index++) {

  171.     output[index] = MSMIN(MSMAX(input0[index] * input1[index], 0), 6);

  172.   }

  173.   return NNACL_OK;

  174. }

  175. 

  176. int ElementOptMulRelu6Fp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size,

  177.                            ArithmeticParameter *param) {

  178. #ifdef ENABLE_NEON

  179.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  180.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  181.   float16x8_t zeros = vdupq_n_f16(0.0);

  182.   float16x8_t bounds = vdupq_n_f16(6.0);

  183. #endif

  184.   int index = 0;

  185.   if (param->in_elements_num0_ == 1) {

  186. #ifdef ENABLE_NEON

  187.     for (; index <= element_size - 8; index += C8NUM) {

  188.       float16x8_t vin1 = vld1q_f16(input1 + index);

  189.       float16x8_t vout = vmulq_f16(vin0_opt, vin1);

  190.       vout = vminq_f16(vmaxq_f16(vout, zeros), bounds);

  191.       vst1q_f16(output + index, vout);

  192.     }

  193. #endif

  194.     for (; index < element_size; index++) {

  195.       output[index] = MSMIN(MSMAX(input0[0] * input1[index], 0), 6);

  196.     }

  197.   } else {

  198. #ifdef ENABLE_NEON

  199.     for (; index <= element_size - 8; index += C8NUM) {

  200.       float16x8_t vin0 = vld1q_f16(input0 + index);

  201.       float16x8_t vout = vmulq_f16(vin0, vin1_opt);

  202.       vout = vminq_f16(vmaxq_f16(vout, zeros), bounds);

  203.       vst1q_f16(output + index, vout);

  204.     }

  205. #endif

  206.     for (; index < element_size; index++) {

  207.       output[index] = MSMIN(MSMAX(input0[index] * input1[0], 0), 6);

  208.     }

  209.   }

  210.   return NNACL_OK;

  211. }

  212. 

  213. int ElementAddFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size) {

  214.   int index = 0;

  215. #ifdef ENABLE_NEON

  216.   for (; index <= element_size - 8; index += C8NUM) {

  217.     float16x8_t vin0 = vld1q_f16(input0 + index);

  218.     float16x8_t vin1 = vld1q_f16(input1 + index);

  219.     float16x8_t vout = vaddq_f16(vin0, vin1);

  220.     vst1q_f16(output + index, vout);

  221.   }

  222. #endif

  223.   for (; index < element_size; index++) {

  224.     output[index] = input0[index] + input1[index];

  225.   }

  226.   return NNACL_OK;

  227. }

  228. 

  229. int ElementOptAddFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size,

  230.                       ArithmeticParameter *param) {

  231. #ifdef ENABLE_NEON

  232.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  233.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  234. #endif

  235.   int index = 0;

  236.   if (param->in_elements_num0_ == 1) {

  237. #ifdef ENABLE_NEON

  238.     for (; index <= element_size - 8; index += C8NUM) {

  239.       float16x8_t vin1 = vld1q_f16(input1 + index);

  240.       float16x8_t vout = vaddq_f16(vin0_opt, vin1);

  241.       vst1q_f16(output + index, vout);

  242.     }

  243. #endif

  244.     for (; index < element_size; index++) {

  245.       output[index] = input0[0] + input1[index];

  246.     }

  247.   } else {

  248. #ifdef ENABLE_NEON

  249.     for (; index <= element_size - 8; index += C8NUM) {

  250.       float16x8_t vin0 = vld1q_f16(input0 + index);

  251.       float16x8_t vout = vaddq_f16(vin0, vin1_opt);

  252.       vst1q_f16(output + index, vout);

  253.     }

  254. #endif

  255.     for (; index < element_size; index++) {

  256.       output[index] = input0[index] + input1[0];

  257.     }

  258.   }

  259.   return NNACL_OK;

  260. }

  261. 

  262. int ElementAddReluFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size) {

  263.   int index = 0;

  264. #ifdef ENABLE_NEON

  265.   float16x8_t zeros = vdupq_n_f16(0.0);

  266.   for (; index <= element_size - 8; index += C8NUM) {

  267.     float16x8_t vin0 = vld1q_f16(input0 + index);

  268.     float16x8_t vin1 = vld1q_f16(input1 + index);

  269.     float16x8_t vout = vaddq_f16(vin0, vin1);

  270.     vout = vmaxq_f16(vout, zeros);

  271.     vst1q_f16(output + index, vout);

  272.   }

  273. #endif

  274.   for (; index < element_size; index++) {

  275.     float16_t res = input0[index] + input1[index];

  276.     output[index] = res > 0 ? res : 0;

  277.   }

  278.   return NNACL_OK;

  279. }

  280. 

  281. int ElementOptAddReluFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size,

  282.                           ArithmeticParameter *param) {

  283. #ifdef ENABLE_NEON

  284.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  285.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  286.   float16x8_t zeros = vdupq_n_f16(0.0);

  287. #endif

  288.   int index = 0;

  289.   if (param->in_elements_num0_ == 1) {

  290. #ifdef ENABLE_NEON

  291.     for (; index <= element_size - 8; index += C8NUM) {

  292.       float16x8_t vin1 = vld1q_f16(input1 + index);

  293.       float16x8_t vout = vaddq_f16(vin0_opt, vin1);

  294.       vout = vmaxq_f16(vout, zeros);

  295.       vst1q_f16(output + index, vout);

  296.     }

  297. #endif

  298.     for (; index < element_size; index++) {

  299.       float16_t res = input0[0] + input1[index];

  300.       output[index] = res > 0 ? res : 0;

  301.     }

  302.   } else {

  303. #ifdef ENABLE_NEON

  304.     for (; index <= element_size - 8; index += C8NUM) {

  305.       float16x8_t vin0 = vld1q_f16(input0 + index);

  306.       float16x8_t vout = vaddq_f16(vin0, vin1_opt);

  307.       vout = vmaxq_f16(vout, zeros);

  308.       vst1q_f16(output + index, vout);

  309.     }

  310. #endif

  311.     for (; index < element_size; index++) {

  312.       float16_t res = input0[index] + input1[0];

  313.       output[index] = res > 0 ? res : 0;

  314.     }

  315.   }

  316.   return NNACL_OK;

  317. }

  318. 

  319. int ElementAddRelu6Fp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size) {

  320.   int index = 0;

  321. #ifdef ENABLE_NEON

  322.   float16x8_t zeros = vdupq_n_f16(0.0);

  323.   float16x8_t bounds = vdupq_n_f16(6.0);

  324.   for (; index <= element_size - 8; index += C8NUM) {

  325.     float16x8_t vin0 = vld1q_f16(input0 + index);

  326.     float16x8_t vin1 = vld1q_f16(input1 + index);

  327.     float16x8_t vout = vaddq_f16(vin0, vin1);

  328.     vout = vminq_f16(vmaxq_f16(vout, zeros), bounds);

  329.     vst1q_f16(output + index, vout);

  330.   }

  331. #endif

  332.   for (; index < element_size; index++) {

  333.     output[index] = MSMIN(MSMAX(input0[index] + input1[index], 0), 6);

  334.   }

  335.   return NNACL_OK;

  336. }

  337. 

  338. int ElementOptAddRelu6Fp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size,

  339.                            ArithmeticParameter *param) {

  340. #ifdef ENABLE_NEON

  341.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  342.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  343.   float16x8_t zeros = vdupq_n_f16(0.0);

  344.   float16x8_t bounds = vdupq_n_f16(6.0);

  345. #endif

  346.   int index = 0;

  347.   if (param->in_elements_num0_ == 1) {

  348. #ifdef ENABLE_NEON

  349.     for (; index <= element_size - 8; index += C8NUM) {

  350.       float16x8_t vin1 = vld1q_f16(input1 + index);

  351.       float16x8_t vout = vaddq_f16(vin0_opt, vin1);

  352.       vout = vminq_f16(vmaxq_f16(vout, zeros), bounds);

  353.       vst1q_f16(output + index, vout);

  354.     }

  355. #endif

  356.     for (; index < element_size; index++) {

  357.       output[index] = MSMIN(MSMAX(input0[0] + input1[index], 0), 6);

  358.     }

  359.   } else {

  360. #ifdef ENABLE_NEON

  361.     for (; index <= element_size - 8; index += C8NUM) {

  362.       float16x8_t vin0 = vld1q_f16(input0 + index);

  363.       float16x8_t vout = vaddq_f16(vin0, vin1_opt);

  364.       vout = vminq_f16(vmaxq_f16(vout, zeros), bounds);

  365.       vst1q_f16(output + index, vout);

  366.     }

  367. #endif

  368.     for (; index < element_size; index++) {

  369.       output[index] = MSMIN(MSMAX(input0[index] + input1[0], 0), 6);

  370.     }

  371.   }

  372.   return NNACL_OK;

  373. }

  374. 

  375. int ElementSubFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size) {

  376.   int index = 0;

  377. #ifdef ENABLE_NEON

  378.   for (; index <= element_size - 8; index += C8NUM) {

  379.     float16x8_t vin0 = vld1q_f16(input0 + index);

  380.     float16x8_t vin1 = vld1q_f16(input1 + index);

  381.     float16x8_t vout = vsubq_f16(vin0, vin1);

  382.     vst1q_f16(output + index, vout);

  383.   }

  384. #endif

  385.   for (; index < element_size; index++) {

  386.     output[index] = input0[index] - input1[index];

  387.   }

  388.   return NNACL_OK;

  389. }

  390. 

  391. int ElementOptSubFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size,

  392.                       ArithmeticParameter *param) {

  393. #ifdef ENABLE_NEON

  394.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  395.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  396. #endif

  397.   int index = 0;

  398.   if (param->in_elements_num0_ == 1) {

  399. #ifdef ENABLE_NEON

  400.     for (; index <= element_size - 8; index += C8NUM) {

  401.       float16x8_t vin1 = vld1q_f16(input1 + index);

  402.       float16x8_t vout = vsubq_f16(vin0_opt, vin1);

  403.       vst1q_f16(output + index, vout);

  404.     }

  405. #endif

  406.     for (; index < element_size; index++) {

  407.       output[index] = input0[0] - input1[index];

  408.     }

  409.   } else {

  410. #ifdef ENABLE_NEON

  411.     for (; index <= element_size - 8; index += C8NUM) {

  412.       float16x8_t vin0 = vld1q_f16(input0 + index);

  413.       float16x8_t vout = vsubq_f16(vin0, vin1_opt);

  414.       vst1q_f16(output + index, vout);

  415.     }

  416. #endif

  417.     for (; index < element_size; index++) {

  418.       output[index] = input0[index] - input1[0];

  419.     }

  420.   }

  421.   return NNACL_OK;

  422. }

  423. 

  424. int ElementSubReluFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size) {

  425.   int index = 0;

  426. #ifdef ENABLE_NEON

  427.   float16x8_t zeros = vdupq_n_f16(0.0);

  428.   for (; index <= element_size - 8; index += C8NUM) {

  429.     float16x8_t vin0 = vld1q_f16(input0 + index);

  430.     float16x8_t vin1 = vld1q_f16(input1 + index);

  431.     float16x8_t vout = vsubq_f16(vin0, vin1);

  432.     vout = vmaxq_f16(vout, zeros);

  433.     vst1q_f16(output + index, vout);

  434.   }

  435. #endif

  436.   for (; index < element_size; index++) {

  437.     float16_t res = input0[index] - input1[index];

  438.     output[index] = res > 0 ? res : 0;

  439.   }

  440.   return NNACL_OK;

  441. }

  442. 

  443. int ElementOptSubReluFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size,

  444.                           ArithmeticParameter *param) {

  445. #ifdef ENABLE_NEON

  446.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  447.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  448.   float16x8_t zeros = vdupq_n_f16(0.0);

  449. #endif

  450.   int index = 0;

  451.   if (param->in_elements_num0_ == 1) {

  452. #ifdef ENABLE_NEON

  453.     for (; index <= element_size - 8; index += C8NUM) {

  454.       float16x8_t vin1 = vld1q_f16(input1 + index);

  455.       float16x8_t vout = vsubq_f16(vin0_opt, vin1);

  456.       vout = vmaxq_f16(vout, zeros);

  457.       vst1q_f16(output + index, vout);

  458.     }

  459. #endif

  460.     for (; index < element_size; index++) {

  461.       float16_t res = input0[0] - input1[index];

  462.       output[index] = res > 0 ? res : 0;

  463.     }

  464.   } else {

  465. #ifdef ENABLE_NEON

  466.     for (; index <= element_size - 8; index += C8NUM) {

  467.       float16x8_t vin0 = vld1q_f16(input0 + index);

  468.       float16x8_t vout = vsubq_f16(vin0, vin1_opt);

  469.       vout = vmaxq_f16(vout, zeros);

  470.       vst1q_f16(output + index, vout);

  471.     }

  472. #endif

  473.     for (; index < element_size; index++) {

  474.       float16_t res = input0[index] - input1[0];

  475.       output[index] = res > 0 ? res : 0;

  476.     }

  477.   }

  478.   return NNACL_OK;

  479. }

  480. 

  481. int ElementSubRelu6Fp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size) {

  482.   int index = 0;

  483. #ifdef ENABLE_NEON

  484.   float16x8_t zeros = vdupq_n_f16(0.0);

  485.   float16x8_t bounds = vdupq_n_f16(6.0);

  486.   for (; index <= element_size - 8; index += C8NUM) {

  487.     float16x8_t vin0 = vld1q_f16(input0 + index);

  488.     float16x8_t vin1 = vld1q_f16(input1 + index);

  489.     float16x8_t vout = vsubq_f16(vin0, vin1);

  490.     vout = vminq_f16(vmaxq_f16(vout, zeros), bounds);

  491.     vst1q_f16(output + index, vout);

  492.   }

  493. #endif

  494.   for (; index < element_size; index++) {

  495.     output[index] = MSMIN(MSMAX(input0[index] - input1[index], 0), 6);

  496.   }

  497.   return NNACL_OK;

  498. }

  499. 

  500. int ElementOptSubRelu6Fp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size,

  501.                            ArithmeticParameter *param) {

  502. #ifdef ENABLE_NEON

  503.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  504.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  505.   float16x8_t zeros = vdupq_n_f16(0.0);

  506.   float16x8_t bounds = vdupq_n_f16(6.0);

  507. #endif

  508.   int index = 0;

  509.   if (param->in_elements_num0_ == 1) {

  510. #ifdef ENABLE_NEON

  511.     for (; index <= element_size - 8; index += C8NUM) {

  512.       float16x8_t vin1 = vld1q_f16(input1 + index);

  513.       float16x8_t vout = vsubq_f16(vin0_opt, vin1);

  514.       vout = vminq_f16(vmaxq_f16(vout, zeros), bounds);

  515.       vst1q_f16(output + index, vout);

  516.     }

  517. #endif

  518.     for (; index < element_size; index++) {

  519.       output[index] = MSMIN(MSMAX(input0[0] - input1[index], 0), 6);

  520.     }

  521.   } else {

  522. #ifdef ENABLE_NEON

  523.     for (; index <= element_size - 8; index += C8NUM) {

  524.       float16x8_t vin0 = vld1q_f16(input0 + index);

  525.       float16x8_t vout = vsubq_f16(vin0, vin1_opt);

  526.       vout = vminq_f16(vmaxq_f16(vout, zeros), bounds);

  527.       vst1q_f16(output + index, vout);

  528.     }

  529. #endif

  530.     for (; index < element_size; index++) {

  531.       output[index] = MSMIN(MSMAX(input0[index] - input1[0], 0), 6);

  532.     }

  533.   }

  534.   return NNACL_OK;

  535. }

  536. 

  537. int ElementDivFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size) {

  538.   int index = 0;

  539. #ifdef ENABLE_NEON

  540.   for (; index <= element_size - 8; index += C8NUM) {

  541.     float16x8_t vin0 = vld1q_f16(input0 + index);

  542.     float16x8_t vin1 = vld1q_f16(input1 + index);

  543.     float16x8_t vout = vdivq_f16(vin0, vin1);

  544.     vst1q_f16(output + index, vout);

  545.   }

  546. #endif

  547.   for (; index < element_size; index++) {

  548.     NNACL_ASSERT(input1[index] != 0);

  549.     output[index] = input0[index] / input1[index];

  550.   }

  551.   return NNACL_OK;

  552. }

  553. 

  554. int ElementOptDivFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size,

  555.                       ArithmeticParameter *param) {

  556. #ifdef ENABLE_NEON

  557.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  558.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  559. #endif

  560.   int index = 0;

  561.   if (param->in_elements_num0_ == 1) {

  562. #ifdef ENABLE_NEON

  563.     for (; index <= element_size - 8; index += C8NUM) {

  564.       float16x8_t vin1 = vld1q_f16(input1 + index);

  565.       float16x8_t vout = vdivq_f16(vin0_opt, vin1);

  566.       vst1q_f16(output + index, vout);

  567.     }

  568. #endif

  569.     for (; index < element_size; index++) {

  570.       NNACL_ASSERT(input1[index] != 0);

  571.       output[index] = input0[0] / input1[index];

  572.     }

  573.   } else {

  574.     if (input1[0] == 0) {

  575.       return NNACL_ERRCODE_DIVISOR_ZERO;

  576.     }

  577. #ifdef ENABLE_NEON

  578.     for (; index <= element_size - 8; index += C8NUM) {

  579.       float16x8_t vin0 = vld1q_f16(input0 + index);

  580.       float16x8_t vout = vdivq_f16(vin0, vin1_opt);

  581.       vst1q_f16(output + index, vout);

  582.     }

  583. #endif

  584.     for (; index < element_size; index++) {

  585.       output[index] = input0[index] / input1[0];

  586.     }

  587.   }

  588.   return NNACL_OK;

  589. }

  590. 

  591. int ElementDivReluFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size) {

  592.   int index = 0;

  593. #ifdef ENABLE_NEON

  594.   float16x8_t zeros = vdupq_n_f16(0.0);

  595.   for (; index <= element_size - 8; index += C8NUM) {

  596.     float16x8_t vin0 = vld1q_f16(input0 + index);

  597.     float16x8_t vin1 = vld1q_f16(input1 + index);

  598.     float16x8_t vout = vdivq_f16(vin0, vin1);

  599.     vout = vmaxq_f16(vout, zeros);

  600.     vst1q_f16(output + index, vout);

  601.   }

  602. #endif

  603.   for (; index < element_size; index++) {

  604.     if (input1[index] == 0) {

  605.       return NNACL_ERRCODE_DIVISOR_ZERO;

  606.     }

  607.     NNACL_ASSERT(input1[index] != 0);

  608.     float16_t res = input0[index] / input1[index];

  609.     output[index] = res > 0 ? res : 0;

  610.   }

  611.   return NNACL_OK;

  612. }

  613. 

  614. int ElementOptDivReluFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size,

  615.                           ArithmeticParameter *param) {

  616. #ifdef ENABLE_NEON

  617.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  618.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  619.   float16x8_t zeros = vdupq_n_f16(0.0);

  620. #endif

  621.   int index = 0;

  622.   if (param->in_elements_num0_ == 1) {

  623. #ifdef ENABLE_NEON

  624.     for (; index <= element_size - 8; index += C8NUM) {

  625.       float16x8_t vin1 = vld1q_f16(input1 + index);

  626.       float16x8_t vout = vmaxq_f16(vdivq_f16(vin0_opt, vin1), zeros);

  627.       vst1q_f16(output + index, vout);

  628.     }

  629. #endif

  630.     for (; index < element_size; index++) {

  631.       if (input1[index] == 0) {

  632.         return NNACL_ERRCODE_DIVISOR_ZERO;

  633.       }

  634.       NNACL_ASSERT(input1[index] != 0);

  635.       output[index] = MSMAX(input0[0] / input1[index], 0);

  636.     }

  637.   } else {

  638.     if (input1[0] == 0) {

  639.       return NNACL_ERRCODE_DIVISOR_ZERO;

  640.     }

  641. #ifdef ENABLE_NEON

  642.     for (; index <= element_size - 8; index += C8NUM) {

  643.       float16x8_t vin0 = vld1q_f16(input0 + index);

  644.       float16x8_t vout = vmaxq_f16(vdivq_f16(vin0, vin1_opt), zeros);

  645.       vst1q_f16(output + index, vout);

  646.     }

  647. #endif

  648.     for (; index < element_size; index++) {

  649.       output[index] = MSMAX(input0[index] / input1[0], 0);

  650.     }

  651.   }

  652.   return NNACL_OK;

  653. }

  654. 

  655. int ElementDivRelu6Fp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size) {

  656.   int index = 0;

  657. #ifdef ENABLE_NEON

  658.   float16x8_t zeros = vdupq_n_f16(0.0);

  659.   float16x8_t bounds = vdupq_n_f16(6.0);

  660.   for (; index <= element_size - 8; index += C8NUM) {

  661.     float16x8_t vin0 = vld1q_f16(input0 + index);

  662.     float16x8_t vin1 = vld1q_f16(input1 + index);

  663.     float16x8_t vout = vdivq_f16(vin0, vin1);

  664.     vout = vminq_f16(vmaxq_f16(vout, zeros), bounds);

  665.     vst1q_f16(output + index, vout);

  666.   }

  667. #endif

  668.   for (; index < element_size; index++) {

  669.     if (input1[index] == 0) {

  670.       return NNACL_ERRCODE_DIVISOR_ZERO;

  671.     }

  672.     output[index] = MSMIN(MSMAX(input0[index] / input1[index], 0), 6);

  673.   }

  674.   return NNACL_OK;

  675. }

  676. 

  677. int ElementOptDivRelu6Fp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size,

  678.                            ArithmeticParameter *param) {

  679. #ifdef ENABLE_NEON

  680.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  681.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  682.   float16x8_t zeros = vdupq_n_f16(0.0);

  683.   float16x8_t bounds = vdupq_n_f16(6.0);

  684. #endif

  685.   int index = 0;

  686.   if (param->in_elements_num0_ == 1) {

  687. #ifdef ENABLE_NEON

  688.     for (; index <= element_size - 8; index += C8NUM) {

  689.       float16x8_t vin1 = vld1q_f16(input1 + index);

  690.       float16x8_t vout = vminq_f16(vmaxq_f16(vdivq_f16(vin0_opt, vin1), zeros), bounds);

  691.       vst1q_f16(output + index, vout);

  692.     }

  693. #endif

  694.     for (; index < element_size; index++) {

  695.       if (input1[index] == 0) {

  696.         return NNACL_ERRCODE_DIVISOR_ZERO;

  697.       }

  698.       output[index] = MSMIN(MSMAX(input0[0] / input1[index], 0), 6);

  699.     }

  700.   } else {

  701.     if (input1[0] == 0) {

  702.       return NNACL_ERRCODE_DIVISOR_ZERO;

  703.     }

  704. #ifdef ENABLE_NEON

  705.     for (; index <= element_size - 8; index += C8NUM) {

  706.       float16x8_t vin0 = vld1q_f16(input0 + index);

  707.       float16x8_t vout = vminq_f16(vmaxq_f16(vdivq_f16(vin0, vin1_opt), zeros), bounds);

  708.       vst1q_f16(output + index, vout);

  709.     }

  710. #endif

  711.     for (; index < element_size; index++) {

  712.       output[index] = MSMIN(MSMAX(input0[index] / input1[0], 0), 6);

  713.     }

  714.   }

  715.   return NNACL_OK;

  716. }

  717. 

  718. int ElementFloorModFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size) {

  719.   for (int i = 0; i < element_size; ++i) {

  720.     if (input1[i] == 0) {

  721.       return NNACL_ERRCODE_DIVISOR_ZERO;

  722.     }

  723.     output[i] = input0[i] - floorf(input0[i] / input1[i]) * input1[i];

  724.   }

  725.   return NNACL_OK;

  726. }

  727. 

  728. int ElementOptFloorModFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size,

  729.                            ArithmeticParameter *param) {

  730.   if (param->in_elements_num1_ == 1) {

  731.     for (int i = 0; i < element_size; ++i) {

  732.       NNACL_ASSERT(input1[0] != 0);

  733.       output[i] = input0[i] - floorf(input0[i] / input1[0]) * input1[0];

  734.     }

  735.   } else {

  736.     for (int i = 0; i < element_size; ++i) {

  737.       NNACL_ASSERT(input1[i] != 0);

  738.       output[i] = input0[i] - floorf(input0[i] / input1[i]) * input1[i];

  739.     }

  740.   }

  741.   return NNACL_OK;

  742. }

  743. 

  744. int ElementFloorDivFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size) {

  745.   for (int i = 0; i < element_size; ++i) {

  746.     NNACL_ASSERT(input1[i] != 0);

  747.     output[i] = floorf(input0[i] / input1[i]);

  748.   }

  749.   return NNACL_OK;

  750. }

  751. int ElementOptFloorDivFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size,

  752.                            ArithmeticParameter *param) {

  753.   if (param->in_elements_num1_ == 1) {

  754.     for (int i = 0; i < element_size; ++i) {

  755.       NNACL_ASSERT(input1[0] != 0);

  756.       output[i] = floorf(input0[i] / input1[0]);

  757.     }

  758.   } else {

  759.     for (int i = 0; i < element_size; ++i) {

  760.       NNACL_ASSERT(input1[i] != 0);

  761.       output[i] = floorf(input0[i] / input1[i]);

  762.     }

  763.   }

  764.   return NNACL_OK;

  765. }

  766. 

  767. int ElementLogicalAndFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size) {

  768.   int index = 0;

  769. #ifdef ENABLE_NEON

  770.   float16x8_t vtrue = vdupq_n_f16(1);

  771.   float16x8_t vfalse = vdupq_n_f16(0);

  772.   uint16x8_t mask = vmovq_n_u16(((uint16_t)(1u << 15) - 1));

  773.   uint16x8_t zeros = vdupq_n_u16(0);

  774.   for (; index <= element_size - 8; index += C8NUM) {

  775.     uint16x8_t vin0 = vandq_u16(vreinterpretq_s16_f16(vld1q_f16(input0 + index)), mask);

  776.     uint16x8_t vin1 = vandq_u16(vreinterpretq_s16_f16(vld1q_f16(input1 + index)), mask);

  777.     float16x8_t vout = vbslq_f16(vceqq_u16(vandq_u16(vin0, vin1), zeros), vfalse, vtrue);

  778.     vst1q_f16(output + index, vout);

  779.   }

  780. #endif

  781.   for (; index < element_size; index++) {

  782.     output[index] = (float16_t)((bool)(input0[index]) & (bool)(input1[index]));

  783.   }

  784.   return NNACL_OK;

  785. }

  786. 

  787. int ElementOptLogicalAndFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size,

  788.                              ArithmeticParameter *param) {

  789. #ifdef ENABLE_NEON

  790.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  791.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  792.   float16x8_t vtrue = vdupq_n_f16(1);

  793.   float16x8_t vfalse = vdupq_n_f16(0);

  794.   uint16x8_t mask = vmovq_n_u16(((uint16_t)(1u << 15) - 1));

  795.   uint16x8_t zeros = vdupq_n_u16(0);

  796. #endif

  797.   int index = 0;

  798.   if (param->in_elements_num0_ == 1) {

  799. #ifdef ENABLE_NEON

  800.     for (; index <= element_size - 8; index += C8NUM) {

  801.       float16x8_t vin1_ = vld1q_f16(input1 + index);

  802.       uint16x8_t vin0 = vandq_u16(vreinterpretq_s16_f16(vin0_opt), mask);

  803.       uint16x8_t vin1 = vandq_u16(vreinterpretq_s16_f16(vin1_), mask);

  804.       float16x8_t vout = vbslq_f16(vceqq_u16(vandq_u16(vin0, vin1), zeros), vfalse, vtrue);

  805.       vst1q_f16(output + index, vout);

  806.     }

  807. #endif

  808.     for (; index < element_size; index++) {

  809.       output[index] = (float16_t)((bool)(input0[0]) & (bool)(input1[index]));

  810.     }

  811.   } else {

  812. #ifdef ENABLE_NEON

  813.     for (; index <= element_size - 8; index += C8NUM) {

  814.       float16x8_t vin0_ = vld1q_f16(input0 + index);

  815.       uint16x8_t vin0 = vandq_u16(vreinterpretq_s16_f16(vin0_), mask);

  816.       uint16x8_t vin1 = vandq_u16(vreinterpretq_s16_f16(vin1_opt), mask);

  817.       float16x8_t vout = vbslq_f16(vceqq_u16(vandq_u16(vin0, vin1), zeros), vfalse, vtrue);

  818.       vst1q_f16(output + index, vout);

  819.     }

  820. #endif

  821.     for (; index < element_size; index++) {

  822.       output[index] = (float16_t)((bool)(input0[index]) & (bool)(input1[0]));

  823.     }

  824.   }

  825.   return NNACL_OK;

  826. }

  827. 

  828. int ElementLogicalOrFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size) {

  829.   int index = 0;

  830. #ifdef ENABLE_NEON

  831.   float16x8_t vtrue = vdupq_n_f16(1);

  832.   float16x8_t vfalse = vdupq_n_f16(0);

  833.   uint16x8_t mask = vmovq_n_u16(((uint16_t)(1u << 15) - 1));

  834.   uint16x8_t zeros = vdupq_n_u16(0);

  835.   for (; index <= element_size - 8; index += C8NUM) {

  836.     uint16x8_t vin0 = vandq_u16(vreinterpretq_s16_f16(vld1q_f16(input0 + index)), mask);

  837.     uint16x8_t vin1 = vandq_u16(vreinterpretq_s16_f16(vld1q_f16(input1 + index)), mask);

  838.     float16x8_t vout = vbslq_f16(vceqq_u16(vorrq_u16(vin0, vin1), zeros), vfalse, vtrue);

  839.     vst1q_f16(output + index, vout);

  840.   }

  841. #endif

  842.   for (; index < element_size; index++) {

  843.     output[index] = (float16_t)((bool)(input0[index]) | (bool)(input1[index]));

  844.   }

  845.   return NNACL_OK;

  846. }

  847. 

  848. int ElementOptLogicalOrFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size,

  849.                             ArithmeticParameter *param) {

  850. #ifdef ENABLE_NEON

  851.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  852.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  853.   float16x8_t vtrue = vdupq_n_f16(1);

  854.   float16x8_t vfalse = vdupq_n_f16(0);

  855.   uint16x8_t mask = vmovq_n_u16(((uint16_t)(1u << 15) - 1));

  856.   uint16x8_t zeros = vdupq_n_u16(0);

  857. #endif

  858.   int index = 0;

  859.   if (param->in_elements_num0_ == 1) {

  860. #ifdef ENABLE_NEON

  861.     for (; index <= element_size - 8; index += C8NUM) {

  862.       float16x8_t vin1_ = vld1q_f16(input1 + index);

  863.       uint16x8_t vin0 = vandq_u16(vreinterpretq_s16_f16(vin0_opt), mask);

  864.       uint16x8_t vin1 = vandq_u16(vreinterpretq_s16_f16(vin1_), mask);

  865.       float16x8_t vout = vbslq_f16(vceqq_u16(vorrq_u16(vin0, vin1), zeros), vfalse, vtrue);

  866.       vst1q_f16(output + index, vout);

  867.     }

  868. #endif

  869.     for (; index < element_size; index++) {

  870.       output[index] = (float16_t)((bool)(input0[0]) | (bool)(input1[index]));

  871.     }

  872.   } else {

  873. #ifdef ENABLE_NEON

  874.     for (; index <= element_size - 8; index += C8NUM) {

  875.       float16x8_t vin0_ = vld1q_f16(input0 + index);

  876.       uint16x8_t vin0 = vandq_u16(vreinterpretq_s16_f16(vin0_), mask);

  877.       uint16x8_t vin1 = vandq_u16(vreinterpretq_s16_f16(vin1_opt), mask);

  878.       float16x8_t vout = vbslq_f16(vceqq_u16(vorrq_u16(vin0, vin1), zeros), vfalse, vtrue);

  879.       vst1q_f16(output + index, vout);

  880.     }

  881. #endif

  882.     for (; index < element_size; index++) {

  883.       output[index] = (float16_t)((bool)(input0[index]) | (bool)(input1[0]));

  884.     }

  885.   }

  886.   return NNACL_OK;

  887. }

  888. 

  889. int ElementSquaredDifferenceFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size) {

  890.   ElementSubFp16(input0, input1, output, element_size);

  891.   return ElementMulFp16(output, output, output, element_size);

  892. }

  893. 

  894. int ElementOptSquaredDifferenceFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size,

  895.                                     ArithmeticParameter *param) {

  896.   ElementOptSubFp16(input0, input1, output, element_size, param);

  897.   return ElementMulFp16(output, output, output, element_size);

  898. }

  899. 

  900. int ElementMaximumFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size) {

  901.   int index = 0;

  902. #ifdef ENABLE_NEON

  903.   for (; index <= element_size - 8; index += C8NUM) {

  904.     float16x8_t vin0 = vld1q_f16(input0 + index);

  905.     float16x8_t vin1 = vld1q_f16(input1 + index);

  906.     float16x8_t vout = vmaxq_f16(vin0, vin1);

  907.     vst1q_f16(output + index, vout);

  908.   }

  909. #endif

  910.   for (; index < element_size; index++) {

  911.     output[index] = MSMAX(input0[index], input1[index]);

  912.   }

  913.   return NNACL_OK;

  914. }

  915. 

  916. int ElementOptMaximumFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size,

  917.                           ArithmeticParameter *param) {

  918. #ifdef ENABLE_NEON

  919.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  920.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  921. #endif

  922.   int index = 0;

  923.   if (param->in_elements_num0_ == 1) {

  924. #ifdef ENABLE_NEON

  925.     for (; index <= element_size - 8; index += C8NUM) {

  926.       float16x8_t vin1 = vld1q_f16(input1 + index);

  927.       float16x8_t vout = vmaxq_f16(vin0_opt, vin1);

  928.       vst1q_f16(output + index, vout);

  929.     }

  930. #endif

  931.     for (; index < element_size; index++) {

  932.       output[index] = MSMAX(input0[0], input1[index]);

  933.     }

  934.   } else {

  935. #ifdef ENABLE_NEON

  936.     for (; index <= element_size - 8; index += C8NUM) {

  937.       float16x8_t vin0 = vld1q_f16(input0 + index);

  938.       float16x8_t vout = vmaxq_f16(vin0, vin1_opt);

  939.       vst1q_f16(output + index, vout);

  940.     }

  941. #endif

  942.     for (; index < element_size; index++) {

  943.       output[index] = MSMAX(input0[index], input1[0]);

  944.     }

  945.   }

  946.   return NNACL_OK;

  947. }

  948. 

  949. int ElementMinimumFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size) {

  950.   int index = 0;

  951. #ifdef ENABLE_NEON

  952.   for (; index <= element_size - 8; index += C8NUM) {

  953.     float16x8_t vin0 = vld1q_f16(input0 + index);

  954.     float16x8_t vin1 = vld1q_f16(input1 + index);

  955.     float16x8_t vout = vminq_f16(vin0, vin1);

  956.     vst1q_f16(output + index, vout);

  957.   }

  958. #endif

  959.   for (; index < element_size; index++) {

  960.     output[index] = MSMIN(input0[index], input1[index]);

  961.   }

  962.   return NNACL_OK;

  963. }

  964. 

  965. int ElementOptMinimumFp16(float16_t *input0, float16_t *input1, float16_t *output, int element_size,

  966.                           ArithmeticParameter *param) {

  967. #ifdef ENABLE_NEON

  968.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  969.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  970. #endif

  971.   int index = 0;

  972.   if (param->in_elements_num0_ == 1) {

  973. #ifdef ENABLE_NEON

  974.     for (; index <= element_size - 8; index += C8NUM) {

  975.       float16x8_t vin1 = vld1q_f16(input1 + index);

  976.       float16x8_t vout = vminq_f16(vin0_opt, vin1);

  977.       vst1q_f16(output + index, vout);

  978.     }

  979. #endif

  980.     for (; index < element_size; index++) {

  981.       output[index] = MSMIN(input0[0], input1[index]);

  982.     }

  983.   } else {

  984. #ifdef ENABLE_NEON

  985.     for (; index <= element_size - 8; index += C8NUM) {

  986.       float16x8_t vin0 = vld1q_f16(input0 + index);

  987.       float16x8_t vout = vminq_f16(vin0, vin1_opt);

  988.       vst1q_f16(output + index, vout);

  989.     }

  990. #endif

  991.     for (; index < element_size; index++) {

  992.       output[index] = MSMIN(input0[index], input1[0]);

  993.     }

  994.   }

  995.   return NNACL_OK;

  996. }

  997. 

  998. int ElementNotEqualFp16(float16_t *input0, float16_t *input1, uint8_t *output, int element_size) {

  999.   int index = 0;

  1000. #ifdef ENABLE_NEON

  1001.   for (; index <= element_size - 8; index += C8NUM) {

  1002.     float16x8_t vin0 = vld1q_f16(input0 + index);

  1003.     float16x8_t vin1 = vld1q_f16(input1 + index);

  1004.     uint8x8_t vout = vmovn_u16(vceqq_f16(vin0, vin1));

  1005.     vst1_u8(output + index, vout);

  1006.   }

  1007. #endif

  1008.   for (; index < element_size; index++) {

  1009.     output[index] = input0[index] != input1[index];

  1010.   }

  1011.   return NNACL_OK;

  1012. }

  1013. 

  1014. int ElementOptNotEqualFp16(float16_t *input0, float16_t *input1, uint8_t *output, int element_size,

  1015.                            ArithmeticParameter *param) {

  1016. #ifdef ENABLE_NEON

  1017.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  1018.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  1019. #endif

  1020.   int index = 0;

  1021.   if (param->in_elements_num0_ == 1) {

  1022. #ifdef ENABLE_NEON

  1023.     for (; index <= element_size - 8; index += C8NUM) {

  1024.       float16x8_t vin1 = vld1q_f16(input1 + index);

  1025.       uint8x8_t vout = vmovn_u16(vceqq_f16(vin0_opt, vin1));

  1026.       vst1_u8(output + index, vout);

  1027.     }

  1028. #endif

  1029.     for (; index < element_size; index++) {

  1030.       output[index] = input0[0] != input1[index];

  1031.     }

  1032.   } else {

  1033. #ifdef ENABLE_NEON

  1034.     for (; index <= element_size - 8; index += C8NUM) {

  1035.       float16x8_t vin0 = vld1q_f16(input0 + index);

  1036.       uint8x8_t vout = vmovn_u16(vceqq_f16(vin0, vin1_opt));

  1037.       vst1_u8(output + index, vout);

  1038.     }

  1039. #endif

  1040.     for (; index < element_size; index++) {

  1041.       output[index] = input0[index] != input1[0];

  1042.     }

  1043.   }

  1044.   return NNACL_OK;

  1045. }

  1046. 

  1047. int ElementEqualFp16(float16_t *input0, float16_t *input1, uint8_t *output, int element_size) {

  1048.   int index = 0;

  1049. #ifdef ENABLE_NEON

  1050.   for (; index <= element_size - 8; index += C8NUM) {

  1051.     float16x8_t vin0 = vld1q_f16(input0 + index);

  1052.     float16x8_t vin1 = vld1q_f16(input1 + index);

  1053.     uint8x8_t vout = vmovn_u16(vceqq_f16(vin0, vin1));

  1054.     vst1_u8(output + index, vout);

  1055.   }

  1056. #endif

  1057.   for (; index < element_size; index++) {

  1058.     output[index] = input0[index] == input1[index];

  1059.   }

  1060.   return NNACL_OK;

  1061. }

  1062. 

  1063. int ElementOptEqualFp16(float16_t *input0, float16_t *input1, uint8_t *output, int element_size,

  1064.                         ArithmeticParameter *param) {

  1065. #ifdef ENABLE_NEON

  1066.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  1067.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  1068. #endif

  1069.   int index = 0;

  1070.   if (param->in_elements_num0_ == 1) {

  1071. #ifdef ENABLE_NEON

  1072.     for (; index <= element_size - 8; index += C8NUM) {

  1073.       float16x8_t vin1 = vld1q_f16(input1 + index);

  1074.       uint8x8_t vout = vmovn_u16(vceqq_f16(vin0_opt, vin1));

  1075.       vst1_u8(output + index, vout);

  1076.     }

  1077. #endif

  1078.     for (; index < element_size; index++) {

  1079.       output[index] = input0[0] == input1[index];

  1080.     }

  1081.   } else {

  1082. #ifdef ENABLE_NEON

  1083.     for (; index <= element_size - 8; index += C8NUM) {

  1084.       float16x8_t vin0 = vld1q_f16(input0 + index);

  1085.       uint8x8_t vout = vmovn_u16(vceqq_f16(vin0, vin1_opt));

  1086.       vst1_u8(output + index, vout);

  1087.     }

  1088. #endif

  1089.     for (; index < element_size; index++) {

  1090.       output[index] = input0[index] == input1[0];

  1091.     }

  1092.   }

  1093.   return NNACL_OK;

  1094. }

  1095. 

  1096. int ElementLessFp16(float16_t *input0, float16_t *input1, uint8_t *output, int element_size) {

  1097.   int index = 0;

  1098. #ifdef ENABLE_NEON

  1099.   for (; index <= element_size - 8; index += C8NUM) {

  1100.     float16x8_t vin0 = vld1q_f16(input0 + index);

  1101.     float16x8_t vin1 = vld1q_f16(input1 + index);

  1102.     uint8x8_t vout = vmovn_u16(vcltq_f16(vin0, vin1));

  1103.     vst1_u8(output + index, vout);

  1104.   }

  1105. #endif

  1106.   for (; index < element_size; index++) {

  1107.     output[index] = input0[index] < input1[index];

  1108.   }

  1109.   return NNACL_OK;

  1110. }

  1111. 

  1112. int ElementOptLessFp16(float16_t *input0, float16_t *input1, uint8_t *output, int element_size,

  1113.                        ArithmeticParameter *param) {

  1114. #ifdef ENABLE_NEON

  1115.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  1116.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  1117. #endif

  1118.   int index = 0;

  1119.   if (param->in_elements_num0_ == 1) {

  1120. #ifdef ENABLE_NEON

  1121.     for (; index <= element_size - 8; index += C8NUM) {

  1122.       float16x8_t vin1 = vld1q_f16(input1 + index);

  1123.       uint8x8_t vout = vmovn_u16(vcltq_f16(vin0_opt, vin1));

  1124.       vst1_u8(output + index, vout);

  1125.     }

  1126. #endif

  1127.     for (; index < element_size; index++) {

  1128.       output[index] = input0[0] < input1[index];

  1129.     }

  1130.   } else {

  1131. #ifdef ENABLE_NEON

  1132.     for (; index <= element_size - 8; index += C8NUM) {

  1133.       float16x8_t vin0 = vld1q_f16(input0 + index);

  1134.       uint8x8_t vout = vmovn_u16(vcltq_f16(vin0, vin1_opt));

  1135.       vst1_u8(output + index, vout);

  1136.     }

  1137. #endif

  1138.     for (; index < element_size; index++) {

  1139.       output[index] = input0[index] < input1[0];

  1140.     }

  1141.   }

  1142.   return NNACL_OK;

  1143. }

  1144. 

  1145. int ElementLessEqualFp16(float16_t *input0, float16_t *input1, uint8_t *output, int element_size) {

  1146.   int index = 0;

  1147. #ifdef ENABLE_NEON

  1148.   for (; index <= element_size - 8; index += C8NUM) {

  1149.     float16x8_t vin0 = vld1q_f16(input0 + index);

  1150.     float16x8_t vin1 = vld1q_f16(input1 + index);

  1151.     uint8x8_t vout = vmovn_u16(vcleq_f16(vin0, vin1));

  1152.     vst1_u8(output + index, vout);

  1153.   }

  1154. #endif

  1155.   for (; index < element_size; index++) {

  1156.     output[index] = input0[index] <= input1[index];

  1157.   }

  1158.   return NNACL_OK;

  1159. }

  1160. 

  1161. int ElementOptLessEqualFp16(float16_t *input0, float16_t *input1, uint8_t *output, int element_size,

  1162.                             ArithmeticParameter *param) {

  1163. #ifdef ENABLE_NEON

  1164.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  1165.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  1166. #endif

  1167.   int index = 0;

  1168.   if (param->in_elements_num0_ == 1) {

  1169. #ifdef ENABLE_NEON

  1170.     for (; index <= element_size - 8; index += C8NUM) {

  1171.       float16x8_t vin1 = vld1q_f16(input1 + index);

  1172.       uint8x8_t vout = vmovn_u16(vcleq_f16(vin0_opt, vin1));

  1173.       vst1_u8(output + index, vout);

  1174.     }

  1175. #endif

  1176.     for (; index < element_size; index++) {

  1177.       output[index] = input0[0] <= input1[index];

  1178.     }

  1179.   } else {

  1180. #ifdef ENABLE_NEON

  1181.     for (; index <= element_size - 8; index += C8NUM) {

  1182.       float16x8_t vin0 = vld1q_f16(input0 + index);

  1183.       uint8x8_t vout = vmovn_u16(vcleq_f16(vin0, vin1_opt));

  1184.       vst1_u8(output + index, vout);

  1185.     }

  1186. #endif

  1187.     for (; index < element_size; index++) {

  1188.       output[index] = input0[index] <= input1[0];

  1189.     }

  1190.   }

  1191.   return NNACL_OK;

  1192. }

  1193. 

  1194. int ElementGreaterFp16(float16_t *input0, float16_t *input1, uint8_t *output, int element_size) {

  1195.   int index = 0;

  1196. #ifdef ENABLE_NEON

  1197.   for (; index <= element_size - 8; index += C8NUM) {

  1198.     float16x8_t vin0 = vld1q_f16(input0 + index);

  1199.     float16x8_t vin1 = vld1q_f16(input1 + index);

  1200.     uint8x8_t vout = vmovn_u16(vcgtq_f16(vin0, vin1));

  1201.     vst1_u8(output + index, vout);

  1202.   }

  1203. #endif

  1204.   for (; index < element_size; index++) {

  1205.     output[index] = input0[index] > input1[index];

  1206.   }

  1207.   return NNACL_OK;

  1208. }

  1209. 

  1210. int ElementOptGreaterFp16(float16_t *input0, float16_t *input1, uint8_t *output, int element_size,

  1211.                           ArithmeticParameter *param) {

  1212. #ifdef ENABLE_NEON

  1213.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  1214.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  1215. #endif

  1216.   int index = 0;

  1217.   if (param->in_elements_num0_ == 1) {

  1218. #ifdef ENABLE_NEON

  1219.     for (; index <= element_size - 8; index += C8NUM) {

  1220.       float16x8_t vin1 = vld1q_f16(input1 + index);

  1221.       uint8x8_t vout = vmovn_u16(vcgtq_f16(vin0_opt, vin1));

  1222.       vst1_u8(output + index, vout);

  1223.     }

  1224. #endif

  1225.     for (; index < element_size; index++) {

  1226.       output[index] = input0[0] > input1[index];

  1227.     }

  1228.   } else {

  1229. #ifdef ENABLE_NEON

  1230.     for (; index <= element_size - 8; index += C8NUM) {

  1231.       float16x8_t vin0 = vld1q_f16(input0 + index);

  1232.       uint8x8_t vout = vmovn_u16(vcgtq_f16(vin0, vin1_opt));

  1233.       vst1_u8(output + index, vout);

  1234.     }

  1235. #endif

  1236.     for (; index < element_size; index++) {

  1237.       output[index] = input0[index] > input1[0];

  1238.     }

  1239.   }

  1240.   return NNACL_OK;

  1241. }

  1242. 

  1243. int ElementGreaterEqualFp16(float16_t *input0, float16_t *input1, uint8_t *output, int element_size) {

  1244.   int index = 0;

  1245. #ifdef ENABLE_NEON

  1246.   for (; index <= element_size - 8; index += C8NUM) {

  1247.     float16x8_t vin0 = vld1q_f16(input0 + index);

  1248.     float16x8_t vin1 = vld1q_f16(input1 + index);

  1249.     uint8x8_t vout = vmovn_u16(vcgeq_f16(vin0, vin1));

  1250.     vst1_u8(output + index, vout);

  1251.   }

  1252. #endif

  1253.   for (; index < element_size; index++) {

  1254.     output[index] = input0[index] >= input1[index];

  1255.   }

  1256.   return NNACL_OK;

  1257. }

  1258. 

  1259. int ElementOptGreaterEqualFp16(float16_t *input0, float16_t *input1, uint8_t *output, int element_size,

  1260.                                ArithmeticParameter *param) {

  1261. #ifdef ENABLE_NEON

  1262.   float16x8_t vin0_opt = vdupq_n_f16(input0[0]);

  1263.   float16x8_t vin1_opt = vdupq_n_f16(input1[0]);

  1264. #endif

  1265.   int index = 0;

  1266.   if (param->in_elements_num0_ == 1) {

  1267. #ifdef ENABLE_NEON

  1268.     for (; index <= element_size - 8; index += C8NUM) {

  1269.       float16x8_t vin1 = vld1q_f16(input1 + index);

  1270.       uint8x8_t vout = vmovn_u16(vcgeq_f16(vin0_opt, vin1));

  1271.       vst1_u8(output + index, vout);

  1272.     }

  1273. #endif

  1274.     for (; index < element_size; index++) {

  1275.       output[index] = input0[0] >= input1[index];

  1276.     }

  1277.   } else {

  1278. #ifdef ENABLE_NEON

  1279.     for (; index <= element_size - 8; index += C8NUM) {

  1280.       float16x8_t vin0 = vld1q_f16(input0 + index);

  1281.       uint8x8_t vout = vmovn_u16(vcgeq_f16(vin0, vin1_opt));

  1282.       vst1_u8(output + index, vout);

  1283.     }

  1284. #endif

  1285.     for (; index < element_size; index++) {

  1286.       output[index] = input0[index] >= input1[0];

  1287.     }

  1288.   }

  1289.   return NNACL_OK;

  1290. }