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

数学计算

开发平台:

Unix_Linux

  1. /* Test mp*_class binary expressions.
  2. Copyright 2001, 2002, 2003, 2008 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 "gmp.h"
  17. #include "gmpxx.h"
  18. #include "gmp-impl.h"
  19. #include "tests.h"
  20. using namespace std;
  21. void
  22. check_mpz (void)
  23. {
  24.   // template <class T, class Op>
  25.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, T>, Op> >
  26.   {
  27.     mpz_class a(1), b(2);
  28.     mpz_class c(a + b); ASSERT_ALWAYS(c == 3);
  29.   }
  30.   {
  31.     mpz_class a(3), b(4);
  32.     mpz_class c;
  33.     c = a * b; ASSERT_ALWAYS(c == 12);
  34.   }
  35.   {
  36.     mpz_class a(5), b(3);
  37.     mpz_class c;
  38.     c = a % b; ASSERT_ALWAYS(c == 2);
  39.   }
  40.   // template <class T, class U, class Op>
  41.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, U, Op> >
  42.   {
  43.     mpz_class a(1);
  44.     signed int b = 3;
  45.     mpz_class c(a - b); ASSERT_ALWAYS(c == -2);
  46.   }
  47.   {
  48.     mpz_class a(-8);
  49.     unsigned int b = 2;
  50.     mpz_class c;
  51.     c = a / b; ASSERT_ALWAYS(c == -4);
  52.   }
  53.   {
  54.     mpz_class a(2);
  55.     double b = 3.0;
  56.     mpz_class c(a + b); ASSERT_ALWAYS(c == 5);
  57.   }
  58.   {
  59.     mpz_class a(4);
  60.     mpz_class b;
  61.     b = a + 0; ASSERT_ALWAYS(b == 4);
  62.   }
  63.   // template <class T, class U, class Op>
  64.   // __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, T>, Op> >
  65.   {
  66.     mpz_class a(3);
  67.     signed int b = 9;
  68.     mpz_class c(b / a); ASSERT_ALWAYS(c == 3);
  69.   }
  70.   // template <class T, class U, class V, class W, class Op>
  71.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> >
  72.   // type of result can't be mpz
  73.   // template <class T, class U, class V, class W, class Op>
  74.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, W>, Op> >
  75.   // type of result can't be mpz
  76.   // template <class T, class U, class Op>
  77.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, U>, Op> >
  78.   {
  79.     mpz_class a(3), b(4);
  80.     mpz_class c(a * (-b)); ASSERT_ALWAYS(c == -12);
  81.   }
  82.   // template <class T, class U, class Op>
  83.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, T>, Op> >
  84.   {
  85.     mpz_class a(3), b(2), c(1);
  86.     mpz_class d;
  87.     d = (a % b) + c; ASSERT_ALWAYS(d == 2);
  88.   }
  89.   // template <class T, class U, class V, class Op>
  90.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, V, Op> >
  91.   {
  92.     mpz_class a(-5);
  93.     unsigned int b = 2;
  94.     mpz_class c((-a) << b); ASSERT_ALWAYS(c == 20);
  95.   }
  96.   {
  97.     mpz_class a(5), b(-4);
  98.     signed int c = 3;
  99.     mpz_class d;
  100.     d = (a * b) >> c; ASSERT_ALWAYS(d == -3);
  101.   }
  102.   // template <class T, class U, class V, class Op>
  103.   // __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, V>, Op> >
  104.   {
  105.     mpz_class a(2), b(4);
  106.     double c = 6;
  107.     mpz_class d(c / (a - b)); ASSERT_ALWAYS(d == -3);
  108.   }
  109.   {
  110.     mpz_class a(3), b(2);
  111.     double c = 1;
  112.     mpz_class d;
  113.     d = c + (a + b); ASSERT_ALWAYS(d == 6);
  114.   }
  115.   // template <class T, class U, class V, class W, class Op>
  116.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> >
  117.   // type of result can't be mpz
  118.   // template <class T, class U, class V, class W, class Op>
  119.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, W>, Op> >
  120.   // type of result can't be mpz
  121.   // template <class T, class U, class V, class Op>
  122.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, V>, Op> >
  123.   {
  124.     mpz_class a(3), b(5), c(7);
  125.     mpz_class d;
  126.     d = (a - b) * (-c); ASSERT_ALWAYS(d == 14);
  127.   }
  128.   {
  129.     mpz_class a(0xcafe), b(0xbeef), c, want;
  130.     c = a & b; ASSERT_ALWAYS (c == 0x8aee);
  131.     c = a | b; ASSERT_ALWAYS (c == 0xfeff);
  132.     c = a ^ b; ASSERT_ALWAYS (c == 0x7411);
  133.     c = a & 0xbeef; ASSERT_ALWAYS (c == 0x8aee);
  134.     c = a | 0xbeef; ASSERT_ALWAYS (c == 0xfeff);
  135.     c = a ^ 0xbeef; ASSERT_ALWAYS (c == 0x7411);
  136.     c = a & -0xbeef; ASSERT_ALWAYS (c == 0x4010);
  137.     c = a | -0xbeef; ASSERT_ALWAYS (c == -0x3401);
  138.     c = a ^ -0xbeef; ASSERT_ALWAYS (c == -0x7411);
  139.     c = a & 48879.0; ASSERT_ALWAYS (c == 0x8aee);
  140.     c = a | 48879.0; ASSERT_ALWAYS (c == 0xfeff);
  141.     c = a ^ 48879.0; ASSERT_ALWAYS (c == 0x7411);
  142.     c = a | 1267650600228229401496703205376.0; // 2^100
  143.     want = "0x1000000000000000000000cafe";
  144.     ASSERT_ALWAYS (c == want);
  145.   }
  146. }
  147. void
  148. check_mpq (void)
  149. {
  150.   // template <class T, class Op>
  151.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, T>, Op> >
  152.   {
  153.     mpq_class a(1, 2), b(3, 4);
  154.     mpq_class c(a + b); ASSERT_ALWAYS(c == 1.25);
  155.   }
  156.   // template <class T, class U, class Op>
  157.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, U, Op> >
  158.   {
  159.     mpq_class a(1, 2);
  160.     signed int b = 3;
  161.     mpq_class c(a - b); ASSERT_ALWAYS(c == -2.5);
  162.   }
  163.   {
  164.     mpq_class a(1, 2);
  165.     mpq_class b;
  166.     b = a + 0; ASSERT_ALWAYS(b == 0.5);
  167.   }
  168.   // template <class T, class U, class Op>
  169.   // __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, T>, Op> >
  170.   {
  171.     mpq_class a(2, 3);
  172.     signed int b = 4;
  173.     mpq_class c;
  174.     c = b / a; ASSERT_ALWAYS(c == 6);
  175.   }
  176.   // template <class T, class U, class V, class Op>
  177.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<U, V>, Op> >
  178.   {
  179.     mpq_class a(1, 2);
  180.     mpz_class b(1);
  181.     mpq_class c(a + b); ASSERT_ALWAYS(c == 1.5);
  182.   }
  183.   {
  184.     mpq_class a(2, 3);
  185.     mpz_class b(1);
  186.     double c = 2.0;
  187.     mpq_class d;
  188.     d = a * (b + c); ASSERT_ALWAYS(d == 2);
  189.   }
  190.   // template <class T, class U, class V, class Op>
  191.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, T>, Op> >
  192.   {
  193.     mpq_class a(2, 3);
  194.     mpz_class b(4);
  195.     mpq_class c(b / a); ASSERT_ALWAYS(c == 6);
  196.   }
  197.   {
  198.     mpq_class a(2, 3);
  199.     mpz_class b(1), c(4);
  200.     mpq_class d;
  201.     d = (b - c) * a; ASSERT_ALWAYS(d == -2);
  202.   }
  203.   // template <class T, class U, class Op>
  204.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, U>, Op> >
  205.   {
  206.     mpq_class a(1, 3), b(3, 4);
  207.     mpq_class c;
  208.     c = a * (-b); ASSERT_ALWAYS(c == -0.25);
  209.   }
  210.   // template <class T, class U, class Op>
  211.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, T>, Op> >
  212.   {
  213.     mpq_class a(1, 3), b(2, 3), c(1, 4);
  214.     mpq_class d((a / b) + c); ASSERT_ALWAYS(d == 0.75);
  215.   }
  216.   // template <class T, class U, class V, class Op>
  217.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, V, Op> >
  218.   {
  219.     mpq_class a(3, 8);
  220.     unsigned int b = 4;
  221.     mpq_class c((-a) << b); ASSERT_ALWAYS(c == -6);
  222.   }
  223.   // template <class T, class U, class V, class Op>
  224.   // __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, V>, Op> >
  225.   {
  226.     mpq_class a(1, 2), b(1, 4);
  227.     double c = 6.0;
  228.     mpq_class d;
  229.     d = c / (a + b); ASSERT_ALWAYS(d == 8);
  230.   }
  231.   // template <class T, class U, class V, class W, class Op>
  232.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> >
  233.   {
  234.     mpq_class a(1, 2), b(1, 4);
  235.     mpz_class c(1);
  236.     mpq_class d((a + b) - c); ASSERT_ALWAYS(d == -0.25);
  237.   }
  238.   {
  239.     mpq_class a(1, 3), b(3, 2);
  240.     mpz_class c(2), d(4);
  241.     mpq_class e;
  242.     e = (a * b) / (c - d); ASSERT_ALWAYS(e == -0.25);
  243.   }
  244.   // template <class T, class U, class V, class W, class Op>
  245.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, W>, Op> >
  246.   {
  247.     mpq_class a(1, 3), b(3, 4);
  248.     mpz_class c(-3);
  249.     mpq_class d(c * (a * b)); ASSERT_ALWAYS(d == -0.75);
  250.   }
  251.   {
  252.     mpq_class a(1, 3), b(3, 5);
  253.     mpz_class c(6);
  254.     signed int d = 4;
  255.     mpq_class e;
  256.     e = (c % d) / (a * b); ASSERT_ALWAYS(e == 10);
  257.   }
  258.   // template <class T, class U, class V, class Op>
  259.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, V>, Op> >
  260.   {
  261.     mpq_class a(1, 3), b(3, 4), c(2, 5);
  262.     mpq_class d;
  263.     d = (a * b) / (-c); ASSERT_ALWAYS(d == -0.625);
  264.   }
  265. }
  266. void
  267. check_mpf (void)
  268. {
  269.   // template <class T, class Op>
  270.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, T>, Op> >
  271.   {
  272.     mpf_class a(1), b(2);
  273.     mpf_class c(a + b); ASSERT_ALWAYS(c == 3);
  274.   }
  275.   {
  276.     mpf_class a(1.5), b(6);
  277.     mpf_class c;
  278.     c = a / b; ASSERT_ALWAYS(c == 0.25);
  279.   }
  280.   // template <class T, class U, class Op>
  281.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, U, Op> >
  282.   {
  283.     mpf_class a(1);
  284.     signed int b = -2;
  285.     mpf_class c(a - b); ASSERT_ALWAYS(c == 3);
  286.   }
  287.   {
  288.     mpf_class a(2);
  289.     mpf_class b;
  290.     b = a + 0; ASSERT_ALWAYS(b == 2);
  291.   }
  292.   // template <class T, class U, class Op>
  293.   // __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, T>, Op> >
  294.   {
  295.     mpf_class a(2);
  296.     unsigned int b = 3;
  297.     mpf_class c;
  298.     c = b / a; ASSERT_ALWAYS(c == 1.5);
  299.   }
  300.   // template <class T, class U, class V, class Op>
  301.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<U, V>, Op> >
  302.   {
  303.     mpf_class a(2);
  304.     mpz_class b(3);
  305.     mpf_class c(a - b); ASSERT_ALWAYS(c == -1);
  306.   }
  307.   {
  308.     mpf_class a(3);
  309.     mpz_class b(2), c(1);
  310.     mpf_class d;
  311.     d = a * (b + c); ASSERT_ALWAYS(d == 9);
  312.   }
  313.   // template <class T, class U, class V, class Op>
  314.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, T>, Op> >
  315.   {
  316.     mpf_class a(6);
  317.     mpq_class b(3, 4);
  318.     mpf_class c(a * b); ASSERT_ALWAYS(c == 4.5);
  319.   }
  320.   // template <class T, class U, class Op>
  321.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, T>, __gmp_expr<T, U>, Op> >
  322.   {
  323.     mpf_class a(2), b(-3);
  324.     mpf_class c;
  325.     c = a * (-b); ASSERT_ALWAYS(c == 6);
  326.   }
  327.   // template <class T, class U, class Op>
  328.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, T>, Op> >
  329.   {
  330.     mpf_class a(3), b(4), c(5);
  331.     mpf_class d;
  332.     d = (a / b) - c; ASSERT_ALWAYS(d == -4.25);
  333.   }
  334.   // template <class T, class U, class V, class Op>
  335.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, V, Op> >
  336.   {
  337.     mpf_class a(3);
  338.     unsigned int b = 2;
  339.     mpf_class c((-a) >> b); ASSERT_ALWAYS(c == -0.75);
  340.   }
  341.   // template <class T, class U, class V, class Op>
  342.   // __gmp_expr<T, __gmp_binary_expr<U, __gmp_expr<T, V>, Op> >
  343.   {
  344.     mpf_class a(2), b(3);
  345.     double c = 5.0;
  346.     mpf_class d;
  347.     d = c / (a + b); ASSERT_ALWAYS(d == 1);
  348.   }
  349.   // template <class T, class U, class V, class W, class Op>
  350.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<V, W>, Op> >
  351.   {
  352.     mpf_class a(2), b(3);
  353.     mpz_class c(4);
  354.     mpf_class d;
  355.     d = (a + b) * c; ASSERT_ALWAYS(d == 20);
  356.   }
  357.   {
  358.     mpf_class a(2), b(3);
  359.     mpq_class c(1, 2), d(1, 4);
  360.     mpf_class e;
  361.     e = (a * b) / (c + d); ASSERT_ALWAYS(e == 8);
  362.   }
  363.   // template <class T, class U, class V, class W, class Op>
  364.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<U, V>, __gmp_expr<T, W>, Op> >
  365.   {
  366.     mpf_class a(1), b(2);
  367.     mpq_class c(3);
  368.     mpf_class d(c / (a + b)); ASSERT_ALWAYS(d == 1);
  369.   }
  370.   {
  371.     mpf_class a(1);
  372.     mpz_class b(2);
  373.     mpq_class c(3, 4);
  374.     mpf_class d;
  375.     d = (-c) + (a + b); ASSERT_ALWAYS(d == 2.25);
  376.   }
  377.   // template <class T, class U, class V, class Op>
  378.   // __gmp_expr<T, __gmp_binary_expr<__gmp_expr<T, U>, __gmp_expr<T, V>, Op> >
  379.   {
  380.     mpf_class a(1), b(2), c(3);
  381.     mpf_class d;
  382.     d = (a + b) * (-c); ASSERT_ALWAYS(d == -9);
  383.   }
  384. }
  385. int
  386. main (void)
  387. {
  388.   tests_start();
  389.   check_mpz();
  390.   check_mpq();
  391.   check_mpf();
  392.   tests_end();
  393.   return 0;
  394. }