# C++ – Fastest way to determine if an integer is between two integers (inclusive) with known sets of values

c++mathperformance

Is there a faster way than `x >= start && x <= end` in C or C++ to test if an integer is between two integers?

UPDATE: My specific platform is iOS. This is part of a box blur function that restricts pixels to a circle in a given square.

UPDATE: After trying the accepted answer, I got an order of magnitude speedup on the one line of code over doing it the normal `x >= start && x <= end` way.

UPDATE: Here is the after and before code with assembler from XCode:

NEW WAY

``````// diff = (end - start) + 1
#define POINT_IN_RANGE_AND_INCREMENT(p, range) ((p++ - range.start) < range.diff)

Ltmp1313:
ldr    r0, [sp, #176] @ 4-byte Reload
ldr    r1, [sp, #164] @ 4-byte Reload
ldr    r0, [r0]
ldr    r1, [r1]
sub.w  r0, r9, r0
cmp    r0, r1
blo    LBB44_30
``````

OLD WAY

``````#define POINT_IN_RANGE_AND_INCREMENT(p, range) (p <= range.end && p++ >= range.start)

Ltmp1301:
ldr    r1, [sp, #172] @ 4-byte Reload
ldr    r1, [r1]
cmp    r0, r1
bls    LBB44_32
mov    r6, r0
b      LBB44_33
LBB44_32:
ldr    r1, [sp, #188] @ 4-byte Reload
Ltmp1302:
ldr    r1, [r1]
cmp    r0, r1
bhs    LBB44_36
``````

Pretty amazing how reducing or eliminating branching can provide such a dramatic speed up.

#### Best Solution

There's an old trick to do this with only one comparison/branch. Whether it'll really improve speed may be open to question, and even if it does, it's probably too little to notice or care about, but when you're only starting with two comparisons, the chances of a huge improvement are pretty remote. The code looks like:

``````// use a < for an inclusive lower bound and exclusive upper bound
// use <= for an inclusive lower bound and inclusive upper bound
// alternatively, if the upper bound is inclusive and you can pre-calculate
//  upper-lower, simply add + 1 to upper-lower and use the < operator.
if ((unsigned)(number-lower) <= (upper-lower))
in_range(number);
``````

With a typical, modern computer (i.e., anything using twos complement), the conversion to unsigned is really a nop -- just a change in how the same bits are viewed.

Note that in a typical case, you can pre-compute `upper-lower` outside a (presumed) loop, so that doesn't normally contribute any significant time. Along with reducing the number of branch instructions, this also (generally) improves branch prediction. In this case, the same branch is taken whether the number is below the bottom end or above the top end of the range.

As to how this works, the basic idea is pretty simple: a negative number, when viewed as an unsigned number, will be larger than anything that started out as a positive number.

In practice this method translates `number` and the interval to the point of origin and checks if `number` is in the interval `[0, D]`, where `D = upper - lower`. If `number` below lower bound: negative, and if above upper bound: larger than `D`.