mlir/test/mlir-cpu-runner/math-polynomial-approx.mlir

   1 // RUN:   mlir-opt %s -pass-pipeline="builtin.module(func.func(test-math-polynomial-approximation,convert-arith-to-llvm),convert-vector-to-scf,convert-scf-to-cf,convert-cf-to-llvm,convert-vector-to-llvm,func.func(convert-math-to-llvm),convert-func-to-llvm,reconcile-unrealized-casts)" \
   2 // RUN: | mlir-cpu-runner                                                      \
   3 // RUN:     -e main -entry-point-result=void -O0                               \
   4 // RUN:     -shared-libs=%mlir_c_runner_utils  \
   5 // RUN:     -shared-libs=%mlir_runner_utils    \
   6 // RUN: | FileCheck %s
   7
   8 // -------------------------------------------------------------------------- //
   9 // Tanh.
  10 // -------------------------------------------------------------------------- //
  11
  12 func.func @tanh_f32(%a : f32) {
  13   %r = math.tanh %a : f32
  14   vector.print %r : f32
  15   return
  16 }
  17
  18 func.func @tanh_4xf32(%a : vector<4xf32>) {
  19   %r = math.tanh %a : vector<4xf32>
  20   vector.print %r : vector<4xf32>
  21   return
  22 }
  23
  24 func.func @tanh_8xf32(%a : vector<8xf32>) {
  25   %r = math.tanh %a : vector<8xf32>
  26   vector.print %r : vector<8xf32>
  27   return
  28 }
  29
  30 func.func @tanh() {
  31   // CHECK: 0.848284
  32   %f0 = arith.constant 1.25 : f32
  33   call @tanh_f32(%f0) : (f32) -> ()
  34
  35   // CHECK: 0.244919, 0.635149, 0.761594, 0.848284
  36   %v1 = arith.constant dense<[0.25, 0.75, 1.0, 1.25]> : vector<4xf32>
  37   call @tanh_4xf32(%v1) : (vector<4xf32>) -> ()
  38
  39   // CHECK: 0.099668, 0.197375, 0.291313, 0.379949, 0.462117, 0.53705, 0.604368, 0.664037
  40   %v2 = arith.constant dense<[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]> : vector<8xf32>
  41   call @tanh_8xf32(%v2) : (vector<8xf32>) -> ()
  42
  43   // CHECK: nan
  44   %nan = arith.constant 0x7fc00000 : f32
  45   call @tanh_f32(%nan) : (f32) -> ()
  46
  47  return
  48 }
  49
  50 // -------------------------------------------------------------------------- //
  51 // Log.
  52 // -------------------------------------------------------------------------- //
  53
  54 func.func @log_f32(%a : f32) {
  55   %r = math.log %a : f32
  56   vector.print %r : f32
  57   return
  58 }
  59
  60 func.func @log_4xf32(%a : vector<4xf32>) {
  61   %r = math.log %a : vector<4xf32>
  62   vector.print %r : vector<4xf32>
  63   return
  64 }
  65
  66 func.func @log_8xf32(%a : vector<8xf32>) {
  67   %r = math.log %a : vector<8xf32>
  68   vector.print %r : vector<8xf32>
  69   return
  70 }
  71
  72 func.func @log() {
  73   // CHECK: 2.64704
  74   %f1 = arith.constant 14.112233 : f32
  75   call @log_f32(%f1) : (f32) -> ()
  76
  77   // CHECK: -1.38629, -0.287682, 0, 0.223144
  78   %v1 = arith.constant dense<[0.25, 0.75, 1.0, 1.25]> : vector<4xf32>
  79   call @log_4xf32(%v1) : (vector<4xf32>) -> ()
  80
  81   // CHECK: -2.30259, -1.60944, -1.20397, -0.916291, -0.693147, -0.510826, -0.356675, -0.223144
  82   %v2 = arith.constant dense<[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]> : vector<8xf32>
  83   call @log_8xf32(%v2) : (vector<8xf32>) -> ()
  84
  85   // CHECK: -inf
  86   %zero = arith.constant 0.0 : f32
  87   call @log_f32(%zero) : (f32) -> ()
  88
  89   // CHECK: nan
  90   %nan = arith.constant 0x7fc00000 : f32
  91   call @log_f32(%nan) : (f32) -> ()
  92
  93   // CHECK: inf
  94   %inf = arith.constant 0x7f800000 : f32
  95   call @log_f32(%inf) : (f32) -> ()
  96
  97   // CHECK: -inf, nan, inf, 0.693147
  98   %special_vec = arith.constant dense<[0.0, -1.0, 0x7f800000, 2.0]> : vector<4xf32>
  99   call @log_4xf32(%special_vec) : (vector<4xf32>) -> ()
 100
 101   return
 102 }
 103
 104 func.func @log2_f32(%a : f32) {
 105   %r = math.log2 %a : f32
 106   vector.print %r : f32
 107   return
 108 }
 109
 110 func.func @log2_4xf32(%a : vector<4xf32>) {
 111   %r = math.log2 %a : vector<4xf32>
 112   vector.print %r : vector<4xf32>
 113   return
 114 }
 115
 116 func.func @log2_8xf32(%a : vector<8xf32>) {
 117   %r = math.log2 %a : vector<8xf32>
 118   vector.print %r : vector<8xf32>
 119   return
 120 }
 121
 122 func.func @log2() {
 123   // CHECK: 3.81887
 124   %f0 = arith.constant 14.112233 : f32
 125   call @log2_f32(%f0) : (f32) -> ()
 126
 127   // CHECK: -2, -0.415037, 0, 0.321928
 128   %v1 = arith.constant dense<[0.25, 0.75, 1.0, 1.25]> : vector<4xf32>
 129   call @log2_4xf32(%v1) : (vector<4xf32>) -> ()
 130
 131   // CHECK: -3.32193, -2.32193, -1.73697, -1.32193, -1, -0.736966, -0.514573, -0.321928
 132   %v2 = arith.constant dense<[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]> : vector<8xf32>
 133   call @log2_8xf32(%v2) : (vector<8xf32>) -> ()
 134
 135   // CHECK: -inf
 136   %zero = arith.constant 0.0 : f32
 137   call @log2_f32(%zero) : (f32) -> ()
 138
 139   // CHECK: nan
 140   %neg_one = arith.constant -1.0 : f32
 141   call @log2_f32(%neg_one) : (f32) -> ()
 142
 143   // CHECK: inf
 144   %inf = arith.constant 0x7f800000 : f32
 145   call @log2_f32(%inf) : (f32) -> ()
 146
 147   // CHECK: -inf, nan, inf, 1.58496
 148   %special_vec = arith.constant dense<[0.0, -1.0, 0x7f800000, 3.0]> : vector<4xf32>
 149   call @log2_4xf32(%special_vec) : (vector<4xf32>) -> ()
 150
 151   return
 152 }
 153
 154 func.func @log1p_f32(%a : f32) {
 155   %r = math.log1p %a : f32
 156   vector.print %r : f32
 157   return
 158 }
 159
 160 func.func @log1p_4xf32(%a : vector<4xf32>) {
 161   %r = math.log1p %a : vector<4xf32>
 162   vector.print %r : vector<4xf32>
 163   return
 164 }
 165
 166 func.func @log1p_8xf32(%a : vector<8xf32>) {
 167   %r = math.log1p %a : vector<8xf32>
 168   vector.print %r : vector<8xf32>
 169   return
 170 }
 171
 172 func.func @log1p() {
 173   // CHECK: 0.00995033
 174   %f0 = arith.constant 0.01 : f32
 175   call @log1p_f32(%f0) : (f32) -> ()
 176
 177
 178   // CHECK: -4.60517, -0.693147, 0, 1.38629
 179   %v1 = arith.constant dense<[-0.99, -0.5, 0.0, 3.0]> : vector<4xf32>
 180   call @log1p_4xf32(%v1) : (vector<4xf32>) -> ()
 181
 182   // CHECK: 0.0953102, 0.182322, 0.262364, 0.336472, 0.405465, 0.470004, 0.530628, 0.587787
 183   %v2 = arith.constant dense<[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]> : vector<8xf32>
 184   call @log1p_8xf32(%v2) : (vector<8xf32>) -> ()
 185
 186   // CHECK: -inf
 187   %neg_one = arith.constant -1.0 : f32
 188   call @log1p_f32(%neg_one) : (f32) -> ()
 189
 190   // CHECK: nan
 191   %neg_two = arith.constant -2.0 : f32
 192   call @log1p_f32(%neg_two) : (f32) -> ()
 193
 194   // CHECK: inf
 195   %inf = arith.constant 0x7f800000 : f32
 196   call @log1p_f32(%inf) : (f32) -> ()
 197
 198   // CHECK: -inf, nan, inf, 9.99995e-06
 199   %special_vec = arith.constant dense<[-1.0, -1.1, 0x7f800000, 0.00001]> : vector<4xf32>
 200   call @log1p_4xf32(%special_vec) : (vector<4xf32>) -> ()
 201
 202   return
 203 }
 204
 205 // -------------------------------------------------------------------------- //
 206 // Erf.
 207 // -------------------------------------------------------------------------- //
 208 func.func @erf_f32(%a : f32) {
 209   %r = math.erf %a : f32
 210   vector.print %r : f32
 211   return
 212 }
 213
 214 func.func @erf_4xf32(%a : vector<4xf32>) {
 215   %r = math.erf %a : vector<4xf32>
 216   vector.print %r : vector<4xf32>
 217   return
 218 }
 219
 220 func.func @erf() {
 221   // CHECK: -0.000274406
 222   %val1 = arith.constant -2.431864e-4 : f32
 223   call @erf_f32(%val1) : (f32) -> ()
 224
 225   // CHECK: 0.742095
 226   %val2 = arith.constant 0.79999 : f32
 227   call @erf_f32(%val2) : (f32) -> ()
 228
 229   // CHECK: 0.742101
 230   %val3 = arith.constant 0.8 : f32
 231   call @erf_f32(%val3) : (f32) -> ()
 232
 233   // CHECK: 0.995322
 234   %val4 = arith.constant 1.99999 : f32
 235   call @erf_f32(%val4) : (f32) -> ()
 236
 237   // CHECK: 0.995322
 238   %val5 = arith.constant 2.0 : f32
 239   call @erf_f32(%val5) : (f32) -> ()
 240
 241   // CHECK: 1
 242   %val6 = arith.constant 3.74999 : f32
 243   call @erf_f32(%val6) : (f32) -> ()
 244
 245   // CHECK: 1
 246   %val7 = arith.constant 3.75 : f32
 247   call @erf_f32(%val7) : (f32) -> ()
 248
 249   // CHECK: -1
 250   %negativeInf = arith.constant 0xff800000 : f32
 251   call @erf_f32(%negativeInf) : (f32) -> ()
 252
 253   // CHECK: -1, -1, -0.913759, -0.731446
 254   %vecVals1 = arith.constant dense<[-3.4028235e+38, -4.54318, -1.2130899, -7.8234202e-01]> : vector<4xf32>
 255   call @erf_4xf32(%vecVals1) : (vector<4xf32>) -> ()
 256
 257   // CHECK: -1.3264e-38, 0, 1.3264e-38, 0.121319
 258   %vecVals2 = arith.constant dense<[-1.1754944e-38, 0.0, 1.1754944e-38, 1.0793410e-01]> : vector<4xf32>
 259   call @erf_4xf32(%vecVals2) : (vector<4xf32>) -> ()
 260
 261   // CHECK: 0.919477, 0.999069, 1, 1
 262   %vecVals3 = arith.constant dense<[1.23578, 2.34093, 3.82342, 3.4028235e+38]> : vector<4xf32>
 263   call @erf_4xf32(%vecVals3) : (vector<4xf32>) -> ()
 264
 265   // CHECK: 1
 266   %inf = arith.constant 0x7f800000 : f32
 267   call @erf_f32(%inf) : (f32) -> ()
 268
 269   // CHECK: nan
 270   %nan = arith.constant 0x7fc00000 : f32
 271   call @erf_f32(%nan) : (f32) -> ()
 272
 273   return
 274 }
 275
 276 // -------------------------------------------------------------------------- //
 277 // Exp.
 278 // -------------------------------------------------------------------------- //
 279 func.func @exp_f32(%a : f32) {
 280   %r = math.exp %a : f32
 281   vector.print %r : f32
 282   return
 283 }
 284
 285 func.func @exp_4xf32(%a : vector<4xf32>) {
 286   %r = math.exp %a : vector<4xf32>
 287   vector.print %r : vector<4xf32>
 288   return
 289 }
 290
 291 func.func @exp() {
 292   // CHECK: 2.71828
 293   %f0 = arith.constant 1.0 : f32
 294   call @exp_f32(%f0) : (f32) -> ()
 295
 296   // CHECK: 0.778801, 2.117, 2.71828, 3.85743
 297   %v1 = arith.constant dense<[-0.25, 0.75, 1.0, 1.35]> : vector<4xf32>
 298   call @exp_4xf32(%v1) : (vector<4xf32>) -> ()
 299
 300   // CHECK: 1
 301   %zero = arith.constant 0.0 : f32
 302   call @exp_f32(%zero) : (f32) -> ()
 303
 304   // CHECK: 0, 1.38879e-11, 7.20049e+10, inf
 305   %special_vec = arith.constant dense<[-89.0, -25.0, 25.0, 89.0]> : vector<4xf32>
 306   call @exp_4xf32(%special_vec) : (vector<4xf32>) -> ()
 307
 308   // CHECK: inf
 309   %inf = arith.constant 0x7f800000 : f32
 310   call @exp_f32(%inf) : (f32) -> ()
 311
 312   // CHECK: 0
 313   %negative_inf = arith.constant 0xff800000 : f32
 314   call @exp_f32(%negative_inf) : (f32) -> ()
 315
 316   // CHECK: nan
 317   %nan = arith.constant 0x7fc00000 : f32
 318   call @exp_f32(%nan) : (f32) -> ()
 319
 320   return
 321 }
 322
 323 func.func @expm1_f32(%a : f32) {
 324   %r = math.expm1 %a : f32
 325   vector.print %r : f32
 326   return
 327 }
 328
 329 func.func @expm1_3xf32(%a : vector<3xf32>) {
 330   %r = math.expm1 %a : vector<3xf32>
 331   vector.print %r : vector<3xf32>
 332   return
 333 }
 334
 335 func.func @expm1_4xf32(%a : vector<4xf32>) {
 336   %r = math.expm1 %a : vector<4xf32>
 337   vector.print %r : vector<4xf32>
 338   return
 339 }
 340
 341 func.func @expm1_8xf32(%a : vector<8xf32>) {
 342   %r = math.expm1 %a : vector<8xf32>
 343   vector.print %r : vector<8xf32>
 344   return
 345 }
 346
 347 func.func @expm1() {
 348   // CHECK: 1e-10
 349   %f0 = arith.constant 1.0e-10 : f32
 350   call @expm1_f32(%f0) : (f32) -> ()
 351
 352   // CHECK: -0.00995017, 0.0100502, 0.648721, 6.38906
 353   %v1 = arith.constant dense<[-0.01, 0.01, 0.5, 2.0]> : vector<4xf32>
 354   call @expm1_4xf32(%v1) : (vector<4xf32>) -> ()
 355
 356   // CHECK: -0.181269, 0, 0.221403, 0.491825, 0.822119, 1.22554, 1.71828, 2.32012
 357   %v2 = arith.constant dense<[-0.2, 0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 1.2]> : vector<8xf32>
 358   call @expm1_8xf32(%v2) : (vector<8xf32>) -> ()
 359
 360   // CHECK: -1
 361   %neg_inf = arith.constant 0xff800000 : f32
 362   call @expm1_f32(%neg_inf) : (f32) -> ()
 363
 364   // CHECK: inf
 365   %inf = arith.constant 0x7f800000 : f32
 366   call @expm1_f32(%inf) : (f32) -> ()
 367
 368   // CHECK: -1, inf, 1e-10
 369   %special_vec = arith.constant dense<[0xff800000, 0x7f800000, 1.0e-10]> : vector<3xf32>
 370   call @expm1_3xf32(%special_vec) : (vector<3xf32>) -> ()
 371
 372   // CHECK: nan
 373   %nan = arith.constant 0x7fc00000 : f32
 374   call @expm1_f32(%nan) : (f32) -> ()
 375
 376   return
 377 }
 378 // -------------------------------------------------------------------------- //
 379 // Sin.
 380 // -------------------------------------------------------------------------- //
 381 func.func @sin_f32(%a : f32) {
 382   %r = math.sin %a : f32
 383   vector.print %r : f32
 384   return
 385 }
 386
 387 func.func @sin_3xf32(%a : vector<3xf32>) {
 388   %r = math.sin %a : vector<3xf32>
 389   vector.print %r : vector<3xf32>
 390   return
 391 }
 392
 393 func.func @sin() {
 394   // CHECK: 0
 395   %zero = arith.constant 0.0 : f32
 396   call @sin_f32(%zero) : (f32) -> ()
 397
 398   // CHECK: 0.707107
 399   %pi_over_4 = arith.constant 0.78539816339 : f32
 400   call @sin_f32(%pi_over_4) : (f32) -> ()
 401
 402   // CHECK: 1
 403   %pi_over_2 = arith.constant 1.57079632679 : f32
 404   call @sin_f32(%pi_over_2) : (f32) -> ()
 405
 406   // CHECK: 0
 407   %pi = arith.constant 3.14159265359 : f32
 408   call @sin_f32(%pi) : (f32) -> ()
 409
 410   // CHECK: -1
 411   %pi_3_over_2 = arith.constant 4.71238898038 : f32
 412   call @sin_f32(%pi_3_over_2) : (f32) -> ()
 413
 414   // CHECK: 0, 0.866025, -1
 415   %vec_x = arith.constant dense<[9.42477796077, 2.09439510239, -1.57079632679]> : vector<3xf32>
 416   call @sin_3xf32(%vec_x) : (vector<3xf32>) -> ()
 417
 418   return
 419 }
 420
 421 // -------------------------------------------------------------------------- //
 422 // cos.
 423 // -------------------------------------------------------------------------- //
 424 func.func @cos_f32(%a : f32) {
 425   %r = math.cos %a : f32
 426   vector.print %r : f32
 427   return
 428 }
 429
 430 func.func @cos_3xf32(%a : vector<3xf32>) {
 431   %r = math.cos %a : vector<3xf32>
 432   vector.print %r : vector<3xf32>
 433   return
 434 }
 435
 436 func.func @cos() {
 437   // CHECK: 1
 438   %zero = arith.constant 0.0 : f32
 439   call @cos_f32(%zero) : (f32) -> ()
 440
 441   // CHECK: 0.707107
 442   %pi_over_4 = arith.constant 0.78539816339 : f32
 443   call @cos_f32(%pi_over_4) : (f32) -> ()
 444
 445   // CHECK: 0
 446   %pi_over_2 = arith.constant 1.57079632679 : f32
 447   call @cos_f32(%pi_over_2) : (f32) -> ()
 448
 449   // CHECK: -1
 450   %pi = arith.constant 3.14159265359 : f32
 451   call @cos_f32(%pi) : (f32) -> ()
 452
 453   // CHECK: 0
 454   %pi_3_over_2 = arith.constant 4.71238898038 : f32
 455   call @cos_f32(%pi_3_over_2) : (f32) -> ()
 456
 457   // CHECK: -1, -0.5, 0
 458   %vec_x = arith.constant dense<[9.42477796077, 2.09439510239, -1.57079632679]> : vector<3xf32>
 459   call @cos_3xf32(%vec_x) : (vector<3xf32>) -> ()
 460
 461   return
 462 }
 463
 464 // -------------------------------------------------------------------------- //
 465 // Asin.
 466 // -------------------------------------------------------------------------- //
 467 func.func @asin_f32(%a : f32) {
 468   %r = math.asin %a : f32
 469   vector.print %r : f32
 470   return
 471 }
 472
 473 func.func @asin_3xf32(%a : vector<3xf32>) {
 474   %r = math.asin %a : vector<3xf32>
 475   vector.print %r : vector<3xf32>
 476   return
 477 }
 478
 479 func.func @asin() {
 480   // CHECK: 0
 481   %zero = arith.constant 0.0 : f32
 482   call @asin_f32(%zero) : (f32) -> ()
 483
 484   // CHECK: -0.597406
 485   %cst1 = arith.constant -0.5625 : f32
 486   call @asin_f32(%cst1) : (f32) -> ()
 487
 488   // CHECK: -0.384397
 489   %cst2 = arith.constant -0.375 : f32
 490   call @asin_f32(%cst2) : (f32) -> ()
 491
 492   // CHECK: -0.25268
 493   %cst3 = arith.constant -0.25 : f32
 494   call @asin_f32(%cst3) : (f32) -> ()
 495
 496   // CHECK: -1.1197
 497   %cst4 = arith.constant -0.90 : f32
 498   call @asin_f32(%cst4) : (f32) -> ()
 499
 500   // CHECK: 0.25268, 0.384397, 0.597406
 501   %vec_x = arith.constant dense<[0.25, 0.375, 0.5625]> : vector<3xf32>
 502   call @asin_3xf32(%vec_x) : (vector<3xf32>) -> ()
 503
 504   return
 505 }
 506
 507 // -------------------------------------------------------------------------- //
 508 // Acos.
 509 // -------------------------------------------------------------------------- //
 510 func.func @acos_f32(%a : f32) {
 511   %r = math.acos %a : f32
 512   vector.print %r : f32
 513   return
 514 }
 515
 516 func.func @acos_3xf32(%a : vector<3xf32>) {
 517   %r = math.acos %a : vector<3xf32>
 518   vector.print %r : vector<3xf32>
 519   return
 520 }
 521
 522 func.func @acos() {
 523   // CHECK: 1.5708
 524   %zero = arith.constant 0.0 : f32
 525   call @acos_f32(%zero) : (f32) -> ()
 526
 527   // CHECK: 2.1682
 528   %cst1 = arith.constant -0.5625 : f32
 529   call @acos_f32(%cst1) : (f32) -> ()
 530
 531   // CHECK: 1.95519
 532   %cst2 = arith.constant -0.375 : f32
 533   call @acos_f32(%cst2) : (f32) -> ()
 534
 535   // CHECK: 1.82348
 536   %cst3 = arith.constant -0.25 : f32
 537   call @acos_f32(%cst3) : (f32) -> ()
 538
 539   // CHECK: 1.31812, 1.1864, 0.97339
 540   %vec_x = arith.constant dense<[0.25, 0.375, 0.5625]> : vector<3xf32>
 541   call @acos_3xf32(%vec_x) : (vector<3xf32>) -> ()
 542
 543   return
 544 }
 545
 546 // -------------------------------------------------------------------------- //
 547 // Atan.
 548 // -------------------------------------------------------------------------- //
 549 func.func @atan_f32(%a : f32) {
 550   %r = math.atan %a : f32
 551   vector.print %r : f32
 552   return
 553 }
 554
 555 func.func @atan() {
 556   // CHECK: -0.785398
 557   %0 = arith.constant -1.0 : f32
 558   call @atan_f32(%0) : (f32) -> ()
 559
 560   // CHECK: 0.785398
 561   %1 = arith.constant 1.0 : f32
 562   call @atan_f32(%1) : (f32) -> ()
 563
 564   // CHECK: -0.463648
 565   %2 = arith.constant -0.5 : f32
 566   call @atan_f32(%2) : (f32) -> ()
 567
 568   // CHECK: 0.463648
 569   %3 = arith.constant 0.5 : f32
 570   call @atan_f32(%3) : (f32) -> ()
 571
 572   // CHECK: 0
 573   %4 = arith.constant 0.0 : f32
 574   call @atan_f32(%4) : (f32) -> ()
 575
 576   // CHECK: -1.10715
 577   %5 = arith.constant -2.0 : f32
 578   call @atan_f32(%5) : (f32) -> ()
 579
 580   // CHECK: 1.10715
 581   %6 = arith.constant 2.0 : f32
 582   call @atan_f32(%6) : (f32) -> ()
 583
 584   return
 585 }
 586
 587
 588 // -------------------------------------------------------------------------- //
 589 // Atan2.
 590 // -------------------------------------------------------------------------- //
 591 func.func @atan2_f32(%a : f32, %b : f32) {
 592   %r = math.atan2 %a, %b : f32
 593   vector.print %r : f32
 594   return
 595 }
 596
 597 func.func @atan2() {
 598   %zero = arith.constant 0.0 : f32
 599   %one = arith.constant 1.0 : f32
 600   %two = arith.constant 2.0 : f32
 601   %neg_one = arith.constant -1.0 : f32
 602   %neg_two = arith.constant -2.0 : f32
 603
 604   // CHECK: 0
 605   call @atan2_f32(%zero, %one) : (f32, f32) -> ()
 606
 607   // CHECK: 1.5708
 608   call @atan2_f32(%one, %zero) : (f32, f32) -> ()
 609
 610   // CHECK: 3.14159
 611   call @atan2_f32(%zero, %neg_one) : (f32, f32) -> ()
 612
 613   // CHECK: -1.5708
 614   call @atan2_f32(%neg_one, %zero) : (f32, f32) -> ()
 615
 616   // CHECK: nan
 617   call @atan2_f32(%zero, %zero) : (f32, f32) -> ()
 618
 619   // CHECK: 1.10715
 620   call @atan2_f32(%two, %one) : (f32, f32) -> ()
 621
 622   // CHECK: 2.03444
 623   %x6 = arith.constant -1.0 : f32
 624   %y6 = arith.constant 2.0 : f32
 625   call @atan2_f32(%two, %neg_one) : (f32, f32) -> ()
 626
 627   // CHECK: -2.03444
 628   call @atan2_f32(%neg_two, %neg_one) : (f32, f32) -> ()
 629
 630   // CHECK: -1.10715
 631   call @atan2_f32(%neg_two, %one) : (f32, f32) -> ()
 632
 633   // CHECK: 0.463648
 634   call @atan2_f32(%one, %two) : (f32, f32) -> ()
 635
 636   // CHECK: 2.67795
 637   %x10 = arith.constant -2.0 : f32
 638   %y10 = arith.constant 1.0 : f32
 639   call @atan2_f32(%one, %neg_two) : (f32, f32) -> ()
 640
 641   // CHECK: -2.67795
 642   %x11 = arith.constant -2.0 : f32
 643   %y11 = arith.constant -1.0 : f32
 644   call @atan2_f32(%neg_one, %neg_two) : (f32, f32) -> ()
 645
 646   // CHECK: -0.463648
 647   call @atan2_f32(%neg_one, %two) : (f32, f32) -> ()
 648
 649   return
 650 }
 651
 652
 653 // -------------------------------------------------------------------------- //
 654 // Cbrt.
 655 // -------------------------------------------------------------------------- //
 656
 657 func.func @cbrt_f32(%a : f32) {
 658   %r = math.cbrt %a : f32
 659   vector.print %r : f32
 660   return
 661 }
 662
 663 func.func @cbrt() {
 664   // CHECK: 1
 665   %a = arith.constant 1.0 : f32
 666   call @cbrt_f32(%a) : (f32) -> ()
 667
 668   // CHECK: -1
 669   %b = arith.constant -1.0 : f32
 670   call @cbrt_f32(%b) : (f32) -> ()
 671
 672   // CHECK: 0
 673   %c = arith.constant 0.0 : f32
 674   call @cbrt_f32(%c) : (f32) -> ()
 675
 676   // CHECK: -0
 677   %d = arith.constant -0.0 : f32
 678   call @cbrt_f32(%d) : (f32) -> ()
 679
 680   // CHECK: 10
 681   %e = arith.constant 1000.0 : f32
 682   call @cbrt_f32(%e) : (f32) -> ()
 683
 684   // CHECK: -10
 685   %f = arith.constant -1000.0 : f32
 686   call @cbrt_f32(%f) : (f32) -> ()
 687
 688   // CHECK: 2.57128
 689   %g = arith.constant 17.0 : f32
 690   call @cbrt_f32(%g) : (f32) -> ()
 691
 692   return
 693 }
 694
 695 // -------------------------------------------------------------------------- //
 696 // floor.
 697 // -------------------------------------------------------------------------- //
 698 func.func @func_floorf32(%a : f32) {
 699   %r = math.floor %a : f32
 700   vector.print %r : f32
 701   return
 702 }
 703
 704 func.func @floorf() {
 705   // CHECK: 3
 706   %a = arith.constant 3.8 : f32
 707   call @func_floorf32(%a) : (f32) -> ()
 708
 709   // CHECK: -4
 710   %b = arith.constant -3.8 : f32
 711   call @func_floorf32(%b) : (f32) -> ()
 712
 713   // CHECK: 0
 714   %c = arith.constant 0.0 : f32
 715   call @func_floorf32(%c) : (f32) -> ()
 716
 717   // CHECK: -5
 718   %d = arith.constant -4.2 : f32
 719   call @func_floorf32(%d) : (f32) -> ()
 720
 721   // CHECK: -2
 722   %e = arith.constant -2.0 : f32
 723   call @func_floorf32(%e) : (f32) -> ()
 724
 725   // CHECK: 2
 726   %f = arith.constant 2.0 : f32
 727   call @func_floorf32(%f) : (f32) -> ()
 728
 729   return
 730 }
 731
 732 // -------------------------------------------------------------------------- //
 733 // ceil.
 734 // -------------------------------------------------------------------------- //
 735 func.func @func_ceilf32(%a : f32) {
 736   %r = math.ceil %a : f32
 737   vector.print %r : f32
 738   return
 739 }
 740
 741 func.func @ceilf() {
 742   // CHECK: 4
 743   %a = arith.constant 3.8 : f32
 744   call @func_ceilf32(%a) : (f32) -> ()
 745
 746   // CHECK: -3
 747   %b = arith.constant -3.8 : f32
 748   call @func_ceilf32(%b) : (f32) -> ()
 749
 750   // CHECK: 0
 751   %c = arith.constant 0.0 : f32
 752   call @func_ceilf32(%c) : (f32) -> ()
 753
 754   // CHECK: -4
 755   %d = arith.constant -4.2 : f32
 756   call @func_ceilf32(%d) : (f32) -> ()
 757
 758   // CHECK: -495
 759   %e = arith.constant -495.0 : f32
 760   call @func_ceilf32(%e) : (f32) -> ()
 761
 762   // CHECK: 495
 763   %f = arith.constant 495.0 : f32
 764   call @func_ceilf32(%f) : (f32) -> ()
 765
 766   return
 767 }
 768
 769 func.func @main() {
 770   call @tanh(): () -> ()
 771   call @log(): () -> ()
 772   call @log2(): () -> ()
 773   call @log1p(): () -> ()
 774   call @erf(): () -> ()
 775   call @exp(): () -> ()
 776   call @expm1(): () -> ()
 777   call @sin(): () -> ()
 778   call @cos(): () -> ()
 779   call @asin(): () -> ()
 780   call @acos(): () -> ()
 781   call @atan() : () -> ()
 782   call @atan2() : () -> ()
 783   call @cbrt() : () -> ()
 784   call @floorf() : () -> ()
 785   call @ceilf() : () -> ()
 786   return
 787 }