CGAL users discussion list

[Stefan Schirra <>]

Hi,

On 19.09.2019 11:27, Stefan Schirra wrote:

> If we set the error to infińity in operator/ for FPF in CORE/Filter.h
>
>   filteredFp operator/ (const filteredFp& x) const {
>      if (x.fpVal == 0.0)
>        core_error("possible zero divisor!", __FILE__, __LINE__, false);
>      double xxx = core_abs(x.fpVal) / x.maxAbs - (x.ind+1)*CORE_EPS + 
> DBL_MIN;
>      if (xxx > 0) {
>        double val =  fpVal / x.fpVal;
>        double maxVal = ( core_abs(val) + maxAbs / x.maxAbs) / xxx + 
> DBL_MIN;
>        return filteredFp(val, maxVal, 1 + core_max(ind, x.ind + 1));
>      } else
>        // return filteredFp(getDoubleInfty(), 0.0, 0);
>        return filteredFp(getDoubleInfty(), getDoubleInfty(), 1);  // NEW
>    }
>
> it works.

In Stefan Funke's Diplomarbeit the recommendation is to return
[NaN, infty, ...] if xxx is not positive. There is no way to get rid of 
the NaN anymore, so no derived interval will be OK later on.

However, you can get rid of the inf later on and this happens in the 
sample code, causing the bug. Again in a division operation, the new 
approximation is computed as
double val =  fpVal / x.fpVal;
with fpVal positive finite and x.fpVal = infinity, resulting in value 0 
in accordance with IEEE 754. The resulting interval is considered OK, 
because the value is finite, although it does not contain the actual value.

Probably one should use something like

return filteredFp( ::sqrt(-1.0), getDoubleInfty(), 1);

or some default NaN, if there is something like that in CORE already.

Best regards

        Stefan