gitee.com/quant1x/gox@v1.7.6/num/asm/_cpp/arithmetic.cpp (about)

     1  #include <cstddef>
     2  #include <cmath>
     3  
     4  template<typename T>
     5  void Add(T* __restrict x, T* __restrict y, size_t n) {
     6      for (size_t i = 0; i < n; i++) {
     7          x[i] += y[i];
     8      }
     9  }
    10  
    11  template<typename T>
    12  void AddNumber(T* __restrict x, T a, size_t n) {
    13      for (size_t i = 0; i < n; i++) {
    14          x[i] += a;
    15      }
    16  }
    17  
    18  template<typename T>
    19  void Sub(T* __restrict x, T* __restrict y, size_t n) {
    20      for (size_t i = 0; i < n; i++) {
    21          x[i] -= y[i];
    22      }
    23  }
    24  
    25  template<typename T>
    26  void SubNumber(T* __restrict x, T a, size_t n) {
    27      for (size_t i = 0; i < n; i++) {
    28          x[i] -= a;
    29      }
    30  }
    31  
    32  template<typename T>
    33  void Mul(T* __restrict x, T* __restrict y, size_t n) {
    34      for (size_t i = 0; i < n; i++) {
    35          x[i] *= y[i];
    36      }
    37  }
    38  
    39  template<typename T>
    40  void MulNumber(T* __restrict x, T a, size_t n) {
    41      for (size_t i = 0; i < n; i++) {
    42          x[i] *= a;
    43      }
    44  }
    45  
    46  template<typename T>
    47  void Div(T* __restrict x, T* __restrict y, size_t n) {
    48      for (size_t i = 0; i < n; i++) {
    49          x[i] /= y[i];
    50      }
    51  }
    52  
    53  template<typename T>
    54  void DivNumber(T* __restrict x, T a, size_t n) {
    55      for (size_t i = 0; i < n; i++) {
    56          x[i] /= a;
    57      }
    58  }
    59  
    60  template<typename T>
    61  void Abs(T* __restrict x, size_t n) {
    62      for (size_t i = 0; i < n; i++) {
    63          x[i] = std::abs(x[i]);
    64      }
    65  }
    66  
    67  template<typename T>
    68  void Neg(T* __restrict x, size_t n) {
    69      for (size_t i = 0; i < n; i++) {
    70          x[i] = -x[i];
    71      }
    72  }
    73  
    74  template<typename T>
    75  void Inv(T* __restrict x, size_t n) {
    76      for (size_t i = 0; i < n; i++) {
    77          x[i] = 1 / x[i];
    78      }
    79  }
    80  
    81  void Add_F64_V(double* x, double* y, size_t n) {
    82      Add(x, y, n);
    83  }
    84  
    85  void Add_F32_V(float* x, float* y, size_t n) {
    86      Add(x, y, n);
    87  }
    88  
    89  void AddNumber_F64_V(double* x, double a, size_t n) {
    90      AddNumber(x, a, n);
    91  }
    92  
    93  void AddNumber_F32_V(float* x, float a, size_t n) {
    94      AddNumber(x, a, n);
    95  }
    96  
    97  void Sub_F64_V(double* x, double* y, size_t n) {
    98      Sub(x, y, n);
    99  }
   100  
   101  void Sub_F32_V(float* x, float* y, size_t n) {
   102      Sub(x, y, n);
   103  }
   104  
   105  void SubNumber_F64_V(double* x, double a, size_t n) {
   106      SubNumber(x, a, n);
   107  }
   108  
   109  void SubNumber_F32_V(float* x, float a, size_t n) {
   110      SubNumber(x, a, n);
   111  }
   112  
   113  void Mul_F64_V(double* x, double* y, size_t n) {
   114      Mul(x, y, n);
   115  }
   116  
   117  void Mul_F32_V(float* x, float* y, size_t n) {
   118      Mul(x, y, n);
   119  }
   120  
   121  void MulNumber_F64_V(double* x, double a, size_t n) {
   122      MulNumber(x, a, n);
   123  }
   124  
   125  void MulNumber_F32_V(float* x, float a, size_t n) {
   126      MulNumber(x, a, n);
   127  }
   128  
   129  void Div_F64_V(double* x, double* y, size_t n) {
   130      Div(x, y, n);
   131  }
   132  
   133  void Div_F32_V(float* x, float* y, size_t n) {
   134      Div(x, y, n);
   135  }
   136  
   137  void DivNumber_F64_V(double* x, double a, size_t n) {
   138      DivNumber(x, a, n);
   139  }
   140  
   141  void DivNumber_F32_V(float* x, float a, size_t n) {
   142      DivNumber(x, a, n);
   143  }
   144  
   145  void Abs_F64_V(double* x, size_t n) {
   146      Abs(x, n);
   147  }
   148  
   149  void Abs_F32_V(float* x, size_t n) {
   150      Abs(x, n);
   151  }
   152  
   153  void Neg_F64_V(double* x, size_t n) {
   154      Neg(x, n);
   155  }
   156  
   157  void Neg_F32_V(float* x, size_t n) {
   158      Neg(x, n);
   159  }
   160  
   161  void Inv_F64_V(double* x, size_t n) {
   162      Inv(x, n);
   163  }
   164  
   165  void Inv_F32_V(float* x, size_t n) {
   166      Inv(x, n);
   167  }