PBXB64 Datentypen

Erweiterte Datentypen Eingeführt in V15

PBXB64 V18 behält die in V15 eingeführte vollständige verwaltete UN-Familie neben Standard-PowerBASIC-Typen und spezialisierten Zahlen-, COM-, String- und Wide-Integer-Erweiterungen bei: UNL, UNF, UNB, UNC, UNI und UNQ.

Vollständige Typ-Referenz

Typ	Größe	Beschreibung	Status
`BYTE`	8-Bit	Vorzeichenlose Ganzzahl (0-255)	Standard
`WORD`	16-Bit	Vorzeichenlose Ganzzahl (0-65535)	Standard
`INTEGER`	16-Bit	Vorzeichenbehaftete Ganzzahl (-32768 bis 32767)	Standard
`LONG`	64-Bit	Vorzeichenbehaftete Ganzzahl (PBXB64-Standard ist 64-Bit)	Standard
`DWORD`	32-Bit	Vorzeichenlose Ganzzahl	Standard
`QUAD`	64-Bit	Vorzeichenbehaftete Ganzzahl (Alias)	Standard
`SINGLE`	32-Bit	IEEE-754 Float	Standard
`DOUBLE`	64-Bit	IEEE-754 Double	Standard
`EXTENDED`	80-Bit	Erweiterte Präzision Float	Standard
`CURRENCY`	64-Bit	Festkomma (×10000)	Standard
`CURRENCYX`	16-Byte	Erweitertes Festkomma (V12)	NEU
`STRING`	Dynamisch	ANSI variable Länge	Standard
`WSTRING`	Dynamisch	Wide-Character (UTF-16) String	Standard
`STRINGZ`	Dynamisch	Null-terminierter ANSI-String	NEU
`WSTRINGZ`	Dynamisch	Null-terminierter Wide-String	NEU
`DEC128`	16-Byte	Dezimales Festkomma, 18-Stellen-Präzision	NEU
`RATIONAL`	16-Byte	Exakte rationale Arithmetik (int64 Zähler/Nenner, auto-GGT)	NEU
`UNL`	Verwaltet	Vorzeichenbehaftete Ganzzahl mit beliebiger Präzision	V15
`UNF`	Verwaltet	Dezimalzahl mit beliebiger Präzision	V15
`UNB`	Verwaltet	Big Float mit beliebiger Präzision	V15
`UNC`	Verwaltet	Komplexe Zahl mit zwei UN-Komponenten	V15
`UNI`	Verwaltet	Intervallwert mit Unter- und Obergrenze	V15
`UNQ`	Verwaltet	Quaternion mit vier Komponenten	V15
`VARIANT`	16-Byte	COM-kompatibel (VT_I8, VT_R8, VT_BSTR)	NEU
`OBJECT`	8-Byte	COM-Objekt-Referenz	NEU
`GUID`	16-Byte	128-Bit UUID	NEU
`128-Bit int`	16-Byte	Inline 128-Bit Arithmetik	NEU
`256-Bit int`	32-Byte	Inline 256-Bit Arithmetik	NEU
`512-Bit int`	64-Byte	Inline 512-Bit Arithmetik	NEU

Die UN-Familie in V15

Diese verwalteten Typen speichern Zahlen jenseits der festen Grenzen nativer Maschinentypen. Unterstützt werden Deklarationen, Zuweisungen, Konvertierungen, Arithmetik, Vergleiche, globale Variablen, Parameter, Rückgabewerte, feste und dynamische Arrays sowie automatische Speicherbereinigung.

Typ	Verwendung	String-Format	Konvertierung
`UNL`	Vorzeichenbehaftete Ganzzahl mit beliebiger Präzision. Zusätzlich mit `FOR`, `INCR`, `DECR`, `SWAP`, Division, Rest, Bit-Operationen und Verschiebungen.	`-123456789...`	`VALUNL()` / `UNL$()`
`UNF`	Dezimalzahl mit beliebiger Präzision. `UNFPRECISION()` liest oder setzt die Dezimalpräzision für Operationen wie die Division.	`12.34`	`VALUNF()` / `UNF$()`
`UNB`	Big-Float-Zahl mit beliebiger Präzision.	`-7.5`	`VALUNB()` / `UNB$()`
`UNC`	Komplexe Zahl mit Real- und Imaginärteil als UN-Komponenten.	`real;imag`	`VALUNC()` / `UNC$()`
`UNI`	Intervallwert aus unterer und oberer UN-Komponente.	`untergrenze;obergrenze`	`VALUNI()` / `UNI$()`
`UNQ`	Quaternion aus vier UN-Komponenten.	`a;b;c;d`	`VALUNQ()` / `UNQ$()`

UN-Typen - Einlesen, Präzision und String-Konvertierung

FUNCTION PBMAIN() AS LONG LOCAL huge AS UNL LOCAL decimalValue AS UNF LOCAL complexValue AS UNC LOCAL quaternion AS UNQ LOCAL precision AS LONG huge = VALUNL("999999999999999999999999999999") precision = UNFPRECISION(64) decimalValue = VALUNF("1.25") complexValue = VALUNC("3;4") quaternion = VALUNQ("1;2;3;4") PRINT UNL$(huge) PRINT UNF$(decimalValue) PRINT UNC$(complexValue) PRINT UNQ$(quaternion) FUNCTION = 0 END FUNCTION

Eine skalare Zuweisung an UNC, UNI oder UNQ belegt die erste Komponente und initialisiert die übrigen Komponenten mit Null. Ungültige UN-Literale und Konvertierungen erzeugen eindeutige Diagnosen.

UNL und UNx im praktischen Einsatz

Die UN-Familie ist überlegen, wenn ein fester nativer Typ überlaufen würde, die benötigte Genauigkeit verliert oder mehrere zusammengehörige Zahlenkomponenten eine selbst gebaute Struktur erfordern würden. Die Werte bleiben streng typisiert, funktionieren in PBXB64-Ausdrücken und Aufrufen und bereinigen ihren verwalteten Speicher automatisch. Wenn Wertebereich und Präzision ausreichen, bleiben native Ganzzahl- und Gleitkommatypen die schnellere und kompaktere Wahl.

UNL - Ganzzahlen jenseits von 64 Bit

Exakte Arithmetik mit großen Ganzzahlen

LOCAL huge AS UNL, result AS UNL huge = VALUNL("999999999999999999999999999999") result = huge * huge + 1 PRINT UNL$(result)

Warum hier überlegen: kein 64-Bit-Überlauf und kein eigener Ziffernarray-Code. UNL unterstützt außerdem Schleifen, Division, MOD, Bit-Operationen, Verschiebungen, INCR, DECR und SWAP.

UNF - steuerbare Dezimalpräzision

Dezimaldivision mit 80 Stellen

LOCAL one AS UNF, three AS UNF, quotient AS UNF LOCAL precision AS LONG precision = UNFPRECISION(80) one = VALUNF("1") three = VALUNF("3") quotient = one / three PRINT UNF$(quotient)

Warum hier überlegen: Die Präzision richtet sich nach der Aufgabe und ist nicht wie bei DOUBLE fest vorgegeben. Das eignet sich für lange Dezimalrechnungen und reproduzierbare Ergebnisse mit hoher Präzision.

UNB - Big Float mit beliebiger Präzision

Big-Float-Werte ohne Fremdbibliothek

LOCAL base AS UNB, delta AS UNB, total AS UNB base = VALUNB("40.25") delta = VALUNB("1.75") total = base + delta PRINT UNB$(total) ' 42

Warum hier überlegen: Große gleitkommaartige Werte bleiben ein nativer PBXB64-Typ; Einlesen, Arithmetik, Vergleich und String-Konvertierung sind direkt eingebaut.

UNC - native komplexe Arithmetik

Real- und Imaginärteil

LOCAL leftValue AS UNC, rightValue AS UNC, product AS UNC leftValue = VALUNC("1;2") rightValue = VALUNC("3;4") product = leftValue * rightValue PRINT UNC$(product) ' -5;10

Warum hier überlegen: Real- und Imaginärteil werden als ein verwalteter Wert transportiert. Multiplikation, Aufrufe, Rückgaben, Arrays und Konvertierung benötigen weder eine eigene UDT noch ein externes Komplexzahlenpaket.

UNI - Unter- und Obergrenze gemeinsam

Typisierte Intervallwerte

LOCAL rangeA AS UNI, rangeB AS UNI, combined AS UNI rangeA = VALUNI("1;2") rangeB = VALUNI("3;4") combined = rangeA + rangeB PRINT UNI$(combined) ' 4;6

Warum hier überlegen: Unter- und Obergrenze können nicht versehentlich getrennt werden. Intervallwerte lassen sich als eine typisierte Einheit zuweisen, vergleichen, übergeben, zurückgeben und konvertieren.

UNQ - Quaternionen mit vier Komponenten

Quaternionen in einem Ausdruck

LOCAL rotationA AS UNQ, rotationB AS UNQ, result AS UNQ rotationA = VALUNQ("1;2;3;4") rotationB = VALUNQ("5;6;7;8") result = rotationA + rotationB PRINT UNQ$(result) ' 6;8;10;12

Warum hier überlegen: Alle vier Komponenten bleiben ein erstklassiger Wert für Arithmetik, Arrays, Parameter und Rückgaben. Wiederholter Verwaltungs-Code für Einzelkomponenten entfällt.

Native H-Lib-Datenstrukturtypen

PBXB64 behandelt auch die nativen H-Lib-Container als erstklassige verwaltete Datentypen. Alle 22 Kernfamilien plus der synchronisierte Safe-Wrapper sind direkt in den Compiler integriert, benötigen weder COM-Objekte noch externe Bibliotheken, verwenden Punktmethoden und geben ihren internen Speicher beim Verlassen des Deklarationsbereichs automatisch frei.

Gruppe	Familien	Typische Verwendung
Sequenzen	`Arr`, `Stk`, `Que`, `Lst`, `Str`, `2D`	Dynamische Arrays, Stapel, Warteschlangen, verkettete Listen, String-Builder und zweidimensionale Arrays.
Maps und Suche	`Hsh`, `Tre`, `DTre`, `Tri`	Hash-Maps, geordnete AVL-Maps, bidirektionale Maps und Präfix-Tries.
Priorität und Mengen	`Heap`, `Deque`, `Set`, `Multiset`, `SkipList`, `B+ Tree`	Prioritätswarteschlangen, doppelseitige Warteschlangen, eindeutige oder gezählte Mengen und geordnete Indizes.
Graphen und Raumdaten	`Graph`, `Union-Find`, `Quadtree`	Graphdurchlauf, disjunkte Mengen und zweidimensionale räumliche Indizierung.
Spezialstrukturen	`LRU Cache`, `Ring`, `Bloom Filter`, `Safe`	Begrenzte Caches, Ringpuffer, probabilistische Mitgliedschaftstests und synchronisierte Stapel.

Typpräfixe wählen den gespeicherten PB-Wert: LnArr speichert zum Beispiel LONG, DbArr speichert DOUBLE, SsArr ANSI-Strings und WsArr Unicode-Strings. Bis zu 13 Elementvarianten ergeben über die Familien hinweg mehr als 125 erkannte Containertypen; unterstützte Familien können außerdem UDT-Elementformen wie AS LnArr OF MyType verwenden.

H-Lib-Typ - verwaltetes dynamisches Array

LOCAL values AS LnArr values.New values.Push 10 values.Push 20 PRINT values.Count PRINT values.Pop ' values.Final wird beim Scope-Ende automatisch erzeugt

Alle H-Lib-Familien und Methoden

DEC128 - 18-Stellen-Dezimal-Präzision

PBXB64-Erweiterung Ein 16-Byte dezimales Festkomma-Typ mit 18-Stellen-Präzision. Ideal für finanzielle Berechnungen, bei denen binäre Gleitkomma-Rundungsfehler inakzeptabel sind.

DEC128 - Finanzielle Präzision

FUNCTION PBMAIN() AS LONG LOCAL price AS DEC128 LOCAL tax AS DEC128 LOCAL total AS DEC128 price = 19.99 ' Exaktes Dezimal tax = 0.07 ' Exakte 7% total = price * (1 + tax) ' Ergebnis ist exakt: 21,3893, nicht 21,389299999999996 PRINT "Gesamt: "; total FUNCTION = 0 END FUNCTION

DEC128 speichert Werte als Dezimalziffern, nicht als binäre Brüche. 19,99 + 0,01 ergibt exakt 20,00, nicht 19,999999999999996.

RATIONAL - Exakte Arithmetik

PBXB64-Erweiterung Speichert Zahlen als int64-Zähler/Nenner-Paare mit automatischer GGT-Normalisierung. 1/3 + 1/3 = 2/3 exakt. Keine Rundung, niemals.

RATIONAL - Exakte Brüche

FUNCTION PBMAIN() AS LONG LOCAL a AS RATIONAL LOCAL b AS RATIONAL LOCAL c AS RATIONAL a = 1/3 ' Gespeichert als 1/3, nicht 0,333... b = 1/6 ' Gespeichert als 1/6 c = a + b ' Ergebnis: 1/2 exakt PRINT "1/3 + 1/6 = "; c ' Druckt 1/2 FUNCTION = 0 END FUNCTION

RATIONAL reduziert Brüche automatisch (GGT-Normalisierung) und unterstützt alle Arithmetik-Operationen: +, -, *, /, Vergleich, Konvertierung zu/von DECIMAL/DOUBLE.

VARIANT - COM-kompatible Werte

PBXB64-Erweiterung Vollständige VARIANT-Implementierung mit VT_EMPTY, VT_I8, VT_R8, VT_CY, VT_BOOL, VT_BSTR. Unterstützt Skalar, feste Arrays und dynamische Arrays mit REDIM PRESERVE.

VARIANT - Dynamischer Typ

FUNCTION PBMAIN() AS LONG LOCAL v AS VARIANT v = 42 ' VT_I8 PRINT VARIANTVT(v) ' 20 (VT_I8) v = "Hello" ' VT_BSTR PRINT VARIANTVT(v) ' 8 (VT_BSTR) v = 3.14159 ' VT_R8 PRINT VARIANTVT(v) ' 5 (VT_R8) FUNCTION = 0 END FUNCTION

VARIANT-Arrays unterstützen elementweise Lebenszyklus-Verwaltung. REDIM PRESERVE führt tiefe Element-Kopien durch.

Breite Ganzzahlen - 128 / 256 / 512 Bit

PBXB64-Erweiterung Inline-Arithmetik auf 128, 256 und 512-Bit-Ganzzahlen. Keine Bibliotheksaufrufe, keine Heap-Allokation - reine Register-basierte Operationen.

128-Bit-Ganzzahl-Arithmetik

FUNCTION PBMAIN() AS LONG LOCAL a AS __int128 LOCAL b AS __int128 LOCAL c AS __int128 a = 170141183460469231731687303715884105727 ' 2^127-1 b = 2 c = a + b ' 170141183460469231731687303715884105729 PRINT c FUNCTION = 0 END FUNCTION

Breite Ganzzahlen unterstützen Addition, Subtraktion, Multiplikation, Division, Vergleich und Bitweise Operationen. Alles inline im x64-Backend ohne externe Bibliotheken.

Ein fairer Vergleich mit wichtigen Compiler-Toolchains

Datentyp-Wettbewerb: Wo andere führen, wo PBXB64 gewinnt

Kein Compiler ist bei jeder Bedeutung von „Datentyp“ universell überlegen. GHC ist auf Typebene ausdrucksstärker, Rust bei statischer Speichersicherheit, Ada/SPARK bei eingeschränkten Typen und formaler Absicherung und Julia bei wissenschaftlichem Dispatch und Ökosystem. Der belastbare Vorsprung von PBXB64 ist die direkt verfügbare Breite konkreter Datentypen in einer nativen Windows-Toolchain: UNL, UNF, UNB, UNC, UNI, UNQ, DEC128, RATIONAL, 128/256/512-Bit-Ganzzahlen, Windows-/COM-Typen und 22 H-Lib-Familien mit 125+ typisierten Varianten.

Vergleich der Datentyp-Stärken von PBXB64 und 15 wichtigen Compiler-Toolchains
Compiler / Sprache	Stärke des Konkurrenten	Wo PBXB64 gewinnt
GHC / Haskell	GADTs, algebraische Datentypen, Type Families, DataKinds, Kind-Polymorphie und fortgeschrittene Type-Level-Programmierung.	PBXB64: deutlich breiteres sofort nutzbares Arsenal konkreter Zahlen- und Containertypen für native Windows-Programme, ohne Type-Level-Komplexität.
Rust	Ownership, Borrowing, Lifetimes, algebraische Enums, Traits, Generics und ausgezeichnete statische Speichersicherheit.	PBXB64: beliebig genaue Dezimal-/Big-Float-, Intervall-, Quaternion-, 256/512-Bit- und verwaltete H-Lib-Typen sind integriert; Rust benötigt dafür meist Crates.
Julia	BigInt, BigFloat, Rational, Complex, parametrische Typen, Multiple Dispatch und ein tiefes wissenschaftliches Paket-Ökosystem.	PBXB64: UNI-Intervalle, UNQ-Quaternionen, extra breite Ganzzahlen, H-Lib, COM-Typen und direkte eigenständige PE32+-Ausgabe werden gemeinsam geliefert.
Ada / SPARK	Bereichsbeschränkte Subtypen, Fixed/Decimal Fixed Point, diskriminierte Records, Verträge und formale Verifikation.	PBXB64: breitere Arbitrary-Precision- und Wide-Integer-Familien plus größeres integriertes Containerangebot und zehn Frontends.
C++ (MSVC / GCC / Clang)	Templates, Concepts, Variants, Tuples, benutzerdefinierte Literale, Compile-Time-Programmierung und das größte native Bibliotheksökosystem.	PBXB64: spezialisierte Zahlen und verwaltete Container sind erstklassige Compiler-Typen statt Templates oder Fremdabhängigkeiten.
C# / .NET	Generics, Nullable References, Records, Pattern Matching, Reflection und ein breites Framework inklusive BigInteger und Complex.	PBXB64: Arbitrary Decimal/Big Float, Rational, Intervall, 256/512-Bit und H-Lib erzeugen native Programme ohne .NET-Laufzeit.
F# / .NET	Discriminated Unions, Maßeinheiten, Records, Pattern Matching, Typinferenz und funktionale Komposition.	PBXB64: mehr spezialisierte integrierte Zahlenrepräsentationen und verwaltete Datenstrukturen in einer eigenständigen nativen Windows-Toolchain.
Swift	Protokollorientierte Generics, Optionals, ausdrucksstarke Enums, Value Semantics und starkes Pattern Matching.	PBXB64: stärkere Windows-Native-Ausrichtung und deutlich breiteres integriertes Großzahlen-, Science-, COM- und Containerangebot.
D (DMD / LDC / GDC)	Templates, Ranges, Compile-Time Function Execution, Mixins, statische Introspektion und systemnahe Werttypen.	PBXB64: direkte UN-, DEC128-, RATIONAL-, Wide-Integer- und H-Lib-Unterstützung mit einfacheren PowerBASIC-nahen Deklarationen.
Nim	Generics, Concepts, Variant Objects, Distinct Types, Makros und wählbare Speicherverwaltungsmodelle.	PBXB64: mehr konkrete hochpräzise Zahlen- und verwaltete Collection-Familien direkt im Release.
Fortran (ifx / gfortran / Flang)	Kind-parametrisierte Zahlen, Complex, mehrdimensionale Arrays, Coarrays und ausgereifte HPC-Optimierung.	PBXB64: beliebige Präzision, Intervalle, Quaternionen, allgemeine Container, COM, GUI und mehrere Sprach-Frontends in einer Toolchain.
Common Lisp (SBCL)	Beliebig große Ganzzahlen, Rational, Complex, dynamische Typen, CLOS und außergewöhnlich leistungsfähige Makros.	PBXB64: statische native Deklarationen, UNI/UNQ, explizite Wide Integers, verwaltete H-Lib-Typen und direkte Windows-EXE-Erzeugung.
Delphi / Free Pascal	Sets, Variants, Records, Klassen, Generics, Properties, native Kompilierung und ausgereifte RAD-Bibliotheken.	PBXB64: vollständige UN-Familie, DEC128/RATIONAL, 128/256/512-Bit-Ganzzahlen, H-Lib-Breite und zehn Quellsprach-Frontends.
Go	Einfache Structs und Interfaces, Generics, Slices/Maps, Garbage Collection und eingebaute Nebenläufigkeit.	PBXB64: wesentlich breitere konkrete Zahlen-, Science-, Windows-/COM- und verwaltete Containerdatentypen.
Zig	Comptime, explizite Layouts, Optionals, Error Unions, Allocator-Kontrolle und vorhersagbare systemnahe Repräsentationen.	PBXB64: hochstufige verwaltete Zahlen und Collections sind sofort nutzbar, bereinigen sich automatisch und verlangen weniger manuelle Speicherarbeit.

Umfang: wichtige relevante Compilerfamilien in ihrer Standard- oder üblichen Lieferform, nicht jeder Forschungscompiler oder jedes Fremdpaket. „PBXB64 gewinnt“ bedeutet, dass die Fähigkeit in V18 integriert ist und für den genannten Anwendungsfall Vorteile bietet; es ist keine Behauptung, PBXB64 besitze das weltweit ausdrucksstärkste Typsystem. Vergleichsgrundlagen: GHC GADTs, Rust Generics, Traits und Lifetimes, Julia Types und Ada 2022.

Direkter Vergleich: das konkrete Datentyp-Arsenal von PBXB64

Verfügbarkeitsmatrix der Datentyp-Funktionen

Diese Matrix vergleicht die konkreten PBXB64-Datentypfamilien mit denselben 15 Toolchains. Ein oranges Werkzeug-Symbol gibt es nur, wenn ein genanntes, etabliertes Paket oder ein belastbarer Plattformweg ein praktisch nutzbares Äquivalent bereitstellt. Ein Typ, den man lediglich vollständig selbst programmieren könnte, bleibt hier nicht verfügbar.

Direkt integriert oder Standard-/Plattformbibliothek Bibliothek / Emulation, in der Zelle genannt Nicht verfügbar als Standard oder etabliertes Äquivalent

Horizontal wischen, um alle Compiler zu vergleichen.

Verfügbarkeit von 11 PBXB64-Datentypfunktionen in PBXB64 und 15 konkurrierenden Toolchains
PBXB64-Funktion	GHC	Rust	Julia	Ada	C++	C#	F#	Swift	D	Nim	Fortran	Lisp	Delphi / FPC	Go	Zig
`UNL`Ganzzahl mit beliebiger Präzision		num-bigint			Boost			BigInt-Paket		bigints-Paket	MPFUN / GMP		Big-Int-Bib.
`UNF`Dezimalzahl mit beliebiger Präzision	Decimal-Paket	bigdecimal	Decimals.jl		Boost	EDecimal	EDecimal							apd
`UNB`Binärer Float mit beliebiger Präzision	MPFR	rug			Boost / MPFR	EFloat	EFloat		MPFR	MPFR	MPFUN
`UNC`Komplexer Wert mit beliebiger Präzision	Complex + MPFR	rug			Boost						MPFUN
`UNI`Intervallarithmetik	data-interval	Interval-Crate	IntervalArithmetic		Boost.Interval						Compiler-Erw.
`UNQ`Quaternion-Wert	linear	nalgebra	Quaternions.jl		Boost.Math			Accelerate			Quaternion-Bib.		Mathe-Bib.	Gonum quat
`DEC128`Exaktes Dezimal / feste 18 Stellen		rust_decimal	DecFP.Dec128		Boost.Decimal								varDecimal	apd
`RATIONAL`Exakte rationale Arithmetik		num-rational			Boost.Rational	ERational	ERational
128 / 256 / 512 BitFamilie von Ganzzahlen fester Breite	wide-word	i128 + Crates	BitIntegers.jl	Big_Integer	Boost	Int128 + BigInteger	Int128 + BigInteger	DoubleWidth	Int128 + BigInt	bigints / stint	kind 16 + MPFUN	Begrenzter Integer	Int128 + Bib.	big.Int-Masken
`VARIANT` / COMWindows-Automation und Plattformtypen	Win32 / FFI	windows crate	FFI / PyCall	Win32Ada				WinSDK		winim				go-ole	C Import
H-Lib-FamilienVerwaltete Maps, Sets, Deques, Graphen, Tries und Spezialcontainer	containers + Pakete	std + Crates	Base + Pakete	Containers + Bib.	STL + Boost	.NET + NuGet	.NET + NuGet	Collections + Pakete				FSet / cl-containers	RTL / FCL + Bib.	std + GoDS

„Direkt integriert“ umfasst die normale Standard- oder offizielle Plattformbibliothek der Sprache. „Bibliothek / Emulation“ bedeutet, dass der grüne Eintrag vom genannten Paket, Binding oder einer Zusammensetzung abhängt und Syntax, Präzisionsmodell, Lebenszyklus oder Auslieferung nicht exakt PBXB64 entsprechen müssen. Beleganker sind Julia Numbers, .NET Numerics, D BigInt, Go math/big und Zig Integer-Typen.

Probieren Sie es selbst

CLI - kompilieren und ausführen

REM DEC128-Präzisionstest PBXB64 test_dec128.pb -o test_dec128.exe test_dec128.exe REM RATIONALE exakte Arithmetik PBXB64 test_rational.pb -o test_rational.exe test_rational.exe REM VARIANT-Typwechsel PBXB64 test_variant.pb -o test_variant.exe test_variant.exe REM 128-Bit-Ganzzahl PBXB64 test_128bit.pb -o test_128bit.exe test_128bit.exe

Alle Testdateien befinden sich in examples/basic/ - kompilieren und ausführen zum Verifizieren.

In Zahlen

6Verwaltete UN-Typen

22/22Fokussierte UN-Tests bestanden

512Maximale Bit-Breite

V15Vollständige UN-Familie