Zahl-Umrechnungen Bin, Oct, Dec, Hex

[Morlon]

Hi,
ich hab den Rechner bereits im Object-Pascal / Delphi-Language-Forum veröffentlicht und mit eurer Hilfe einige Dinge verbessert.
Das Programm kann Binär, Oktal, Dezimal und HexaDezimal hin und her rechnen wie man mag. Ich habs mit einigen Kommentaren versehen und die einzelnen Schritte, die dafür gemacht werden genau beschrieben.

Viel Spaß damit
Elmar

[DP-Maintenance]

Dieses Thema wurde von "Chakotay1308" von "Neuen Beitrag zur Code-Library hinzufügen" nach "Open-Source" verschoben.
Ist eher ein OpenSource-Programm, als ein Beitrag für die Code-Library.

[Neutral General]

Könntest du bitte auch direkt die exe mitliefern, weil ich z.B das Projekt mit Delphi 3 nicht öffnen kann :wink:

[arbu man]

Guck dir das mal an :coder:

Vieleich nützt es dir was is auch en ZahlenWandler von Dezimal auf alles

[Morlon]

WAAAHHH so einfach?? und dafür mach ich mir so nen stress? :?

aber danke dir für den quelltext, wirklich gut :)

Grüße

[KLS]

hmm, beide rechener haben probleme bei negativen zahlen :(

ansonsten sind die progs durchaus nutzbar :)

[MaBuSE]

Zitat:

Zitat von arbu man

Guck dir das mal an :coder:
Vieleich nützt es dir was is auch en ZahlenWandler von Dezimal auf alles

Hier kann man sich auch eine Lösung anschauen, die von allem nach allem umwandelt:
http://www.delphipraxis.net/internal...=289485#289485
(Weiter oben wird auch nochmal die Umwandlung in belibige Zahlensysteme erklärt)

In der Funktion x2y wandele ich erst die Quellbais nach dec (Basis 10) und danach in die Zielbasis.
Meine dec2alles macht fast das selbe wie Deine.
Du macht ein

Delphi-Quellcode:

Result := Zifferberechnung + Result;

ich mache ein

Delphi-Quellcode:

Result := Result + Zifferberechnung

Deine Methode ist etwas effizienter, da Du nicht erst die 1. Ziffer bestimmen musst und auch auf das Potenzieren verzichten kannst. ;-)
Aber viele Wegen führen nach Rom ;-)

Delphi-Quellcode:

  // Umrechnen dec nach BaseY 
  Result := ''; 
  // erste Ziffer bestimmen
  i := 0; 
  while Base10Zahl >= IntPower(BaseY, i) do 
  begin 
    inc(i); 
  end; 
  // die eigentliche Umwandlung
  while i>0 do 
  begin 
    Result := Result + Ziffern[Base10Zahl div Round(IntPower(BaseY, i-1))+1]; 
    Base10zahl := Base10Zahl mod Round(IntPower(BaseY, i-1)); 
    dec(i); 
  end;

[MaBuSE]

Zitat:

Zitat von KLS

hmm, beide rechener haben probleme bei negativen zahlen :(
ansonsten sind die progs durchaus nutzbar :)

Dann denk Dir doch einfach ein - vor die Zahl :mrgreen:

Code:

-5 (dec) = -1001 (bin)

Delphi-Quellcode:

if abs(QuellBasis) <> QuellBasis then begin Neg := True; QuellBasis := QuellBasis * -1; end;
ZielBasis := Umwandeln(QuellBais);
if Neg then ZielBasis := ZielBais * -1;

[thepaul]

bei binär is das nich so einfach. da muss dann das MSB (most significant bit) den wert 1 haben und die anderen entsprechend geändert weredn!

[MaBuSE]

Zitat:

Zitat von thepaul

bei binär is das nich so einfach. da muss dann das MSB (most significant bit) den wert 1 haben und die anderen entsprechend geändert weredn!

Das ist nicht ganz richtig.

Auch bei Binär kann man (in der Mathematik) mit dem "-" Zeichen arbeiten.

In der EDV werden die Binärzahlen aber in dem von Dir angegebenen Format abgelegt. Das hat aber nichts damit zu tun, das im Binärsystem kein Minus möglich ist, sondern es relativ einfach nach Deiner Methode zu handeln ist.

Im Dualsystem kann eine Subtraktion als eine Addition mit dem 2er Kompliment dargestellt werden.
Eine Negative Zahl wird deswegen in der EDV gerne als Zweierkompliment dargestellt.
Das funktioniert sehr gut, da man in der Regel genau weiß wie viel Bits eine Zahl groß werden darf.

Was machst Du wenn Du nicht weißt, wie viele Bits Dein Wert hat?
Sprich wir arbeiten mit Binärzahlen, die sagen wir mal bis zum Bereich 2^10.000.000 groß werden können.
Wenn Du nun den Wert -1 ablegen willst, kann man natürlich auch 10 Mio. Einsen davor schreiben :mrgreen:

Ich hatte irgendwann mal eine Funktionssammlung in TP6 die mit sehr großen Binärzahlen rechnen kann. dort wurde sich nur das Vorzeichen gemerkt. Beim Rechnen wurde dann das 2er Komplimentgebildet (Max(AnzBits(Zahl1), AnzBits(Zahl2))+1 und danach bei einer negativen Zahl wieder zurückgewandelt.
Das klappte sehr gut.

Anmerkung:
Kompliment ist das Negativ der Zahl: z.B. 00001001 -> 11110110
2er Kompliment ist das Kompliment der Zahl + 1 z.B. -> 00001001 -> 11110111

[KLS]

Es ist ja nicht so das ich nicht schon eine lsg. dafür habe, nur ist die nicht gerade die beste *g*

hier mal ein bsp. wie die negativen zahlen aufgebaut sind. (shortint (-128 - 127))

bin = dec

0000 0000 = 0
0000 0001 = 1
...
0111 1111 = 127

1111 1111 = -1
1111 1110 = -2
...
1000 0000 = -128

[MaBuSE]

Zitat:

Zitat von KLS

Es ist ja nicht so das ich nicht schon eine lsg. dafür habe, nur ist die nicht gerade die beste *g*

hier mal ein bsp. wie die negativen zahlen aufgebaut sind. (shortint (-128 - 127))

bin = dec

0000 0000 = 0
0000 0001 = 1
...
0111 1111 = 127

1111 1111 = -1
1111 1110 = -2
...
1000 0000 = -128

Das nennt sich 2er Kompliment

ich schrieb im obigen Beitrag

Anmerkung:
Kompliment ist das Negativ der Zahl: z.B. 00001001 -> 11110110
2er Kompliment ist das Kompliment der Zahl + 1 z.B. -> 00001001 -> 11110111

also
-1 = NOT(00000001)+1 = 11111111
-2 = NOT(00000010)+1 = 11111110
...

Dazu muß aber die Bitlänge bekannt sein. In Deinem Fall 8 Bit.

Was aber wenn Du eiene Variable bitlänge verwendest. z.B. ein paar Zahlen mit 12 Bits, dann ein paar mit 1.000 Bits, dann ein paar mit 100.000 Bits.

Um Dein Format zu verwenden müssten dann alle mit 100.000 Bit gespeichert werden.

z.B. -2 = -10 oder bei 8 Bit 11111110 oder bei 12 Bit 111111111110 oder bei 1.000 Bits 999 Einsen und eine Null.

Da macht es keinen Sinn.

Beim Hexadezimalsystem ist es doch das gleiche.

...
2 = 02
1 = 01
0 = 00
-1 = FF
-2 = FE
...

also
-0101 + 1110 = 1001

Es ist egal wie die Daten im Rechner abgelegt werden.
-05 + 0E = 09
Du schreibst ja auch nicht
FB + 0E = 09

Oder?

ps: der Rechner von MS Windows zeigt im wissenschaftlichen Modus bei negativen Zahlen das 2er Kompliment an, kann aber dann nicht wieder zurückwandeln:

-5 (dec) = 11111111111111111111111111111111111111111111111111 11111111111011 (bin)
aber
11111111111111111111111111111111111111111111111111 11111111111011 (bin) = 18446744073709551611 (dec)

Das ist doch nicht wirklich das was man will, oder?