Black Lives Matter. Support the Equal Justice Initiative.

# 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
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