Can I use std::lower_bound on function calls instead iterators? - c++

Question

Simple use case: I want to find with binary search the minimal index i for which f(i)>=t, where t is some threshold and f is a monotonically increasing function over integer values.
A simple way to go would be to just call this function on every possible input, save it to a container and then use lower_bound, this would be useful in a scenario where I want to do multiple searches on the same function with different thresholds.
However, in my scenario, function evaluations are runtime expensive and I have multiple different functions/lambdas on which I only perform a single binary search.
So I guess, what I need, is either a lower_bound function taking a function and a value range instead of start and end iterators, or I need a mechanism to hide the function calls inside an iterator structure. I know the first solution is easy to implement, but I hoped for a solution that would avoid implementing binary search from scratch.
To me, this seemed like a common use case but somehow I failed to find anything on this particular problem on the web. I'd appreciate any tips, tricks, and links.
EDIT
I found the two first provided solutions very intriguing. The given solution using the comp argument is very elegant, however I forget to mention a reason why this approach does not work for me. In addition to long runtimes for a single function evaluation I also have the problem of having a large search space (e.g. over 10**15 integers) which makes it impractical to allocate a dummy vector for this purpose. I do not know how it would work with the boost increment iterators but I need something to work with std only anyway.
The second solution using a custom iterator is quite verbose though. I tested it with the large number I mentioned (and changing the ints to long longs) but this seems to be also to slow. It seems that lower_bound actually calls the operator++ several times to go from one location to the other, so the implementation of the std::lower_bound might already be the killer for my approach here (see below modified code example and output) and there is no way around a custom implementation (which I already have, no need here).
Thanks, however, for the insights, both answers showed me something new. And maybe someone can shine some more light on the points mentioned above, as I am definitely no expert on iterators or the implementation of lower_bound, maybe I used it wrong or it is something about the code example given by #idclev that makes it iterate this inefficiently through the numbers which I did not recognize.
Modified code example
#include <iostream>
#include <unordered_map>
#include <algorithm>
long long foo(long long i){ std::cout << "function evaluation:\t" << i << std::endl; return i;}
using function_type = long long(*)(long long);
template <function_type F>
struct fun_iterator {
using difference_type = size_t;
using value_type = long long;
using pointer = int*;
using reference = int&;
using iterator_category = std::forward_iterator_tag;
static std::unordered_map<long long,long long> m;
long long index;
fun_iterator(long long index) : index(index) {}
fun_iterator& operator++() {
std::cout << "operator++:\t" << index << std::endl;
++index;
return *this;
}
fun_iterator operator++(int x) {
fun_iterator it = *this;
++index;
return it;
}
int operator*() {
auto it = m.find(index);
if (it != m.end()) return it->second;
auto res = F(index);
m[index] = res;
return res;
}
bool operator!=(const fun_iterator& other){
return index != other.index;
}
bool operator==(const fun_iterator& other){
return index == other.index;
}
bool operator<(const fun_iterator& other){
return index < other.index;
}
};
template <function_type F>
std::unordered_map<long long,long long> fun_iterator<F>::m;
template <function_type F>
std::pair<fun_iterator<F>,fun_iterator<F>> make_begin_and_end(long long begin,long long end){
return {{begin},{end}};
}
int main() {
auto x = make_begin_and_end<foo>(0,10L);
auto it = std::lower_bound(x.first,x.second,4L);
// auto x = make_begin_and_end<foo>(0,1000000000000L);
// auto it = std::lower_bound(x.first,x.second,400000000000L);
std::cout << it.index << std::endl;
}
and the output:
operator++: 0
operator++: 1
operator++: 2
operator++: 3
operator++: 4
operator++: 5
operator++: 6
operator++: 7
operator++: 8
operator++: 9
operator++: 0
operator++: 1
operator++: 2
operator++: 3
operator++: 4
function evaluation: 5
operator++: 0
operator++: 1
function evaluation: 2
operator++: 2
operator++: 3
function evaluation: 4
function evaluation: 3
operator++: 3
4

Answer 1

As #KamilCuk suggested, write your own iterator, or alternatively
You can take any container of natural numbers (if you don't have ranges at hand, simply create an std::vector<int> and populate it with monotonically growing numbers — provided you at least know the boundaries of expected interval your expected value lies within). Next, std::lower_bound accepts a comp argument:
std::vector<int> args(1000);
std::iota(args.begin(), args.end(), 0);
root = std::lower_bound(args.cbegin(), args.cend(), t,
[](int x, int t){ return f(x) < t; });
(As a sanity check, check if root is args's begin — then 0 can be higher than your desired root — or is args's end — then the root is higher than the estimated right boundary.)

Answer 2

You can write your own iterator and to avoid unnessesary evaluations of the function, you can use memoization. The iterator can have a static map to cache results of function calls. To make iterators for different functions a different type, I parametrized the iterator on a function pointer:
#include <iostream>
#include <unordered_map>
#include <algorithm>
double foo(int i){ return i;}
using function_type = double(*)(int);
template <function_type F>
struct fun_iterator {
using difference_type = size_t;
using value_type = int;
using pointer = int*;
using reference = int&;
using iterator_category = std::forward_iterator_tag;
static std::unordered_map<int,double> m;
int index;
fun_iterator(int index) : index(index) {}
fun_iterator& operator++() {
++index;
return *this;
}
fun_iterator operator++(int x) {
fun_iterator it = *this;
++index;
return it;
}
int operator*() {
auto it = m.find(index);
if (it != m.end()) return it->second;
auto res = F(index);
m[index] = res;
return res;
}
bool operator!=(const fun_iterator& other){
return index != other.index;
}
bool operator==(const fun_iterator& other){
return index == other.index;
}
bool operator<(const fun_iterator& other){
return index < other.index;
}
};
template <function_type F>
std::unordered_map<int,double> fun_iterator<F>::m;
template <function_type F>
std::pair<fun_iterator<F>,fun_iterator<F>> make_begin_and_end(int begin,int end){
return {{begin},{end}};
}
int main() {
auto x = make_begin_and_end<foo>(0,100);
auto it = std::lower_bound(x.first,x.second,50);
std::cout << it.index;
}
The map will be reused also for later instances of fun_iterator for the same function. And because it is parametrized on the function pointer, a fun_iterator for a different function uses a different map to store the results.