refmpf.c
上传用户:qaz666999
上传日期:2022-08-06
资源大小:2570k
文件大小:10k
源码类别:

数学计算

开发平台:

Unix_Linux

  1. /* Reference floating point routines.
  2. Copyright 1996, 2001, 2004, 2005 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 <stdio.h>
  15. #include <stdlib.h>
  16. #include "gmp.h"
  17. #include "gmp-impl.h"
  18. #include "tests.h"
  19. void
  20. refmpf_add (mpf_ptr w, mpf_srcptr u, mpf_srcptr v)
  21. {
  22.   mp_size_t hi, lo, size;
  23.   mp_ptr ut, vt, wt;
  24.   int neg;
  25.   mp_exp_t exp;
  26.   mp_limb_t cy;
  27.   TMP_DECL;
  28.   TMP_MARK;
  29.   if (SIZ (u) == 0)
  30.     {
  31.       size = ABSIZ (v);
  32.       wt = TMP_ALLOC_LIMBS (size + 1);
  33.       MPN_COPY (wt, PTR (v), size);
  34.       exp = EXP (v);
  35.       neg = SIZ (v) < 0;
  36.       goto done;
  37.     }
  38.   if (SIZ (v) == 0)
  39.     {
  40.       size = ABSIZ (u);
  41.       wt = TMP_ALLOC_LIMBS (size + 1);
  42.       MPN_COPY (wt, PTR (u), size);
  43.       exp = EXP (u);
  44.       neg = SIZ (u) < 0;
  45.       goto done;
  46.     }
  47.   if ((SIZ (u) ^ SIZ (v)) < 0)
  48.     {
  49.       mpf_t tmp;
  50.       SIZ (tmp) = -SIZ (v);
  51.       EXP (tmp) = EXP (v);
  52.       PTR (tmp) = PTR (v);
  53.       refmpf_sub (w, u, tmp);
  54.       return;
  55.     }
  56.   neg = SIZ (u) < 0;
  57.   /* Compute the significance of the hi and lo end of the result.  */
  58.   hi = MAX (EXP (u), EXP (v));
  59.   lo = MIN (EXP (u) - ABSIZ (u), EXP (v) - ABSIZ (v));
  60.   size = hi - lo;
  61.   ut = TMP_ALLOC_LIMBS (size + 1);
  62.   vt = TMP_ALLOC_LIMBS (size + 1);
  63.   wt = TMP_ALLOC_LIMBS (size + 1);
  64.   MPN_ZERO (ut, size);
  65.   MPN_ZERO (vt, size);
  66.   {int off;
  67.   off = size + (EXP (u) - hi) - ABSIZ (u);
  68.   MPN_COPY (ut + off, PTR (u), ABSIZ (u));
  69.   off = size + (EXP (v) - hi) - ABSIZ (v);
  70.   MPN_COPY (vt + off, PTR (v), ABSIZ (v));
  71.   }
  72.   cy = mpn_add_n (wt, ut, vt, size);
  73.   wt[size] = cy;
  74.   size += cy;
  75.   exp = hi + cy;
  76. done:
  77.   if (size > PREC (w))
  78.     {
  79.       wt += size - PREC (w);
  80.       size = PREC (w);
  81.     }
  82.   MPN_COPY (PTR (w), wt, size);
  83.   SIZ (w) = neg == 0 ? size : -size;
  84.   EXP (w) = exp;
  85.   TMP_FREE;
  86. }
  87. /* Add 1 "unit in last place" (ie. in the least significant limb) to f.
  88.    f cannot be zero, since that has no well-defined "last place".
  89.    This routine is designed for use in cases where we pay close attention to
  90.    the size of the data value and are using that (and the exponent) to
  91.    indicate the accurate part of a result, or similar.  For this reason, if
  92.    there's a carry out we don't store 1 and adjust the exponent, we just
  93.    leave 100..00.  We don't even adjust if there's a carry out of prec+1
  94.    limbs, but instead give up in that case (which we intend shouldn't arise
  95.    in normal circumstances).  */
  96. void
  97. refmpf_add_ulp (mpf_ptr f)
  98. {
  99.   mp_ptr     fp = PTR(f);
  100.   mp_size_t  fsize = SIZ(f);
  101.   mp_size_t  abs_fsize = ABSIZ(f);
  102.   mp_limb_t  c;
  103.   if (fsize == 0)
  104.     {
  105.       printf ("Oops, refmpf_add_ulp called with f==0n");
  106.       abort ();
  107.     }
  108.   c = refmpn_add_1 (fp, fp, abs_fsize, CNST_LIMB(1));
  109.   if (c != 0)
  110.     {
  111.       if (abs_fsize >= PREC(f) + 1)
  112.         {
  113.           printf ("Oops, refmpf_add_ulp carried out of prec+1 limbsn");
  114.           abort ();
  115.         }
  116.       fp[abs_fsize] = c;
  117.       abs_fsize++;
  118.       SIZ(f) = (fsize > 0 ? abs_fsize : - abs_fsize);
  119.       EXP(f)++;
  120.     }
  121. }
  122. /* Fill f with size limbs of the given value, setup as an integer. */
  123. void
  124. refmpf_fill (mpf_ptr f, mp_size_t size, mp_limb_t value)
  125. {
  126.   ASSERT (size >= 0);
  127.   size = MIN (PREC(f) + 1, size);
  128.   SIZ(f) = size;
  129.   EXP(f) = size;
  130.   refmpn_fill (PTR(f), size, value);
  131. }
  132. /* Strip high zero limbs from the f data, adjusting exponent accordingly. */
  133. void
  134. refmpf_normalize (mpf_ptr f)
  135. {
  136.   while (SIZ(f) != 0 && PTR(f)[ABSIZ(f)-1] == 0)
  137.     {
  138.       SIZ(f) = (SIZ(f) >= 0 ? SIZ(f)-1 : SIZ(f)+1);
  139.       EXP(f) --;
  140.     }
  141.   if (SIZ(f) == 0)
  142.     EXP(f) = 0;
  143. }
  144. /* refmpf_set_overlap sets up dst as a copy of src, but with PREC(dst)
  145.    unchanged, in preparation for an overlap test.
  146.    The full value of src is copied, and the space at PTR(dst) is extended as
  147.    necessary.  The way PREC(dst) is unchanged is as per an mpf_set_prec_raw.
  148.    The return value is the new PTR(dst) space precision, in bits, ready for
  149.    a restoring mpf_set_prec_raw before mpf_clear.  */
  150. unsigned long
  151. refmpf_set_overlap (mpf_ptr dst, mpf_srcptr src)
  152. {
  153.   mp_size_t  dprec = PREC(dst);
  154.   mp_size_t  ssize = ABSIZ(src);
  155.   unsigned long  ret;
  156.   refmpf_set_prec_limbs (dst, (unsigned long) MAX (dprec, ssize));
  157.   mpf_set (dst, src);
  158.   ret = mpf_get_prec (dst);
  159.   PREC(dst) = dprec;
  160.   return ret;
  161. }
  162. /* Like mpf_set_prec, but taking a precision in limbs.
  163.    PREC(f) ends up as the given "prec" value.  */
  164. void
  165. refmpf_set_prec_limbs (mpf_ptr f, unsigned long prec)
  166. {
  167.   mpf_set_prec (f, __GMPF_PREC_TO_BITS (prec));
  168. }
  169. void
  170. refmpf_sub (mpf_ptr w, mpf_srcptr u, mpf_srcptr v)
  171. {
  172.   mp_size_t hi, lo, size;
  173.   mp_ptr ut, vt, wt;
  174.   int neg;
  175.   mp_exp_t exp;
  176.   TMP_DECL;
  177.   TMP_MARK;
  178.   if (SIZ (u) == 0)
  179.     {
  180.       size = ABSIZ (v);
  181.       wt = TMP_ALLOC_LIMBS (size + 1);
  182.       MPN_COPY (wt, PTR (v), size);
  183.       exp = EXP (v);
  184.       neg = SIZ (v) > 0;
  185.       goto done;
  186.     }
  187.   if (SIZ (v) == 0)
  188.     {
  189.       size = ABSIZ (u);
  190.       wt = TMP_ALLOC_LIMBS (size + 1);
  191.       MPN_COPY (wt, PTR (u), size);
  192.       exp = EXP (u);
  193.       neg = SIZ (u) < 0;
  194.       goto done;
  195.     }
  196.   if ((SIZ (u) ^ SIZ (v)) < 0)
  197.     {
  198.       mpf_t tmp;
  199.       SIZ (tmp) = -SIZ (v);
  200.       EXP (tmp) = EXP (v);
  201.       PTR (tmp) = PTR (v);
  202.       refmpf_add (w, u, tmp);
  203.       if (SIZ (u) < 0)
  204. mpf_neg (w, w);
  205.       return;
  206.     }
  207.   neg = SIZ (u) < 0;
  208.   /* Compute the significance of the hi and lo end of the result.  */
  209.   hi = MAX (EXP (u), EXP (v));
  210.   lo = MIN (EXP (u) - ABSIZ (u), EXP (v) - ABSIZ (v));
  211.   size = hi - lo;
  212.   ut = TMP_ALLOC_LIMBS (size + 1);
  213.   vt = TMP_ALLOC_LIMBS (size + 1);
  214.   wt = TMP_ALLOC_LIMBS (size + 1);
  215.   MPN_ZERO (ut, size);
  216.   MPN_ZERO (vt, size);
  217.   {int off;
  218.   off = size + (EXP (u) - hi) - ABSIZ (u);
  219.   MPN_COPY (ut + off, PTR (u), ABSIZ (u));
  220.   off = size + (EXP (v) - hi) - ABSIZ (v);
  221.   MPN_COPY (vt + off, PTR (v), ABSIZ (v));
  222.   }
  223.   if (mpn_cmp (ut, vt, size) >= 0)
  224.     mpn_sub_n (wt, ut, vt, size);
  225.   else
  226.     {
  227.       mpn_sub_n (wt, vt, ut, size);
  228.       neg ^= 1;
  229.     }
  230.   exp = hi;
  231.   while (size != 0 && wt[size - 1] == 0)
  232.     {
  233.       size--;
  234.       exp--;
  235.     }
  236. done:
  237.   if (size > PREC (w))
  238.     {
  239.       wt += size - PREC (w);
  240.       size = PREC (w);
  241.     }
  242.   MPN_COPY (PTR (w), wt, size);
  243.   SIZ (w) = neg == 0 ? size : -size;
  244.   EXP (w) = exp;
  245.   TMP_FREE;
  246. }
  247. /* Validate got by comparing to want.  Return 1 if good, 0 if bad.
  248.    The data in got is compared to that in want, up to either PREC(got) limbs
  249.    or the size of got, whichever is bigger.  Clearly we always demand
  250.    PREC(got) of accuracy, but we go further and say that if got is bigger
  251.    then any extra must be correct too.
  252.    want needs to have enough data to allow this comparison.  The size in
  253.    want doesn't have to be that big though, if it's smaller then further low
  254.    limbs are taken to be zero.
  255.    This validation approach is designed to allow some flexibility in exactly
  256.    how much data is generated by an mpf function, ie. either prec or prec+1
  257.    limbs.  We don't try to make a reference function that emulates that same
  258.    size decision, instead the idea is for a validation function to generate
  259.    at least as much data as the real function, then compare.  */
  260. int
  261. refmpf_validate (const char *name, mpf_srcptr got, mpf_srcptr want)
  262. {
  263.   int  bad = 0;
  264.   mp_size_t  gsize, wsize, cmpsize, i;
  265.   mp_srcptr  gp, wp;
  266.   mp_limb_t  glimb, wlimb;
  267.   MPF_CHECK_FORMAT (got);
  268.   if (EXP (got) != EXP (want))
  269.     {
  270.       printf ("%s: wrong exponentn", name);
  271.       bad = 1;
  272.     }
  273.   gsize = SIZ (got);
  274.   wsize = SIZ (want);
  275.   if ((gsize < 0 && wsize > 0) || (gsize > 0 && wsize < 0))
  276.     {
  277.       printf ("%s: wrong signn", name);
  278.       bad = 1;
  279.     }
  280.   gsize = ABS (gsize);
  281.   wsize = ABS (wsize);
  282.   /* most significant limb of respective data */
  283.   gp = PTR (got) + gsize - 1;
  284.   wp = PTR (want) + wsize - 1;
  285.   /* compare limb data */
  286.   cmpsize = MAX (PREC (got), gsize);
  287.   for (i = 0; i < cmpsize; i++)
  288.     {
  289.       glimb = (i < gsize ? gp[-i] : 0);
  290.       wlimb = (i < wsize ? wp[-i] : 0);
  291.       if (glimb != wlimb)
  292.         {
  293.           printf ("%s: wrong data starting at index %ld from topn",
  294.                   name, (long) i);
  295.           bad = 1;
  296.           break;
  297.         }
  298.     }
  299.   if (bad)
  300.     {
  301.       printf ("  prec       %dn", PREC(got));
  302.       printf ("  exp got    %ldn", (long) EXP(got));
  303.       printf ("  exp want   %ldn", (long) EXP(want));
  304.       printf ("  size got   %dn", SIZ(got));
  305.       printf ("  size want  %dn", SIZ(want));
  306.       printf ("  limbs (high to low)n");
  307.       printf ("   got  ");
  308.       for (i = ABSIZ(got)-1; i >= 0; i--)
  309.         {
  310.           gmp_printf ("%MX", PTR(got)[i]);
  311.           if (i != 0)
  312.             printf (",");
  313.         }
  314.       printf ("n");
  315.       printf ("   want ");
  316.       for (i = ABSIZ(want)-1; i >= 0; i--)
  317.         {
  318.           gmp_printf ("%MX", PTR(want)[i]);
  319.           if (i != 0)
  320.             printf (",");
  321.         }
  322.       printf ("n");
  323.       return 0;
  324.     }
  325.   return 1;
  326. }
  327. int
  328. refmpf_validate_division (const char *name, mpf_srcptr got,
  329.                           mpf_srcptr n, mpf_srcptr d)
  330. {
  331.   mp_size_t  nsize, dsize, sign, prec, qsize, tsize;
  332.   mp_srcptr  np, dp;
  333.   mp_ptr     tp, qp, rp;
  334.   mpf_t      want;
  335.   int        ret;
  336.   nsize = SIZ (n);
  337.   dsize = SIZ (d);
  338.   ASSERT_ALWAYS (dsize != 0);
  339.   sign = nsize ^ dsize;
  340.   nsize = ABS (nsize);
  341.   dsize = ABS (dsize);
  342.   np = PTR (n);
  343.   dp = PTR (d);
  344.   prec = PREC (got);
  345.   EXP (want) = EXP (n) - EXP (d) + 1;
  346.   qsize = prec + 2;            /* at least prec+1 limbs, after high zero */
  347.   tsize = qsize + dsize - 1;   /* dividend size to give desired qsize */
  348.   /* dividend n, extended or truncated */
  349.   tp = refmpn_malloc_limbs (tsize);
  350.   refmpn_copy_extend (tp, tsize, np, nsize);
  351.   qp = refmpn_malloc_limbs (qsize);
  352.   rp = refmpn_malloc_limbs (dsize);  /* remainder, unused */
  353.   ASSERT_ALWAYS (qsize == tsize - dsize + 1);
  354.   refmpn_tdiv_qr (qp, rp, (mp_size_t) 0, tp, tsize, dp, dsize);
  355.   PTR (want) = qp;
  356.   SIZ (want) = (sign >= 0 ? qsize : -qsize);
  357.   refmpf_normalize (want);
  358.   ret = refmpf_validate (name, got, want);
  359.   free (tp);
  360.   free (qp);
  361.   free (rp);
  362.   return ret;
  363. }