To calculate the arithmetic mean (average value) in Go, you should write your own function that takes a slice of numbers as an input, sum all values in the slice, and divides the sum by the number of elements.
package main
import "fmt"
func mean(data []float64) float64 {
if len(data) == 0 {
return 0
}
var sum float64
for _, d := range data {
sum += d
}
return sum / float64(len(data))
}
func main() {
fmt.Println(mean([]float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}))
}
This function requires that the input slice to be of a certain type, such as float64. In case you want to calculate the mean for a slice of, for example, int values, until recently you had to write a separate function that differed only in that it accepted an int slice as an argument. Another solution was to convert the slice to float64 before the calculation. However, the new version of Go 1.18, which introduced Generics, allows you to simplify this problem. All you need to do is write a generic mean() function that takes a slice of any numeric type.
package main
import (
"fmt"
"golang.org/x/exp/constraints"
)
type Number interface {
constraints.Float | constraints.Integer
}
func mean[T Number](data []T) float64 {
if len(data) == 0 {
return 0
}
var sum float64
for _, d := range data {
sum += float64(d)
}
return sum / float64(len(data))
}
func main() {
fmt.Println(mean([]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}))
fmt.Println(mean([]float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}))
}
If you are not already familiar with the basics of Generics in Go, check out our series of articles: Introduction to Go Generics by example.
Check also our example on how to calculate median in Go.
In the example above, we start with the custom constraint declaration. The Number interface is a type set being union of constraints.Float and constraints.Integer.
This is a new feature released along with Generics in Go 1.18 - now interfaces can have not only a set of methods but also a set of types. Just use the | operator to declare the set of types that our generic function should accept. In our case, we accept constraints.Float and constraints.Integer types, which are themselves type sets containing all floating and integer point types.
The rest of the new mean() function is the same as in the non-generic version. The only difference is that we use type T instead of float64 for the input data. The function result is still float64, because no matter if the input is a slice of integers or floating-point numbers, we can get a floating-point number as the result of the mean.
