Face_handle test_point_location(const Triangulation &t,
const Point &query,
const Triangulation::Locate_type <_in)
{
Triangulation::Locate_type lt, lt2;
int li, li2;
Face_handle fh;
CGAL::Bounded_side bs;
CGAL::Oriented_side os;
fh = t.locate(query, lt, li);
CGAL_assertion(lt == lt_in);
if (lt_in == Triangulation::EMPTY) {
CGAL_assertion(fh == Face_handle());
return fh;
}
bs = t.side_of_face(query, fh, lt2, li2);
os = t.oriented_side(fh, query);
CGAL_USE(bs);
CGAL_USE(os);
CGAL_assertion(lt2 == lt_in);
switch (lt_in)
{
case Triangulation::VERTEX:
case Triangulation::EDGE:
{
CGAL_assertion(fh != Face_handle());
CGAL_assertion(bs == CGAL::ON_BOUNDARY);
CGAL_assertion(os == CGAL::ON_ORIENTED_BOUNDARY);
CGAL_assertion(li == li2);
break;
}
case Triangulation::FACE:
{
CGAL_assertion(fh != Face_handle());
CGAL_assertion(bs == CGAL::ON_BOUNDED_SIDE);
CGAL_assertion(os == CGAL::ON_POSITIVE_SIDE);
break;
}
case Triangulation::EMPTY:
{
// Handled above
CGAL_assertion(false);
break;
}
case Triangulation::OUTSIDE_CONVEX_HULL: CGAL_error();
case Triangulation::OUTSIDE_AFFINE_HULL: CGAL_error();
}
return fh;
}
// Squaring simplifies things and is faster, so we specialize it.
MP_Float
INTERN_MP_FLOAT::square(const MP_Float &a)
{
// There is a bug here (see test-case in test/NT/MP_Float.C).
// For now, I disable this small optimization.
// See also the comment code in operator*().
return a*a;
#if 0
typedef MP_Float::limb limb;
typedef MP_Float::limb2 limb2;
if (a.is_zero())
return MP_Float();
MP_Float r;
r.exp = 2*a.exp;
r.v.assign(2*a.v.size(), 0);
for(unsigned i=0; i<a.v.size(); i++)
{
unsigned j;
limb2 carry = 0;
limb carry2 = 0;
for(j=0; j<i; j++)
{
// There is a risk of overflow here :(
// It can only happen when a.v[i] == a.v[j] == -2^15 (log_limb...)
limb2 tmp0 = std::multiplies<limb2>()(a.v[i], a.v[j]);
limb2 tmp1 = carry + (limb2) r.v[i+j] + tmp0;
limb2 tmp = tmp0 + tmp1;
limb tmpcarry;
MP_Float::split(tmp, tmpcarry, r.v[i+j]);
carry = tmpcarry + (limb2) carry2;
// Is there a more efficient way to handle this carry ?
if (tmp > 0 && tmp0 < 0 && tmp1 < 0)
{
// If my calculations are correct, this case should never happen.
CGAL_error();
}
else if (tmp < 0 && tmp0 > 0 && tmp1 > 0)
carry2 = 1;
else
carry2 = 0;
}
// last round for j=i :
limb2 tmp0 = carry + (limb2) r.v[i+i]
+ std::multiplies<limb2>()(a.v[i], a.v[i]);
MP_Float::split(tmp0, r.v[i+i+1], r.v[i+i]);
r.v[i+i+1] += carry2;
}
r.canonicalize();
return r;
#endif
}