rounding | Round by any arbitrary step in Ruby | Ecommerce library

I couldn't figure out your math. I think you should try annotating this kind of code with explanatory comments. Often that will help you spot your own mistake:

The Fraction type can do this easily and exactly:

The following method avoids overflow and should result in fairly efficient assembly (example) without depending on non-standard features:

You're right to be confused by this example. With a range of 4..5, the guess (midVal) would be 4. The only way the line of code GuessNumber(lowVal, midVal-1); would be executed is if the user answered "low" which is:

1. a lie, or
2. their number is out of range.

The example code doesn't account for search values outside the initial input range, which a binary search should do.

Quick answer:

The first magical number forces rescaling of the argument so that the LSbit of the integer part becomes rightmost-but-one in the fraction.

Then adding the second magical will erase the exponent bits.

Regarding the necessity of the last division by 2, IDK, there must be an extra technicality (probably related to the addition of 3.2^21 rather than 1.2^21).

This is a bug in GLM. While the usual admonition about using % with rand is that the range doesn’t evenly divide RAND_MAX, this code opts for the more straightforward approach of reducing rand() modulo UINT8_MAX, so that 255 is never produced. Every random value is ultimately derived from combining several such bytes, so 127/255=49.8% of the values will be in the upper half (here, positive).

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++:

Just quick speedups:

1. You can omit math.sqrt()
2. Create dictionary of colors instead of a list (that way you don't have to search for the index each iteration)
3. use min() instead of sorted()