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

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

数学计算

开发平台：

Unix_Linux

t-jac.c：源码内容
  1. /* Exercise mpz_*_kronecker_*() and mpz_jacobi() functions.
  3. Copyright 1999, 2000, 2001, 2002, 2003, 2004 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. /* With no arguments the various Kronecker/Jacobi symbol routines are
  22.    checked against some test data and a lot of derived data.
  24.    To check the test data against PARI-GP, run
  26.    t-jac -p | gp -q
  28.    It takes a while because the output from "t-jac -p" is big.
  31.    Enhancements:
  33.    More big test cases than those given by check_squares_zi would be good.  */
  36. #include <stdio.h>
  37. #include <stdlib.h>
  38. #include <string.h>
  40. #include "gmp.h"
  41. #include "gmp-impl.h"
  42. #include "tests.h"
  45. #ifdef _LONG_LONG_LIMB
  46. #define LL(l,ll)  ll
  47. #else
  48. #define LL(l,ll)  l
  49. #endif
  52. int option_pari = 0;
  55. unsigned long
  56. mpz_mod4 (mpz_srcptr z)
  57. {
  58.   mpz_t          m;
  59.   unsigned long  ret;
  61.   mpz_init (m);
  62.   mpz_fdiv_r_2exp (m, z, 2);
  63.   ret = mpz_get_ui (m);
  64.   mpz_clear (m);
  65.   return ret;
  66. }
  68. int
  69. mpz_fits_ulimb_p (mpz_srcptr z)
  70. {
  71.   return (SIZ(z) == 1 || SIZ(z) == 0);
  72. }
  74. mp_limb_t
  75. mpz_get_ulimb (mpz_srcptr z)
  76. {
  77.   if (SIZ(z) == 0)
  78.     return 0;
  79.   else
  80.     return PTR(z)[0];
  81. }
  84. void
  85. try_base (mp_limb_t a, mp_limb_t b, int answer)
  86. {
  87.   int  got;
  89.   if ((b & 1) == 0 || b == 1 || a > b)
  90.     return;
  92.   got = mpn_jacobi_base (a, b, 0);
  93.   if (got != answer)
  94.     {
  95.       printf (LL("mpn_jacobi_base (%lu, %lu) is %d should be %dn",
  96.  "mpn_jacobi_base (%llu, %llu) is %d should be %dn"),
  97.       a, b, got, answer);
  98.       abort ();
  99.     }
  100. }
  103. void
  104. try_zi_ui (mpz_srcptr a, unsigned long b, int answer)
  105. {
  106.   int  got;
  108.   got = mpz_kronecker_ui (a, b);
  109.   if (got != answer)
  110.     {
  111.       printf ("mpz_kronecker_ui (");
  112.       mpz_out_str (stdout, 10, a);
  113.       printf (", %lu) is %d should be %dn", b, got, answer);
  114.       abort ();
  115.     }
  116. }
  119. void
  120. try_zi_si (mpz_srcptr a, long b, int answer)
  121. {
  122.   int  got;
  124.   got = mpz_kronecker_si (a, b);
  125.   if (got != answer)
  126.     {
  127.       printf ("mpz_kronecker_si (");
  128.       mpz_out_str (stdout, 10, a);
  129.       printf (", %ld) is %d should be %dn", b, got, answer);
  130.       abort ();
  131.     }
  132. }
  135. void
  136. try_ui_zi (unsigned long a, mpz_srcptr b, int answer)
  137. {
  138.   int  got;
  140.   got = mpz_ui_kronecker (a, b);
  141.   if (got != answer)
  142.     {
  143.       printf ("mpz_ui_kronecker (%lu, ", a);
  144.       mpz_out_str (stdout, 10, b);
  145.       printf (") is %d should be %dn", got, answer);
  146.       abort ();
  147.     }
  148. }
  151. void
  152. try_si_zi (long a, mpz_srcptr b, int answer)
  153. {
  154.   int  got;
  156.   got = mpz_si_kronecker (a, b);
  157.   if (got != answer)
  158.     {
  159.       printf ("mpz_si_kronecker (%ld, ", a);
  160.       mpz_out_str (stdout, 10, b);
  161.       printf (") is %d should be %dn", got, answer);
  162.       abort ();
  163.     }
  164. }
  167. /* Don't bother checking mpz_jacobi, since it only differs for b even, and
  168.    we don't have an actual expected answer for it.  tests/devel/try.c does
  169.    some checks though.  */
  170. void
  171. try_zi_zi (mpz_srcptr a, mpz_srcptr b, int answer)
  172. {
  173.   int  got;
  175.   got = mpz_kronecker (a, b);
  176.   if (got != answer)
  177.     {
  178.       printf ("mpz_kronecker (");
  179.       mpz_out_str (stdout, 10, a);
  180.       printf (", ");
  181.       mpz_out_str (stdout, 10, b);
  182.       printf (") is %d should be %dn", got, answer);
  183.       abort ();
  184.     }
  185. }
  188. void
  189. try_pari (mpz_srcptr a, mpz_srcptr b, int answer)
  190. {
  191.   printf ("try(");
  192.   mpz_out_str (stdout, 10, a);
  193.   printf (",");
  194.   mpz_out_str (stdout, 10, b);
  195.   printf (",%d)n", answer);
  196. }
  199. void
  200. try_each (mpz_srcptr a, mpz_srcptr b, int answer)
  201. {
  202.   if (option_pari)
  203.     {
  204.       try_pari (a, b, answer);
  205.       return;
  206.     }
  208.   if (mpz_fits_ulimb_p (a) && mpz_fits_ulimb_p (b))
  209.     try_base (mpz_get_ulimb (a), mpz_get_ulimb (b), answer);
  211.   if (mpz_fits_ulong_p (b))
  212.     try_zi_ui (a, mpz_get_ui (b), answer);
  214.   if (mpz_fits_slong_p (b))
  215.     try_zi_si (a, mpz_get_si (b), answer);
  217.   if (mpz_fits_ulong_p (a))
  218.     try_ui_zi (mpz_get_ui (a), b, answer);
  220.   if (mpz_fits_sint_p (a))
  221.     try_si_zi (mpz_get_si (a), b, answer);
  223.   try_zi_zi (a, b, answer);
  224. }
  227. /* Try (a/b) and (a/-b). */
  228. void
  229. try_pn (mpz_srcptr a, mpz_srcptr b_orig, int answer)
  230. {
  231.   mpz_t  b;
  233.   mpz_init_set (b, b_orig);
  234.   try_each (a, b, answer);
  236.   mpz_neg (b, b);
  237.   if (mpz_sgn (a) < 0)
  238.     answer = -answer;
  240.   try_each (a, b, answer);
  242.   mpz_clear (b);
  243. }
  246. /* Try (a+k*p/b) for various k, using the fact (a/b) is periodic in a with
  247.    period p.  For b>0, p=b if b!=2mod4 or p=4*b if b==2mod4. */
  249. void
  250. try_periodic_num (mpz_srcptr a_orig, mpz_srcptr b, int answer)
  251. {
  252.   mpz_t  a, a_period;
  253.   int    i;
  255.   if (mpz_sgn (b) <= 0)
  256.     return;
  258.   mpz_init_set (a, a_orig);
  259.   mpz_init_set (a_period, b);
  260.   if (mpz_mod4 (b) == 2)
  261.     mpz_mul_ui (a_period, a_period, 4);
  263.   /* don't bother with these tests if they're only going to produce
  264.      even/even */
  265.   if (mpz_even_p (a) && mpz_even_p (b) && mpz_even_p (a_period))
  266.     goto done;
  268.   for (i = 0; i < 6; i++)
  269.     {
  270.       mpz_add (a, a, a_period);
  271.       try_pn (a, b, answer);
  272.     }
  274.   mpz_set (a, a_orig);
  275.   for (i = 0; i < 6; i++)
  276.     {
  277.       mpz_sub (a, a, a_period);
  278.       try_pn (a, b, answer);
  279.     }
  281.  done:
  282.   mpz_clear (a);
  283.   mpz_clear (a_period);
  284. }
  287. /* Try (a/b+k*p) for various k, using the fact (a/b) is periodic in b of
  288.    period p.
  290.        period p
  291.    a==0,1mod4             a
  292.    a==2mod4              4*a
  293.    a==3mod4 and b odd    4*a
  294.    a==3mod4 and b even   8*a
  296.    In Henri Cohen's book the period is given as 4*a for all a==2,3mod4, but
  297.    a counterexample would seem to be (3/2)=-1 which with (3/14)=+1 doesn't
  298.    have period 4*a (but rather 8*a with (3/26)=-1).  Maybe the plain 4*a is
  299.    to be read as applying to a plain Jacobi symbol with b odd, rather than
  300.    the Kronecker extension to b even. */
  302. void
  303. try_periodic_den (mpz_srcptr a, mpz_srcptr b_orig, int answer)
  304. {
  305.   mpz_t  b, b_period;
  306.   int    i;
  308.   if (mpz_sgn (a) == 0 || mpz_sgn (b_orig) == 0)
  309.     return;
  311.   mpz_init_set (b, b_orig);
  313.   mpz_init_set (b_period, a);
  314.   if (mpz_mod4 (a) == 3 && mpz_even_p (b))
  315.     mpz_mul_ui (b_period, b_period, 8L);
  316.   else if (mpz_mod4 (a) >= 2)
  317.     mpz_mul_ui (b_period, b_period, 4L);
  319.   /* don't bother with these tests if they're only going to produce
  320.      even/even */
  321.   if (mpz_even_p (a) && mpz_even_p (b) && mpz_even_p (b_period))
  322.     goto done;
  324.   for (i = 0; i < 6; i++)
  325.     {
  326.       mpz_add (b, b, b_period);
  327.       try_pn (a, b, answer);
  328.     }
  330.   mpz_set (b, b_orig);
  331.   for (i = 0; i < 6; i++)
  332.     {
  333.       mpz_sub (b, b, b_period);
  334.       try_pn (a, b, answer);
  335.     }
  337.  done:
  338.   mpz_clear (b);
  339.   mpz_clear (b_period);
  340. }
  343. static const unsigned long  ktable[] = {
  344.   0, 1, 2, 3, 4, 5, 6, 7,
  345.   GMP_NUMB_BITS-1, GMP_NUMB_BITS, GMP_NUMB_BITS+1,
  346.   2*GMP_NUMB_BITS-1, 2*GMP_NUMB_BITS, 2*GMP_NUMB_BITS+1,
  347.   3*GMP_NUMB_BITS-1, 3*GMP_NUMB_BITS, 3*GMP_NUMB_BITS+1
  348. };
  351. /* Try (a/b*2^k) for various k. */
  352. void
  353. try_2den (mpz_srcptr a, mpz_srcptr b_orig, int answer)
  354. {
  355.   mpz_t  b;
  356.   int    kindex;
  357.   int    answer_a2, answer_k;
  358.   unsigned long k;
  360.   /* don't bother when b==0 */
  361.   if (mpz_sgn (b_orig) == 0)
  362.     return;
  364.   mpz_init_set (b, b_orig);
  366.   /* (a/2) is 0 if a even, 1 if a==1 or 7 mod 8, -1 if a==3 or 5 mod 8 */
  367.   answer_a2 = (mpz_even_p (a) ? 0
  368.        : (((SIZ(a) >= 0 ? PTR(a)[0] : -PTR(a)[0]) + 2) & 7) < 4 ? 1
  369.        : -1);
  371.   for (kindex = 0; kindex < numberof (ktable); kindex++)
  372.     {
  373.       k = ktable[kindex];
  375.       /* answer_k = answer*(answer_a2^k) */
  376.       answer_k = (answer_a2 == 0 && k != 0 ? 0
  377.   : (k & 1) == 1 && answer_a2 == -1 ? -answer
  378.   : answer);
  380.       mpz_mul_2exp (b, b_orig, k);
  381.       try_pn (a, b, answer_k);
  382.     }
  384.   mpz_clear (b);
  385. }
  388. /* Try (a*2^k/b) for various k.  If it happens mpz_ui_kronecker() gets (2/b)
  389.    wrong it will show up as wrong answers demanded. */
  390. void
  391. try_2num (mpz_srcptr a_orig, mpz_srcptr b, int answer)
  392. {
  393.   mpz_t  a;
  394.   int    kindex;
  395.   int    answer_2b, answer_k;
  396.   unsigned long  k;
  398.   /* don't bother when a==0 */
  399.   if (mpz_sgn (a_orig) == 0)
  400.     return;
  402.   mpz_init (a);
  404.   /* (2/b) is 0 if b even, 1 if b==1 or 7 mod 8, -1 if b==3 or 5 mod 8 */
  405.   answer_2b = (mpz_even_p (b) ? 0
  406.        : (((SIZ(b) >= 0 ? PTR(b)[0] : -PTR(b)[0]) + 2) & 7) < 4 ? 1
  407.        : -1);
  409.   for (kindex = 0; kindex < numberof (ktable); kindex++)
  410.     {
  411.       k = ktable[kindex];
  413.       /* answer_k = answer*(answer_2b^k) */
  414.       answer_k = (answer_2b == 0 && k != 0 ? 0
  415.   : (k & 1) == 1 && answer_2b == -1 ? -answer
  416.   : answer);
  418. mpz_mul_2exp (a, a_orig, k);
  419.       try_pn (a, b, answer_k);
  420.     }
  422.   mpz_clear (a);
  423. }
  426. /* The try_2num() and try_2den() routines don't in turn call
  427.    try_periodic_num() and try_periodic_den() because it hugely increases the
  428.    number of tests performed, without obviously increasing coverage.
  430.    Useful extra derived cases can be added here. */
  432. void
  433. try_all (mpz_t a, mpz_t b, int answer)
  434. {
  435.   try_pn (a, b, answer);
  436.   try_periodic_num (a, b, answer);
  437.   try_periodic_den (a, b, answer);
  438.   try_2num (a, b, answer);
  439.   try_2den (a, b, answer);
  440. }
  443. void
  444. check_data (void)
  445. {
  446.   static const struct {
  447.     const char  *a;
  448.     const char  *b;
  449.     int         answer;
  451.   } data[] = {
  453.     /* Note that the various derived checks in try_all() reduce the cases
  454.        that need to be given here.  */
  456.     /* some zeros */
  457.     {  "0",  "0", 0 },
  458.     {  "0",  "2", 0 },
  459.     {  "0",  "6", 0 },
  460.     {  "5",  "0", 0 },
  461.     { "24", "60", 0 },
  463.     /* (a/1) = 1, any a
  464.        In particular note (0/1)=1 so that (a/b)=(a mod b/b). */
  465.     { "0", "1", 1 },
  466.     { "1", "1", 1 },
  467.     { "2", "1", 1 },
  468.     { "3", "1", 1 },
  469.     { "4", "1", 1 },
  470.     { "5", "1", 1 },
  472.     /* (0/b) = 0, b != 1 */
  473.     { "0",  "3", 0 },
  474.     { "0",  "5", 0 },
  475.     { "0",  "7", 0 },
  476.     { "0",  "9", 0 },
  477.     { "0", "11", 0 },
  478.     { "0", "13", 0 },
  479.     { "0", "15", 0 },
  481.     /* (1/b) = 1 */
  482.     { "1",  "1", 1 },
  483.     { "1",  "3", 1 },
  484.     { "1",  "5", 1 },
  485.     { "1",  "7", 1 },
  486.     { "1",  "9", 1 },
  487.     { "1", "11", 1 },
  489.     /* (-1/b) = (-1)^((b-1)/2) which is -1 for b==3 mod 4 */
  490.     { "-1",  "1",  1 },
  491.     { "-1",  "3", -1 },
  492.     { "-1",  "5",  1 },
  493.     { "-1",  "7", -1 },
  494.     { "-1",  "9",  1 },
  495.     { "-1", "11", -1 },
  496.     { "-1", "13",  1 },
  497.     { "-1", "15", -1 },
  498.     { "-1", "17",  1 },
  499.     { "-1", "19", -1 },
  501.     /* (2/b) = (-1)^((b^2-1)/8) which is -1 for b==3,5 mod 8.
  502.        try_2num() will exercise multiple powers of 2 in the numerator.  */
  503.     { "2",  "1",  1 },
  504.     { "2",  "3", -1 },
  505.     { "2",  "5", -1 },
  506.     { "2",  "7",  1 },
  507.     { "2",  "9",  1 },
  508.     { "2", "11", -1 },
  509.     { "2", "13", -1 },
  510.     { "2", "15",  1 },
  511.     { "2", "17",  1 },
  513.     /* (-2/b) = (-1)^((b^2-1)/8)*(-1)^((b-1)/2) which is -1 for b==5,7mod8.
  514.        try_2num() will exercise multiple powers of 2 in the numerator, which
  515.        will test that the shift in mpz_si_kronecker() uses unsigned not
  516.        signed.  */
  517.     { "-2",  "1",  1 },
  518.     { "-2",  "3",  1 },
  519.     { "-2",  "5", -1 },
  520.     { "-2",  "7", -1 },
  521.     { "-2",  "9",  1 },
  522.     { "-2", "11",  1 },
  523.     { "-2", "13", -1 },
  524.     { "-2", "15", -1 },
  525.     { "-2", "17",  1 },
  527.     /* (a/2)=(2/a).
  528.        try_2den() will exercise multiple powers of 2 in the denominator. */
  529.     {  "3",  "2", -1 },
  530.     {  "5",  "2", -1 },
  531.     {  "7",  "2",  1 },
  532.     {  "9",  "2",  1 },
  533.     {  "11", "2", -1 },
  535.     /* Harriet Griffin, "Elementary Theory of Numbers", page 155, various
  536.        examples.  */
  537.     {   "2", "135",  1 },
  538.     { "135",  "19", -1 },
  539.     {   "2",  "19", -1 },
  540.     {  "19", "135",  1 },
  541.     { "173", "135",  1 },
  542.     {  "38", "135",  1 },
  543.     { "135", "173",  1 },
  544.     { "173",   "5", -1 },
  545.     {   "3",   "5", -1 },
  546.     {   "5", "173", -1 },
  547.     { "173",   "3", -1 },
  548.     {   "2",   "3", -1 },
  549.     {   "3", "173", -1 },
  550.     { "253",  "21",  1 },
  551.     {   "1",  "21",  1 },
  552.     {  "21", "253",  1 },
  553.     {  "21",  "11", -1 },
  554.     {  "-1",  "11", -1 },
  556.     /* Griffin page 147 */
  557.     {  "-1",  "17",  1 },
  558.     {   "2",  "17",  1 },
  559.     {  "-2",  "17",  1 },
  560.     {  "-1",  "89",  1 },
  561.     {   "2",  "89",  1 },
  563.     /* Griffin page 148 */
  564.     {  "89",  "11",  1 },
  565.     {   "1",  "11",  1 },
  566.     {  "89",   "3", -1 },
  567.     {   "2",   "3", -1 },
  568.     {   "3",  "89", -1 },
  569.     {  "11",  "89",  1 },
  570.     {  "33",  "89", -1 },
  572.     /* H. Davenport, "The Higher Arithmetic", page 65, the quadratic
  573.        residues and non-residues mod 19.  */
  574.     {  "1", "19",  1 },
  575.     {  "4", "19",  1 },
  576.     {  "5", "19",  1 },
  577.     {  "6", "19",  1 },
  578.     {  "7", "19",  1 },
  579.     {  "9", "19",  1 },
  580.     { "11", "19",  1 },
  581.     { "16", "19",  1 },
  582.     { "17", "19",  1 },
  583.     {  "2", "19", -1 },
  584.     {  "3", "19", -1 },
  585.     {  "8", "19", -1 },
  586.     { "10", "19", -1 },
  587.     { "12", "19", -1 },
  588.     { "13", "19", -1 },
  589.     { "14", "19", -1 },
  590.     { "15", "19", -1 },
  591.     { "18", "19", -1 },
  593.     /* Residues and non-residues mod 13 */
  594.     {  "0",  "13",  0 },
  595.     {  "1",  "13",  1 },
  596.     {  "2",  "13", -1 },
  597.     {  "3",  "13",  1 },
  598.     {  "4",  "13",  1 },
  599.     {  "5",  "13", -1 },
  600.     {  "6",  "13", -1 },
  601.     {  "7",  "13", -1 },
  602.     {  "8",  "13", -1 },
  603.     {  "9",  "13",  1 },
  604.     { "10",  "13",  1 },
  605.     { "11",  "13", -1 },
  606.     { "12",  "13",  1 },
  608.     /* various */
  609.     {  "5",   "7", -1 },
  610.     { "15",  "17",  1 },
  611.     { "67",  "89",  1 },
  613.     /* special values inducing a==b==1 at the end of jac_or_kron() */
  614.     { "0x10000000000000000000000000000000000000000000000001",
  615.       "0x10000000000000000000000000000000000000000000000003", 1 },
  616.   };
  618.   int    i;
  619.   mpz_t  a, b;
  621.   mpz_init (a);
  622.   mpz_init (b);
  624.   for (i = 0; i < numberof (data); i++)
  625.     {
  626.       mpz_set_str_or_abort (a, data[i].a, 0);
  627.       mpz_set_str_or_abort (b, data[i].b, 0);
  628.       try_all (a, b, data[i].answer);
  629.     }
  631.   mpz_clear (a);
  632.   mpz_clear (b);
  633. }
  636. /* (a^2/b)=1 if gcd(a,b)=1, or (a^2/b)=0 if gcd(a,b)!=1.
  637.    This includes when a=0 or b=0. */
  638. void
  639. check_squares_zi (void)
  640. {
  641.   gmp_randstate_ptr rands = RANDS;
  642.   mpz_t  a, b, g;
  643.   int    i, answer;
  644.   mp_size_t size_range, an, bn;
  645.   mpz_t bs;
  647.   mpz_init (bs);
  648.   mpz_init (a);
  649.   mpz_init (b);
  650.   mpz_init (g);
  652.   for (i = 0; i < 50; i++)
  653.     {
  654.       mpz_urandomb (bs, rands, 32);
  655.       size_range = mpz_get_ui (bs) % 10 + 2;
  657.       mpz_urandomb (bs, rands, size_range);
  658.       an = mpz_get_ui (bs);
  659.       mpz_rrandomb (a, rands, an);
  661.       mpz_urandomb (bs, rands, size_range);
  662.       bn = mpz_get_ui (bs);
  663.       mpz_rrandomb (b, rands, bn);
  665.       mpz_gcd (g, a, b);
  666.       if (mpz_cmp_ui (g, 1L) == 0)
  667. answer = 1;
  668.       else
  669. answer = 0;
  671.       mpz_mul (a, a, a);
  673.       try_all (a, b, answer);
  674.     }
  676.   mpz_clear (bs);
  677.   mpz_clear (a);
  678.   mpz_clear (b);
  679.   mpz_clear (g);
  680. }
  683. /* Check the handling of asize==0, make sure it isn't affected by the low
  684.    limb. */
  685. void
  686. check_a_zero (void)
  687. {
  688.   mpz_t  a, b;
  690.   mpz_init_set_ui (a, 0);
  691.   mpz_init (b);
  693.   mpz_set_ui (b, 1L);
  694.   PTR(a)[0] = 0;
  695.   try_all (a, b, 1);   /* (0/1)=1 */
  696.   PTR(a)[0] = 1;
  697.   try_all (a, b, 1);   /* (0/1)=1 */
  699.   mpz_set_si (b, -1L);
  700.   PTR(a)[0] = 0;
  701.   try_all (a, b, 1);   /* (0/-1)=1 */
  702.   PTR(a)[0] = 1;
  703.   try_all (a, b, 1);   /* (0/-1)=1 */
  705.   mpz_set_ui (b, 0);
  706.   PTR(a)[0] = 0;
  707.   try_all (a, b, 0);   /* (0/0)=0 */
  708.   PTR(a)[0] = 1;
  709.   try_all (a, b, 0);   /* (0/0)=0 */
  711.   mpz_set_ui (b, 2);
  712.   PTR(a)[0] = 0;
  713.   try_all (a, b, 0);   /* (0/2)=0 */
  714.   PTR(a)[0] = 1;
  715.   try_all (a, b, 0);   /* (0/2)=0 */
  717.   mpz_clear (a);
  718.   mpz_clear (b);
  719. }
  722. int
  723. main (int argc, char *argv[])
  724. {
  725.   tests_start ();
  727.   if (argc >= 2 && strcmp (argv[1], "-p") == 0)
  728.     {
  729.       option_pari = 1;
  731.       printf ("
  732. try(a,b,answer) =n
  733. {n
  734.   if (kronecker(a,b) != answer,n
  735.     print("wrong at ", a, ",", b,n
  736.       " expected ", answer,n
  737.       " pari says ", kronecker(a,b)))n
  738. }n");
  739.     }
  741.   check_data ();
  742.   check_squares_zi ();
  743.   check_a_zero ();
  745.   tests_end ();
  746.   exit (0);
  747. }