func MinAbs32(a []float32) float32 {
	m := float32(math.MaxFloat32)
	for _, av := range a {
		if mat32.IsNaN(av) {
			continue
		}
		m = mat32.Min(m, mat32.Abs(av))
	}
	return m
}
/////////////////////////////////////////
MinAbs
MinAbs32 computes the max of absolute value 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))
}
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
}
func MaxIdx32(a []float32) (float32, int) {
	m := float32(-math.MaxFloat32)
	mi := -1
	for i, av := range a {
		if mat32.IsNaN(av) {
			continue
		}
		if av > m {
			m = av
			mi = i
		}
	}
	return m, mi
}
func Max64(a []float64) float64 {
	m := float64(-math.MaxFloat64)
	for _, av := range a {
		if math.IsNaN(av) {
			continue
		}
		m = math.Max(m, av)
	}
	return m
}
func MaxIdx64(a []float64) (float64, int) {
	m := float64(-math.MaxFloat64)
	mi := -1
	for i, av := range a {
		if math.IsNaN(av) {
			continue
		}
		if av > m {
			m = av
			mi = i
		}
	}
	return m, mi
}
func MaxAbs32(a []float32) float32 {
	m := float32(0)
	for _, av := range a {
		if mat32.IsNaN(av) {
			continue
		}
		m = mat32.Max(m, mat32.Abs(av))
	}
	return m
}
func MaxAbs64(a []float64) float64 {
	m := float64(0)
	for _, av := range a {
		if math.IsNaN(av) {
			continue
		}
		m = math.Max(m, math.Abs(av))
	}
	return m
}
func Min32(a []float32) float32 {
	m := float32(math.MaxFloat32)
	for _, av := range a {
		if mat32.IsNaN(av) {
			continue
		}
		m = mat32.Min(m, av)
	}
	return m
}
func MinIdx32(a []float32) (float32, int) {
	m := float32(math.MaxFloat32)
	mi := -1
	for i, av := range a {
		if mat32.IsNaN(av) {
			continue
		}
		if av < m {
			m = av
			mi = i
		}
	}
	return m, mi
}
func Min64(a []float64) float64 {
	m := float64(math.MaxFloat64)
	for _, av := range a {
		if math.IsNaN(av) {
			continue
		}
		m = math.Min(m, av)
	}
	return m
}
func MinIdx64(a []float64) (float64, int) {
	m := float64(math.MaxFloat64)
	mi := -1
	for i, av := range a {
		if math.IsNaN(av) {
			continue
		}
		if av < m {
			m = av
			mi = i
		}
	}
	return m, mi
}