originally reported by Jeremy Murphy (GitHub PR #326); the problem is that
when debug_print_complement_graph() is called, std::cout needs to be defined
which requires the inclusion of <iostream> even in non-debug mode; with this
commit the call to debug_print_complement_graph() is guarded by the appropriate
macro and the use inclusion of <iostream> is no longer needed in non-debug mode;
This allows the algorithms using sections to check spatial predicates
using raw operators < (e.g. in Box/Box disjoint). There is no need to
use less performant calls to math::smaller.
Replace math::smaller usage in section functions preceeding() and
exceeding() and therefore revert the change done recently.
In places where a check must be performed, if a Point is one of the
endpoints of a Linestring contained in a MultiLinestring, std::sort() and
std::equal_range() algorithms are used. With MSVC the assertion in
std::equal_range() fails if the elements cannot be reliably compared, i.e.
in the case when Points has NaN coordinates.
Add has_nan_coordinate() utility and use it in boundary_checker and
topology_check in relate() implementation.
- Instead of assertion failure there is no effect and 0 is returned.
- Handle the NULL root in a similar way in insert, remove and count.
- Add runtime asserts.
equality (using math::equals) for turn fractions is called before operator<;
this is done for consistency with how turns are computed in L/L set operations
and also to make sure that turns in relate are computed in a consistent way;
In the previous implementation the fractions of the two turns where
compared first using operator< and then tested for equality using
math::equals; the consequence of this implementation is that it could
be possible to have two turns t1 and t2 whose fractions satisfied both
operator< and math::equals, which lead to the possibility of having both
less(t1, t2) and less(t2, t1) true; this behavior for less is wrong and
has produced failures on various compilers (especially when sorting);
The solution is to rearrange the code in the less functor so that
math::equals for the two fractions is checked first, that is before
the operator< is called; this makes the outcomes of less(t1, t2) and
less(t2, t1) always consistent with each other;
This fixes the function for long double on some compilers.
For all FP types non-std fabs() was called. This function is defined
only for double. On compilers supporting long double type more precise
than double (GCC, Clang, etc.) this resulted in truncation of the result.
