Speeding up comparison of doubles in C++ [closed] - c++

Question

Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
This question does not appear to be about programming within the scope defined in the help center.
Closed 7 years ago.
Improve this question
I have a function that uses binary search to find the index in a sorted array of doubles such that a "search value" is greater than or equal to the value in the array at that index but strictly less than the value in the array at the subsequent index, if sorted ascending. The input array can be sorted ascending or descending.
I have profiled my code on Microsoft Visual Studio 2012 which shows that 12% of the time is spent in this function while 8% of the time is spent doing a comparison between the "search value" and a value in the array. I would like to explore the possibility of speeding up this function.
/**
Binary Search algorithm for a sorted array of doubles
_sortedArr could be sorted ascending or descending
Find the index in the array _sortedArr such that:
_sortedArr[lowerIndex] <= _valToFind < _sortedArr[lowerIndex+1]
*/
size_t findInArray(const double _sortedArr[], size_t _len, double _valToFind)
{
size_t startIndex = 0;
if( _len <= 1 ) return startIndex;
// Determine if the array is sorted ascending or descending
unsigned int isAscending = (_sortedArr[_len-1] > _sortedArr[startIndex]);
// To avoid looping through the array, detect edge cases first
if( isAscending ) {
if( _valToFind < _sortedArr[startIndex+1] ) return startIndex;
if( _valToFind >= _sortedArr[_len-1] ) return _len-1;
} else {
if( _valToFind > _sortedArr[startIndex+1] ) return startIndex;
if( _valToFind <= _sortedArr[_len-1] ) return _len-1;
}
size_t lowerIndex = startIndex + 1;
size_t upperIndex = _len - 1;
size_t midIndex = 0;
// Binary search loop
while (upperIndex - lowerIndex > 1)
{
midIndex = (upperIndex + lowerIndex) >> 1; // (upperIndex+lowerIndex)/2
// 8% of time spent executing the if-clause
if (_valToFind >= _sortedArr[midIndex] == isAscending)
lowerIndex = midIndex;
else
upperIndex = midIndex;
}
return lowerIndex;
}
The following is a way to test this function:
int main (int argc, char *argv[])
{
const double arr[] = {-3.0000000000000000, -2.5714285714285716, -2.1428571428571432,
-1.7142857142857146, -1.2857142857142860, -0.85714285714285743,
-0.42857142857142888, -3.3306690738754696e-016, 0.42857142857142821,
0.85714285714285676, 1.2857142857142854, 1.7142857142857140,
2.1428571428571423, 2.5714285714285707, 2.9999999999999991};
size_t index = findInArray(arr, 15, 0.0);
std::cout << "Index is: " << index << std::endl;
return 0;
}
When I change the if-clause (8% of the time spent here) to use the less-than comparison, there is no noticeable performance improvement:
if (!(_valToFind < _sortedArr[midIndex]) == isAscending)
The only difference in the disassembly with this change was the use of 'ja' rather than jb.
Any ideas would be appreciated.

Answer 1

Perhaps attempt to remove the conditional branch in the code.
size_t luIndex[2] = { startIndex + 1, _len - 1 };
size_t &lowerIndex = luIndex[0];
size_t &upperIndex = luIndex[1];
size_t midIndex = 0;
// Binary search loop
while (upperIndex - lowerIndex > 1)
{
midIndex = (upperIndex + lowerIndex) >> 1; // (upperIndex+lowerIndex)/2
luIndex[_valToFind >= _sortedArr[midIndex] != isAscending] = midIndex;
}
return lowerIndex;

Answer 2

You can take one of the comparisons out of the loop:
size_t findInArray(const double _sortedArr[], size_t _len, double _valToFind)
{
size_t startIndex = 0;
if( _len <= 1 ) return startIndex;
// Determine if the array is sorted ascending or descending
unsigned int isAscending = (_sortedArr[_len-1] > _sortedArr[startIndex]);
size_t lowerIndex = startIndex + 1;
size_t upperIndex = _len - 1;
size_t midIndex = 0;
// To avoid looping through the array, detect edge cases first
if( isAscending ) {
if( _valToFind < _sortedArr[startIndex+1] ) return startIndex;
if( _valToFind >= _sortedArr[_len-1] ) return _len-1;
// Binary search loop for isAscending == true
while (upperIndex - lowerIndex > 1)
{
midIndex = (upperIndex + lowerIndex) >> 1; // (upperIndex+lowerIndex)/2
if (_valToFind >= _sortedArr[midIndex])
lowerIndex = midIndex;
else
upperIndex = midIndex;
}
} else {
if( _valToFind > _sortedArr[startIndex+1] ) return startIndex;
if( _valToFind <= _sortedArr[_len-1] ) return _len-1;
// Binary search loop for isAscending == false
while (upperIndex - lowerIndex > 1)
{
midIndex = (upperIndex + lowerIndex) >> 1; // (upperIndex+lowerIndex)/2
if (_valToFind >= _sortedArr[midIndex])
upperIndex = midIndex;
else
lowerIndex = midIndex;
}
}
return lowerIndex;
}