Golang中math.NaN()未被正确处理的问题

在Golang中处理NaN值确实需要特别注意，特别是在统计计算和数据序列化场景中。以下是针对您提到的几个问题的解决方案：

1. 统计计算中的NaN处理

对于样本均值计算，建议在计算前过滤NaN值：

package main

import (
	"fmt"
	"math"
)

func MeanWithNaNHandling(data []float64) (float64, int) {
	var sum float64
	count := 0
	
	for _, v := range data {
		if !math.IsNaN(v) {
			sum += v
			count++
		}
	}
	
	if count == 0 {
		return math.NaN(), 0
	}
	return sum / float64(count), count
}

func main() {
	data := []float64{0.0, 1.0, math.NaN(), 2.0, math.NaN(), 3.0}
	mean, validCount := MeanWithNaNHandling(data)
	fmt.Printf("均值: %f, 有效数据点: %d\n", mean, validCount)
}

2. Gonum统计包中的NaN处理

Gonum提供了专门的函数处理NaN值：

package main

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

func main() {
	data := []float64{0.0, 1.0, math.NaN(), 2.0, math.NaN(), 3.0}
	
	// 方法1: 使用stat.Mean，但需要先过滤NaN
	var filtered []float64
	for _, v := range data {
		if !math.IsNaN(v) {
			filtered = append(filtered, v)
		}
	}
	
	mean := stat.Mean(filtered, nil)
	fmt.Printf("过滤后均值: %f\n", mean)
	
	// 方法2: 使用权重数组排除NaN
	weights := make([]float64, len(data))
	validCount := 0
	for i, v := range data {
		if !math.IsNaN(v) {
			weights[i] = 1.0
			validCount++
		}
	}
	
	meanWeighted := stat.Mean(data, weights)
	fmt.Printf("加权均值: %f, 有效数据点: %d\n", meanWeighted, validCount)
}

3. JSON序列化中的NaN处理

JSON标准不支持NaN，需要自定义序列化：

package main

import (
	"encoding/json"
	"fmt"
	"math"
)

type StatsData struct {
	Values []float64 `json:"values"`
	Mean   float64   `json:"mean"`
}

func (s StatsData) MarshalJSON() ([]byte, error) {
	// 处理NaN值为null
	type Alias StatsData
	aux := &struct {
		Values []*float64 `json:"values"`
		Mean   *float64   `json:"mean"`
		*Alias
	}{
		Alias: (*Alias)(&s),
	}
	
	// 处理Values数组中的NaN
	aux.Values = make([]*float64, len(s.Values))
	for i, v := range s.Values {
		if math.IsNaN(v) {
			aux.Values[i] = nil
		} else {
			val := v
			aux.Values[i] = &val
		}
	}
	
	// 处理Mean中的NaN
	if math.IsNaN(s.Mean) {
		aux.Mean = nil
	} else {
		mean := s.Mean
		aux.Mean = &mean
	}
	
	return json.Marshal(aux)
}

func main() {
	data := StatsData{
		Values: []float64{0.0, 1.0, math.NaN(), 2.0},
		Mean:   math.NaN(),
	}
	
	jsonData, _ := json.MarshalIndent(data, "", "  ")
	fmt.Println(string(jsonData))
}

4. 完整的空值处理方案

建议使用自定义类型统一处理空值：

package main

import (
	"encoding/json"
	"fmt"
	"math"
)

type OptionalFloat struct {
	Value float64
	Valid bool
}

func (f OptionalFloat) Float64() float64 {
	if !f.Valid {
		return math.NaN()
	}
	return f.Value
}

func (f *OptionalFloat) Set(value float64) {
	f.Value = value
	f.Valid = true
}

func (f *OptionalFloat) SetNaN() {
	f.Valid = false
}

func (f OptionalFloat) MarshalJSON() ([]byte, error) {
	if !f.Valid || math.IsNaN(f.Value) {
		return []byte("null"), nil
	}
	return json.Marshal(f.Value)
}

func (f *OptionalFloat) UnmarshalJSON(data []byte) error {
	if string(data) == "null" {
		f.Valid = false
		return nil
	}
	var val float64
	if err := json.Unmarshal(data, &val); err != nil {
		return err
	}
	f.Value = val
	f.Valid = true
	return nil
}

func MeanOptional(data []OptionalFloat) OptionalFloat {
	var sum float64
	count := 0
	
	for _, v := range data {
		if v.Valid && !math.IsNaN(v.Value) {
			sum += v.Value
			count++
		}
	}
	
	result := OptionalFloat{}
	if count > 0 {
		result.Set(sum / float64(count))
	} else {
		result.SetNaN()
	}
	return result
}

func main() {
	// 使用示例
	values := []OptionalFloat{
		{Value: 0.0, Valid: true},
		{Value: 1.0, Valid: true},
		{Valid: false}, // NaN/空值
		{Value: 2.0, Valid: true},
	}
	
	mean := MeanOptional(values)
	fmt.Printf("均值: %v (有效: %v)\n", mean.Float64(), mean.Valid)
	
	// JSON序列化
	stats := struct {
		Data []OptionalFloat `json:"data"`
		Mean OptionalFloat   `json:"mean"`
	}{
		Data: values,
		Mean: mean,
	}
	
	jsonData, _ := json.MarshalIndent(stats, "", "  ")
	fmt.Println(string(jsonData))
}

这些方法确保了在统计计算和序列化过程中正确处理NaN和空值，同时保持了数据的完整性和计算的准确性。