diff --git a/xml/System.Numerics/Complex.xml b/xml/System.Numerics/Complex.xml
index dabce831640..1764baa24bb 100644
--- a/xml/System.Numerics/Complex.xml
+++ b/xml/System.Numerics/Complex.xml
@@ -1832,6 +1832,37 @@
         <altmember cref="F:System.Numerics.Complex.Zero" />
       </Docs>
     </Member>
+    <MemberGroup MemberName="op_Addition">
+      <Docs>
+        <summary>Adds a specified number to another specified number, where at least one of them is a complex number, and the other could be a double-precision real number.</summary>
+        <remarks>
+          <format type="text/markdown">
+  <![CDATA[
+
+## Remarks
+
+The <xref:System.Numerics.Complex.op_Addition%2A> operator allows performing addition operations that involve complex numbers. It enables code such as the following:
+
+[!code-csharp[System.Numerics.Complex.Add#3](~/samples/snippets/csharp/VS_Snippets_CLR_System/system.numerics.complex.add/cs/add3.cs#3)]
+[!code-vb[System.Numerics.Complex.Add#3](~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.numerics.complex.add/vb/add3.vb#3)]
+
+If the addition results in an overflow in either the real or imaginary component, the value of that component is either <xref:System.Double.PositiveInfinity?displayProperty=nameWithType> or <xref:System.Double.NegativeInfinity?displayProperty=nameWithType>.
+
+Languages that do not support custom operators can call the <xref:System.Numerics.Complex.Add%2A> equivalent group of methods instead.
+
+The <xref:System.Numerics.Complex.op_Addition%2A> operators that receive one double are more efficient than the operators that receive two Complex numbers.
+
+## Examples
+
+The following example illustrates addition with complex numbers:
+
+[!code-csharp[System.Numerics.Complex.Add#2](~/samples/snippets/csharp/VS_Snippets_CLR_System/system.numerics.complex.add/cs/add2.cs#2)]
+[!code-vb[System.Numerics.Complex.Add#2](~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.numerics.complex.add/vb/add2.vb#2)]
+
+          ]]></format>
+        </remarks>
+      </Docs>
+    </MemberGroup>
     <Member MemberName="op_Addition">
       <MemberSignature Language="C#" Value="public static System.Numerics.Complex operator + (double left, System.Numerics.Complex right);" />
       <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.Complex op_Addition(float64 left, valuetype System.Numerics.Complex right) cil managed" />
@@ -1858,11 +1889,24 @@
         <Parameter Name="right" Type="System.Numerics.Complex" Index="1" FrameworkAlternate="netcore-3.0" />
       </Parameters>
       <Docs>
-        <param name="left">To be added.</param>
-        <param name="right">To be added.</param>
-        <summary>To be added.</summary>
-        <returns>To be added.</returns>
-        <remarks>To be added.</remarks>
+        <param name="left">The double-precision real value to add.</param>
+        <param name="right">The complex value to add.</param>
+        <summary>Adds a double-precision real number to a complex number.</summary>
+        <returns>The sum of <paramref name="left" /> and <paramref name="right" /> as a complex number.</returns>
+        <remarks>
+          <format type="text/markdown"><![CDATA[
+
+## Remarks
+
+The addition of a real number (which can be regarded as the complex number a + 0i) and a complex number (c + di) takes the following form:
+
+(a + c) + di
+
+Languages that do not support custom operators can call the <xref:System.Numerics.Complex.Add%28System.Double%2CSystem.Numerics.Complex%29?displayProperty=nameWithType> equivalent method instead.
+
+          ]]></format>
+        </remarks>
+        <altmember cref="M:System.Numerics.Complex.Add(System.NDouble,System.Numerics.Complex)" />
       </Docs>
     </Member>
     <Member MemberName="op_Addition">
@@ -1891,11 +1935,24 @@
         <Parameter Name="right" Type="System.Double" Index="1" FrameworkAlternate="netcore-3.0" />
       </Parameters>
       <Docs>
-        <param name="left">To be added.</param>
-        <param name="right">To be added.</param>
-        <summary>To be added.</summary>
-        <returns>To be added.</returns>
-        <remarks>To be added.</remarks>
+        <param name="left">The complex value to add.</param>
+        <param name="right">The double-precision real value to add.</param>
+        <summary>Adds a complex number to a double-precision real number.</summary>
+        <returns>The sum of <paramref name="left" /> and <paramref name="right" /> as a complex number.</returns>
+        <remarks>
+          <format type="text/markdown"><![CDATA[
+
+## Remarks
+
+The addition of a complex number (a + bi) and a real number (which can be regarded as the complex number c + 0i) takes the following form:
+
+(a + c) + bi
+
+Languages that do not support custom operators can call the <xref:System.Numerics.Complex.Add%28System.Double%2CSystem.Numerics.Complex%29?displayProperty=nameWithType> equivalent method instead.
+
+          ]]></format>
+        </remarks>
+        <altmember cref="M:System.Numerics.Complex.Add(System.Numerics.Complex,System.Double)" />
       </Docs>
     </Member>
     <Member MemberName="op_Addition">
@@ -1930,40 +1987,50 @@
         <Parameter Name="right" Type="System.Numerics.Complex" />
       </Parameters>
       <Docs>
-        <param name="left">The first value to add.</param>
-        <param name="right">The second value to add.</param>
+        <param name="left">The first complex value to add.</param>
+        <param name="right">The second complex value to add.</param>
         <summary>Adds two complex numbers.</summary>
         <returns>The sum of <paramref name="left" /> and <paramref name="right" />.</returns>
         <remarks>
-          <format type="text/markdown"><![CDATA[  
-  
-## Remarks  
- The <xref:System.Numerics.Complex.op_Addition%2A> method defines the addition operation for complex numbers. It enables code such as the following:  
-  
- [!code-csharp[System.Numerics.Complex.Add#3](~/samples/snippets/csharp/VS_Snippets_CLR_System/system.numerics.complex.add/cs/add3.cs#3)]
- [!code-vb[System.Numerics.Complex.Add#3](~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.numerics.complex.add/vb/add3.vb#3)]  
-  
- The addition of a complex number, a + bi, and a second complex number, c + di, takes the following form:  
-  
- (a + c) + (b + d)i  
-  
- If the method call results in an overflow in either the real or imaginary component, the value of that component is either <xref:System.Double.PositiveInfinity?displayProperty=nameWithType> or <xref:System.Double.NegativeInfinity?displayProperty=nameWithType>.  
-  
- Languages that do not support custom operators can call the <xref:System.Numerics.Complex.Add%2A> method instead.  
-  
- The equivalent method for this operator is <xref:System.Numerics.Complex.Add%28System.Numerics.Complex%2CSystem.Numerics.Complex%29?displayProperty=nameWithType>  
-  
-## Examples  
- The following example illustrates addition with complex numbers.  
-  
- [!code-csharp[System.Numerics.Complex.Add#2](~/samples/snippets/csharp/VS_Snippets_CLR_System/system.numerics.complex.add/cs/add2.cs#2)]
- [!code-vb[System.Numerics.Complex.Add#2](~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.numerics.complex.add/vb/add2.vb#2)]  
-  
- ]]></format>
+          <format type="text/markdown"><![CDATA[
+
+## Remarks
+
+The addition of a complex number, a + bi, and a second complex number, c + di, takes the following form:
+
+(a + c) + (b + d)i
+
+Languages that do not support custom operators can call the <xref:System.Numerics.Complex.Add%28System.Numerics.Complex%2CSystem.Double%29?displayProperty=nameWithType> equivalent method instead.
+
+          ]]></format>
         </remarks>
         <altmember cref="M:System.Numerics.Complex.Add(System.Numerics.Complex,System.Numerics.Complex)" />
       </Docs>
     </Member>
+    <MemberGroup MemberName="op_Division">
+      <Docs>
+        <summary>Divides a specified number by another specified number, where at least one of them is a complex number, and the other could be a double-precision real number.</summary>
+        <remarks>
+          <format type="text/markdown">
+  <![CDATA[
+
+## Remarks
+
+The <xref:System.Numerics.Complex.op_Division%2A> operator allows performing division operations that involve complex numbers. It enables code such as the following:
+
+[!code-csharp[System.Numerics.Complex.Divide#2](~/samples/snippets/csharp/VS_Snippets_CLR_System/system.numerics.complex.divide/cs/divide2.cs#2)]
+[!code-vb[System.Numerics.Complex.Divide#2](~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.numerics.complex.divide/vb/divide2.vb#2)]
+
+If the division results in an overflow in either the real or imaginary component, the value of that component is either <xref:System.Double.PositiveInfinity?displayProperty=nameWithType> or <xref:System.Double.NegativeInfinity?displayProperty=nameWithType>.
+
+Languages that do not support custom operators and operator overloading can call the <xref:System.Numerics.Complex.Divide%2A> equivalent group of method instead.
+
+The <xref:System.Numerics.Complex.op_Division%2A> operators that receive one double are more efficient than the operators that receive two Complex numbers.
+
+          ]]></format>
+        </remarks>
+      </Docs>
+    </MemberGroup>
     <Member MemberName="op_Division">
       <MemberSignature Language="C#" Value="public static System.Numerics.Complex operator / (double left, System.Numerics.Complex right);" />
       <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.Complex op_Division(float64 left, valuetype System.Numerics.Complex right) cil managed" />
@@ -1990,11 +2057,24 @@
         <Parameter Name="right" Type="System.Numerics.Complex" Index="1" FrameworkAlternate="netcore-3.0" />
       </Parameters>
       <Docs>
-        <param name="left">To be added.</param>
-        <param name="right">To be added.</param>
-        <summary>To be added.</summary>
-        <returns>To be added.</returns>
-        <remarks>To be added.</remarks>
+        <param name="left">The double-precision real value to be divided.</param>
+        <param name="right">The complex value to divide by.</param>
+        <summary>Divides a specified double-precision real number by a specified complex number.</summary>
+        <returns>The result of dividing <paramref name="left" /> by <paramref name="right" />, as a complex number.</returns>
+        <remarks>
+          <format type="text/markdown"><![CDATA[
+
+## Remarks
+
+The division of a real number (which can be regarded as the complex number a + 0i) and a complex number (c + di) takes the following form:
+
+(ac / (c<sup>2</sup> + d<sup>2</sup>)) + (ad / (c<sup>2</sup> + d<sup>2</sup>)i
+
+Languages that do not support custom operators and operator overloading can call the <xref:System.Numerics.Complex.Divide%28System.Double%2CSystem.Numerics.Complex%29?displayProperty=nameWithType> equivalent method instead.
+
+          ]]></format>
+        </remarks>
+        <altmember cref="M:System.Numerics.Complex.Divide(System.Double,System.Numerics.Complex)" />
       </Docs>
     </Member>
     <Member MemberName="op_Division">
@@ -2023,11 +2103,24 @@
         <Parameter Name="right" Type="System.Double" Index="1" FrameworkAlternate="netcore-3.0" />
       </Parameters>
       <Docs>
-        <param name="left">To be added.</param>
-        <param name="right">To be added.</param>
-        <summary>To be added.</summary>
-        <returns>To be added.</returns>
-        <remarks>To be added.</remarks>
+        <param name="left">The complex value to be divided.</param>
+        <param name="right">The double-precision real value to divide by.</param>
+        <summary>Divides a specified complex number by a specified double-precision real number.</summary>
+        <returns>The result of dividing <paramref name="left" /> by <paramref name="right" />, as a complex number.</returns>
+        <remarks>
+          <format type="text/markdown"><![CDATA[
+
+## Remarks
+
+The division of a complex number (a + bi) and a real number (which can be regarded as the complex number c + 0i) takes the following form:
+
+(ac / c<sup>2</sup>) + (bc / c<sup>2</sup>)i
+
+Languages that do not support custom operators and operator overloading can call the <xref:System.Numerics.Complex.Divide%28System.Numerics.Complex%2CSystem.Double%29?displayProperty=nameWithType> equivalent method instead.
+
+          ]]></format>
+        </remarks>
+        <altmember cref="M:System.Numerics.Complex.Divide(System.Numerics.Complex,System.Double)" />
       </Docs>
     </Member>
     <Member MemberName="op_Division">
@@ -2062,28 +2155,22 @@
         <Parameter Name="right" Type="System.Numerics.Complex" />
       </Parameters>
       <Docs>
-        <param name="left">The value to be divided.</param>
-        <param name="right">The value to divide by.</param>
+        <param name="left">The complex value to be divided.</param>
+        <param name="right">The complex value to divide by.</param>
         <summary>Divides a specified complex number by another specified complex number.</summary>
         <returns>The result of dividing <paramref name="left" /> by <paramref name="right" />.</returns>
         <remarks>
-          <format type="text/markdown"><![CDATA[  
-  
-## Remarks  
- The <xref:System.Numerics.Complex.op_Division%2A> method defines the division operation for complex numbers. It enables code such as the following:  
-  
- [!code-csharp[System.Numerics.Complex.Divide#2](~/samples/snippets/csharp/VS_Snippets_CLR_System/system.numerics.complex.divide/cs/divide2.cs#2)]
- [!code-vb[System.Numerics.Complex.Divide#2](~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.numerics.complex.divide/vb/divide2.vb#2)]  
-  
- The division of a complex number, a + bi, and a second complex number, c + di, takes the following form:  
-  
- ((ac + bd) / (c<sup>2</sup> + d<sup>2</sup>)) + ((bc - ad) / (c<sup>2</sup> + d<sup>2</sup>)i  
-  
- If the division results in an overflow in either the real or imaginary component, the value of that component is either <xref:System.Double.PositiveInfinity?displayProperty=nameWithType> or <xref:System.Double.NegativeInfinity?displayProperty=nameWithType>.  
-  
- Languages that do not support custom operators and operator overloading can call the <xref:System.Numerics.Complex.Divide%2A> method instead.  
-  
- The equivalent method for this operator is <xref:System.Numerics.Complex.Divide%28System.Numerics.Complex%2CSystem.Numerics.Complex%29?displayProperty=nameWithType>]]></format>
+          <format type="text/markdown"><![CDATA[
+
+## Remarks
+
+The division of a complex number, a + bi, and a second complex number, c + di, takes the following form:
+
+((ac + bd) / (c<sup>2</sup> + d<sup>2</sup>)) + ((bc - ad) / (c<sup>2</sup> + d<sup>2</sup>)i
+
+Languages that do not support custom operators and operator overloading can call the <xref:System.Numerics.Complex.Divide%28System.Numerics.Complex%2CSystem.Double%29?displayProperty=nameWithType> equivalent method instead.
+
+          ]]></format>
         </remarks>
         <altmember cref="M:System.Numerics.Complex.Divide(System.Numerics.Complex,System.Numerics.Complex)" />
       </Docs>
@@ -2851,6 +2938,30 @@ This API is not CLS-compliant.</summary>
         <altmember cref="M:System.Numerics.Complex.op_Equality(System.Numerics.Complex,System.Numerics.Complex)" />
       </Docs>
     </Member>
+    <MemberGroup MemberName="op_Multiply">
+      <Docs>
+        <summary>Multiplies a specified number by another specified number, where at least one of them is a complex number, and the other could be a double-precision real number.</summary>
+        <remarks>
+          <format type="text/markdown">
+  <![CDATA[
+
+## Remarks
+
+The <xref:System.Numerics.Complex.op_Multiply%2A> operator allows performing multiplication operations that involve complex numbers. It enables code such as the following:
+
+[!code-csharp[System.Numerics.Complex.Multiply#2](~/samples/snippets/csharp/VS_Snippets_CLR_System/system.numerics.complex.multiply/cs/multiply2.cs#2)]
+[!code-vb[System.Numerics.Complex.Multiply#2](~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.numerics.complex.multiply/vb/multiply2.vb#2)]
+
+If the multiplication results in an overflow in either the real or imaginary component, the value of that component is either <xref:System.Double.PositiveInfinity?displayProperty=nameWithType> or <xref:System.Double.NegativeInfinity?displayProperty=nameWithType>.
+
+Languages that do not support custom operators can call the <xref:System.Numerics.Complex.Multiply%2A> equivalent group of methods instead.
+
+The <xref:System.Numerics.Complex.op_Multiply%2A> operators that receive one double are more efficient than the operators that receive two Complex numbers.
+
+          ]]></format>
+        </remarks>
+      </Docs>
+    </MemberGroup>
     <Member MemberName="op_Multiply">
       <MemberSignature Language="C#" Value="public static System.Numerics.Complex operator * (double left, System.Numerics.Complex right);" />
       <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.Complex op_Multiply(float64 left, valuetype System.Numerics.Complex right) cil managed" />
@@ -2877,11 +2988,25 @@ This API is not CLS-compliant.</summary>
         <Parameter Name="right" Type="System.Numerics.Complex" Index="1" FrameworkAlternate="netcore-3.0" />
       </Parameters>
       <Docs>
-        <param name="left">To be added.</param>
-        <param name="right">To be added.</param>
-        <summary>To be added.</summary>
-        <returns>To be added.</returns>
-        <remarks>To be added.</remarks>
+        <param name="left">The double-precision real value to multiply.</param>
+        <param name="right">The complex value to multiply.</param>
+        <summary>Multiplies a specified double-precision real number by a specified complex number.</summary>
+        <returns>The product of <paramref name="left" /> and <paramref name="right" />, as a complex number.</returns>
+        <remarks>
+          <format type="text/markdown"><![CDATA[
+
+## Remarks
+
+The multiplication of a real number (which can be regarded as the complex number a + 0i) and a complex number (c + di) takes the following form:
+
+ac + adi
+
+Languages that do not support custom operators can call the <xref:System.Numerics.Complex.Multiply%28System.Double%2CSystem.Numerics.Complex%29?displayProperty=nameWithType> equivalent method instead.
+
+
+          ]]></format>
+        </remarks>
+        <altmember cref="M:System.Numerics.Complex.Multiply(System.Double,System.Numerics.Complex)" />
       </Docs>
     </Member>
     <Member MemberName="op_Multiply">
@@ -2910,11 +3035,24 @@ This API is not CLS-compliant.</summary>
         <Parameter Name="right" Type="System.Double" Index="1" FrameworkAlternate="netcore-3.0" />
       </Parameters>
       <Docs>
-        <param name="left">To be added.</param>
-        <param name="right">To be added.</param>
-        <summary>To be added.</summary>
-        <returns>To be added.</returns>
-        <remarks>To be added.</remarks>
+        <param name="left">The complex value to multiply.</param>
+        <param name="right">The double-precision real value to multiply.</param>
+        <summary>Multiplies the specified complex number by a specified double-precision real number.</summary>
+        <returns>The product of <paramref name="left" /> and <paramref name="right" />, as a complex number.</returns>
+        <remarks>
+          <format type="text/markdown"><![CDATA[
+
+## Remarks
+
+The multiplication of a complex number (a + bi) and a real number (which can be regarded as the complex number c + 0i) takes the following form:
+
+ac + bci
+
+Languages that do not support custom operators can call the <xref:System.Numerics.Complex.Multiply%28System.Numerics.Complex%2CSystem.Double%29?displayProperty=nameWithType> equivalent method instead.
+
+          ]]></format>
+        </remarks>
+        <altmember cref="M:System.Numerics.Complex.Multiply(System.Numerics.Complex,System.Double)" />
       </Docs>
     </Member>
     <Member MemberName="op_Multiply">
@@ -2949,32 +3087,50 @@ This API is not CLS-compliant.</summary>
         <Parameter Name="right" Type="System.Numerics.Complex" />
       </Parameters>
       <Docs>
-        <param name="left">The first value to multiply.</param>
-        <param name="right">The second value to multiply.</param>
+        <param name="left">The first complex value to multiply.</param>
+        <param name="right">The second complex value to multiply.</param>
         <summary>Multiplies two specified complex numbers.</summary>
         <returns>The product of <paramref name="left" /> and <paramref name="right" />.</returns>
         <remarks>
-          <format type="text/markdown"><![CDATA[  
-  
-## Remarks  
- The <xref:System.Numerics.Complex.op_Multiply%2A> method defines the operation of the multiplication operator for complex numbers. It enables code such as the following:  
-  
- [!code-csharp[System.Numerics.Complex.Multiply#2](~/samples/snippets/csharp/VS_Snippets_CLR_System/system.numerics.complex.multiply/cs/multiply2.cs#2)]
- [!code-vb[System.Numerics.Complex.Multiply#2](~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.numerics.complex.multiply/vb/multiply2.vb#2)]  
-  
- The multiplication of a complex number, a + bi, and a second complex number, c + di, takes the following form:  
-  
- (ac - bd) + (ad + bc)i  
-  
- If the multiplication results in an overflow in either the real or imaginary component, the value of that component is either <xref:System.Double.PositiveInfinity?displayProperty=nameWithType> or <xref:System.Double.NegativeInfinity?displayProperty=nameWithType>.  
-  
- Languages that do not support custom operators can call the <xref:System.Numerics.Complex.Multiply%2A> method instead.  
-  
- The equivalent method for this operator is <xref:System.Numerics.Complex.Multiply%28System.Numerics.Complex%2CSystem.Numerics.Complex%29?displayProperty=nameWithType>]]></format>
+          <format type="text/markdown"><![CDATA[
+
+## Remarks
+
+The multiplication of a complex number, a + bi, and a second complex number, c + di, takes the following form:
+
+(ac - bd) + (ad + bc)i
+
+Languages that do not support custom operators can call the <xref:System.Numerics.Complex.Multiply%28System.Numerics.Complex%2CSystem.Numerics.Complex%29?displayProperty=nameWithType> equivalent method instead.
+
+          ]]></format>
         </remarks>
         <altmember cref="M:System.Numerics.Complex.Multiply(System.Numerics.Complex,System.Numerics.Complex)" />
       </Docs>
     </Member>
+    <MemberGroup MemberName="op_Subtraction">
+      <Docs>
+        <summary>Subtracts a specified number from another specified number, where at least one of them is a complex number, and the other could be a double-precision real number.</summary>
+        <remarks>
+          <format type="text/markdown">
+  <![CDATA[
+
+## Remarks
+
+The <xref:System.Numerics.Complex.op_Subtraction%2A> operator allows performing subtraction operations that involve complex numbers. It enables code such as the following:
+
+[!code-csharp[System.Numerics.Complex.Subtract#2](~/samples/snippets/csharp/VS_Snippets_CLR_System/system.numerics.complex.subtract/cs/subtract2.cs#2)]
+[!code-vb[System.Numerics.Complex.Subtract#2](~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.numerics.complex.subtract/vb/subtract2.vb#2)]
+
+If the subtraction results in an overflow in either the real or imaginary component, the value of that component is either <xref:System.Double.PositiveInfinity?displayProperty=nameWithType> or <xref:System.Double.NegativeInfinity?displayProperty=nameWithType>.
+
+Languages that do not support custom operators can call the <xref:System.Numerics.Complex.Subtract%2A> equivalent group of methods instead.
+
+The <xref:System.Numerics.Complex.op_Addition%2A> operators that receive one double are more efficient than the operators that receive two Complex numbers.
+
+          ]]></format>
+        </remarks>
+      </Docs>
+    </MemberGroup>
     <Member MemberName="op_Subtraction">
       <MemberSignature Language="C#" Value="public static System.Numerics.Complex operator - (double left, System.Numerics.Complex right);" />
       <MemberSignature Language="ILAsm" Value=".method public static hidebysig specialname valuetype System.Numerics.Complex op_Subtraction(float64 left, valuetype System.Numerics.Complex right) cil managed" />
@@ -3001,11 +3157,24 @@ This API is not CLS-compliant.</summary>
         <Parameter Name="right" Type="System.Numerics.Complex" Index="1" FrameworkAlternate="netcore-3.0" />
       </Parameters>
       <Docs>
-        <param name="left">To be added.</param>
-        <param name="right">To be added.</param>
-        <summary>To be added.</summary>
-        <returns>To be added.</returns>
-        <remarks>To be added.</remarks>
+        <param name="left">The double-precision real value to subtract from (the minuend).</param>
+        <param name="right">The complex value to subtract (the subtrahend).</param>
+        <summary>Subtracts a complex number from a double-precision real number.</summary>
+        <returns>The result of subtracting <paramref name="right" /> from <paramref name="left" />, as a complex number.</returns>
+        <remarks>
+          <format type="text/markdown"><![CDATA[
+
+## Remarks
+
+The subtraction of a complex number (c + di) from a real number (which can be regarded as the complex number a + 0i) takes the following form:
+
+(a - c) - di
+
+Languages that do not support custom operators can call the <xref:System.Numerics.Complex.Subtract%28System.Double%2CSystem.Numerics.Complex%29?displayProperty=nameWithType> method instead.
+ 
+          ]]></format>
+        </remarks>
+        <altmember cref="M:System.Numerics.Complex.Subtract(System.Double,System.Numerics.Complex)" />
       </Docs>
     </Member>
     <Member MemberName="op_Subtraction">
@@ -3034,11 +3203,24 @@ This API is not CLS-compliant.</summary>
         <Parameter Name="right" Type="System.Double" Index="1" FrameworkAlternate="netcore-3.0" />
       </Parameters>
       <Docs>
-        <param name="left">To be added.</param>
-        <param name="right">To be added.</param>
-        <summary>To be added.</summary>
-        <returns>To be added.</returns>
-        <remarks>To be added.</remarks>
+        <param name="left">The complex value to subtract from (the minuend).</param>
+        <param name="right">The double-precision real value to subtract (the subtrahend).</param>
+        <summary>Subtracts a double-precision real number from a complex number.</summary>
+        <returns>The result of subtracting <paramref name="right" /> from <paramref name="left" />, as a complex number.</returns>
+        <remarks>
+          <format type="text/markdown"><![CDATA[
+
+## Remarks
+
+The subtraction of a real number (which can be regarded as the complex number c + 0i) from a complex number (a + bi) takes the following form:
+
+(a - c) + bi
+
+Languages that do not support custom operators can call the <xref:System.Numerics.Complex.Subtract%28System.Numerics.Complex%2CSystem.Double%29?displayProperty=nameWithType> method instead.
+ 
+          ]]></format>
+        </remarks>
+        <altmember cref="M:System.Numerics.Complex.Subtract(System.Numerics.Complex,System.Double)" />
       </Docs>
     </Member>
     <Member MemberName="op_Subtraction">
@@ -3078,23 +3260,17 @@ This API is not CLS-compliant.</summary>
         <summary>Subtracts a complex number from another complex number.</summary>
         <returns>The result of subtracting <paramref name="right" /> from <paramref name="left" />.</returns>
         <remarks>
-          <format type="text/markdown"><![CDATA[  
-  
-## Remarks  
- The <xref:System.Numerics.Complex.op_Subtraction%2A> method defines the operation of the subtraction operator for complex numbers. It enables code such as the following:  
-  
- [!code-csharp[System.Numerics.Complex.Subtract#2](~/samples/snippets/csharp/VS_Snippets_CLR_System/system.numerics.complex.subtract/cs/subtract2.cs#2)]
- [!code-vb[System.Numerics.Complex.Subtract#2](~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.numerics.complex.subtract/vb/subtract2.vb#2)]  
-  
- If the method call results in an overflow in either the real or imaginary component, the value of that component is either <xref:System.Double.PositiveInfinity?displayProperty=nameWithType> or <xref:System.Double.NegativeInfinity?displayProperty=nameWithType>.  
-  
- The subtraction of a complex number, c + di, from another complex number, a + bi, takes the following form:  
-  
- (a - c) + (b - d)i  
-  
- Languages that do not support custom operators can call the <xref:System.Numerics.Complex.Subtract%2A> method instead.  
-  
- The equivalent method for this operator is <xref:System.Numerics.Complex.Subtract%28System.Numerics.Complex%2CSystem.Numerics.Complex%29?displayProperty=nameWithType>]]></format>
+          <format type="text/markdown"><![CDATA[
+
+## Remarks
+
+The subtraction of a complex number, c + di, from another complex number, a + bi, takes the following form:
+
+(a - c) + (b - d)i
+
+Languages that do not support custom operators can call the <xref:System.Numerics.Complex.Subtract%28System.Numerics.Complex%2CSystem.Numerics.Complex%29?displayProperty=nameWithType> method instead.
+ 
+          ]]></format>
         </remarks>
         <altmember cref="M:System.Numerics.Complex.Subtract(System.Numerics.Complex,System.Numerics.Complex)" />
       </Docs>
@@ -3572,6 +3748,34 @@ This API is not CLS-compliant.</summary>
         </remarks>
       </Docs>
     </Member>
+    <MemberGroup MemberName="Subtract">
+      <Docs>
+        <summary>Subtracts a specified number from another specified number, where at least one of them is a complex number, and the other could be a double-precision real number, and returns the result.</summary>
+        <remarks>
+          <format type="text/markdown">
+  <![CDATA[
+
+## Remarks
+
+The <xref:System.Numerics.Complex.Subtract%2A> method allows subtraction operations that involve complex numbers.
+
+If the subtraction results in an overflow in either the real or imaginary component, the value of that component is either <xref:System.Double.PositiveInfinity?displayProperty=nameWithType> or <xref:System.Double.NegativeInfinity?displayProperty=nameWithType>.
+
+Languages that support custom operators can use the <xref:System.Numerics.Complex.op_Subtraction%2A> equivalent group of operators too.
+
+The <xref:System.Numerics.Complex.Subtract%2A> methods that receive one double are more efficient than the method that receive two Complex numbers.
+
+## Examples
+
+The following example subtracts each complex number in an array from a complex number:
+
+[!code-csharp[System.Numerics.Complex.Subtract#1](~/samples/snippets/csharp/VS_Snippets_CLR_System/system.numerics.complex.subtract/cs/subtract1.cs#1)]
+[!code-vb[System.Numerics.Complex.Subtract#1](~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.numerics.complex.subtract/vb/subtract1.vb#1)]
+
+          ]]></format>
+        </remarks>
+      </Docs>
+    </MemberGroup>
     <Member MemberName="Subtract">
       <MemberSignature Language="C#" Value="public static System.Numerics.Complex Subtract (double left, System.Numerics.Complex right);" />
       <MemberSignature Language="ILAsm" Value=".method public static hidebysig valuetype System.Numerics.Complex Subtract(float64 left, valuetype System.Numerics.Complex right) cil managed" />
@@ -3598,11 +3802,24 @@ This API is not CLS-compliant.</summary>
         <Parameter Name="right" Type="System.Numerics.Complex" Index="1" FrameworkAlternate="netcore-3.0" />
       </Parameters>
       <Docs>
-        <param name="left">To be added.</param>
-        <param name="right">To be added.</param>
-        <summary>To be added.</summary>
-        <returns>To be added.</returns>
-        <remarks>To be added.</remarks>
+        <param name="left">The double-precision real value to subtract from (the minuend).</param>
+        <param name="right">The complex value to subtract (the subtrahend).</param>
+        <summary>Subtracts one complex number from a double-precision real number and returns the result.</summary>
+        <returns>The result of subtracting <paramref name="right" /> from <paramref name="left" />, as a complex number.</returns>
+        <remarks>
+          <format type="text/markdown"><![CDATA[
+
+## Remarks
+
+The subtraction of a complex number (c + di) from a real number (which can be regarded as the complex number a + 0i) takes the following form:
+
+(a - c) - di
+
+Languages that support custom operators can use the <xref:System.Numerics.Complex.op_Subtraction%28System.Double%2CSystem.Numerics.Complex%29?displayProperty=nameWithType> equivalent operator too.
+
+          ]]></format>
+        </remarks>
+        <altmember cref="M:System.Numerics.Complex.op_Subtraction(System.Double,System.Numerics.Complex)" />
       </Docs>
     </Member>
     <Member MemberName="Subtract">
@@ -3631,11 +3848,24 @@ This API is not CLS-compliant.</summary>
         <Parameter Name="right" Type="System.Double" Index="1" FrameworkAlternate="netcore-3.0" />
       </Parameters>
       <Docs>
-        <param name="left">To be added.</param>
-        <param name="right">To be added.</param>
-        <summary>To be added.</summary>
-        <returns>To be added.</returns>
-        <remarks>To be added.</remarks>
+        <param name="left">The complex value to subtract from (the minuend).</param>
+        <param name="right">The double-precision real value to subtract (the subtrahend).</param>
+        <summary>Subtracts one double-precision real number from a complex number and returns the result.</summary>
+        <returns>The result of subtracting <paramref name="right" /> from <paramref name="left" />, as a complex number.</returns>
+        <remarks>
+          <format type="text/markdown"><![CDATA[
+
+## Remarks
+
+The subtraction of a real number (which can be regarded as the complex number c + 0i) from a complex number (a + bi) takes the following form:
+
+(a - c) + bi
+
+Languages that support custom operators can use the <xref:System.Numerics.Complex.op_Subtraction%28System.Numerics.Complex%2CSystem.Double%29?displayProperty=nameWithType> equivalent operator too.
+
+          ]]></format>
+        </remarks>
+        <altmember cref="M:System.Numerics.Complex.op_Subtraction(System.Numerics.Complex,System.Double)" />
       </Docs>
     </Member>
     <Member MemberName="Subtract">
@@ -3680,26 +3910,17 @@ This API is not CLS-compliant.</summary>
         <summary>Subtracts one complex number from another and returns the result.</summary>
         <returns>The result of subtracting <paramref name="right" /> from <paramref name="left" />.</returns>
         <remarks>
-          <format type="text/markdown"><![CDATA[  
-  
-## Remarks  
- The subtraction of a complex number, c + di, from another complex number, a + bi, takes the following form:  
-  
- (a - c) + (b - d)i  
-  
- If the method call results in an overflow in either the real or imaginary component, the value of that component is either <xref:System.Double.PositiveInfinity?displayProperty=nameWithType> or <xref:System.Double.NegativeInfinity?displayProperty=nameWithType>.  
-  
- Languages that do not support custom operators can use the <xref:System.Numerics.Complex.Subtract%2A> method to perform subtraction using complex numbers.  
-  
-   
-  
-## Examples  
- The following example subtracts each complex number in an array from a complex number.  
-  
- [!code-csharp[System.Numerics.Complex.Subtract#1](~/samples/snippets/csharp/VS_Snippets_CLR_System/system.numerics.complex.subtract/cs/subtract1.cs#1)]
- [!code-vb[System.Numerics.Complex.Subtract#1](~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.numerics.complex.subtract/vb/subtract1.vb#1)]  
-  
- ]]></format>
+          <format type="text/markdown"><![CDATA[
+
+## Remarks
+
+The subtraction of a complex number, c + di, from another complex number, a + bi, takes the following form:
+
+(a - c) + (b - d)i
+
+Languages that support custom operators can use the <xref:System.Numerics.Complex.op_Subtraction%28System.Numerics.Complex%2CSystem.Numerics.Complex%29?displayProperty=nameWithType> equivalent operator too.
+
+          ]]></format>
         </remarks>
         <altmember cref="M:System.Numerics.Complex.op_Subtraction(System.Numerics.Complex,System.Numerics.Complex)" />
       </Docs>
@@ -4123,4 +4344,4 @@ This API is not CLS-compliant.</summary>
       </Docs>
     </Member>
   </Members>
-</Type>
\ No newline at end of file
+</Type>