Golang实现基础计算与统计工具

math

package main

import (
    "fmt"
    "math"
    "sort"
)

// 求和
func Sum(data []float64) float64 {
    sum := 0.0
    for _, v := range data {
        sum += v
    }
    return sum
}

// 平均值
func Mean(data []float64) float64 {
    if len(data) == 0 {
        return 0
    }
    return Sum(data) / float64(len(data))
}

// 标准差
func StandardDeviation(data []float64) float64 {
    mean := Mean(data)
    sumOfSquares := 0.0
    for _, v := range data {
        sumOfSquares += math.Pow(v-mean, 2)
    }
    return math.Sqrt(sumOfSquares / float64(len(data)-1)) // 使用样本标准差
}

// 方差
func Variance(data []float64) float64 {
    mean := Mean(data)
    sumOfSquares := 0.0
    for _, v := range data {
        sumOfSquares += math.Pow(v-mean, 2)
    }
    return sumOfSquares / float64(len(data)-1)
}

// 中位数
func Median(data []float64) float64 {
    if len(data) == 0 {
        return 0
    }
    sort.Float64s(data)
    middle := len(data) / 2
    if len(data)%2 == 0 {
        return (data[middle-1] + data[middle]) / 2
    }
    return data[middle]
}

// 最大值
func Max(data []float64) float64 {
    if len(data) == 0 {
        return 0
    }
    max := data[0]
    for _, v := range data {
        if v > max {
            max = v
        }
    }
    return max
}

// 最小值
func Min(data []float64) float64 {
    if len(data) == 0 {
        return 0
    }
    min := data[0]
    for _, v := range data {
        if v < min {
            min = v
        }
    }
    return min
}

func main() {
    data := []float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    fmt.Println("Sum:", Sum(data))
    fmt.Println("Mean:", Mean(data))
    fmt.Println("Standard Deviation:", StandardDeviation(data))
    fmt.Println("Variance:", Variance(data))
    fmt.Println("Median:", Median(data))
    fmt.Println("Max:", Max(data))
    fmt.Println("Min:", Min(data))
}

// 并发求和
func ConcurrentSum(data []float64, numRoutines int) float64 {
    if numRoutines <= 0 {
        numRoutines = 1
    }

    chunkSize := len(data) / numRoutines
    if chunkSize == 0 {
        numRoutines = len(data) // 每个元素一个goroutine
        chunkSize = 1
    }

    results := make(chan float64, numRoutines)
    var wg sync.WaitGroup

    for i := 0; i < numRoutines; i++ {
        wg.Add(1)
        start := i * chunkSize
        end := start + chunkSize
        if i == numRoutines-1 {
            end = len(data) // 最后一个goroutine处理剩余的数据
        }
        go func(chunk []float64) {
            defer wg.Done()
            results <- Sum(chunk)
        }(data[start:end])
    }

    wg.Wait()
    close(results)

    totalSum := 0.0
    for sum := range results {
        totalSum += sum
    }
    return totalSum
}

// 移除NaN值
func RemoveNaN(data []float64) []float64 {
    result := make([]float64, 0, len(data))
    for _, v := range data {
        if !math.IsNaN(v) {
            result = append(result, v)
        }
    }
    return result
}

// 移除超过n个标准差的数据
func RemoveOutliers(data []float64, n float64) []float64 {
    mean := Mean(data)
    std := StandardDeviation(data)
    result := make([]float64, 0, len(data))
    for _, v := range data {
        if math.Abs(v-mean) <= n*std {
            result = append(result, v)
        }
    }
    return result
}

gonum/stat

gonum/stat

import (
    "fmt"
    "gonum.org/v1/gonum/stat"
)

func LinearRegression(x, y []float64) (float64, float64, error) {
    a, b := stat.LinearRegression(x, y, nil)
    return a, b, nil // a是截距，b是斜率
}

func main() {
    x := []float64{1, 2, 3, 4, 5}
    y := []float64{2, 4, 5, 4, 5}

    a, b, err := LinearRegression(x, y)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Printf("Linear Regression: y = %.2fx + %.2f\n", b, a)
}