MMA causes division by zero when using relative tolerance (ftol_rel)

[rafaelrojasmiliani]

What happened?

When using the NLopt MMA optimizer (LD_MMA) with relative stopping tolerances (ftol_rel), a division-by-zero floating-point exception occurs.

I observed this phenomenon trying to solve the unconstrainted Matyas and Three-hump camel function reported in wikipedia with ftol_rel set and (0, 0) as initial condition. No matter the value of ftol_rel a division by zero is performed.

While debugging, I arrived here and observed that dd.wval is zero.

How to reproduce the issue?

Run this


// test_mma_divzero.cpp

#include <cfenv>    // feenableexcept
#include <iostream>
#include <nlopt.hpp>    // NLopt C++ wrapper
#include <stdexcept>
#include <vector>

// f(x) = x^T x, with gradient 2x
double objective(const std::vector<double>& x, std::vector<double>& grad, void* /*data*/)
{
	if (!grad.empty())
	{
		grad[0] = 2.0 * x[0];
		grad[1] = 2.0 * x[1];
	}
	return (x[0] * x[0]) + (x[1] * x[1]);
}

int main()
{
	// Enable floating point exceptions (except inexact, underflow, overflow)
	feenableexcept(FE_ALL_EXCEPT & ~FE_INEXACT & ~FE_UNDERFLOW & ~FE_OVERFLOW);

	const int n = 2;
	nlopt::opt opt(nlopt::LD_MMA, n);


	// MMA requires bounds; choose [0, 1] so that x=0 is feasible and optimal
	std::vector<double> lb(n, -1.0);
	std::vector<double> ub(n, 1.0);
	opt.set_lower_bounds(lb);
	opt.set_upper_bounds(ub);

	opt.set_min_objective(objective, nullptr);
	opt.set_ftol_rel(1e-2);

	// Initial guess x = (0, 0)
	std::vector<double> x(n, 0.5);
	double minf = 0.0;

	nlopt::result res = opt.optimize(x, minf);
	std::cout << "NLopt result code: " << res << "\n";
	std::cout << "x = [" << x[0] << ", " << x[1] << "], f = " << minf << "\n";

	return 0;
}

Version

2.7.1

Operating System

Linux

Installation media

other

Additional Context

Installed with apt-get.

[marcoafo]

I might be wrong but isn’t MMA designed for constrained problems? I think that when it reaches (0,0) the rho goes to zero exactly. I’m not sure if there should be a change in the algorithm to add some epsilon and avoid this, or maybe you could add an inequality constrain to avoid this.

[rafaelrojasmiliani]

Hello @marcoafo, Thanks you for the feedback!. That made me check the MMA paper by Svanberg that I didn't read before creating the issue 🙈. And yes, MMA is designed for constrained problem, but also handles problems without constrains. In fact, MMA implementation in nlopt handles uncontained problems very well. The problem is with that division by zero that may pass unnoticed if you don't activate the exception with feenableexcept. Moreover, it solves the problem regardless the exception 🤸‍♂️ . I think that this is more a "full c++ correctness" issue, rather than a problem in the optimizer.