13. Numbers and math

Go numbers come in two main kinds, do the usual arithmetic, and plug into standard library packages for more helpers. This chapter covers what you need for game logic: rounding, random numbers, basic maths, and moving between the two kinds.

Integers and floats

Go has two common number types:

• int. A whole number with no decimal part: 0, 7, -42.
• float64. A number with a decimal point: 3.14, 0.5, -1.0.

In Go you do have to care which is which. 7 is an int, 7.0 is a float64, and the two kinds do not mix in variables, as you will see below.

%T tells you which you have:

fmt.Printf("%T\n", 7)    // int
fmt.Printf("%T\n", 7.0)  // float64
fmt.Printf("%T\n", 3.14) // float64

Arithmetic

The familiar operators are all here:

Two are worth a closer look:

Division / depends on the type. Dividing two whole numbers gives a whole number, and everything after the decimal point is dropped: 7 / 2 is 3. It drops toward zero, so -7 / 2 is -3. With a decimal in the calculation, you get a decimal: 7.0 / 2 is 3.5.

Modulo % is the remainder after whole number division. 7 % 3 is 1 because 7 = 2 * 3 + 1. It is the standard way to ask "is this number even?" — n % 2 is 0 for evens and 1 for positive odds. It only works on whole numbers.

fmt.Println(7 / 2)   // 3
fmt.Println(7.0 / 2) // 3.5
fmt.Println(7 % 2)   // 1

The math package

Go's math package has the helpers you reach for most. Import it next to fmt:

import (
    "fmt"
    "math"
)

Call them like any other function:

fmt.Println(math.Floor(3.7)) // 3
fmt.Println(math.Ceil(3.2))  // 4
fmt.Println(math.Sqrt(16))   // 4
fmt.Println(min(7, 3))       // 3
fmt.Println(math.Pi)         // 3.141592653589793

These calls, and the rest of the table, are in exercises/13/02-math-package.go.

Showing decimals with %.2f

fmt.Println prints a float64 however it sees fit. For a fixed number of decimals, use the marker %.2f in fmt.Printf. The 2 is the number of decimals to show, and the value is rounded to fit:

price := 3.14159
fmt.Printf("Price: %.2f\n", price) // Price: 3.14

Use it for anything a person reads. fmt.Println(1000000.0) prints 1e+06, and 0.1 + 0.2, when held in variables, prints 0.30000000000000004, because computers store decimals only approximately. %.2f shows these as 1000000.00 and 0.30.

Random numbers

Random numbers live in the math/rand package. Import it next to fmt, and call it by the last part of its name, rand:

import (
    "fmt"
    "math/rand"
)

• rand.Float64() gives a float64 from 0.0 up to, but not including, 1.0.
• rand.Intn(n) gives a whole number from 0 to n-1. To get a six-sided die, add one: rand.Intn(6) + 1.

fmt.Println(rand.Float64())     // for example 0.6238...
fmt.Println(rand.Intn(6) + 1)   // for example 4
fmt.Println(rand.Intn(100) + 1) // for example 73

These lines are in exercises/13/03-random.go.

Mixing int and float64

Here Go is stricter than maths. Two variables of different number types cannot be combined.

# command-line-arguments
exercises\13\05-mixed-types.go:12:14: invalid operation: level * bonus (mismatched types int and float64)

A conversion makes a new value of the type you name. Write the type like a function:

level := 7
bonus := 1.5
fmt.Println(float64(level) * bonus) // 10.5

total := 7
count := 2
fmt.Println(total / count)                   // 3
fmt.Println(float64(total) / float64(count)) // 3.5

price := 3.99
fmt.Println(int(price)) // 3

Go makes you write this so that nothing changes type by accident. The last line shows why that matters: int(price) throws away the decimal part. It does not round, so 3.99 becomes 3. These lines are in exercises/13/04-conversions.go.

A number written directly in the code, such as 2 or 1.5, is more flexible than a variable. Go calls it a constant, and it takes whatever number type the calculation needs as long as its value fits. So bonus * 2 works although bonus is a float64 and 2 looks like an int. level * 1.5 does not work, because 1.5 cannot fit in an int:

1.5 (untyped float constant) truncated to int

Homework

Homework starters that need another package say so in their top comment. Remember that the Go extension for VS Code may add the import line for you when you save.

Die 1: 4
Die 2: 6
Total: 10

Stuck or finished? Open the homework solutions page.