zzy34407230
/
mindspore2022
Not watched
1
0
Fork 0
Code
Releases 22 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: bc738d4ec3
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'bc738d4ec3'
${ noResults }
mindspore2022/mindspore/lite/nnacl/fp32/arithmetic.h

140 lines
8.7 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. #ifndef MINDSPORE_LITE_NNACL_ARITHMETIC_H_

  17. #define MINDSPORE_LITE_NNACL_ARITHMETIC_H_

  18. 

  19. #ifdef ENABLE_NEON

  20. #include <arm_neon.h>

  21. #endif

  22. #include "nnacl/op_base.h"

  23. #include "nnacl/arithmetic_common.h"

  24. #include "nnacl/errorcode.h"

  25. 

  26. #ifdef __cplusplus

  27. extern "C" {

  28. #endif

  29. int ElementOptAdd(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param);

  30. int ElementOptAddInt(int *input0, int *input1, int *output, int element_size, ArithmeticParameter *param);

  31. int ElementOptAddRelu(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param);

  32. int ElementOptAddRelu6(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param);

  33. int ElementOptSub(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param);

  34. int ElementOptSubRelu(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param);

  35. int ElementOptSubRelu6(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param);

  36. int ElementOptMul(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param);

  37. int ElementOptMulRelu(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param);

  38. int ElementOptMulRelu6(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param);

  39. int ElementOptMulInt(int *input0, int *input1, int *output, int element_size, ArithmeticParameter *param);

  40. int ElementOptMulReluInt(int *input0, int *input1, int *output, int element_size, ArithmeticParameter *param);

  41. int ElementOptMulRelu6Int(int *input0, int *input1, int *output, int element_size, ArithmeticParameter *param);

  42. int ElementOptDiv(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param);

  43. int ElementOptDivRelu(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param);

  44. int ElementOptDivRelu6(float *input0, float *input1, float *output, int element_size, ArithmeticParameter *param);

  45. int ElementMul(float *input0, float *input1, float *output, int element_size);

  46. int ElementMulRelu(float *input0, float *input1, float *output, int element_size);

  47. int ElementMulRelu6(float *input0, float *input1, float *output, int element_size);

  48. int ElementMulInt(int *input0, int *input1, int *output, int element_size);

  49. int ElementMulReluInt(int *input0, int *input1, int *output, int element_size);

  50. int ElementMulRelu6Int(int *input0, int *input1, int *output, int element_size);

  51. int BroadcastMul(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size,

  52.                  ArithmeticParameter *param);

  53. 

  54. int ElementAdd(float *input0, float *input1, float *output, int element_size);

  55. int ElementAddRelu(float *input0, float *input1, float *output, int element_size);

  56. int ElementAddRelu6(float *input0, float *input1, float *output, int element_size);

  57. int ElementAddInt(int *input0, int *input1, int *output, int element_size);

  58. int BroadcastAdd(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size,

  59.                  ArithmeticParameter *param);

  60. int BroadcastAddInt8(int8_t *input0, int8_t *input1, int8_t *tile_input0, int8_t *tile_input1, int8_t *output,

  61.                      int element_size, ArithmeticParameter *param);

  62. 

  63. int ElementSub(float *input0, float *input1, float *output, int element_size);

  64. int ElementSubRelu(float *input0, float *input1, float *output, int element_size);

  65. int ElementSubRelu6(float *input0, float *input1, float *output, int element_size);

  66. int BroadcastSub(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size,

  67.                  ArithmeticParameter *param);

  68. 

  69. int ElementDiv(float *input0, float *input1, float *output, int element_size);

  70. int ElementDivRelu(float *input0, float *input1, float *output, int element_size);

  71. int ElementDivRelu6(float *input0, float *input1, float *output, int element_size);

  72. int BroadcastDiv(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size,

  73.                  ArithmeticParameter *param);

  74. 

  75. int ElementLogicalAnd(float *input0, float *input1, float *output, int element_size);

  76. int BroadcastLogicalAnd(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,

  77.                         int element_size, ArithmeticParameter *param);

  78. 

  79. int ElementLogicalOr(float *input0, float *input1, float *output, int element_size);

  80. int BroadcastLogicalOr(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,

  81.                        int element_size, ArithmeticParameter *param);

  82. 

  83. int ElementMaximum(float *input0, float *input1, float *output, int element_size);

  84. int BroadcastMaximum(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,

  85.                      int element_size, ArithmeticParameter *param);

  86. 

  87. int ElementMinimum(float *input0, float *input1, float *output, int element_size);

  88. int BroadcastMinimum(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,

  89.                      int element_size, ArithmeticParameter *param);

  90. 

  91. int ElementFloorDiv(float *input0, float *input1, float *output, int element_size);

  92. int ElementFloorDivInt(int *input0, int *input1, int *output, int element_size);

  93. int BroadcastFloorDiv(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,

  94.                       int element_size, ArithmeticParameter *param);

  95. 

  96. int ElementFloorMod(float *input0, float *input1, float *output, int element_size);

  97. int ElementFloorModInt(int *input0, int *input1, int *output, int element_size);

  98. int BroadcastFloorMod(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,

  99.                       int element_size, ArithmeticParameter *param);

  100. 

  101. int ElementSquaredDifference(float *input0, float *input1, float *output, int element_size);

  102. int BroadcastSquaredDifference(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,

  103.                                int element_size, ArithmeticParameter *param);

  104. 

  105. int ElementNotEqual(float *input0, float *input1, float *output, int element_size);

  106. 

  107. int BroadcastNotEqual(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,

  108.                       int element_size, ArithmeticParameter *param);

  109. 

  110. int ElementEqual(float *input0, float *input1, float *output, int element_size);

  111. 

  112. int BroadcastEqual(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,

  113.                    int element_size, ArithmeticParameter *param);

  114. 

  115. int ElementLess(float *input0, float *input1, float *output, int element_size);

  116. int BroadcastLess(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output, int element_size,

  117.                   ArithmeticParameter *param);

  118. 

  119. int ElementLessEqual(float *input0, float *input1, float *output, int element_size);

  120. int BroadcastLessEqual(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,

  121.                        int element_size, ArithmeticParameter *param);

  122. 

  123. int ElementGreater(float *input0, float *input1, float *output, int element_size);

  124. int BroadcastGreater(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,

  125.                      int element_size, ArithmeticParameter *param);

  126. 

  127. int ElementGreaterEqual(float *input0, float *input1, float *output, int element_size);

  128. int BroadcastGreaterEqual(float *input0, float *input1, float *tile_input0, float *tile_input1, float *output,

  129.                           int element_size, ArithmeticParameter *param);

  130. 

  131. #ifdef ENABLE_NNACL_INFER_SHAPE

  132. int ArithmeticInferShape(int **in_shape, size_t *dim_size, int *out_shape, int *in_format, int *out_format,

  133.                          int *in_datatype, int *out_datatype, OpParameter *param);

  134. #endif

  135. #ifdef __cplusplus

  136. }

  137. #endif

  138. 

  139. #endif  // MINDSPORE_LITE_NNACL_ARITHMETIC_H_