Rename "modulus" to "remainder" (#4860)

Author: aaronfranke

.openpublishing.redirection.json

@@ -329,6 +329,14 @@
             "source_path": "docs/csharp/interop.md",
             "redirect_url": "/dotnet/csharp/programming-guide/interop/index"
         },
+        {
+            "source_path": "docs/csharp/language-reference/operators/modulus-assignment-operator.md",
+            "redirect_url": "/dotnet/csharp/language-reference/operators/remainder-assignment-operator"
+        },
+        {
+            "source_path": "docs/csharp/language-reference/operators/modulus-operator.md",
+            "redirect_url": "/dotnet/csharp/language-reference/operators/remainder-operator"
+        },
         {
             "source_path": "docs/csharp/namespaces-and-assemblies.md",
             "redirect_url": "/dotnet/csharp/programming-guide/namespaces/index"

docs/csharp/language-reference/operators/and-operator.md

@@ -1,6 +1,6 @@
 ---
 title: "& Operator (C# Reference)"
-ms.date: 07/20/2015
+ms.date: 04/04/2018
 ms.prod: .net
 ms.technology: 
   - "devlang-csharp"
@@ -18,14 +18,14 @@ author: "BillWagner"
 ms.author: "wiwagn"
 ---
 # & Operator (C# Reference)
-The & operator can function as either a unary or a binary operator.  
+The `&` operator can function as either a unary or a binary operator.  
 
 ## Remarks  
- The unary & operator returns the address of its operand (requires [unsafe](../../../csharp/language-reference/keywords/unsafe.md) context).  
+ The unary `&` operator returns the address of its operand (requires [unsafe](../../../csharp/language-reference/keywords/unsafe.md) context).  
 
- Binary & operators are predefined for the integral types and `bool`. For integral types, & computes the logical bitwise AND of its operands. For `bool` operands, & computes the logical AND of its operands; that is, the result is `true` if and only if both its operands are `true`.  
+ Binary `&` operators are predefined for the integral types and `bool`. For integral types, & computes the logical bitwise AND of its operands. For `bool` operands, & computes the logical AND of its operands; that is, the result is `true` if and only if both its operands are `true`.  
 
- The `&` operator evaluates both operators regardless of the first one's value. For example:  
+ The binary `&` operator evaluates both operators regardless of the first one's value, in contrast to the [conditional AND operator](../../../csharp/language-reference/operators/conditional-and-operator.md) `&&`. For example:  
 
  [!code-csharp[csRefOperators#37](../../../csharp/language-reference/operators/codesnippet/CSharp/and-operator_1.cs)]  
 

docs/csharp/language-reference/operators/codesnippet/CSharp/modulus-operator_1.cs renamed to docs/csharp/language-reference/operators/codesnippet/CSharp/remainder-operator_1.cs

@@ -1,6 +1,6 @@
 ---
 title: "/ Operator (C# Reference)"
-ms.date: 07/20/2015
+ms.date: 04/04/2018
 ms.prod: .net
 ms.technology: 
   - "devlang-csharp"
@@ -16,12 +16,16 @@ author: "BillWagner"
 ms.author: "wiwagn"
 ---
 # / Operator (C# Reference)
-The division operator (`/`) divides its first operand by its second operand. All numeric types have predefined division operators.  
+The division operator (`/`) divides its first operand by its second operand. All numeric types have predefined division operators.
 
 ## Remarks  
  User-defined types can overload the `/` operator (see [operator](../../../csharp/language-reference/keywords/operator.md)). An overload of the `/` operator implicitly overloads the [/= operator](division-assignment-operator.md).  
 
- When you divide two integers, the result is always an integer. For example, the result of 7 / 3 is 2. To determine the remainder of 7 / 3, use the remainder operator ([%](../../../csharp/language-reference/operators/modulus-operator.md)). To obtain a quotient as a rational number or fraction, give the dividend or divisor type `float` or type `double`. You can assign the type implicitly if you express the dividend or divisor as a decimal by putting a digit to the right side of the decimal point, as the following example shows.  
+ When you divide two integers, the result is always an integer. For example, the result of 7 / 3 is 2. This is not to be confused with floored division, as the `/` operator rounds towards zero: -7 / 3 is -2.  
+  
+ To obtain a quotient as a rational number, use the `float`, `double`, or `decimal` types. There are many ways to convert between [built in numeric types](../../../csharp/language-reference/keywords/reference-tables-for-types.md).  
+  
+ To determine the remainder, use the [remainder operator](../../../csharp/language-reference/operators/remainder-operator.md) `%`.  
 
 ## Example  
  [!code-csharp[csRefOperators#42](../../../csharp/language-reference/operators/codesnippet/CSharp/division-operator_1.cs)]  

docs/csharp/language-reference/operators/division-operator.md

@@ -1,6 +1,6 @@
 ---
 title: "C# Operators"
-ms.date: 03/09/2017
+ms.date: 04/04/2018
 ms.prod: .net
 ms.technology: 
   - "devlang-csharp"
@@ -96,7 +96,7 @@ C# provides many operators, which are symbols that specify which operations (mat
 
  [x / y](../../../csharp/language-reference/operators/division-operator.md) – division. If the operands are integers, the result is an integer truncated toward zero (for example, `-7 / 2 is -3`).  
 
- [x % y](../../../csharp/language-reference/operators/modulus-operator.md) – modulus. If the operands are integers, this returns the remainder of dividing x by y.  If `q = x / y` and `r = x % y`, then `x = q * y + r`.  
+ [x % y](../../../csharp/language-reference/operators/remainder-operator.md) – remainder. If the operands are integers, this returns the remainder of dividing x by y.  If `q = x / y` and `r = x % y`, then `x = q * y + r`.  
 
 ## Additive Operators  
  These operators have higher precedence than the next section and lower precedence than the previous section.  
@@ -182,7 +182,7 @@ C# provides many operators, which are symbols that specify which operations (mat
 
  [x /= y](../../../csharp/language-reference/operators/division-assignment-operator.md) – division assignment. Divide the value of `x` by the value of `y`, store the result in `x`, and return the new value.  
 
- [x %= y](../../../csharp/language-reference/operators/modulus-assignment-operator.md) – modulus assignment. Divide the value of `x` by the value of `y`, store the remainder in `x`, and return the new value.  
+ [x %= y](../../../csharp/language-reference/operators/remainder-assignment-operator.md) – remainder assignment. Divide the value of `x` by the value of `y`, store the remainder in `x`, and return the new value.  
 
  [x &= y](../../../csharp/language-reference/operators/and-assignment-operator.md) – AND assignment. AND the value of `y` with the value of `x`, store the result in `x`, and return the new value.  
 

docs/csharp/language-reference/operators/index.md

@@ -1,6 +1,6 @@
 ---
 title: "* Operator (C# Reference)"
-ms.date: 07/20/2015
+ms.date: 04/04/2018
 ms.prod: .net
 ms.technology: 
   - "devlang-csharp"
@@ -16,11 +16,11 @@ author: "BillWagner"
 ms.author: "wiwagn"
 ---
 # * Operator (C# Reference)
-The multiplication operator (`*`), which computes the product of its operands.  Also, the dereference operator, which allows reading and writing to a pointer.  
+The multiplication operator (`*`) computes the product of its operands. All numeric types have predefined multiplication operators.  
+
+`*` also serves as the dereference operator, which allows reading and writing to a pointer.
 
 ## Remarks  
- All numeric types have predefined multiplication operators.  
-  
  The `*` operator is also used to declare pointer types and to dereference pointers. This operator can only be used in unsafe contexts, denoted by the use of the [unsafe](../../../csharp/language-reference/keywords/unsafe.md) keyword, and requiring the [/unsafe](../../../csharp/language-reference/compiler-options/unsafe-compiler-option.md) compiler option.  The dereference operator is also known as the indirection operator.  
 
  User-defined types can overload the binary `*` operator (see [operator](../../../csharp/language-reference/keywords/operator.md)). When a binary operator is overloaded, the corresponding assignment operator, if any, is also implicitly overloaded.  

docs/csharp/language-reference/operators/multiplication-operator.md

@@ -1,15 +1,15 @@
 ---
 title: "%= Operator (C# Reference)"
-ms.date: 07/20/2015
+ms.date: 04/04/2018
 ms.prod: .net
 ms.technology: 
   - "devlang-csharp"
 ms.topic: "article"
 f1_keywords: 
   - "%=_CSharpKeyword"
 helpviewer_keywords: 
-  - "modulus assignment operator (=%) [C#]"
-  - "%= assignment operator (modulus assignment) [C#]"
+  - "remainder assignment operator (%=) [C#]"
+  - "%= assignment operator (remainder assignment) [C#]"
 ms.assetid: 47e5f068-1d97-4010-bd3b-e21b5d3a77f5
 caps.latest.revision: 20
 author: "BillWagner"
@@ -31,9 +31,9 @@ x %= y
 x = x % y  
 ```  
 
- except that `x` is only evaluated once. The [% operator](../../../csharp/language-reference/operators/modulus-operator.md) is predefined for numeric types to compute the remainder after division.  
+ except that `x` is only evaluated once. The [% operator](../../../csharp/language-reference/operators/remainder-operator.md) is predefined for numeric types to compute the remainder after division.  
 
- The `%=` operator cannot be overloaded directly, but user-defined types can overload the [% operator](../../../csharp/language-reference/operators/modulus-operator.md) (see [operator (C# Reference)](../../../csharp/language-reference/keywords/operator.md)).  
+ The `%=` operator cannot be overloaded directly, but user-defined types can overload the [% operator](../../../csharp/language-reference/operators/remainder-operator.md) (see [operator (C# Reference)](../../../csharp/language-reference/keywords/operator.md)).  
 
 ## Example  
  [!code-csharp[csRefOperators#4](../../../csharp/language-reference/operators/codesnippet/CSharp/modulus-assignment-operator_1.cs)]  

docs/csharp/language-reference/operators/modulus-assignment-operator.md renamed to docs/csharp/language-reference/operators/remainder-assignment-operator.md

@@ -1,28 +1,32 @@
 ---
 title: "% Operator (C# Reference)"
-ms.date: 07/20/2015
+ms.date: 04/04/2018
 ms.prod: .net
 ms.technology: 
   - "devlang-csharp"
 ms.topic: "article"
 f1_keywords: 
   - "%_CSharpKeyword"
 helpviewer_keywords: 
-  - "modulus operator [C#]"
+  - "remainder operator [C#]"
   - "% operator [C#]"
 ms.assetid: 3b74f4f9-fd9c-45e7-84fa-c8d71a0dfad7
 caps.latest.revision: 15
 author: "BillWagner"
 ms.author: "wiwagn"
 ---
 # % Operator (C# Reference)
-The `%` operator computes the remainder after dividing its first operand by its second. All numeric types have predefined remainder operators.  
+The remainder operator (`%`) computes the remainder after dividing its first operand by its second. All numeric types have predefined remainder operators. 
 
 ## Remarks  
+ The formula `a % b` will always return a value on the range `(-b, b)`, exclusive (it can never return `b` or `-b`), keeping the sign of the dividend. For integer division, the remainder operator satisfies the rule `a % b = a - (a / b) * b`.
+  
+ This is not to be confused with canonical modulus, which satisfies a similar rule but with floored division and returns values on the range `[0, b)`. C# does not have an operator for canonical modulus. However, the behavior is the same for positive dividends.
+  
  User-defined types can overload the `%` operator (see [operator](../../../csharp/language-reference/keywords/operator.md)). When a binary operator is overloaded, the corresponding assignment operator, if any, is also implicitly overloaded.  
 
 ## Example  
- [!code-csharp[csRefOperators#9](../../../csharp/language-reference/operators/codesnippet/CSharp/modulus-operator_1.cs)]  
+ [!code-csharp[csRefOperators#9](../../../csharp/language-reference/operators/codesnippet/CSharp/remainder-operator_1.cs)]  
 
 ## Comments  
  Note the round-off errors associated with the double type.  

docs/csharp/language-reference/operators/modulus-operator.md renamed to docs/csharp/language-reference/operators/remainder-operator.md

@@ -4,7 +4,7 @@ description: Learn about the arithmetic operators that are available in the F# p
 keywords: visual f#, f#, functional programming
 author: cartermp
 ms.author: phcart
-ms.date: 05/16/2016
+ms.date: 04/04/2018
 ms.topic: language-reference
 ms.prod: .net
 ms.technology: devlang-fsharp
@@ -25,7 +25,7 @@ The following table summarizes the binary arithmetic operators that are availabl
 |`-` (subtraction, minus)|Unchecked. Possible underflow condition when unsigned types are subtracted, or when floating-point values are too small to be represented by the type.|
 |`*` (multiplication, times)|Unchecked. Possible overflow condition when numbers are multiplied and the product exceeds the maximum absolute value supported by the type.|
 |`/` (division, divided by)|Division by zero causes a <xref:System.DivideByZeroException> for integral types. For floating-point types, division by zero gives you the special floating-point values `+Infinity` or `-Infinity`. There is also a possible underflow condition when a floating-point number is too small to be represented by the type.|
-|`%` (modulus, mod)|Returns the remainder of a division operation. The sign of the result is the same as the sign of the first operand.|
+|`%` (remainder, rem)|Returns the remainder of a division operation. The sign of the result is the same as the sign of the first operand.|
 |`**` (exponentiation, to the power of)|Possible overflow condition when the result exceeds the maximum absolute value for the type.<br /><br />The exponentiation operator works only with floating-point types.|
 
 ## Summary of Unary Arithmetic Operators

docs/fsharp/language-reference/symbol-and-operator-reference/arithmetic-operators.md

@@ -4,7 +4,7 @@ description: Learn about the symbols and operators that are used in the F# progr
 keywords: visual f#, f#, functional programming
 author: cartermp
 ms.author: phcart
-ms.date: 05/16/2016
+ms.date: 04/04/2018
 ms.topic: language-reference
 ms.prod: .net
 ms.technology: devlang-fsharp
@@ -30,9 +30,9 @@ The following table describes symbols used in the F# language, provides links to
 |`"""`|[Strings](../strings.md)|Delimits a verbatim text string. Differs from `@"..."` in that a you can indicate a quotation mark character by using a single quote in the string.|
 |`#`|[Compiler Directives](../compiler-directives.md)<br /><br />[Flexible Types](../flexible-types.md)|<ul><li>Prefixes a preprocessor or compiler directive, such as `#light`.<br /></li><li>When used with a type, indicates a *flexible type*, which refers to a type or any one of its derived types.<br /></li><ul/>|
 |`$`|No more information available.|<ul><li>Used internally for certain compiler-generated variable and function names.<br /></li><ul/>|
-|`%`|[Arithmetic Operators](arithmetic-operators.md)<br /><br />[Code Quotations](../code-quotations.md)|<ul><li>Computes the integer modulus.<br /></li><li>Used for splicing expressions into typed code quotations.<br /></li><ul/>|
+|`%`|[Arithmetic Operators](arithmetic-operators.md)<br /><br />[Code Quotations](../code-quotations.md)|<ul><li>Computes the integer remainder.<br /></li><li>Used for splicing expressions into typed code quotations.<br /></li><ul/>|
 |`%%`|[Code Quotations](../code-quotations.md)|<ul><li>Used for splicing expressions into untyped code quotations.<br /></li><ul/>|
-|`%?`|[Nullable Operators](nullable-operators.md)|<ul><li>Computes the integer modulus, when the right side is a nullable type.<br /></li><ul/>|
+|`%?`|[Nullable Operators](nullable-operators.md)|<ul><li>Computes the integer remainder, when the right side is a nullable type.<br /></li><ul/>|
 |`&`|[Match Expressions](../match-expressions.md)|<ul><li>Computes the address of a mutable value, for use when interoperating with other languages.<br /></li><li>Used in AND patterns.<br /></li><ul/>|
 |`&&`|[Boolean Operators](boolean-operators.md)|<ul><li>Computes the Boolean AND operation.<br /></li><ul/>|
 |`&&&`|[Bitwise Operators](bitwise-operators.md)|<ul><li>Computes the bitwise AND operation.<br /></li><ul/>|