On Monday, 8 May 2023 at 13:22:44 UTC, jmh530 wrote:

> [snip

I was able to get nlopt's tutorial example working with importC. I can write a bit more up later.

For some more details, in case anyone is interested (and myself in case I forget and need to search for it in the future). I installed nlopt as a shared library to some random location (I had to use cmake to disable installation of some parts, like how it handles python). I started with the tutorial [1] and put together a C version of the example and compiled with gcc using

```
gcc cversion.c -w -lnlopt -lm -L/usr/local/nlopt/nlopt/build/ -Wl,-rpath=/usr/local/nlopt/nlopt/build/ -o myprogram
```

The -Wl,rpath is because I didn't install the shared library into a usual location for shared libraries. How to actually do this in practice depends on how you install it and whether to use shared or static libraries. Regardless, I think it is good to get the C version working first.

I then created two .c files one that just includes nlopt.h and another that just includes math.h (as bachmeier recommends) and adjusted the C version of the tutorial to a D version (see below) and compiled with

```
dmd dversion.d math.c nlopt.c -of=dversion -L-lnlopt -L--rpath=/usr/local/nlopt/nlopt/build/
```

dversion.d

```
import math;
import nlopt;
extern(C)
double myfunc(uint n, const double* x, double* grad, void* my_func_data)
{
if (grad) {
grad[0] = 0.0;
grad[1] = 0.5 / sqrt(x[1]);
}
return sqrt(x[1]);
}
struct my_constraint_data
{
double a, b;
}
extern(C)
double myconstraint(uint n, const double* x, double* grad, void* data)
{
my_constraint_data* d = cast(my_constraint_data*) data;
double a = d.a, b = d.b;
if (grad) {
grad[0] = 3 * a * (a*x[0] + b) * (a*x[0] + b);
grad[1] = -1.0;
}
return ((a*x[0] + b) * (a*x[0] + b) * (a*x[0] + b) - x[1]);
}
void main() {
import core.stdc.stdio: printf;
import core.stdc.math: HUGE_VAL;
double[2] lb = [-HUGE_VAL, 0]; /* lower bounds */
nlopt_opt opt;
opt = nlopt_create(NLOPT_LD_MMA, 2); /* algorithm and dimensionality */
nlopt_set_lower_bounds(opt, lb.ptr);
nlopt_set_min_objective(opt, &myfunc, null);
my_constraint_data[2] data = [{2,0}, {-1,1}];
nlopt_add_inequality_constraint(opt, &myconstraint, &data[0], 1e-8);
nlopt_add_inequality_constraint(opt, &myconstraint, &data[1], 1e-8);
nlopt_set_xtol_rel(opt, 1e-4);
double[2] x = [1.234, 5.678]; /* `*`some` `initial` `guess`*` */
double minf = void; /* `*`the` `minimum` `objective` `value,` `upon` `return`*` */
if (nlopt_optimize(opt, x.ptr, &minf) < 0) {
printf("nlopt failed!\n");
}
else {
printf("found minimum at f(%g,%g) = %0.10g\n", x[0], x[1], minf);
}
nlopt_destroy(opt);
}
```

[1] https://github.com/stevengj/nlopt/blob/master/doc/docs/NLopt_Tutorial.md