开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 数学计算 > 查看源码
t-misc.cc
资源名称：gmp-5.0.1.tar.gz　[点击查看]
上传用户：qaz666999
上传日期：2022-08-06
资源大小：2570k
文件大小：12k
源码类别：

数学计算

开发平台：

Unix_Linux

t-misc.cc：源码内容
  1. /* Test mp*_class functions.
  3. Copyright 2002, 2003 Free Software Foundation, Inc.
  5. This file is part of the GNU MP Library.
  7. The GNU MP Library is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU Lesser General Public License as published by
  9. the Free Software Foundation; either version 3 of the License, or (at your
  10. option) any later version.
  12. The GNU MP Library is distributed in the hope that it will be useful, but
  13. WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14. or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  15. License for more details.
  17. You should have received a copy of the GNU Lesser General Public License
  18. along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.  */
  21. /* Note that we don't use <climits> for LONG_MIN, but instead our own
  22.    definitions in gmp-impl.h.  In g++ 2.95.4 (debian 3.0) under
  23.    -mcpu=ultrasparc, limits.h sees __sparc_v9__ defined and assumes that
  24.    means long is 64-bit long, but it's only 32-bits, causing fatal compile
  25.    errors.  */
  27. #include "config.h"
  29. #include <string>
  31. #include "gmp.h"
  32. #include "gmpxx.h"
  33. #include "gmp-impl.h"
  34. #include "tests.h"
  36. using namespace std;
  39. void
  40. check_mpz (void)
  41. {
  42.   // mpz_class::fits_sint_p
  43.   {
  44.     int        fits;
  45.     mpz_class  z;
  46.     z = INT_MIN; fits = z.fits_sint_p(); ASSERT_ALWAYS (fits);
  47.     z--;         fits = z.fits_sint_p(); ASSERT_ALWAYS (! fits);
  48.     z = INT_MAX; fits = z.fits_sint_p(); ASSERT_ALWAYS (fits);
  49.     z++;         fits = z.fits_sint_p(); ASSERT_ALWAYS (! fits);
  50.   }
  52.   // mpz_class::fits_uint_p
  53.   {
  54.     int        fits;
  55.     mpz_class  z;
  56.     z = 0;        fits = z.fits_uint_p(); ASSERT_ALWAYS (fits);
  57.     z--;          fits = z.fits_uint_p(); ASSERT_ALWAYS (! fits);
  58.     z = UINT_MAX; fits = z.fits_uint_p(); ASSERT_ALWAYS (fits);
  59.     z++;          fits = z.fits_uint_p(); ASSERT_ALWAYS (! fits);
  60.   }
  62.   // mpz_class::fits_slong_p
  63.   {
  64.     int        fits;
  65.     mpz_class  z;
  66.     z = LONG_MIN; fits = z.fits_slong_p(); ASSERT_ALWAYS (fits);
  67.     z--;          fits = z.fits_slong_p(); ASSERT_ALWAYS (! fits);
  68.     z = LONG_MAX; fits = z.fits_slong_p(); ASSERT_ALWAYS (fits);
  69.     z++;          fits = z.fits_slong_p(); ASSERT_ALWAYS (! fits);
  70.   }
  72.   // mpz_class::fits_ulong_p
  73.   {
  74.     int        fits;
  75.     mpz_class  z;
  76.     z = 0;         fits = z.fits_ulong_p(); ASSERT_ALWAYS (fits);
  77.     z--;           fits = z.fits_ulong_p(); ASSERT_ALWAYS (! fits);
  78.     z = ULONG_MAX; fits = z.fits_ulong_p(); ASSERT_ALWAYS (fits);
  79.     z++;           fits = z.fits_ulong_p(); ASSERT_ALWAYS (! fits);
  80.   }
  82.   // mpz_class::fits_sshort_p
  83.   {
  84.     int        fits;
  85.     mpz_class  z;
  86.     z = SHRT_MIN; fits = z.fits_sshort_p(); ASSERT_ALWAYS (fits);
  87.     z--;          fits = z.fits_sshort_p(); ASSERT_ALWAYS (! fits);
  88.     z = SHRT_MAX; fits = z.fits_sshort_p(); ASSERT_ALWAYS (fits);
  89.     z++;          fits = z.fits_sshort_p(); ASSERT_ALWAYS (! fits);
  90.   }
  92.   // mpz_class::fits_ushort_p
  93.   {
  94.     int        fits;
  95.     mpz_class  z;
  96.     z = 0;         fits = z.fits_ushort_p(); ASSERT_ALWAYS (fits);
  97.     z--;           fits = z.fits_ushort_p(); ASSERT_ALWAYS (! fits);
  98.     z = USHRT_MAX; fits = z.fits_ushort_p(); ASSERT_ALWAYS (fits);
  99.     z++;           fits = z.fits_ushort_p(); ASSERT_ALWAYS (! fits);
  100.   }
  102.   // mpz_class::get_mpz_t
  103.   {
  104.     mpz_class  z(0);
  105.     mpz_ptr    p = z.get_mpz_t();
  106.     ASSERT_ALWAYS (mpz_cmp_ui (p, 0) == 0);
  107.   }
  108.   {
  109.     mpz_class  z(0);
  110.     mpz_srcptr p = z.get_mpz_t();
  111.     ASSERT_ALWAYS (mpz_cmp_ui (p, 0) == 0);
  112.   }
  114.   // mpz_class::get_d
  115.   // mpz_class::get_si
  116.   // mpz_class::get_ui
  117.   {
  118.     mpz_class  z(123);
  119.     { double d = z.get_d();  ASSERT_ALWAYS (d == 123.0); }
  120.     { long   l = z.get_si(); ASSERT_ALWAYS (l == 123L); }
  121.     { long   u = z.get_ui(); ASSERT_ALWAYS (u == 123L); }
  122.   }
  123.   {
  124.     mpz_class  z(-123);
  125.     { double d = z.get_d();  ASSERT_ALWAYS (d == -123.0); }
  126.     { long   l = z.get_si(); ASSERT_ALWAYS (l == -123L); }
  127.   }
  129.   // mpz_class::get_str
  130.   {
  131.     mpz_class  z(123);
  132.     string     s;
  133.     s = z.get_str(); ASSERT_ALWAYS (s == "123");
  134.     s = z.get_str(16); ASSERT_ALWAYS (s == "7b");
  135.     s = z.get_str(-16); ASSERT_ALWAYS (s == "7B");
  136.   }
  138.   // mpz_class::set_str
  139.   {
  140.     mpz_class  z;
  141.     int        ret;
  142.     ret = z.set_str ("123", 10);  ASSERT_ALWAYS (ret == 0 && z == 123);
  143.     ret = z.set_str ("7b",  16);  ASSERT_ALWAYS (ret == 0 && z == 123);
  144.     ret = z.set_str ("7B",  16);  ASSERT_ALWAYS (ret == 0 && z == 123);
  145.     ret = z.set_str ("0x7B", 0);  ASSERT_ALWAYS (ret == 0 && z == 123);
  147.     ret = z.set_str (string("123"), 10);  ASSERT_ALWAYS (ret == 0 && z == 123);
  148.     ret = z.set_str (string("7b"),  16);  ASSERT_ALWAYS (ret == 0 && z == 123);
  149.     ret = z.set_str (string("7B"),  16);  ASSERT_ALWAYS (ret == 0 && z == 123);
  150.     ret = z.set_str (string("0x7B"), 0);  ASSERT_ALWAYS (ret == 0 && z == 123);
  151.   }
  152. }
  154. void
  155. check_mpq (void)
  156. {
  157.   // mpq_class::canonicalize
  158.   {
  159.     mpq_class  q(12,9);
  160.     q.canonicalize();
  161.     ASSERT_ALWAYS (q.get_num() == 4);
  162.     ASSERT_ALWAYS (q.get_den() == 3);
  163.   }
  165.   // mpq_class::get_d
  166.   {
  167.     mpq_class  q(123);
  168.     { double d = q.get_d();  ASSERT_ALWAYS (d == 123.0); }
  169.   }
  170.   {
  171.     mpq_class  q(-123);
  172.     { double d = q.get_d();  ASSERT_ALWAYS (d == -123.0); }
  173.   }
  175.   // mpq_class::get_mpq_t
  176.   {
  177.     mpq_class  q(0);
  178.     mpq_ptr    p = q.get_mpq_t();
  179.     ASSERT_ALWAYS (mpq_cmp_ui (p, 0, 1) == 0);
  180.   }
  181.   {
  182.     mpq_class  q(0);
  183.     mpq_srcptr p = q.get_mpq_t();
  184.     ASSERT_ALWAYS (mpq_cmp_ui (p, 0, 1) == 0);
  185.   }
  187.   // mpq_class::get_num, mpq_class::get_den
  188.   {
  189.     mpq_class  q(4,5);
  190.     mpz_class  z;
  191.     z = q.get_num(); ASSERT_ALWAYS (z == 4);
  192.     z = q.get_den(); ASSERT_ALWAYS (z == 5);
  193.   }
  195.   // mpq_class::get_num_mpz_t, mpq_class::get_den_mpz_t
  196.   {
  197.     mpq_class  q(4,5);
  198.     mpz_ptr    p;
  199.     p = q.get_num_mpz_t(); ASSERT_ALWAYS (mpz_cmp_ui (p, 4) == 0);
  200.     p = q.get_den_mpz_t(); ASSERT_ALWAYS (mpz_cmp_ui (p, 5) == 0);
  201.   }
  202.   {
  203.     mpq_class  q(4,5);
  204.     mpz_srcptr p;
  205.     p = q.get_num_mpz_t(); ASSERT_ALWAYS (mpz_cmp_ui (p, 4) == 0);
  206.     p = q.get_den_mpz_t(); ASSERT_ALWAYS (mpz_cmp_ui (p, 5) == 0);
  207.   }
  209.   // mpq_class::get_str
  210.   {
  211.     mpq_class  q(17,11);
  212.     string     s;
  213.     s = q.get_str();    ASSERT_ALWAYS (s == "17/11");
  214.     s = q.get_str(10);  ASSERT_ALWAYS (s == "17/11");
  215.     s = q.get_str(16);  ASSERT_ALWAYS (s == "11/b");
  216.     s = q.get_str(-16); ASSERT_ALWAYS (s == "11/B");
  217.   }
  219.   // mpq_class::set_str
  220.   {
  221.     mpq_class  q;
  222.     int        ret;
  223.     ret = q.set_str ("123", 10);     ASSERT_ALWAYS (ret == 0 && q == 123);
  224.     ret = q.set_str ("4/5", 10);     ASSERT_ALWAYS (ret == 0 && q == mpq_class(4,5));
  225.     ret = q.set_str ("7b",  16);     ASSERT_ALWAYS (ret == 0 && q == 123);
  226.     ret = q.set_str ("7B",  16);     ASSERT_ALWAYS (ret == 0 && q == 123);
  227.     ret = q.set_str ("0x7B", 0);     ASSERT_ALWAYS (ret == 0 && q == 123);
  228.     ret = q.set_str ("0x10/17", 0);  ASSERT_ALWAYS (ret == 0 && q == mpq_class(16,17));
  230.     ret = q.set_str (string("4/5"), 10);  ASSERT_ALWAYS (ret == 0 && q == mpq_class(4,5));
  231.     ret = q.set_str (string("123"), 10);  ASSERT_ALWAYS (ret == 0 && q == 123);
  232.     ret = q.set_str (string("7b"),  16);  ASSERT_ALWAYS (ret == 0 && q == 123);
  233.     ret = q.set_str (string("7B"),  16);  ASSERT_ALWAYS (ret == 0 && q == 123);
  234.     ret = q.set_str (string("0x7B"), 0);  ASSERT_ALWAYS (ret == 0 && q == 123);
  235.     ret = q.set_str (string("0x10/17"), 0);  ASSERT_ALWAYS (ret == 0 && q == mpq_class(16,17));
  236.   }
  237. }
  239. void
  240. check_mpf (void)
  241. {
  242.   // mpf_class::fits_sint_p
  243.   {
  244.     int        fits;
  245.     mpf_class  f (0, 2*8*sizeof(int));
  246.     f = INT_MIN; fits = f.fits_sint_p(); ASSERT_ALWAYS (fits);
  247.     f--;         fits = f.fits_sint_p(); ASSERT_ALWAYS (! fits);
  248.     f = INT_MAX; fits = f.fits_sint_p(); ASSERT_ALWAYS (fits);
  249.     f++;         fits = f.fits_sint_p(); ASSERT_ALWAYS (! fits);
  250.   }
  252.   // mpf_class::fits_uint_p
  253.   {
  254.     int        fits;
  255.     mpf_class  f (0, 2*8*sizeof(int));
  256.     f = 0;        fits = f.fits_uint_p(); ASSERT_ALWAYS (fits);
  257.     f--;          fits = f.fits_uint_p(); ASSERT_ALWAYS (! fits);
  258.     f = UINT_MAX; fits = f.fits_uint_p(); ASSERT_ALWAYS (fits);
  259.     f++;          fits = f.fits_uint_p(); ASSERT_ALWAYS (! fits);
  260.   }
  262.   // mpf_class::fits_slong_p
  263.   {
  264.     int        fits;
  265.     mpf_class  f (0, 2*8*sizeof(long));
  266.     f = LONG_MIN; fits = f.fits_slong_p(); ASSERT_ALWAYS (fits);
  267.     f--;          fits = f.fits_slong_p(); ASSERT_ALWAYS (! fits);
  268.     f = LONG_MAX; fits = f.fits_slong_p(); ASSERT_ALWAYS (fits);
  269.     f++;          fits = f.fits_slong_p(); ASSERT_ALWAYS (! fits);
  270.   }
  272.   // mpf_class::fits_ulong_p
  273.   {
  274.     int        fits;
  275.     mpf_class  f (0, 2*8*sizeof(long));
  276.     f = 0;         fits = f.fits_ulong_p(); ASSERT_ALWAYS (fits);
  277.     f--;           fits = f.fits_ulong_p(); ASSERT_ALWAYS (! fits);
  278.     f = ULONG_MAX; fits = f.fits_ulong_p(); ASSERT_ALWAYS (fits);
  279.     f++;           fits = f.fits_ulong_p(); ASSERT_ALWAYS (! fits);
  280.   }
  282.   // mpf_class::fits_sshort_p
  283.   {
  284.     int        fits;
  285.     mpf_class  f (0, 2*8*sizeof(short));
  286.     f = SHRT_MIN; fits = f.fits_sshort_p(); ASSERT_ALWAYS (fits);
  287.     f--;          fits = f.fits_sshort_p(); ASSERT_ALWAYS (! fits);
  288.     f = SHRT_MAX; fits = f.fits_sshort_p(); ASSERT_ALWAYS (fits);
  289.     f++;          fits = f.fits_sshort_p(); ASSERT_ALWAYS (! fits);
  290.   }
  292.   // mpf_class::fits_ushort_p
  293.   {
  294.     int        fits;
  295.     mpf_class  f (0, 2*8*sizeof(short));
  296.     f = 0;         fits = f.fits_ushort_p(); ASSERT_ALWAYS (fits);
  297.     f--;           fits = f.fits_ushort_p(); ASSERT_ALWAYS (! fits);
  298.     f = USHRT_MAX; fits = f.fits_ushort_p(); ASSERT_ALWAYS (fits);
  299.     f++;           fits = f.fits_ushort_p(); ASSERT_ALWAYS (! fits);
  300.   }
  302.   // mpf_class::get_d
  303.   // mpf_class::get_si
  304.   // mpf_class::get_ui
  305.   {
  306.     mpf_class  f(123);
  307.     { double d = f.get_d();  ASSERT_ALWAYS (d == 123.0); }
  308.     { long   l = f.get_si(); ASSERT_ALWAYS (l == 123L); }
  309.     { long   u = f.get_ui(); ASSERT_ALWAYS (u == 123L); }
  310.   }
  311.   {
  312.     mpf_class  f(-123);
  313.     { double d = f.get_d();  ASSERT_ALWAYS (d == -123.0); }
  314.     { long   l = f.get_si(); ASSERT_ALWAYS (l == -123L); }
  315.   }
  317.   // mpf_class::get_prec
  318.   {
  319.     mpf_class  f;
  320.     ASSERT_ALWAYS (f.get_prec() == mpf_get_default_prec());
  321.   }
  323.   // mpf_class::get_str
  324.   {
  325.     mpf_class  f(123);
  326.     string     s;
  327.     mp_exp_t   e;
  328.     s = f.get_str(e);        ASSERT_ALWAYS (s == "123" && e == 3);
  329.     s = f.get_str(e,  16);   ASSERT_ALWAYS (s == "7b"  && e == 2);
  330.     s = f.get_str(e, -16);   ASSERT_ALWAYS (s == "7B"  && e == 2);
  331.     s = f.get_str(e, 10, 2); ASSERT_ALWAYS (s == "12"  && e == 3);
  332.     s = f.get_str(e, 10, 1); ASSERT_ALWAYS (s == "1"   && e == 3);
  333.   }
  335.   // mpf_class::set_str
  336.   {
  337.     mpf_class  f;
  338.     int        ret;
  339.     ret = f.set_str ("123",     10);  ASSERT_ALWAYS (ret == 0 && f == 123);
  340.     ret = f.set_str ("123e1",   10);  ASSERT_ALWAYS (ret == 0 && f == 1230);
  341.     ret = f.set_str ("1230e-1", 10);  ASSERT_ALWAYS (ret == 0 && f == 123);
  342.     ret = f.set_str ("7b",      16);  ASSERT_ALWAYS (ret == 0 && f == 123);
  343.     ret = f.set_str ("7B",      16);  ASSERT_ALWAYS (ret == 0 && f == 123);
  344.     ret = f.set_str ("7B@1",    16);  ASSERT_ALWAYS (ret == 0 && f == 1968);
  345.     ret = f.set_str ("7B0@-1",  16);  ASSERT_ALWAYS (ret == 0 && f == 123);
  347.     ret = f.set_str (string("123"),     10);  ASSERT_ALWAYS (ret == 0 && f == 123);
  348.     ret = f.set_str (string("123e1"),   10);  ASSERT_ALWAYS (ret == 0 && f == 1230);
  349.     ret = f.set_str (string("1230e-1"), 10);  ASSERT_ALWAYS (ret == 0 && f == 123);
  350.     ret = f.set_str (string("7b"),      16);  ASSERT_ALWAYS (ret == 0 && f == 123);
  351.     ret = f.set_str (string("7B"),      16);  ASSERT_ALWAYS (ret == 0 && f == 123);
  352.     ret = f.set_str (string("7B@1"),    16);  ASSERT_ALWAYS (ret == 0 && f == 1968);
  353.     ret = f.set_str (string("7B0@-1"),  16);  ASSERT_ALWAYS (ret == 0 && f == 123);
  354.   }
  356.   // mpf_class::set_prec
  357.   {
  358.     mpf_class  f;
  359.     f.set_prec (256);
  360.     ASSERT_ALWAYS (f.get_prec () >= 256);
  361.   }
  363.   // mpf_class::set_prec_raw
  364.   {
  365.     mpf_class  f (0, 100 * GMP_NUMB_BITS);
  366.     f.set_prec_raw (5 * GMP_NUMB_BITS);
  367.     ASSERT_ALWAYS (f.get_prec () >= 5 * GMP_NUMB_BITS);
  368.     ASSERT_ALWAYS (f.get_prec () < 100 * GMP_NUMB_BITS);
  369.     f.set_prec_raw (100 * GMP_NUMB_BITS);
  370.   }
  371. }
  374. int
  375. main (void)
  376. {
  377.   tests_start();
  379.   check_mpz();
  380.   check_mpq();
  381.   check_mpf();
  383.   tests_end();
  384.   return 0;
  385. }