go/src/math/big/float_test.go

var _ …

func (x *Float) uint64() uint64 { … }

func (x *Float) int64() int64 { … }

func TestFloatZeroValue(t *testing.T) { … }

func makeFloat(s string) *Float { … }

func TestFloatSetPrec(t *testing.T) { … }

func TestFloatMinPrec(t *testing.T) { … }

func TestFloatSign(t *testing.T) { … }

// alike(x, y) is like x.Cmp(y) == 0 but also considers the sign of 0 (0 != -0).
func alike(x, y *Float) bool { … }

func alike32(x, y float32) bool { … }

func alike64(x, y float64) bool { … }

func TestFloatMantExp(t *testing.T) { … }

func TestFloatMantExpAliasing(t *testing.T) { … }

func TestFloatSetMantExp(t *testing.T) { … }

func TestFloatPredicates(t *testing.T) { … }

func TestFloatIsInt(t *testing.T) { … }

func fromBinary(s string) int64 { … }

func toBinary(x int64) string { … }

func testFloatRound(t *testing.T, x, r int64, prec uint, mode RoundingMode) { … }

// TestFloatRound tests basic rounding.
func TestFloatRound(t *testing.T) { … }

// TestFloatRound24 tests that rounding a float64 to 24 bits
// matches IEEE 754 rounding to nearest when converting a
// float64 to a float32 (excluding denormal numbers).
func TestFloatRound24(t *testing.T) { … }

func TestFloatSetUint64(t *testing.T) { … }

func TestFloatSetInt64(t *testing.T) { … }

func TestFloatSetFloat64(t *testing.T) { … }

func TestFloatSetInt(t *testing.T) { … }

func TestFloatSetRat(t *testing.T) { … }

func TestFloatSetInf(t *testing.T) { … }

func TestFloatUint64(t *testing.T) { … }

func TestFloatInt64(t *testing.T) { … }

func TestFloatFloat32(t *testing.T) { … }

func TestFloatFloat64(t *testing.T) { … }

func TestFloatInt(t *testing.T) { … }

func TestFloatRat(t *testing.T) { … }

func TestFloatAbs(t *testing.T) { … }

func TestFloatNeg(t *testing.T) { … }

func TestFloatInc(t *testing.T) { … }

var precList …

var bitsList …

// TestFloatAdd tests Float.Add/Sub by comparing the result of a "manual"
// addition/subtraction of arguments represented by Bits values with the
// respective Float addition/subtraction for a variety of precisions
// and rounding modes.
func TestFloatAdd(t *testing.T) { … }

// TestFloatAddRoundZero tests Float.Add/Sub rounding when the result is exactly zero.
// x + (-x) or x - x for non-zero x should be +0 in all cases except when
// the rounding mode is ToNegativeInf in which case it should be -0.
func TestFloatAddRoundZero(t *testing.T) { … }

// TestFloatAdd32 tests that Float.Add/Sub of numbers with
// 24bit mantissa behaves like float32 addition/subtraction
// (excluding denormal numbers).
func TestFloatAdd32(t *testing.T) { … }

// TestFloatAdd64 tests that Float.Add/Sub of numbers with
// 53bit mantissa behaves like float64 addition/subtraction.
func TestFloatAdd64(t *testing.T) { … }

func TestIssue20490(t *testing.T) { … }

// TestFloatMul tests Float.Mul/Quo by comparing the result of a "manual"
// multiplication/division of arguments represented by Bits values with the
// respective Float multiplication/division for a variety of precisions
// and rounding modes.
func TestFloatMul(t *testing.T) { … }

// TestFloatMul64 tests that Float.Mul/Quo of numbers with
// 53bit mantissa behaves like float64 multiplication/division.
func TestFloatMul64(t *testing.T) { … }

func TestIssue6866(t *testing.T) { … }

func TestFloatQuo(t *testing.T) { … }

var long …

// TestFloatQuoSmoke tests all divisions x/y for values x, y in the range [-n, +n];
// it serves as a smoke test for basic correctness of division.
func TestFloatQuoSmoke(t *testing.T) { … }

// TestFloatArithmeticSpecialValues tests that Float operations produce the
// correct results for combinations of zero (±0), finite (±1 and ±2.71828),
// and infinite (±Inf) operands.
func TestFloatArithmeticSpecialValues(t *testing.T) { … }

func TestFloatArithmeticOverflow(t *testing.T) { … }

// For rounding modes ToNegativeInf and ToPositiveInf, rounding is affected
// by the sign of the value to be rounded. Test that rounding happens after
// the sign of a result has been set.
// This test uses specific values that are known to fail if rounding is
// "factored" out before setting the result sign.
func TestFloatArithmeticRounding(t *testing.T) { … }

// TestFloatCmpSpecialValues tests that Cmp produces the correct results for
// combinations of zero (±0), finite (±1 and ±2.71828), and infinite (±Inf)
// operands.
func TestFloatCmpSpecialValues(t *testing.T) { … }

func BenchmarkFloatAdd(b *testing.B) { … }

func BenchmarkFloatSub(b *testing.B) { … }