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

数学计算

开发平台:

Unix_Linux

  1. /* Test mp*_class constructors.
  2. Copyright 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 "config.h"
  15. #include <iostream>
  16. #include <string>
  17. #include "gmp.h"
  18. #include "gmpxx.h"
  19. #include "gmp-impl.h"
  20. #include "tests.h"
  21. using namespace std;
  22. void
  23. check_mpz (void)
  24. {
  25.   // mpz_class()
  26.   {
  27.     mpz_class a; ASSERT_ALWAYS(a == 0);
  28.   }
  29.   // mpz_class(const mpz_class &)
  30.   // see below
  31.   // template <class T, class U> mpz_class(const __gmp_expr<T, U> &)
  32.   // not tested here, see t-unary.cc, t-binary.cc
  33.   // mpz_class(signed char)
  34.   {
  35.     signed char a = -127;
  36.     mpz_class b(a); ASSERT_ALWAYS(b == -127);
  37.   }
  38.   // mpz_class(unsigned char)
  39.   {
  40.     unsigned char a = 255;
  41.     mpz_class b(a); ASSERT_ALWAYS(b == 255);
  42.   }
  43.   // either signed or unsigned char, machine dependent
  44.   {
  45.     mpz_class a('A'); ASSERT_ALWAYS(a == 65);
  46.   }
  47.   {
  48.     mpz_class a('z'); ASSERT_ALWAYS(a == 122);
  49.   }
  50.   // mpz_class(signed int)
  51.   {
  52.     signed int a = 0;
  53.     mpz_class b(a); ASSERT_ALWAYS(b == 0);
  54.   }
  55.   {
  56.     signed int a = -123;
  57.     mpz_class b(a); ASSERT_ALWAYS(b == -123);
  58.   }
  59.   {
  60.     signed int a = 4567;
  61.     mpz_class b(a); ASSERT_ALWAYS(b == 4567);
  62.   }
  63.   // mpz_class(unsigned int)
  64.   {
  65.     unsigned int a = 890;
  66.     mpz_class b(a); ASSERT_ALWAYS(b == 890);
  67.   }
  68.   // mpz_class(signed short int)
  69.   {
  70.     signed short int a = -12345;
  71.     mpz_class b(a); ASSERT_ALWAYS(b == -12345);
  72.   }
  73.   // mpz_class(unsigned short int)
  74.   {
  75.     unsigned short int a = 54321u;
  76.     mpz_class b(a); ASSERT_ALWAYS(b == 54321u);
  77.   }
  78.   // mpz_class(signed long int)
  79.   {
  80.     signed long int a = -1234567890L;
  81.     mpz_class b(a); ASSERT_ALWAYS(b == -1234567890L);
  82.   }
  83.   // mpz_class(unsigned long int)
  84.   {
  85.     unsigned long int a = 1UL << 30;
  86.     mpz_class b(a); ASSERT_ALWAYS(b == 1073741824L);
  87.   }
  88.   // mpz_class(float)
  89.   {
  90.     float a = 123.45;
  91.     mpz_class b(a); ASSERT_ALWAYS(b == 123);
  92.   }
  93.   // mpz_class(double)
  94.   {
  95.     double a = 3.141592653589793238;
  96.     mpz_class b(a); ASSERT_ALWAYS(b == 3);
  97.   }
  98.   // mpz_class(long double)
  99.   // currently not implemented
  100.   // mpz_class(const char *)
  101.   {
  102.     const char *a = "1234567890";
  103.     mpz_class b(a); ASSERT_ALWAYS(b == 1234567890L);
  104.   }
  105.   // mpz_class(const char *, int)
  106.   {
  107.     const char *a = "FFFF";
  108.     int base = 16;
  109.     mpz_class b(a, base); ASSERT_ALWAYS(b == 65535u);
  110.   }
  111.   // mpz_class(const std::string &)
  112.   {
  113.     string a("1234567890");
  114.     mpz_class b(a); ASSERT_ALWAYS(b == 1234567890L);
  115.   }
  116.   // mpz_class(const std::string &, int)
  117.   {
  118.     string a("7777");
  119.     int base = 8;
  120.     mpz_class b(a, base); ASSERT_ALWAYS(b == 4095);
  121.   }
  122.   // mpz_class(const char *) with invalid
  123.   {
  124.     try {
  125.       const char *a = "ABC";
  126.       mpz_class b(a);
  127.       ASSERT_ALWAYS (0);  /* should not be reached */
  128.     } catch (invalid_argument) {
  129.     }
  130.   }
  131.   // mpz_class(const char *, int) with invalid
  132.   {
  133.     try {
  134.       const char *a = "GHI";
  135.       int base = 16;
  136.       mpz_class b(a, base);
  137.       ASSERT_ALWAYS (0);  /* should not be reached */
  138.     } catch (invalid_argument) {
  139.     }
  140.   }
  141.   // mpz_class(const std::string &) with invalid
  142.   {
  143.     try {
  144.       string a("abc");
  145.       mpz_class b(a);
  146.       ASSERT_ALWAYS (0);  /* should not be reached */
  147.     } catch (invalid_argument) {
  148.     }
  149.   }
  150.   // mpz_class(const std::string &, int) with invalid
  151.   {
  152.     try {
  153.       string a("ZZZ");
  154.       int base = 8;
  155.       mpz_class b(a, base);
  156.       ASSERT_ALWAYS (0);  /* should not be reached */
  157.     } catch (invalid_argument) {
  158.     }
  159.   }
  160.   // mpz_class(mpz_srcptr)
  161.   {
  162.     mpz_t a;
  163.     mpz_init_set_ui(a, 100);
  164.     mpz_class b(a); ASSERT_ALWAYS(b == 100);
  165.     mpz_clear(a);
  166.   }
  167.   // mpz_class(const mpz_class &)
  168.   {
  169.     mpz_class a(12345); // tested above, assume it works
  170.     mpz_class b(a); ASSERT_ALWAYS(b == 12345);
  171.   }
  172.   // no constructor for bool, but it gets casted to int
  173.   {
  174.     bool a = true;
  175.     mpz_class b(a); ASSERT_ALWAYS(b == 1);
  176.   }
  177.   {
  178.     bool a = false;
  179.     mpz_class b(a); ASSERT_ALWAYS(b == 0);
  180.   }
  181. }
  182. void
  183. check_mpq (void)
  184. {
  185.   // mpq_class()
  186.   {
  187.     mpq_class a; ASSERT_ALWAYS(a == 0);
  188.   }
  189.   // mpq_class(const mpq_class &)
  190.   // see below
  191.   // template <class T, class U> mpq_class(const __gmp_expr<T, U> &)
  192.   // not tested here, see t-unary.cc, t-binary.cc
  193.   // mpq_class(signed char)
  194.   {
  195.     signed char a = -127;
  196.     mpq_class b(a); ASSERT_ALWAYS(b == -127);
  197.   }
  198.   // mpq_class(unsigned char)
  199.   {
  200.     unsigned char a = 255;
  201.     mpq_class b(a); ASSERT_ALWAYS(b == 255);
  202.   }
  203.   // either signed or unsigned char, machine dependent
  204.   {
  205.     mpq_class a('A'); ASSERT_ALWAYS(a == 65);
  206.   }
  207.   {
  208.     mpq_class a('z'); ASSERT_ALWAYS(a == 122);
  209.   }
  210.   // mpq_class(signed int)
  211.   {
  212.     signed int a = 0;
  213.     mpq_class b(a); ASSERT_ALWAYS(b == 0);
  214.   }
  215.   {
  216.     signed int a = -123;
  217.     mpq_class b(a); ASSERT_ALWAYS(b == -123);
  218.   }
  219.   {
  220.     signed int a = 4567;
  221.     mpq_class b(a); ASSERT_ALWAYS(b == 4567);
  222.   }
  223.   // mpq_class(unsigned int)
  224.   {
  225.     unsigned int a = 890;
  226.     mpq_class b(a); ASSERT_ALWAYS(b == 890);
  227.   }
  228.   // mpq_class(signed short int)
  229.   {
  230.     signed short int a = -12345;
  231.     mpq_class b(a); ASSERT_ALWAYS(b == -12345);
  232.   }
  233.   // mpq_class(unsigned short int)
  234.   {
  235.     unsigned short int a = 54321u;
  236.     mpq_class b(a); ASSERT_ALWAYS(b == 54321u);
  237.   }
  238.   // mpq_class(signed long int)
  239.   {
  240.     signed long int a = -1234567890L;
  241.     mpq_class b(a); ASSERT_ALWAYS(b == -1234567890L);
  242.   }
  243.   // mpq_class(unsigned long int)
  244.   {
  245.     unsigned long int a = 1UL << 30;
  246.     mpq_class b(a); ASSERT_ALWAYS(b == 1073741824L);
  247.   }
  248.   // mpq_class(float)
  249.   {
  250.     float a = 0.625;
  251.     mpq_class b(a); ASSERT_ALWAYS(b == 0.625);
  252.   }
  253.   // mpq_class(double)
  254.   {
  255.     double a = 1.25;
  256.     mpq_class b(a); ASSERT_ALWAYS(b == 1.25);
  257.   }
  258.   // mpq_class(long double)
  259.   // currently not implemented
  260.   // mpq_class(const char *)
  261.   {
  262.     const char *a = "1234567890";
  263.     mpq_class b(a); ASSERT_ALWAYS(b == 1234567890L);
  264.   }
  265.   // mpq_class(const char *, int)
  266.   {
  267.     const char *a = "FFFF";
  268.     int base = 16;
  269.     mpq_class b(a, base); ASSERT_ALWAYS(b == 65535u);
  270.   }
  271.   // mpq_class(const std::string &)
  272.   {
  273.     string a("1234567890");
  274.     mpq_class b(a); ASSERT_ALWAYS(b == 1234567890L);
  275.   }
  276.   // mpq_class(const std::string &, int)
  277.   {
  278.     string a("7777");
  279.     int base = 8;
  280.     mpq_class b(a, base); ASSERT_ALWAYS(b == 4095);
  281.   }
  282.   // mpq_class(const char *) with invalid
  283.   {
  284.     try {
  285.       const char *a = "abc";
  286.       mpq_class b(a);
  287.       ASSERT_ALWAYS (0);  /* should not be reached */
  288.     } catch (invalid_argument) {
  289.     }
  290.   }
  291.   // mpq_class(const char *, int) with invalid
  292.   {
  293.     try {
  294.       const char *a = "ZZZ";
  295.       int base = 16;
  296.       mpq_class b (a, base);
  297.       ASSERT_ALWAYS (0);  /* should not be reached */
  298.     } catch (invalid_argument) {
  299.     }
  300.   }
  301.   // mpq_class(const std::string &) with invalid
  302.   {
  303.     try {
  304.       string a("abc");
  305.       mpq_class b(a);
  306.       ASSERT_ALWAYS (0);  /* should not be reached */
  307.     } catch (invalid_argument) {
  308.     }
  309.   }
  310.   // mpq_class(const std::string &, int) with invalid
  311.   {
  312.     try {
  313.       string a("ZZZ");
  314.       int base = 8;
  315.       mpq_class b (a, base);
  316.       ASSERT_ALWAYS (0);  /* should not be reached */
  317.     } catch (invalid_argument) {
  318.     }
  319.   }
  320.   // mpq_class(mpq_srcptr)
  321.   {
  322.     mpq_t a;
  323.     mpq_init(a);
  324.     mpq_set_ui(a, 100, 1);
  325.     mpq_class b(a); ASSERT_ALWAYS(b == 100);
  326.     mpq_clear(a);
  327.   }
  328.   // mpq_class(const mpz_class &, const mpz_class &)
  329.   {
  330.     mpz_class a(123), b(4); // tested above, assume it works
  331.     mpq_class c(a, b); ASSERT_ALWAYS(c == 30.75);
  332.   }
  333.   {
  334.     mpz_class a(-1), b(2);  // tested above, assume it works
  335.     mpq_class c(a, b); ASSERT_ALWAYS(c == -0.5);
  336.   }
  337.   {
  338.     mpz_class a(5), b(4); // tested above, assume it works
  339.     mpq_class c(a, b); ASSERT_ALWAYS(c == 1.25);
  340.   }
  341.   // mpq_class(const mpz_class &)
  342.   {
  343.     mpq_class a(12345); // tested above, assume it works
  344.     mpq_class b(a); ASSERT_ALWAYS(b == 12345);
  345.   }
  346.   // no constructor for bool, but it gets casted to int
  347.   {
  348.     bool a = true;
  349.     mpq_class b(a); ASSERT_ALWAYS(b == 1);
  350.   }
  351.   {
  352.     bool a = false;
  353.     mpq_class b(a); ASSERT_ALWAYS(b == 0);
  354.   }
  355. }
  356. void
  357. check_mpf (void)
  358. {
  359.   // mpf_class()
  360.   {
  361.     mpf_class a; ASSERT_ALWAYS(a == 0);
  362.   }
  363.   // mpf_class(const mpf_class &)
  364.   // mpf_class(const mpf_class &, unsigned long int)
  365.   // see below
  366.   // template <class T, class U> mpf_class(const __gmp_expr<T, U> &)
  367.   // template <class T, class U> mpf_class(const __gmp_expr<T, U> &,
  368.   //                                       unsigned long int)
  369.   // not tested here, see t-unary.cc, t-binary.cc
  370.   // mpf_class(signed char)
  371.   {
  372.     signed char a = -127;
  373.     mpf_class b(a); ASSERT_ALWAYS(b == -127);
  374.   }
  375.   // mpf_class(signed char, unsigned long int)
  376.   {
  377.     signed char a = -1;
  378.     int prec = 64;
  379.     mpf_class b(a, prec); ASSERT_ALWAYS(b == -1);
  380.   }
  381.   // mpf_class(unsigned char)
  382.   {
  383.     unsigned char a = 255;
  384.     mpf_class b(a); ASSERT_ALWAYS(b == 255);
  385.   }
  386.   // mpf_class(unsigned char, unsigned long int)
  387.   {
  388.     unsigned char a = 128;
  389.     int prec = 128;
  390.     mpf_class b(a, prec); ASSERT_ALWAYS(b == 128);
  391.   }
  392.   // either signed or unsigned char, machine dependent
  393.   {
  394.     mpf_class a('A'); ASSERT_ALWAYS(a == 65);
  395.   }
  396.   {
  397.     int prec = 256;
  398.     mpf_class a('z', prec); ASSERT_ALWAYS(a == 122);
  399.   }
  400.   // mpf_class(signed int)
  401.   {
  402.     signed int a = 0;
  403.     mpf_class b(a); ASSERT_ALWAYS(b == 0);
  404.   }
  405.   {
  406.     signed int a = -123;
  407.     mpf_class b(a); ASSERT_ALWAYS(b == -123);
  408.   }
  409.   {
  410.     signed int a = 4567;
  411.     mpf_class b(a); ASSERT_ALWAYS(b == 4567);
  412.   }
  413.   // mpf_class(signed int, unsigned long int)
  414.   {
  415.     signed int a = -123;
  416.     int prec = 64;
  417.     mpf_class b(a, prec); ASSERT_ALWAYS(b == -123);
  418.   }
  419.   // mpf_class(unsigned int)
  420.   {
  421.     unsigned int a = 890;
  422.     mpf_class b(a); ASSERT_ALWAYS(b == 890);
  423.   }
  424.   // mpf_class(unsigned int, unsigned long int)
  425.   {
  426.     unsigned int a = 890;
  427.     int prec = 128;
  428.     mpf_class b(a, prec); ASSERT_ALWAYS(b == 890);
  429.   }
  430.   // mpf_class(signed short int)
  431.   {
  432.     signed short int a = -12345;
  433.     mpf_class b(a); ASSERT_ALWAYS(b == -12345);
  434.   }
  435.   // mpf_class(signed short int, unsigned long int)
  436.   {
  437.     signed short int a = 6789;
  438.     int prec = 256;
  439.     mpf_class b(a, prec); ASSERT_ALWAYS(b == 6789);
  440.   }
  441.   // mpf_class(unsigned short int)
  442.   {
  443.     unsigned short int a = 54321u;
  444.     mpf_class b(a); ASSERT_ALWAYS(b == 54321u);
  445.   }
  446.   // mpf_class(unsigned short int, unsigned long int)
  447.   {
  448.     unsigned short int a = 54321u;
  449.     int prec = 64;
  450.     mpf_class b(a, prec); ASSERT_ALWAYS(b == 54321u);
  451.   }
  452.   // mpf_class(signed long int)
  453.   {
  454.     signed long int a = -1234567890L;
  455.     mpf_class b(a); ASSERT_ALWAYS(b == -1234567890L);
  456.   }
  457.   // mpf_class(signed long int, unsigned long int)
  458.   {
  459.     signed long int a = -1234567890L;
  460.     int prec = 128;
  461.     mpf_class b(a, prec); ASSERT_ALWAYS(b == -1234567890L);
  462.   }
  463.   // mpf_class(unsigned long int)
  464.   {
  465.     unsigned long int a = 3456789012UL;
  466.     mpf_class b(a); ASSERT_ALWAYS(b == 3456789012UL);
  467.   }
  468.   // mpf_class(unsigned long int, unsigned long int)
  469.   {
  470.     unsigned long int a = 3456789012UL;
  471.     int prec = 256;
  472.     mpf_class b(a, prec); ASSERT_ALWAYS(b == 3456789012UL);
  473.   }
  474.   // mpf_class(float)
  475.   {
  476.     float a = 1234.5;
  477.     mpf_class b(a); ASSERT_ALWAYS(b == 1234.5);
  478.   }
  479.   // mpf_class(float, unsigned long int)
  480.   {
  481.     float a = 1234.5;
  482.     int prec = 64;
  483.     mpf_class b(a, prec); ASSERT_ALWAYS(b == 1234.5);
  484.   }
  485.   // mpf_class(double)
  486.   {
  487.     double a = 12345.0;
  488.     mpf_class b(a); ASSERT_ALWAYS(b == 12345);
  489.   }
  490.   {
  491.     double a = 1.2345e+4;
  492.     mpf_class b(a); ASSERT_ALWAYS(b == 12345);
  493.   }
  494.   {
  495.     double a = 312.5e-2;
  496.     mpf_class b(a); ASSERT_ALWAYS(b == 3.125);
  497.   }
  498.   // mpf_class(double, unsigned long int)
  499.   {
  500.     double a = 5.4321e+4;
  501.     int prec = 128;
  502.     mpf_class b(a, prec); ASSERT_ALWAYS(b == 54321L);
  503.   }
  504.   // mpf_class(long double)
  505.   // mpf_class(long double, unsigned long int)
  506.   // currently not implemented
  507.   // mpf_class(const char *)
  508.   {
  509.     const char *a = "1234567890";
  510.     mpf_class b(a); ASSERT_ALWAYS(b == 1234567890L);
  511.   }
  512.   // mpf_class(const char *, unsigned long int, int = 0)
  513.   {
  514.     const char *a = "1234567890";
  515.     int prec = 256;
  516.     mpf_class b(a, prec); ASSERT_ALWAYS(b == 1234567890L);
  517.   }
  518.   {
  519.     const char *a = "777777";
  520.     int prec = 64, base = 8;
  521.     mpf_class b(a, prec, base); ASSERT_ALWAYS(b == 262143L);
  522.   }
  523.   // mpf_class(const std::string &)
  524.   {
  525.     string a("1234567890");
  526.     mpf_class b(a); ASSERT_ALWAYS(b == 1234567890L);
  527.   }
  528.   // mpf_class(const std::string &, unsigned long int, int = 0)
  529.   {
  530.     string a("1234567890");
  531.     int prec = 128;
  532.     mpf_class b(a, prec); ASSERT_ALWAYS(b == 1234567890L);
  533.   }
  534.   {
  535.     string a("FFFF");
  536.     int prec = 256, base = 16;
  537.     mpf_class b(a, prec, base); ASSERT_ALWAYS(b == 65535u);
  538.   }
  539.   // mpf_class(const char *) with invalid
  540.   {
  541.     try {
  542.       const char *a = "abc";
  543.       mpf_class b(a);
  544.       ASSERT_ALWAYS (0);  /* should not be reached */
  545.     } catch (invalid_argument) {
  546.     }
  547.   }
  548.   // mpf_class(const char *, unsigned long int, int = 0) with invalid
  549.   {
  550.     try {
  551.       const char *a = "def";
  552.       int prec = 256;
  553.       mpf_class b(a, prec); ASSERT_ALWAYS(b == 1234567890L);
  554.       ASSERT_ALWAYS (0);  /* should not be reached */
  555.     } catch (invalid_argument) {
  556.     }
  557.   }
  558.   {
  559.     try {
  560.       const char *a = "ghi";
  561.       int prec = 64, base = 8;
  562.       mpf_class b(a, prec, base); ASSERT_ALWAYS(b == 262143L);
  563.       ASSERT_ALWAYS (0);  /* should not be reached */
  564.     } catch (invalid_argument) {
  565.     }
  566.   }
  567.   // mpf_class(const std::string &) with invalid
  568.   {
  569.     try {
  570.       string a("abc");
  571.       mpf_class b(a); ASSERT_ALWAYS(b == 1234567890L);
  572.       ASSERT_ALWAYS (0);  /* should not be reached */
  573.     } catch (invalid_argument) {
  574.     }
  575.   }
  576.   // mpf_class(const std::string &, unsigned long int, int = 0) with invalid
  577.   {
  578.     try {
  579.       string a("def");
  580.       int prec = 128;
  581.       mpf_class b(a, prec); ASSERT_ALWAYS(b == 1234567890L);
  582.       ASSERT_ALWAYS (0);  /* should not be reached */
  583.     } catch (invalid_argument) {
  584.     }
  585.   }
  586.   {
  587.     try {
  588.       string a("ghi");
  589.       int prec = 256, base = 16;
  590.       mpf_class b(a, prec, base); ASSERT_ALWAYS(b == 65535u);
  591.       ASSERT_ALWAYS (0);  /* should not be reached */
  592.     } catch (invalid_argument) {
  593.     }
  594.   }
  595.   // mpf_class(mpf_srcptr)
  596.   {
  597.     mpf_t a;
  598.     mpf_init_set_ui(a, 100);
  599.     mpf_class b(a); ASSERT_ALWAYS(b == 100);
  600.     mpf_clear(a);
  601.   }
  602.   // mpf_class(mpf_srcptr, unsigned long int)
  603.   {
  604.     mpf_t a;
  605.     int prec = 64;
  606.     mpf_init_set_ui(a, 100);
  607.     mpf_class b(a, prec); ASSERT_ALWAYS(b == 100);
  608.     mpf_clear(a);
  609.   }
  610.   // mpf_class(const mpf_class &)
  611.   {
  612.     mpf_class a(12345); // tested above, assume it works
  613.     mpf_class b(a); ASSERT_ALWAYS(b == 12345);
  614.   }
  615.   // mpf_class(const mpf_class &, unsigned long int)
  616.   {
  617.     mpf_class a(12345); // tested above, assume it works
  618.     int prec = 64;
  619.     mpf_class b(a, prec); ASSERT_ALWAYS(b == 12345);
  620.   }
  621.   // no constructors for bool, but it gets casted to int
  622.   {
  623.     bool a = true;
  624.     mpf_class b(a); ASSERT_ALWAYS(b == 1);
  625.   }
  626.   {
  627.     bool a = false;
  628.     mpf_class b(a); ASSERT_ALWAYS(b == 0);
  629.   }
  630.   {
  631.     bool a = true;
  632.     int prec = 128;
  633.     mpf_class b(a, prec); ASSERT_ALWAYS(b == 1);
  634.   }
  635.   {
  636.     bool a = false;
  637.     int prec = 256;
  638.     mpf_class b(a, prec); ASSERT_ALWAYS(b == 0);
  639.   }
  640. }
  641. int
  642. main (void)
  643. {
  644.   tests_start();
  645.   check_mpz();
  646.   check_mpq();
  647.   check_mpf();
  648.   tests_end();
  649.   return 0;
  650. }