Is it inadvisable to make a function that essentially renames a built-in function?

Question

I get confused over min and max functions, in certain contexts.

In one context, when you're using the functions to take the greater or lesser of two values, there is no issue. For example,

//how many autographed CD's can I give out?
int howManyAutographs(int CDs, int Cases, int Pens)
{
    //if no pens, then I cannot sign any autographs
    if (Pens == 0)
        return 0;

    //I cannot give away a CD without a case or a case without a CD
    return min(CDs, Cases);
}

Easy. But in another context, I get confused. If I'm trying to set a maximum or minimum, I get it backwards.

//return the sum, with a maximum of 255
int cappedSumWRONG(int x, int y)
{
    return max(x + y, 255); //nope, this is wrong
}

//return the sum, with a maximum of 255
int cappedSumCORRECT(int x, int y)
{
    return min(x + y, 255); //much better, but counter-intuitive to my mind
}

Is it inadvisable to make my own functions as follows?

//return x, with a maximum of max
int maximize(int x, int max)
{
    return min(x, max);
}

//return x, with a minimum of min
int minimize(int x, int min)
{
    return max(x, min)
}

Obviously, using the builtins will be faster but this seems like a needless microoptimization to me. Is there any other reason this would be inadvisable? What about in a group project?

Answer 1

As others have already mentioned: don't create a function with a name that is similar to that of a builtin, standard-library or generally widely used function but change its behavior. It is possible to get used to a naming convention even if it doesn't make much sense to you at first sight but it will be impossible to reason about the functioning of your code once you introduce those other functions that do the same thing but have their names swapped.

Instead of “overloading” the names used by the standard library, use new names that convey precisely what you mean. In your case, you're not really interested in a “minimum”. Rather, you want to cap a value. Mathematically, this is the same operation but semantically, it is not quite. So why not just a function

int cap(int value, int limit) { return (value > limit) ? limit : value; }

that does what is needed and tells so from its name. (You could also implement capin terms of min as shown in timster's answer).

Another frequently used function name is clamp. It takes three arguments and “clamps” a provided value into the interval defined by the other two values.

int clamp(int value, int lower, int upper) {
    assert(lower <= upper);  // precondition check
    if (value < lower) return lower;
    else if (value > upper) return upper;
    else return value;
}

If you're using such a generally known function name, any new person joining your team (including the future you coming back to the code after a while) will quickly understand what is going on instead of cursing you for having confused them by breaking their expectations about function names they thought they knew.

Answer 2

If you make a function like that where minimize(4, 10) returns 10, then I'd say that is inadvisable because your fellow programmers may strangle you.

(Okay, maybe they will not literally strangle you to death, but seriously... Don't do that.)

Answer 3

Aliasing a function is fine, but don't try to change the meaning of existing terms

It's OK to create an alias of the function - common libraries do that all the time.

However, it's a bad idea to use terms in a way contrary to common usage, like your example where to your mind max and min should be flipped. It's confusing to other programmers, and you will be doing yourself a disservice by training yourself to keep interpreting these terms in a non-standard way.

So in your case, abandon the "mininum/maximum" parlance that you find confusing and create your own, easy to understand code.

Refactoring your example:

int apply_upper_bound(int x, int y)
{
    return min(x, y);
}


int apply_lower_bound(int x, int y)
{
    return max(x, y)
}

As an added bonus, every time you look at this code, you will be reminding yourself how min and max are used in your programming language. Eventually, it will come to make sense in your head.

Answer 4

I love this question. Let's break it down though.

1: Should you wrap a single line of code?

Yes, I can think of plenty of examples where you might do this. Maybe you are enforcing typed parameters or hiding a concrete implementation behind an interface. In your example you are essentially hiding a static method call.

Additionally you can do a lot of stuff in a single line these days.

2: Are the names 'Min' and 'Max' confusing

Yes! They totally are! A clean coding guru would rename them "FunctionWhichReturnsTheLargestOfItsParameters" or something. Fortunately we have documentation and (if you are lucky) IntelliSense and comments to help us out so anyone who is confused by the names can read up on what they are supposed to do.

3: Should you rename them to something else yourself.

Yup, go for it. For instance, you could have:

class Employee
{
    int NumberOfHolidayDaysIShouldHave(int daysInLue, int maxAllowableHolidayDays)
    {
         // Return the number of days in lue, but keep the value under the max allowable holiday days!
         // Don't use max, you fool!!
         return Math.Max(daysInLue, maxAllowableHolidayDays)
    }
}

It adds meaning, and the caller doesn't have to or want to know how to calculate the value.

4: Should you rename "min" to "maximize"

No!! are you crazy?! But yes, the question underlines the point that different people read different meanings into function and object names. What one person finds clear and conventional another finds opaque and confusing. That is why we have comments. You should instead write:

// Add x and y, but don't let it go over 255
s = min(x + y, 255);

Then when someone reads

// Add x and y, but don't let it go over 255
s = max(x + y, 255);

they know you made a mistake.

Answer 5

No. Dont make functions with names very similar to built-in functions, but which actually does the opposite. It may seem intuitive to you, but is going to be very confusing to other developers, and even to yourself some time in the future when you have more experience.

The meaning of max is "the maximum of", but your "intuitive" understanding is something like "to the maximum of". But this is simply a wrong understanding of the function, and changing the name from max to maximum does not communicate your different interpretation. Even if you strongly believe the language designers made a mistake, don't do something like this.

But changing the name to say cap(x, limit) as has been suggested would be fine, since it clearly does communicate the intention, even if it just wraps min.

Answer 6

What may be confusing you is either using Capped in your function name or your understanding of what placing a cap means. It is a limiter and doesn't require a max of anything.

If you're asked for the lowest, smallest or earliest, do you feel like Max is the appropriate function?

Leave min and max alone. Write tests so at least you'll get it correct the second time.

If you're required to use these functions so much in your project, you will come up with some sort of hint to help you clarify which one to use. Sort of like < or >, the wide part of the mouth faces the larger value.

Answer 7

To answer your question: Is there any other reason this would be inadvisable? What about in a group project? It makes sense that you want your own functions, which is no problem. Just make sure they are in your own helper class and are not easily callable for others unless they import it. (Joes.Utilities.)

But to look again at your problem, basically I would instead be thinking:

return (input >= 255) ? 255 : input;

You're getting confused because you're trying to apply your brain logic to these min/max functions. Instead just speak in English. if the input is greater than or equal to 255 then return 255 otherwise return the input.

Which is:

if (input >= 255) {
   255 
} else {
   input
}

My opinion. You're going for the max\min functions for the wrong reasons, the speed of these things is negligible. Do what makes sense.

Answer 8

While I understand your problem, I'd be reluctant to do this. It would be better to simply drill into your skull what min() and max() do.

Most programmers know what min() and max() functions do -- even if, like you, they sometimes struggle with their intuition over which to use at any given time. If I'm reading a program and see max(x,y), I immediately know what it does. If you create your own "alias" function, then anyone else reading your code will not know what this alias does. They have to find your function. It unnecessarily breaks the flow of reading and forces the reader to do some extra thinking to understand your program.

If you have trouble figuring out which to use at some point, I'd say, add a comment explaining it. Then if a future reader is similarly confused, your comment should clear it up. Or if you do it wrong but the comment explains what you were trying to do, the person trying to debug it will have a clue.

Once you alias a function because the name clashes with your intuition ... is this the only case where that's a problem? Or are you going to alias other functions? Maybe you're confused by "read" and find it easier to think of it as "accept", you change "append" to "StringTogether", "round" to "DropDecimals", etc, etc. Take this to a ridiculous extreme and your programs will be incomprehensible.

Indeed, years ago I worked with a programmer who didn't like all the punctuation in C. So he wrote a bunch of macros to let him write "THEN" instead of "{" and "END-IF" instead of "}" and dozens of other such substitutions. So then when you tried to read his programs, it didn't even look like C any more, it was like having to learn a whole new language. I don't remember now whether "AND" translated to "&" or "&&" -- and that's the point. You undermine the investment people have made in learning the language and the library.

That said, I would not say that a function that does nothing but call a standard library function is necessarily bad. If the point of your function is not to create an alias, but to encapsulate behavior that just happens to be a single function, this could be good and proper. I mean, if logically and inevitably you have to do a max at this point in the program, then just call max directly. But if you have to perform some calculation that today calls for a max, but that might be modified in the future to do something else, then an intermediate function is appropriate.

Answer 9

It is OK to rename built in functions provided the new names makes your code a lot clear and will not be miss understood by anyone. (If you are using C/C++ do not use a #define as it makes it hard to see what is going on.) The name of a function should act like a comment explaining what the calling code is doing and why it is doing to.

You are not the only person that has had this problem with min and max, however I yet to see a good general solution that works across all domains. I think one problem with naming of these functions is that the two arguments have different logical meanings, but are presented as meaning the same.

If your language allows it you could try

return  calculatedDiscount.ButNoMoreThen(maxAllowedDiscount)

return  CDsInStocked.ButNoMoreThen(CasesInStock)

Answer 10

No.

You don't write your wrappers. Names of those wrappers are not very significant.

What you're trying to do is a kind code obfuscation. You're inventing an extra layer which serves 2 purposes:

1. Other people can't understand your code.
2. You never learn to understand other people's code.

By hiding away things you're not comfortable with, you're only hurting your code now and yourself in the future. You can't grow by staying in your comfort zone. What you need is to learn how min and max work.

Answer 11

It is Ok, and not really counterintuitive to use Min,Max to rein in over and undershoot. This is also done using :

• floor() and ceil()
• clamp,limit,bounds
• and of course mod with high order truncation.

In firmware it dates back further than MMX, which itself predates modern 3D graphics which relies on this extensivley.

Replacing an industry standard function even locally would worry me, a derivative name may be better. C++ students might overload for their obscure class perhaps.

Answer 12

It's fine in some cases, but not in your example, because there are much better ways to word it:
saturate, clamp, clip, etc.

Answer 13

I'd rather create a generic function named 'bounded'

//Assumes lower_bound <= upper_bound
template <typename T>
T bounded(T value, T lower_bound, T upper_bound){
    if (value < lower_bound)
        return lower_bound;
    if (value > upper_bound)
        return upper_bound;
    return value;
}

//Checks an upper (by default) or lower bound
template <typename T>
T bounded(T value, T bound, bool is_upper_bound = true){
    if (is_upper_bound){
        if (value > bound)
            return bound;
    }
    else {
        if (value < bound)
            return bound;
    }
    return value;
}

or with the usage of 'min' and 'max'

//Assumes lower_bound <= upper_bound
template <typename T>
T bounded(T value, T lower_bound, T upper_bound){
    return max(min(value, upper_bound), lower_bound);
}

//Checks an upper (by default) or lower bound
template <typename T>
T bounded(T value, T bound, bool is_upper_bound = true){
    if (is_upper_bound)
        return min(value, bound);
    else
        return max(value, bound);
}

Answer 14

What about calling your functions:

atmost(x,255): return the lower of x or 255 at most.

atleast(10,x): return the higher of x or at least 10.

Answer 15

min(x+y, MAX_VALUE); would carry much more meaning than myCustomFunction(x, y);

So the answer is YES, it is unadvisable. It serves only as an alias to your brain language.