# Base N converter (N = 10-62)

By , 16 Jul 2008
Votes of 3 or less require a comment

## Introduction

This class uses the Hex algorithm idea and expands it. Or, more like the Base64 conversion.

## The Class

```public static class ExpandableHexConverter
{
public enum ExpandLevel
{
A = 11,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
UseCaseSensitive = 62
}

public static string ToHex(long value, ExpandLevel ExpandBy)
{
return loopRemainder(value, (long)ExpandBy);
}

public static long ToInt64(string value, ExpandLevel ExpandBy)
{
value = validate(value, ExpandBy);
long returnvalue = 0;
for (int i = 0; i < value.Length; i++)
returnvalue += (long)Math.Pow((long)ExpandBy,
(value.Length - (i + 1))) * CharToVal(value[i]);
return returnvalue;
}

private static string loopRemainder(long value, long PowerOf)
{
long x = 0;
long y = Math.DivRem(value, PowerOf, out x);
if (y > 0)
return loopRemainder(y, PowerOf) + ValToChar(x).ToString();
else
return ValToChar(x).ToString();
}
private static char ValToChar(long value)
{
if (value > 9)
{
int ascii = (65 + ((int)value - 10));
if (ascii > 90)
ascii += 6;
return (char)ascii;
}
else
return value.ToString()[0];
}
private static long CharToVal(char value)
{
long chrval = (int)value;
if (chrval > 96)
return (chrval - 71) + 10;
else if (chrval > 64)
return (chrval - 65) + 10;
else
return int.Parse(value.ToString());
}
private static string validate(string input, ExpandLevel ExpandBy)
{
string validchars = "";
string rtnval = "";
for (long c = 0; c < (long)ExpandBy; c++)
validchars += ValToChar(c);
foreach (char i in input)
if (validchars.Contains(i.ToString()))
rtnval += i;
return rtnval;
}
}```

## Using the code

Normal hex looks like this:

```string HexValue = ExpandableHexConverter.ToHex(255,
ExpandableHexConverter.ExpandLevel.F);```

Result:

`HexValue = FF`

Expanded hex could look like this:

```//NOTE: Z Level selected and the value to convert is larger.
string HexValue = ExpandableHexConverter.ToHex(1295,
ExpandableHexConverter.ExpandLevel.Z);```

Result:

```Result:
HexValue = ZZ```

Expanded hex could also look like this:

```//NOTE: UseCaseSensitive Level selected and the value
//to convert is larger that the previus example.
string HexValue = ExpandableHexConverter.ToHex(3843,
ExpandableHexConverter.ExpandLevel.UseCaseSensitive);```

Result:

```Result:
HexValue = zz```

## Some comparisons

The normal Hex Algorithm is Base 16, which is demonstrated here:

• F = 15 (0 to 15 = 16)
• FF = 255
• FFF = 4095

The expanded Hex Algorithm set to Z is Base 36, which is demonstrated here:

• Z = 35 (0 to 35 = 36)
• ZZ = 1295
• ZZZ = 46655 (11 times larger than normal Hex)

The expanded Hex Algorithm set to UseCaseSensitive is Base 62, which is demonstrated here:

• z = 61 (0 to 61 = 62)
• zz = 3843
• zz = 238327(58 times larger than normal Hex)

## History

• 23. Nov. 2007 - The first version is posted.
• 23. Nov. 2007 - Article renamed...

 First PrevNext
 Thanks westdw 1-May-09 6:16
 Limited PIEBALDconsult 17-Jul-08 4:16
 Re: Limited kevdelkevdel 17-Jul-08 4:49
 Article layout Jaime Olivares 16-Jul-08 15:06
 Re: Article layout Paw Jershauge 16-Jul-08 23:35
 Re: Article layout Jaime Olivares 17-Jul-08 1:22
 Is there such thing as base 1? reinux 24-Nov-07 21:29
 Re: Is there such thing as base 1? PawJershauge 25-Nov-07 0:56
 Re: Is there such thing as base 1? reinux 25-Nov-07 12:46
 Re: Is there such thing as base 1? CoLithium 26-Nov-07 18:03
 Last Visit: 31-Dec-99 18:00     Last Update: 17-Dec-13 17:03 Refresh 123 Next »