source/gDel2D/gDel2D/CPU/predicates.cpp
void exactinit()
{
    RealType half;
    RealType check, lastcheck;
    int every_other;

#ifdef _WIN32
#ifdef REAL_TYPE_FP32
    _control87(_PC_24, _MCW_PC); /* Set FPU control word for single precision. */
#else /* not SINGLE */
    _control87(_PC_53, _MCW_PC); /* Set FPU control word for double precision. */
#endif /* not SINGLE */
#else
    int cword; 
#ifdef REAL_TYPE_FP32
    cword = 4210; /* Set FPU control word for single precision */
#else
    cword = 4722; /* Set FPU control word for double precision */
#endif
    _FPU_SETCW(cword); 
#endif

    every_other = 1;
    half = 0.5;
    epsilon = 1.0;
    splitter = 1.0;
    check = 1.0;
    /* Repeatedly divide `epsilon' by two until it is too small to add to    */
    /*   one without causing roundoff.  (Also check if the sum is equal to   */
    /*   the previous sum, for machines that round up instead of using exact */
    /*   rounding.  Not that this library will work on such machines anyway. */
    do {
        lastcheck = check;
        epsilon *= half;
        if (every_other) {
            splitter *= 2.0;
        }
        every_other = !every_other;
        check = 1.0 + epsilon;
    } while ((check != 1.0) && (check != lastcheck));
    splitter += 1.0;

    /* Error bounds for orientation and incircle tests. */
    resulterrbound = (3.0 + 8.0 * epsilon) * epsilon;
    ccwerrboundA = (3.0 + 16.0 * epsilon) * epsilon;
    ccwerrboundB = (2.0 + 12.0 * epsilon) * epsilon;
    ccwerrboundC = (9.0 + 64.0 * epsilon) * epsilon * epsilon;
    o3derrboundA = (7.0 + 56.0 * epsilon) * epsilon;
    o3derrboundB = (3.0 + 28.0 * epsilon) * epsilon;
    o3derrboundC = (26.0 + 288.0 * epsilon) * epsilon * epsilon;
    iccerrboundA = (10.0 + 96.0 * epsilon) * epsilon;
    iccerrboundB = (4.0 + 48.0 * epsilon) * epsilon;
    iccerrboundC = (44.0 + 576.0 * epsilon) * epsilon * epsilon;
    isperrboundA = (16.0 + 224.0 * epsilon) * epsilon;
    isperrboundB = (5.0 + 72.0 * epsilon) * epsilon;
    isperrboundC = (71.0 + 1408.0 * epsilon) * epsilon * epsilon;
    o3derrboundlifted = ( 11 + 112 * epsilon ) * epsilon; 
}
/*****************************************************************************/
/*                                                                           */
/*  exactinit()   Initialize the variables used for exact arithmetic.        */
/*                                                                           */
/*  `epsilon' is the largest power of two such that 1.0 + epsilon = 1.0 in   */
/*  floating-point arithmetic.  `epsilon' bounds the relative roundoff       */
/*  error.  It is used for floating-point error analysis.                    */
/*                                                                           */
/*  `splitter' is used to split floating-point numbers into two half-        */
/*  length significands for exact multiplication.                            */
/*                                                                           */
/*  I imagine that a highly optimizing compiler might be too smart for its   */
/*  own good, and somehow cause this routine to fail, if it pretends that    */
/*  floating-point arithmetic is too much like real arithmetic.              */
/*                                                                           */
/*  Don't change this routine unless you fully understand it.                */
/*                                                                           */
/*****************************************************************************/
exactinit()   Initialize the variables used for exact arithmetic.

`epsilon' is the largest power of two such that 1.0 + epsilon = 1.0 in
floating-point arithmetic.  `epsilon' bounds the relative roundoff
error.  It is used for floating-point error analysis.

`splitter' is used to split floating-point numbers into two half
length significands for exact multiplication.

I imagine that a highly optimizing compiler might be too smart for its
own good, and somehow cause this routine to fail, if it pretends that
floating-point arithmetic is too much like real arithmetic.

Don't change this routine unless you fully understand it.
exactinit () Initialize the variables used for exact arithmetic . ` epsilon ' is the largest power of two such that 1 . 0 + epsilon = 1 . 0 in floating - point arithmetic . ` epsilon ' bounds the relative roundoff error . It is used for floating - point error analysis . ` splitter ' is used to split floating - point numbers into two half length significands for exact multiplication . I imagine that a highly optimizing compiler might be too smart for its own good and somehow cause this routine to fail if it pretends that floating - point arithmetic is too much like real arithmetic . Don ' t change this routine unless you fully understand it .
void exactinit()
{
    RealType half;
    RealType check, lastcheck;
    int every_other;
#ifdef _WIN32
#ifdef REAL_TYPE_FP32
    _control87(_PC_24, _MCW_PC); 
#else 
    _control87(_PC_53, _MCW_PC); 
#endif 
#else
    int cword; 
#ifdef REAL_TYPE_FP32
    cword = 4210; 
#else
    cword = 4722; 
#endif
    _FPU_SETCW(cword); 
#endif
    every_other = 1;
    half = 0.5;
    epsilon = 1.0;
    splitter = 1.0;
    check = 1.0;
    do {
        lastcheck = check;
        epsilon *= half;
        if (every_other) {
            splitter *= 2.0;
        }
        every_other = !every_other;
        check = 1.0 + epsilon;
    } while ((check != 1.0) && (check != lastcheck));
    splitter += 1.0;
    resulterrbound = (3.0 + 8.0 * epsilon) * epsilon;
    ccwerrboundA = (3.0 + 16.0 * epsilon) * epsilon;
    ccwerrboundB = (2.0 + 12.0 * epsilon) * epsilon;
    ccwerrboundC = (9.0 + 64.0 * epsilon) * epsilon * epsilon;
    o3derrboundA = (7.0 + 56.0 * epsilon) * epsilon;
    o3derrboundB = (3.0 + 28.0 * epsilon) * epsilon;
    o3derrboundC = (26.0 + 288.0 * epsilon) * epsilon * epsilon;
    iccerrboundA = (10.0 + 96.0 * epsilon) * epsilon;
    iccerrboundB = (4.0 + 48.0 * epsilon) * epsilon;
    iccerrboundC = (44.0 + 576.0 * epsilon) * epsilon * epsilon;
    isperrboundA = (16.0 + 224.0 * epsilon) * epsilon;
    isperrboundB = (5.0 + 72.0 * epsilon) * epsilon;
    isperrboundC = (71.0 + 1408.0 * epsilon) * epsilon * epsilon;
    o3derrboundlifted = ( 11 + 112 * epsilon ) * epsilon; 
}
void exactinit ( ) { RealType half ; RealType check , lastcheck ; int every_other ; #ifdef _WIN32 #ifdef REAL_TYPE_FP32 _control87 ( _PC_24 , _MCW_PC ) ; #else _control87 ( _PC_53 , _MCW_PC ) ; #endif #else int cword ; #ifdef REAL_TYPE_FP32 cword = 4210 ; #else cword = 4722 ; #endif _FPU_SETCW ( cword ) ; #endif every_other = 1 ; half = 0.5 ; epsilon = 1.0 ; splitter = 1.0 ; check = 1.0 ; do { lastcheck = check ; epsilon *= half ; if ( every_other ) { splitter *= 2.0 ; } every_other = ! every_other ; check = 1.0 + epsilon ; } while ( ( check != 1.0 ) && ( check != lastcheck ) ) ; splitter += 1.0 ; resulterrbound = ( 3.0 + 8.0 * epsilon ) * epsilon ; ccwerrboundA = ( 3.0 + 16.0 * epsilon ) * epsilon ; ccwerrboundB = ( 2.0 + 12.0 * epsilon ) * epsilon ; ccwerrboundC = ( 9.0 + 64.0 * epsilon ) * epsilon * epsilon ; o3derrboundA = ( 7.0 + 56.0 * epsilon ) * epsilon ; o3derrboundB = ( 3.0 + 28.0 * epsilon ) * epsilon ; o3derrboundC = ( 26.0 + 288.0 * epsilon ) * epsilon * epsilon ; iccerrboundA = ( 10.0 + 96.0 * epsilon ) * epsilon ; iccerrboundB = ( 4.0 + 48.0 * epsilon ) * epsilon ; iccerrboundC = ( 44.0 + 576.0 * epsilon ) * epsilon * epsilon ; isperrboundA = ( 16.0 + 224.0 * epsilon ) * epsilon ; isperrboundB = ( 5.0 + 72.0 * epsilon ) * epsilon ; isperrboundC = ( 71.0 + 1408.0 * epsilon ) * epsilon * epsilon ; o3derrboundlifted = ( 11 + 112 * epsilon ) * epsilon ; }
exactinit()   Initialize the variables used for exact arithmetic.
exactinit () Initialize the variables used for exact arithmetic .
/* Set FPU control word for single precision. */ /* not SINGLE */ /* Set FPU control word for double precision. */ /* not SINGLE */ /* Set FPU control word for single precision */ /* Set FPU control word for double precision */ /* Repeatedly divide `epsilon' by two until it is too small to add to    */ /*   one without causing roundoff.  (Also check if the sum is equal to   */ /*   the previous sum, for machines that round up instead of using exact */ /*   rounding.  Not that this library will work on such machines anyway. */ /* Error bounds for orientation and incircle tests. */