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 ilogbl (long double);
      12  int match (long double _Complex,long double _Complex);
      13  
      14  #define SMALL LDBL_MIN
      15  #define MAXBIT LDBL_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 (long double _Complex c,long double _Complex z)
      23  {
      24    long double rz, iz, rc, ic;
      25    long double 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_fabsl (rz) > SMALL)
      33      {
      34        rerr = __builtin_fabsl (rz - rc) / __builtin_fabsl(rz);
      35      }
      36    else if (__builtin_fabsl (rz) == 0.0)
      37      {
      38        rerr = __builtin_fabsl (rc);
      39      }
      40    else
      41      {
      42        rerr = __builtin_fabsl (rz - rc) / SMALL;
      43      }
      44  
      45    if (__builtin_fabsl (iz) > SMALL)
      46      {
      47        ierr = __builtin_fabsl (iz - ic) / __builtin_fabsl(iz);
      48      }
      49    else if (__builtin_fabsl (iz) == 0.0)
      50      {
      51        ierr = __builtin_fabsl (ic);
      52      }
      53    else
      54      {
      55        ierr = __builtin_fabsl (iz - ic) / SMALL;
      56      }
      57    rmax = __builtin_fmaxl (rerr, ierr);
      58    biterr = 0;
      59    if ( rmax != 0.0)      
      60      {
      61        biterr = ilogbl (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    long double _Complex a,b,c,z;
      74    long double xr[4], xi[4], yr[4], yi[4], zr[4], zi[4];
      75    long double cr, ci;
      76    int i;
      77    int ok = 1;
      78  
      79  #if (LDBL_MAX_EXP < 2048)
      80    /*
      81      Test values when mantissa is 11 or fewer bits.  Either LDBL is
      82      using DBL on this platform or we are using IBM extended double
      83      precision. Test values will be automatically truncated when
      84      the available precision is smaller than the explicit precision.
      85    */
      86    xr[0] = -0x1.16e7fad79e45ep+651;
      87    xi[0] = -0x1.f7f75b94c6c6ap-860;
      88    yr[0] = -0x1.2f40d8ff7e55ep+245;
      89    yi[0] = -0x0.0000000004ebcp-968;
      90    zr[0] = 0x1.d6e4b0e2828694570ba839070beep+405L;
      91    zi[0] = -0x1.e9095e311e70498db810196259b7p-846L;
      92  
      93    xr[1] = -0x1.21ff587f953d3p-310;
      94    xi[1] = -0x1.5a526dcc59960p+837;
      95    yr[1] = 0x1.b88b8b552eaadp+735;
      96    yi[1] = -0x1.873e2d6544d92p-327;
      97    zr[1] = 0x1.65734a88b2ddff699c482ee8eef6p-961L;
      98    zi[1] = -0x1.927e85b8b576f94a797a1bcb733dp+101L;
      99  
     100    xr[2] = 0x1.4612e41aa8080p-846;
     101    xi[2] = -0x0.0000000613e07p-968;
     102    yr[2] = 0x1.df9cd0d58caafp-820;
     103    yi[2] = -0x1.e47051a9036dbp-584;
     104    zr[2] = 0x1.9b194f3aaadea545174c5372d8p-415L;
     105    zi[2] = 0x1.58a00ab740a6ad3249002f2b79p-263L;
     106  
     107    xr[3] = 0x1.cb27eece7c585p-355;
     108    xi[3] = 0x0.000000223b8a8p-968;
     109    yr[3] = -0x1.74e7ed2b9189fp-22;
     110    yi[3] = 0x1.3d80439e9a119p-731;
     111    zr[3] = -0x1.3b35ed806ae5a2a8cc1c9a96931dp-333L;
     112    zi[3] = -0x1.7802c17c774895bd541adeb200p-974L;
     113  #else
     114    /*
     115      Test values intended for either IEEE128 or Intel80 formats.  In
     116      either case, 15 bits of exponent are available.  Test values will
     117      be automatically truncated when the available precision is smaller
     118      than the explicit precision.
     119    */
     120    xr[0] = -0x9.c793985b7d029d90p-8480L;
     121    xi[0] = 0x8.018745ffa61a8fe0p+16329L;
     122    yr[0] = -0xe.d5bee9c523a35ad0p-15599L;
     123    yi[0] = -0xa.8c93c5a4f94128f0p+869L;
     124    zr[0] = -0x1.849178451c035b95d16311d0efdap+15459L;
     125    zi[0] = -0x1.11375ed2c1f58b9d047ab64aed97p-1008L;
     126  
     127    xr[1] = 0xb.68e44bc6d0b91a30p+16026L;
     128    xi[1] = 0xb.ab10f5453e972f30p-14239L;
     129    yr[1] = 0x8.8cbd470705428ff0p-16350L;
     130    yi[1] = -0xa.0c1cbeae4e4b69f0p+347L;
     131    zr[1] = 0x1.eec40848785e500d9f0945ab58d3p-1019L;
     132    zi[1] = 0x1.22b6b579927a3f238b772bb6dc95p+15679L;
     133  
     134    xr[2] = -0x9.e8c093a43b546a90p+15983L;
     135    xi[2] = 0xc.95b18274208311e0p-2840L;
     136    yr[2] = -0x8.dedb729b5c1b2ec0p+8L;
     137    yi[2] = 0xa.a49fb81b24738370p-16385L;
     138    zr[2] = 0x1.1df99ee89bb118f3201369e06576p+15975L;
     139    zi[2] = 0x1.571e7ef904d6b6eee7acb0dcf098p-418L;
     140  
     141    xr[3] = 0xc.4687f251c0f48bd0p-3940L;
     142    xi[3] = -0xe.a3f2138992d85fa0p+15598L;
     143    yr[3] = 0xe.4b0c25c3d5ebb830p-16344L;
     144    yi[3] = -0xa.6cbf1ba80f7b97a0p+78L;
     145    zr[3] = 0x1.6785ba23bfb744cee97b4142348bp+15520L;
     146    zi[3] = -0x1.ecee7b8c7bdd36237eb538324289p-902L;
     147  #endif
     148  
     149    for (i = 0; i < 4; i++)
     150      {
     151        __real__ a = xr[i];
     152        __imag__ a = xi[i];
     153        __real__ b = yr[i];
     154        __imag__ b = yi[i];
     155        __real__ z = zr[i];
     156        __imag__ z = zi[i];
     157        c = a / b;
     158        cr = __real__ c;
     159        ci = __imag__ c;
     160  
     161        if (!match (c,z)){
     162  	ok = 0;
     163        }
     164      }
     165    if (!ok)
     166      abort ();
     167    exit (0);
     168  }