t-constants.c
上传用户:qaz666999
上传日期:2022-08-06
资源大小:2570k
文件大小:13k
源码类别:

数学计算

开发平台:

Unix_Linux

  1. /* Check the values of some constants.
  2. Copyright 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
  3. This file is part of the GNU MP Library.
  4. The GNU MP Library is free software; you can redistribute it and/or modify
  5. it under the terms of the GNU Lesser General Public License as published by
  6. the Free Software Foundation; either version 3 of the License, or (at your
  7. option) any later version.
  8. The GNU MP Library is distributed in the hope that it will be useful, but
  9. WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  10. or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  11. License for more details.
  12. You should have received a copy of the GNU Lesser General Public License
  13. along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.  */
  14. #include <stdio.h>
  15. #include <stdlib.h>
  16. #include "gmp.h"
  17. #include "tests.h"
  18. #ifdef ULONG_MAX
  19. char *ulong_max_def = "defined";
  20. #else
  21. char *ulong_max_def = "not defined";
  22. #endif
  23. #ifdef LONG_MAX
  24. char *long_max_def = "defined";
  25. #else
  26. char *long_max_def = "not defined";
  27. #endif
  28. #ifdef UINT_MAX
  29. char *uint_max_def = "defined";
  30. #else
  31. char *uint_max_def = "not defined";
  32. #endif
  33. #ifdef INT_MAX
  34. char *int_max_def = "defined";
  35. #else
  36. char *int_max_def = "not defined";
  37. #endif
  38. #ifdef USHRT_MAX
  39. char *ushrt_max_def = "defined";
  40. #else
  41. char *ushrt_max_def = "not defined";
  42. #endif
  43. #ifdef SHRT_MAX
  44. char *shrt_max_def = "defined";
  45. #else
  46. char *shrt_max_def = "not defined";
  47. #endif
  48. #include "gmp-impl.h"
  49. #include "longlong.h"
  50. #ifdef _LONG_LONG_LIMB
  51. #define LL(l,ll)  ll
  52. #else
  53. #define LL(l,ll)  l
  54. #endif
  55. #if __GMP_MP_SIZE_T_INT
  56. #define SS(i,l)   i
  57. #else
  58. #define SS(i,l)   l
  59. #endif
  60. #define CHECK_LIMB_S(x, xname, y, yname)                
  61.   do {                                                  
  62.     if ((x) != (y))                                     
  63.       {                                                 
  64.         printf (LL("%s == %lx, but %s == %lxn",        
  65.                    "%s == %llx, but %s == %llxn"),     
  66.                 xname, x, yname, y);                    
  67.         error = 1;                                      
  68.       }                                                 
  69.   } while (0)
  70. #define CHECK_INT_S(x, xname, y, yname)                                 
  71.   do {                                                                  
  72.     if ((x) != (y))                                                     
  73.       {                                                                 
  74.         printf ("%s == %d, but %s == %dn", xname, x, yname, y);        
  75.         error = 1;                                                      
  76.       }                                                                 
  77.   } while (0)
  78. #define CHECK_CONDITION_S(x, xname)             
  79.   do {                                          
  80.     if (!(x))                                   
  81.       {                                         
  82.         printf ("%s is falsen", xname);        
  83.         error = 1;                              
  84.       }                                         
  85.   } while (0)
  86. /* How many bits seem to work in the given type. */
  87. #define CALC_BITS(result, type) 
  88.   do {                          
  89.     type  n = 1;                
  90.     result = 0;                 
  91.     while (n != 0)              
  92.       {                         
  93.         n <<= 1;                
  94.         result++;               
  95.       }                         
  96.   } while (0)
  97. #define CHECK_BITS_S(constant, constant_name, type)     
  98.   do {                                                  
  99.     int   calculated;                                   
  100.     CALC_BITS (calculated, type);                       
  101.     if (calculated != constant)                         
  102.       {                                                 
  103.         printf ("%s == %d, but calculated %dn",        
  104.                 constant_name, constant, calculated);   
  105.         error = 1;                                      
  106.       }                                                 
  107.   } while (0)
  108. #define CHECK_HIGHBIT_S(value, value_name, type, format)        
  109.   do {                                                          
  110.     type  n = value;                                            
  111.     if (n == 0)                                                 
  112.       {                                                         
  113.         printf ("%s == 0n", value_name);                       
  114.         error = 1;                                              
  115.       }                                                         
  116.     n <<= 1;                                                    
  117.     if (n != 0)                                                 
  118.       {                                                         
  119.         printf ("%s << 1 = ", value_name);                      
  120.         printf (format, n);                                     
  121.         printf (" != 0n");                                     
  122.         error = 1;                                              
  123.       }                                                         
  124.   } while (0)
  125. #define CHECK_MAX_S(max_val, max_name, min_val, min_name, type, format) 
  126.   do {                                                                  
  127.     type  maxval = max_val;                                             
  128.     type  minval = min_val;                                             
  129.     type  n = maxval;                                                   
  130.     n++;                                                                
  131.     if (n != minval)                                                    
  132.       {                                                                 
  133.         printf ("%s + 1 = ", max_name);                                 
  134.         printf (format, n);                                             
  135.         printf (" != %s = ", min_name);                                 
  136.         printf (format, minval);                                        
  137.         printf ("n");                                                  
  138.         error = 1;                                                      
  139.       }                                                                 
  140.     if (maxval <= minval)                                               
  141.       {                                                                 
  142.         printf ("%s = ", max_name);                                     
  143.         printf (format, maxval);                                        
  144.         printf (" <= %s = ", min_name);                                 
  145.         printf (format, minval);                                        
  146.         printf ("n");                                                  
  147.         error = 1;                                                      
  148.       }                                                                 
  149.   } while (0)
  150. #if HAVE_STRINGIZE
  151. #define CHECK_LIMB(x,y)      CHECK_LIMB_S (x, #x, y, #y)
  152. #define CHECK_INT(x,y)       CHECK_INT_S (x, #x, y, #y)
  153. #define CHECK_CONDITION(x)   CHECK_CONDITION_S (x, #x)
  154. #define CHECK_BITS(c,t)      CHECK_BITS_S (c, #c, t)
  155. #define CHECK_MAX(m,n,t,f)   CHECK_MAX_S (m, #m, n, #n, t, f)
  156. #define CHECK_HIGHBIT(n,t,f) CHECK_HIGHBIT_S (n, #n, t, f)
  157. #else
  158. #define CHECK_LIMB(x,y)      CHECK_LIMB_S (x, "x", y, "y")
  159. #define CHECK_INT(x,y)       CHECK_INT_S (x, "x", y, "y")
  160. #define CHECK_CONDITION(x)   CHECK_CONDITION_S (x, "x")
  161. #define CHECK_BITS(c,t)      CHECK_BITS_S (c, "c", t)
  162. #define CHECK_MAX(m,n,t,f)   CHECK_MAX_S (m, "m", n, "n", t, f)
  163. #define CHECK_HIGHBIT(n,t,f) CHECK_HIGHBIT_S (n, "n", t, f)
  164. #endif
  165. /* The tests below marked "Bad!" fail on Cray T90 systems, where int, short
  166.    and mp_size_t are 48 bits or some such but don't wraparound in a plain
  167.    twos complement fashion.  In particular,
  168.        INT_HIGHBIT << 1 = 0xFFFFC00000000000 != 0
  169.        INT_MAX + 1 = 35184372088832 != INT_MIN = -35184372088832
  170.    This is a bit bizarre, but doesn't matter because GMP doesn't rely on any
  171.    particular overflow behaviour for int or short, only for mp_limb_t.  */
  172. int
  173. main (int argc, char *argv[])
  174. {
  175.   int  error = 0;
  176.   CHECK_INT (BYTES_PER_MP_LIMB, (int) sizeof(mp_limb_t));
  177.   CHECK_INT (mp_bits_per_limb, GMP_LIMB_BITS);
  178.   CHECK_BITS (GMP_LIMB_BITS, mp_limb_t);
  179.   CHECK_BITS (BITS_PER_ULONG, unsigned long);
  180.   CHECK_HIGHBIT (GMP_LIMB_HIGHBIT, mp_limb_t,      LL("0x%lX","0x%llX"));
  181.   CHECK_HIGHBIT (ULONG_HIGHBIT,     unsigned long,  "0x%lX");
  182.   CHECK_HIGHBIT (UINT_HIGHBIT,      unsigned int,   "0x%X");
  183.   CHECK_HIGHBIT (USHRT_HIGHBIT,     unsigned short, "0x%hX");
  184.   CHECK_HIGHBIT (LONG_HIGHBIT,      long,           "0x%lX");
  185. #if 0 /* Bad! */
  186.   CHECK_HIGHBIT (INT_HIGHBIT,       int,            "0x%X");
  187.   CHECK_HIGHBIT (SHRT_HIGHBIT,      short,          "0x%hX");
  188. #endif
  189. #if 0 /* Bad! */
  190.   CHECK_MAX (LONG_MAX,      LONG_MIN,      long,           "%ld");
  191.   CHECK_MAX (INT_MAX,       INT_MIN,       int,            "%d");
  192.   CHECK_MAX (SHRT_MAX,      SHRT_MIN,      short,          "%hd");
  193. #endif
  194.   CHECK_MAX (ULONG_MAX,     0,             unsigned long,  "%lu");
  195.   CHECK_MAX (UINT_MAX,      0,             unsigned int,   "%u");
  196.   CHECK_MAX (USHRT_MAX,     0,             unsigned short, "%hu");
  197. #if 0 /* Bad! */
  198.   CHECK_MAX (MP_SIZE_T_MAX, MP_SIZE_T_MIN, mp_size_t,      SS("%d","%ld"));
  199. #endif
  200.   /* UHWtype should have at least enough bits for half a UWtype */
  201.   {
  202.     int  bits_per_UWtype, bits_per_UHWtype;
  203.     CALC_BITS (bits_per_UWtype,  UWtype);
  204.     CALC_BITS (bits_per_UHWtype, UHWtype);
  205.     CHECK_CONDITION (2*bits_per_UHWtype >= bits_per_UWtype);
  206.   }
  207.   ASSERT_ALWAYS_LIMB (MODLIMB_INVERSE_3);
  208.   {
  209.     mp_limb_t  modlimb_inverse_3_calc;
  210.     binvert_limb (modlimb_inverse_3_calc, CNST_LIMB(3));
  211.     ASSERT_ALWAYS_LIMB (modlimb_inverse_3_calc);
  212.     CHECK_LIMB (MODLIMB_INVERSE_3, modlimb_inverse_3_calc);
  213.   }
  214.   {
  215.     mp_limb_t  MODLIMB_INVERSE_3_times_3
  216.       = (MODLIMB_INVERSE_3 * CNST_LIMB(3)) & GMP_NUMB_MASK;
  217.     CHECK_LIMB (MODLIMB_INVERSE_3_times_3, CNST_LIMB(1));
  218.   }
  219.   {
  220.     mp_limb_t  hi, lo;
  221.     hi = refmpn_umul_ppmm (&lo, GMP_NUMB_CEIL_MAX_DIV3-1,
  222.                            CNST_LIMB(3) << GMP_NAIL_BITS);
  223.     if (! (hi < 1))
  224.       {
  225.         printf ("GMP_NUMB_CEIL_MAX_DIV3 too bign");
  226.         error = 1;
  227.       }
  228.     hi = refmpn_umul_ppmm (&lo, GMP_NUMB_CEIL_MAX_DIV3,
  229.                            CNST_LIMB(3) << GMP_NAIL_BITS);
  230.     if (! (hi >= 1))
  231.       {
  232.         printf ("GMP_NUMB_CEIL_MAX_DIV3 too smalln");
  233.         error = 1;
  234.       }
  235.   }
  236.   {
  237.     mp_limb_t  hi, lo;
  238.     hi = refmpn_umul_ppmm (&lo, GMP_NUMB_CEIL_2MAX_DIV3-1,
  239.                            CNST_LIMB(3) << GMP_NAIL_BITS);
  240.     if (! (hi < 2))
  241.       {
  242.         printf ("GMP_NUMB_CEIL_2MAX_DIV3 too bign");
  243.         error = 1;
  244.       }
  245.     hi = refmpn_umul_ppmm (&lo, GMP_NUMB_CEIL_2MAX_DIV3,
  246.                            CNST_LIMB(3) << GMP_NAIL_BITS);
  247.     if (! (hi >= 2))
  248.       {
  249.         printf ("GMP_NUMB_CEIL_2MAX_DIV3 too smalln");
  250.         error = 1;
  251.       }
  252.   }
  253. #ifdef PP_INVERTED
  254.   {
  255.     mp_limb_t  pp_inverted_calc;
  256.     invert_limb (pp_inverted_calc, PP);
  257.     CHECK_LIMB (PP_INVERTED, pp_inverted_calc);
  258.   }
  259. #endif
  260.   if (argc >= 2 || error)
  261.     {
  262.       int  bits;
  263.       printf ("n");
  264.       printf ("After gmp.h,n");
  265.       printf ("  ULONG_MAX  %sn", ulong_max_def);
  266.       printf ("  LONG_MAX   %sn", long_max_def);
  267.       printf ("  UINT_MAX   %sn", uint_max_def);
  268.       printf ("  INT_MAX    %sn", int_max_def);
  269.       printf ("  USHRT_MAX  %sn", ushrt_max_def);
  270.       printf ("  SHRT_MAX   %sn", shrt_max_def);
  271.       printf ("n");
  272. #ifdef _CRAY
  273.       printf ("_CRAY is defined, so limits.h is being usedn");
  274. #endif
  275.       printf ("ULONG_MAX      %lXn", ULONG_MAX);
  276.       printf ("ULONG_HIGHBIT  %lXn", ULONG_HIGHBIT);
  277.       printf ("LONG_MAX       %lXn", LONG_MAX);
  278.       printf ("LONG_MIN       %lXn", LONG_MIN);
  279.       printf ("UINT_MAX       %Xn", UINT_MAX);
  280.       printf ("UINT_HIGHBIT   %Xn", UINT_HIGHBIT);
  281.       printf ("INT_MAX        %Xn", INT_MAX);
  282.       printf ("INT_MIN        %Xn", INT_MIN);
  283.       printf ("USHRT_MAX      %hXn", USHRT_MAX);
  284.       printf ("USHRT_HIGHBIT  %hXn", USHRT_HIGHBIT);
  285.       printf ("SHRT_MAX       %hXn", SHRT_MAX);
  286.       printf ("SHRT_MIN       %hXn", SHRT_MIN);
  287.       printf ("n");
  288.       printf ("Bitsn");
  289.       CALC_BITS (bits, long);           printf ("  long           %dn", bits);
  290.       CALC_BITS (bits, int);            printf ("  int            %dn", bits);
  291.       CALC_BITS (bits, short);          printf ("  short          %dn", bits);
  292.       CALC_BITS (bits, unsigned long);  printf ("  unsigned long  %dn", bits);
  293.       CALC_BITS (bits, unsigned int);   printf ("  unsigned int   %dn", bits);
  294.       CALC_BITS (bits, unsigned short); printf ("  unsigned short %dn", bits);
  295.       CALC_BITS (bits, mp_size_t);      printf ("  mp_size_t      %dn", bits);
  296.     }
  297.   if (error)
  298.     abort ();
  299.   exit (0);
  300. }