Why aren't C#'s Math.Min/Max variadic?

Question

I need to find the minimum between 3 values, and I ended up doing something like this:

Math.Min(Math.Min(val1, val2), val3)

It just seems a little silly to me, because other languages use variadic functions for this. I highly doubt this was an oversight though.

Is there any reason why a simple Min/Max function shoundn't be variadic? Are there performance implications? Is there a variadic version that I didn't notice?

Answer 1

If it is a collection (A subclass of IEnumerable<T>) one could easily use the functions in the System.Linq library

int min = new int[] {2,3,4,8}.Min();

furthermore it's easy to implement these methods on your own:

public static class Maths {

    public static T Min<T> (params T[] vals) {
        return vals.Min();
    }
    public static T Max<T> (params T[] vals) {
        return vals.Max();
    }

}

You can call this methods with just simple scalars so Maths.Min(14,25,13,2) would give 2.

These are the generic methods, so there is no need to implement this method for each type of numbers (int,float,...)

I think the basic reason why these methods are not implemented in general is that every time you call this method an array (or at least an IList object should be created. By keeping low level methods one can avoid the overhead. However I agree one could add these methods to the Math class to make the life of some programmers more easy.

Answer 2

CommuSoft has addressed how to accomplish the equivalent in C#, so I won't retread that part.

To specifically address your question "Why aren't C#'s Math.Min/Max variadic?", two thoughts come to mind.

First, Math.Min (and Math.Max) is not, in fact, a C# language feature, it is a .NET framework library feature. That may seem pedantic, but it is an important distinction. C# does not, in fact, provide any special purpose language feature for determining the minimum or maximum value between two (or more) potential values.

Secondly, as Eric Lippert has pointed out a number of times, language features ( and presumably framework features) are not "removed" or actively excluded - all features are unimplemented until someone designs, implements, tests, documents and ships the feature. See here for an example.

Not being a .NET framework developer, I cannot speak to the actual decision process that occurred, but it seems like this is a classic case of a feature that simply never rose to the level of inclusion, similar to the sequence foreach "feature" Eric discusses in the provided link.

Answer 3

I think CommuSoft is providing a robust answer that is at least suited for people searching for something along these lines, and that should be accepted.

With that said, the reason is definitely to avoid the overhead necessary for the less likely use case that people want to compare a group rather than two values.

As pointed about by @arx, using a parametric would be unnecessary overhead for the most used case, but it would also be a lot of unnecessary overhead with regards to the loop that would have to be used internally to go through the array n - 1 times.

I can easily see an argument for having created the method in addition to the basic form, but with LINQ that's just no longer necessary.