Fix typos (spelling errors) in dist/*

# New Ticket Created by  (Peter J. Acklam)
# Please include the string:  [perl #81888]
# in the subject line of all future correspondence about this issue.
# <URL: http://rt.perl.org/rt3/Ticket/Display.html?id=81888 >

Signed-off-by: Abigail <abigail@abigail.be>

12 files changed, 25 insertions, 25 deletions

diff --git a/dist/Math-BigInt/lib/Math/BigFloat.pm b/dist/Math-BigInt/lib/Math/BigFloat.pm
index 1ccd381680..1d9da29be1 100644
--- a/dist/Math-BigInt/lib/Math/BigFloat.pm
+++ b/dist/Math-BigInt/lib/Math/BigFloat.pm
@@ -2501,7 +2501,7 @@ sub bpow
 sub bmodpow
   {
   # takes a very large number to a very large exponent in a given very
-  # large modulus, quickly, thanks to binary exponentation. Supports
+  # large modulus, quickly, thanks to binary exponentiation. Supports
   # negative exponents.
   my ($self,$num,$exp,$mod,@r) = objectify(3,@_);
 
@@ -3888,7 +3888,7 @@ Math::BigFloat - Arbitrary size floating point math package
 
   $x->bmod($y);			# modulus ($x % $y)
   $x->bpow($y);			# power of arguments ($x ** $y)
-  $x->bmodpow($exp,$mod);	# modular exponentation (($num**$exp) % $mod))
+  $x->bmodpow($exp,$mod);	# modular exponentiation (($num**$exp) % $mod))
   $x->blsft($y, $n);		# left shift by $y places in base $n
   $x->brsft($y, $n);		# right shift by $y places in base $n
 				# returns (quo,rem) or quo if in scalar context
diff --git a/dist/Math-BigInt/lib/Math/BigInt.pm b/dist/Math-BigInt/lib/Math/BigInt.pm
index 52acc7a682..c3a05a1567 100644
--- a/dist/Math-BigInt/lib/Math/BigInt.pm
+++ b/dist/Math-BigInt/lib/Math/BigInt.pm
@@ -931,7 +931,7 @@ sub round
   # Round $self according to given parameters, or given second argument's
   # parameters or global defaults 
 
-  # for speed reasons, _find_round_parameters is embeded here:
+  # for speed reasons, _find_round_parameters is embedded here:
 
   my ($self,$a,$p,$r,@args) = @_;
   # $a accuracy, if given by caller
@@ -989,7 +989,7 @@ sub round
     {
     $self->bfround(int($p),$r) if !defined $self->{_p} || $self->{_p} <= $p;
     }
-  # bround() or bfround() already callled bnorm() if nec.
+  # bround() or bfround() already called bnorm() if nec.
   $self;
   }
 
@@ -1402,7 +1402,7 @@ sub bgcd
   { 
   # (BINT or num_str, BINT or num_str) return BINT
   # does not modify arguments, but returns new object
-  # GCD -- Euclids algorithm, variant C (Knuth Vol 3, pg 341 ff)
+  # GCD -- Euclid's algorithm, variant C (Knuth Vol 3, pg 341 ff)
 
   my $y = shift;
   $y = $class->new($y) if !ref($y);
@@ -1859,7 +1859,7 @@ sub bmodinv
 sub bmodpow
   {
   # takes a very large number to a very large exponent in a given very
-  # large modulus, quickly, thanks to binary exponentation. Supports
+  # large modulus, quickly, thanks to binary exponentiation. Supports
   # negative exponents.
   my ($self,$num,$exp,$mod,@r) = objectify(3,@_);
 
@@ -2886,7 +2886,7 @@ sub _split
   # invalid input.
   my $x = shift;
 
-  # strip white space at front, also extranous leading zeros
+  # strip white space at front, also extraneous leading zeros
   $x =~ s/^\s*([-]?)0*([0-9])/$1$2/g;   # will not strip '  .2'
   $x =~ s/^\s+//;                       # but this will
   $x =~ s/\s+$//g;                      # strip white space at end
@@ -3212,8 +3212,8 @@ Math::BigInt - Arbitrary size integer/float math package
   $x->bmuladd($y,$z);	# $x = $x * $y + $z
 
   $x->bmod($y);		   # modulus (x % y)
-  $x->bmodpow($exp,$mod);  # modular exponentation (($num**$exp) % $mod))
-  $x->bmodinv($mod);	   # the multiplicative inverse of $x modulo $mod
+  $x->bmodpow($exp,$mod);  # modular exponentiation (($num**$exp) % $mod)
+  $x->bmodinv($mod);	   # the inverse of $x in the given modulus $mod
 
   $x->bpow($y);		   # power of arguments (x ** y)
   $x->blsft($y);	   # left shift in base 2
@@ -3749,11 +3749,11 @@ inverse exists.
 
 =head2 bmodpow()
 
-	$num->bmodpow($exp,$mod);	# modular exponentation
+	$num->bmodpow($exp,$mod);	# modular exponentiation
 					# ($num**$exp % $mod)
 
 Returns the value of C<$num> taken to the power C<$exp> in the modulus
-C<$mod> using binary exponentation.  C<bmodpow> is far superior to
+C<$mod> using binary exponentiation.  C<bmodpow> is far superior to
 writing
 
 	$num ** $exp % $mod
@@ -4085,7 +4085,7 @@ the decimal point. For example, 123.45 has a precision of -2. 0 means an
 integer like 123 (or 120). A precision of 2 means two digits to the left
 of the decimal point are zero, so 123 with P = 1 becomes 120. Note that
 numbers with zeros before the decimal point may have different precisions,
-because 1200 can have p = 0, 1 or 2 (depending on what the inital value
+because 1200 can have p = 0, 1 or 2 (depending on what the initial value
 was). It could also have p < 0, when the digits after the decimal point
 are zero.
 
@@ -4232,7 +4232,7 @@ versions <= 5.7.2) is like this:
     assumption that 124 has 3 significant digits, while 120/7 will get you
     '17', not '17.1' since 120 is thought to have 2 significant digits.
     The rounding after the division then uses the remainder and $y to determine
-    wether it must round up or down.
+    whether it must round up or down.
  ?  I have no idea which is the right way. That's why I used a slightly more
  ?  simple scheme and tweaked the few failing testcases to match it.
 
diff --git a/dist/Math-BigInt/lib/Math/BigInt/Calc.pm b/dist/Math-BigInt/lib/Math/BigInt/Calc.pm
index 054e8984a7..f78457af43 100644
--- a/dist/Math-BigInt/lib/Math/BigInt/Calc.pm
+++ b/dist/Math-BigInt/lib/Math/BigInt/Calc.pm
@@ -1492,7 +1492,7 @@ sub _lsft
     }
   # set lowest parts to 0
   while ($dst >= 0) { $x->[$dst--] = 0; }
-  # fix spurios last zero element
+  # fix spurious last zero element
   splice @$x,-1 if $x->[-1] == 0;
   $x;
   }
diff --git a/dist/Math-BigInt/t/bare_mif.t b/dist/Math-BigInt/t/bare_mif.t
index 2c80f7fedd..2e533241ea 100644
--- a/dist/Math-BigInt/t/bare_mif.t
+++ b/dist/Math-BigInt/t/bare_mif.t
@@ -1,6 +1,6 @@
 #!/usr/bin/perl -w
 
-# test rounding, accuracy, precicion and fallback, round_mode and mixing
+# test rounding, accuracy, precision and fallback, round_mode and mixing
 # of classes under BareCalc
 
 use strict;
diff --git a/dist/Math-BigInt/t/bigfltpm.inc b/dist/Math-BigInt/t/bigfltpm.inc
index 8c349c951b..743752e07e 100644
--- a/dist/Math-BigInt/t/bigfltpm.inc
+++ b/dist/Math-BigInt/t/bigfltpm.inc
@@ -726,7 +726,7 @@ abc:NaN
 -123456E-2:-1234.56
 1e1:10
 2e-11:0.00000000002
-# excercise _split
+# exercise _split
   .02e-1:0.002
    000001:1
    -00001:-1
diff --git a/dist/Math-BigInt/t/bigintc.t b/dist/Math-BigInt/t/bigintc.t
index 3123ff8668..d5837f0890 100644
--- a/dist/Math-BigInt/t/bigintc.t
+++ b/dist/Math-BigInt/t/bigintc.t
@@ -313,7 +313,7 @@ $x = $C->_new("11"); is ($C->_str($C->_fac($x)),'39916800');
 $x = $C->_new("12"); is ($C->_str($C->_fac($x)),'479001600');
 $x = $C->_new("13"); is ($C->_str($C->_fac($x)),'6227020800');
 
-# test that _fac modifes $x in place for small arguments
+# test that _fac modifies $x in place for small arguments
 $x = $C->_new("3"); $C->_fac($x); is ($C->_str($x),'6');
 $x = $C->_new("13"); $C->_fac($x); is ($C->_str($x),'6227020800');
 
diff --git a/dist/Math-BigInt/t/bigintpm.inc b/dist/Math-BigInt/t/bigintpm.inc
index 822b44610e..47daa409a0 100644
--- a/dist/Math-BigInt/t/bigintpm.inc
+++ b/dist/Math-BigInt/t/bigintpm.inc
@@ -1672,7 +1672,7 @@ inf:0:inf
 84696969696969696943434343434871161616161616161452525252486813131313131313143230042929292929292930:13131313131313131313131313131394949494949494949494949494943535353535353535353535:6449999999999999998
 84696969696969696969696969697497424242424242424242424242385803030303030303030300750000000000000000:13131313131313131313131313131394949494949494949494949494943535353535353535353535:6450000000000000000
 84696969696969696930303030303558030303030303030057575757537318181818181818199694689393939393939395:13131313131313131313131313131394949494949494949494949494943535353535353535353535:6449999999999999997
-# excercise shortcut for numbers of the same length in div
+# exercise shortcut for numbers of the same length in div
 999999999999999999999999999999999:999999999999999999999999999999999:1
 999999999999999999999999999999999:888888888888888888888888888888888:1
 999999999999999999999999999999999:777777777777777777777777777777777:1
diff --git a/dist/Math-BigInt/t/calling.t b/dist/Math-BigInt/t/calling.t
index 5fa25315af..6cdb4ac92f 100644
--- a/dist/Math-BigInt/t/calling.t
+++ b/dist/Math-BigInt/t/calling.t
@@ -83,7 +83,7 @@ $try .= ' $x = 2**150; bgcd($x); $x = "$x";';
 $ans = eval $try;
 is ( $ans, "1427247692705959881058285969449495136382746624");
 
-# test wether Math::BigInt::Scalar via use works (w/ dff. spellings of calc)
+# test whether Math::BigInt::Scalar via use works (w/ dff. spellings of calc)
 $try = "use $class ($version,'lib','Scalar');";
 $try .= ' $x = 2**10; $x = "$x";';
 $ans = eval $try; is ( $ans, "1024");
diff --git a/dist/Math-BigInt/t/mbimbf.inc b/dist/Math-BigInt/t/mbimbf.inc
index 50e0ebc7df..7b2c94613c 100644
--- a/dist/Math-BigInt/t/mbimbf.inc
+++ b/dist/Math-BigInt/t/mbimbf.inc
@@ -1,4 +1,4 @@
-# test rounding, accuracy, precicion and fallback, round_mode and mixing
+# test rounding, accuracy, precision and fallback, round_mode and mixing
 # of classes
 
 # Make sure you always quote any bare floating-point values, lest 123.46 will
@@ -274,8 +274,8 @@ foreach my $c ($mbi,$mbf)
   }
 
 ###############################################################################
-# test wether operations round properly afterwards
-# These tests are not complete, since they do not excercise every "return"
+# test whether operations round properly afterwards
+# These tests are not complete, since they do not exercise every "return"
 # statement in the op's. But heh, it's better than nothing...
 
 $x = $mbf->new('123.456');
diff --git a/dist/Math-BigInt/t/mbimbf.t b/dist/Math-BigInt/t/mbimbf.t
index 63e9bb3d25..7d8afb07c9 100644
--- a/dist/Math-BigInt/t/mbimbf.t
+++ b/dist/Math-BigInt/t/mbimbf.t
@@ -1,6 +1,6 @@
 #!/usr/bin/perl -w
 
-# test rounding, accuracy, precicion and fallback, round_mode and mixing
+# test rounding, accuracy, precision and fallback, round_mode and mixing
 # of classes
 
 use strict;
diff --git a/dist/Math-BigInt/t/sub_mif.t b/dist/Math-BigInt/t/sub_mif.t
index 3ccbca0403..6317e97cf3 100644
--- a/dist/Math-BigInt/t/sub_mif.t
+++ b/dist/Math-BigInt/t/sub_mif.t
@@ -1,6 +1,6 @@
 #!/usr/bin/perl -w
 
-# test rounding, accuracy, precicion and fallback, round_mode and mixing
+# test rounding, accuracy, precision and fallback, round_mode and mixing
 # of classes
 
 use strict;
diff --git a/dist/Math-BigInt/t/upgrade.inc b/dist/Math-BigInt/t/upgrade.inc
index 5c8d11a4a8..088c567762 100644
--- a/dist/Math-BigInt/t/upgrade.inc
+++ b/dist/Math-BigInt/t/upgrade.inc
@@ -581,7 +581,7 @@ abc:abc:NaN
 +4294967296:+32:1
 +281474976710656:+48:1
 +2:-2:NaN
-# excercise base 10
+# exercise base 10
 -1234:0:10:-1234
 +1234:0:10:1234
 +200:2:10:2