Корень и есть "какое y соответствует данному x". Но вот считать его для каждой точки - подозреваю будет накладно. Кстати ф-ция немонотонна и неизвестно правильно ли это вообще.

Да, и возможна ситуация когда одному x соответствует неск y, т.е. результат не определен. Поэтому по-простому-народному выберите диапазон y (напр от 0 до 10), там все монотонно, создайте массив напр 1000 значений x и спокойно находите через lower_bound

Ну что Вы мне парите Пусть бисекшин - простая дихотомия, т.е. деление отрезка пополам (иначе еще хуже). Напр 10 шагов - уже 10 раз вычислена exp, а это разложение в ряд и.т.п.

Аргументы?

Вы такую задачку не слышали: Если сложить газету 40 раз, то толщина стопки получится равной расстоянию от земли до луны..
Так вот к чему это я? А теперь прикиньте, какую точность мы получим  за всего каких то 10 итераций бисекшином..

А они для Вас не очевидны? Давайте сравним две реализации.. С условием, что вычислять функцию нужно с заданной точностью при любом положительном x. Думаю тогда все вопросы сразу отпадут)
 

bisect требует диапазона аргумента (в данном случае y). Откуда Вы его возьмете? Ну напр y = 50, exp(50) - уже "слишком много" чтобы реально использоваться в задаче. Поэтому разговоры о "любом положительном x" неуместны. Более того, на практике часто вообще интересен диапазон [0..1]. Так что давайте реалистичнее, тогда пожалуйста - сравним 

Я говорю о значениях аргумента (y). exp(100000..) вернет nan. Наверное Вы имеете ввиду график х(y) где макс x - достаточно большое. Ну что ж, потрачу больше памяти чтобы добиться нужной точности. Да, если Вы не поняли (судя по постам) то массив строится 1 раз на этапе предрасчета. Поэтому соревноваться с ним в скорости поиска довольно глупо 

Похоже, народное решение мы не увидим.. Ну да ладно)

Скажу несколько слов о производительности метода bisect..
Написал пробный тест, где сравнивается скорость построения графика нашей функции (exact) y(x) (обратной к y*exp(y))
и очень на неё похожей функции (approx) y = log(1 + x)/1.35. На приаттаченом рисунке они обе изображены.

Переменная x проходит от 0 до 10000 с шагом dx = 1. Результат записывается в файл.

Исходник с замером времени:

C++ (Qt)
#include <iostream>
#include <fstream>
#include <chrono>
 
#include <specmath/roots.h>
 
 
template <class T>
T exact_func(const T & x, const T & err = 0.000001)
{
    static const T e = exp(1);
 
    const T ln_x = log(x);
    const T min = (x < e) ? 0 : 1;
    const T max = (x < e) ? 1 : ln_x;
 
    return specmath::bisect([&](const T& s) { return (x < e) ? (x - s * exp(s)) : (ln_x - s - log(s)); },  min, max, err);
}
 
template <class T>
T approx_func(const T & x)
{
    return log(1 + x)/1.35;
}
 
int main()
{
    double x = 0;
    const double xmax = 10000;
    const double dx = 1;
 
 
    std::ofstream out1("data1.txt");
    std::ofstream out2("data2.txt");
 
    auto start = std::chrono::high_resolution_clock::now();
    while (x < xmax)
    {
        out1 << x << " " << exact_func(x) << std::endl;
        x += dx;
    }
    auto stop = std::chrono::high_resolution_clock::now();
 
    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(stop-start).count();
 
    std::cout << " bisection: total time = " << elapsed << "ms" << std::endl;
 
 
 
    x = 0;
    start = std::chrono::high_resolution_clock::now();
    while (x < xmax)
    {
        out2 << x << " " << approx_func2(x) << std::endl;
        x += dx;
    }
    stop = std::chrono::high_resolution_clock::now();
 
    elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(stop-start).count();
 
    std::cout << "aprox func: total time = " << elapsed << "ms" << std::endl;
 
    return 0;
}
 

 

Результаты трёх прогонов следующие:

Bash
 bisection: total time = 58ms
aprox func: total time = 50ms
 
 bisection: total time = 58ms
aprox func: total time = 50ms
 
 bisection: total time = 58ms
aprox func: total time = 51ms
 

Как видно, разница ничтожна..  
"Народный" вариант от igors однозначно проиграл бы по памяти (это мягко говоря), да и по скорости тоже есть сомнения..
Так что делаем выводы..

ЗЫ В примере выше, вместо boost::bisect использовалась более  быстрая её версия.. Но сути это не меняет..

Ну вообще то, эти результаты: два графика были построены после запуска этого примера.. Строится всё корректно) Время тоже считается честно)  

Нет, если внимательно посмотреть, то в самой лямбде тоже проверяется условие (x < e) и в зависимости от него выбирается своя схема..
Там всё корректно, иначе результат (график) не получился бы)  

Поменял местами exact и approx.. Результаты не изменились..