The Go Programming Language Specification

Integer literals

An integer literal is a sequence of digits representing an integer constant.

Floating-point literals

A floating-point literal is a decimal representation of a floating-point constant. It has an integer part, a decimal point, a fractional part, and an exponent part. The integer and fractional part comprise decimal digits; the exponent part is an e or E followed by an optionally signed decimal exponent. One of the integer part or the fractional part may be elided; one of the decimal point or the exponent may be elided.

Arithmetic operators

For two integer values x and y, the integer quotient q = x / y and remainder r = x % y satisfy the following relationships:

x = q*y + r  and  |r| < |y|

with x / y truncated towards zero.

You wrote, using integer literals and arithmetic (x / y truncates towards zero):

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var num float64
    num = 5 / 3 // float64(int(5)/int(3))
    fmt.Printf("%v\n", num)
    numString := strconv.FormatFloat(num, 'f', -1, 64)
    fmt.Println(numString)
}

Playground: https://play.golang.org/p/PBqSbpHvuSL

Output:

1
1

You should write, using floating-point literals and arithmetic:

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var num float64
    num = 5.0 / 3.0 // float64(float64(5.0) / float64 (3.0))
    fmt.Printf("%v\n", num)
    numString := strconv.FormatFloat(num, 'f', -1, 64)
    fmt.Println(numString)
}

Playground: https://play.golang.org/p/Hp1nac358HK

Output:

1.6666666666666667
1.6666666666666667

Copypackage main
import "fmt"
func main() {
  var x float64 = 5.7
  var y int = int(x)
  fmt.Println(y)  // outputs "5"
}

Using math.Float32bits and math.Float64bits, you can see how Go represents the different decimal values as a IEEE 754 binary value:

Playground: https://play.golang.org/p/ZqzdCZLfvC

Result:

float32(0.1): 00111101110011001100110011001101
float32(0.2): 00111110010011001100110011001101
float32(0.3): 00111110100110011001100110011010
float64(0.1): 0011111110111001100110011001100110011001100110011001100110011010
float64(0.2): 0011111111001001100110011001100110011001100110011001100110011010
float64(0.3): 0011111111010011001100110011001100110011001100110011001100110011

If you convert these binary representation to decimal values and do your loop, you can see that for float32, the initial value of a will be:

0.20000000298023224
+ 0.10000000149011612
- 0.30000001192092896
= -7.4505806e-9

a negative value that can never never sum up to 1.

So, why does C behave different?

If you look at the binary pattern (and know slightly about how to represent binary values), you can see that Go rounds the last bit while I assume C just crops it instead.

So, in a sense, while neither Go nor C can represent 0.1 exactly in a float, Go uses the value closest to 0.1:

Go:   00111101110011001100110011001101 => 0.10000000149011612
C(?): 00111101110011001100110011001100 => 0.09999999403953552

Edit:

I posted a question about how C handles float constants, and from the answer it seems that any implementation of the C standard is allowed to do either. The implementation you tried it with just did it differently than Go.

From the documentation, it converts the float64 into an uint64 without changing the bits, it's the way the bits are interpreted that change.

Here is the full source code of the Float64bits function:

func Float64bits(f float64) uint64 { return *(*uint64)(unsafe.Pointer(&f)) }

Don't be scared by that syntax trick of using an unsafe Pointer, it's quite common in Go's source code (avoids copying the data). So, that really is that simple: take the binary data of the given float and interpret it as an unsigned integer.

The reason it changes so much is because of the representation of floating point numbers. According to the specification, a floating point number is composed of a Sign, an Exponent and a Mantissa.

On a 64 bits float, there is 1 bit for the Sign, 11 bits for the exponent and 52 bits for the mantissa.

The representation of 4 as a floating point number on 64 bits is:

0b0100 0000 0001 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
  SEEE EEEE EEEE MMMM MMMM MMMM MMMM MMMM MMMM MMMM MMMM MMMM MMMM MMMM MMMM MMMM

It turns out that this value is 4616189618054758400 if interpreted as an unsigned integer. You'll find plenty of great tutorials on the web regarding the IEEE754 to understand fully how the above value is a representation of 4.