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

     1  #include <cstddef>
     2  #include <cmath>
     3  
     4  template<typename T>
     5  T Dot(T* x, T* y, size_t n) {
     6      T res = 0;
     7      for (size_t i = 0; i < n; i++) {
     8          res += x[i] * y[i];
     9      }
    10      return res;
    11  }
    12  
    13  template<typename T>
    14  T CosineSimilarity(T* x, T* y, size_t n) {
    15      T dp = 0;
    16      T xdp = 0;
    17      T ydp = 0;
    18      for (size_t i = 0; i < n; i++) {
    19          dp += x[i] * y[i];
    20          xdp += x[i] * x[i];
    21          ydp += y[i] * y[i];
    22      }
    23      return dp / std::sqrt(xdp*ydp);
    24  }
    25  
    26  template<typename T>
    27  T EuclideanNorm(T* x, size_t n) {
    28      T res = 0;
    29      for (size_t i = 0; i < n; i++) {
    30          res += x[i] * x[i];
    31      }
    32      return std::sqrt(res);
    33  }
    34  
    35  template<typename T>
    36  T EuclideanDistance(T* x, T* y, size_t n) {
    37      T res = 0;
    38      for (size_t i = 0; i < n; i++) {
    39          res += (x[i] - y[i])*(x[i] - y[i]);
    40      }
    41      return std::sqrt(res);
    42  }
    43  
    44  template<typename T>
    45  T ManhattanNorm(T* x, size_t n) {
    46      T res = 0;
    47      for (size_t i = 0; i < n; i++) {
    48          res += std::abs(x[i]);
    49      }
    50      return res;
    51  }
    52  
    53  template<typename T>
    54  T ManhattanDistance(T* x, T* y, size_t n) {
    55      T res = 0;
    56      for (size_t i = 0; i < n; i++) {
    57          res += std::abs(x[i] - y[i]);
    58      }
    59      return res;
    60  }
    61  
    62  double Dot_F64_D(double* x, double* y, size_t n) {
    63      return Dot(x, y, n);
    64  }
    65  
    66  float Dot_F32_F(float* x, float* y, size_t n) {
    67      return Dot(x, y, n);
    68  }
    69  
    70  double CosineSimilarity_F64_D(double* x, double* y, size_t n) {
    71      return CosineSimilarity(x, y, n);
    72  }
    73  
    74  float CosineSimilarity_F32_F(float* x, float* y, size_t n) {
    75      return CosineSimilarity(x, y, n);
    76  }
    77  
    78  double Norm_F64_D(double* x, size_t n) {
    79      return EuclideanNorm(x, n);
    80  }
    81  
    82  float Norm_F32_F(float* x, size_t n) {
    83      return EuclideanNorm(x, n);
    84  }
    85  
    86  double Distance_F64_D(double* x, double* y, size_t n) {
    87      return EuclideanDistance(x, y, n);
    88  }
    89  
    90  float Distance_F32_F(float* x, float* y, size_t n) {
    91      return EuclideanDistance(x, y, n);
    92  }
    93  
    94  double ManhattanNorm_F64_D(double* x, size_t n) {
    95      return ManhattanNorm(x, n);
    96  }
    97  
    98  float ManhattanNorm_F32_F(float* x, size_t n) {
    99      return ManhattanNorm(x, n);
   100  }
   101  
   102  double ManhattanDistance_F64_D(double* x, double* y, size_t n) {
   103      return ManhattanDistance(x, y, n);
   104  }
   105  
   106  float ManhattanDistance_F32_F(float* x, float* y, size_t n) {
   107      return ManhattanDistance(x, y, n);
   108  }