proposal: math: MinOf and MaxOf for generic numeric limits

[rogpeppe]

Currently when writing a function involving a generic numeric type, there's no easy way to determine the maximum or minimum possible value of that type, because the math.Min* and math.Max* constants are all type-specific.

I propose that we add the following functions to the math package:

// MinOf returns the minimum possible value of type T.
func MinOf[T contraints.Integer | constraints.Float]() T

// MaxOf returns the maximum possible value of type T.
func MaxOf[T contraints.Integer | constraints.Float]() T

It's currently not possible to write the above functions without using reflection until #45380
is fixed, but here's an approximation:

https://gotipplay.golang.org/p/0i3Wc7i4dJs

[robpike]

To do this with any kind of efficiency in implementation code, generated code, and execution time seems unlikely. Plus you really want this to be a constant, which won't happen for a function.

So this feels like the wrong approach to me, but the right approach might require some kind of language support if we are to avoid type-asserting from interface{} on the way out.

[robpike]

P.S. That said, I'm not convinced it's worthwhile to do. I know what it's for but will it show up often enough to need so much mechanism?

[Inuart]

the right approach might require some kind of language support

IMHO it's essential that somebody writes a crazy idea that everybody can reject. So here I go:

const (
	MaxOf[T number] {
		int: math.MaxInt,
		int8: math.MaxInt8,
		...
	}
	MinOf[T number] {
		int: math.MinInt,
		int8: math.MinInt8,
		...
	}
	...
)

To be used like

func MaxSubSum[T number](arr []T) T {
	best := MinOf[T]
	var current T
	for _, v := range arr {
		current = Max(v, current+v)
		best = Max(best, current)
	}
	return best
}

[rogpeppe]

To do this with any kind of efficiency in implementation code, generated code, and execution time seems unlikely. Plus you really want this to be a constant, which won't happen for a function.

In general we don't allow constants to be derived from type parameters (that way lies madness), but I think it could be done with reasonable efficiency if #45380 was implemented.

In that case, the code might look like this:

func MinOf[T constraints.Integer | constraints.Float]() T {
	switch type T {
	case ~int:
		return math.MinInt
	case ~int8:
		return math.MinInt8
	...
	}
}

I have a feeling it wouldn't take too smart a compiler to implement it as a direct lookup from the dictionary, so not as efficient as a constant (we don't allow constants based on type parameters anyway), but one indirection still isn't too bad.

[renthraysk]

Did play around trying to get something similar, though just for constraints.Integer. With inlining they effectively a constant, though the inliner does assign them a higher inlining cost.

https://gotipplay.golang.org/p/Hw4hnZq3imw

Edit: Typo in code, should not have had the go vet warning.

[robpike]

In general we don't allow constants to be derived from type parameters (that way lies madness)

What I was getting at, incoherently, was that type parameters might not be the way to do this. The fact that a problem arises because of them does not necessarily mean the solution requires them too.

[g-talbot]

What's being asked for here is the Go equivalent of the C++ numeric_limits package. That doesn't seem unreasonable? If I'm implementing a generic function on [T constraints.Signed] I might want to return an error (etc.) instead of overflowing the type. Is the issue that the generated code for func X[T constraints.Signed](v T) T {...} is the same function when making the calls X(int64(1)), X(int32(1)), X(int16(1)), X(int8(1)), etc. because these will fall into the same GC shape?

[jdemeyer]

This works for signed and unsigned integers:

func MinOfInt[T constraints.Integer]() T {
    var zero T
    minusone := ^zero
    if minusone > 0 {
        return zero // Unsigned
    }
    bits := 8 * unsafe.Sizeof(zero)
    return minusone << (bits - 1) // Signed
}

func MaxOfInt[T constraints.Integer]() T {
    return ^MinOfInt[T]()
}