tests/tsub1sp.c

   1 /* Test file for mpfr_sub1sp.
   2
   3 Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
   4 Contributed by the AriC and Caramel projects, INRIA.
   5
   6 This file is part of the GNU MPFR Library.
   7
   8 The GNU MPFR Library is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU Lesser General Public License as published by
  10 the Free Software Foundation; either version 3 of the License, or (at your
  11 option) any later version.
  12
  13 The GNU MPFR Library is distributed in the hope that it will be useful, but
  14 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  15 or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  16 License for more details.
  17
  18 You should have received a copy of the GNU Lesser General Public License
  19 along with the GNU MPFR Library; see the file COPYING.LESSER.  If not, see
  20 http://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
  21 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25
  26 #include "mpfr-test.h"
  27
  28 static void check_special (void);
  29 static void check_random (mpfr_prec_t p);
  30
  31 int
  32 main (void)
  33 {
  34   mpfr_prec_t p;
  35
  36   tests_start_mpfr ();
  37
  38   check_special ();
  39   for (p = 2 ; p < 200 ; p++)
  40     check_random (p);
  41
  42   tests_end_mpfr ();
  43   return 0;
  44 }
  45
  46 #define STD_ERROR                                                       \
  47   do                                                                    \
  48     {                                                                   \
  49       printf("ERROR: for %s and p=%lu and i=%d:\nY=",                   \
  50              mpfr_print_rnd_mode ((mpfr_rnd_t) r), (unsigned long) p, i); \
  51       mpfr_print_binary(y);                                             \
  52       printf("\nZ="); mpfr_print_binary(z);                             \
  53       printf("\nReal: "); mpfr_print_binary(x2);                        \
  54       printf("\nGot : "); mpfr_print_binary(x);                         \
  55       putchar('\n');                                                    \
  56       exit(1);                                                          \
  57     }                                                                   \
  58  while (0)
  59
  60 #define STD_ERROR2                                                      \
  61   do                                                                    \
  62     {                                                                   \
  63       printf("ERROR: for %s and p=%lu and i=%d:\nY=",                   \
  64              mpfr_print_rnd_mode ((mpfr_rnd_t) r), (unsigned long) p, i); \
  65       mpfr_print_binary(y);                                             \
  66       printf("\nZ="); mpfr_print_binary(z);                             \
  67       printf("\nR="); mpfr_print_binary(x);                             \
  68       printf("\nWrong inexact flag. Real: %d. Got: %d\n",               \
  69              inexact1, inexact2);                                       \
  70       exit(1);                                                          \
  71     }                                                                   \
  72  while (0)
  73
  74 static void
  75 check_random (mpfr_prec_t p)
  76 {
  77   mpfr_t x,y,z,x2;
  78   int r;
  79   int i, inexact1, inexact2;
  80
  81   mpfr_inits2 (p, x, y, z, x2, (mpfr_ptr) 0);
  82
  83   for (i = 0 ; i < 500 ; i++)
  84     {
  85       mpfr_urandomb (y, RANDS);
  86       mpfr_urandomb (z, RANDS);
  87       if (MPFR_IS_PURE_FP(y) && MPFR_IS_PURE_FP(z))
  88         for(r = 0 ; r < MPFR_RND_MAX ; r++)
  89           {
  90             inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
  91             inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
  92             if (mpfr_cmp(x, x2))
  93               STD_ERROR;
  94             if (inexact1 != inexact2)
  95               STD_ERROR2;
  96           }
  97     }
  98
  99   mpfr_clears (x, y, z, x2, (mpfr_ptr) 0);
 100 }
 101
 102 static void
 103 check_special (void)
 104 {
 105   mpfr_t x,y,z,x2;
 106   int r;
 107   mpfr_prec_t p;
 108   int i = -1, inexact1, inexact2;
 109   mpfr_exp_t es;
 110
 111   mpfr_inits (x, y, z, x2, (mpfr_ptr) 0);
 112
 113   for (r = 0 ; r < MPFR_RND_MAX ; r++)
 114     {
 115       p = 53;
 116       mpfr_set_prec(x, 53);
 117       mpfr_set_prec(x2, 53);
 118       mpfr_set_prec(y, 53);
 119       mpfr_set_prec(z, 53);
 120
 121       mpfr_set_str_binary (y,
 122        "0.10110111101101110010010010011011000001101101011011001E31");
 123
 124       mpfr_sub1sp (x, y, y, (mpfr_rnd_t) r);
 125       if (mpfr_cmp_ui(x, 0))
 126         {
 127           printf("Error for x-x with p=%lu. Expected 0. Got:",
 128                  (unsigned long) p);
 129           mpfr_print_binary(x);
 130           exit(1);
 131         }
 132
 133       mpfr_set(z, y, (mpfr_rnd_t) r);
 134       mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 135       if (mpfr_cmp_ui(x, 0))
 136         {
 137           printf("Error for x-y with y=x and p=%lu. Expected 0. Got:",
 138                  (unsigned long) p);
 139           mpfr_print_binary(x);
 140           exit(1);
 141         }
 142       /* diff = 0 */
 143       mpfr_set_str_binary (y,
 144        "0.10110111101101110010010010011011001001101101011011001E31");
 145       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 146       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 147       if (mpfr_cmp(x, x2))
 148         STD_ERROR;
 149       if (inexact1 != inexact2)
 150         STD_ERROR2;
 151
 152       /* Diff = 1 */
 153       mpfr_set_str_binary (y,
 154        "0.10110111101101110010010010011011000001101101011011001E30");
 155       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 156       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 157       if (mpfr_cmp(x, x2))
 158         STD_ERROR;
 159       if (inexact1 != inexact2)
 160         STD_ERROR2;
 161
 162       /* Diff = 2 */
 163       mpfr_set_str_binary (y,
 164        "0.10110111101101110010010010011011000101101101011011001E32");
 165       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 166       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 167       if (mpfr_cmp(x, x2))
 168         STD_ERROR;
 169       if (inexact1 != inexact2)
 170         STD_ERROR2;
 171
 172       /* Diff = 32 */
 173       mpfr_set_str_binary (y,
 174        "0.10110111101101110010010010011011000001101101011011001E63");
 175       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 176       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 177       if (mpfr_cmp(x, x2))
 178         STD_ERROR;
 179       if (inexact1 != inexact2)
 180         STD_ERROR2;
 181
 182       /* Diff = 52 */
 183       mpfr_set_str_binary (y,
 184        "0.10110111101101110010010010011011010001101101011011001E83");
 185       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 186       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 187       if (mpfr_cmp(x, x2))
 188         STD_ERROR;
 189       if (inexact1 != inexact2)
 190         STD_ERROR2;
 191
 192       /* Diff = 53 */
 193       mpfr_set_str_binary (y,
 194        "0.10110111101101110010010010011111000001101101011011001E31");
 195       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 196       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 197       if (mpfr_cmp(x, x2))
 198         STD_ERROR;
 199       if (inexact1 != inexact2)
 200         STD_ERROR2;
 201
 202       /* Diff > 200 */
 203       mpfr_set_str_binary (y,
 204        "0.10110111101101110010010010011011000001101101011011001E331");
 205       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 206       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 207       if (mpfr_cmp(x, x2))
 208         STD_ERROR;
 209       if (inexact1 != inexact2)
 210         STD_ERROR2;
 211
 212       mpfr_set_str_binary (y,
 213        "0.10000000000000000000000000000000000000000000000000000E31");
 214       mpfr_set_str_binary (z,
 215        "0.11111111111111111111111111111111111111111111111111111E30");
 216       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 217       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 218       if (mpfr_cmp(x, x2))
 219         STD_ERROR;
 220       if (inexact1 != inexact2)
 221         STD_ERROR2;
 222
 223       mpfr_set_str_binary (y,
 224        "0.10000000000000000000000000000000000000000000000000000E31");
 225       mpfr_set_str_binary (z,
 226        "0.11111111111111111111111111111111111111111111111111111E29");
 227       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 228       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 229       if (mpfr_cmp(x, x2))
 230         STD_ERROR;
 231       if (inexact1 != inexact2)
 232         STD_ERROR2;
 233
 234       mpfr_set_str_binary (y,
 235        "0.10000000000000000000000000000000000000000000000000000E52");
 236       mpfr_set_str_binary (z,
 237        "0.10000000000010000000000000000000000000000000000000000E00");
 238       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 239       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 240       if (mpfr_cmp(x, x2))
 241         STD_ERROR;
 242       if (inexact1 != inexact2)
 243         STD_ERROR2;
 244
 245       mpfr_set_str_binary (y,
 246         "0.11100000000000000000000000000000000000000000000000000E53");
 247       mpfr_set_str_binary (z,
 248         "0.10000000000000000000000000000000000000000000000000000E00");
 249       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 250       inexact2 = mpfr_sub1sp(z, y, z, (mpfr_rnd_t) r);
 251       mpfr_set(x, z, (mpfr_rnd_t) r);
 252       if (mpfr_cmp(x, x2))
 253         STD_ERROR;
 254       if (inexact1 != inexact2)
 255         STD_ERROR2;
 256
 257       mpfr_set_str_binary (y,
 258        "0.10000000000000000000000000000000000000000000000000000E53");
 259       mpfr_set_str_binary (z,
 260        "0.10100000000000000000000000000000000000000000000000000E00");
 261       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 262       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 263       if (mpfr_cmp(x, x2))
 264         STD_ERROR;
 265       if (inexact1 != inexact2)
 266         STD_ERROR2;
 267
 268       mpfr_set_str_binary (y,
 269         "0.10000000000000000000000000000000000000000000000000000E54");
 270       mpfr_set_str_binary (z,
 271         "0.10100000000000000000000000000000000000000000000000000E00");
 272       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 273       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 274       if (mpfr_cmp(x, x2))
 275         STD_ERROR;
 276       if (inexact1 != inexact2)
 277         STD_ERROR2;
 278
 279       p = 63;
 280       mpfr_set_prec(x, p);
 281       mpfr_set_prec(x2, p);
 282       mpfr_set_prec(y, p);
 283       mpfr_set_prec(z, p);
 284       mpfr_set_str_binary (y,
 285       "0.100000000000000000000000000000000000000000000000000000000000000E62");
 286       mpfr_set_str_binary (z,
 287       "0.110000000000000000000000000000000000000000000000000000000000000E00");
 288       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 289       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 290       if (mpfr_cmp(x, x2))
 291         STD_ERROR;
 292       if (inexact1 != inexact2)
 293         STD_ERROR2;
 294
 295       p = 64;
 296       mpfr_set_prec(x, 64);
 297       mpfr_set_prec(x2, 64);
 298       mpfr_set_prec(y, 64);
 299       mpfr_set_prec(z, 64);
 300
 301       mpfr_set_str_binary (y,
 302       "0.1100000000000000000000000000000000000000000000000000000000000000E31");
 303       mpfr_set_str_binary (z,
 304       "0.1111111111111111111111111110000000000000000000000000011111111111E29");
 305       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 306       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 307       if (mpfr_cmp(x, x2))
 308         STD_ERROR;
 309       if (inexact1 != inexact2)
 310         STD_ERROR2;
 311
 312       mpfr_set_str_binary (y,
 313       "0.1000000000000000000000000000000000000000000000000000000000000000E63");
 314       mpfr_set_str_binary (z,
 315       "0.1011000000000000000000000000000000000000000000000000000000000000E00");
 316       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 317       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 318       if (mpfr_cmp(x, x2))
 319         STD_ERROR;
 320       if (inexact1 != inexact2)
 321         STD_ERROR2;
 322
 323       mpfr_set_str_binary (y,
 324       "0.1000000000000000000000000000000000000000000000000000000000000000E63");
 325       mpfr_set_str_binary (z,
 326       "0.1110000000000000000000000000000000000000000000000000000000000000E00");
 327       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 328       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 329       if (mpfr_cmp(x, x2))
 330         STD_ERROR;
 331       if (inexact1 != inexact2)
 332         STD_ERROR2;
 333
 334       mpfr_set_str_binary (y,
 335         "0.10000000000000000000000000000000000000000000000000000000000000E63");
 336       mpfr_set_str_binary (z,
 337         "0.10000000000000000000000000000000000000000000000000000000000000E00");
 338       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 339       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 340       if (mpfr_cmp(x, x2))
 341         STD_ERROR;
 342       if (inexact1 != inexact2)
 343         STD_ERROR2;
 344
 345       mpfr_set_str_binary (y,
 346       "0.1000000000000000000000000000000000000000000000000000000000000000E64");
 347       mpfr_set_str_binary (z,
 348       "0.1010000000000000000000000000000000000000000000000000000000000000E00");
 349       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 350       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 351       if (mpfr_cmp(x, x2))
 352         STD_ERROR;
 353       if (inexact1 != inexact2)
 354         STD_ERROR2;
 355
 356       MPFR_SET_NAN(x);
 357       MPFR_SET_NAN(x2);
 358       mpfr_set_str_binary (y,
 359       "0.1000000000000000000000000000000000000000000000000000000000000000"
 360                           "E-1073741823");
 361       mpfr_set_str_binary (z,
 362       "0.1100000000000000000000000000000000000000000000000000000000000000"
 363                           "E-1073741823");
 364       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 365       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 366       if (mpfr_cmp(x, x2))
 367         STD_ERROR;
 368       if (inexact1 != inexact2)
 369         STD_ERROR2;
 370
 371       p = 9;
 372       mpfr_set_prec(x, p);
 373       mpfr_set_prec(x2, p);
 374       mpfr_set_prec(y, p);
 375       mpfr_set_prec(z, p);
 376
 377       mpfr_set_str_binary (y, "0.100000000E1");
 378       mpfr_set_str_binary (z, "0.100000000E-8");
 379       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 380       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 381       if (mpfr_cmp(x, x2))
 382         STD_ERROR;
 383       if (inexact1 != inexact2)
 384         STD_ERROR2;
 385
 386       p = 34;
 387       mpfr_set_prec(x, p);
 388       mpfr_set_prec(x2, p);
 389       mpfr_set_prec(y, p);
 390       mpfr_set_prec(z, p);
 391
 392       mpfr_set_str_binary (y, "-0.1011110000111100010111011100110100E-18");
 393       mpfr_set_str_binary (z, "0.1000101010110011010101011110000000E-14");
 394       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 395       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 396       if (mpfr_cmp(x, x2))
 397         STD_ERROR;
 398       if (inexact1 != inexact2)
 399         STD_ERROR2;
 400
 401       p = 124;
 402       mpfr_set_prec(x, p);
 403       mpfr_set_prec(x2, p);
 404       mpfr_set_prec(y, p);
 405       mpfr_set_prec(z, p);
 406
 407       mpfr_set_str_binary (y,
 408 "0.1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E1");
 409       mpfr_set_str_binary (z,
 410 "0.1011111000100111000011001000011101010101101100101010101001000001110100001101110110001110111010000011101001100010111110001100E-31");
 411       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 412       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 413       if (mpfr_cmp(x, x2))
 414         STD_ERROR;
 415       if (inexact1 != inexact2)
 416         STD_ERROR2;
 417
 418       p = 288;
 419       mpfr_set_prec(x, p);
 420       mpfr_set_prec(x2, p);
 421       mpfr_set_prec(y, p);
 422       mpfr_set_prec(z, p);
 423
 424       mpfr_set_str_binary (y,
 425      "0.111000110011000001000111101010111011110011101001101111111110000011100101000001001010110010101010011001010100000001110011110001010101101010001011101110100100001011110100110000101101100011010001001011011010101010000010001101001000110010010111111011110001111101001000101101001100101100101000E80");
 426       mpfr_set_str_binary (z,
 427      "-0.100001111111101001011010001100110010100111001110000110011101001011010100001000000100111011010110110010000000000010101101011000010000110001110010100001100101011100100100001011000100011110000001010101000100011101001000010111100000111000111011001000100100011000100000010010111000000100100111E-258");
 428       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 429       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 430       if (mpfr_cmp(x, x2))
 431         STD_ERROR;
 432       if (inexact1 != inexact2)
 433         STD_ERROR2;
 434
 435       p = 85;
 436       mpfr_set_prec(x, p);
 437       mpfr_set_prec(x2, p);
 438       mpfr_set_prec(y, p);
 439       mpfr_set_prec(z, p);
 440
 441       mpfr_set_str_binary (y,
 442 "0.1111101110100110110110100010101011101001100010100011110110110010010011101100101111100E-4");
 443       mpfr_set_str_binary (z,
 444 "0.1111101110100110110110100010101001001000011000111000011101100101110100001110101010110E-4");
 445       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 446       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 447       if (mpfr_cmp(x, x2))
 448         STD_ERROR;
 449       if (inexact1 != inexact2)
 450         STD_ERROR2;
 451
 452       p = 64;
 453       mpfr_set_prec(x, p); mpfr_set_prec(x2, p);
 454       mpfr_set_prec(y, p); mpfr_set_prec(z, p);
 455
 456       mpfr_set_str_binary (y,
 457                           "0.11000000000000000000000000000000"
 458                           "00000000000000000000000000000000E1");
 459       mpfr_set_str_binary (z,
 460                           "0.10000000000000000000000000000000"
 461                           "00000000000000000000000000000001E0");
 462       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 463       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 464       if (mpfr_cmp(x, x2))
 465         STD_ERROR;
 466       if (inexact1 != inexact2)
 467         STD_ERROR2;
 468
 469       mpfr_set_str_binary (y,
 470                           "0.11000000000000000000000000000000"
 471                           "000000000000000000000000000001E1");
 472       mpfr_set_str_binary (z,
 473                           "0.10000000000000000000000000000000"
 474                           "00000000000000000000000000000001E0");
 475       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 476       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 477       if (mpfr_cmp(x, x2))
 478         STD_ERROR;
 479       if (inexact1 != inexact2)
 480         STD_ERROR2;
 481
 482       es = mpfr_get_emin ();
 483       set_emin (-1024);
 484
 485       mpfr_set_str_binary (y,
 486                           "0.10000000000000000000000000000000"
 487                           "000000000000000000000000000000E-1023");
 488       mpfr_set_str_binary (z,
 489                           "0.10000000000000000000000000000000"
 490                           "00000000000000000000000000000001E-1023");
 491       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 492       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 493       if (mpfr_cmp(x, x2))
 494         STD_ERROR;
 495       if (inexact1 != inexact2)
 496         STD_ERROR2;
 497
 498       mpfr_set_str_binary (y,
 499                            "0.10000000000000000000000000000000"
 500                            "000000000000000000000000000000E-1023");
 501       mpfr_set_str_binary (z,
 502                            "0.1000000000000000000000000000000"
 503                            "000000000000000000000000000000E-1023");
 504       inexact1 = mpfr_sub1(x2, y, z, (mpfr_rnd_t) r);
 505       inexact2 = mpfr_sub1sp(x, y, z, (mpfr_rnd_t) r);
 506       if (mpfr_cmp(x, x2))
 507         STD_ERROR;
 508       if (inexact1 != inexact2)
 509         STD_ERROR2;
 510
 511       set_emin (es);
 512     }
 513
 514   mpfr_clears (x, y, z, x2, (mpfr_ptr) 0);
 515 }