tpl/math: Allow variadic math functions to take slice args, add math.Product, math.Sum

* Update math.Min and math.Max to allow 1 or more args, either scalar or slice, or combination of the two
* Add math.Sum (allow 1 or more args, either scalar or slice, or combination of the two)
* Add math.Product (allow 1 or more args, either scalar or slice, or combination of the two)

Fixes #11030

2 files changed, 141 insertions, 43 deletions

diff --git a/tpl/math/math.go b/tpl/math/math.go
index d73f212a6..a921bd7ad 100644
--- a/tpl/math/math.go
+++ b/tpl/math/math.go
@@ -16,7 +16,9 @@ package math
 
 import (
 	"errors"
+	"fmt"
 	"math"
+	"reflect"
 	"sync/atomic"
 
 	_math "github.com/gohugoio/hugo/common/math"
@@ -25,6 +27,7 @@ import (
 
 var (
 	errMustTwoNumbersError = errors.New("must provide at least two numbers")
+	errMustOneNumberError  = errors.New("must provide at least one number")
 )
 
 // New returns a new instance of the math-namespaced template functions.
@@ -85,48 +88,30 @@ func (ns *Namespace) Log(n any) (float64, error) {
 	return math.Log(af), nil
 }
 
-// Max returns the greater of the multivalued numbers n1 and n2 or more values.
+// Max returns the greater of all numbers in inputs. Any slices in inputs are flattened.
 func (ns *Namespace) Max(inputs ...any) (maximum float64, err error) {
-	if len(inputs) < 2 {
-		err = errMustTwoNumbersError
-		return
-	}
-	var value float64
-	for index, input := range inputs {
-		value, err = cast.ToFloat64E(input)
-		if err != nil {
-			err = errors.New("Max operator can't be used with non-float value")
-			return
-		}
-		if index == 0 {
-			maximum = value
-			continue
-		}
-		maximum = math.Max(value, maximum)
-	}
-	return
+	return ns.applyOpToScalarsOrSlices("Max", math.Max, inputs...)
 }
 
-// Min returns the smaller of multivalued numbers n1 and n2 or more values.
+// Min returns the smaller of all numbers in inputs. Any slices in inputs are flattened.
 func (ns *Namespace) Min(inputs ...any) (minimum float64, err error) {
-	if len(inputs) < 2 {
-		err = errMustTwoNumbersError
-		return
+	return ns.applyOpToScalarsOrSlices("Min", math.Min, inputs...)
+}
+
+// Sum returns the sum of all numbers in inputs. Any slices in inputs are flattened.
+func (ns *Namespace) Sum(inputs ...any) (sum float64, err error) {
+	fn := func(x, y float64) float64 {
+		return x + y
 	}
-	var value float64
-	for index, input := range inputs {
-		value, err = cast.ToFloat64E(input)
-		if err != nil {
-			err = errors.New("Max operator can't be used with non-float value")
-			return
-		}
-		if index == 0 {
-			minimum = value
-			continue
-		}
-		minimum = math.Min(value, minimum)
+	return ns.applyOpToScalarsOrSlices("Sum", fn, inputs...)
+}
+
+// Product returns the product of all numbers in inputs. Any slices in inputs are flattened.
+func (ns *Namespace) Product(inputs ...any) (product float64, err error) {
+	fn := func(x, y float64) float64 {
+		return x * y
 	}
-	return
+	return ns.applyOpToScalarsOrSlices("Product", fn, inputs...)
 }
 
 // Mod returns n1 % n2.
@@ -197,6 +182,58 @@ func (ns *Namespace) Sub(inputs ...any) (any, error) {
 	return ns.doArithmetic(inputs, '-')
 }
 
+func (ns *Namespace) applyOpToScalarsOrSlices(opName string, op func(x, y float64) float64, inputs ...any) (result float64, err error) {
+	var i int
+	var hasValue bool
+	for _, input := range inputs {
+		var values []float64
+		var isSlice bool
+		values, isSlice, err = ns.toFloatsE(input)
+		if err != nil {
+			err = fmt.Errorf("%s operator can't be used with non-float values", opName)
+			return
+		}
+		hasValue = hasValue || len(values) > 0 || isSlice
+		for _, value := range values {
+			i++
+			if i == 1 {
+				result = value
+				continue
+			}
+			result = op(result, value)
+		}
+	}
+
+	if !hasValue {
+		err = errMustOneNumberError
+		return
+	}
+	return
+
+}
+
+func (ns *Namespace) toFloatsE(v any) ([]float64, bool, error) {
+	vv := reflect.ValueOf(v)
+	switch vv.Kind() {
+	case reflect.Slice, reflect.Array:
+		var floats []float64
+		for i := 0; i < vv.Len(); i++ {
+			f, err := cast.ToFloat64E(vv.Index(i).Interface())
+			if err != nil {
+				return nil, true, err
+			}
+			floats = append(floats, f)
+		}
+		return floats, true, nil
+	default:
+		f, err := cast.ToFloat64E(v)
+		if err != nil {
+			return nil, false, err
+		}
+		return []float64{f}, false, nil
+	}
+}
+
 func (ns *Namespace) doArithmetic(inputs []any, operation rune) (value any, err error) {
 	if len(inputs) < 2 {
 		return nil, errMustTwoNumbersError
diff --git a/tpl/math/math_test.go b/tpl/math/math_test.go
index fad86938d..5b54b6ac8 100644
--- a/tpl/math/math_test.go
+++ b/tpl/math/math_test.go
@@ -415,15 +415,21 @@ func TestMax(t *testing.T) {
 		{[]any{0, 1}, 1.0},
 		{[]any{1, -1}, 1.0},
 		{[]any{1, 0}, 1.0},
+		{[]any{32}, 32.0},
 		{[]any{1, 1}, 1.0},
 		{[]any{1.2, 1.23}, 1.23},
 		{[]any{-1.2, -1.23}, -1.2},
 		{[]any{0, "a"}, false},
 		{[]any{"a", 0}, false},
 		{[]any{"a", "b"}, false},
-		// miss values
+		// Issue #11030
+		{[]any{7, []any{3, 4}}, 7.0},
+		{[]any{8, []any{3, 12}, 3}, 12.0},
+		{[]any{[]any{3, 5, 2}}, 5.0},
+		{[]any{3, []int{3, 6}, 3}, 6.0},
+		// No values.
 		{[]any{}, false},
-		{[]any{0}, false},
+
 		// multi values
 		{[]any{-1, -2, -3}, -1.0},
 		{[]any{1, 2, 3}, 3.0},
@@ -436,8 +442,9 @@ func TestMax(t *testing.T) {
 			continue
 		}
 
-		c.Assert(err, qt.IsNil)
-		c.Assert(result, qt.Equals, test.expect)
+		msg := qt.Commentf("values: %v", test.values)
+		c.Assert(err, qt.IsNil, msg)
+		c.Assert(result, qt.Equals, test.expect, msg)
 	}
 }
 
@@ -463,14 +470,21 @@ func TestMin(t *testing.T) {
 		{[]any{1, -1}, -1.0},
 		{[]any{1, 0}, 0.0},
 		{[]any{1, 1}, 1.0},
+		{[]any{2}, 2.0},
 		{[]any{1.2, 1.23}, 1.2},
 		{[]any{-1.2, -1.23}, -1.23},
 		{[]any{0, "a"}, false},
 		{[]any{"a", 0}, false},
 		{[]any{"a", "b"}, false},
-		// miss values
+		// Issue #11030
+		{[]any{1, []any{3, 4}}, 1.0},
+		{[]any{8, []any{3, 2}, 3}, 2.0},
+		{[]any{[]any{3, 2, 2}}, 2.0},
+		{[]any{8, []int{3, 2}, 3}, 2.0},
+
+		// No values.
 		{[]any{}, false},
-		{[]any{0}, false},
+
 		// multi values
 		{[]any{-1, -2, -3}, -3.0},
 		{[]any{1, 2, 3}, 1.0},
@@ -484,7 +498,54 @@ func TestMin(t *testing.T) {
 			continue
 		}
 
-		c.Assert(err, qt.IsNil)
+		c.Assert(err, qt.IsNil, qt.Commentf("values: %v", test.values))
 		c.Assert(result, qt.Equals, test.expect)
 	}
 }
+
+func TestSum(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	ns := New()
+
+	mustSum := func(values ...any) any {
+		result, err := ns.Sum(values...)
+		c.Assert(err, qt.IsNil)
+		return result
+	}
+
+	c.Assert(mustSum(1, 2, 3), qt.Equals, 6.0)
+	c.Assert(mustSum(1, 2, 3.0), qt.Equals, 6.0)
+	c.Assert(mustSum(1, 2, []any{3, 4}), qt.Equals, 10.0)
+	c.Assert(mustSum(23), qt.Equals, 23.0)
+	c.Assert(mustSum([]any{23}), qt.Equals, 23.0)
+	c.Assert(mustSum([]any{}), qt.Equals, 0.0)
+
+	_, err := ns.Sum()
+	c.Assert(err, qt.Not(qt.IsNil))
+
+}
+
+func TestProduct(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	ns := New()
+
+	mustProduct := func(values ...any) any {
+		result, err := ns.Product(values...)
+		c.Assert(err, qt.IsNil)
+		return result
+	}
+
+	c.Assert(mustProduct(2, 2, 3), qt.Equals, 12.0)
+	c.Assert(mustProduct(1, 2, 3.0), qt.Equals, 6.0)
+	c.Assert(mustProduct(1, 2, []any{3, 4}), qt.Equals, 24.0)
+	c.Assert(mustProduct(3.0), qt.Equals, 3.0)
+	c.Assert(mustProduct([]string{}), qt.Equals, 0.0)
+
+	_, err := ns.Product()
+	c.Assert(err, qt.Not(qt.IsNil))
+
+}