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.
Get rid of formulas objects and implement the formulas as a struct
template taking parameters enabling the formula parts (e.g. distance
and/or azimuth) with apply() static member function. This way the code is
more clear as all temporary values are created directly in the algorithms.
Furthermore there are no uninitialized values and it's not required to
keep a flag indicating if the distance or azimuth can be calculated.
Use the new implementation of formulas in geographic distance and side
strategies.
Alter the unit test.
The optimization is based on the fact that in the most cases the segments
handled in the TurnInfoPolicy are disjoint. For disjoint segments first
the points are rescaled, then the test for disjoint is run, next the
TurnInfoPolicy just returns and the next pair of segments is handled.
Therefore to optimze the get_turns() this commit changes two things:
1. the cart_intersect strategy may return just after the calculation of sides
for the first segment (2 sides calculation instead of 4),
2. the points are rescaled only one time in the intersection_helper,
already rescaled points are passed into the intersection strategy
* step 1: compute difference(g1, g2)
* step 2: compute difference(g2, g1)
* step 3: return the union of the two differences in previous two steps (as opposed to returning
the concatenation of the previous two steps)
Create and return the end iterator in initialize() function the same way how
iterator `it` is, by output function argument passed by reference. Reuse it
inside this function.
In ..._parser::apply() functions reuse the end iterator, do not create it
each time it is needed.
Consistently pass the end iterator by const reference.
