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

数学计算

开发平台:

Unix_Linux

  1. /* Test mp*_class assignment operators.
  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.   // operator=(const mpz_class &)
  26.   {
  27.     mpz_class a(123), b;
  28.     b = a; ASSERT_ALWAYS(b == 123);
  29.   }
  30.   // template <class T, class U> operator=(const __gmp_expr<T, U> &)
  31.   // not tested here, see t-unary.cc, t-binary.cc
  32.   // operator=(signed char)
  33.   {
  34.     signed char a = -127;
  35.     mpz_class b;
  36.     b = a; ASSERT_ALWAYS(b == -127);
  37.   }
  38.   // operator=(unsigned char)
  39.   {
  40.     unsigned char a = 255;
  41.     mpz_class b;
  42.     b = a; ASSERT_ALWAYS(b == 255);
  43.   }
  44.   // either signed or unsigned char, machine dependent
  45.   {
  46.     mpz_class a;
  47.     a = 'A'; ASSERT_ALWAYS(a == 65);
  48.   }
  49.   {
  50.     mpz_class a;
  51.     a = 'z'; ASSERT_ALWAYS(a == 122);
  52.   }
  53.   // operator=(signed int)
  54.   {
  55.     signed int a = 0;
  56.     mpz_class b;
  57.     b = a; ASSERT_ALWAYS(b == 0);
  58.   }
  59.   {
  60.     signed int a = -123;
  61.     mpz_class b;
  62.     b = a; ASSERT_ALWAYS(b == -123);
  63.   }
  64.   {
  65.     signed int a = 32767;
  66.     mpz_class b;
  67.     b = a; ASSERT_ALWAYS(b == 32767);
  68.   }
  69.   // operator=(unsigned int)
  70.   {
  71.     unsigned int a = 65535u;
  72.     mpz_class b;
  73.     b = a; ASSERT_ALWAYS(b == 65535u);
  74.   }
  75.   // operator=(signed short int)
  76.   {
  77.     signed short int a = -12345;
  78.     mpz_class b;
  79.     b = a; ASSERT_ALWAYS(b == -12345);
  80.   }
  81.   // operator=(unsigned short int)
  82.   {
  83.     unsigned short int a = 54321u;
  84.     mpz_class b;
  85.     b = a; ASSERT_ALWAYS(b == 54321u);
  86.   }
  87.   // operator=(signed long int)
  88.   {
  89.     signed long int a = -1234567890L;
  90.     mpz_class b;
  91.     b = a; ASSERT_ALWAYS(b == -1234567890L);
  92.   }
  93.   // operator=(unsigned long int)
  94.   {
  95.     unsigned long int a = 3456789012UL;
  96.     mpz_class b;
  97.     b = a; ASSERT_ALWAYS(b == 3456789012UL);
  98.   }
  99.   // operator=(float)
  100.   {
  101.     float a = 123.0;
  102.     mpz_class b;
  103.     b = a; ASSERT_ALWAYS(b == 123);
  104.   }
  105.   // operator=(double)
  106.   {
  107.     double a = 0.0;
  108.     mpz_class b;
  109.     b = a; ASSERT_ALWAYS(b == 0);
  110.   }
  111.   {
  112.     double a = -12.375;
  113.     mpz_class b;
  114.     b = a; ASSERT_ALWAYS(b == -12);
  115.   }
  116.   {
  117.     double a = 6.789e+3;
  118.     mpz_class b;
  119.     b = a; ASSERT_ALWAYS(b == 6789);
  120.   }
  121.   {
  122.     double a = 9.375e-1;
  123.     mpz_class b;
  124.     b = a; ASSERT_ALWAYS(b == 0);
  125.   }
  126.   // operator=(long double)
  127.   // currently not implemented
  128.   // operator=(const char *)
  129.   {
  130.     const char *a = "1234567890";
  131.     mpz_class b;
  132.     b = a; ASSERT_ALWAYS(b == 1234567890L);
  133.   }
  134.   // operator=(const std::string &)
  135.   {
  136.     string a("1234567890");
  137.     mpz_class b;
  138.     b = a; ASSERT_ALWAYS(b == 1234567890L);
  139.   }
  140.   // operator=(const char *) with invalid
  141.   {
  142.     try {
  143.       const char *a = "abc";
  144.       mpz_class b;
  145.       b = a;
  146.       ASSERT_ALWAYS (0);  /* should not be reached */
  147.     } catch (invalid_argument) {
  148.     }
  149.   }
  150.   // operator=(const std::string &) with invalid
  151.   {
  152.     try {
  153.       string a("def");
  154.       mpz_class b;
  155.       b = a;
  156.       ASSERT_ALWAYS (0);  /* should not be reached */
  157.     } catch (invalid_argument) {
  158.     }
  159.   }
  160. }
  161. void
  162. check_mpq (void)
  163. {
  164.   // operator=(const mpq_class &)
  165.   {
  166.     mpq_class a(1, 2), b;
  167.     b = a; ASSERT_ALWAYS(b == 0.5);
  168.   }
  169.   // template <class T, class U> operator=(const __gmp_expr<T, U> &)
  170.   // not tested here, see t-unary.cc, t-binary.cc
  171.   // operator=(signed char)
  172.   {
  173.     signed char a = -127;
  174.     mpq_class b;
  175.     b = a; ASSERT_ALWAYS(b == -127);
  176.   }
  177.   // operator=(unsigned char)
  178.   {
  179.     unsigned char a = 255;
  180.     mpq_class b;
  181.     b = a; ASSERT_ALWAYS(b == 255);
  182.   }
  183.   // either signed or unsigned char, machine dependent
  184.   {
  185.     mpq_class a;
  186.     a = 'A'; ASSERT_ALWAYS(a == 65);
  187.   }
  188.   {
  189.     mpq_class a;
  190.     a = 'z'; ASSERT_ALWAYS(a == 122);
  191.   }
  192.   // operator=(signed int)
  193.   {
  194.     signed int a = 0;
  195.     mpq_class b;
  196.     b = a; ASSERT_ALWAYS(b == 0);
  197.   }
  198.   {
  199.     signed int a = -123;
  200.     mpq_class b;
  201.     b = a; ASSERT_ALWAYS(b == -123);
  202.   }
  203.   {
  204.     signed int a = 32767;
  205.     mpq_class b;
  206.     b = a; ASSERT_ALWAYS(b == 32767);
  207.   }
  208.   // operator=(unsigned int)
  209.   {
  210.     unsigned int a = 65535u;
  211.     mpq_class b;
  212.     b = a; ASSERT_ALWAYS(b == 65535u);
  213.   }
  214.   // operator=(signed short int)
  215.   {
  216.     signed short int a = -12345;
  217.     mpq_class b;
  218.     b = a; ASSERT_ALWAYS(b == -12345);
  219.   }
  220.   // operator=(unsigned short int)
  221.   {
  222.     unsigned short int a = 54321u;
  223.     mpz_class b;
  224.     b = a; ASSERT_ALWAYS(b == 54321u);
  225.   }
  226.   // operator=(signed long int)
  227.   {
  228.     signed long int a = -1234567890L;
  229.     mpq_class b;
  230.     b = a; ASSERT_ALWAYS(b == -1234567890L);
  231.   }
  232.   // operator=(unsigned long int)
  233.   {
  234.     unsigned long int a = 3456789012UL;
  235.     mpq_class b;
  236.     b = a; ASSERT_ALWAYS(b == 3456789012UL);
  237.   }
  238.   // operator=(float)
  239.   {
  240.     float a = 123.0;
  241.     mpq_class b;
  242.     b = a; ASSERT_ALWAYS(b == 123);
  243.   }
  244.   // operator=(double)
  245.   {
  246.     double a = 0.0;
  247.     mpq_class b;
  248.     b = a; ASSERT_ALWAYS(b == 0);
  249.   }
  250.   {
  251.     double a = -12.375;
  252.     mpq_class b;
  253.     b = a; ASSERT_ALWAYS(b == -12.375);
  254.   }
  255.   {
  256.     double a = 6.789e+3;
  257.     mpq_class b;
  258.     b = a; ASSERT_ALWAYS(b == 6789);
  259.   }
  260.   {
  261.     double a = 9.375e-1;
  262.     mpq_class b;
  263.     b = a; ASSERT_ALWAYS(b == 0.9375);
  264.   }
  265.   // operator=(long double)
  266.   // currently not implemented
  267.   // operator=(const char *)
  268.   {
  269.     const char *a = "1234567890";
  270.     mpq_class b;
  271.     b = a; ASSERT_ALWAYS(b == 1234567890L);
  272.   }
  273.   // operator=(const std::string &)
  274.   {
  275.     string a("1234567890");
  276.     mpq_class b;
  277.     b = a; ASSERT_ALWAYS(b == 1234567890L);
  278.   }
  279.   // operator=(const char *) with invalid
  280.   {
  281.     try {
  282.       const char *a = "abc";
  283.       mpq_class b;
  284.       b = a;
  285.       ASSERT_ALWAYS (0);  /* should not be reached */
  286.     } catch (invalid_argument) {
  287.     }
  288.   }
  289.   // operator=(const std::string &) with invalid
  290.   {
  291.     try {
  292.       string a("def");
  293.       mpq_class b;
  294.       b = a;
  295.       ASSERT_ALWAYS (0);  /* should not be reached */
  296.     } catch (invalid_argument) {
  297.     }
  298.   }
  299. }
  300. void
  301. check_mpf (void)
  302. {
  303.   // operator=(const mpf_class &)
  304.   {
  305.     mpf_class a(123), b;
  306.     b = a; ASSERT_ALWAYS(b == 123);
  307.   }
  308.   // template <class T, class U> operator=(const __gmp_expr<T, U> &)
  309.   // not tested here, see t-unary.cc, t-binary.cc
  310.   // operator=(signed char)
  311.   {
  312.     signed char a = -127;
  313.     mpf_class b;
  314.     b = a; ASSERT_ALWAYS(b == -127);
  315.   }
  316.   // operator=(unsigned char)
  317.   {
  318.     unsigned char a = 255;
  319.     mpf_class b;
  320.     b = a; ASSERT_ALWAYS(b == 255);
  321.   }
  322.   // either signed or unsigned char, machine dependent
  323.   {
  324.     mpf_class a;
  325.     a = 'A'; ASSERT_ALWAYS(a == 65);
  326.   }
  327.   {
  328.     mpf_class a;
  329.     a = 'z'; ASSERT_ALWAYS(a == 122);
  330.   }
  331.   // operator=(signed int)
  332.   {
  333.     signed int a = 0;
  334.     mpf_class b;
  335.     b = a; ASSERT_ALWAYS(b == 0);
  336.   }
  337.   {
  338.     signed int a = -123;
  339.     mpf_class b;
  340.     b = a; ASSERT_ALWAYS(b == -123);
  341.   }
  342.   {
  343.     signed int a = 32767;
  344.     mpf_class b;
  345.     b = a; ASSERT_ALWAYS(b == 32767);
  346.   }
  347.   // operator=(unsigned int)
  348.   {
  349.     unsigned int a = 65535u;
  350.     mpf_class b;
  351.     b = a; ASSERT_ALWAYS(b == 65535u);
  352.   }
  353.   // operator=(signed short int)
  354.   {
  355.     signed short int a = -12345;
  356.     mpf_class b;
  357.     b = a; ASSERT_ALWAYS(b == -12345);
  358.   }
  359.   // operator=(unsigned short int)
  360.   {
  361.     unsigned short int a = 54321u;
  362.     mpf_class b;
  363.     b = a; ASSERT_ALWAYS(b == 54321u);
  364.   }
  365.   // operator=(signed long int)
  366.   {
  367.     signed long int a = -1234567890L;
  368.     mpf_class b;
  369.     b = a; ASSERT_ALWAYS(b == -1234567890L);
  370.   }
  371.   // operator=(unsigned long int)
  372.   {
  373.     unsigned long int a = 3456789012UL;
  374.     mpf_class b;
  375.     b = a; ASSERT_ALWAYS(b == 3456789012UL);
  376.   }
  377.   // operator=(float)
  378.   {
  379.     float a = 123.0;
  380.     mpf_class b;
  381.     b = a; ASSERT_ALWAYS(b == 123);
  382.   }
  383.   // operator=(double)
  384.   {
  385.     double a = 0.0;
  386.     mpf_class b;
  387.     b = a; ASSERT_ALWAYS(b == 0);
  388.   }
  389.   {
  390.     double a = -12.375;
  391.     mpf_class b;
  392.     b = a; ASSERT_ALWAYS(b == -12.375);
  393.   }
  394.   {
  395.     double a = 6.789e+3;
  396.     mpf_class b;
  397.     b = a; ASSERT_ALWAYS(b == 6789);
  398.   }
  399.   {
  400.     double a = 9.375e-1;
  401.     mpf_class b;
  402.     b = a; ASSERT_ALWAYS(b == 0.9375);
  403.   }
  404.   // operator=(long double)
  405.   // currently not implemented
  406.   // operator=(const char *)
  407.   {
  408.     const char *a = "1234567890";
  409.     mpf_class b;
  410.     b = a; ASSERT_ALWAYS(b == 1234567890L);
  411.   }
  412.   // operator=(const std::string &)
  413.   {
  414.     string a("1234567890");
  415.     mpf_class b;
  416.     b = a; ASSERT_ALWAYS(b == 1234567890L);
  417.   }
  418.   // operator=(const char *) with invalid
  419.   {
  420.     try {
  421.       const char *a = "abc";
  422.       mpf_class b;
  423.       b = a;
  424.       ASSERT_ALWAYS (0);  /* should not be reached */
  425.     } catch (invalid_argument) {
  426.     }
  427.   }
  428.   // operator=(const std::string &) with invalid
  429.   {
  430.     try {
  431.       string a("def");
  432.       mpf_class b;
  433.       b = a;
  434.       ASSERT_ALWAYS (0);  /* should not be reached */
  435.     } catch (invalid_argument) {
  436.     }
  437.   }
  438. }
  439. int
  440. main (void)
  441. {
  442.   tests_start();
  443.   check_mpz();
  444.   check_mpq();
  445.   check_mpf();
  446.   tests_end();
  447.   return 0;
  448. }