Fastest Dec to Hex and Hex to Dec conversions

Monkey Forums/Monkey Code/Fastest Dec to Hex and Hex to Dec conversions

Goodlookinguy

(Posted 2014) [#1]

This is ~~probably~~ the fastest multiplatform solution to solving dec to hex and vice-versa. I spent quite some time on it to ensure it beat everything currently available. There is more of an explanation on this on my site. There were very good reasons things were done the way they were.

Unlike most dec to hex (and vice-versa) things, I always like to have both Big Endian and Little Endian bit order. The functions are named accordingly with the abbreviations BE and LE.

BE = Big Endian
LE = Little Endian

Dec to Hex

Function DecToHexBE:String( decimal:Int )
	Local a1:Int = decimal & 15
	Local a2:Int = (decimal Shr 4) & 15
	Local b1:Int = (decimal Shr 8) & 15
	Local b2:Int = (decimal Shr 12) & 15
	Local c1:Int = (decimal Shr 16) & 15
	Local c2:Int = (decimal Shr 20) & 15
	Local d1:Int = (decimal Shr 24) & 15
	Local d2:Int = (decimal Shr 28) & 15
	
	#If TARGET = "html5" Or TARGET = "flash"
	If a1 < 10 Then a1 = a1 + 48 Else a1 = a1 + 55
	If a2 < 10 Then a2 = a2 + 48 Else a2 = a2 + 55
	If b1 < 10 Then b1 = b1 + 48 Else b1 = b1 + 55
	If b2 < 10 Then b2 = b2 + 48 Else b2 = b2 + 55
	If c1 < 10 Then c1 = c1 + 48 Else c1 = c1 + 55
	If c2 < 10 Then c2 = c2 + 48 Else c2 = c2 + 55
	If d1 < 10 Then d1 = d1 + 48 Else d1 = d1 + 55
	If d2 < 10 Then d2 = d2 + 48 Else d2 = d2 + 55
	
	Return String.FromChar(d2) + String.FromChar(d1) + String.FromChar(c2) + String.FromChar(c1) +
		String.FromChar(b2) + String.FromChar(b1) + String.FromChar(a2) + String.FromChar(a1)
	#Else
	If a1 < 10 Then __dhex[7] = a1 + 48 Else __dhex[7] = a1 + 55
	If a2 < 10 Then __dhex[6] = a2 + 48 Else __dhex[6] = a2 + 55
	If b1 < 10 Then __dhex[5] = b1 + 48 Else __dhex[5] = b1 + 55
	If b2 < 10 Then __dhex[4] = b2 + 48 Else __dhex[4] = b2 + 55
	If c1 < 10 Then __dhex[3] = c1 + 48 Else __dhex[3] = c1 + 55
	If c2 < 10 Then __dhex[2] = c2 + 48 Else __dhex[2] = c2 + 55
	If d1 < 10 Then __dhex[1] = d1 + 48 Else __dhex[1] = d1 + 55
	If d2 < 10 Then __dhex[0] = d2 + 48 Else __dhex[0] = d2 + 55
	
	Return String.FromChars(__dhex)
	#EndIf
End

Function DecToHexLE:String( decimal:Int )
	Local a1:Int = decimal & 15
	Local a2:Int = (decimal Shr 4) & 15
	Local b1:Int = (decimal Shr 8) & 15
	Local b2:Int = (decimal Shr 12) & 15
	Local c1:Int = (decimal Shr 16) & 15
	Local c2:Int = (decimal Shr 20) & 15
	Local d1:Int = (decimal Shr 24) & 15
	Local d2:Int = (decimal Shr 28) & 15
	
	#If TARGET = "html5" Or TARGET = "flash"
	If a1 < 10 Then a1 = a1 + 48 Else a1 = a1 + 55
	If a2 < 10 Then a2 = a2 + 48 Else a2 = a2 + 55
	If b1 < 10 Then b1 = b1 + 48 Else b1 = b1 + 55
	If b2 < 10 Then b2 = b2 + 48 Else b2 = b2 + 55
	If c1 < 10 Then c1 = c1 + 48 Else c1 = c1 + 55
	If c2 < 10 Then c2 = c2 + 48 Else c2 = c2 + 55
	If d1 < 10 Then d1 = d1 + 48 Else d1 = d1 + 55
	If d2 < 10 Then d2 = d2 + 48 Else d2 = d2 + 55
	
	Return String.FromChar(a2) + String.FromChar(a1) + String.FromChar(b2) + String.FromChar(b1) +
		String.FromChar(c2) + String.FromChar(c1) + String.FromChar(d2) + String.FromChar(d1)
	#Else
	If a1 < 10 Then __dhex[1] = a1 + 48 Else __dhex[1] = a1 + 55
	If a2 < 10 Then __dhex[0] = a2 + 48 Else __dhex[0] = a2 + 55
	If b1 < 10 Then __dhex[3] = b1 + 48 Else __dhex[3] = b1 + 55
	If b2 < 10 Then __dhex[2] = b2 + 48 Else __dhex[2] = b2 + 55
	If c1 < 10 Then __dhex[5] = c1 + 48 Else __dhex[5] = c1 + 55
	If c2 < 10 Then __dhex[4] = c2 + 48 Else __dhex[4] = c2 + 55
	If d1 < 10 Then __dhex[7] = d1 + 48 Else __dhex[7] = d1 + 55
	If d2 < 10 Then __dhex[6] = d2 + 48 Else __dhex[6] = d2 + 55
	
	Return String.FromChars(__dhex)
	#EndIf
End

#If TARGET <> "html5" And TARGET <> "flash"
Private
Global __dhex:Int[8]
Public
#EndIf

Hex to Dec

Function HexBEToDec:Int( hex:String )
	Local a1, a2, b1, b2, c1, c2, d1, d2, len, off
	len = hex.Length ' assuming 8 is the max without having to clamp
	off = 8 - len
	
	If len < 1 Then a1 = 0 Else a1 = hex[7 - off] - 48
	If len < 2 Then a2 = 0 Else a2 = hex[6 - off] - 48
	If len < 3 Then b1 = 0 Else b1 = hex[5 - off] - 48
	If len < 4 Then b2 = 0 Else b2 = hex[4 - off] - 48
	If len < 5 Then c1 = 0 Else c1 = hex[3 - off] - 48
	If len < 6 Then c2 = 0 Else c2 = hex[2 - off] - 48
	If len < 7 Then d1 = 0 Else d1 = hex[1 - off] - 48
	If len < 8 Then d2 = 0 Else d2 = hex[0] - 48
	
	If a1 > 9 Then a1 = a1 - 7 - (a1 / 48 * 32)
	If a2 > 9 Then a2 = a2 - 7 - (a2 / 48 * 32)
	If b1 > 9 Then b1 = b1 - 7 - (b1 / 48 * 32)
	If b2 > 9 Then b2 = b2 - 7 - (b2 / 48 * 32)
	If c1 > 9 Then c1 = c1 - 7 - (c1 / 48 * 32)
	If c2 > 9 Then c2 = c2 - 7 - (c2 / 48 * 32)
	If d1 > 9 Then d1 = d1 - 7 - (d1 / 48 * 32)
	If d2 > 9 Then d2 = d2 - 7 - (d2 / 48 * 32)
	
	Return a1 | (a2 Shl 4) | (b1 Shl 8) | (b2 Shl 12) | (c1 Shl 16) | (c2 Shl 20) | (d1 Shl 24) | (d2 Shl 28)
End

Function HexLEToDec:Int( hex:String )
	Local a1, a2, b1, b2, c1, c2, d1, d2, len
	len = hex.Length
	
	If len < 8 Then d1 = 0 Else d1 = hex[7] - 48
	If len < 7 Then d2 = 0 Else d2 = hex[6] - 48
	If len < 6 Then c1 = 0 Else c1 = hex[5] - 48
	If len < 5 Then c2 = 0 Else c2 = hex[4] - 48
	If len < 4 Then b1 = 0 Else b1 = hex[3] - 48
	If len < 3 Then b2 = 0 Else b2 = hex[2] - 48
	If len < 2 Then a1 = 0 Else a1 = hex[1] - 48
	If len < 1 Then a2 = 0 Else a2 = hex[0] - 48
	
	If a1 > 9 Then a1 = a1 - 7 - (a1 / 48 * 32)
	If a2 > 9 Then a2 = a2 - 7 - (a2 / 48 * 32)
	If b1 > 9 Then b1 = b1 - 7 - (b1 / 48 * 32)
	If b2 > 9 Then b2 = b2 - 7 - (b2 / 48 * 32)
	If c1 > 9 Then c1 = c1 - 7 - (c1 / 48 * 32)
	If c2 > 9 Then c2 = c2 - 7 - (c2 / 48 * 32)
	If d1 > 9 Then d1 = d1 - 7 - (d1 / 48 * 32)
	If d2 > 9 Then d2 = d2 - 7 - (d2 / 48 * 32)
	
	Return a1 | (a2 Shl 4) | (b1 Shl 8) | (b2 Shl 12) | (c1 Shl 16) | (c2 Shl 20) | (d1 Shl 24) | (d2 Shl 28)
End

Example usage / testing...

Hex to Dec

Function Main:Int()
	Print HexBEToDec("00000BB8") + " <-- 3000"
	Print HexBEToDec("00000DAC") + " <-- 3500"
	Print ""
	
	Print HexLEToDec("B80B0000") + " <-- 3000"
	Print HexLEToDec("AC0D0000") + " <-- 3500"
	Print ""
	
	Print HexBEToDec("BB8") + " <-- 3000"
	Print HexBEToDec("DAC") + " <-- 3500"
	Print ""
	
	Print HexLEToDec("B80B") + " <-- 3000"
	Print HexLEToDec("AC0D") + " <-- 3500"
	Print ""
	
	Print HexBEToDec("00000bb8") + " <-- 3000"
	Print HexBEToDec("00000dac") + " <-- 3500"
	Print ""
	
	Print HexLEToDec("b80b0000") + " <-- 3000"
	Print HexLEToDec("ac0d0000") + " <-- 3500"
	Print ""
	
	Print HexBEToDec("bb8") + " <-- 3000"
	Print HexBEToDec("dac") + " <-- 3500"
	Print ""
	
	Print HexLEToDec("b80b") + " <-- 3000"
	Print HexLEToDec("ac0d") + " <-- 3500"
	Print ""
	
	Print HexBEToDec("Bb8") + " <-- 3000"
	Print HexBEToDec("dAc") + " <-- 3500"
	Print ""
	
	Print HexLEToDec("b80B") + " <-- 3000"
	Print HexLEToDec("aC0d") + " <-- 3500"
	Print ""
End

Dec to Hex

Function Main:Int()
	Print DecToHexBE(3000) + " <-- 00000BB8"
	Print DecToHexBE(3500) + " <-- 00000DAC"
	Print ""
	
	Print DecToHexLE(3000) + " <-- B80B0000"
	Print DecToHexLE(3500) + " <-- AC0D0000"
	Print ""
End

Do you need proof that it's working and is faster than everyone else's solutions? Here, try for yourself. I even added the links to said functions from the other users.

CODE ~ This has the testing lines so that you can see (and test if need be) that I did not obscure the results, as I have no reason to lie about how much faster my functions are.

Import mojo

Function Main:Int()
	New TestsToRun()
End

Class TestsToRun Extends App
	Method OnCreate:Int()
		Local tests:Int = 10000000
		Local m:Int = 0
		Local be:String = "1199AA"
		Local le:String = "AA9911"
		Local startTime:Int = 0
		Local totalTime:Int = 0
		
		Print String(HexToInteger(be))
		Print String(HexToInt(be))
		Print String(HexToDec(be))
		Print String(HexBEToDec(be))
		Print String(HexLEToDec(le))
		
		Print "Start Other A 1"
		startTime = Millisecs()
		For Local i:Int = 0 Until tests
			m = HexToInteger(be)
		Next
		totalTime = Millisecs() - startTime
		Print "Total Time: " + String(totalTime) + "~n"
		
		Print "Start Other B 1"
		startTime = Millisecs()
		For Local i:Int = 0 Until tests
			m = HexToInt(be)
		Next
		totalTime = Millisecs() - startTime
		Print "Total Time: " + String(totalTime) + "~n"
		
		Print "Start Other C 1"
		startTime = Millisecs()
		For Local i:Int = 0 Until tests
			m = HexToDec(be)
		Next
		totalTime = Millisecs() - startTime
		Print "Total Time: " + String(totalTime) + "~n"
		
		Print "Start BE 1"
		startTime = Millisecs()
		For Local i:Int = 0 Until tests
			m = HexBEToDec(be)
		Next
		totalTime = Millisecs() - startTime
		Print "Total Time: " + String(totalTime) + "~n"
		
		Print "Start LE 1"
		startTime = Millisecs()
		For Local i:Int = 0 Until tests
			m = HexLEToDec(le)
		Next
		totalTime = Millisecs() - startTime
		Print "Total Time: " + String(totalTime) + "~n"
		
		Print "Start Other A 2"
		startTime = Millisecs()
		For Local i:Int = 0 Until tests
			m = HexToInteger(be)
		Next
		totalTime = Millisecs() - startTime
		Print "Total Time: " + String(totalTime) + "~n"
		
		Print "Start Other B 2"
		startTime = Millisecs()
		For Local i:Int = 0 Until tests
			m = HexToInt(be)
		Next
		totalTime = Millisecs() - startTime
		Print "Total Time: " + String(totalTime) + "~n"
		
		Print "Start Other C 2"
		startTime = Millisecs()
		For Local i:Int = 0 Until tests
			m = HexToDec(be)
		Next
		totalTime = Millisecs() - startTime
		Print "Total Time: " + String(totalTime) + "~n"
		
		Print "Start BE 2"
		startTime = Millisecs()
		For Local i:Int = 0 Until tests
			m = HexBEToDec(be)
		Next
		totalTime = Millisecs() - startTime
		Print "Total Time: " + String(totalTime) + "~n"
		
		Print "Start LE 2"
		startTime = Millisecs()
		For Local i:Int = 0 Until tests
			m = HexLEToDec(le)
		Next
		totalTime = Millisecs() - startTime
		Print "Total Time: " + String(totalTime) + "~n"
	End
End

'http://www.monkey-x.com/Community/posts.php?topic=10391
Function HexToInteger:Int(Hex:String)

	Local digit:Int, value:Int;
	For Local i:Int = 0 Until Hex.Length '-1;
		value*=16
		Select Hex[i]
			Case "0"[0]; digit = 0;
			Case "1"[0]; digit = 1;
			Case "2"[0]; digit = 2;
			Case "3"[0]; digit = 3;
			Case "4"[0]; digit = 4;
			Case "5"[0]; digit = 5;
			Case "6"[0]; digit = 6;
			Case "7"[0]; digit = 7;
			Case "8"[0]; digit = 8;
			Case "9"[0]; digit = 9;
			Case "A"[0], "a"[0]; digit = 10;
			Case "B"[0], "b"[0]; digit = 11;
			Case "C"[0], "c"[0]; digit = 12;
			Case "D"[0], "d"[0]; digit = 13;
			Case "E"[0], "e"[0]; digit = 14;
			Case "F"[0], "f"[0]; digit = 15;
			Default
				'Error("unexpected character on hexadecimal literal.");
				digit = 0;
		End
		value = (value + digit) 
	Next
	Return value;
	
End

'http://www.monkey-x.com/Community/posts.php?topic=7716
Function HexToInt:Int(hexIn:String)
	Local hexRefTable:String
	Local tokenValue:Int
	Local column:Int
	Local intOut:Int
	
	hexIn = hexIn.ToUpper()
	hexRefTable = "0123456789ABCDEF"
	
	For column = 0 To hexIn.Length() - 1
		tokenValue = hexRefTable.Find(hexIn[column .. column + 1])
		intOut = (intOut * 16) + tokenValue
	Next
	
	Return intOut
End

'http://www.monkey-x.com/Community/posts.php?topic=4058&post=53420
Function HexToDec:Int( Hex:String )
	Local Value:Int = 0
	Local Char:Int =0
	
	If Hex.Length() <8
		'add 0's to beginning of thing so FF becomes 000000FF
		Local TempHex:String = ""
		For Char =Hex.Length() To 7
			TempHex += "0"
		Next
		TempHex += Hex
		Hex = TempHex
	Endif
	
	Local Conversion:Int = 1		'starts at 1 then 16, 256, 4096, 
	'now the characters are 'eight bytes' now begin conversion
	For Char=7 To 0 Step -1
		If Hex[ Char ]<58
			Value += ( ( Hex[ Char ] -48 ) *Conversion )
		Else
			Value += ( ( Hex[ Char ] -55 ) *Conversion )
		Endif			
		Conversion *= 16	'multiply conversion by 16 for next byte
	Next
			
	Return Value
End


'http://www.monkey-x.com/Community/posts.php?topic=8247
Function HexBEToDec:Int( hex:String )
	Local a1, a2, b1, b2, c1, c2, d1, d2, len, off
	len = hex.Length ' assuming 8 is the max without having to clamp
	off = 8 - len
	
	If len < 1 Then a1 = 0 Else a1 = hex[7 - off] - 48
	If len < 2 Then a2 = 0 Else a2 = hex[6 - off] - 48
	If len < 3 Then b1 = 0 Else b1 = hex[5 - off] - 48
	If len < 4 Then b2 = 0 Else b2 = hex[4 - off] - 48
	If len < 5 Then c1 = 0 Else c1 = hex[3 - off] - 48
	If len < 6 Then c2 = 0 Else c2 = hex[2 - off] - 48
	If len < 7 Then d1 = 0 Else d1 = hex[1 - off] - 48
	If len < 8 Then d2 = 0 Else d2 = hex[0] - 48
	
	If a1 > 9 Then a1 = a1 - 7 - (a1 / 48 * 32)
	If a2 > 9 Then a2 = a2 - 7 - (a2 / 48 * 32)
	If b1 > 9 Then b1 = b1 - 7 - (b1 / 48 * 32)
	If b2 > 9 Then b2 = b2 - 7 - (b2 / 48 * 32)
	If c1 > 9 Then c1 = c1 - 7 - (c1 / 48 * 32)
	If c2 > 9 Then c2 = c2 - 7 - (c2 / 48 * 32)
	If d1 > 9 Then d1 = d1 - 7 - (d1 / 48 * 32)
	If d2 > 9 Then d2 = d2 - 7 - (d2 / 48 * 32)
	
	Return a1 | (a2 Shl 4) | (b1 Shl 8) | (b2 Shl 12) | (c1 Shl 16) | (c2 Shl 20) | (d1 Shl 24) | (d2 Shl 28)
End

'http://www.monkey-x.com/Community/posts.php?topic=8247
Function HexLEToDec:Int( hex:String )
	Local a1, a2, b1, b2, c1, c2, d1, d2, len
	len = hex.Length
	
	If len < 8 Then d1 = 0 Else d1 = hex[7] - 48
	If len < 7 Then d2 = 0 Else d2 = hex[6] - 48
	If len < 6 Then c1 = 0 Else c1 = hex[5] - 48
	If len < 5 Then c2 = 0 Else c2 = hex[4] - 48
	If len < 4 Then b1 = 0 Else b1 = hex[3] - 48
	If len < 3 Then b2 = 0 Else b2 = hex[2] - 48
	If len < 2 Then a1 = 0 Else a1 = hex[1] - 48
	If len < 1 Then a2 = 0 Else a2 = hex[0] - 48
	
	If a1 > 9 Then a1 = a1 - 7 - (a1 / 48 * 32)
	If a2 > 9 Then a2 = a2 - 7 - (a2 / 48 * 32)
	If b1 > 9 Then b1 = b1 - 7 - (b1 / 48 * 32)
	If b2 > 9 Then b2 = b2 - 7 - (b2 / 48 * 32)
	If c1 > 9 Then c1 = c1 - 7 - (c1 / 48 * 32)
	If c2 > 9 Then c2 = c2 - 7 - (c2 / 48 * 32)
	If d1 > 9 Then d1 = d1 - 7 - (d1 / 48 * 32)
	If d2 > 9 Then d2 = d2 - 7 - (d2 / 48 * 32)
	
	Return a1 | (a2 Shl 4) | (b1 Shl 8) | (b2 Shl 12) | (c1 Shl 16) | (c2 Shl 20) | (d1 Shl 24) | (d2 Shl 28)
End

OUTPUT ~ This has the first 5 confirming lines that make sure each function does as it says it does. Second bit is the test from each of the functions. BE and LE ones are mine. Notice they are quite a bit faster.

1153450
1153450
1153450
1153450
1153450
Start Other A 1
Total Time: 1287

Start Other B 1
Total Time: 6609

Start Other C 1
Total Time: 1465

Start BE 1
Total Time: 861

Start LE 1
Total Time: 821

Start Other A 2
Total Time: 1266

Start Other B 2
Total Time: 6533

Start Other C 2
Total Time: 1459

Start BE 2
Total Time: 877

Start LE 2
Total Time: 827