go/src/math/all_test.go

var vf

var acos

var acosh

var asin

var asinh

var atan

var atanh

var atan2

var cbrt

var ceil

var copysign

var cos

var cosLarge

var cosh

var erf

var erfc

var erfinv

var exp

var expm1

var expm1Large

var exp2

var fabs

var fdim

var floor

var fmod

type fi

var frexp

var gamma

var j0

var j1

var j2

var jM3

var lgamma

var log

var logb

var log10

var log1p

var log2

var modf

var nextafter32

var nextafter64

var pow

var remainder

var round

var signbit

var sin

var sinLarge

var sinh

var sqrt

var tan

var tanLarge

var tanh

var trunc

var y0

var y1

var y2

var yM3

var vfacosSC

var acosSC

var vfacoshSC

var acoshSC

var vfasinSC

var asinSC

var vfasinhSC

var asinhSC

var vfatanSC

var atanSC

var vfatanhSC

var atanhSC

var vfatan2SC

var atan2SC

var vfcbrtSC

var cbrtSC

var vfceilSC

var ceilBaseSC

var ceilSC

var floorSC

var truncSC

var vfcopysignSC

var copysignSC

var vfcosSC

var cosSC

var vfcoshSC

var coshSC

var vferfSC

var erfSC

var vferfcSC

var erfcSC

var vferfinvSC

var erfinvSC

var vferfcinvSC

var erfcinvSC

var vfexpSC

var expSC

var vfexp2SC

var exp2SC

var vfexpm1SC

var expm1SC

var vffabsSC

var fabsSC

var vffdimSC

var nan

var vffdim2SC

var fdimSC

var fmaxSC

var fminSC

var vffmodSC

var fmodSC

var vffrexpSC

var frexpSC

var vfgamma

var vfhypotSC

var hypotSC

var ilogbSC

var vfj0SC

var j0SC

var j1SC

var j2SC

var jM3SC

var vfldexpSC

var ldexpSC

var vflgammaSC

var lgammaSC

var vflogSC

var logSC

var vflogbSC

var logbSC

var vflog1pSC

var log1pSC

var vfmodfSC

var modfSC

var vfnextafter32SC

var nextafter32SC

var vfnextafter64SC

var nextafter64SC

var vfpowSC

var powSC

var vfpow10SC

var pow10SC

var vfroundSC

var vfroundEvenSC

var vfsignbitSC

var signbitSC

var vfsinSC

var sinSC

var vfsinhSC

var sinhSC

var vfsqrtSC

var sqrtSC

var vftanhSC

var tanhSC

var vfy0SC

var y0SC

var y1SC

var y2SC

var yM3SC

const SmallestNormalFloat64

const LargestSubnormalFloat64

var vffrexpBC

var frexpBC

var vfldexpBC

var ldexpBC

var logbBC

var fmaC

var sqrt32

func tolerance(a, b, e float64) bool {}

func close(a, b float64) bool      {}

func veryclose(a, b float64) bool  {}

func soclose(a, b, e float64) bool {}

func alike(a, b float64) bool {}

func TestNaN(t *testing.T) {}

func TestAcos(t *testing.T) {}

func TestAcosh(t *testing.T) {}

func TestAsin(t *testing.T) {}

func TestAsinh(t *testing.T) {}

func TestAtan(t *testing.T) {}

func TestAtanh(t *testing.T) {}

func TestAtan2(t *testing.T) {}

func TestCbrt(t *testing.T) {}

func TestCeil(t *testing.T) {}

func TestCopysign(t *testing.T) {}

func TestCos(t *testing.T) {}

func TestCosh(t *testing.T) {}

func TestErf(t *testing.T) {}

func TestErfc(t *testing.T) {}

func TestErfinv(t *testing.T) {}

func TestErfcinv(t *testing.T) {}

func TestExp(t *testing.T) {}

func testExp(t *testing.T, Exp func(float64) float64, name string) {}

func TestExpm1(t *testing.T) {}

func TestExp2(t *testing.T) {}

func testExp2(t *testing.T, Exp2 func(float64) float64, name string) {}

func TestAbs(t *testing.T) {}

func TestDim(t *testing.T) {}

func TestFloor(t *testing.T) {}

func TestMax(t *testing.T) {}

func TestMin(t *testing.T) {}

func TestMod(t *testing.T) {}

func TestFrexp(t *testing.T) {}

func TestGamma(t *testing.T) {}

func TestHypot(t *testing.T) {}

func TestHypotGo(t *testing.T) {}

func TestIlogb(t *testing.T) {}

func TestJ0(t *testing.T) {}

func TestJ1(t *testing.T) {}

func TestJn(t *testing.T) {}

func TestLdexp(t *testing.T) {}

func TestLgamma(t *testing.T) {}

func TestLog(t *testing.T) {}

func TestLogb(t *testing.T) {}

func TestLog10(t *testing.T) {}

func TestLog1p(t *testing.T) {}

func TestLog2(t *testing.T) {}

func TestModf(t *testing.T) {}

func TestNextafter32(t *testing.T) {}

func TestNextafter64(t *testing.T) {}

func TestPow(t *testing.T) {}

func TestPow10(t *testing.T) {}

func TestRemainder(t *testing.T) {}

func TestRound(t *testing.T) {}

func TestRoundToEven(t *testing.T) {}

func TestSignbit(t *testing.T) {}

func TestSin(t *testing.T) {}

func TestSincos(t *testing.T) {}

func TestSinh(t *testing.T) {}

func TestSqrt(t *testing.T) {}

func TestTan(t *testing.T) {}

func TestTanh(t *testing.T) {}

func TestTrunc(t *testing.T) {}

func TestY0(t *testing.T) {}

func TestY1(t *testing.T) {}

func TestYn(t *testing.T) {}

var PortableFMA

func TestFMA(t *testing.T) {}

//go:noinline
func fmsub(x, y, z float64) float64 {}

//go:noinline
func fnmsub(x, y, z float64) float64 {}

//go:noinline
func fnmadd(x, y, z float64) float64 {}

func TestFMANegativeArgs(t *testing.T) {}

// Check that math functions of high angle values
// return accurate results. [Since (vf[i] + large) - large != vf[i],
// testing for Trig(vf[i] + large) == Trig(vf[i]), where large is
// a multiple of 2*Pi, is misleading.]
func TestLargeCos(t *testing.T) {}

func TestLargeSin(t *testing.T) {}

func TestLargeSincos(t *testing.T) {}

func TestLargeTan(t *testing.T) {}

// Check that trigReduce matches the standard reduction results for input values
// below reduceThreshold.
func TestTrigReduce(t *testing.T) {}

type floatTest

var floatTests

func TestFloatMinMax(t *testing.T) {}

func TestFloatMinima(t *testing.T) {}

var indirectSqrt

// TestFloat32Sqrt checks the correctness of the float32 square root optimization result.
func TestFloat32Sqrt(t *testing.T) {}

var GlobalI

var GlobalB

var GlobalF

func BenchmarkAcos(b *testing.B) {}

func BenchmarkAcosh(b *testing.B) {}

func BenchmarkAsin(b *testing.B) {}

func BenchmarkAsinh(b *testing.B) {}

func BenchmarkAtan(b *testing.B) {}

func BenchmarkAtanh(b *testing.B) {}

func BenchmarkAtan2(b *testing.B) {}

func BenchmarkCbrt(b *testing.B) {}

func BenchmarkCeil(b *testing.B) {}

var copysignNeg

func BenchmarkCopysign(b *testing.B) {}

func BenchmarkCos(b *testing.B) {}

func BenchmarkCosh(b *testing.B) {}

func BenchmarkErf(b *testing.B) {}

func BenchmarkErfc(b *testing.B) {}

func BenchmarkErfinv(b *testing.B) {}

func BenchmarkErfcinv(b *testing.B) {}

func BenchmarkExp(b *testing.B) {}

func BenchmarkExpGo(b *testing.B) {}

func BenchmarkExpm1(b *testing.B) {}

func BenchmarkExp2(b *testing.B) {}

func BenchmarkExp2Go(b *testing.B) {}

var absPos

func BenchmarkAbs(b *testing.B) {}

func BenchmarkDim(b *testing.B) {}

func BenchmarkFloor(b *testing.B) {}

func BenchmarkMax(b *testing.B) {}

func BenchmarkMin(b *testing.B) {}

func BenchmarkMod(b *testing.B) {}

func BenchmarkFrexp(b *testing.B) {}

func BenchmarkGamma(b *testing.B) {}

func BenchmarkHypot(b *testing.B) {}

func BenchmarkHypotGo(b *testing.B) {}

func BenchmarkIlogb(b *testing.B) {}

func BenchmarkJ0(b *testing.B) {}

func BenchmarkJ1(b *testing.B) {}

func BenchmarkJn(b *testing.B) {}

func BenchmarkLdexp(b *testing.B) {}

func BenchmarkLgamma(b *testing.B) {}

func BenchmarkLog(b *testing.B) {}

func BenchmarkLogb(b *testing.B) {}

func BenchmarkLog1p(b *testing.B) {}

func BenchmarkLog10(b *testing.B) {}

func BenchmarkLog2(b *testing.B) {}

func BenchmarkModf(b *testing.B) {}

func BenchmarkNextafter32(b *testing.B) {}

func BenchmarkNextafter64(b *testing.B) {}

func BenchmarkPowInt(b *testing.B) {}

func BenchmarkPowFrac(b *testing.B) {}

var pow10pos

func BenchmarkPow10Pos(b *testing.B) {}

var pow10neg

func BenchmarkPow10Neg(b *testing.B) {}

var roundNeg

func BenchmarkRound(b *testing.B) {}

func BenchmarkRoundToEven(b *testing.B) {}

func BenchmarkRemainder(b *testing.B) {}

var signbitPos

func BenchmarkSignbit(b *testing.B) {}

func BenchmarkSin(b *testing.B) {}

func BenchmarkSincos(b *testing.B) {}

func BenchmarkSinh(b *testing.B) {}

func BenchmarkSqrtIndirect(b *testing.B) {}

func BenchmarkSqrtLatency(b *testing.B) {}

func BenchmarkSqrtIndirectLatency(b *testing.B) {}

func BenchmarkSqrtGoLatency(b *testing.B) {}

func isPrime(i int) bool {}

func BenchmarkSqrtPrime(b *testing.B) {}

func BenchmarkTan(b *testing.B) {}

func BenchmarkTanh(b *testing.B) {}

func BenchmarkTrunc(b *testing.B) {}

func BenchmarkY0(b *testing.B) {}

func BenchmarkY1(b *testing.B) {}

func BenchmarkYn(b *testing.B) {}

func BenchmarkFloat64bits(b *testing.B) {}

var roundUint64

func BenchmarkFloat64frombits(b *testing.B) {}

var roundFloat32

func BenchmarkFloat32bits(b *testing.B) {}

var roundUint32

func BenchmarkFloat32frombits(b *testing.B) {}

func BenchmarkFMA(b *testing.B) {}