1  /*
       2    Program to test complex divide for correct results on selected values.
       3    Checking known failure points.
       4  */
       5  
       6  #include <float.h>
       7  
       8  extern void abort (void);
       9  extern void exit (int);
      10  
      11  extern int ilogbf (float);
      12  int match (float _Complex, float _Complex);
      13  
      14  #define SMALL FLT_MIN
      15  #define MAXBIT FLT_MANT_DIG
      16  #define ERRLIM 6
      17  
      18  /*
      19    Compare c (computed value) with z (expected value).
      20    Return 0 if within allowed range.  Return 1 if not.
      21  */
      22  int match (float _Complex c, float _Complex z)
      23  {
      24    float rz, iz, rc, ic;
      25    float rerr, ierr, rmax;
      26    int biterr;
      27    rz = __real__ z;
      28    iz = __imag__ z;
      29    rc = __real__ c;
      30    ic = __imag__ c;
      31  
      32    if (__builtin_fabsf (rz) > SMALL)
      33      {
      34        rerr = __builtin_fabsf (rz - rc) / __builtin_fabsf (rz);
      35      }
      36    else if (__builtin_fabsf (rz) == 0.0)
      37      {
      38        rerr = __builtin_fabsf (rc);
      39      }
      40    else
      41      {
      42        rerr = __builtin_fabsf (rz - rc) / SMALL;
      43      }
      44  
      45    if (__builtin_fabsf (iz) > SMALL)
      46      {
      47        ierr = __builtin_fabsf (iz - ic) / __builtin_fabsf (iz);
      48      }
      49    else if (__builtin_fabsf (iz) == 0.0)
      50      {
      51        ierr = __builtin_fabsf (ic);
      52      }
      53    else
      54      {
      55        ierr = __builtin_fabsf (iz - ic) / SMALL;
      56      }
      57    rmax = __builtin_fmaxf(rerr, ierr);
      58    biterr = 0;
      59    if ( rmax != 0.0)      
      60      {
      61        biterr = ilogbf (rmax) + MAXBIT + 1;
      62      }
      63  
      64    if (biterr >= ERRLIM)
      65      return 0;
      66    else
      67      return 1;
      68  }
      69  
      70  
      71  int main(int argc, char** argv)
      72  {
      73    float _Complex a,b,c,z;
      74    float xr[4], xi[4], yr[4], yi[4], zr[4], zi[4];
      75    float cr, ci;
      76    int i;
      77    int ok = 1;
      78    xr[0] = 0x1.0b1600p-133;
      79    xi[0] = 0x1.5e1c28p+54;
      80    yr[0] = -0x1.cdec8cp-119;
      81    yi[0] = 0x1.1e72ccp+32;
      82    zr[0] = 0x1.38e502p+22;
      83    zi[0] = -0x1.f89220p-129;
      84  
      85    xr[1] = -0x1.b1bee2p+121;
      86    xi[1] = -0x1.cb403ep-59;
      87    yr[1] = 0x1.480000p-144;
      88    yi[1] = -0x1.c66fc4p+5;
      89    zr[1] = -0x1.60b8cap-34;
      90    zi[1] = -0x1.e8b02ap+115;
      91  
      92    xr[2] = -0x1.3f6e00p-97;
      93    xi[2] = -0x1.c00000p-146;
      94    yr[2] = 0x1.000000p-148;
      95    yi[2] = -0x1.0c4e70p-91;
      96    zr[2] = 0x1.aa50d0p-55;
      97    zi[2] = -0x1.30c746p-6;
      98  
      99    xr[3] = 0x1.000000p-148;
     100    xi[3] = 0x1.f4bc04p-84;
     101    yr[3] = 0x1.00ad74p-20;
     102    yi[3] = 0x1.2ad02ep-85;
     103    zr[3] = 0x1.1102ccp-127;
     104    zi[3] = 0x1.f369a4p-64;
     105  
     106    for (i = 0; i < 4; i++)
     107      {
     108        __real__ a = xr[i];
     109        __imag__ a = xi[i];
     110        __real__ b = yr[i];
     111        __imag__ b = yi[i];
     112        __real__ z = zr[i];
     113        __imag__ z = zi[i];
     114        c = a / b;
     115        cr = __real__ c;
     116        ci = __imag__ c;
     117  
     118        if (!match (c,z)){
     119  	ok = 0;
     120        }
     121      }
     122    if (!ok)
     123      abort ();
     124    exit (0);
     125  }