1 files changed, 35 insertions, 35 deletions

diff --git a/src/pkg/math/bits.go b/src/pkg/math/bits.go
index 5372c6806..65eabfd60 100644
--- a/src/pkg/math/bits.go
+++ b/src/pkg/math/bits.go
@@ -5,32 +5,32 @@
 package math
 
 const (
-	uvnan		= 0x7FF0000000000001;
-	uvinf		= 0x7FF0000000000000;
-	uvneginf	= 0xFFF0000000000000;
-	mask		= 0x7FF;
-	shift		= 64 - 11 - 1;
-	bias		= 1022;
+	uvnan    = 0x7FF0000000000001
+	uvinf    = 0x7FF0000000000000
+	uvneginf = 0xFFF0000000000000
+	mask     = 0x7FF
+	shift    = 64 - 11 - 1
+	bias     = 1022
 )
 
 // Inf returns positive infinity if sign >= 0, negative infinity if sign < 0.
 func Inf(sign int) float64 {
-	var v uint64;
+	var v uint64
 	if sign >= 0 {
 		v = uvinf
 	} else {
 		v = uvneginf
 	}
-	return Float64frombits(v);
+	return Float64frombits(v)
 }
 
 // NaN returns an IEEE 754 ``not-a-number'' value.
-func NaN() float64	{ return Float64frombits(uvnan) }
+func NaN() float64 { return Float64frombits(uvnan) }
 
 // IsNaN returns whether f is an IEEE 754 ``not-a-number'' value.
 func IsNaN(f float64) (is bool) {
-	x := Float64bits(f);
-	return uint32(x>>shift)&mask == mask && x != uvinf && x != uvneginf;
+	x := Float64bits(f)
+	return uint32(x>>shift)&mask == mask && x != uvinf && x != uvneginf
 }
 
 // IsInf returns whether f is an infinity, according to sign.
@@ -38,8 +38,8 @@ func IsNaN(f float64) (is bool) {
 // If sign < 0, IsInf returns whether f is negative infinity.
 // If sign == 0, IsInf returns whether f is either infinity.
 func IsInf(f float64, sign int) bool {
-	x := Float64bits(f);
-	return sign >= 0 && x == uvinf || sign <= 0 && x == uvneginf;
+	x := Float64bits(f)
+	return sign >= 0 && x == uvinf || sign <= 0 && x == uvneginf
 }
 
 // Frexp breaks f into a normalized fraction
@@ -50,31 +50,31 @@ func Frexp(f float64) (frac float64, exp int) {
 	if f == 0 {
 		return
 	}
-	x := Float64bits(f);
-	exp = int((x>>shift)&mask) - bias;
-	x &^= mask << shift;
-	x |= bias << shift;
-	frac = Float64frombits(x);
-	return;
+	x := Float64bits(f)
+	exp = int((x>>shift)&mask) - bias
+	x &^= mask << shift
+	x |= bias << shift
+	frac = Float64frombits(x)
+	return
 }
 
 // Ldexp is the inverse of Frexp.
 // It returns frac × 2<sup>exp</sup>.
 func Ldexp(frac float64, exp int) float64 {
-	x := Float64bits(frac);
-	exp += int(x>>shift) & mask;
+	x := Float64bits(frac)
+	exp += int(x>>shift) & mask
 	if exp <= 0 {
-		return 0	// underflow
+		return 0 // underflow
 	}
-	if exp >= mask {	// overflow
+	if exp >= mask { // overflow
 		if frac < 0 {
 			return Inf(-1)
 		}
-		return Inf(1);
+		return Inf(1)
 	}
-	x &^= mask << shift;
-	x |= uint64(exp) << shift;
-	return Float64frombits(x);
+	x &^= mask << shift
+	x |= uint64(exp) << shift
+	return Float64frombits(x)
 }
 
 // Modf returns integer and fractional floating-point numbers
@@ -83,20 +83,20 @@ func Ldexp(frac float64, exp int) float64 {
 func Modf(f float64) (int float64, frac float64) {
 	if f < 1 {
 		if f < 0 {
-			int, frac = Modf(-f);
-			return -int, -frac;
+			int, frac = Modf(-f)
+			return -int, -frac
 		}
-		return 0, f;
+		return 0, f
 	}
 
-	x := Float64bits(f);
-	e := uint(x>>shift)&mask - bias;
+	x := Float64bits(f)
+	e := uint(x>>shift)&mask - bias
 
 	// Keep the top 11+e bits, the integer part; clear the rest.
 	if e < 64-11 {
 		x &^= 1<<(64-11-e) - 1
 	}
-	int = Float64frombits(x);
-	frac = f - int;
-	return;
+	int = Float64frombits(x)
+	frac = f - int
+	return
 }