-func Sum(a *[3]float) (sum float) {
+func Sum(a *[3]float64) (sum float64) {
for _, v := range *a {
sum += v
}
return
}
-array := [...]float{7.0, 8.5, 9.1}
+array := [...]float64{7.0, 8.5, 9.1}
x := Sum(&array) // Note the explicit address-of operator
@@ -1233,7 +1233,8 @@ Maps are a convenient and powerful built-in data structure to associate
values of different types.
The key can be of any type for which the equality operator is defined,
such as integers,
-floats, strings, pointers, and interfaces (as long as the dynamic type
+floating point and complex numbers,
+strings, pointers, and interfaces (as long as the dynamic type
supports equality). Structs, arrays and slices cannot be used as map keys,
because equality is not defined on those types.
Like slices, maps are a reference type. If you pass a map to a function
@@ -1806,7 +1807,7 @@ Because the two types (Sequence and []int)
are the same if we ignore the type name, it's legal to convert between them.
The conversion doesn't create a new value, it just temporarily acts
as though the existing value has a new type.
-(There are other legal conversions, such as from integer to float, that
+(There are other legal conversions, such as from integer to floating point, that
do create a new value.)
diff --git a/doc/gccgo_install.html b/doc/gccgo_install.html index 393e57963b..2ab6dcdae9 100644 --- a/doc/gccgo_install.html +++ b/doc/gccgo_install.html @@ -296,8 +296,8 @@ than one value, the C function returns a struct. For example, these functions have equivalent types:
-func GoFunction(int) (int, float)
-struct { int i; float f; } CFunction(int)
+func GoFunction(int) (int, float64)
+struct { int i; float64 f; } CFunction(int)
diff --git a/doc/go_faq.html b/doc/go_faq.html
index 1c7b85ef89..f923a6ae29 100644
--- a/doc/go_faq.html
+++ b/doc/go_faq.html
@@ -665,11 +665,16 @@ of Effective Go for more details.
Why is int 32 bits on 64 bit machines?
-The size of int and float is implementation-specific.
+The sizes of int and uint are implementation-specific
+but the same as each other on a given platform.
The 64 bit Go compilers (both 6g and gccgo) use a 32 bit representation for
-both int and float. Code that relies on a particular
-size of value should use an explicitly sized type, like int64 or
-float64.
+int. Code that relies on a particular
+size of value should use an explicitly sized type, like int64.
+On the other hand, floating-point scalars and complex
+numbers are always sized: float32, complex64,
+etc., because programmers should be aware of precision when using
+floating-point numbers.
+The default size of a floating-point constant is float64.
var (
i int
- m float
+ m float64
)
diff --git a/doc/go_tutorial.html b/doc/go_tutorial.html
index e3d966b874..ece22036ae 100644
--- a/doc/go_tutorial.html
+++ b/doc/go_tutorial.html
@@ -238,14 +238,19 @@ started; for instance, os.Args is a slice used by the
-Go has some familiar types such as int and float, which represent
+Go has some familiar types such as int and uint (unsigned int), which represent
values of the ''appropriate'' size for the machine. It also defines
explicitly-sized types such as int8, float64, and so on, plus
-unsigned integer types such as uint, uint32, etc. These are
-distinct types; even if int and int32 are both 32 bits in size,
+unsigned integer types such as uint, uint32, etc.
+These are distinct types; even if int and int32 are both 32 bits in size,
they are not the same type. There is also a byte synonym for
uint8, which is the element type for strings.
+Floating-point types are always sized: float32 and float64,
+plus complex64 (two float32s) and complex128
+(two float64s). Complex numbers are outside the
+scope of this tutorial.
+
Speaking of string, that's a built-in type as well. Strings are
immutable values—they are not just arrays of byte values.
Once you've built a string value, you can't change it, although
@@ -452,14 +457,15 @@ language specification but here are some illustrative examples:
a := uint64(0) // equivalent; uses a "conversion"
i := 0x1234 // i gets default type: int
var j int = 1e6 // legal - 1000000 is representable in an int
- x := 1.5 // a float
+ x := 1.5 // a float64, the default type for floating constants
i3div2 := 3/2 // integer division - result is 1
- f3div2 := 3./2. // floating point division - result is 1.5
+ f3div2 := 3./2. // floating-point division - result is 1.5
Conversions only work for simple cases such as converting ints of one
-sign or size to another, and between ints and floats, plus a few other
-simple cases. There are no automatic numeric conversions of any kind in Go,
+sign or size to another and between integers and floating-point numbers,
+plus a couple of other instances outside the scope of a tutorial.
+There are no automatic numeric conversions of any kind in Go,
other than that of making constants have concrete size and type when
assigned to a variable.
diff --git a/doc/go_tutorial.txt b/doc/go_tutorial.txt index bf07330a87..5eea3c980b 100644 --- a/doc/go_tutorial.txt +++ b/doc/go_tutorial.txt @@ -189,14 +189,19 @@ started; for instance, "os.Args" is a slice used by the An Interlude about Types ---- -Go has some familiar types such as "int" and "float", which represent +Go has some familiar types such as "int" and "uint" (unsigned "int"), which represent values of the ''appropriate'' size for the machine. It also defines explicitly-sized types such as "int8", "float64", and so on, plus -unsigned integer types such as "uint", "uint32", etc. These are -distinct types; even if "int" and "int32" are both 32 bits in size, +unsigned integer types such as "uint", "uint32", etc. +These are distinct types; even if "int" and "int32" are both 32 bits in size, they are not the same type. There is also a "byte" synonym for "uint8", which is the element type for strings. +Floating-point types are always sized: "float32" and "float64", +plus "complex64" (two "float32s") and "complex128" +(two "float64s"). Complex numbers are outside the +scope of this tutorial. + Speaking of "string", that's a built-in type as well. Strings are immutable values—they are not just arrays of "byte" values. Once you've built a string value, you can't change it, although @@ -362,13 +367,14 @@ language specification but here are some illustrative examples: a := uint64(0) // equivalent; uses a "conversion" i := 0x1234 // i gets default type: int var j int = 1e6 // legal - 1000000 is representable in an int - x := 1.5 // a float + x := 1.5 // a float64, the default type for floating constants i3div2 := 3/2 // integer division - result is 1 - f3div2 := 3./2. // floating point division - result is 1.5 + f3div2 := 3./2. // floating-point division - result is 1.5 Conversions only work for simple cases such as converting "ints" of one -sign or size to another, and between "ints" and "floats", plus a few other -simple cases. There are no automatic numeric conversions of any kind in Go, +sign or size to another and between integers and floating-point numbers, +plus a couple of other instances outside the scope of a tutorial. +There are no automatic numeric conversions of any kind in Go, other than that of making constants have concrete size and type when assigned to a variable. diff --git a/doc/install.html b/doc/install.html index 92b099fe8d..5917da964a 100644 --- a/doc/install.html +++ b/doc/install.html @@ -45,11 +45,10 @@ architectures.