Edit documentation; nonsubstantive code edits

Author: peteroupc

Numbers/PeterO/Numbers/BitShiftAccumulator.cs

@@ -323,7 +323,7 @@ private FastInteger CalcKnownBitLength() {
     }
 
     private void ShiftBigToBits(int bits) {
-      // Shifts a number until it reaches the given number of bits,
+      // Shifts a number until it reaches the specified number of bits,
       // gathering information on whether the last bit discarded is set and
       // whether the discarded bits to the right of that bit are set. Assumes
       // that the big integer being shifted is positive.

Numbers/PeterO/Numbers/DigitShiftAccumulator.cs

@@ -714,7 +714,7 @@ private void ShiftRightLong(long shiftedLong, int digits) {
     }
 
     private void ShiftToDigitsBig(int digits, bool truncate) {
-      // Shifts a number until it reaches the given number of digits,
+      // Shifts a number until it reaches the specified number of digits,
       // gathering information on whether the last digit discarded is set
       // and whether the discarded digits to the right of that digit are set.
       // Assumes that the big integer being shifted is positive.

Numbers/PeterO/Numbers/NumberUtility.cs

@@ -843,7 +843,7 @@ public static EInteger IntegerDigitLengthUpperBound<THelper>(
        IRadixMathHelper<THelper> helper,
        THelper val) {
        // Gets an upper bound on the number of digits in the integer
-       // part of the given number 'val'.
+       // part of the specified number 'val'.
        int flags = helper.GetFlags(val);
        if ((flags & BigNumberFlags.FlagSpecial) != 0) {
           // Infinity and NaN are not supported

Numbers/PeterO/Numbers/RadixMath.cs

@@ -6504,7 +6504,7 @@ public T SignalOverflow(EContext ctx, bool neg) {
             (roundingOnOverflow == ERounding.Ceiling && neg) ||
             (roundingOnOverflow == ERounding.Floor && !neg))) {
           // Set to the highest possible value for
-          // the given precision
+          // the specified precision
           EInteger overflowMant = EInteger.Zero;
           FastInteger fastPrecision = FastInteger.FromBig(ctx.Precision);
           overflowMant = this.TryMultiplyByRadixPower(

Numbers/docs.xml

@@ -30,7 +30,7 @@ public RandomGenerator(IRandomGen valueIrg) {
       this.valueIrg = valueIrg;
     }
 
-    /// <summary>Returns either true or false, depending on the given
+    /// <summary>Returns either true or false, depending on the specified
     /// probability.</summary>
     /// <param name='p'>A probability from 0 through 1. 0 means always
     /// false, and 1 means always true.</param>
@@ -49,9 +49,9 @@ public bool Bernoulli() {
       return this.UniformInt(2) == 0;
     }
 
-    /// <summary>Conceptually, generates either 1 or 0 the given number of
-    /// times, where either number is equally likely, and counts the number
-    /// of 1's generated.</summary>
+    /// <summary>Conceptually, generates either 1 or 0 the specified number
+    /// of times, where either number is equally likely, and counts the
+    /// number of 1's generated.</summary>
     /// <param name='trials'>The number of times to generate a random
     /// number, conceptually.</param>
     /// <returns>A 32-bit signed integer.</returns>
@@ -68,9 +68,9 @@ public int GetBytes(byte[] bytes, int offset, int count) {
       return this.valueIrg.GetBytes(bytes, offset, count);
     }
 
-    /// <summary>Conceptually, generates either 1 or 0 the given number of
-    /// times, where a 1 is generated at the given probability, and counts
-    /// the number of 1's generated.</summary>
+    /// <summary>Conceptually, generates either 1 or 0 the specified number
+    /// of times, where a 1 is generated at the specified probability, and
+    /// counts the number of 1's generated.</summary>
     /// <param name='trials'>The number of times to generate a random
     /// number, conceptually.</param>
     /// <param name='p'>The probability for each trial to succeed, from 0
@@ -173,7 +173,7 @@ public int Geometric() {
 
     /// <summary>Conceptually, generates either 1 or 0 until a 1 is
     /// generated, and counts the number of 0's generated. A 1 is generated
-    /// at the given probability.</summary>
+    /// at the specified probability.</summary>
     /// <param name='p'>A 64-bit floating-point number.</param>
     /// <returns>The number of failures until a success happens.</returns>
     public int Geometric(double p) {
@@ -221,17 +221,17 @@ public int Hypergeometric(int trials, int ones, int count) {
     }
 
     /// <summary>Generates a logarithmic normally-distributed number with
-    /// the given mean and standard deviation.</summary>
+    /// the specified mean and standard deviation.</summary>
     /// <param name='mean'>The desired mean.</param>
     /// <param name='sd'>Standard deviation.</param>
     /// <returns>A 64-bit floating-point number.</returns>
     public double LogNormal(double mean, double sd) {
       return Math.Exp(this.Normal(mean, sd));
     }
 
-    /// <summary>Conceptually, generates either 1 or 0 until the given
+    /// <summary>Conceptually, generates either 1 or 0 until the specified
     /// number of 1's are generated, and counts the number of 0's
-    /// generated. A 1 is generated at the given probability.</summary>
+    /// generated. A 1 is generated at the specified probability.</summary>
     /// <param name='trials'>The number of 1's to generate before the
     /// process stops.</param>
     /// <param name='p'>The probability for each trial to succeed, from 0
@@ -288,10 +288,10 @@ public int NegativeBinomial(int trials, double p) {
       }
     }
 
-    /// <summary>Conceptually, generates either 1 or 0 the given number of
-    /// times until the given number of 1's are generated, and counts the
-    /// number of 0's generated. Either number has an equal probability of
-    /// being generated.</summary>
+    /// <summary>Conceptually, generates either 1 or 0 the specified number
+    /// of times until the specified number of 1's are generated, and
+    /// counts the number of 0's generated. Either number has an equal
+    /// probability of being generated.</summary>
     /// <param name='trials'>The number of 1's to generate before the
     /// process stops.</param>
     /// <returns>The number of 0's generated. Returns Int32.MaxValue if "p"
@@ -325,7 +325,7 @@ public double Normal() {
       return s * Math.Cos(t);
     }
 
-    /// <summary>Generates a normally-distributed number with the given
+    /// <summary>Generates a normally-distributed number with the specified
     /// mean and standard deviation.</summary>
     /// <param name='mean'>The desired mean.</param>
     /// <param name='sd'>Standard deviation.</param>
@@ -335,8 +335,8 @@ public double Normal(double mean, double sd) {
     }
 
     /// <summary>Generates a random integer such that the average of random
-    /// numbers approaches the given mean number when this method is called
-    /// repeatedly with the same mean.</summary>
+    /// numbers approaches the specified mean number when this method is
+    /// called repeatedly with the same mean.</summary>
     /// <param name='mean'>The expected mean of the random numbers.</param>
     /// <returns>A 32-bit signed integer.</returns>
     public int Poisson(double mean) {
@@ -369,7 +369,7 @@ public double Uniform(double min, double max) {
     }
 
     /// <summary>Returns a uniformly-distributed 64-bit floating-point
-    /// number from 0 and up, but less than the given number.</summary>
+    /// number from 0 and up, but less than the specified number.</summary>
     /// <param name='max'>Number that the randomly-generated number will be
     /// less than.</param>
     /// <returns>A 64-bit floating-point number.</returns>
@@ -460,7 +460,7 @@ public long UniformLong(long minInclusive, long maxExclusive) {
     }
 
     /// <summary>Generates a random 32-bit signed integer 0 or greater and
-    /// less than the given number.</summary>
+    /// less than the specified number.</summary>
     /// <param name='maxExclusive'>One plus the largest possible value of
     /// the random number.</param>
     /// <returns>A 32-bit signed integer.</returns>
@@ -533,7 +533,7 @@ public int GetInt32(int maxExclusive) {
     }
 
     /// <summary>Generates a random 32-bit signed integer 0 or greater and
-    /// less than the given number.</summary>
+    /// less than the specified number.</summary>
     /// <param name='maxExclusive'>One plus the largest possible value of
     /// the random number.</param>
     /// <returns>A 64-bit signed integer.</returns>