Вычисление корня функционального уравнения

#include <iostream>
#include <stack>
#include <vector>
#include <cmath>
 
typedef std::pair<double, double> arg_t;
typedef double res_t;
 
class CS {
public:
    int i;
    std::vector<arg_t> core_args;
    std::vector<res_t> fold_args;
    CS * (*core)(arg_t);
    res_t (*fold)(std::vector<res_t>&);
    res_t raw_value;
    bool is_raw_value;
 
    CS(CS * (*core_)(arg_t), res_t (*fold_)(std::vector<res_t>&), std::vector<arg_t>&& v) : core_args(std::move(v)) {
        core = core_;
        fold = fold_;
        fold_args.resize(core_args.size());
        i = 0;
        is_raw_value = false;
    }
    CS(res_t raw_value_) {
        raw_value = raw_value_;
        is_raw_value = true;
    }
};
 
res_t evalCS(CS * cs) {
    if (cs->is_raw_value) return cs->raw_value;
 
    res_t r; CS *h;
    std::stack<CS*> *s = new std::stack<CS*>;
    s->push(cs);
 
    while (1) {
        h = s->top();
        if (h->i < h->core_args.size()) {
            CS *v = h->core(h->core_args[h->i]);
            if (v->is_raw_value) {
                h->fold_args[h->i++] = v->raw_value;
                delete v;
            } else {
                s->push(v);
            }
        } else {
            r = h->fold ? h->fold(h->fold_args) : h->fold_args[h->fold_args.size()-1];
            s->pop();
            delete h;
            if (s->empty()) {
                break;
            } else {
                h = s->top();
                h->fold_args[h->i++] = r;
            }
        }
    }
    delete s;
    return r;
}
 
// root
 
double eps = 0.0001;
 
double f(double x) { return ( log(1.0+x) + 10.0/3.0*exp(0.01*x) ) / (2.0 * sqrt(x)) - x; }
 
CS * rootCS(arg_t p) {
    double a = p.first, b = p.second, c = (a+b)/2;
    return b-a<eps ? new CS(c) : f(a)*f(c) < 0 ? new CS(rootCS, NULL, {{a, c}}) : new CS(rootCS, NULL, {{c, b}});
}
 
int main() {
    std::cout << evalCS(rootCS({eps, 2.0})) << "\n";
}