Comparing 3 number properties of an object - c++

Question

I wanted to know what would be the fastest and most efficient way of comparing three numerical properties of a number and determining the lowest value and the highest value.
Say I have an object with following prop
obj.a = 5;
obj.b = 13;
obj.c = 2;
Now I need to calculate the lowest value(2) and the highest value(13);
One option I have is using conditional statement thus having three conditions for checking the greatest element and three for the lowest element.Resulting in 6 conditional statements.My other option is pushing these values in a vector and then retrieving the extreme values from a sorted vector. Is there an alternative approach to this ? Any suggestions ?

Answer 1

If using C+11 is okay, you can just do:
auto result = std::minmax({a, b, c});
result.first will hold the smallest value, result.second the largest - here's a live demo.

Answer 2

Create your Min() function for 2 variables as:
int Min(int x, int y)
{
return y ^ ((x ^ y) & -(x < y));
}
Similarly Max for 2 variables as:
int Max(int x, int y)
{
return x ^ ((x ^ y) & -(x < y));
}
And now call this function for your 3 variables as:
int max = Max(a,Max(b,c));
int min = Min(a,Min(b,c));
These methods are quite efficient and may be used for any number of variable comparison.
It uses the concept that
the XOR of a number with itself is 0
XOR of a number with 0 is the number itself.
Again this can be used for nested calls for N number of number comparisons.
NOTE: You may even replace x<y with x-y>>31 (considering X to be a 32 bit signed integer).
I am very much sure that it cannot be more efficient than that for 3 numbers

Answer 3

A solution with no more than three compares:
struct Obj
{
int a;
int b;
int c;
std::pair<int,int> getMinMax() const
{
std::pair<int,int> minmax = a< b ? std::make_pair(a,b) : std::make_pair(b,a);
if (c < minmax.first )
minmax.first = c;
else if (c > minmax.second)
minmax.second = c;
return minmax;
}
};

Answer 4

I am giving the psudocode:
a[0] = obj.a
a[1] = obj.b
a[2] = obj.c
To get largest:
index = int(obj.a < obj.b)
larger = a[index]
largest = a[(larger > obj.c) ? index : 2]
To get the smallest:
index = int (obj.a > obj.b)
smaller = a[index]
smallest = a[(smaller < obj.c) ? index : 2]
Makes 2 + 2 comparisons.

Answer 5

Once you've found that a is the minimum, you don't have to consider it for the maximum anymore. So any solution that determines min and max separately is sub-optimal.
There are 6 ways to order 3 things: abc acb bac bca cab cba. So no solution can do with less than 6 branches.
This solution has 6 branches, with at most 3 comparisons per case, so I expect it to be optimal:
if (obj.a < obj.b)
{
if (obj.b < obj.c)
{
min = obj.a; max = obj.c; // abc
}
else if (obj.c < obj.a)
{
min = obj.c; max = obj.b; // cab
}
else
{
min = obj.a; max = obj.b; // acb
}
}
else
{
if (obj.a < obj.c)
{
min = obj.b; max = obj.c; // bac
}
else if (obj.c < obj.b)
{
min = obj.c; max = obj.a; // cba
}
else
{
min = obj.b; max = obj.a; // bca
}
}
EDIT:
Apparently, this is slow. I guess it has something to do with the conditional jumps. Conditional moves are better:
Maybe this one is better, although it still has one branch:
if (obj.a < obj.b)
{
min = std::min(obj.a, obj.c);
max = std::max(obj.b, obj.c);
}
else
{
min = std::min(obj.b, obj.c);
max = std::max(obj.a, obj.c);
}
Eleminating the last branch would turn this into one of the other answers:
min = std::min(std::min(obj.a, obj.b), obj.c);
max = std::max(std::max(obj.a, obj.b), obj.c);
Bottomline: Who would have thought that the 'naive' approach would be faster than writing it all out!