Conversion of Decimal to any Base (Binary, Octal or Hexa) and vice-versa (C#)

string Calculate(string Input, double FromBase, double ToBase)
    {
        double NativeForm;  //The input in native representation
        string Output;      //The output representation

        //Ensure that there is data in all textboxes
        if (textBox1.Text == "" || textBox2.Text == "" || textBox3.Text == "")
            throw new Exception("Empty Field");
        //Locate decimal point in input
        int Decimal1;
        if (Input.Contains('.'))
        {
            Decimal1 = Input.IndexOf('.');
            Input = Input.Remove(Decimal1, 1);
            if (Input.Contains('.'))
                throw new Exception("Multiple Decimal Points");
        }
        else
        {
            Decimal1 = Input.Length;
        }
        Decimal1--;
        NativeForm = 0.0;
        for (int Position1 = 0; Position1 < Input.Length; Position1++)
        {
                int Place = Decimal1 - Position1;
                double PlaceValue = Math.Pow(FromBase, Place);
                char DigitRepresentation = Input[Position1];
                int Digit = digits.IndexOf(char.ToUpper(DigitRepresentation));
                if (Digit > FromBase)
                    throw new Exception("Symbol '" + DigitRepresentation + "' Exceeds Maximum");
                double DigitValue = Digit * PlaceValue;
                NativeForm += DigitValue;
        }
        //We now have the native representation, time to convert into our base of choice
        int Position2 = 0;
        int Decimal2 = (int)Math.Floor(Math.Log(NativeForm, ToBase));
        double Remainder = NativeForm;
        Output = "";
        while (Remainder > 0.0 && Output.Length < 17)
        {
            int Place = Decimal2 - Position2;
            double PlaceValue = Math.Pow(ToBase, Place);
            int Digit = (int)Math.Floor(Remainder / PlaceValue);
            char DigitRepresentation = digits[Digit];
            Output += DigitRepresentation;
            Remainder -= Digit * PlaceValue;
            if (Position2 == 0)
                Output += '.';
            Position2++;
        }
        Output += "×" + ToBase.ToString() + "^" + Decimal2.ToString();
        return Output;
    }
}

static readonly char[] m_sDigit = new[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
static string DecimalToBase(int decimalNumber, int baseNumber)
{
   if (baseNumber != 2)
      if(baseNumber != 8)
          if(baseNumber != 16)
               return string.Empty;
   
   uint val = (uint)decimalNumber;
            
   StringBuilder binaryHolder = new StringBuilder();

   int mask = 0, bits = 0;
   if (baseNumber == 2)
   {
       mask = 1;
       bits = 31;
   }
   else if (baseNumber == 8)
   {
       mask = 3;
       bits = 30;
   }
   else if (baseNumber == 16)
   {
       mask = 4;
       bits = 28;
   }

   baseNumber -=1;
   for (; bits >= 0; bits -= mask)
   {
        binaryHolder.Append(m_sDigit[(val >> bits) & (baseNumber)]);
   }
   return binaryHolder.ToString();
}

public static int BaseToDecimal(string input, int nBase)
{
    string characters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
    if (nBase < 2 || nBase > characters.Length)
    {
        throw new ArgumentOutOfRangeException("nBase", nBase, "Range: 2.." + characters.Length);
    }
    int result = 0;
    bool negative = false;
    if (input.StartsWith("-"))
    {
        negative = true;
        input = input.Substring(1);
    }
    for (int i = 0; i < input.Length; i++)
    {
        int value = characters.IndexOf(input[i]);
        if (value >= nBase || value < 0)
        {
            throw new ArgumentOutOfRangeException("input[" + i + "]", input[i], "This character is not valid for base " + nBase);
        }
        result += value * (int)Math.Pow(nBase, input.Length - i - 1);
    }
    if (negative)
    {
        result *= -1;
    }
    return result;
}

public static string DecimalToBase(int input, int nBase)
{
    string characters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
    if (nBase < 2 || nBase > characters.Length)
    {
        throw new ArgumentOutOfRangeException("nBase", nBase, "Range: 2.." + characters.Length);
    }
    if (input == 0)
    {
        return characters[0].ToString();
    }
    bool negative = false;
    if (input < 0)
    {
        negative = true;
        input *= -1;
    }
    StringBuilder sb = new StringBuilder();
    while (input != 0)
    {
        sb.Insert(0, (characters[input % nBase]));
        input /= nBase;
    }
    if (negative)
    {
        sb.Insert(0, "-");
    }
    return sb.ToString();
}

private string DecimalToBase(int iDec, int numberBase, int zeroPadding)
{
	if (numberBase > 16 || numberBase < 2) throw new System.ArgumentOutOfRangeException ("numberBase", numberBase, "numberBase - Range: 2..16") ;
	if (zeroPadding < 0) throw new System.ArgumentOutOfRangeException ("zeroPadding", zeroPadding, "zeroPadding should be positive") ;

	System.Text.StringBuilder str = new System.Text.StringBuilder() ;
	bool negative ;

	if (iDec < 0)
	{
		negative = true ;
		iDec *=-1 ;
	}
	else
	{
		negative = false ;
	}

	int MaxBit = 32;
	int max = MaxBit ;
	int[] result = new int[MaxBit];

	for(; iDec > 0; iDec/=numberBase)
	{
		int rem = iDec % numberBase;
		result[--max] = rem;
	} 

	if (iDec > 0) throw new System.ArgumentOutOfRangeException ("iDec", iDec, "iDec - Too large") ;

	for (int i=max;i<MaxBit;i++)
	{
		str.Append(cHexa[result[i]]);
	}
	int zeroPaddingRequired = zeroPadding - (MaxBit - max) ; 
	if (zeroPaddingRequired > 0) str.Insert (0, new string('0',zeroPaddingRequired)) ;
	if (negative) str.Insert (0, '-') ;
	return str.ToString();
}

[NonSerialized()]private char[] cHexa = new char[]{'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};