hex, dezimal

hth · Beitrag von **hth** » 08.10.2004 23:13

x=255
x$=Hex(x) ;dezimal zu hexadezimal

Wie komme ich ohne größeren Aufwand in die Gegenrichtung?
Oder muss ich mir dafür wirklich eine eigene Funktion (Procedure) schreiben?

Ynnus · Beitrag von **Ynnus** » 09.10.2004 00:34

Speziell von PureBasic aus gibt es keinen Befehl der einen Hex-String wieder in eine Dezimalvariable wandelt. Also wenn du von "FF" (dem Hex-Wert) wieder auf 255 kommen willst, musst du dir da einen Algorithmus schreiben welcher dies umrechnet.

Ich hab dazu hier mal schnell eine Prozedur geschrieben:

Code: Alles auswählen

Procedure hex_2_dec(hex$)

  Protected decimal_wert
  decimal_wert = 0
  
  For z = 0 To Len(hex$) - 1
    hex_single$ = Mid(hex$, Len(hex$) - z, 1)
    Select hex_single$
      Case "0"
        decimal_wert = decimal_wert + (0 * Pow(16, z))
      Case "1"
        decimal_wert = decimal_wert + (1 * Pow(16, z))
      Case "2"
        decimal_wert = decimal_wert + (2 * Pow(16, z))
      Case "3"
        decimal_wert = decimal_wert + (3 * Pow(16, z))
      Case "4"
        decimal_wert = decimal_wert + (4 * Pow(16, z))
      Case "5"
        decimal_wert = decimal_wert + (5 * Pow(16, z))
      Case "6"
        decimal_wert = decimal_wert + (6 * Pow(16, z))
      Case "7"
        decimal_wert = decimal_wert + (7 * Pow(16, z))
      Case "8"
        decimal_wert = decimal_wert + (8 * Pow(16, z))
      Case "9"
        decimal_wert = decimal_wert + (9 * Pow(16, z))
      Case "A"
        decimal_wert = decimal_wert + (10 * Pow(16, z))
      Case "B"
        decimal_wert = decimal_wert + (11 * Pow(16, z))
      Case "C"
        decimal_wert = decimal_wert + (12 * Pow(16, z))
      Case "D"
        decimal_wert = decimal_wert + (13 * Pow(16, z))
      Case "E"
        decimal_wert = decimal_wert + (14 * Pow(16, z))      
      Case "F"
        decimal_wert = decimal_wert + (15 * Pow(16, z))
    EndSelect
  Next z

  ProcedureReturn decimal_wert
EndProcedure

Debug hex_2_dec("FF")

Jetzt kannst du einen beliebig langen Hex-String eingeben und erhälst dazu den Dezimalwert. Ich habs jetzt explizit mit 2-Stellen getestet, sollte aber auch mit 3, 4, 5, oder mehr Stellen gehen.

Dabei arbeitet die Prozedur so, dass sie von rechts nach links die Stellen abliest und sie den Dezimalwerten zuordnet und ausrechnet. Ganz rechts angefangen würde das bei "F" also 15 * 16^0 = 15 sein.
Diesen Wert + den nächsten, nämlich 15 * 16^1 = 240 + 15 = 255 = "FF"
Wie du ja sicher weißt beginnt man da rechts und bei dem Exponenten 0 und arbeitet sich Stellenweise nach links vor, jeweils um 1 erhöhen. Meine Prozedur arbeitet dabei dynamisch, egal wie viele Stellen man hat, mittels For-Schleife und geht somit alle Stellen ab.
Jetzt könnte man vielleicht noch eine Fehlerroutine-Prüfung einbauen die erstmal abfragt, ob der eingegebene String wirklich ein Hex-Wert ist. Aber davon geh ich mal aus, dass du es dafür nutzt. Kannst du ja noch erweitern.

hth · Beitrag von **hth** » 09.10.2004 01:44

Danke für deine Antwort,

ich hatte auch schon so was ähnliches. Dachte aber, dass es doch noch
eine versteckte spezielle Funktion gibt.

Code: Alles auswählen

Procedure.l hex_dec(x$)
  
  x$=UCase(x$)
  l=Len(x$)
  
  For i=1 To l
        
      h1$=Mid(x$,i,1)      
      h1=Val(h1$)
            
      Select h1$      
          Case "A"
              h1=10
          Case "B"
              h1=11
          Case "C"
              h1=12
          Case "D"
              h1=13
          Case "E"
              h1=14
          Case "F"
              h1=15     
      EndSelect      
      
      h1=h1*Pow(16,l-i)      
                    
      x=x+h1      
   
   Next i

  ProcedureReturn x
EndProcedure


Debug hex_dec("FF")

Danilo · Beitrag von **Danilo** » 09.10.2004 06:43

Hier mal noch ein paar andere (kleine) Versionen:

Code: Alles auswählen

; Autor: ?
; Datum: ?
; Forum: ?
Procedure.l hex2dec(h$)
  h$=UCase(h$)
  For r=1 To Len(h$)
    d<<4 : a$=Mid(h$,r,1)
    If Asc(a$)>60
      d+Asc(a$)-55
    Else
      d+Asc(a$)-48
    EndIf
  Next
  ProcedureReturn d
EndProcedure
;
Debug hex2dec("FF")
Debug hex2dec("FFFF")
Debug hex2dec("FFFFFF")
Debug StrU(hex2dec("FFFFFFFF"),#LONG)

Oder mit Pointer:

Code: Alles auswählen

;
; by Danilo, 15.01.2004 - german chat (for Suco-X)
;
; 22.07.2004  -  changed to pointers by Danilo
;
Procedure Hex2Dec(String$)
  *String.BYTE = @String$
  If *String
    If *String\b = '$'   : *String + 1 : EndIf
    
    num = *String\b
    While num
      result << 4
      If     num >= '0' And num <= '9'  ; 0 - 9
        result + num - '0'
      ElseIf num >= 'A' And num <= 'F'  ; A - F
        result + num - 55 ; 'A' + 10
      ElseIf num >= 'a' And num <= 'f'  ; a - f
        result + num - 87 ; 'a' + 10
      Else
        ProcedureReturn 0               ; Error: not 0-9,A-F,a-f
      EndIf
      *String+1
      num = *String\b
    Wend
  EndIf
  ProcedureReturn result
EndProcedure

Debug Hex2Dec("")
Debug Hex2Dec("$c")
Debug Hex2Dec("$FA")
Debug Hex2Dec("$FFFF")
Debug Hex2Dec("$7FFFFFFF")
Debug Hex2Dec("$FFFFFFFF")
Debug StrU(Hex2Dec("$FFFFFFFF"),#LONG)

Und hier gleich noch ein paar andere Prozeduren von
F. Weil hinterher:

Code: Alles auswählen

;It's a bit long but may it help some of us ...
;
;I tested as much as possible To have good performances And bugless results.
;
;I suppose it exist a better solution using assembly but I do Not have so much time To find ...
;
;**************************************
Dim Dec2BaseDigit.s(16)

Dec2BaseDigit(0) = "0"
Dec2BaseDigit(1) = "1"
Dec2BaseDigit(2) = "2"
Dec2BaseDigit(3) = "3"
Dec2BaseDigit(4) = "4"
Dec2BaseDigit(5) = "5"
Dec2BaseDigit(6) = "6"
Dec2BaseDigit(7) = "7"
Dec2BaseDigit(8) = "8"
Dec2BaseDigit(9) = "9"
Dec2BaseDigit(10) = "A"
Dec2BaseDigit(11) = "B"
Dec2BaseDigit(12) = "C"
Dec2BaseDigit(13) = "D"
Dec2BaseDigit(14) = "E"
Dec2BaseDigit(15) = "F"

Global Dec2BaseDigit

Procedure.s Dec2Base(n.l, Base.l)
  RB.l
  Out.s = ""
  Select Base
    Case 16
      Out = Hex(n)
    Default
      Result.l = n
      Res.l = 0
      While Result > 0
        RB = Result / Base
        Res = Base * RB
        Out = Dec2BaseDigit(Result - Res) + Out
        Result = RB
      Wend
      If Out = ""
          Out = "0"
      EndIf
  EndSelect
  ProcedureReturn Out
EndProcedure

Procedure.s Dec2Hex(n.l)
  Res.l
  R16.l
  Result.l = n
  Out.s = ""
  While Result > 0
    R16 = Result >> 4
    Res = R16 << 4
    Out = Dec2BaseDigit(Result - Res) + Out
    Result = R16
  Wend
  If Out = ""
      Out = "0"
  EndIf
  ProcedureReturn Out
EndProcedure

Procedure.s Dec2Oct(n.l)
  Res.l
  R8.l
  Result.l = n
  Out.s = ""
  While Result > 0
    R8 = Result >> 3
    Res = R8 << 3
    Out = Dec2BaseDigit(Result - Res) + Out
    Result = R8
  Wend
  If Out = ""
      Out = "0"
  EndIf
  ProcedureReturn Out
EndProcedure

Procedure.s Dec2Bin(n.l)
  Res.l
  R2.l
  Result.l = n
  Out.s = ""
  While Result > 0
    R2 = Result >> 1
    Res = 2 * R2
    Out = Dec2BaseDigit(Result - Res) + Out
    Result = R2
  Wend
  If Out = ""
      Out = "0"
  EndIf
  ProcedureReturn Out
EndProcedure

Procedure Bin2Dec(n.s)
Result.l
  For i = 1 To Len(n)
    Result = 2 * Result + Val(Mid(n, i, 1))
  Next
  ProcedureReturn Result
EndProcedure

Procedure Oct2Dec(n.s)
Result.l
  For i = 1 To Len(n)
    Result = 8 * Result + Val(Mid(n, i, 1))
  Next
  ProcedureReturn Result
EndProcedure

Procedure Hex2Dec(n.s)
Result.l
Digit.l
  For i = 1 To Len(n)
    Select Mid(n, i, 1)
      Case "A"
        Digit = 10
      Case "B"
        Digit = 11
      Case "C"
        Digit = 12
      Case "D"
        Digit = 13
      Case "E"
        Digit = 14
      Case "F"
        Digit = 15
      Default
        Digit = Val(Mid(n, i, 1))
    EndSelect
    Result = 16 * Result + Digit
  Next
  ProcedureReturn Result
EndProcedure

;
; Main starts here for testing
;  

DecConst.l
BinConst.s
OctConst.s
HexConst.s

OpenConsole()

DecConst = 16434824
BinConst = "111110101100011010001000"
OctConst = "76543210"
HexConst = "FAC688"

PrintN("Dec2Base(n,2)   : Dec2Base(" + Str(DecConst) + ",2) =" + Dec2Base(DecConst, 2))
PrintN("Dec2Bin(n)      : Dec2Bin(" + Str(DecConst) + ")    =" + Dec2Bin(DecConst))
PrintN("Dec2Base(n,8)   : Dec2Base(" + Str(DecConst) + ",8) =" + Dec2Base(DecConst, 8))
PrintN("Dec2Oct(n)      : Dec2Oct(" + Str(DecConst) + ")    =" + Dec2Oct(DecConst))
PrintN("Dec2Base(n,16)  : Dec2Base(" + Str(DecConst) + ",16)=" + Dec2Base(DecConst, 16))
PrintN("Dec2Hex(n)      : Dec2Hex(" + Str(DecConst) + ")    =" + Dec2Hex(DecConst))
PrintN("Hex(n)          : Hex(" + Str(DecConst) + ")        =" + Hex(DecConst))
PrintN("Bin2Dec(n)      : Bin2Dec(" + BinConst + ")         =" + Str(Bin2Dec(BinConst)))
PrintN("Oct2Dec(n)      : Oct2Dec(" + OctConst + ")         =" + Str(Oct2Dec(OctConst)))
PrintN("Hex2Dec(n)      : Hex2Dec(" + HexConst + ")         =" + Str(Hex2Dec(HexConst)))

;
; and for fun ...
;

PrintN(Str(Hex2Dec(Dec2Hex(123456789))))
PrintN(Str(Oct2Dec(Dec2Oct(123456789))))
PrintN(Str(Bin2Dec(Dec2Bin(123456789))))

While Inkey() = ""
Wend

CloseConsole()

End
;**************************************

;Francois Weil
;14, rue Douer
;F64100 Bayonne

Sollte Fred vielleicht wirklich mal direkt einbauen, falls er mal
ein paar Minuten Zeit hat... ist auf jeden Fall nützlich und wird
von vielen Leuten gebraucht - so wie Asc, Val und ValF.

Andre · Beitrag von **Andre** » 09.10.2004 14:58

Sollte Fred vielleicht wirklich mal direkt einbauen, falls er mal
ein paar Minuten Zeit hat... ist auf jeden Fall nützlich und wird
von vielen Leuten gebraucht - so wie Asc, Val und ValF.

Habe daher diesen Wunsch auch mitsamt Beispielen an Fred weitergeleitet.

hth · Beitrag von **hth** » 09.10.2004 17:49

Code: Alles auswählen

Procedure.l hex_dec(x$)

  x$=lCase(x$)
  l=Len(x$)
  
  For i=1 To l
        
      h1$=Mid(x$,i,1)  
          
      n=FindString("0123456789abcdef",h1$,1)           
                    
      x=x+(n-1)*Pow(16,l-i)      
   
  Next i

  ProcedureReturn x
EndProcedure


Debug hex_dec("FF")

Sylvia · Beitrag von **Sylvia** » 09.10.2004 23:18

Na, dann will ich mal noch meinen Senf dazugeben...

Code: Alles auswählen

; **********************************
; * 09.Oct.2004 "Sylvia" GermanForum
; **********************************

Procedure Dec(NoDec$)
     ; wandelt einen Hex$ / Bin$ um in einen Dezimalwert.
     ; Die Umwandlung erfolgt bis zum ersten ungültigen Zeichen
     ; "Overflow" wird nicht überprüft (unkritisch)
          
     ; NoDec$ = 1.Zeichen ->$ Wert wird als Hexzahl behandelt
     ;                    ->% Wert wird als Binärzahl behandelt
  
     Protected Result,x,Char
  
     If   PeekB(@NoDec$)='$'    ;Hex -> Dec
               
          NoDec$=UCase(NoDec$)

          x=1: Char=PeekB(@NoDec$+x)
          While Char
               Result << 4
               If     Char='0'
               ElseIf Char='1': Result+ 1
               ElseIf Char='2': Result+ 2
               ElseIf Char='3': Result+ 3
               ElseIf Char='4': Result+ 4
               ElseIf Char='5': Result+ 5
               ElseIf Char='6': Result+ 6
               ElseIf Char='7': Result+ 7
               ElseIf Char='8': Result+ 8
               ElseIf Char='9': Result+ 9
               ElseIf Char='A': Result+10
               ElseIf Char='B': Result+11
               ElseIf Char='C': Result+12
               ElseIf Char='D': Result+13
               ElseIf Char='E': Result+14
               ElseIf Char='F': Result+15
               Else:  ProcedureReturn Result >> 4
               EndIf
          
               x+1: Char=PeekB(@NoDec$+x)
          Wend
               
     ElseIf PeekB(@NoDec$)='%'     ; Bin -> Dec
     
          x=1: Char=PeekB(@NoDec$+x)
          While Char
               Result << 1
               If     Char='0'
               ElseIf Char='1': Result+1
               Else:  ProcedureReturn Result >> 1
               EndIf
                  
               x+1: Char=PeekB(@NoDec$+x)
          Wend

     EndIf
  
     ProcedureReturn Result 
EndProcedure 


Debug dec("$ff")                  ; =255
Debug dec("$7F FF 00")            ; =127 Space is no valid
Debug dec("%1010")                ; = 10
Debug dec("%111F")                ; =  7 'F' is no valid in Binary
Debug dec("$FFCDAFBCDF53A31C90")  ; ok,ok,ok...no problem, cut by 53A31C90 :D

Beitrag von **NicTheQuick** » 31.03.2005 18:50

Hier noch eine schnelle Bin2Dec-Procedure, die nur funktioniert, wenn wirklich nur "0"en und "1"en im String stehen. Sonst schlägt sie fehl.

Code: Alles auswählen

Binaer.s = InputRequester("Binär -> Dezimal", "Geben sie eine Binärzahl ein.", "")

Dezimal = 0
*z.BYTE = @Binaer

While *z\b
  a = *z\b - 48
  
  Dezimal << 1
  Dezimal + a
  
  *z + 1
Wend

MessageRequester("Binär -> Dezimal", "Binärzahl: " + Binaer + #CRLF$ + "Dezimalzahl:" + Str(Dezimal))

Kaeru Gaman · Beitrag von **Kaeru Gaman** » 31.03.2005 22:21

ich würde mir mega-booleans wünschen:

Code: Alles auswählen

i=asc(a$)
a=(48<=i<=57)*(i-48)+(65<=i<=70)*(i-55)

wer verstehts?

geht auch mit einfachen booleans:

Code: Alles auswählen

i=asc(a$)
a=((i>=48)and(i<=57))*(i-48)+((i>=65)and(i<=70))*(i-55)

Heroglyph · Beitrag von **Heroglyph** » 01.04.2005 11:27

Kanns mir nicht verkneifen

.

Code: Alles auswählen

Procedure Hex2Dec(N.s)
  For i = 1 To Len(N)
    d = (d << 4) + Asc(UCase(Mid(N,i,1)))-48 - 7 * (Asc(UCase(Mid(N,i,1)))>>6)
  Next
  ProcedureReturn d
EndProcedure


Debug Hex2Dec("FF")
Debug Hex2Dec("F1")
Debug Hex2Dec("CAFEBABE")
Debug Hex2Dec("10000")
Debug Hex2Dec(Hex(-4))

PureBoard

hex, dezimal

hex, dezimal

hex_dec

Noch eine Lösung, die mir im Traum eingefallen ist.