func Max32(a []float32) float32 {
	m := float32(-math.MaxFloat32)
	for _, av := range a {
		if mat32.IsNaN(av) {
			continue
		}
		m = mat32.Max(m, av)
	}
	return m
}
/////////////////////////////////////////
Max
Max32 computes the max over vector values.
Skips NaN's
package norm
import (
	"math"
	"github.com/goki/mat32"
)
func N32(a []float32) float32 {
	n := 0
	for _, av := range a {
		if mat32.IsNaN(av) {
			continue
		}
		n++
	}
	return float32(n)
}
func N64(a []float64) float64 {
	n := 0
	for _, av := range a {
		if math.IsNaN(av) {
			continue
		}
		n++
	}
	return float64(n)
}
func Sum32(a []float32) float32 {
	s := float32(0)
	for _, av := range a {
		if mat32.IsNaN(av) {
			continue
		}
		s += av
	}
	return s
}
func Sum64(a []float64) float64 {
	s := float64(0)
	for _, av := range a {
		if math.IsNaN(av) {
			continue
		}
		s += av
	}
	return s
}
func Mean32(a []float32) float32 {
	s := float32(0)
	n := 0
	for _, av := range a {
		if mat32.IsNaN(av) {
			continue
		}
		s += av
		n++
	}
	if n > 0 {
		s /= float32(n)
	}
	return s
}
func Mean64(a []float64) float64 {
	s := float64(0)
	n := 0
	for _, av := range a {
		if math.IsNaN(av) {
			continue
		}
		s += av
		n++
	}
	if n > 0 {
		s /= float64(n)
	}
	return s
}
func Var32(a []float32) float32 {
	mean := Mean32(a)
	n := 0
	s := float32(0)
	for _, av := range a {
		if mat32.IsNaN(av) {
			continue
		}
		dv := av - mean
		s += dv * dv
		n++
	}
	if n > 1 {
		s /= float32(n - 1)
	}
	return s
}
func Var64(a []float64) float64 {
	mean := Mean64(a)
	n := 0
	s := float64(0)
	for _, av := range a {
		if math.IsNaN(av) {
			continue
		}
		dv := av - mean
		s += dv * dv
		n++
	}
	if n > 1 {
		s /= float64(n - 1)
	}
	return s
}
func Std32(a []float32) float32 {
	return mat32.Sqrt(Var32(a))
}
func Std64(a []float64) float64 {
	return math.Sqrt(Var64(a))
}