Function median

builtin/lib.go:445–524

(depth int, args ...any)

}

func median(depth int, args ...any) ([]float64, error) {
	if depth > MaxDepth {
		return nil, ErrorMaxDepth
	}
	var values []float64

	for _, arg := range args {
		// Fast paths for common typed slices - avoid reflection and allocations
		switch arr := arg.(type) {
		case []int:
			for _, v := range arr {
				values = append(values, float64(v))
			}
			continue
		case []float64:
			values = append(values, 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:
					values = append(values, float64(e))
				case float64:
					values = append(values, e)
				case []int, []float64, []any:
					// Nested array - recurse
					elems, err := median(depth+1, e)
					if err != nil {
						return nil, err
					}
					values = append(values, elems...)
				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:
						values = append(values, float64(rv.Int()))
					case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
						values = append(values, float64(rv.Uint()))
					case reflect.Float32, reflect.Float64:
						values = append(values, rv.Float())
					case reflect.Slice, reflect.Array:
						elems, err := median(depth+1, e)
						if err != nil {
							return nil, err
						}
						values = append(values, elems...)
					default:
						return nil, fmt.Errorf("invalid argument for median (type %T)", e)
					}
				}
			}
			continue
		}

		// Slow path: use reflection for other types
		rv := reflect.ValueOf(arg)