Line data    Source code

       1             : #include "Python.h"
       2             : 
       3             : #ifdef X87_DOUBLE_ROUNDING
       4             : /* On x86 platforms using an x87 FPU, this function is called from the
       5             :    Py_FORCE_DOUBLE macro (defined in pymath.h) to force a floating-point
       6             :    number out of an 80-bit x87 FPU register and into a 64-bit memory location,
       7             :    thus rounding from extended precision to double precision. */
       8           0 : double _Py_force_double(double x)
       9             : {
      10             :     volatile double y;
      11           0 :     y = x;
      12           0 :     return y;
      13             : }
      14             : #endif
      15             : 
      16             : #ifdef HAVE_GCC_ASM_FOR_X87
      17             : 
      18             : /* inline assembly for getting and setting the 387 FPU control word on
      19             :    gcc/x86 */
      20             : 
      21           0 : unsigned short _Py_get_387controlword(void) {
      22             :     unsigned short cw;
      23           0 :     __asm__ __volatile__ ("fnstcw %0" : "=m" (cw));
      24           0 :     return cw;
      25             : }
      26             : 
      27           0 : void _Py_set_387controlword(unsigned short cw) {
      28           0 :     __asm__ __volatile__ ("fldcw %0" : : "m" (cw));
      29           0 : }
      30             : 
      31             : #endif
      32             : 
      33             : 
      34             : #ifndef HAVE_HYPOT
      35             : double hypot(double x, double y)
      36             : {
      37             :     double yx;
      38             : 
      39             :     x = fabs(x);
      40             :     y = fabs(y);
      41             :     if (x < y) {
      42             :         double temp = x;
      43             :         x = y;
      44             :         y = temp;
      45             :     }
      46             :     if (x == 0.)
      47             :         return 0.;
      48             :     else {
      49             :         yx = y/x;
      50             :         return x*sqrt(1.+yx*yx);
      51             :     }
      52             : }
      53             : #endif /* HAVE_HYPOT */
      54             : 
      55             : #ifndef HAVE_COPYSIGN
      56             : double
      57             : copysign(double x, double y)
      58             : {
      59             :     /* use atan2 to distinguish -0. from 0. */
      60             :     if (y > 0. || (y == 0. && atan2(y, -1.) > 0.)) {
      61             :         return fabs(x);
      62             :     } else {
      63             :         return -fabs(x);
      64             :     }
      65             : }
      66             : #endif /* HAVE_COPYSIGN */
      67             : 
      68             : #ifndef HAVE_ROUND
      69             : double
      70             : round(double x)
      71             : {
      72             :     double absx, y;
      73             :     absx = fabs(x);
      74             :     y = floor(absx);
      75             :     if (absx - y >= 0.5)
      76             :     y += 1.0;
      77             :     return copysign(y, x);
      78             : }
      79             : #endif /* HAVE_ROUND */