Zahlen & Ganzzahlbasen

Dezimale, gruppierte, wissenschaftliche und kompakte Literale, Schnelloperatoren und exakte Ganzzahlbasen (Hex, Binär, Oktal).

Numlex akzeptiert Zahlen so, wie Menschen sie schreiben — gruppierte Tausender, wissenschaftliche Notation, kompakte Suffixe wie 1.5M — und ebenso die exakten Ganzzahlformen 0x, 0b und 0o.

Diese Seite dokumentiert die literalen Formen selbst, die wissenswerten Kompaktsuffix-Mehrdeutigkeiten (5m sind fünf Millionen, nicht fünf Meter), die optionalen Schnelloperatoren, Ganzzahlbasen mit ihren Anzeige- und Überlaufregeln und die Beispiele.

Dezimale Literale

Das Dezimaltrennzeichen ist . oder , je nach regionalem Format — siehe Zahlenformate & Ergebnisanzeige.
Tausendertrennzeichen in der Eingabe werden normalisiert: 1,234 → 1234, 1 234 (formatabhängig). Innerhalb von Funktionsaufrufen kann ein Komma stattdessen Argumente trennen — siehe Integrierte Funktionen.
Wissenschaftliche Notation: 1.5e6, 2E-3.
Leerzeichen um Operatoren sind beliebig; Klammern ( ) gruppieren; unäre + und - sind erlaubt.

Kompakte Suffixe

Kompakte Suffixe stehen unmittelbar nach der Zahl, ohne Leerzeichen, und gelten für Skalare und Geldsummen:

Suffix	Faktor	Beispiele
`k` / `K`	×10³	`1.5k` = 1.500; `$2.5k` = $2.500
`m` / `M`	×10⁶	`1.5M` = 1.500.000; `$2.5M` = $2.500.000

Zwei Dinge, die man kennen sollte:

5m sind 5.000.000 — nicht fünf Meter. Ein Meter braucht ein Leerzeichen: 5 m.
G, T und P sind keine Skalar- oder Geldsuffixe. 1.5G streicht das G als unbekanntes Wort und liefert 1.5. Giga und Tera existieren nur als Katalog-Einheitennamen mit Leerzeichen: 2 Gm, 2 Gb, 2 Gbyte.

Schnelloperatoren (Einstellung)

Mit aktivierter Einstellung Quick operators wirken vier Buchstaben als Operatoren nur zwischen zwei Ziffern — nie innerhalb von Bezeichnern:

Buchstabe	Operator
`p`	`+`
`m`	`−`
`x`	`×`
`d`	`÷`

Das Literal 0x… wird nie zu einer Multiplikation.

Ganzzahlbasen (exakt)

Basisliterale nutzen ein strenges Präfix; die Groß-/Kleinschreibung des Präfixes spielt keine Rolle (0X, 0B, 0O funktionieren):

Präfix	Basis	Ziffern
`0x`	16	`0-9 A-F`
`0b`	2	`0 1`
`0o`	8	`0-7`

Regeln:

Unterstriche nur zwischen zwei Ziffern: 0x1_0, 100_000. Doppelte Unterstriche, Unterstriche an den Rändern oder direkt nach dem Präfix sind Fehler (0x_1F, 0x1F_).
Vorzeichen-Betrag: -0x10 = −16. Der Betrag des Literals ist in jeder Basis auf 0x7FFFFFFFFFFFFFFF (9223372036854775807) begrenzt: -0x7FFFFFFFFFFFFFFF wird akzeptiert, während -0x8000000000000000 und 0x8000000000000000 das exakte Maximum überschreiten und Fehler sind. Ziffernüberlauf (0x10000000000000000) ist ebenfalls ein Fehler.
Anzeige: Nicht negative Ergebnisse werden in der Basis des Ausdrucks angezeigt (0x1F + 1 → 0x20). Negative Ergebnisse und Operationen außerhalb der exakten Ganzzahlen (Division mit Rest, ^ mit negativem Exponenten) werden dezimal angezeigt (-0x10 → −16).
Gewöhnliche Dezimalziffernketten sind keine exakten Ganzzahlen. 9223372036854775808 wird zu 9.22e18. Die exakte Behandlung gilt nur für Basisliterale, die Funktionen int/bin/oct/hex und die Phrasen as / in / to base.

Basisnamen und Phrasen

Basisnamen sind schreibunabhängig:

Name	Basis
`decimal`, `base10`	10
`binary`, `base2`	2
`octal`, `base8`	8
`hex`, `hexadecimal`, `base16`	16
`base 2` / `base 8` / `base 10` / `base 16` (durch Leerzeichen getrennte Ganzzahl)	2 / 8 / 10 / 16

<expr> as <base name>          255 as hex            → 0xFF
<expr> in <base name>          99 in binary          → 0b1100011
<expr> to base 8               64 to base 8          → 0o100

Bit-Operationen

Der exakte Ganzzahlmodus wird durch 0x/0b/0o-Literale, die Aufrufe int(/bin(/oct(/hex(, die Phrasen … as|in <base> und … to base N sowie die Bit-Glyphen & | << >> oder das Wort xor aktiviert (Glyphen zählen nur, wenn die Zeile mathematischen Inhalt hat — fish & chips bleibt Prosa). Die Wörter and/or wirken nur dann bitweise, wenn beide Seiten Ganzzahlen sind.

Operation	Bedeutung	Hinweise
`&`	bitweises UND
`\|`	bitweises ODER	die Glyphe ist immer bitweise: boolesche Operanden sind ein Fehler (`false \| (1/0 > 0)`)
`xor`	bitweises XOR (Wort)	`6 xor 3` = 5
`<<`	Linksverschiebung	Verschiebung 0…63; Überlauf ist ein Fehler
`>>`	Rechtsverschiebung	Verschiebung 0…63; arithmetisch für negative Werte
`/`	Ganzzahldivision	das Ergebnis ist eine Dezimalzahl, wenn ein Rest bleibt
`%`	Rest
`^`	Potenz	Exponent wird geprüft; ein negativer Exponent erzeugt eine Dezimalzahl

Alle Werte hier sind exakte Ganzzahlen: 0x7FFFFFFFFFFFFFFF = 9223372036854775807, und Überlauf ist ein sichtbarer Fehler — nie Wraparound, nie eine still gerundete Zahl. Die Wörter and/or/xor sind kontextuell: Zwei Ganzzahlen machen sie bitweise, zwei boolesche Werte machen and/or logisch, und das Mischen von Typen in einem Operator ist ein strenger Fehler. Verwende an Grenzen ausdrückliche Klammern.

Die vollständige Operatorrangfolge steht unter Operatoren & Logik.

Geprüfte Beispiele

0x1F + 1              → 0x20
0x1F in decimal       → 31
0b101101 + 1          → 0b101110
0o55 + 1              → 0o56
0x1_0                 → 0x10
100_000 as hex        → 0x186A0
256 as hex            → 0x100
16 in binary          → 0b10000
-0x10                 → -16
1 << 4                → 16
32 >> 2               → 8
0xFF & 0x0F           → 0x0F
5 | 2                 → 7
6 xor 3               → 5
5 << 3                → 40
(5 << 3) / 2          → 20

x = 0x1F
x & 1                 → 1
x + 1                 → 0x20
x as hex              → 0x1F

Die letzten vier Zeilen laufen in einem Blatt, x wird einmal deklariert.

Verwandt

Operatoren & Logik — Rangfolge und die vollständigen Tabellen für exakte Ganzzahlen.
Integrierte Funktionen — int, bin, oct, hex und die anderen 19.
Antwort-Tokens — wie die Basisdarstellung ein Token übersteht.