Punctuation (missing comma after "however").

git-svn-id: https://scm.gforge.inria.fr/anonscm/svn/mpfr/trunk@14542 280ebfd0-de03-0410-8827-d642c229c3f4

16 files changed, 34 insertions, 34 deletions

diff --git a/BUGS b/BUGS
index 7337a8e63..5ca356883 100644
--- a/BUGS
+++ b/BUGS
@@ -56,7 +56,7 @@ Potential bugs:
 
 * Possible infinite loop in some functions for particular cases: when
   the exact result is an exactly representable number or the middle of
-  consecutive two such numbers. However for non-algebraic functions, it is
+  consecutive two such numbers. However, for non-algebraic functions, it is
   believed that no such case exists, except the well-known cases like cos(0)=1,
   exp(0)=1, and so on, and the x^y function when y is an integer or y=1/2^k.
 
diff --git a/INSTALL b/INSTALL
index f85a76c99..ec2b72e08 100644
--- a/INSTALL
+++ b/INSTALL
@@ -218,7 +218,7 @@ specific architecture.
 
 --disable-thread-safe   build MPFR without TLS. By default, TLS support
                         is detected automatically, and MPFR is built as
-                        thread safe if supported. However this detection
+                        thread safe if supported. However, this detection
                         is only a heuristic: TLS can be detected as
                         supported while its support is incomplete or
                         buggy (MPFR tests may fail). In such a case,
diff --git a/TODO b/TODO
index 648957188..3c43677e2 100644
--- a/TODO
+++ b/TODO
@@ -383,7 +383,7 @@ Table of contents:
 - improve mpfr_grandom using the algorithm in https://arxiv.org/abs/1303.6257
 - implement a mpfr_sqrthigh algorithm based on Mulders' algorithm, with a
   basecase variant
-- use mpn_div_q to speed up mpfr_div. However mpn_div_q, which is new in
+- use mpn_div_q to speed up mpfr_div. However, mpn_div_q, which is new in
   GMP 5, is not documented in the GMP manual, thus we are not sure it
   guarantees to return the same quotient as mpn_tdiv_qr.
   Also mpfr_div uses the remainder computed by mpn_divrem. A workaround would
diff --git a/configure.ac b/configure.ac
index f5ed90f6e..8e1d89f4d 100644
--- a/configure.ac
+++ b/configure.ac
@@ -757,7 +757,7 @@ AC_RUN_IFELSE([AC_LANG_PROGRAM([[
     AC_MSG_WARN([(such as /usr/include or /usr/local/include). Another])
     AC_MSG_WARN([cause may be that LD_RUN_PATH is not honored (problem])
     AC_MSG_WARN([seen under OpenBSD 6.6).])
-    AC_MSG_WARN([However since we can't use 'libtool' inside the configure,])
+    AC_MSG_WARN([However, since we can't use 'libtool' inside the configure,])
     AC_MSG_WARN([we can't be sure. See 'config.log' for details.])
     AC_MSG_WARN([CC="$CC"])
     AC_MSG_WARN([CFLAGS="$CFLAGS"])
diff --git a/doc/algorithms.tex b/doc/algorithms.tex
index 9b11d0491..e1ba990a7 100644
--- a/doc/algorithms.tex
+++ b/doc/algorithms.tex
@@ -954,7 +954,7 @@ which yields $X - \frac{1}{2} \cdot 2^{-n} \leq A^{-1/2} \leq
               X + 1.21 \cdot 2^{-n}$,
 thus the right bound is not a priori fulfilled.
 % (3*1.003*1.311^2+0.5)/8+0.5 <= 1.21
-However the only problematic case is $n=19$, which gives exactly
+However, the only problematic case is $n=19$, which gives exactly
 $(n+3)/2 = 11$, since for $12 \leq n \leq 18$,
 the error terms in $2^{-2h}$ are halved.
 An exhaustive search of all possible inputs for $h=11$ and $n=19$ gives
@@ -966,7 +966,7 @@ Thus as soon as $n \geq 2$, Eq.~(\ref{rec_sqrt_eq1}) is fulfilled.
 
 In summary, Algorithm $\texttt{ApproximateInverseSquareRoot}$ provides an
 approximation $X$ of $A^{-1/2}$ with an error of at most one ulp.
-However if the input $A$ was itself truncated at precision $\geq p$
+However, if the input $A$ was itself truncated at precision $\geq p$
 from an input $A_0$ ---
 for example when the output precision $p$ is less than the input precision ---
 then we have $|X - A^{-1/2}| \leq \ulp(X)$, and
@@ -3176,7 +3176,7 @@ $\rho_k = -a_k \sigma_{k-1} / (1 + a_k \sigma_{k-1})$,
 $\sigma_k = 1 / (1 + a_k \sigma_{k-1})$, and:
 \[ a_k = \frac{k (a-k)}{(x + 2k - 1 - a) (x + 2k + 1 - a)}. \]
 Gautschi proves that when  $x \geq 1/4$ and $a \leq x + 1/4$, then
-$|\rho_k| \leq 1$ for all $k \geq 1$. However this is not enough to bound
+$|\rho_k| \leq 1$ for all $k \geq 1$. However, this is not enough to bound
 the tail of the above series.
 
 We consider here the case where $a \leq -1$, thus $a_k \leq 0$
@@ -4511,7 +4511,7 @@ $$  \wprec = \precc + 1 + 4 + \lceil \log_2(4\kvar)\rceil + \cond - \Exp(\svar).
 The \texttt{mpfr\_get\_str} function with size $0$ and base $b$ chooses an
 output precision of $1 + \lceil e \log(2)/\log(b) \rceil$ for a precision
 of $e$ bits if $b$ is not a power of two \cite{Mat68}.
-However the code uses instead $1 + \lceil e y \rceil$, where $y$ is
+However, the code uses instead $1 + \lceil e y \rceil$, where $y$ is
 an upper $76$-bit approximation of $\log(2)/\log(b)$. When do both values
 differ?
 In the case $b=2^k$, the worst case is when the first output digit contains
diff --git a/doc/mpfr.texi b/doc/mpfr.texi
index 9a43535c6..6757c9f02 100644
--- a/doc/mpfr.texi
+++ b/doc/mpfr.texi
@@ -561,7 +561,7 @@ You should include that file in any program using the MPFR library:
 @end example
 
 @cindex @code{stdio.h}
-Note however that prototypes for MPFR functions with @code{FILE *} parameters
+Note, however, that prototypes for MPFR functions with @code{FILE *} parameters
 are provided only if @code{<stdio.h>} is included too (before @file{mpfr.h}):
 
 @example
@@ -3495,7 +3495,7 @@ the MPFR library (contents of the @file{PATCHES} file), separated by spaces.
 Note: If the program has been compiled with an older MPFR version and is
 dynamically linked with a new MPFR library version, the identifiers of the
 patches applied to the old (compile-time) MPFR version are not available
-(however this information should not have much interest in general).
+(however, this information should not have much interest in general).
 @end deftypefun
 
 @deftypefun int mpfr_buildopt_tls_p (void)
@@ -4000,7 +4000,7 @@ with @code{mpfr_custom_init_set} is undefined.
 @deftypefun void mpfr_custom_move (mpfr_t @var{x}, void *@var{new_position})
 Inform MPFR that the significand of @var{x} has moved due to a garbage collect
 and update its new position to @code{new_position}.
-However the application has to move the significand and the @code{mpfr_t}
+However, the application has to move the significand and the @code{mpfr_t}
 itself.
 The behavior of this function for any @code{mpfr_t} not initialized
 with @code{mpfr_custom_init_set} is undefined.
@@ -4145,7 +4145,7 @@ Warning!  A program assuming (intentionally or not) that
 it is built and run against MPFR@tie{}2.x.
 
 The rounding modes @code{GMP_RNDx} were renamed to @code{MPFR_RNDx}
-in MPFR@tie{}3.0. However the old names @code{GMP_RNDx} have been kept for
+in MPFR@tie{}3.0. However, the old names @code{GMP_RNDx} have been kept for
 compatibility (this might change in future versions), using:
 @example
 #define GMP_RNDN MPFR_RNDN
@@ -4154,7 +4154,7 @@ compatibility (this might change in future versions), using:
 #define GMP_RNDD MPFR_RNDD
 @end example
 The rounding mode ``round away from zero'' (@code{MPFR_RNDA}) was added in
-MPFR@tie{}3.0 (however no rounding mode @code{GMP_RNDA} exists).
+MPFR@tie{}3.0 (however, no rounding mode @code{GMP_RNDA} exists).
 Faithful rounding (@code{MPFR_RNDF}) was added in MPFR@tie{}4.0, but
 currently, it is partially supported.
 @c That's sufficient information for now. More should be said in future
@@ -4548,7 +4548,7 @@ In MPFR@tie{}2.x, if a macro @code{INTMAX_C} or @code{UINTMAX_C} was defined
 (e.g. when the @code{__STDC_CONSTANT_MACROS} macro had been defined
 before @code{<stdint.h>} or @code{<inttypes.h>} has been included),
 @code{intmax_t} was assumed to be defined.
-However this was not always the case (more precisely, @code{intmax_t}
+However, this was not always the case (more precisely, @code{intmax_t}
 can be defined only in the namespace @code{std}, as with Boost), so
 that compilations could fail.
 Thus the check for @code{INTMAX_C} or @code{UINTMAX_C} is now disabled for
@@ -4567,7 +4567,7 @@ namespace, though this is not clean.
 
 @end itemize
 
-The divide-by-zero exception is new in MPFR@tie{}3.1. However it should
+The divide-by-zero exception is new in MPFR@tie{}3.1. However, it should
 not introduce incompatible changes for programs that strictly follow
 the MPFR API since the exception can only be seen via new functions.
 
diff --git a/src/cos.c b/src/cos.c
index b4b3d63f2..ffde09afb 100644
--- a/src/cos.c
+++ b/src/cos.c
@@ -263,8 +263,8 @@ mpfr_cos (mpfr_ptr y, mpfr_srcptr x, mpfr_rnd_t rnd_mode)
           if (m > k && (m - k >= precy + (rnd_mode == MPFR_RNDN)))
             {
               /* If round to nearest or away, result is s = 1 or -1,
-                 otherwise it is round(nexttoward (s, 0)). However in order to
-                 have the inexact flag correctly set below, we set |s| to
+                 otherwise it is round(nexttoward (s, 0)). However, in order
+                 to have the inexact flag correctly set below, we set |s| to
                  1 - 2^(-m) in all cases. */
               mpfr_nexttozero (s);
               break;
diff --git a/src/get_ld.c b/src/get_ld.c
index f04bf59ce..c2050a047 100644
--- a/src/get_ld.c
+++ b/src/get_ld.c
@@ -235,8 +235,8 @@ mpfr_get_ld (mpfr_srcptr x, mpfr_rnd_t rnd_mode)
 
           /* First round x to the target long double precision, so that
              all subsequent operations are exact (this avoids double rounding
-             problems). However if the format contains numbers that have more
-             precision, MPFR won't be able to generate such numbers. */
+             problems). However, if the format contains numbers that have
+             more precision, MPFR won't be able to generate such numbers. */
           mpfr_init2 (y, MPFR_LDBL_MANT_DIG);
           mpfr_init2 (z, MPFR_LDBL_MANT_DIG);
           /* Note about the precision of z: even though IEEE_DBL_MANT_DIG is
diff --git a/src/inp_str.c b/src/inp_str.c
index ab6048f30..676255480 100644
--- a/src/inp_str.c
+++ b/src/inp_str.c
@@ -103,7 +103,7 @@ mpfr_inp_str (mpfr_ptr rop, FILE *stream, int base, mpfr_rnd_t rnd_mode)
   MPFR_ASSERTD (nread >= 1);
   str_size += nread - 1;
   if (MPFR_UNLIKELY (str_size < nread - 1))  /* size_t overflow */
-    return 0;  /* however rop has been set successfully */
+    return 0;  /* however, rop has been set successfully */
   else
     return str_size;
 }
diff --git a/src/mpfr.h b/src/mpfr.h
index 8b9c2c1a4..29f7716fb 100644
--- a/src/mpfr.h
+++ b/src/mpfr.h
@@ -260,8 +260,8 @@ typedef __mpfr_struct *mpfr_ptr;
 typedef const __mpfr_struct *mpfr_srcptr;
 
 /* For those who need a direct and fast access to the sign field.
-   However it is not in the API, thus use it at your own risk: it might
-   not be supported, or change name, in further versions!
+   However, it is not in the API, thus use it at your own risk: it
+   might not be supported, or change name, in further versions!
    Unfortunately, it must be defined here (instead of MPFR's internal
    header file mpfr-impl.h) because it is used by some macros below.
 */
diff --git a/src/pow_ui.c b/src/pow_ui.c
index aa23dd764..6ea2d6ae5 100644
--- a/src/pow_ui.c
+++ b/src/pow_ui.c
@@ -146,7 +146,7 @@ POW_U (mpfr_ptr y, mpfr_srcptr x, UTYPE n, mpfr_rnd_t rnd)
     {
       mpz_t z;
 
-      /* Internal overflow or underflow. However the approximation error has
+      /* Internal overflow or underflow. However, the approximation error has
        * not been taken into account. So, let's solve this problem by using
        * mpfr_pow_z, which can handle it. This case could be improved in the
        * future, without having to use mpfr_pow_z.
diff --git a/src/round_prec.c b/src/round_prec.c
index 99ce2655e..2c533fb85 100644
--- a/src/round_prec.c
+++ b/src/round_prec.c
@@ -233,7 +233,7 @@ mpfr_can_round_raw (const mp_limb_t *bp, mp_size_t bn, int neg, mpfr_exp_t err,
 
   /* For err < prec (+1 for rnd1=RNDN), we can never round correctly, since
      the error is at least 2*ulp(b) >= ulp(round(b)).
-     However for err = prec (+1 for rnd1=RNDN), we can round correctly in some
+     However, for err = prec (+1 for rnd1=RNDN), we can round correctly in some
      rare cases where ulp(b) = 1/2*ulp(U) [see below for the definition of U],
      which implies rnd1 = RNDZ or RNDN, and rnd2 = RNDA or RNDN. */
 
diff --git a/src/sub1sp.c b/src/sub1sp.c
index 96ef4ffd9..32368aa6f 100644
--- a/src/sub1sp.c
+++ b/src/sub1sp.c
@@ -244,7 +244,7 @@ mpfr_sub1sp1 (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode,
               /* Warning: if d = GMP_NUMB_BITS and c0 = 1000...000, then
                  b0 - c0 = |0111...111|1000...000|, which after the shift
                  becomes |111...111|000...000| thus if p = GMP_NUMB_BITS-1
-                 we have rb = 1 but sb = 0. However in this case the round
+                 we have rb = 1 but sb = 0. However, in this case the round
                  even rule will round up, which is what we get with sb = 1:
                  the final result will be correct, while sb is incorrect. */
             }
@@ -255,7 +255,7 @@ mpfr_sub1sp1 (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode,
   /* now perform rounding */
 
   /* Warning: MPFR considers underflow *after* rounding with an unbounded
-     exponent range. However since b and c have same precision p, they are
+     exponent range. However, since b and c have same precision p, they are
      multiples of 2^(emin-p), likewise for b-c. Thus if bx < emin, the
      subtraction (with an unbounded exponent range) is exact, so that bx is
      also the exponent after rounding with an unbounded exponent range. */
@@ -445,7 +445,7 @@ mpfr_sub1sp1n (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
   /* now perform rounding */
 
   /* Warning: MPFR considers underflow *after* rounding with an unbounded
-     exponent range. However since b and c have same precision p, they are
+     exponent range. However, since b and c have same precision p, they are
      multiples of 2^(emin-p), likewise for b-c. Thus if bx < emin, the
      subtraction (with an unbounded exponent range) is exact, so that bx is
      also the exponent after rounding with an unbounded exponent range. */
@@ -711,7 +711,7 @@ mpfr_sub1sp2 (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode,
   /* now perform rounding */
 
   /* Warning: MPFR considers underflow *after* rounding with an unbounded
-     exponent range. However since b and c have same precision p, they are
+     exponent range. However, since b and c have same precision p, they are
      multiples of 2^(emin-p), likewise for b-c. Thus if bx < emin, the
      subtraction (with an unbounded exponent range) is exact, so that bx is
      also the exponent after rounding with an unbounded exponent range. */
@@ -992,7 +992,7 @@ mpfr_sub1sp2n (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
   /* now perform rounding */
 
   /* Warning: MPFR considers underflow *after* rounding with an unbounded
-     exponent range. However since b and c have same precision p, they are
+     exponent range. However, since b and c have same precision p, they are
      multiples of 2^(emin-p), likewise for b-c. Thus if bx < emin, the
      subtraction (with an unbounded exponent range) is exact, so that bx is
      also the exponent after rounding with an unbounded exponent range. */
@@ -1318,7 +1318,7 @@ mpfr_sub1sp3 (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode,
   /* now perform rounding */
 
   /* Warning: MPFR considers underflow *after* rounding with an unbounded
-     exponent range. However since b and c have same precision p, they are
+     exponent range. However, since b and c have same precision p, they are
      multiples of 2^(emin-p), likewise for b-c. Thus if bx < emin, the
      subtraction (with an unbounded exponent range) is exact, so that bx is
      also the exponent after rounding with an unbounded exponent range. */
@@ -1648,7 +1648,7 @@ mpfr_sub1sp (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode)
                   return 0;
                 }
               /* c0 is non-zero, thus we have to subtract 1/2*ulp(a),
-                 however we know (see analysis above) that this cannot
+                 however, we know (see analysis above) that this cannot
                  make the exponent decrease */
               MPFR_ASSERTD( !(ap[0] & ~mask) );    /* Check last bits */
               /* No normalize is needed */
diff --git a/src/sum.c b/src/sum.c
index 33b2c590f..f40d7060a 100644
--- a/src/sum.c
+++ b/src/sum.c
@@ -51,7 +51,7 @@ TODO [VL, after a discussion with James Demmel]: Compared to
   volume 37, number 1-4, pages 101--112, 2004.
 sorting is not necessary here. It is not done because in the most common
 cases (where big cancellations are rare), it would take time and be
-useless. However the lack of sorting increases the worst case complexity.
+useless. However, the lack of sorting increases the worst case complexity.
 For instance, consider many inputs that cancel one another (two by two).
 One would need n/2 iterations, where each iteration reads the exponent
 of each input, therefore n*n/2 read operations. Using a worst-case sort
diff --git a/tests/tlgamma.c b/tests/tlgamma.c
index 85d2c30f4..fc7ed285a 100644
--- a/tests/tlgamma.c
+++ b/tests/tlgamma.c
@@ -389,7 +389,7 @@ mpfr_lgamma1 (mpfr_ptr y, mpfr_srcptr x, mpfr_rnd_t r)
    when MPFR is built with Debian's tcc 0.9.27~git20151227.933c223-1
    on x86_64. The problem came from __gmpfr_ceil_log2, now fixed in
    r10443 (according to the integer promotion rules, this appeared to
-   be a bug in tcc, not in MPFR; however relying on such an obscure
+   be a bug in tcc, not in MPFR; however, relying on such an obscure
    rule was not a good idea). */
 static void
 tcc_bug20160606 (void)
diff --git a/tools/mpfrlint b/tools/mpfrlint
index 56d1e61dc..9c9ea83b2 100755
--- a/tools/mpfrlint
+++ b/tools/mpfrlint
@@ -326,7 +326,7 @@ grep '(mp_limb_t) *-\?[01][^0-9]' $srctests | grep -v '#define MPFR_LIMB_' | \
 # fragile. In practice, this may work because most (or all) platforms use
 # two's complement, and 0 being of type int (signed), this will give -1;
 # then when converted to a larger unsigned type, this will give the maximum
-# value as expected. However the reader may not know this explanation, and
+# value as expected. However, the reader may not know this explanation, and
 # a small change of the code can easily make it incorrect. The correct way
 # to obtain this result is to cast the constant to the expected type, then
 # do the bitwise complement; alternatively, cast -1 to the expected type.