Diese Seite funktioniert am besten mit aktiviertem JavaScript!

Beschreibung: Zahlensysteme umwandeln

Konverter Zahlensysteme umwandeln

Mit diesem Konverter kannst du eine Zahl von einem beliebigen polyadischen Zahlensystem (Basis von 2 bis 36) in ein anderes polyadisches Zahlensystem umwandeln und dir dabei den Rechenweg anzeigen lassen. Was genau Zahlensysteme sind und wie die Umwandlung funktioniert, das erfährst du hier.


Anzeige
Klick-Tipp Mentorship Programm

Kurze Beschreibung

Mit diesem Konverter können Zahlen von einem Zahlensystem (mit Basis von 2 bis 36) in ein anderes polyadisches Zahlensystem umgewandelt werden.

Was genau sind Zahlensysteme und wie sind diese aufgebaut?

Vermutlich hat schon jeder einmal die Begriffe Dualsystem oder Dezimalsystem gehört. Doch was genau sich wirklich hinter den Zahlensystemen verbirgt, haben wahrscheinlich nur die wenigsten wirklich verstanden. Grundsätzlich werden Zahlensysteme schlichtweg zum Darstellen von Zahlen verwendet. An dieser Stelle beschränken wir uns konkret auf sogenannte polyadische Zahlensysteme, welche auch Stellenwertsysteme genannt werden. Bei diesen Zahlensystemen hängt die Wertigkeit eines Symbols von seiner Position ab. Polyadische Zahlensystem sind im Prinzip wie folgt aufgebaut:

$$Z=a_n\cdot b^n+a_{n-1}\cdot b^{n-1}+...+a_1\cdot b^1+a_0\cdot b^0+a_{-1}\cdot b^{-1}+a_{-2}\cdot b^{-2}+...+a_{-m}\cdot b^{-m}$$ \(Z\text{: Zahl, }a_i\text{: Ziffer, }b\text{: Basis}\)
Z = an * bn + an-1 * bn-1 + ... + a1 * b1 + a0 * b0 + a-1 * b-1 + a-2 * b-2 + ... + a-m * b-m
Z: Zahl, ai: Ziffer, b: Basis

Um das einmal besser zu verstehen, wird dies nachfolgend anhand des Dezimalsystems veranschaulicht, welches wir tagtäglich verwenden. Das Dezimalsystem heißt so, weil das Wort Dezi für den Wert 10 steht, es handelt sich also um das 10er-System. Die obige Formel sieht somit wie folgt aus:

$$Z=a_n\cdot 10^n+a_{n-1}\cdot 10^{n-1}+...+a_1\cdot 10^1+a_0\cdot 10^0+a_{-1}\cdot 10^{-1}+a_{-2}\cdot 10^{-2}+...+a_{-m}\cdot 10^{-m}$$
Z = an * 10n + an-1 * 10n-1 + ... + a1 * 101 + a0 * 100 + a-1 * 10-1 + a-2 * 10-2 + ... + a-m * 10-m

an\(a_n\) ist die erste Ziffer, an-1\(a_{n-1}\) ist die zweite und a0\(a_0\) stellt die letzte Ziffer vor dem Komma dar. a-1\(a_{-1}\) ist hingegen die erste Ziffer nach dem Komma, a-2\(a_{-2}\) die zweite usw.

Nehmen wir einmal an, wir haben eine Zahl mit drei Ziffern vor dem Komma (n = 2\(n=2\)) und zwei Ziffern nach dem Komma (m = 2\(m=2\)), z.B. die Zahl 123,45. Dann gilt:

$$\text{123,45}_{10}=\text{ }1\cdot 10^{2}+2\cdot 10^1+3\cdot 10^0+4\cdot 10^{-1}+5\cdot 10^{-2}$$
123,4510 = 1 * 102 + 2 * 101 + 3 * 100 + 4 * 10-1 + 5 * 10-2

Analog kann das auch auf jedes Zahlensystem mit einer anderen Basis angewendet werden, wie wir im nachfolgenden Kapitel sehen werden.

Umwandlung der Zahlensysteme

Bei der Umwandlung von verschiedenen Zahlensystemen ineinander spielt das Dezimalsystem eine Schlüsselrolle, da die Umrechnung stets hierüber erfolgt.

Umwandlung in das Dezimalsystem

Wenn wir die Zahl eines beliebigen Zahlensystems in das Dezimalsystem umrechnen wollen, dann müssen wir im Prinzip nur die oben bereits gezeigte Formel anwenden. Nehmen wir beispielsweise an, dass die Zahl 123,45 nicht im 10er-System, sondern im 8er-System vorliegt, dann sieht die Rechnung wie folgt aus:

$$\text{123,45}_{8} = 1\cdot 8^{2}+2\cdot 8^1+3\cdot 8^0+4\cdot 8^{-1}+5\cdot 8^{-2}\approx\text{ 83,58}_{10}$$
123,458 = 1 * 82 + 2 * 81 + 3 * 80 + 4 * 8-1 + 5 * 8-2 = 83,5810

Der dahinterliegende PHP-Code berechnet dies aus numerischen Gründen allerdings etwas anders. Außerdem erfolgt die Berechnung für den ganzzahligen Anteil und die Nachkommastellen separat:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Dieser Code muss zweimal aufgerufen werden: einmal für den Teil vor dem Komma und einmal für den Teil nach dem Komma
$ergebnis = "0";
$laenge = strlen(ZAHL); // Diese Zahl muss als String vorliegen

for ($i = 0; $i < $laenge; $i++)
{
   $ziffer = substr(ZAHL, $i, 1);
   if (!preg_match("#^[0-9]+$#iu", $ziffer))
   {
      $ziffer = (string) (ord($ziffer) - 55); // Buchstabe in Zahlenwert umwandeln
   }
   $ergebnis = bcadd(bcmul($ergebnis, (string) BASIS, 0), $ziffer, 0); // Horner-Schema
 }

// Der nachfolgende Code ist nur dann noch zusätzlich anzuwenden, wenn es sich um die Nachkommastellen-Berechnung handelt
$ergebnis = bcdiv($ergebnis, bcpow((string) BASIS, $laenge, 0), FESTGELEGTE_GENAUIGKEIT);
$ergebnis = explode(".", $ergebnis);
$ergebnis = $ergebnis[1];

Umwandlung vom Dezimalsystem in andere Basis

Für die Umwandlung einer Zahl vom Dezimalsystem in ein Zahlensystem mit anderer Basis müssen wir den ganzzahligen Anteil und die Nachkommastellen getrennt betrachten. Zur genaueren Erläuterung der nachfolgenden Berechnungsvorschriften wandeln wir die Zahl 73,42 mit Basis 10 in das 5er-System um.

Für den ganzzahligen Anteil gehen wir nach folgendem System vor:
  1. Dividiere die Zahl mit Rest durch die Basis.
  2. Der Rest stellt die Ziffer dar, angefangen von rechts nach links. Der erste erhaltene Rest-Wert ist somit die niederwertigste Ziffer und der letzte erhalten Rest-Wert stellt die höchstwertige Ziffer dar.
  3. Der ganzzahlige Quotient ist Ausgangspunkt für die weitere Berechnung. Falls der Quotient = 0 ist, dann bist du fertig. Andernfalls springe zu Punkt 1 und wiederhole das Ganze.

Konkret für unser Beispiel bedeutet das:

$$ \begin{equation*} \begin{split} 73\text{ : }&5=14&\text{ }\Rightarrow\text{ Rest: }3\\ 14\text{ : }&5=2&\text{ }\Rightarrow\text{ Rest: }4\\ 2\text{ : }&5=0&\text{ }\Rightarrow\text{ Rest: }2\\ \end{split} \end{equation*} $$ $$\Rightarrow\text{ Ergebnis: }243$$
73 : 5 = 14 -
14 : 5 = 2 -
2 : 5 = 0 -

-

In PHP wird das wie folgt berechnet:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$ergebnis = "";
$quotient = ZAHL;

do
{
   $rest = (int) bcmod($quotient, (string) BASIS);
   if ($rest > 9)
   {
      $rest = chr($rest + 55); // In Buchstabe umwandeln
   }
   $ergebnis = $rest.$ergebnis;
   $quotient = bcdiv($quotient, (string) BASIS, 0);
}
while ($quotient != "0");
Für die Nachkommastellen wenden wir hingegen das nachfolgende System an:
  1. Multipliziere die Zahl mit der Basis.
  2. Die Zahl vor dem Komma stellt die gewünschte Ziffer dar, angefangen von links nach rechts.
  3. Der Teil hinter dem Komma ist Ausgangspunkt für die weitere Berechnung. Falls dieser = 0 ist, dann bist du fertig. Andernfalls springe zu Punkt 1 und wiederhole das Ganze.

Bei unserem Beispiel erhalten wir somit:

$$ \begin{equation*} \begin{split} \text{0,42 }\cdot\text{ }&5=\text{2,1}&\text{ }\Rightarrow\text{ }2\\ \text{0,1 }\cdot\text{ }&5=\text{0,5}&\text{ }\Rightarrow\text{ }0\\ \text{0,5 }\cdot\text{ }&5=\text{2,5}&\text{ }\Rightarrow\text{ }2\\ \text{0,5 }\cdot\text{ }&5=\text{2,5}&\text{ }\Rightarrow\text{ }2 \end{split} \end{equation*} $$ $$\Rightarrow\text{ Ergebnis: 0,20222222...}$$
0,42 * 5 = 2,1 -
0,1 * 5 = 0,5 -
0,5 * 5 = 2,5 -
0,5 * 5 = 2,5 -

-

Der PHP-Code dazu ist etwas umfangreicher, da man aufgrund der begrenzten Rechengenauigkeit noch einen Spezialfall abdecken muss:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
$ergebnis = "";
$temp = "0.".ZAHL;
$max_fehler = "1";
$i = 0;

do
{
   $produkt = bcmul($temp, (string) BASIS, FESTGELEGTE_GENAUIGKEIT);
   $max_fehler = bcadd($max_fehler, bcpow((string) BASIS, (string) ($i + 1), 0), 0);
   $explode = explode(".", $produkt);
   $ganzzahl = $explode[0];

   // Dieser if-Block deckt den Sonderfall für eine periodische 9 ab, welche aufgrund der begrenzten Genauigkeit entstanden sein könnte
   if (count($explode) == 2)
   {
      $anzahl_ungueltige_ziffern = strlen($max_fehler);
      $anzahl_gueltige_ziffern = strlen($explode[1]) - $anzahl_ungueltige_ziffern;
      $gueltige_ziffern = substr($explode[1], 0, $anzahl_gueltige_ziffern);

      if (preg_match('#^9+$#iu', $gueltige_ziffern))
      {
         $ganzzahl = bcadd($explode[0], "1", 0);
         $produkt = $ganzzahl;
      }
   }
   $temp = bcsub($produkt, $ganzzahl, FESTGELEGTE_GENAUIGKEIT);
   if (((int) $ganzzahl) > 9)
   {
      $ganzzahl = chr($ganzzahl + 55); // In Buchstabe umwandeln
   }
   $ergebnis .= $ganzzahl;
   $i++;
}
while (!preg_match('#^0.0+$#iu', $temp) && ($i < ANZAHL_DER_NACHKOMMASTELLEN));

Insgesamt lautet die Umrechnung somit:

$$\text{73,42}_{10}=\text{243,20222...}_5$$
73,4210 = 243,20222...5

Fazit

Wir haben nun gelernt, wie genau polyadische Zahlensysteme aufgebaut sind und wie man generell unterschiedliche Zahlensysteme ineinander umrechnen kann. Außerdem haben wir hiermit auch einen konkreten Einblick in den Alogorithmus des hier beschriebenen Konverters erlangt.

ZUM ZAHLENSYSTEM KONVERTER
Teile diese Seite
Erstellt am 03.06.2021 | Zuletzt geändert am 04.06.2021