Introduction

In this article, we'll delve into how to calculate variance and standard deviation in Go. Variance and standard deviation are statistical measures that help us understand the spread or dispersion of a set of numbers. Variance gives an idea of how much the values in a dataset deviate from the mean, while the standard deviation provides a measure of dispersion expressed in the same unit as the original data.

Basic Example

Let's start by calculating the variance and standard deviation for a small array of numbers. Below is the basic implementation.


package main

import (
    "fmt"
    "math"
)

func variance(data []float64) float64 {
    mean := mean(data)
    var sum float64
    for _, value := range data {
        diff := value - mean
        sum += diff * diff
    }
    return sum / float64(len(data))
}

func mean(data []float64) float64 {
    total := 0.0
    for _, value := range data {
        total += value
    }
    return total / float64(len(data))
}

func standardDeviation(data []float64) float64 {
    return math.Sqrt(variance(data))
}

func main() {
    data := []float64{1, 2, 3, 4, 5}
    fmt.Printf("Variance: %.2f\n", variance(data))
    fmt.Printf("Standard Deviation: %.2f\n", standardDeviation(data))
}

Intermediate Example

Now let's add error handling and improve the function to handle potential edge cases, such as passing an empty slice.


package main

import (
    "errors"
    "fmt"
    "math"
)

func variance(data []float64) (float64, error) {
    if len(data) == 0 {
        return 0, errors.New("data slice is empty")
    }
    mean := mean(data)
    var sum float64
    for _, value := range data {
        diff := value - mean
        sum += diff * diff
    }
    return sum / float64(len(data)), nil
}

func mean(data []float64) float64 {
    total := 0.0
    for _, value := range data {
        total += value
    }
    return total / float64(len(data))
}

func standardDeviation(data []float64) (float64, error) {
    varValue, err := variance(data)
    if err != nil {
        return 0, err
    }
    return math.Sqrt(varValue), nil
}

func main() {
    data := []float64{1, 2, 3, 4, 5}
    varValue, err := variance(data)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Printf("Variance: %.2f\n", varValue)
    }
    stdDev, err := standardDeviation(data)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Printf("Standard Deviation: %.2f\n", stdDev)
    }
}

Advanced Example

For a more advanced scenario, let’s refactor our code with a struct-based approach that can handle dynamic data sets and provides utilities for people working with streams of data.


package main

import (
    "errors"
    "fmt"
    "math"
)

type Statistic struct {
    data []float64
}

func NewStatistic() *Statistic {
    return &Statistic{data: []float64{}}
}

func (s *Statistic) AddData(value float64) {
    s.data = append(s.data, value)
}

func (s *Statistic) Mean() (float64, error) {
    if len(s.data) == 0 {
        return 0, errors.New("no data available")
    }
    mean := s.sum() / float64(len(s.data))
    return mean, nil
}

func (s *Statistic) sum() float64 {
    total := 0.0
    for _, value := range s.data {
        total += value
    }
    return total
}

func (s *Statistic) Variance() (float64, error) {
    mean, err := s.Mean()
    if err != nil {
        return 0, err
    }
    var sumSquares float64
    for _, value := range s.data {
        diff := value - mean
        sumSquares += diff * diff
    }
    return sumSquares / float64(len(s.data)), nil
}

func (s *Statistic) StandardDeviation() (float64, error) {
    varValue, err := s.Variance()
    if err != nil {
        return 0, err
    }
    return math.Sqrt(varValue), nil
}

func main() {
    stats := NewStatistic()
    stats.AddData(1)
    stats.AddData(2)
    stats.AddData(3)
    stats.AddData(4)
    stats.AddData(5)

    variance, err := stats.Variance()
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Printf("Variance: %.2f\n", variance)
    }
    stdDev, err := stats.StandardDeviation()
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Printf("Standard Deviation: %.2f\n", stdDev)
    }
}

Conclusion

By using varying complexity levels of code, we managed to calculate variance and standard deviation in Go. We've created solutions that cater to simple, intermediate, and advanced needs, ensuring robust and flexible programming practices in Go development. Utilizing a struct-based approach can significantly improve code organization and allow statistics operations to cater to evolving data streams.