libgo/go/math/arith_s390x_test.go

   1 // Copyright 2016 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // +build ignore
   6
   7 // Tests whether the non vector routines are working, even when the tests are run on a
   8 // vector-capable machine.
   9 package math_test
  10
  11 import (
  12         . "math"
  13         "testing"
  14 )
  15
  16 func TestCosNovec(t *testing.T) {
  17         if !HasVX {
  18                 t.Skipf("no vector support")
  19         }
  20         for i := 0; i < len(vf); i++ {
  21                 if f := CosNoVec(vf[i]); !veryclose(cos[i], f) {
  22                         t.Errorf("Cos(%g) = %g, want %g", vf[i], f, cos[i])
  23                 }
  24         }
  25         for i := 0; i < len(vfcosSC); i++ {
  26                 if f := CosNoVec(vfcosSC[i]); !alike(cosSC[i], f) {
  27                         t.Errorf("Cos(%g) = %g, want %g", vfcosSC[i], f, cosSC[i])
  28                 }
  29         }
  30 }
  31
  32 func TestCoshNovec(t *testing.T) {
  33         if !HasVX {
  34                 t.Skipf("no vector support")
  35         }
  36         for i := 0; i < len(vf); i++ {
  37                 if f := CoshNoVec(vf[i]); !close(cosh[i], f) {
  38                         t.Errorf("Cosh(%g) = %g, want %g", vf[i], f, cosh[i])
  39                 }
  40         }
  41         for i := 0; i < len(vfcoshSC); i++ {
  42                 if f := CoshNoVec(vfcoshSC[i]); !alike(coshSC[i], f) {
  43                         t.Errorf("Cosh(%g) = %g, want %g", vfcoshSC[i], f, coshSC[i])
  44                 }
  45         }
  46 }
  47 func TestSinNovec(t *testing.T) {
  48         if !HasVX {
  49                 t.Skipf("no vector support")
  50         }
  51         for i := 0; i < len(vf); i++ {
  52                 if f := SinNoVec(vf[i]); !veryclose(sin[i], f) {
  53                         t.Errorf("Sin(%g) = %g, want %g", vf[i], f, sin[i])
  54                 }
  55         }
  56         for i := 0; i < len(vfsinSC); i++ {
  57                 if f := SinNoVec(vfsinSC[i]); !alike(sinSC[i], f) {
  58                         t.Errorf("Sin(%g) = %g, want %g", vfsinSC[i], f, sinSC[i])
  59                 }
  60         }
  61 }
  62
  63 func TestSinhNovec(t *testing.T) {
  64         if !HasVX {
  65                 t.Skipf("no vector support")
  66         }
  67         for i := 0; i < len(vf); i++ {
  68                 if f := SinhNoVec(vf[i]); !close(sinh[i], f) {
  69                         t.Errorf("Sinh(%g) = %g, want %g", vf[i], f, sinh[i])
  70                 }
  71         }
  72         for i := 0; i < len(vfsinhSC); i++ {
  73                 if f := SinhNoVec(vfsinhSC[i]); !alike(sinhSC[i], f) {
  74                         t.Errorf("Sinh(%g) = %g, want %g", vfsinhSC[i], f, sinhSC[i])
  75                 }
  76         }
  77 }
  78
  79 // Check that math functions of high angle values
  80 // return accurate results. [Since (vf[i] + large) - large != vf[i],
  81 // testing for Trig(vf[i] + large) == Trig(vf[i]), where large is
  82 // a multiple of 2*Pi, is misleading.]
  83 func TestLargeCosNovec(t *testing.T) {
  84         if !HasVX {
  85                 t.Skipf("no vector support")
  86         }
  87         large := float64(100000 * Pi)
  88         for i := 0; i < len(vf); i++ {
  89                 f1 := cosLarge[i]
  90                 f2 := CosNoVec(vf[i] + large)
  91                 if !close(f1, f2) {
  92                         t.Errorf("Cos(%g) = %g, want %g", vf[i]+large, f2, f1)
  93                 }
  94         }
  95 }
  96
  97 func TestLargeSinNovec(t *testing.T) {
  98         if !HasVX {
  99                 t.Skipf("no vector support")
 100         }
 101         large := float64(100000 * Pi)
 102         for i := 0; i < len(vf); i++ {
 103                 f1 := sinLarge[i]
 104                 f2 := SinNoVec(vf[i] + large)
 105                 if !close(f1, f2) {
 106                         t.Errorf("Sin(%g) = %g, want %g", vf[i]+large, f2, f1)
 107                 }
 108         }
 109 }
 110
 111 func TestLargeTanNovec(t *testing.T) {
 112         if !HasVX {
 113                 t.Skipf("no vector support")
 114         }
 115         large := float64(100000 * Pi)
 116         for i := 0; i < len(vf); i++ {
 117                 f1 := tanLarge[i]
 118                 f2 := TanNovec(vf[i] + large)
 119                 if !close(f1, f2) {
 120                         t.Errorf("Tan(%g) = %g, want %g", vf[i]+large, f2, f1)
 121                 }
 122         }
 123 }
 124
 125 func TestTanNovec(t *testing.T) {
 126         if !HasVX {
 127                 t.Skipf("no vector support")
 128         }
 129         for i := 0; i < len(vf); i++ {
 130                 if f := TanNovec(vf[i]); !veryclose(tan[i], f) {
 131                         t.Errorf("Tan(%g) = %g, want %g", vf[i], f, tan[i])
 132                 }
 133         }
 134         // same special cases as Sin
 135         for i := 0; i < len(vfsinSC); i++ {
 136                 if f := TanNovec(vfsinSC[i]); !alike(sinSC[i], f) {
 137                         t.Errorf("Tan(%g) = %g, want %g", vfsinSC[i], f, sinSC[i])
 138                 }
 139         }
 140 }
 141
 142 func TestTanhNovec(t *testing.T) {
 143         if !HasVX {
 144                 t.Skipf("no vector support")
 145         }
 146         for i := 0; i < len(vf); i++ {
 147                 if f := TanhNoVec(vf[i]); !veryclose(tanh[i], f) {
 148                         t.Errorf("Tanh(%g) = %g, want %g", vf[i], f, tanh[i])
 149                 }
 150         }
 151         for i := 0; i < len(vftanhSC); i++ {
 152                 if f := TanhNoVec(vftanhSC[i]); !alike(tanhSC[i], f) {
 153                         t.Errorf("Tanh(%g) = %g, want %g", vftanhSC[i], f, tanhSC[i])
 154                 }
 155         }
 156
 157 }
 158
 159 func TestLog10Novec(t *testing.T) {
 160         if !HasVX {
 161                 t.Skipf("no vector support")
 162         }
 163         for i := 0; i < len(vf); i++ {
 164                 a := Abs(vf[i])
 165                 if f := Log10NoVec(a); !veryclose(log10[i], f) {
 166                         t.Errorf("Log10(%g) = %g, want %g", a, f, log10[i])
 167                 }
 168         }
 169         if f := Log10NoVec(E); f != Log10E {
 170                 t.Errorf("Log10(%g) = %g, want %g", E, f, Log10E)
 171         }
 172         for i := 0; i < len(vflogSC); i++ {
 173                 if f := Log10NoVec(vflogSC[i]); !alike(logSC[i], f) {
 174                         t.Errorf("Log10(%g) = %g, want %g", vflogSC[i], f, logSC[i])
 175                 }
 176         }
 177 }
 178
 179 func TestLog1pNovec(t *testing.T) {
 180         if !HasVX {
 181                 t.Skipf("no vector support")
 182         }
 183         for i := 0; i < len(vf); i++ {
 184                 a := vf[i] / 100
 185                 if f := Log1pNovec(a); !veryclose(log1p[i], f) {
 186                         t.Errorf("Log1p(%g) = %g, want %g", a, f, log1p[i])
 187                 }
 188         }
 189         a := 9.0
 190         if f := Log1pNovec(a); f != Ln10 {
 191                 t.Errorf("Log1p(%g) = %g, want %g", a, f, Ln10)
 192         }
 193         for i := 0; i < len(vflogSC); i++ {
 194                 if f := Log1pNovec(vflog1pSC[i]); !alike(log1pSC[i], f) {
 195                         t.Errorf("Log1p(%g) = %g, want %g", vflog1pSC[i], f, log1pSC[i])
 196                 }
 197         }
 198 }
 199
 200 func TestAtanhNovec(t *testing.T) {
 201         if !HasVX {
 202                 t.Skipf("no vector support")
 203         }
 204         for i := 0; i < len(vf); i++ {
 205                 a := vf[i] / 10
 206                 if f := AtanhNovec(a); !veryclose(atanh[i], f) {
 207                         t.Errorf("Atanh(%g) = %g, want %g", a, f, atanh[i])
 208                 }
 209         }
 210         for i := 0; i < len(vfatanhSC); i++ {
 211                 if f := AtanhNovec(vfatanhSC[i]); !alike(atanhSC[i], f) {
 212                         t.Errorf("Atanh(%g) = %g, want %g", vfatanhSC[i], f, atanhSC[i])
 213                 }
 214         }
 215 }
 216
 217 func TestAcosNovec(t *testing.T) {
 218         if !HasVX {
 219                 t.Skipf("no vector support")
 220         }
 221         for i := 0; i < len(vf); i++ {
 222                 a := vf[i] / 10
 223                 if f := AcosNovec(a); !close(acos[i], f) {
 224                         t.Errorf("Acos(%g) = %g, want %g", a, f, acos[i])
 225                 }
 226         }
 227         for i := 0; i < len(vfacosSC); i++ {
 228                 if f := AcosNovec(vfacosSC[i]); !alike(acosSC[i], f) {
 229                         t.Errorf("Acos(%g) = %g, want %g", vfacosSC[i], f, acosSC[i])
 230                 }
 231         }
 232 }
 233
 234 func TestAsinNovec(t *testing.T) {
 235         if !HasVX {
 236                 t.Skipf("no vector support")
 237         }
 238         for i := 0; i < len(vf); i++ {
 239                 a := vf[i] / 10
 240                 if f := AsinNovec(a); !veryclose(asin[i], f) {
 241                         t.Errorf("Asin(%g) = %g, want %g", a, f, asin[i])
 242                 }
 243         }
 244         for i := 0; i < len(vfasinSC); i++ {
 245                 if f := AsinNovec(vfasinSC[i]); !alike(asinSC[i], f) {
 246                         t.Errorf("Asin(%g) = %g, want %g", vfasinSC[i], f, asinSC[i])
 247                 }
 248         }
 249 }
 250
 251 func TestAcoshNovec(t *testing.T) {
 252         if !HasVX {
 253                 t.Skipf("no vector support")
 254         }
 255         for i := 0; i < len(vf); i++ {
 256                 a := 1 + Abs(vf[i])
 257                 if f := AcoshNovec(a); !veryclose(acosh[i], f) {
 258                         t.Errorf("Acosh(%g) = %g, want %g", a, f, acosh[i])
 259                 }
 260         }
 261         for i := 0; i < len(vfacoshSC); i++ {
 262                 if f := AcoshNovec(vfacoshSC[i]); !alike(acoshSC[i], f) {
 263                         t.Errorf("Acosh(%g) = %g, want %g", vfacoshSC[i], f, acoshSC[i])
 264                 }
 265         }
 266 }
 267
 268 func TestAsinhNovec(t *testing.T) {
 269         if !HasVX {
 270                 t.Skipf("no vector support")
 271         }
 272         for i := 0; i < len(vf); i++ {
 273                 if f := AsinhNovec(vf[i]); !veryclose(asinh[i], f) {
 274                         t.Errorf("Asinh(%g) = %g, want %g", vf[i], f, asinh[i])
 275                 }
 276         }
 277         for i := 0; i < len(vfasinhSC); i++ {
 278                 if f := AsinhNovec(vfasinhSC[i]); !alike(asinhSC[i], f) {
 279                         t.Errorf("Asinh(%g) = %g, want %g", vfasinhSC[i], f, asinhSC[i])
 280                 }
 281         }
 282 }
 283
 284 func TestErfNovec(t *testing.T) {
 285         if !HasVX {
 286                 t.Skipf("no vector support")
 287         }
 288         for i := 0; i < len(vf); i++ {
 289                 a := vf[i] / 10
 290                 if f := ErfNovec(a); !veryclose(erf[i], f) {
 291                         t.Errorf("Erf(%g) = %g, want %g", a, f, erf[i])
 292                 }
 293         }
 294         for i := 0; i < len(vferfSC); i++ {
 295                 if f := ErfNovec(vferfSC[i]); !alike(erfSC[i], f) {
 296                         t.Errorf("Erf(%g) = %g, want %g", vferfSC[i], f, erfSC[i])
 297                 }
 298         }
 299 }
 300
 301 func TestErfcNovec(t *testing.T) {
 302         if !HasVX {
 303                 t.Skipf("no vector support")
 304         }
 305         for i := 0; i < len(vf); i++ {
 306                 a := vf[i] / 10
 307                 if f := ErfcNovec(a); !veryclose(erfc[i], f) {
 308                         t.Errorf("Erfc(%g) = %g, want %g", a, f, erfc[i])
 309                 }
 310         }
 311         for i := 0; i < len(vferfcSC); i++ {
 312                 if f := ErfcNovec(vferfcSC[i]); !alike(erfcSC[i], f) {
 313                         t.Errorf("Erfc(%g) = %g, want %g", vferfcSC[i], f, erfcSC[i])
 314                 }
 315         }
 316 }
 317
 318 func TestAtanNovec(t *testing.T) {
 319         if !HasVX {
 320                 t.Skipf("no vector support")
 321         }
 322         for i := 0; i < len(vf); i++ {
 323                 if f := AtanNovec(vf[i]); !veryclose(atan[i], f) {
 324                         t.Errorf("Atan(%g) = %g, want %g", vf[i], f, atan[i])
 325                 }
 326         }
 327         for i := 0; i < len(vfatanSC); i++ {
 328                 if f := AtanNovec(vfatanSC[i]); !alike(atanSC[i], f) {
 329                         t.Errorf("Atan(%g) = %g, want %g", vfatanSC[i], f, atanSC[i])
 330                 }
 331         }
 332 }
 333
 334 func TestAtan2Novec(t *testing.T) {
 335         if !HasVX {
 336                 t.Skipf("no vector support")
 337         }
 338         for i := 0; i < len(vf); i++ {
 339                 if f := Atan2Novec(10, vf[i]); !veryclose(atan2[i], f) {
 340                         t.Errorf("Atan2(10, %g) = %g, want %g", vf[i], f, atan2[i])
 341                 }
 342         }
 343         for i := 0; i < len(vfatan2SC); i++ {
 344                 if f := Atan2Novec(vfatan2SC[i][0], vfatan2SC[i][1]); !alike(atan2SC[i], f) {
 345                         t.Errorf("Atan2(%g, %g) = %g, want %g", vfatan2SC[i][0], vfatan2SC[i][1], f, atan2SC[i])
 346                 }
 347         }
 348 }
 349
 350 func TestCbrtNovec(t *testing.T) {
 351         if !HasVX {
 352                 t.Skipf("no vector support")
 353         }
 354         for i := 0; i < len(vf); i++ {
 355                 if f := CbrtNovec(vf[i]); !veryclose(cbrt[i], f) {
 356                         t.Errorf("Cbrt(%g) = %g, want %g", vf[i], f, cbrt[i])
 357                 }
 358         }
 359         for i := 0; i < len(vfcbrtSC); i++ {
 360                 if f := CbrtNovec(vfcbrtSC[i]); !alike(cbrtSC[i], f) {
 361                         t.Errorf("Cbrt(%g) = %g, want %g", vfcbrtSC[i], f, cbrtSC[i])
 362                 }
 363         }
 364 }
 365
 366 func TestLogNovec(t *testing.T) {
 367         if !HasVX {
 368                 t.Skipf("no vector support")
 369         }
 370         for i := 0; i < len(vf); i++ {
 371                 a := Abs(vf[i])
 372                 if f := LogNovec(a); log[i] != f {
 373                         t.Errorf("Log(%g) = %g, want %g", a, f, log[i])
 374                 }
 375         }
 376         if f := LogNovec(10); f != Ln10 {
 377                 t.Errorf("Log(%g) = %g, want %g", 10.0, f, Ln10)
 378         }
 379         for i := 0; i < len(vflogSC); i++ {
 380                 if f := LogNovec(vflogSC[i]); !alike(logSC[i], f) {
 381                         t.Errorf("Log(%g) = %g, want %g", vflogSC[i], f, logSC[i])
 382                 }
 383         }
 384 }
 385
 386 func TestExpNovec(t *testing.T) {
 387         if !HasVX {
 388                 t.Skipf("no vector support")
 389         }
 390         testExpNovec(t, Exp, "Exp")
 391         testExpNovec(t, ExpGo, "ExpGo")
 392 }
 393
 394 func testExpNovec(t *testing.T, Exp func(float64) float64, name string) {
 395         for i := 0; i < len(vf); i++ {
 396                 if f := ExpNovec(vf[i]); !veryclose(exp[i], f) {
 397                         t.Errorf("%s(%g) = %g, want %g", name, vf[i], f, exp[i])
 398                 }
 399         }
 400         for i := 0; i < len(vfexpSC); i++ {
 401                 if f := ExpNovec(vfexpSC[i]); !alike(expSC[i], f) {
 402                         t.Errorf("%s(%g) = %g, want %g", name, vfexpSC[i], f, expSC[i])
 403                 }
 404         }
 405 }
 406
 407 func TestExpm1Novec(t *testing.T) {
 408         if !HasVX {
 409                 t.Skipf("no vector support")
 410         }
 411         for i := 0; i < len(vf); i++ {
 412                 a := vf[i] / 100
 413                 if f := Expm1Novec(a); !veryclose(expm1[i], f) {
 414                         t.Errorf("Expm1(%g) = %g, want %g", a, f, expm1[i])
 415                 }
 416         }
 417         for i := 0; i < len(vf); i++ {
 418                 a := vf[i] * 10
 419                 if f := Expm1Novec(a); !close(expm1Large[i], f) {
 420                         t.Errorf("Expm1(%g) = %g, want %g", a, f, expm1Large[i])
 421                 }
 422         }
 423         for i := 0; i < len(vfexpm1SC); i++ {
 424                 if f := Expm1Novec(vfexpm1SC[i]); !alike(expm1SC[i], f) {
 425                         t.Errorf("Expm1(%g) = %g, want %g", vfexpm1SC[i], f, expm1SC[i])
 426                 }
 427         }
 428 }
 429
 430 func TestPowNovec(t *testing.T) {
 431         if !HasVX {
 432                 t.Skipf("no vector support")
 433         }
 434         for i := 0; i < len(vf); i++ {
 435                 if f := PowNovec(10, vf[i]); !close(pow[i], f) {
 436                         t.Errorf("Pow(10, %g) = %g, want %g", vf[i], f, pow[i])
 437                 }
 438         }
 439         for i := 0; i < len(vfpowSC); i++ {
 440                 if f := PowNovec(vfpowSC[i][0], vfpowSC[i][1]); !alike(powSC[i], f) {
 441                         t.Errorf("Pow(%g, %g) = %g, want %g", vfpowSC[i][0], vfpowSC[i][1], f, powSC[i])
 442                 }
 443         }
 444 }