...
Run Format

Source file src/math/arith_s390x_test.go

Documentation: math

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

View as plain text