gitee.com/quant1x/num@v0.3.2/internal/functions/accel_noasm.go (about)

     1  //go:build !amd64
     2  
     3  package functions
     4  
     5  var UseAVX2 bool = false
     6  
     7  // Arithmetic
     8  
     9  func Add_AVX2_F64(x, y []float64) {
    10  	panic("not implemented")
    11  }
    12  func AddNumber_AVX2_F64(x []float64, a float64) {
    13  	panic("not implemented")
    14  }
    15  func Sub_AVX2_F64(x, y []float64) []float64 {
    16  	panic("not implemented")
    17  }
    18  func SubNumber_AVX2_F64(x []float64, a float64) {
    19  	panic("not implemented")
    20  }
    21  func Mul_AVX2_F64(x, y []float64) {
    22  	panic("not implemented")
    23  }
    24  func MulNumber_AVX2_F64(x []float64, a float64) {
    25  	panic("not implemented")
    26  }
    27  func Div_AVX2_F64(x, y []float64) {
    28  	panic("not implemented")
    29  }
    30  func DivNumber_AVX2_F64(x []float64, a float64) {
    31  	panic("not implemented")
    32  }
    33  
    34  func Abs_AVX2_F64(x []float64) {
    35  	panic("not implemented")
    36  }
    37  func Neg_AVX2_F64(x []float64) {
    38  	panic("not implemented")
    39  }
    40  func Inv_AVX2_F64(x []float64) {
    41  	panic("not implemented")
    42  }
    43  
    44  // Aggregates
    45  
    46  func Sum_AVX2_F64(x []float64) float64 {
    47  	panic("not implemented")
    48  }
    49  func CumSum_AVX2_F64(x []float64) {
    50  	panic("not implemented")
    51  }
    52  func Prod_AVX2_F64(x []float64) float64 {
    53  	panic("not implemented")
    54  }
    55  func CumProd_AVX2_F64(x []float64) {
    56  	panic("not implemented")
    57  }
    58  func Mean_AVX2_F64(x []float64) float64 {
    59  	panic("not implemented")
    60  }
    61  func Median_AVX2_F64(x []float64) float64 {
    62  	panic("not implemented")
    63  }
    64  func Quantile_AVX2_F64(x []float64, q float64) float64 {
    65  	panic("not implemented")
    66  }
    67  
    68  // Distance
    69  
    70  func Dot_AVX2_F64(x, y []float64) float64 {
    71  	panic("not implemented")
    72  }
    73  func Norm_AVX2_F64(x []float64) float64 {
    74  	panic("not implemented")
    75  }
    76  func Distance_AVX2_F64(x, y []float64) float64 {
    77  	panic("not implemented")
    78  }
    79  func ManhattanNorm_AVX2_F64(x []float64) float64 {
    80  	panic("not implemented")
    81  }
    82  func ManhattanDistance_AVX2_F64(x, y []float64) float64 {
    83  	panic("not implemented")
    84  }
    85  func CosineSimilarity_AVX2_F64(x, y []float64) float64 {
    86  	panic("not implemented")
    87  }
    88  
    89  // Matrices
    90  
    91  func MatMul_Parallel_AVX2_F64(x, y, z []float64, m, n, p int) {
    92  	panic("not implemented")
    93  }
    94  func MatMul_AVX2_F64(x []float64, y []float64, z []float64, a int, b int, c int) {
    95  	panic("not implemented")
    96  }
    97  func MatMulVec_AVX2_F64(x []float64, y []float64, z []float64, a int, b int) {
    98  	panic("not implemented")
    99  }
   100  func MatMulTiled_AVX2_F64(x []float64, y []float64, z []float64, a int, b int, c int) {
   101  	panic("not implemented")
   102  }
   103  func Mat4Mul_AVX2_F64(x, y, z []float64) {
   104  	panic("not implemented")
   105  }
   106  
   107  // Special
   108  
   109  func Sqrt_AVX2_F64(x []float64) {
   110  	panic("not implemented")
   111  }
   112  func Round_AVX2_F64(x []float64) {
   113  	panic("not implemented")
   114  }
   115  func Floor_AVX2_F64(x []float64) {
   116  	panic("not implemented")
   117  }
   118  func Ceil_AVX2_F64(x []float64) {
   119  	panic("not implemented")
   120  }
   121  
   122  // Comparison
   123  
   124  func Min_AVX2_F64(x []float64) float64 {
   125  	panic("not implemented")
   126  }
   127  func ArgMin_AVX2_F64(x []float64) int {
   128  	panic("not implemented")
   129  }
   130  func Minimum_AVX2_F64(x, y []float64) {
   131  	panic("not implemented")
   132  }
   133  func MinimumNumber_AVX2_F64(x []float64, a float64) {
   134  	panic("not implemented")
   135  }
   136  func Max_AVX2_F64(x []float64) float64 {
   137  	panic("not implemented")
   138  }
   139  func ArgMax_AVX2_F64(x []float64) int {
   140  	panic("not implemented")
   141  }
   142  func Maximum_AVX2_F64(x, y []float64) {
   143  	panic("not implemented")
   144  }
   145  func MaximumNumber_AVX2_F64(x []float64, a float64) {
   146  	panic("not implemented")
   147  }
   148  func Find_AVX2_F64(x []float64, a float64) int {
   149  	panic("not implemented")
   150  }
   151  
   152  func Lt_AVX2_F64(dst []bool, x, y []float64) {
   153  	panic("not implemented")
   154  }
   155  func LtNumber_AVX2_F64(dst []bool, x []float64, a float64) {
   156  	panic("not implemented")
   157  }
   158  func Lte_AVX2_F64(dst []bool, x, y []float64) {
   159  	panic("not implemented")
   160  }
   161  func LteNumber_AVX2_F64(dst []bool, x []float64, a float64) {
   162  	panic("not implemented")
   163  }
   164  func Gt_AVX2_F64(dst []bool, x, y []float64) {
   165  	panic("not implemented")
   166  }
   167  func GtNumber_AVX2_F64(dst []bool, x []float64, a float64) {
   168  	panic("not implemented")
   169  }
   170  func Gte_AVX2_F64(dst []bool, x, y []float64) {
   171  	panic("not implemented")
   172  }
   173  func GteNumber_AVX2_F64(dst []bool, x []float64, a float64) {
   174  	panic("not implemented")
   175  }
   176  func Eq_AVX2_F64(dst []bool, x, y []float64) {
   177  	panic("not implemented")
   178  }
   179  func EqNumber_AVX2_F64(dst []bool, x []float64, a float64) {
   180  	panic("not implemented")
   181  }
   182  func Neq_AVX2_F64(dst []bool, x, y []float64) {
   183  	panic("not implemented")
   184  }
   185  func NeqNumber_AVX2_F64(dst []bool, x []float64, a float64) {
   186  	panic("not implemented")
   187  }
   188  
   189  // Boolean
   190  
   191  func Not_AVX2(x []bool) {
   192  	panic("not implemented")
   193  }
   194  func And_AVX2(x, y []bool) {
   195  	panic("not implemented")
   196  }
   197  func Or_AVX2(x, y []bool) {
   198  	panic("not implemented")
   199  }
   200  func Xor_AVX2(x, y []bool) {
   201  	panic("not implemented")
   202  }
   203  func Select_AVX2_F64(x, y []float64, z []bool) {
   204  	panic("not implemented")
   205  }
   206  
   207  func All_AVX2(x []bool) int {
   208  	panic("not implemented")
   209  }
   210  func Any_AVX2(x []bool) int {
   211  	panic("not implemented")
   212  }
   213  func None_AVX2(x []bool) int {
   214  	panic("not implemented")
   215  }
   216  func Count_AVX2(x []bool) int {
   217  	panic("not implemented")
   218  }
   219  
   220  // Construction
   221  
   222  func Zeros_AVX2_F64(dst []float64, n int) {
   223  	panic("not implemented")
   224  }
   225  func Ones_AVX2_F64(dst []float64, n int) {
   226  	panic("not implemented")
   227  }
   228  func Repeat_AVX2_F64(dst []float64, a float64, n int) {
   229  	panic("not implemented")
   230  }
   231  func Range_AVX2_F64(dst []float64, a float64, n int) {
   232  	panic("not implemented")
   233  }
   234  
   235  func Gather_AVX2_F64(x, y []float64, idx []int) {
   236  	panic("not implemented")
   237  }
   238  func Scatter_AVX2_F64(x []float64, idx []int, size int) {
   239  	panic("not implemented")
   240  }
   241  
   242  func FromFloat64_AVX2_F32(x []float32, y []float64) {
   243  	panic("not implemented")
   244  }
   245  func FromFloat32_AVX2_F64(x []float64, y []float32) {
   246  	panic("not implemented")
   247  }
   248  func FromInt64_AVX2_F64(x []float64, y []int64) {
   249  	panic("not implemented")
   250  }
   251  func FromInt32_AVX2_F64(x []float64, y []int32) {
   252  	panic("not implemented")
   253  }
   254  func FromBool_AVX2_F64(x []float64, y []bool) {
   255  	panic("not implemented")
   256  }
   257  
   258  func ToInt64_AVX2_F64(x []int64, y []float64) {
   259  	panic("not implemented")
   260  }
   261  func ToInt32_AVX2_F64(x []int32, y []float64) {
   262  	panic("not implemented")
   263  }
   264  func ToBool_AVX2_F64(x []bool, y []float64) {
   265  	panic("not implemented")
   266  }
   267  
   268  // float32
   269  
   270  func Add_AVX2_F32(x []float32, y []float32) {
   271  	panic("not implemented")
   272  }
   273  
   274  func AddNumber_AVX2_F32(x []float32, a float32) {
   275  	panic("not implemented")
   276  }
   277  
   278  func Sub_AVX2_F32(x []float32, y []float32) {
   279  	panic("not implemented")
   280  }
   281  
   282  func SubNumber_AVX2_F32(x []float32, a float32) {
   283  	panic("not implemented")
   284  }
   285  
   286  func Mul_AVX2_F32(x []float32, y []float32) {
   287  	panic("not implemented")
   288  }
   289  
   290  func MulNumber_AVX2_F32(x []float32, a float32) {
   291  	panic("not implemented")
   292  }
   293  
   294  func Div_AVX2_F32(x []float32, y []float32) {
   295  	panic("not implemented")
   296  }
   297  
   298  func DivNumber_AVX2_F32(x []float32, a float32) {
   299  	panic("not implemented")
   300  }
   301  
   302  func Abs_AVX2_F32(x []float32) {
   303  	panic("not implemented")
   304  }
   305  
   306  func Neg_AVX2_F32(x []float32) {
   307  	panic("not implemented")
   308  }
   309  
   310  func Inv_AVX2_F32(x []float32) {
   311  	panic("not implemented")
   312  }
   313  
   314  func Sum_AVX2_F32(x []float32) float32 {
   315  	panic("not implemented")
   316  }
   317  
   318  func CumSum_AVX2_F32(x []float32) {
   319  	panic("not implemented")
   320  }
   321  
   322  func Prod_AVX2_F32(x []float32) float32 {
   323  	panic("not implemented")
   324  }
   325  
   326  func CumProd_AVX2_F32(x []float32) {
   327  	panic("not implemented")
   328  }
   329  
   330  func Mean_AVX2_F32(x []float32) float32 {
   331  	panic("not implemented")
   332  }
   333  
   334  func Median_AVX2_F32(x []float32) float32 {
   335  	panic("not implemented")
   336  }
   337  
   338  func Quantile_AVX2_F32(x []float32, q float32) float32 {
   339  	panic("not implemented")
   340  }
   341  
   342  func Dot_AVX2_F32(x []float32, y []float32) float32 {
   343  	panic("not implemented")
   344  }
   345  
   346  func Norm_AVX2_F32(x []float32) float32 {
   347  	panic("not implemented")
   348  }
   349  
   350  func Distance_AVX2_F32(x []float32, y []float32) float32 {
   351  	panic("not implemented")
   352  }
   353  
   354  func ManhattanNorm_AVX2_F32(x []float32) float32 {
   355  	panic("not implemented")
   356  }
   357  
   358  func ManhattanDistance_AVX2_F32(x []float32, y []float32) float32 {
   359  	panic("not implemented")
   360  }
   361  
   362  func CosineSimilarity_AVX2_F32(x []float32, y []float32) float32 {
   363  	panic("not implemented")
   364  }
   365  
   366  func MatMul_Parallel_AVX2_F32(x, y, z []float32, m, n, p int) {
   367  	panic("not implemented")
   368  }
   369  
   370  func Mat4Mul_AVX2_F32(x []float32, y []float32, z []float32) {
   371  	panic("not implemented")
   372  }
   373  
   374  func MatMul_AVX2_F32(x []float32, y []float32, z []float32, a int, b int, c int) {
   375  	panic("not implemented")
   376  }
   377  
   378  func MatMulVec_AVX2_F32(x []float32, y []float32, z []float32, a int, b int) {
   379  	panic("not implemented")
   380  }
   381  
   382  func MatMulTiled_AVX2_F32(x []float32, y []float32, z []float32, a int, b int, c int) {
   383  	panic("not implemented")
   384  }
   385  
   386  func Sqrt_AVX2_F32(x []float32) float32 {
   387  	panic("not implemented")
   388  }
   389  
   390  func Round_AVX2_F32(x []float32) float32 {
   391  	panic("not implemented")
   392  }
   393  
   394  func Floor_AVX2_F32(x []float32) float32 {
   395  	panic("not implemented")
   396  }
   397  
   398  func Ceil_AVX2_F32(x []float32) float32 {
   399  	panic("not implemented")
   400  }
   401  
   402  func Sin_AVX2_F32(x []float32) {
   403  	panic("not implemented")
   404  }
   405  
   406  func Cos_AVX2_F32(x []float32) {
   407  	panic("not implemented")
   408  }
   409  
   410  func SinCos_AVX2_F32(x []float32, y []float32, z []float32) {
   411  	panic("not implemented")
   412  }
   413  
   414  func Exp_AVX2_F32(x []float32) {
   415  	panic("not implemented")
   416  }
   417  
   418  func Log_AVX2_F32(x []float32) {
   419  	panic("not implemented")
   420  }
   421  
   422  func Log2_AVX2_F32(x []float32) {
   423  	panic("not implemented")
   424  }
   425  
   426  func Log10_AVX2_F32(x []float32) {
   427  	panic("not implemented")
   428  }
   429  
   430  func Min_AVX2_F32(x []float32) float32 {
   431  	panic("not implemented")
   432  }
   433  
   434  func ArgMin_AVX2_F32(x []float32) int {
   435  	panic("not implemented")
   436  }
   437  
   438  func Minimum_AVX2_F32(x []float32, y []float32) {
   439  	panic("not implemented")
   440  }
   441  
   442  func MinimumNumber_AVX2_F32(x []float32, a float32) {
   443  	panic("not implemented")
   444  }
   445  
   446  func Max_AVX2_F32(x []float32) float32 {
   447  	panic("not implemented")
   448  }
   449  
   450  func ArgMax_AVX2_F32(x []float32) int {
   451  	panic("not implemented")
   452  }
   453  
   454  func Maximum_AVX2_F32(x []float32, y []float32) {
   455  	panic("not implemented")
   456  }
   457  
   458  func MaximumNumber_AVX2_F32(x []float32, a float32) {
   459  	panic("not implemented")
   460  }
   461  
   462  func Find_AVX2_F32(x []float32, a float32) int {
   463  	panic("not implemented")
   464  }
   465  
   466  func Lt_AVX2_F32(x []bool, y []float32, z []float32) {
   467  	panic("not implemented")
   468  }
   469  
   470  func Lte_AVX2_F32(x []bool, y []float32, z []float32) {
   471  	panic("not implemented")
   472  }
   473  
   474  func Gt_AVX2_F32(x []bool, y []float32, z []float32) {
   475  	panic("not implemented")
   476  }
   477  
   478  func Gte_AVX2_F32(x []bool, y []float32, z []float32) {
   479  	panic("not implemented")
   480  }
   481  
   482  func Eq_AVX2_F32(x []bool, y []float32, z []float32) {
   483  	panic("not implemented")
   484  }
   485  
   486  func Neq_AVX2_F32(x []bool, y []float32, z []float32) {
   487  	panic("not implemented")
   488  }
   489  
   490  func LtNumber_AVX2_F32(x []bool, y []float32, a float32) {
   491  	panic("not implemented")
   492  }
   493  
   494  func LteNumber_AVX2_F32(x []bool, y []float32, a float32) {
   495  	panic("not implemented")
   496  }
   497  
   498  func GtNumber_AVX2_F32(x []bool, y []float32, a float32) {
   499  	panic("not implemented")
   500  }
   501  
   502  func GteNumber_AVX2_F32(x []bool, y []float32, a float32) {
   503  	panic("not implemented")
   504  }
   505  
   506  func EqNumber_AVX2_F32(x []bool, y []float32, a float32) {
   507  	panic("not implemented")
   508  }
   509  
   510  func NeqNumber_AVX2_F32(x []bool, y []float32, a float32) {
   511  	panic("not implemented")
   512  }
   513  
   514  func Repeat_AVX2_F32(x []float32, a float32, n int) {
   515  	panic("not implemented")
   516  }
   517  
   518  func Range_AVX2_F32(x []float32, a float32, n int) {
   519  	panic("not implemented")
   520  }
   521  
   522  func Gather_AVX2_F32(x []float32, y []float32, z []int) {
   523  	panic("not implemented")
   524  }
   525  
   526  func Scatter_AVX2_F32(x []float32, y []float32, z []int) {
   527  	panic("not implemented")
   528  }
   529  
   530  func FromBool_AVX2_F32(x []float32, y []bool) {
   531  	panic("not implemented")
   532  }
   533  
   534  func FromInt32_AVX2_F32(x []float32, y []int32) {
   535  	panic("not implemented")
   536  }
   537  
   538  func FromInt64_AVX2_F32(x []float32, y []int64) {
   539  	panic("not implemented")
   540  }
   541  
   542  func ToBool_AVX2_F32(x []bool, y []float32) {
   543  	panic("not implemented")
   544  }
   545  
   546  func ToInt32_AVX2_F32(x []int32, y []float32) {
   547  	panic("not implemented")
   548  }
   549  
   550  func ToInt64_AVX2_F32(x []int64, y []float32) {
   551  	panic("not implemented")
   552  }
   553  
   554  // extras
   555  func Pow_AVX2_F32(x, y []float32) {
   556  	panic("not implemented")
   557  }
   558  
   559  func Pow_AVX2_F64(x, y []float64) {
   560  	panic("not implemented")
   561  }