support fractions in base converter

Author: justcoding121

Advanced.Algorithms.Tests/BitAlgorithms/BaseConversion_Tests.cs

@@ -14,21 +14,40 @@ public class BaseConversion_Tests
         [TestMethod]
         public void BaseConversion_Smoke_Test()
         {
+            //decimal to binary
+            Assert.AreEqual("11",
+              BaseConversion.Convert("1011", "01",
+                  "0123456789"));
+
+            //binary to decimal
+            Assert.AreEqual("11.5",
+                BaseConversion.Convert("1011.10", "01",
+               "0123456789"));
+
+            //decimal to base3
             Assert.AreEqual("Foo",
                 BaseConversion.Convert("9", "0123456789", 
                     "oF8"));
 
+            //base3 to decimal 
             Assert.AreEqual("9",
                 BaseConversion.Convert("Foo", "oF8",
                     "0123456789"));
 
+            //hex to binary
             Assert.AreEqual("10011",
                 BaseConversion.Convert("13", "0123456789abcdef",
                     "01"));
 
-            Assert.AreEqual("JAM!",
-                BaseConversion.Convert("CODE", "O!CDE?",
-                    "A?JM!."));
+            //decimal to hex
+            Assert.AreEqual("5.0e631f8a0902de00d1b71758e219652b",
+                BaseConversion.Convert("5.05620", "0123456789",
+                    "0123456789abcdef"));
+
+            //hex to decimal with precision 5
+            Assert.AreEqual("5.05619",
+               BaseConversion.Convert("5.0e631f8a0902de00d1b71758e219652b", "0123456789abcdef",
+                    "0123456789", 5));
 
         }
     }

Advanced.Algorithms/BitAlgorithms/BaseConversion.cs

@@ -15,10 +15,39 @@ public class BaseConversion
         /// <param name="srcBaseChars">Should be in correct order => eg. 0123456789 for decimal</param>
         /// <param name="dstBaseChars">>Should be in correct order => eg. 01 for binary</param>
         /// <returns></returns>
-        public static string Convert(string srcNumber, 
+        public static string Convert(string srcNumber,
                     string srcBaseChars,
-                    string dstBaseChars)
+                    string dstBaseChars, int precision = 32)
         {
+            srcNumber = srcNumber.Trim();
+            if (srcNumber.Contains("."))
+            {
+                var tmp = srcNumber.Split('.');
+                var whole = tmp[0].TrimEnd();
+                var fraction = tmp[1].TrimStart();
+
+                return ConvertWhole(whole, srcBaseChars, dstBaseChars) +
+                   "." + ConvertFraction(fraction, srcBaseChars, dstBaseChars, precision);
+            }
+
+            return ConvertWhole(srcNumber, srcBaseChars, dstBaseChars);
+        }
+        /// <summary>
+        /// Converts base of given number
+        /// </summary>
+        /// <param name="srcNumber">input number in source base system</param>
+        /// <param name="srcBaseChars">Should be in correct order => eg. 0123456789 for decimal</param>
+        /// <param name="dstBaseChars">>Should be in correct order => eg. 01 for binary</param>
+        /// <returns></returns>
+        private static string ConvertWhole(string srcNumber,
+                string srcBaseChars,
+                string dstBaseChars)
+        {
+            if (string.IsNullOrEmpty(srcNumber))
+            {
+                return string.Empty;
+            }
+
             var srcBase = srcBaseChars.Length;
             var dstBase = dstBaseChars.Length;
 
@@ -27,7 +56,7 @@ public static string Convert(string srcNumber,
                 throw new Exception("Invalid source base length.");
             }
 
-            if (dstBase <=1)
+            if (dstBase <= 1)
             {
                 throw new Exception("Invalid destination base length.");
             }
@@ -36,16 +65,17 @@ public static string Convert(string srcNumber,
             var j = 0;
             //convert to base 10
             //move from least to most significant numbers
-            for(int i=srcNumber.Length-1;i >= 0;i--)
+            for (int i = srcNumber.Length - 1; i >= 0; i--)
             {
                 //eg. 1 * 2^0 
-                base10Result += (long)((srcBaseChars.IndexOf(srcNumber[i])) * Math.Pow(srcBase, j));
+                base10Result += (srcBaseChars.IndexOf(srcNumber[i]))
+                    * (long)(Math.Pow(srcBase, j));
                 j++;
             }
 
             var result = new StringBuilder();
             //now convert to target base
-            while(base10Result!=0)
+            while (base10Result != 0)
             {
                 var rem = (int)base10Result % dstBase;
                 result.Insert(0, dstBaseChars[rem]);
@@ -55,5 +85,51 @@ public static string Convert(string srcNumber,
             return result.ToString();
 
         }
+
+        private static string ConvertFraction(string srcNumber,
+           string srcBaseChars,
+           string dstBaseChars, int maxPrecision)
+        {
+            if (string.IsNullOrEmpty(srcNumber))
+            {
+                return string.Empty;
+            }
+
+            var srcBase = srcBaseChars.Length;
+            var dstBase = dstBaseChars.Length;
+
+            if (srcBase <= 1)
+            {
+                throw new Exception("Invalid source base length.");
+            }
+
+            if (dstBase <= 1)
+            {
+                throw new Exception("Invalid destination base length.");
+            }
+
+            decimal base10Result = 0;
+            //convert to base 10
+            //move from most significant numbers to least
+            for (int i = 0; i < srcNumber.Length; i++)
+            {
+                //eg. 1 * 1/(2^1) 
+                base10Result += (srcBaseChars.IndexOf(srcNumber[i]))
+                    * (decimal)(1 / Math.Pow(srcBase, i + 1));
+            }
+
+            var result = new StringBuilder();
+            //now convert to target base
+            while (base10Result != 0 && maxPrecision > 0)
+            {
+                base10Result = base10Result * dstBase;
+                result.Append(dstBaseChars[(int)Math.Floor(base10Result)]);
+                base10Result -= Math.Floor(base10Result);
+                maxPrecision--;
+            }
+
+            return result.ToString();
+
+        }
     }
 }