Corrected typo, corrected float/complex, added more tests.

src/Numerics/Complex32.cs

@@ -641,7 +641,8 @@ namespace MathNet.Numerics
         }
 
         /// <summary>Division operator. Divides a complex number by another.</summary>
-        /// <remarks>Enchanted Smith's algorithm for dividing two complex numbers </remarks>
+        /// <remarks>Enhanced Smith's algorithm for dividing two complex numbers </remarks>
+        /// <see cref="InternalDiv(float, float, float, float, bool)"/>
         /// <returns>The result of the division.</returns>
         /// <param name="dividend">The dividend.</param>
         /// <param name="divisor">The divisor.</param>
@@ -694,6 +695,8 @@ namespace MathNet.Numerics
         }
 
         /// <summary>Division operator. Divides a float value by a complex number.</summary>
+        /// <remarks>Algorithm based on Smith's algorithm</remarks>
+        /// <see cref="InternalDiv(float, float, float, float, bool)"/> 
         /// <returns>The result of the division.</returns>
         /// <param name="dividend">The dividend.</param>
         /// <param name="divisor">The divisor.</param>
@@ -708,9 +711,11 @@ namespace MathNet.Numerics
             {
                 return PositiveInfinity;
             }
-
-            var zmod = divisor.MagnitudeSquared;
-            return new Complex32(dividend * divisor._real / zmod, -dividend * divisor._imag / zmod);
+            float c = divisor.Real;
+            float d = divisor.Imaginary;
+            if (Math.Abs(d) <= Math.Abs(c))
+                return InternalDiv(dividend, 0, c, d, false);
+            return InternalDiv(0, dividend, d, c, true);
         }
 
         /// <summary>Division operator. Divides a complex number by a float value.</summary>

src/UnitTests/ComplexTests/Complex32Test.cs

@@ -436,7 +436,21 @@ namespace MathNet.Numerics.UnitTests.ComplexTests
             Assert.AreEqual(new Complex32(-(float)Math.Pow(10, 20), (float)Math.Pow(10, -14)), first / second);
 
         }
+        /// <summary>
+        /// Can divide float/complex without overflow
+        /// </summary>
+        [Test]
+        public void CanDodgeOverflowDivisionFloat()
+        {
+
+            var first = new Complex32((float)Math.Pow(10, 25), (float)Math.Pow(10, -25));
+            float second = (float)Math.Pow(10, -37);
+            float third = (float)Math.Pow(10, 37);
+            Assert.AreEqual(new Complex32(0, 0), second / first); // it's (10^-62,10^-112) thus overflow
+            Assert.AreEqual(new Complex32((float)Math.Pow(10, 12), (float)Math.Pow(10, -38)), third / first); 
+            Assert.AreEqual(new Complex32((float)Math.Pow(10, -28), -(float)Math.Pow(10, 12)), third / new Complex32((float)Math.Pow(10, -25), (float)Math.Pow(10, 25))); 
 
+        }
         /// <summary>
         /// Can multiple a complex number and a double using operators.
         /// </summary>
@@ -574,7 +588,7 @@ namespace MathNet.Numerics.UnitTests.ComplexTests
         {
             Assert.AreEqual((float)Math.Sqrt(2) * float.Epsilon, new Complex32(float.Epsilon, float.Epsilon).Magnitude);
             Assert.AreEqual(float.Epsilon, new Complex32(0, float.Epsilon).Magnitude);
-            Assert.AreEqual((float)(Math.Pow(10,30) * Math.Sqrt(2)), new Complex32((float)Math.Pow(10, 30), (float)Math.Pow(10, 30)).Magnitude);
+            Assert.AreEqual((float)(Math.Pow(10, 30) * Math.Sqrt(2)), new Complex32((float)Math.Pow(10, 30), (float)Math.Pow(10, 30)).Magnitude);
 
         }
         /// <summary>