Start · Sprachen · JavaScript · Referenz · Float16Array

Float16Array

Klasse

Typisiertes Array für 16-Bit-Gleitkommazahlen (Half-Precision Float, IEEE 754) in der Byte-Reihenfolge der Plattform.

seit JavaScript ES2025 / Baseline: moderne Browser (ab 2024) Kategorie: core

Signatur

class Float16Array

Beschreibung

Float16Array ist ein typisiertes Array, das eine Folge von 16-Bit-Gleitkommazahlen im Half-Precision-Format (IEEE 754-2008) speichert. Jedes Element belegt genau 2 Bytes im zugrunde liegenden ArrayBuffer. Der darstellbare Wertebereich liegt zwischen etwa −65504 und +65504, mit einer deutlich geringeren Präzision als Float32Array oder Float64Array.

Typischer Einsatz: Float16Array ist besonders nützlich in grafiknahen und maschinenlern-orientierten Anwendungen — z. B. beim Übergeben von Gewichten neuronaler Netze an die GPU (WebGPU/WebGL), wo Half-Precision weit verbreitet ist, um Speicher und Bandbreite zu sparen. Auch in der Bildverarbeitung (HDR-Texturen) spielt das Format eine wichtige Rolle.

Die API entspricht der aller anderen typisierten Arrays und erbt von TypedArray: Konstruktoren mit Länge, Buffer, Array oder Iterable; Methoden wie set(), subarray(), slice(), map(), filter() und alle Array-Iterationsmethoden stehen zur Verfügung.

Achtung: Da 16-Bit-Floats nur etwa 3 Dezimalstellen Genauigkeit bieten, können Rundungsfehler bei normalen Berechnungen erheblich sein. Für allgemeine numerische Arbeit sind Float32Array oder Float64Array besser geeignet. Die Browserunterstützung ist noch nicht universell (Stand 2024/2025), weshalb ein Feature-Check empfehlenswert ist.

Parameter

Name Typ Default Beschreibung
$length number Anzahl der Elemente. Erstellt einen neuen ArrayBuffer der Größe length × 2 Bytes.
$typedArray TypedArray Ein bestehendes typisiertes Array, dessen Werte in Float16Array konvertiert und kopiert werden.
$object Array|Iterable Ein Array-ähnliches oder iterierbares Objekt; jeder Wert wird in einen 16-Bit-Float konvertiert.
$buffer ArrayBuffer|SharedArrayBuffer Ein vorhandener Puffer, auf dem die Sicht erstellt wird. Optionale Parameter byteOffset und length grenzen den Bereich ein.
$byteOffset number 0 Byte-Offset innerhalb des übergebenen buffer, ab dem die Sicht beginnt. Muss ein Vielfaches von 2 sein.

Rückgabewert

Typ
Float16Array
Beschreibung
Eine neue Float16Array-Instanz, die auf einem ArrayBuffer mit 16-Bit-Gleitkommazahlen operiert.

Beispiele

Einfaches Float16Array erstellen und befüllen

// Unterstützungs-Check
if (typeof Float16Array === 'undefined') {
  console.warn('Float16Array wird in diesem Browser nicht unterstützt.');
} else {
  // Array mit 4 Elementen
  const f16 = new Float16Array([1.5, 2.25, -0.5, 65504]);

  console.log(f16.length);       // 4
  console.log(f16.byteLength);   // 8 (4 × 2 Byte)
  console.log(f16[0]);           // 1.5
  console.log(f16[3]);           // 65504 (Maximalwert)

  // Wert überschreiben
  f16[1] = 3.14159;
  // Half-Precision: Rundung auf ~3.140625
  console.log(f16[1]);           // 3.140625
}
4 8 1.5 65504 3.140625

Float16Array mit SharedArrayBuffer für WebGPU-Gewichte

// Simuliert das Vorbereiten von Half-Precision-Gewichten für die GPU
const WEIGHTS_COUNT = 6;

// Gewichte als Float32-Quelldaten
const sourceWeights = new Float32Array([0.1, -0.2, 0.35, 0.9, -1.0, 0.001]);

// In Float16Array konvertieren (Speicherhalbierung)
const gpuBuffer = new Float16Array(sourceWeights);

console.log('Byte-Größe Float32:', sourceWeights.byteLength); // 24
console.log('Byte-Größe Float16:', gpuBuffer.byteLength);     // 12

// subarray für einen Teil der Gewichte
const partial = gpuBuffer.subarray(2, 5);
console.log([...partial]); // [0.3500976..., 0.89990..., -1]

// map: Alle Gewichte skalieren
const scaled = gpuBuffer.map(w => w * 2);
console.log(scaled[0]); // ~0.2
Byte-Größe Float32: 24 Byte-Größe Float16: 12 [0.3500976562, 0.89990234375, -1] 0.199951171875

// Wichtig · Fallstricke

Präzisionsverlust: Float16 bietet nur etwa 3–4 signifikante Dezimalstellen. Werte außerhalb von ±65504 werden auf Infinity gerundet. Für mathematisch genaue Berechnungen immer Float32Array oder Float64Array vorziehen.

Browser-Kompatibilität: Float16Array wurde in Chrome 120+, Firefox 129+ und Safari 18.2+ eingeführt (Stand 2024/2025). Node.js-Unterstützung ab v22+. Für ältere Umgebungen existieren Polyfill-Bibliotheken wie @petamoriken/float16.

Byte-Reihenfolge: Die Werte werden in der nativen Byte-Reihenfolge der Plattform gespeichert (Little-Endian auf x86/ARM). Für portablen plattformübergreifenden Datenaustausch DataView mit expliziten getFloat16()/setFloat16()-Methoden verwenden.