Simple way to check a large number of similar conditions?

Question

I am working on a game, and I am finding myself very often checking that certain quantities are in the bounds of the indexes accepted by the vector that represents my world:

if(a >= 0 && a < 16 && b >= 0 && b < 16 && c >= 0 && c < 16 && 
   d >= 0 && d < 16 && e >= 0 && e < 16)
{
    //do things with vector[a][b][c][d][e]
}

I often have to check even more conditions than this. Is there a way that I can make these checks more concise and/or easier to read?

Alternatively, is there a way that I can avoid doing the checks entirely? The vector is 16x16x16x16x16; can I make it so that if I were to give it a 16 as an index, it would do nothing rather than segfault?

Write a `inRange()` function and call it on all the variables? — yizzlez, Aug 04 '15 at 16:51
This is a x-y problem. It's much better to combine 4 points and 4 bonds into something like `QRect` and use a method like`bool QRect::contains(const QPoint & point, bool proper = false) const` http://doc.qt.io/qt-5/qrect.html#contains — user3528438, Aug 04 '15 at 17:19
Firstly, I don't think it's wise to "just do nothing rather than segfault" if an index is out of range. The simple reason is that the calling code might assume it has a correct index, which means the error propagates through the program. However, if that doesn't matter, you could replace the 16x16x16x16x16 vector of vectors with a single vector and compute the index using bit-shifting, which is relatively fast and avoids the overhead of jumping through arrays. BTW, if the size 16 is fixed, any `i` where `i != (i&15)` is invalid. Lastly, using `vector::at()` would be an option. — Ulrich Eckhardt, Aug 04 '15 at 17:25
@user3528438 I think you misunderstand, a, b, c, d, and e each represent a different dimension of the vector, not points of rectangles. — Kai Schmidt, Aug 04 '15 at 17:25
For checking against 0 and an upper bound, if you typecast to an unsigned value, negative numbers get really big. This allows you to check both bounds with one compare. — Michael Dorgan, Aug 04 '15 at 17:58
@KaiSchmidt Those are the same thing. The coordinates (a,b,c,d,e) specify a point in five-dimensional space and you want to know whether or not that point is inside the five-dimensional rectangle composed of all valid combinations of those variables. The insight that you're missing is that what all valid combinations of a, b, c, d, and e have in common is that they represent a point inside a particular rectangle that all invalid combinations are outside. — David Schwartz, Aug 04 '15 at 17:58
@DavidSchwartz It seems to me that QRect has only two dimensions, so not quite what one would want here. But something "like" it with more dimensions might work. — David K, Aug 05 '15 at 04:18
I am personally more worried about you hard-coding 16 everywhere; if ever comes a time where this dimension needs to change... I suggest that you look into *encapsulation*, if you design a class to contain the array, then it could have a method "is_in_bounds" which accept the coordinates and check them, — Matthieu M., Aug 05 '15 at 06:20

yizzlez · Accepted Answer · 2015-08-04T18:53:30.170

40

You could write a variadic check function:

bool check(int a) {
  return 0 <= a && a < 16;
}   

template<typename... Args>
bool check(int a, Args... args) {
  return check(a) && check(args...);
}

You can use it like check(a, b, c, d, e, ...). It also has the advantage of being able to take any number of conditions.

Here's a demo

edited Aug 04 '15 at 18:53

answered Aug 04 '15 at 16:55

yizzlez

8,757
4
29
44

1

the comparison can be optimized more using this way [Fastest way in C to determine if an integer is between two integers (inclusive) with known sets of values](http://stackoverflow.com/a/17095534/995714) `return ((unsigned)a <= 16) && check(args...);` – phuclv Aug 04 '15 at 17:47
1

You remove some duplication by writing your second function like this: `return check(a) && check(args...);` – Joel Aug 04 '15 at 18:48
12

@LưuVĩnhPhúc That's a very nice performance optimization indeed. Which is why compiler writers have been applying it for a very, very long time and that without you having to obfuscate your code. – Voo Aug 04 '15 at 20:58
@Voo I just wonder why the iOS compiler in the other question didn't implement this – phuclv Aug 05 '15 at 03:26
1

@LưuVĩnhPhúc Presumably because in that case there were three variables involved and the compiler couldn't prove that `upper >= lower`. Much easier for constants. – Voo Aug 05 '15 at 05:58

score 13 · Answer 2 · answered Aug 04 '15 at 23:49

13

Here's a compact and efficient way to do the check. It assumes two's complement arithmetic.

bool IsInBounds(int a, int b, int c, int d, int e)
{
    // Make sure only bits 0-3 are set (i.e. all values are 0-15)
    return ((a | b | c | d | e) & ~0xf) == 0;
}

This works by noting that all values outside the 0-15 range all have a bit set that isn't one of the four least significant ones, and all values inside the range don't.

Of course it's only worth using this sort of optimization if the gains in efficiency outweigh the loss of code readability.

answered Aug 04 '15 at 23:49

Adam

882
5
10

1

@mucaho : which PC doesn't have two's complement arithmetic? – rkosegi Aug 05 '15 at 12:37
@rkosegi Almost none according to this [SE question](http://stackoverflow.com/questions/161797/is-ones-complement-a-real-world-issue-or-just-a-historical-one) – mucaho Aug 05 '15 at 15:34

score 11 · Answer 3 · answered Aug 04 '15 at 16:53

11

The point of functions is reusability. If you find yourself writing certain long expressions or groups of statements repeatedly, it might be time to refactor it out.

In this case, I would write a simple function to do the bounds checking:

bool isInBounds(int a, int b, int c, int d, int e)
{
     return a >= 0 && a < 16 &&
            b >= 0 && b < 16 &&
            c >= 0 && c < 16 && 
            d >= 0 && d < 16 &&
            e >= 0 && e < 16;
}

Then use it instead of your long condition:

if (isInBounds(a, b, c, d, e))
{
    // do things with array[a][b][c][d][e]
}

answered Aug 04 '15 at 16:53

Jashaszun

9,207
3
29
57

When checking if variables are within a certain range it's generally easier to read if you write the condition as 0 <= a && a < 16 (this makes it look a lot like 0 <= a < 16) – Rich Smith Aug 05 '15 at 16:49
@RichSmith That's a good suggestion, although personally I always like seeing the variable name first, and the constant second. It really is opinion though, so whatever people want to use. – Jashaszun Aug 05 '15 at 17:07

Galik · Answer 4 · 2017-07-05T13:04:57.597

You can store your variables as elements in a std::vector rather than separate variabes like this:

bool test(const std::vector<int>& values)
{
    for(auto v: values)
        if(v < 0 || v >= 16)
            return false;
    return true;
}

Alternatively if you are using C++11 or later you can use std::all_of:

if(std::all_of(std::begin(values), std::end(values),
    [](int i){ return i >= 0 && i < 16; }))
{
    // do stuff with values
}

In that case you may also be able to use a std::array.

Chris Drew · Answer 5 · 2015-08-05T06:26:12.300

You could combine the 5 integers making up your index into one std::array or your own class.

using Index5 = std::array<int, 5>;

Then you can write a function like:

bool contains(Index5 bounds, Index5 point) {
    for (Index5::size_type d = 0; d != bounds.size(); ++d) {
        if ((unsigned)point[d] > bounds[d])  // using the trick mentioned in comments
            return false;
    }
    return true;
}

Then use it like this:

auto bounds = Index5{16, 16, 16, 16, 16};
auto point = Index5{a, b, c, d, e};

if (contains(bounds, point)) {
    // do things with point
}

Generally, I would suggest using something like Index5 instead of managing five integers.

score 1 · Answer 6 · answered Aug 05 '15 at 04:26

If the quantities a, b, c, d, and e are something that occur together quite frequently and all need to stay within the bounds of your "world" (e.g. they represent the "state" of something in that world) then it might make sense to define a class whose primary purpose is to hold one "state" consisting of those five quantities.

Then make sure that if any code ever tries to store values in an object of that class that are not within the bounds, something reasonable (not a segfault) happens instead, and no out-of-bounds values are ever stored there. That way, an object of that class is safe to pass to any function that requires a, b, c, d, and e to be within bounds, and there is no need for any such function to do bounds-checking on those five values.

Simple way to check a large number of similar conditions?

6 Answers6