Function mean

builtin/lib.go:348–443

(depth int, args ...any)

}

func mean(depth int, args ...any) (int, float64, error) {
	if depth > MaxDepth {
		return 0, 0, ErrorMaxDepth
	}
	var total float64
	var count int

	for _, arg := range args {
		// Fast paths for common typed slices - avoid reflection and allocations
		switch arr := arg.(type) {
		case []int:
			for _, v := range arr {
				total += float64(v)
			}
			count += len(arr)
			continue
		case []float64:
			for _, v := range arr {
				total += v
			}
			count += len(arr)
			continue
		case []any:
			// Fast path for []any - single pass without recursive calls for flat arrays
			for _, elem := range arr {
				switch e := elem.(type) {
				case int:
					total += float64(e)
					count++
				case float64:
					total += e
					count++
				case []int, []float64, []any:
					// Nested array - recurse
					nestedCount, nestedSum, err := mean(depth+1, e)
					if err != nil {
						return 0, 0, err
					}
					total += nestedSum
					count += nestedCount
				default:
					// Other numeric types or slices - use reflection
					rv := reflect.ValueOf(e)
					switch rv.Kind() {
					case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
						total += float64(rv.Int())
						count++
					case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
						total += float64(rv.Uint())
						count++
					case reflect.Float32, reflect.Float64:
						total += rv.Float()
						count++
					case reflect.Slice, reflect.Array:
						nestedCount, nestedSum, err := mean(depth+1, e)
						if err != nil {
							return 0, 0, err
						}