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 TestTanhNovec(t *testing.T) {
 112         if !HasVX {
 113                 t.Skipf("no vector support")
 114         }
 115         for i := 0; i < len(vf); i++ {
 116                 if f := TanhNoVec(vf[i]); !veryclose(tanh[i], f) {
 117                         t.Errorf("Tanh(%g) = %g, want %g", vf[i], f, tanh[i])
 118                 }
 119         }
 120         for i := 0; i < len(vftanhSC); i++ {
 121                 if f := TanhNoVec(vftanhSC[i]); !alike(tanhSC[i], f) {
 122                         t.Errorf("Tanh(%g) = %g, want %g", vftanhSC[i], f, tanhSC[i])
 123                 }
 124         }
 125
 126 }
 127
 128 func TestLog10Novec(t *testing.T) {
 129         if !HasVX {
 130                 t.Skipf("no vector support")
 131         }
 132         for i := 0; i < len(vf); i++ {
 133                 a := Abs(vf[i])
 134                 if f := Log10NoVec(a); !veryclose(log10[i], f) {
 135                         t.Errorf("Log10(%g) = %g, want %g", a, f, log10[i])
 136                 }
 137         }
 138         if f := Log10NoVec(E); f != Log10E {
 139                 t.Errorf("Log10(%g) = %g, want %g", E, f, Log10E)
 140         }
 141         for i := 0; i < len(vflogSC); i++ {
 142                 if f := Log10NoVec(vflogSC[i]); !alike(logSC[i], f) {
 143                         t.Errorf("Log10(%g) = %g, want %g", vflogSC[i], f, logSC[i])
 144                 }
 145         }
 146 }