Numerics serialization (#20222)

morganbr · krwq · commit b6f9533d989f · 2017-06-01T15:14:38.000-07:00
Adds serialization support to BigInteger and Complex, which were inadvetently dropped in the previous cleanup. Also renames the private fields of Complex to match NetFX so that it will be serialization compatible.
diff --git a/src/System.Runtime.Numerics/src/System/Numerics/BigInteger.cs b/src/System.Runtime.Numerics/src/System/Numerics/BigInteger.cs
@@ -8,6 +8,7 @@
 
 namespace System.Numerics
 {
+    [Serializable]
     public struct BigInteger : IFormattable, IComparable, IComparable<BigInteger>, IEquatable<BigInteger>
     {
         private const int knMaskHighBit = int.MinValue;
diff --git a/src/System.Runtime.Numerics/src/System/Numerics/Complex.cs b/src/System.Runtime.Numerics/src/System/Numerics/Complex.cs
@@ -12,6 +12,7 @@ namespace System.Numerics
     /// A complex number z is a number of the form z = x + yi, where x and y 
     /// are real numbers, and i is the imaginary unit, with the property i2= -1.
     /// </summary>
+    [Serializable]
     public struct Complex : IEquatable<Complex>, IFormattable
     {
         public static readonly Complex Zero = new Complex(0.0, 0.0);
@@ -29,20 +30,21 @@ public struct Complex : IEquatable<Complex>, IFormattable
         // This value is used inside Asin and Acos.
         private static readonly double s_log2 = Math.Log(2.0);
 
-        private double _real;
-        private double _imaginary;
+        // Do not rename, these fields are needed for binary serialization
+        private double m_real;
+        private double m_imaginary;
         
         public Complex(double real, double imaginary)
         {
-            _real = real;
-            _imaginary = imaginary;
+            m_real = real;
+            m_imaginary = imaginary;
         }
 
-        public double Real { get { return _real; } }
-        public double Imaginary { get { return _imaginary; } }
+        public double Real { get { return m_real; } }
+        public double Imaginary { get { return m_imaginary; } }
 
         public double Magnitude { get { return Abs(this); } }
-        public double Phase { get { return Math.Atan2(_imaginary, _real); } }
+        public double Phase { get { return Math.Atan2(m_imaginary, m_real); } }
 
         public static Complex FromPolarCoordinates(double magnitude, double phase)
         {
@@ -76,34 +78,34 @@ public static Complex Divide(Complex dividend, Complex divisor)
         
         public static Complex operator -(Complex value)  /* Unary negation of a complex number */
         {
-            return new Complex(-value._real, -value._imaginary);
+            return new Complex(-value.m_real, -value.m_imaginary);
         }
         
         public static Complex operator +(Complex left, Complex right)
         {
-            return new Complex(left._real + right._real, left._imaginary + right._imaginary);
+            return new Complex(left.m_real + right.m_real, left.m_imaginary + right.m_imaginary);
         }
 
         public static Complex operator -(Complex left, Complex right)
         {
-            return new Complex(left._real - right._real, left._imaginary - right._imaginary);
+            return new Complex(left.m_real - right.m_real, left.m_imaginary - right.m_imaginary);
         }
 
         public static Complex operator *(Complex left, Complex right)
         {
             // Multiplication:  (a + bi)(c + di) = (ac -bd) + (bc + ad)i
-            double result_Realpart = (left._real * right._real) - (left._imaginary * right._imaginary);
-            double result_Imaginarypart = (left._imaginary * right._real) + (left._real * right._imaginary);
-            return new Complex(result_Realpart, result_Imaginarypart);
+            double result_realpart = (left.m_real * right.m_real) - (left.m_imaginary * right.m_imaginary);
+            double result_imaginarypart = (left.m_imaginary * right.m_real) + (left.m_real * right.m_imaginary);
+            return new Complex(result_realpart, result_imaginarypart);
         }
 
         public static Complex operator /(Complex left, Complex right)
         {
             // Division : Smith's formula.
-            double a = left._real;
-            double b = left._imaginary;
-            double c = right._real;
-            double d = right._imaginary;
+            double a = left.m_real;
+            double b = left.m_imaginary;
+            double c = right.m_real;
+            double d = right.m_imaginary;
 
             if (Math.Abs(d) < Math.Abs(c))
             {
@@ -119,7 +121,7 @@ public static Complex Divide(Complex dividend, Complex divisor)
 
         public static double Abs(Complex value)
         {
-            return Hypot(value._real, value._imaginary);
+            return Hypot(value.m_real, value.m_imaginary);
         }
 
         private static double Hypot(double a, double b)
@@ -191,13 +193,13 @@ private static double Log1P(double x)
         public static Complex Conjugate(Complex value)
         {
             // Conjugate of a Complex number: the conjugate of x+i*y is x-i*y
-            return new Complex(value._real, -value._imaginary);
+            return new Complex(value.m_real, -value.m_imaginary);
         }
 
         public static Complex Reciprocal(Complex value)
         {
             // Reciprocal of a Complex number : the reciprocal of x+i*y is 1/(x+i*y)
-            if (value._real == 0 && value._imaginary == 0)
+            if (value.m_real == 0 && value.m_imaginary == 0)
             {
                 return Zero;
             }
@@ -206,12 +208,12 @@ public static Complex Reciprocal(Complex value)
         
         public static bool operator ==(Complex left, Complex right)
         {
-            return left._real == right._real && left._imaginary == right._imaginary;
+            return left.m_real == right.m_real && left.m_imaginary == right.m_imaginary;
         }
 
         public static bool operator !=(Complex left, Complex right)
         {
-            return left._real != right._real || left._imaginary != right._imaginary;
+            return left.m_real != right.m_real || left.m_imaginary != right.m_imaginary;
         }
 
         public override bool Equals(object obj)
@@ -222,47 +224,47 @@ public override bool Equals(object obj)
 
         public bool Equals(Complex value)
         {
-            return _real.Equals(value._real) && _imaginary.Equals(value._imaginary);
+            return m_real.Equals(value.m_real) && m_imaginary.Equals(value.m_imaginary);
         }
 
         public override int GetHashCode()
         {
             int n1 = 99999997;
-            int realHash = _real.GetHashCode() % n1;
-            int imaginaryHash = _imaginary.GetHashCode();
+            int realHash = m_real.GetHashCode() % n1;
+            int imaginaryHash = m_imaginary.GetHashCode();
             int finalHash = realHash ^ imaginaryHash;
             return finalHash;
         }
 
         public override string ToString()
         {
-            return string.Format(CultureInfo.CurrentCulture, "({0}, {1})", _real, _imaginary);
+            return string.Format(CultureInfo.CurrentCulture, "({0}, {1})", m_real, m_imaginary);
         }
 
         public string ToString(string format)
         {
-            return string.Format(CultureInfo.CurrentCulture, "({0}, {1})", _real.ToString(format, CultureInfo.CurrentCulture), _imaginary.ToString(format, CultureInfo.CurrentCulture));
+            return string.Format(CultureInfo.CurrentCulture, "({0}, {1})", m_real.ToString(format, CultureInfo.CurrentCulture), m_imaginary.ToString(format, CultureInfo.CurrentCulture));
         }
 
         public string ToString(IFormatProvider provider)
         {
-            return string.Format(provider, "({0}, {1})", _real, _imaginary);
+            return string.Format(provider, "({0}, {1})", m_real, m_imaginary);
         }
 
         public string ToString(string format, IFormatProvider provider)
         {
-            return string.Format(provider, "({0}, {1})", _real.ToString(format, provider), _imaginary.ToString(format, provider));
+            return string.Format(provider, "({0}, {1})", m_real.ToString(format, provider), m_imaginary.ToString(format, provider));
         }
 
         public static Complex Sin(Complex value)
         {
             // We need both sinh and cosh of imaginary part. To avoid multiple calls to Math.Exp with the same value,
             // we compute them both here from a single call to Math.Exp.
-            double p = Math.Exp(value._imaginary);
+            double p = Math.Exp(value.m_imaginary);
             double q = 1.0 / p;
             double sinh = (p - q) * 0.5;
             double cosh = (p + q) * 0.5;
-            return new Complex(Math.Sin(value._real) * cosh, Math.Cos(value._real) * sinh);
+            return new Complex(Math.Sin(value.m_real) * cosh, Math.Cos(value.m_real) * sinh);
             // There is a known limitation with this algorithm: inputs that cause sinh and cosh to overflow, but for
             // which sin or cos are small enough that sin * cosh or cos * sinh are still representable, nonetheless
             // produce overflow. For example, Sin((0.01, 711.0)) should produce (~3.0E306, PositiveInfinity), but
@@ -273,8 +275,8 @@ public static Complex Sin(Complex value)
         public static Complex Sinh(Complex value)
         {
             // Use sinh(z) = -i sin(iz) to compute via sin(z).
-            Complex sin = Sin(new Complex(-value._imaginary, value._real));
-            return new Complex(sin._imaginary, -sin._real);
+            Complex sin = Sin(new Complex(-value.m_imaginary, value.m_real));
+            return new Complex(sin.m_imaginary, -sin.m_real);
         }
 
         public static Complex Asin(Complex value)
@@ -299,18 +301,18 @@ public static Complex Asin(Complex value)
         }
 
         public static Complex Cos(Complex value) {
-            double p = Math.Exp(value._imaginary);
+            double p = Math.Exp(value.m_imaginary);
             double q = 1.0 / p;
             double sinh = (p - q) * 0.5;
             double cosh = (p + q) * 0.5;
-            return new Complex(Math.Cos(value._real) * cosh, -Math.Sin(value._real) * sinh);
+            return new Complex(Math.Cos(value.m_real) * cosh, -Math.Sin(value.m_real) * sinh);
         }
 
         [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Cosh", Justification = "Cosh is the name of a mathematical function.")]
         public static Complex Cosh(Complex value)
         {
             // Use cosh(z) = cos(iz) to compute via cos(z).
-            return Cos(new Complex(-value._imaginary, value._real));
+            return Cos(new Complex(-value.m_imaginary, value.m_real));
         }
 
         public static Complex Acos(Complex value)
@@ -345,12 +347,12 @@ public static Complex Tan(Complex value)
             //   tan z = (sin(2x) / cosh(2y) + i \tanh(2y)) / (1 + cos(2x) / cosh(2y))
             // which correctly computes the (tiny) real part and the (normal-sized) imaginary part.
             
-            double x2 = 2.0 * value._real;
-            double y2 = 2.0 * value._imaginary;
+            double x2 = 2.0 * value.m_real;
+            double y2 = 2.0 * value.m_imaginary;
             double p = Math.Exp(y2);
             double q = 1.0 / p;
             double cosh = (p + q) * 0.5;
-            if (Math.Abs(value._imaginary) <= 4.0)
+            if (Math.Abs(value.m_imaginary) <= 4.0)
             {
                 double sinh = (p - q) * 0.5;
                 double D = Math.Cos(x2) + cosh;
@@ -367,8 +369,8 @@ public static Complex Tan(Complex value)
         public static Complex Tanh(Complex value)
         {
             // Use tanh(z) = -i tan(iz) to compute via tan(z).
-            Complex tan = Tan(new Complex(-value._imaginary, value._real));
-            return new Complex(tan._imaginary, -tan._real);
+            Complex tan = Tan(new Complex(-value.m_imaginary, value.m_real));
+            return new Complex(tan.m_imaginary, -tan.m_real);
         }
 
         public static Complex Atan(Complex value)
@@ -497,7 +499,7 @@ private static void Asin_Internal (double x, double y, out double b, out double
 
         public static Complex Log(Complex value)
         {
-            return new Complex(Math.Log(Abs(value)), Math.Atan2(value._imaginary, value._real));
+            return new Complex(Math.Log(Abs(value)), Math.Atan2(value.m_imaginary, value.m_real));
         }
 
         public static Complex Log(Complex value, double baseValue)
@@ -513,26 +515,26 @@ public static Complex Log10(Complex value)
 
         public static Complex Exp(Complex value)
         {
-            double expReal = Math.Exp(value._real);
-            double cosImaginary = expReal * Math.Cos(value._imaginary);
-            double sinImaginary = expReal * Math.Sin(value._imaginary);
+            double expReal = Math.Exp(value.m_real);
+            double cosImaginary = expReal * Math.Cos(value.m_imaginary);
+            double sinImaginary = expReal * Math.Sin(value.m_imaginary);
             return new Complex(cosImaginary, sinImaginary);
         }
 
         [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Sqrt", Justification = "Sqrt is the name of a mathematical function.")]
         public static Complex Sqrt(Complex value)
         {
 
-            if (value._imaginary == 0.0)
+            if (value.m_imaginary == 0.0)
             {
                 // Handle the trivial case quickly.
-                if (value._real < 0.0)
+                if (value.m_real < 0.0)
                 {
-                    return new Complex(0.0, Math.Sqrt(-value._real));
+                    return new Complex(0.0, Math.Sqrt(-value.m_real));
                 }
                 else
                 {
-                    return new Complex(Math.Sqrt(value._real), 0.0);
+                    return new Complex(Math.Sqrt(value.m_real), 0.0);
                 }
             }
             else
@@ -565,35 +567,35 @@ public static Complex Sqrt(Complex value)
                 // make the result representable. To avoid this, we re-scale (by exact powers of 2 for accuracy)
                 // when we encounter very large components to avoid intermediate infinities.
                 bool rescale = false;
-                if ((Math.Abs(value._real) >= s_sqrtRescaleThreshold) || (Math.Abs(value._imaginary) >= s_sqrtRescaleThreshold))
+                if ((Math.Abs(value.m_real) >= s_sqrtRescaleThreshold) || (Math.Abs(value.m_imaginary) >= s_sqrtRescaleThreshold))
                 {
-                    if (double.IsInfinity(value._imaginary) && !double.IsNaN(value._real))
+                    if (double.IsInfinity(value.m_imaginary) && !double.IsNaN(value.m_real))
                     {
                         // We need to handle infinite imaginary parts specially because otherwise
                         // our formulas below produce inf/inf = NaN. The NaN test is necessary
                         // so that we return NaN rather than (+inf,inf) for (NaN,inf).
-                        return (new Complex(double.PositiveInfinity, value._imaginary));
+                        return (new Complex(double.PositiveInfinity, value.m_imaginary));
                     }
                     else
                     {
-                        value._real *= 0.25;
-                        value._imaginary *= 0.25;
+                        value.m_real *= 0.25;
+                        value.m_imaginary *= 0.25;
                         rescale = true;
                     }
                 }
  
                 // This is the core of the algorithm. Everything else is special case handling.
                 double x, y;
-                if (value._real >= 0.0)
+                if (value.m_real >= 0.0)
                 {
-                    x = Math.Sqrt((Hypot(value._real, value._imaginary) + value._real) * 0.5);
-                    y = value._imaginary / (2.0 * x);
+                    x = Math.Sqrt((Hypot(value.m_real, value.m_imaginary) + value.m_real) * 0.5);
+                    y = value.m_imaginary / (2.0 * x);
                 }
                 else
                 {
-                    y = Math.Sqrt((Hypot(value._real, value._imaginary) - value._real) * 0.5);
-                    if (value._imaginary < 0.0) y = -y;
-                    x = value._imaginary / (2.0 * y);
+                    y = Math.Sqrt((Hypot(value.m_real, value.m_imaginary) - value.m_real) * 0.5);
+                    if (value.m_imaginary < 0.0) y = -y;
+                    x = value.m_imaginary / (2.0 * y);
                 }
 
                 if (rescale)
@@ -620,10 +622,10 @@ public static Complex Pow(Complex value, Complex power)
                 return Zero;
             }
 
-            double valueReal = value._real;
-            double valueImaginary = value._imaginary;
-            double powerReal = power._real;
-            double powerImaginary = power._imaginary;
+            double valueReal = value.m_real;
+            double valueImaginary = value.m_imaginary;
+            double powerReal = power.m_real;
+            double powerImaginary = power.m_imaginary;
 
             double rho = Abs(value);
             double theta = Math.Atan2(valueImaginary, valueReal);
@@ -641,8 +643,8 @@ public static Complex Pow(Complex value, double power)
         
         private static Complex Scale(Complex value, double factor)
         {
-            double realResult = factor * value._real;
-            double imaginaryResuilt = factor * value._imaginary;
+            double realResult = factor * value.m_real;
+            double imaginaryResuilt = factor * value.m_imaginary;
             return new Complex(realResult, imaginaryResuilt);
         }
 

Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@`
`8`	`8`
`9`	`9`	`namespace System.Numerics`
`10`	`10`	`{`
	`11`	`+ [Serializable]`
`11`	`12`	`public struct BigInteger : IFormattable, IComparable, IComparable<BigInteger>, IEquatable<BigInteger>`
`12`	`13`	`{`
`13`	`14`	`private const int knMaskHighBit = int.MinValue;`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@ namespace System.Numerics`
`12`	`12`	`/// A complex number z is a number of the form z = x + yi, where x and y`
`13`	`13`	`/// are real numbers, and i is the imaginary unit, with the property i2= -1.`
`14`	`14`	`/// </summary>`
	`15`	`+ [Serializable]`
`15`	`16`	`public struct Complex : IEquatable<Complex>, IFormattable`
`16`	`17`	`{`
`17`	`18`	`public static readonly Complex Zero = new Complex(0.0, 0.0);`
`@@ -29,20 +30,21 @@ public struct Complex : IEquatable<Complex>, IFormattable`
`29`	`30`	`// This value is used inside Asin and Acos.`
`30`	`31`	`private static readonly double s_log2 = Math.Log(2.0);`
`31`	`32`
`32`		`- private double _real;`
`33`		`- private double _imaginary;`
	`33`	`+ // Do not rename, these fields are needed for binary serialization`
	`34`	`+ private double m_real;`
	`35`	`+ private double m_imaginary;`
`34`	`36`
`35`	`37`	`public Complex(double real, double imaginary)`
`36`	`38`	`{`
`37`		`- _real = real;`
`38`		`- _imaginary = imaginary;`
	`39`	`+ m_real = real;`
	`40`	`+ m_imaginary = imaginary;`
`39`	`41`	`}`
`40`	`42`
`41`		`- public double Real { get { return _real; } }`
`42`		`- public double Imaginary { get { return _imaginary; } }`
	`43`	`+ public double Real { get { return m_real; } }`
	`44`	`+ public double Imaginary { get { return m_imaginary; } }`
`43`	`45`
`44`	`46`	`public double Magnitude { get { return Abs(this); } }`
`45`		`- public double Phase { get { return Math.Atan2(_imaginary, _real); } }`
	`47`	`+ public double Phase { get { return Math.Atan2(m_imaginary, m_real); } }`
`46`	`48`
`47`	`49`	`public static Complex FromPolarCoordinates(double magnitude, double phase)`
`48`	`50`	`{`
`@@ -76,34 +78,34 @@ public static Complex Divide(Complex dividend, Complex divisor)`
`76`	`78`
`77`	`79`	`public static Complex operator -(Complex value) /* Unary negation of a complex number */`
`78`	`80`	`{`
`79`		`- return new Complex(-value._real, -value._imaginary);`
	`81`	`+ return new Complex(-value.m_real, -value.m_imaginary);`
`80`	`82`	`}`
`81`	`83`
`82`	`84`	`public static Complex operator +(Complex left, Complex right)`
`83`	`85`	`{`
`84`		`- return new Complex(left._real + right._real, left._imaginary + right._imaginary);`
	`86`	`+ return new Complex(left.m_real + right.m_real, left.m_imaginary + right.m_imaginary);`
`85`	`87`	`}`
`86`	`88`
`87`	`89`	`public static Complex operator -(Complex left, Complex right)`
`88`	`90`	`{`
`89`		`- return new Complex(left._real - right._real, left._imaginary - right._imaginary);`
	`91`	`+ return new Complex(left.m_real - right.m_real, left.m_imaginary - right.m_imaginary);`
`90`	`92`	`}`
`91`	`93`
`92`	`94`	`public static Complex operator *(Complex left, Complex right)`
`93`	`95`	`{`
`94`	`96`	`// Multiplication: (a + bi)(c + di) = (ac -bd) + (bc + ad)i`
`95`		`- double result_Realpart = (left._real * right._real) - (left._imaginary * right._imaginary);`
`96`		`- double result_Imaginarypart = (left._imaginary * right._real) + (left._real * right._imaginary);`
`97`		`- return new Complex(result_Realpart, result_Imaginarypart);`
	`97`	`+ double result_realpart = (left.m_real * right.m_real) - (left.m_imaginary * right.m_imaginary);`
	`98`	`+ double result_imaginarypart = (left.m_imaginary * right.m_real) + (left.m_real * right.m_imaginary);`
	`99`	`+ return new Complex(result_realpart, result_imaginarypart);`
`98`	`100`	`}`
`99`	`101`
`100`	`102`	`public static Complex operator /(Complex left, Complex right)`
`101`	`103`	`{`
`102`	`104`	`// Division : Smith's formula.`
`103`		`- double a = left._real;`
`104`		`- double b = left._imaginary;`
`105`		`- double c = right._real;`
`106`		`- double d = right._imaginary;`
	`105`	`+ double a = left.m_real;`
	`106`	`+ double b = left.m_imaginary;`
	`107`	`+ double c = right.m_real;`
	`108`	`+ double d = right.m_imaginary;`
`107`	`109`
`108`	`110`	`if (Math.Abs(d) < Math.Abs(c))`
`109`	`111`	`{`
`@@ -119,7 +121,7 @@ public static Complex Divide(Complex dividend, Complex divisor)`
`119`	`121`
`120`	`122`	`public static double Abs(Complex value)`
`121`	`123`	`{`
`122`		`- return Hypot(value._real, value._imaginary);`
	`124`	`+ return Hypot(value.m_real, value.m_imaginary);`
`123`	`125`	`}`
`124`	`126`
`125`	`127`	`private static double Hypot(double a, double b)`
`@@ -191,13 +193,13 @@ private static double Log1P(double x)`
`191`	`193`	`public static Complex Conjugate(Complex value)`
`192`	`194`	`{`
`193`	`195`	`// Conjugate of a Complex number: the conjugate of x+iy is x-iy`
`194`		`- return new Complex(value._real, -value._imaginary);`
	`196`	`+ return new Complex(value.m_real, -value.m_imaginary);`
`195`	`197`	`}`
`196`	`198`
`197`	`199`	`public static Complex Reciprocal(Complex value)`
`198`	`200`	`{`
`199`	`201`	`// Reciprocal of a Complex number : the reciprocal of x+iy is 1/(x+iy)`
`200`		`- if (value._real == 0 && value._imaginary == 0)`
	`202`	`+ if (value.m_real == 0 && value.m_imaginary == 0)`
`201`	`203`	`{`
`202`	`204`	`return Zero;`
`203`	`205`	`}`
`@@ -206,12 +208,12 @@ public static Complex Reciprocal(Complex value)`
`206`	`208`
`207`	`209`	`public static bool operator ==(Complex left, Complex right)`
`208`	`210`	`{`
`209`		`- return left._real == right._real && left._imaginary == right._imaginary;`
	`211`	`+ return left.m_real == right.m_real && left.m_imaginary == right.m_imaginary;`
`210`	`212`	`}`
`211`	`213`
`212`	`214`	`public static bool operator !=(Complex left, Complex right)`
`213`	`215`	`{`
`214`		`- return left._real != right._real \|\| left._imaginary != right._imaginary;`
	`216`	`+ return left.m_real != right.m_real \|\| left.m_imaginary != right.m_imaginary;`
`215`	`217`	`}`
`216`	`218`
`217`	`219`	`public override bool Equals(object obj)`
`@@ -222,47 +224,47 @@ public override bool Equals(object obj)`
`222`	`224`
`223`	`225`	`public bool Equals(Complex value)`
`224`	`226`	`{`
`225`		`- return _real.Equals(value._real) && _imaginary.Equals(value._imaginary);`
	`227`	`+ return m_real.Equals(value.m_real) && m_imaginary.Equals(value.m_imaginary);`
`226`	`228`	`}`
`227`	`229`
`228`	`230`	`public override int GetHashCode()`
`229`	`231`	`{`
`230`	`232`	`int n1 = 99999997;`
`231`		`- int realHash = _real.GetHashCode() % n1;`
`232`		`- int imaginaryHash = _imaginary.GetHashCode();`
	`233`	`+ int realHash = m_real.GetHashCode() % n1;`
	`234`	`+ int imaginaryHash = m_imaginary.GetHashCode();`
`233`	`235`	`int finalHash = realHash ^ imaginaryHash;`
`234`	`236`	`return finalHash;`
`235`	`237`	`}`
`236`	`238`
`237`	`239`	`public override string ToString()`
`238`	`240`	`{`
`239`		`- return string.Format(CultureInfo.CurrentCulture, "({0}, {1})", _real, _imaginary);`
	`241`	`+ return string.Format(CultureInfo.CurrentCulture, "({0}, {1})", m_real, m_imaginary);`
`240`	`242`	`}`
`241`	`243`
`242`	`244`	`public string ToString(string format)`
`243`	`245`	`{`
`244`		`- return string.Format(CultureInfo.CurrentCulture, "({0}, {1})", _real.ToString(format, CultureInfo.CurrentCulture), _imaginary.ToString(format, CultureInfo.CurrentCulture));`
	`246`	`+ return string.Format(CultureInfo.CurrentCulture, "({0}, {1})", m_real.ToString(format, CultureInfo.CurrentCulture), m_imaginary.ToString(format, CultureInfo.CurrentCulture));`
`245`	`247`	`}`
`246`	`248`
`247`	`249`	`public string ToString(IFormatProvider provider)`
`248`	`250`	`{`
`249`		`- return string.Format(provider, "({0}, {1})", _real, _imaginary);`
	`251`	`+ return string.Format(provider, "({0}, {1})", m_real, m_imaginary);`
`250`	`252`	`}`
`251`	`253`
`252`	`254`	`public string ToString(string format, IFormatProvider provider)`
`253`	`255`	`{`
`254`		`- return string.Format(provider, "({0}, {1})", _real.ToString(format, provider), _imaginary.ToString(format, provider));`
	`256`	`+ return string.Format(provider, "({0}, {1})", m_real.ToString(format, provider), m_imaginary.ToString(format, provider));`
`255`	`257`	`}`
`256`	`258`
`257`	`259`	`public static Complex Sin(Complex value)`
`258`	`260`	`{`
`259`	`261`	`// We need both sinh and cosh of imaginary part. To avoid multiple calls to Math.Exp with the same value,`
`260`	`262`	`// we compute them both here from a single call to Math.Exp.`
`261`		`- double p = Math.Exp(value._imaginary);`
	`263`	`+ double p = Math.Exp(value.m_imaginary);`
`262`	`264`	`double q = 1.0 / p;`
`263`	`265`	`double sinh = (p - q) * 0.5;`
`264`	`266`	`double cosh = (p + q) * 0.5;`
`265`		`- return new Complex(Math.Sin(value._real) * cosh, Math.Cos(value._real) * sinh);`
	`267`	`+ return new Complex(Math.Sin(value.m_real) * cosh, Math.Cos(value.m_real) * sinh);`
`266`	`268`	`// There is a known limitation with this algorithm: inputs that cause sinh and cosh to overflow, but for`
`267`	`269`	`// which sin or cos are small enough that sin * cosh or cos * sinh are still representable, nonetheless`
`268`	`270`	`// produce overflow. For example, Sin((0.01, 711.0)) should produce (~3.0E306, PositiveInfinity), but`
`@@ -273,8 +275,8 @@ public static Complex Sin(Complex value)`
`273`	`275`	`public static Complex Sinh(Complex value)`
`274`	`276`	`{`
`275`	`277`	`// Use sinh(z) = -i sin(iz) to compute via sin(z).`
`276`		`- Complex sin = Sin(new Complex(-value._imaginary, value._real));`
`277`		`- return new Complex(sin._imaginary, -sin._real);`
	`278`	`+ Complex sin = Sin(new Complex(-value.m_imaginary, value.m_real));`
	`279`	`+ return new Complex(sin.m_imaginary, -sin.m_real);`
`278`	`280`	`}`
`279`	`281`
`280`	`282`	`public static Complex Asin(Complex value)`
`@@ -299,18 +301,18 @@ public static Complex Asin(Complex value)`
`299`	`301`	`}`
`300`	`302`
`301`	`303`	`public static Complex Cos(Complex value) {`
`302`		`- double p = Math.Exp(value._imaginary);`
	`304`	`+ double p = Math.Exp(value.m_imaginary);`
`303`	`305`	`double q = 1.0 / p;`
`304`	`306`	`double sinh = (p - q) * 0.5;`
`305`	`307`	`double cosh = (p + q) * 0.5;`
`306`		`- return new Complex(Math.Cos(value._real) * cosh, -Math.Sin(value._real) * sinh);`
	`308`	`+ return new Complex(Math.Cos(value.m_real) * cosh, -Math.Sin(value.m_real) * sinh);`
`307`	`309`	`}`
`308`	`310`
`309`	`311`	`[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Cosh", Justification = "Cosh is the name of a mathematical function.")]`
`310`	`312`	`public static Complex Cosh(Complex value)`
`311`	`313`	`{`
`312`	`314`	`// Use cosh(z) = cos(iz) to compute via cos(z).`
`313`		`- return Cos(new Complex(-value._imaginary, value._real));`
	`315`	`+ return Cos(new Complex(-value.m_imaginary, value.m_real));`
`314`	`316`	`}`
`315`	`317`
`316`	`318`	`public static Complex Acos(Complex value)`
`@@ -345,12 +347,12 @@ public static Complex Tan(Complex value)`
`345`	`347`	`// tan z = (sin(2x) / cosh(2y) + i \tanh(2y)) / (1 + cos(2x) / cosh(2y))`
`346`	`348`	`// which correctly computes the (tiny) real part and the (normal-sized) imaginary part.`
`347`	`349`
`348`		`- double x2 = 2.0 * value._real;`
`349`		`- double y2 = 2.0 * value._imaginary;`
	`350`	`+ double x2 = 2.0 * value.m_real;`
	`351`	`+ double y2 = 2.0 * value.m_imaginary;`
`350`	`352`	`double p = Math.Exp(y2);`
`351`	`353`	`double q = 1.0 / p;`
`352`	`354`	`double cosh = (p + q) * 0.5;`
`353`		`- if (Math.Abs(value._imaginary) <= 4.0)`
	`355`	`+ if (Math.Abs(value.m_imaginary) <= 4.0)`
`354`	`356`	`{`
`355`	`357`	`double sinh = (p - q) * 0.5;`
`356`	`358`	`double D = Math.Cos(x2) + cosh;`
`@@ -367,8 +369,8 @@ public static Complex Tan(Complex value)`
`367`	`369`	`public static Complex Tanh(Complex value)`
`368`	`370`	`{`
`369`	`371`	`// Use tanh(z) = -i tan(iz) to compute via tan(z).`
`370`		`- Complex tan = Tan(new Complex(-value._imaginary, value._real));`
`371`		`- return new Complex(tan._imaginary, -tan._real);`
	`372`	`+ Complex tan = Tan(new Complex(-value.m_imaginary, value.m_real));`
	`373`	`+ return new Complex(tan.m_imaginary, -tan.m_real);`
`372`	`374`	`}`
`373`	`375`
`374`	`376`	`public static Complex Atan(Complex value)`
`@@ -497,7 +499,7 @@ private static void Asin_Internal (double x, double y, out double b, out double`
`497`	`499`
`498`	`500`	`public static Complex Log(Complex value)`
`499`	`501`	`{`
`500`		`- return new Complex(Math.Log(Abs(value)), Math.Atan2(value._imaginary, value._real));`
	`502`	`+ return new Complex(Math.Log(Abs(value)), Math.Atan2(value.m_imaginary, value.m_real));`
`501`	`503`	`}`
`502`	`504`
`503`	`505`	`public static Complex Log(Complex value, double baseValue)`
`@@ -513,26 +515,26 @@ public static Complex Log10(Complex value)`
`513`	`515`
`514`	`516`	`public static Complex Exp(Complex value)`
`515`	`517`	`{`
`516`		`- double expReal = Math.Exp(value._real);`
`517`		`- double cosImaginary = expReal * Math.Cos(value._imaginary);`
`518`		`- double sinImaginary = expReal * Math.Sin(value._imaginary);`
	`518`	`+ double expReal = Math.Exp(value.m_real);`
	`519`	`+ double cosImaginary = expReal * Math.Cos(value.m_imaginary);`
	`520`	`+ double sinImaginary = expReal * Math.Sin(value.m_imaginary);`
`519`	`521`	`return new Complex(cosImaginary, sinImaginary);`
`520`	`522`	`}`
`521`	`523`
`522`	`524`	`[SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Sqrt", Justification = "Sqrt is the name of a mathematical function.")]`
`523`	`525`	`public static Complex Sqrt(Complex value)`
`524`	`526`	`{`
`525`	`527`
`526`		`- if (value._imaginary == 0.0)`
	`528`	`+ if (value.m_imaginary == 0.0)`
`527`	`529`	`{`
`528`	`530`	`// Handle the trivial case quickly.`
`529`		`- if (value._real < 0.0)`
	`531`	`+ if (value.m_real < 0.0)`
`530`	`532`	`{`
`531`		`- return new Complex(0.0, Math.Sqrt(-value._real));`
	`533`	`+ return new Complex(0.0, Math.Sqrt(-value.m_real));`
`532`	`534`	`}`
`533`	`535`	`else`
`534`	`536`	`{`
`535`		`- return new Complex(Math.Sqrt(value._real), 0.0);`
	`537`	`+ return new Complex(Math.Sqrt(value.m_real), 0.0);`
`536`	`538`	`}`
`537`	`539`	`}`
`538`	`540`	`else`
`@@ -565,35 +567,35 @@ public static Complex Sqrt(Complex value)`
`565`	`567`	`// make the result representable. To avoid this, we re-scale (by exact powers of 2 for accuracy)`
`566`	`568`	`// when we encounter very large components to avoid intermediate infinities.`
`567`	`569`	`bool rescale = false;`
`568`		`- if ((Math.Abs(value._real) >= s_sqrtRescaleThreshold) \|\| (Math.Abs(value._imaginary) >= s_sqrtRescaleThreshold))`
	`570`	`+ if ((Math.Abs(value.m_real) >= s_sqrtRescaleThreshold) \|\| (Math.Abs(value.m_imaginary) >= s_sqrtRescaleThreshold))`
`569`	`571`	`{`
`570`		`- if (double.IsInfinity(value._imaginary) && !double.IsNaN(value._real))`
	`572`	`+ if (double.IsInfinity(value.m_imaginary) && !double.IsNaN(value.m_real))`
`571`	`573`	`{`
`572`	`574`	`// We need to handle infinite imaginary parts specially because otherwise`
`573`	`575`	`// our formulas below produce inf/inf = NaN. The NaN test is necessary`
`574`	`576`	`// so that we return NaN rather than (+inf,inf) for (NaN,inf).`
`575`		`- return (new Complex(double.PositiveInfinity, value._imaginary));`
	`577`	`+ return (new Complex(double.PositiveInfinity, value.m_imaginary));`
`576`	`578`	`}`
`577`	`579`	`else`
`578`	`580`	`{`
`579`		`- value._real *= 0.25;`
`580`		`- value._imaginary *= 0.25;`
	`581`	`+ value.m_real *= 0.25;`
	`582`	`+ value.m_imaginary *= 0.25;`
`581`	`583`	`rescale = true;`
`582`	`584`	`}`
`583`	`585`	`}`
`584`	`586`
`585`	`587`	`// This is the core of the algorithm. Everything else is special case handling.`
`586`	`588`	`double x, y;`
`587`		`- if (value._real >= 0.0)`
	`589`	`+ if (value.m_real >= 0.0)`
`588`	`590`	`{`
`589`		`- x = Math.Sqrt((Hypot(value._real, value._imaginary) + value._real) * 0.5);`
`590`		`- y = value._imaginary / (2.0 * x);`
	`591`	`+ x = Math.Sqrt((Hypot(value.m_real, value.m_imaginary) + value.m_real) * 0.5);`
	`592`	`+ y = value.m_imaginary / (2.0 * x);`
`591`	`593`	`}`
`592`	`594`	`else`
`593`	`595`	`{`
`594`		`- y = Math.Sqrt((Hypot(value._real, value._imaginary) - value._real) * 0.5);`
`595`		`- if (value._imaginary < 0.0) y = -y;`
`596`		`- x = value._imaginary / (2.0 * y);`
	`596`	`+ y = Math.Sqrt((Hypot(value.m_real, value.m_imaginary) - value.m_real) * 0.5);`
	`597`	`+ if (value.m_imaginary < 0.0) y = -y;`
	`598`	`+ x = value.m_imaginary / (2.0 * y);`
`597`	`599`	`}`
`598`	`600`
`599`	`601`	`if (rescale)`
`@@ -620,10 +622,10 @@ public static Complex Pow(Complex value, Complex power)`
`620`	`622`	`return Zero;`
`621`	`623`	`}`
`622`	`624`
`623`		`- double valueReal = value._real;`
`624`		`- double valueImaginary = value._imaginary;`
`625`		`- double powerReal = power._real;`
`626`		`- double powerImaginary = power._imaginary;`
	`625`	`+ double valueReal = value.m_real;`
	`626`	`+ double valueImaginary = value.m_imaginary;`
	`627`	`+ double powerReal = power.m_real;`
	`628`	`+ double powerImaginary = power.m_imaginary;`
`627`	`629`
`628`	`630`	`double rho = Abs(value);`
`629`	`631`	`double theta = Math.Atan2(valueImaginary, valueReal);`
`@@ -641,8 +643,8 @@ public static Complex Pow(Complex value, double power)`
`641`	`643`
`642`	`644`	`private static Complex Scale(Complex value, double factor)`
`643`	`645`	`{`
`644`		`- double realResult = factor * value._real;`
`645`		`- double imaginaryResuilt = factor * value._imaginary;`
	`646`	`+ double realResult = factor * value.m_real;`
	`647`	`+ double imaginaryResuilt = factor * value.m_imaginary;`
`646`	`648`	`return new Complex(realResult, imaginaryResuilt);`
`647`	`649`	`}`
`648`	`650`