.NET 4.x Неправильно умножаются большие шестнадцатеричные числа - C#

Формулировка задачи:

Пишу калькулятор. Для обработки шестнадцатеричных чисел написал два метода: Десятеричное в шестнадцатеричное:
public string DecimalToHexadecimalSystem(long  digit)
        {
            //digit = Double.Parse(Console.ReadLine());
            bool positive = true;
            //if (digit < 0) { digit = Math.Abs(digit); positive = false; }
            string _result = "";
            long remainder = 0;          
 
            if (digit >= 0 && digit <= 9)
            {
                _result += digit.ToString(); return _result;
            }
            if (digit >= 10 && digit <= 16)
            {
                switch (digit.ToString())
                {
                    case "10":
                        { _result += "A"; return _result; }
                    case "11":
                        { _result += "B"; return _result; }
                    case "12":
                        { _result += "C"; return _result; }
                    case "13":
                        { _result += "D"; return _result; }
                    case "14":
                        { _result += "E"; return _result; }
                    case "15":
                        { _result += "F"; return _result; }
                    case "16":
                        { _result += "10"; return _result; }
                }
            }
 
            while (digit > 0)
            {
                remainder = digit % 16;
 
                if (remainder >= 0 && remainder <= 9) _result += remainder.ToString();
                else if (remainder >= 10 && remainder <= 16)
                {
                    switch (remainder.ToString())
                    {
                        case "10":
                            { _result += "A"; break; }
                        case "11":
                            { _result += "B"; break; }
                        case "12":
                            { _result += "C"; break; }
                        case "13":
                            { _result += "D"; break; }
                        case "14":
                            { _result += "E"; break; }
                        case "15":
                            { _result += "F"; break; }
                        case "16":
                            { _result += "10"; break; }
                    }
                }
                digit = (digit - remainder) / 16;
            }
            char[] arr = _result.ToCharArray();
            Array.Reverse(arr);
            _result = new string(arr);
            if (!positive) { _result = "-" + _result; }
            return _result;
        }
И наоборот:
public double HexadecimalToDecimalSystem(string input)
        {
            double result = 0;             
            string[] array = new string[input.Length];
            int i = 0;
            foreach (char x in input)
            {
                if (Char.IsDigit(x))
                {
                    array[i] = x.ToString(); i++;
                }
                else
                {
                    switch (x)
                    {
                        case 'A': { array[i] = "10"; i++; break; }
                        case 'B': { array[i] = "11"; i++; break; }
                        case 'C': { array[i] = "12"; i++; break; }
                        case 'D': { array[i] = "13"; i++; break; }
                        case 'E': { array[i] = "14"; i++; break; }
                        case 'F': { array[i] = "15"; i++; break; }
                    }
                }
            }
 
            int pow = array.Length - 1;
 
            for (i = 0; i < array.Length; i++)
            {
                result += Convert.ToDouble(array[i]) * Math.Pow(16, pow);
                pow--;
            }           
                return result;
        }
Вот так пробую умножать:
        public string Hexa_operations(string ex1,string ex2, string op)
        {
            double ex = 0;
            switch(op)
            {
                case "+":
                    {
                        ex = conv.HexadecimalToDecimalSystem(ex1) + conv.HexadecimalToDecimalSystem(ex2);
                        if (ex < 0) ex *= -1;
                        ex = (int)ex;
                        return conv.DecimalToHexadecimalSystem(Convert.ToInt64(ex));
                    }
 
                case "-":
                    {
                        ex = conv.HexadecimalToDecimalSystem(ex1) - conv.HexadecimalToDecimalSystem(ex2);
                        if (ex < 0) ex *= -1;
                        ex = (int)ex;
                        return conv.DecimalToHexadecimalSystem(Convert.ToInt64(ex));
                    }
                case "*":
                    {
                        ex = conv.HexadecimalToDecimalSystem(ex1) * conv.HexadecimalToDecimalSystem(ex2);
                        if (ex < 0) ex *= -1;
                        ex = (int)ex;
                        return conv.DecimalToHexadecimalSystem(Convert.ToInt64(ex));
                    }
                case "/":
                    {
                        ex = conv.HexadecimalToDecimalSystem(ex1) / conv.HexadecimalToDecimalSystem(ex2);
                        if (ex < 0) ex *= -1;
                        ex = (int)ex;
                        return conv.DecimalToHexadecimalSystem(Convert.ToInt64(ex));
                    }
            }
            return "0";
        }
Максимальное число, которое моя программа способна обработать: F в седьмой степени. F в восьмой возвращает -80000000.

Код к задаче: «.NET 4.x Неправильно умножаются большие шестнадцатеричные числа - C#»

textual
result += Convert.ToDouble(array[i]) * Math.Pow(16, pow);

13   голосов, оценка 4.077 из 5


СОХРАНИТЬ ССЫЛКУ