# Base N converter (N = 10-62)

By , 16 Jul 2008

## 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...

 Paw Jershauge Software Developer Denmark Member

Votes of 3 or less require a comment

 Search this forum Profile popups    Spacing RelaxedCompactTight   Noise Very HighHighMediumLowVery Low   Layout Open AllThread ViewNo JavascriptPreview   Per page 102550
 First Prev Next
 Thanks westdw 1 May '09 - 6:16 1
 Limited PIEBALDconsult 17 Jul '08 - 4:16 2
 Article layout Jaime Olivares 16 Jul '08 - 15:06 3
 Is there such thing as base 1? reinux 24 Nov '07 - 21:29 10
 confusing Luc Pattyn 23 Nov '07 - 3:21 8
 Last Visit: 31 Dec '99 - 18:00     Last Update: 19 May '13 - 23:58 Refresh 1