Hex & Bin - Proceduren

[Jilocasin]

Hi

Ich hab hier 3 Proceduren geschrieben, die HEX und BIN-Werte konvertierten können:

Code: Alles auswählen

Procedure.l Hex2Dec(Wert.s)
  ; Verbesserung von Karl...
  Protected temp.l, i.w
  
  For i = 1 To Len(Wert)
    Select UCase(Mid(Wert, i, 1))
      Case "A"
        temp + 10 * Pow(16,(Len(Wert)-i))
      Case "B"
        temp + 11 * Pow(16,(Len(Wert)-i))
      Case "C"
        temp + 12 * Pow(16,(Len(Wert)-i))
      Case "D"
        temp + 13 * Pow(16,(Len(Wert)-i))
      Case "E"
        temp + 14 * Pow(16,(Len(Wert)-i))
      Case "F"
        temp + 15 * Pow(16,(Len(Wert)-i))
      Default
        temp + Val(Mid(Wert,i,1)) * Pow(16,(Len(Wert)-i))
    EndSelect
  Next i
  
  ProcedureReturn temp
EndProcedure 

;   "Dez2Hex"   gibt's ja schon...





Procedure Bin2Dec(bin.s) ; bin.s muss immer die Länge von 8 Zeichen (1 Byte) haben, sonst werden Nullen drangehängt!
  long = 0
  For a = 1 To 8
    long + Val(Mid(bin,9-a,1))*Pow(2,a-1)
  Next
  ProcedureReturn long
EndProcedure



Procedure.s Dec2Bin(dez.l)
  Result.s = ""
  For a = 8 To 1 Step -1
    If Pow(2,a-1) <= dez
      dez - Pow(2,a-1)
      dez = dez/-1
      Result + "1"
    Else
     Result + "0"
    EndIf
  Next
  ProcedureReturn Result
EndProcedure

[Karl]

Dein Hex2Dez ließe sich auch so schreiben:

(Damit vermeidest du die merkwürdige For a .. Schleife)

Code: Alles auswählen

Procedure.l Hex2Dec(Wert.s)
  
  Protected temp.l, i.w
  
  
  For i = 1 To Len(Wert)
    Select UCase(Mid(Wert, i, 1))
      Case "A"
        temp + 10 * Pow(16,(Len(Wert)-i))
      Case "B"
        temp + 11 * Pow(16,(Len(Wert)-i))
      Case "C"
        temp + 12 * Pow(16,(Len(Wert)-i))
      Case "D"
        temp + 13 * Pow(16,(Len(Wert)-i))
      Case "E"
        temp + 14 * Pow(16,(Len(Wert)-i))
      Case "F"
        temp + 15 * Pow(16,(Len(Wert)-i))
      Default
        temp + Val(Mid(Wert,i,1)) * Pow(16,(Len(Wert)-i))
    EndSelect
  Next i
  
  ProcedureReturn temp
  
EndProcedure

Gruß Karl

[corrected]

[Jilocasin]

Da warst du irgendwie zu huddelisch!!!

Gucksdu:

Code: Alles auswählen

      Case "E"
        temp + 14 * Pow(16,(Len(Wert)-i))
      Case "F"
        temp + 14 * Pow(16,(Len(Wert)-i))

Muss heißen:

Code: Alles auswählen

      Case "E"
        temp + 14 * Pow(16,(Len(Wert)-i))
      Case "F"
        temp + 15 * Pow(16,(Len(Wert)-i))

Hab jetzt oben die neuste Version reingestellt

[Kaeru Gaman]

hm.. das ist wohl die lange aber schnelle version...

kurz gehts so:

Code: Alles auswählen

For i = 1 to Len(Wert)
   Q = Asc(UCase(Mid(Wert, i, 1))) - 48
   If Q > 9
      Q - 7
   EndIf
   temp + Q * Pow(16, Len(Wert)-i))
Next

wobei nur erlaubte zeichen drin sein dürfen, wenn andere dazwischen hängen, gibts falsche werte, keine fehlermeldung.
bei eurem wird ein falsches zeichen als 0 verrechnet.

außerdem könnte man Len(Wert) vor der schleife einmal ausrechnen,
und man könnte das langsame Pow durch ein LeftShift ersetzen...

[edit]

Code: Alles auswählen

L = Len(Wert)
For i = 1 to L
   Q = Asc(UCase(Mid(Wert, i, 1))) - 48
   If Q > 9
      Q - 7
   EndIf
   temp + (Q << 4*(L-i))
Next

das shift müsste so stimmen... glaub ich jedenfalls

[Jilocasin]

Wos Ferz!

Auf Deutsch:

"Das ist ja toll!"

[Kaeru Gaman]

nuja... bei dieser problemstellung ist das wohl zweitrangig, außer man will es als macro implementieren, was bei vielfacher anwendung der Select-methode den code wahnsinnig aufblähen würde.

aber ich finde es wichtig, sich mit dieser denkweise zumindest anzufreunden, weil es manchmal ungemein praktisch sein kann, etwas mit 3 formeln lösen zu können als hundertfuffzig Cases zu benutzen...

[HeX0R]

Code: Alles auswählen

Procedure Hex2Dec(Wert.s)
	Protected *a.BYTE, Result.l, k.l
	Wert = UCase(Wert)
	*a   = @Wert + Len(Wert) - 1
	k    = 1
	While *a\b
		If *a\b >= '0' And *a\b <= '9'
			Result + k * (*a\b - '0')
		ElseIf *a\b >= 'A' And *a\b <= 'F'
			Result + k * (*a\b - '7')
		Else
			Result = 0
			Break
		EndIf
		k << 4
		*a - 1
	Wend
	ProcedureReturn Result
EndProcedure

[Jilocasin]

Sooooo kompliziert muss das ja nu auch nich sein, oder?

[HeX0R]

Kompliziert ist es eigentlich nicht, aber es dürfte das schnellste sein.

[Kaeru Gaman]

sieht sehr gut aus... schick.