modulo | Basic Cross-platform GUI Toolkit for Any Language | Machine Learning library

The original commit message sheds some light on this. In short, libc++ originally used just prime numbers. This commit introduces an optimization for power-of-2 numbers in case the user explicitly requests them.

Also note that the new function __constrain_hash() in that commit checks if it is a power-of-2 and then does not use the modulo operation. According to the commit message, the cost for the additional check if the input is a power-of-2 number is outweighed by not using a modulo operation. So even if you do not know the information at compile time, you can get a performance boost.

Quote of the commit message:

This commit establishes a new bucket_count policy in the unordered containers: The policy now allows a power-of-2 number of buckets to be requested (and that request honored) by the client. And if the number of buckets is set to a power of 2, then the constraint of the hash to the number of buckets uses & instead of %. If the client does not specify a number of buckets, then the policy remains unchanged: a prime number of buckets is selected. The growth policy is that the number of buckets is roughly doubled when needed. While growing, either the prime, or the power-of-2 strategy will be preserved. There is a small run time cost for putting in this switch. For very cheap hash functions, e.g. identity for int, the cost can be as high as 18%. However with more typical use cases, e.g. strings, the cost is in the noise level. I've measured cases with very cheap hash functions (int) that using a power-of-2 number of buckets can make look up about twice as fast. However I've also noted that a power-of-2 number of buckets is more susceptible to accidental catastrophic collisions. Though I've also noted that accidental catastrophic collisions are also possible when using a prime number of buckets (but seems far less likely). In short, this patch adds an extra tuning knob for those clients trying to get the last bit of performance squeezed out of their hash containers. Casual users of the hash containers will not notice the introduction of this tuning knob. Those clients who swear by power-of-2 hash containers can now opt-in to that strategy. Clients who prefer a prime number of buckets can continue as they have.

Actually here is what the output in release mode looks like:

I think that this should work:

Although I can't provide a formal definition of why/how the rounding modes were chosen as they were, the citation about compatibility with the % operator, which you have included, does make sense when you consider that % is not quite the same thing in C++ and Python.

In C++, it is the remainder operator, whereas, in Python, it is the modulus operator – and, when the two operands have different signs, these aren't necessarily the same thing. There are some fine explanations of the difference between these operators in the answers to: What's the difference between “mod” and “remainder”?

Now, considering this difference, the rounding (truncation) modes for integer division have to be as they are in the two languages, to ensure that the relationship you quoted, (m/n)*n + m%n == m, remains valid.

Here are two short programs that demonstrate this in action (please forgive my somewhat naïve Python code – I'm a beginner in that language):

C++:

To escape the symbol '%' in the format string you need to double it like

Instead of using

After some more experimental work I found that concepts can be used for non type template parms. I simply did not find anything about that in the docs I read.

My usual trick is to first show n mod 10 ∈ {..<10} (which is trivially proven by simp) and then unfold {..<10} to {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, which can be done by feeding the right rules to the simplifier:

From the C Standard (6.5.6 Additive operators)

4 If both operands have arithmetic type, the usual arithmetic conversions are performed on them

And (6.3.1.8 Usual arithmetic conversions)

1 Many operators that expect operands of arithmetic type cause conversions and yield result types in a similar way ...

Otherwise, the integer promotions are performed on both operands.

And (6.3.1.1 Boolean, characters, and integers)

1. ...If an int can represent all values of the original type (as restricted by the width, for a bit-field), the value is converted to an int; otherwise, it is converted to an unsigned int. These are called the integer promotions. 58) All other types are unchanged by the integer promotions.

So the result of an additive operation has the type int when the both operands have the type _Bool that are integer promoted to the type int before performing the operation.

Pay attention to that in C there is no boolean type as in C++. The boolean type _Bool is a standard unsigned integer type in C that can store either 1 or 0.

So if you will write for example