Would a reverse communication interface be possible?

[TLCFEM]

I am wondering if you are interested in a reverse communication interface style version just like ARPACK.

The motivation is that, the current interface accepts a callback function to be passed. For small/simple problems in C and Fortran, it is generally not a problem to define such a function. While for large complex problems written in CPP with the OO style, wrapping things into such a function may not be straightforward and potentially could be cumbersome. All the dependent data have to be somewhat arranged in a single container so that the pointer can then be passed as the third argument *data.

An RCI style API could be beneficial for downstream projects to flexibly design the algorithm.

However, I do see the challenges. For an RCI, the solver needs to be terminated wherever the functional evaluation is needed. Before returning, temporary data needs to be stored in user provided working buffer. When resuming, the solver needs to recover temporary data from buffer and reads the new function value from designated location. This may be quite different from the current implementation that calls the callback.

Any ideas?

[jschueller]

in c++ it is much more elegant to use fonctors, eg:
typedef std::function<double(const double*, double*)>
that way you can pass the method of an object as an objective function

[TLCFEM]

It is possible to define a std::function and call it accordingly. But it cannot be converted into a function pointer, thus, cannot be passed as the callback function.

It is indeed possible to use lambdas (without captures), which shall be similar to free functions. Workarounds can be, for example,

double target_function(double* x, double* data) {
    Object* obj = (Object*)data;
    // apply update logic
    obj->update(x);
    // return objective function value, for example,
    return obj->get_residual();
}

Then before calling, pass this to data in the corresponding method.

    options.data = (void*)this;
    const int rc = prima_newuoa(&problem, &options, &result);

This is fine if the caller is the only thing that is in charge of updating the target objective function. In a more complex setup, maybe multiple objects would be involved, then one shall create a temporary container that accommodates all relevant object pointers, then pass its pointer to data.

[jschueller]

of course, it will need a small c++ interface layer part of prima to convert the functor and get rid of the pointer

[oschuett]

A reverse communication interface would also greatly simplify the integration into CP2K. Any chances this could be add to libprima?