Sqrt(negative number) throws ArgumentOutOfRangeException

Author: asik

Fix64.cs

@@ -264,7 +264,7 @@ public static Fix64 FastMul(Fix64 x, Fix64 y) {
         }
 
         [MethodImplAttribute(MethodImplOptions.AggressiveInlining)] 
-        static int Clz(ulong x) {
+        static int CountLeadingZeroes(ulong x) {
             int result = 0;
             while ((x & 0xF000000000000000) == 0) { result += 4; x <<= 4; }
             while ((x & 0x8000000000000000) == 0) { result += 1; x <<= 1; }
@@ -292,7 +292,7 @@ static int Clz(ulong x) {
             }
 
             while (remainder != 0 && bitPos >= 0) {
-                int shift = Clz(remainder);
+                int shift = CountLeadingZeroes(remainder);
                 if (shift > bitPos) {
                     shift = bitPos;
                 }
@@ -368,14 +368,16 @@ public static Fix64 FastMod(Fix64 x, Fix64 y) {
 
         /// <summary>
         /// Returns the square root of a specified number.
-        /// Throws an ArgumentException if the number is negative.
         /// </summary>
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// The argument was negative.
+        /// </exception>
         public static Fix64 Sqrt(Fix64 x) {
             var xl = x.m_rawValue;
             if (xl < 0) {
                 // We cannot represent infinities like Single and Double, and Sqrt is
                 // mathematically undefined for x < 0. So we just throw an exception.
-                throw new ArgumentException("Negative value passed to Sqrt", "x");
+                throw new ArgumentOutOfRangeException("Negative value passed to Sqrt", "x");
             }
 
             var num = (ulong)xl;

Fix64Tests.cs

@@ -312,7 +312,7 @@ public void Sqrt() {
             for (int i = 0; i < m_testCases.Length; ++i) {
                 var f = Fix64.FromRaw(m_testCases[i]);
                 if (Fix64.Sign(f) < 0) {
-                    Assert.Throws<ArgumentException>(() => Fix64.Sqrt(f));
+                    Assert.Throws<ArgumentOutOfRangeException>(() => Fix64.Sqrt(f));
                 }
                 else {
                     var expected = Math.Sqrt((double)f);