Berechnung beschreibender Statistiken für numerische Datensätze in WebAssembly

WebAssembly-Modul in WAT zur Berechnung von Mittelwert, Median und Varianz für numerische Datensätze mit Speicherverwaltung und Bubble-Sort.

Kurze Einführung

Berechnung beschreibender Statistiken für numerische Datensätze in WebAssembly (wasm)
BESCHREIBUNG:
Dieses Beispiel zeigt, wie man ein WebAssembly-Modul in WAT (WebAssembly Text Format) implementiert, um grundlegende beschreibende Statistiken (Mittelwert, Median, Varianz) für ein Array von Ganzzahlen zu berechnen. Das Modul stellt eine Funktion bereit, die einen Zeiger und die Länge des Arrays im Speicher erhält, die Statistiken berechnet und die Ergebnisse im gemeinsamen Speicher zurückgibt. Der Code ist bereit zur Integration in eine JavaScript-Umgebung oder eine andere WASM-Laufzeit.

WEITERE HINWEISE:
Das Modul ist in WAT geschrieben, um Klarheit und Portabilität zu gewährleisten. Speicherzuweisung und -freigabe werden manuell über einfache Funktionen verwaltet. Die Funktion compute_stats geht davon aus, dass das Array bereits im linearen Speicher zugewiesen und gefüllt ist. Der Median wird berechnet, indem eine Kopie des Arrays sortiert wird (Bubble-Sort-Algorithmus zur Vereinfachung).

ERKLÄRUNGEN:
- Die Funktion alloc verwaltet einen einfachen Heap-Zeiger zur Zuweisung von linearem Speicher für Eingabe und Ausgabe.
- Die Funktion compute_stats liest das Integer-Array aus dem Speicher, berechnet Mittelwert, Median und Varianz und schreibt die Ergebnisse in den Speicher.
- Der Median wird berechnet, indem eine Kopie des Arrays mit Bubble Sort sortiert wird, eine einfache, aber für große Datensätze nicht optimale Methode.
- Die Ergebnisse werden als drei aufeinanderfolgende float64-Werte im Speicher geschrieben, beginnend bei einem von der Funktion zurückgegebenen Zeiger.
- Der Host muss den zugewiesenen Speicher verwalten und mit dealloc freigeben, um Speicherlecks zu vermeiden.

Beispielcode: wasm

(module
  ;; Definition des exportierten linearen Speichers, 1 Seite = 64KiB
  (memory (export "memory") 1)

  ;; Heap-Zeiger für einfache Zuweisungen
  (global $heap_ptr (mut i32) (i32.const 0))

  ;; Funktion alloc: weist n Bytes zu und gibt Zeiger zurück
  (func (export "alloc") (param $size i32) (result i32)
    (local $ptr i32)
    global.get $heap_ptr
    local.tee $ptr
    local.get $size
    i32.add
    global.set $heap_ptr
    local.get $ptr
  )

  ;; Funktion dealloc: Dummy (macht nichts, einfache manuelle Verwaltung)
  (func (export "dealloc") (param $ptr i32) (param $size i32)
    ;; Nicht implementiert aus Einfachheitsgründen
    nop
  )

  ;; Funktion bubble_sort zum Sortieren eines i32-Arrays im Speicher
  (func $bubble_sort (param $ptr i32) (param $len i32)
    (local $i i32)
    (local $j i32)
    (local $tmp i32)
    (local $val1 i32)
    (local $val2 i32)
    (local $offset1 i32)
    (local $offset2 i32)

    (local.set $i (i32.const 0))
    (block $outer
      (loop $loop_i
        (local.set $j (i32.const 0))
        (block $inner
          (loop $loop_j
            ;; wenn j+1 >= len abbrechen
            local.get $j
            local.get $len
            i32.const 1
            i32.sub
            i32.ge_u
            br_if $inner

            ;; offset1 = ptr + j*4
            local.get $ptr
            local.get $j
            i32.const 4
            i32.mul
            i32.add
            local.set $offset1

            ;; offset2 = ptr + (j+1)*4
            local.get $ptr
            local.get $j
            i32.const 1
            i32.add
            i32.const 4
            i32.mul
            i32.add
            local.set $offset2

            ;; val1 = lade offset1
            local.get $offset1
            i32.load
            local.set $val1

            ;; val2 = lade offset2
            local.get $offset2
            i32.load
            local.set $val2

            ;; wenn val1 > val2 tauschen
            local.get $val1
            local.get $val2
            i32.gt_s
            if
              ;; speichere val2 an offset1
              local.get $offset1
              local.get $val2
              i32.store
              ;; speichere val1 an offset2
              local.get $offset2
              local.get $val1
              i32.store
            end

            ;; j++
            local.get $j
            i32.const 1
            i32.add
            local.set $j

            br $loop_j
          )
        )

        ;; i++
        local.get $i
        i32.const 1
        i32.add
        local.set $i

        ;; wenn i >= len abbrechen
        local.get $i
        local.get $len
        i32.ge_u
        br_if $outer

        br $loop_i
      )
    )
  )

  ;; Funktion compute_stats:
  ;; Eingabe: ptr Array i32, Länge Array i32
  ;; Ausgabe: ptr struct {f64 Mittelwert, f64 Median, f64 Varianz}
  (func (export "compute_stats") (param $ptr i32) (param $len i32) (result i32)
    (local $sum f64)
    (local $mean f64)
    (local $var_sum f64)
    (local $variance f64)
    (local $median f64)
    (local $i i32)
    (local $val f64)
    (local $copy_ptr i32)
    (local $result_ptr i32)

    ;; Speicher für Array-Kopie zuweisen (len * 4 Bytes)
    local.get $len
    i32.const 4
    i32.mul
    call $alloc
    local.set $copy_ptr

    ;; Eingabearray nach copy_ptr kopieren
    (local.set $i (i32.const 0))
    (block $copy_loop
      (loop $copy_loop_inner
        local.get $i
        local.get $len
        i32.ge_u
        br_if $copy_loop

        ;; Wert von ptr + i*4 laden
        local.get $ptr
        local.get $i
        i32.const 4
        i32.mul
        i32.add
        i32.load

        ;; In copy_ptr + i*4 speichern
        local.get $copy_ptr
        local.get $i
        i32.const 4
        i32.mul
        i32.add
        i32.store

        ;; i++
        local.get $i
        i32.const 1
        i32.add
        local.set $i

        br $copy_loop_inner
      )
    )

    ;; copy_ptr sortieren
    local.get $copy_ptr
    local.get $len
    call $bubble_sort

    ;; Summe berechnen
    (local.set $sum (f64.const 0))
    (local.set $i (i32.const 0))
    (block $sum_loop
      (loop $sum_loop_inner
        local.get $i
        local.get $len
        i32.ge_u
        br_if $sum_loop

        ;; i32 Wert laden und in f64 konvertieren
        local.get $ptr
        local.get $i
        i32.const 4
        i32.mul
        i32.add
        i32.load
        f64.convert_i32_s

        local.get $sum
        f64.add
        local.set $sum

        ;; i++
        local.get $i
        i32.const 1
        i32.add
        local.set $i

        br $sum_loop_inner
      )
    )

    ;; Mittelwert berechnen
    local.get $sum
    f64.convert_i32_s local.get $len
    f64.div
    local.set $mean

    ;; Median berechnen
    local.get $len
    i32.const 2
    i32.rem_u
    if
      ;; ungerade Länge: Median = mittlerer Wert
      local.get $copy_ptr
      local.get $len
      i32.const 2
      i32.div_u
      i32.const 4
      i32.mul
      i32.add
      i32.load
      f64.convert_i32_s
      local.set $median
    else
      ;; gerade Länge: Median = Durchschnitt der zwei mittleren Werte
      local.get $copy_ptr
      local.get $len
      i32.const 2
      i32.div_u
      i32.const 4
      i32.mul
      i32.add
      i32.load
      f64.convert_i32_s

      local.get $copy_ptr
      local.get $len
      i32.const 2
      i32.div_u
      i32.const 1
      i32.sub
      i32.const 4
      i32.mul
      i32.add
      i32.load
      f64.convert_i32_s

      f64.add
      f64.const 2
      f64.div
      local.set $median
    end

    ;; Varianz berechnen
    (local.set $var_sum (f64.const 0))
    (local.set $i (i32.const 0))
    (block $var_loop
      (loop $var_loop_inner
        local.get $i
        local.get $len
        i32.ge_u
        br_if $var_loop

        ;; val = array[i]
        local.get $ptr
        local.get $i
        i32.const 4
        i32.mul
        i32.add
        i32.load
        f64.convert_i32_s
        local.set $val

        ;; var_sum += (val - mean)^2
        local.get $val
        local.get $mean
        f64.sub
        local.tee $val
        f64.mul
        local.get $var_sum
        f64.add
        local.set $var_sum

        ;; i++
        local.get $i
        i32.const 1
        i32.add
        local.set $i

        br $var_loop_inner
      )
    )

    ;; varianz = var_sum / len
    local.get $var_sum
    f64.convert_i32_s local.get $len
    f64.div
    local.set $variance

    ;; Speicher für Ausgabestruktur zuweisen (3 * 8 Bytes = 24)
    i32.const 24
    call $alloc
    local.set $result_ptr

    ;; Mittelwert schreiben
    local.get $result_ptr
    local.get $mean
    f64.store

    ;; Median schreiben
    local.get $result_ptr
    i32.const 8
    i32.add
    local.get $median
    f64.store

    ;; Varianz schreiben
    local.get $result_ptr
    i32.const 16
    i32.add
    local.get $variance
    f64.store

    ;; Speicher der Array-Kopie freigeben
    local.get $copy_ptr
    local.get $len
    i32.const 4
    i32.mul
    call $dealloc

    ;; Zeiger auf Ergebnisstruktur zurückgeben
    local.get $result_ptr
  )
)
×
×
×
Möchtest du die Antwort neu generieren?
×
Chat exportieren
Exportformat wählen
Generazione PDF in corso…
Allegati
×
Du bist dabei, den Chat zu schließen und zum Bildgenerator zu wechseln. Wenn du nicht eingeloggt bist, wirst du unseren Chat verlieren. Bestätigst du?
Du siehst einen geteilten Chat im temporären Modus. Er wird nicht gespeichert.
×
Gespeicherte Prompts
×
Private Notiz
×
Bezeichnung
×
In allen Chats suchen
×
Deine Erkenntnisse
Analyse läuft…
×
KI-Einstellungen
Name des Assistenten 30
Länge der Antworten
KI-Modell
Strukturierte Antworten
Beispiele einbeziehen
Emojis verwenden
Führe mich, löse nicht Hinweise und Fragen statt fertiger Lösung
Mehr Einstellungen →
×
Diesen Chat teilen
Wer diesen Link öffnet, kann den Chat ansehen oder ihn als eigenen Chat zum Profil hinzufügen.
Achtung: Auch die Anhänge des Chats werden geteilt. Wer ihn hinzufügt, erhält eine Kopie der Dateien im eigenen Ordner.
Geteilter Chat
Jemand hat einen Chat mit dir geteilt. Möchtest du ihn nur ansehen oder zu deinen Chats hinzufügen?
Achtung: Auch die Anhänge des Chats werden geteilt. Wer ihn hinzufügt, erhält eine Kopie der Dateien im eigenen Ordner.
×

Gespeicherte Nachrichten

Wird geladen...

×

Chat-Verlauf

beispiel-programme · CHAT-VERLAUF

Wird geladen...

KI-Einstellungen

×
  • BasisSchnelle und einfache Antworten zum Lernen
  • MittelHöhere Qualität für Studium und Programmierung
  • FortgeschrittenKomplexes Denken und detaillierte Analysen
Schritte erklären

Vollständiges Beispiel

html
<!DOCTYPE html>
<html lang="de">
<head>
  <meta charset="UTF-8">
  <title>Beispiel: Berechnung beschreibender Statistiken mit WebAssembly</title>
</head>
<body>
  <h1>Berechnung beschreibender Statistiken mit WebAssembly</h1>
  <pre id="output"></pre>

  <script>
    // Originaler WebAssembly-Code als Text
    const wasmCode = `(module
  ;; Definition des exportierten linearen Speichers, 1 Seite = 64KiB
  (memory (export "memory") 1)

  ;; Heap-Zeiger für einfache Zuweisungen
  (global $heap_ptr (mut i32) (i32.const 0))

  ;; Funktion alloc: weist n Bytes zu und gibt Zeiger zurück
  (func (export "alloc") (param $size i32) (result i32)
    (local $ptr i32)
    global.get $heap_ptr
    local.tee $ptr
    local.get $size
    i32.add
    global.set $heap_ptr
    local.get $ptr
  )

  ;; Funktion dealloc: Dummy (macht nichts, einfache manuelle Verwaltung)
  (func (export "dealloc") (param $ptr i32) (param $size i32)
    ;; Nicht implementiert aus Einfachheitsgründen
    nop
  )

  ;; Funktion bubble_sort zum Sortieren eines i32-Arrays im Speicher
  (func $bubble_sort (param $ptr i32) (param $len i32)
    (local $i i32)
    (local $j i32)
    (local $tmp i32)
    (local $val1 i32)
    (local $val2 i32)
    (local $offset1 i32)
    (local $offset2 i32)

    (local.set $i (i32.const 0))
    (block $outer
      (loop $loop_i
        (local.set $j (i32.const 0))
        (block $inner
          (loop $loop_j
            ;; wenn j+1 >= len abbrechen
            local.get $j
            local.get $len
            i32.const 1
            i32.sub
            i32.ge_u
            br_if $inner

            ;; offset1 = ptr + j*4
            local.get $ptr
            local.get $j
            i32.const 4
            i32.mul
            i32.add
            local.set $offset1

            ;; offset2 = ptr + (j+1)*4
            local.get $ptr
            local.get $j
            i32.const 1
            i32.add
            i32.const 4
            i32.mul
            i32.add
            local.set $offset2

            ;; val1 = lade offset1
            local.get $offset1
            i32.load
            local.set $val1

            ;; val2 = lade offset2
            local.get $offset2
            i32.load
            local.set $val2

            ;; wenn val1 > val2 tauschen
            local.get $val1
            local.get $val2
            i32.gt_s
            if
              ;; speichere val2 an offset1
              local.get $offset1
              local.get $val2
              i32.store
              ;; speichere val1 an offset2
              local.get $offset2
              local.get $val1
              i32.store
            end

            ;; j++
            local.get $j
            i32.const 1
            i32.add
            local.set $j

            br $loop_j
          )
        )

        ;; i++
        local.get $i
        i32.const 1
        i32.add
        local.set $i

        ;; wenn i >= len abbrechen
        local.get $i
        local.get $len
        i32.ge_u
        br_if $outer

        br $loop_i
      )
    )
  )

  ;; Funktion compute_stats:
  ;; Eingabe: ptr Array i32, Länge Array i32
  ;; Ausgabe: ptr struct {f64 Mittelwert, f64 Median, f64 Varianz}
  (func (export "compute_stats") (param $ptr i32) (param $len i32) (result i32)
    (local $sum f64)
    (local $mean f64)
    (local $var_sum f64)
    (local $variance f64)
    (local $median f64)
    (local $i i32)
    (local $val f64)
    (local $copy_ptr i32)
    (local $result_ptr i32)

    ;; Speicher für Array-Kopie zuweisen (len * 4 Bytes)
    local.get $len
    i32.const 4
    i32.mul
    call $alloc
    local.set $copy_ptr

    ;; Eingabearray nach copy_ptr kopieren
    (local.set $i (i32.const 0))
    (block $copy_loop
      (loop $copy_loop_inner
        local.get $i
        local.get $len
        i32.ge_u
        br_if $copy_loop

        ;; Wert von ptr + i*4 laden
        local.get $ptr
        local.get $i
        i32.const 4
        i32.mul
        i32.add
        i32.load

        ;; In copy_ptr + i*4 speichern
        local.get $copy_ptr
        local.get $i
        i32.const 4
        i32.mul
        i32.add
        i32.store

        ;; i++
        local.get $i
        i32.const 1
        i32.add
        local.set $i

        br $copy_loop_inner
      )
    )

    ;; copy_ptr sortieren
    local.get $copy_ptr
    local.get $len
    call $bubble_sort

    ;; Summe berechnen
    (local.set $sum (f64.const 0))
    (local.set $i (i32.const 0))
    (block $sum_loop
      (loop $sum_loop_inner
        local.get $i
        local.get $len
        i32.ge_u
        br_if $sum_loop

        ;; i32 Wert laden und in f64 konvertieren
        local.get $ptr
        local.get $i
        i32.const 4
        i32.mul
        i32.add
        i32.load
        f64.convert_i32_s

        local.get $sum
        f64.add
        local.set $sum

        ;; i++
        local.get $i
        i32.const 1
        i32.add
        local.set $i

        br $sum_loop_inner
      )
    )

    ;; Mittelwert berechnen
    local.get $sum
    f64.convert_i32_s local.get $len
    f64.div
    local.set $mean

    ;; Median berechnen
    local.get $len
    i32.const 2
    i32.rem_u
    if
      ;; ungerade Länge: Median = mittlerer Wert
      local.get $copy_ptr
      local.get $len
      i32.const 2
      i32.div_u
      i32.const 4
      i32.mul
      i32.add
      i32.load
      f64.convert_i32_s
      local.set $median
    else
      ;; gerade Länge: Median = Durchschnitt der zwei mittleren Werte
      local.get $copy_ptr
      local.get $len
      i32.const 2
      i32.div_u
      i32.const 4
      i32.mul
      i32.add
      i32.load
      f64.convert_i32_s

      local.get $copy_ptr
      local.get $len
      i32.const 2
      i32.div_u
      i32.const 1
      i32.sub
      i32.const 4
      i32.mul
      i32.add
      i32.load
      f64.convert_i32_s

      f64.add
      f64.const 2
      f64.div
      local.set $median
    end

    ;; Varianz berechnen
    (local.set $var_sum (f64.const 0))
    (local.set $i (i32.const 0))
    (block $var_loop
      (loop $var_loop_inner
        local.get $i
        local.get $len
        i32.ge_u
        br_if $var_loop

        ;; val = array[i]
        local.get $ptr
        local.get $i
        i32.const 4
        i32.mul
        i32.add
        i32.load
        f64.convert_i32_s
        local.set $val

        ;; var_sum += (val - mean)^2
        local.get $val
        local.get $mean
        f64.sub
        local.tee $val
        f64.mul
        local.get $var_sum
        f64.add
        local.set $var_sum

        ;; i++
        local.get $i
        i32.const 1
        i32.add
        local.set $i

        br $var_loop_inner
      )
    )

    ;; varianz = var_sum / len
    local.get $var_sum
    f64.convert_i32_s local.get $len
    f64.div
    local.set $variance

    ;; Speicher für Ausgabestruktur zuweisen (3 * 8 Bytes = 24)
    i32.const 24
    call $alloc
    local.set $result_ptr

    ;; Mittelwert schreiben
    local.get $result_ptr
    local.get $mean
    f64.store

    ;; Median schreiben
    local.get $result_ptr
    i32.const 8
    i32.add
    local.get $median
    f64.store

    ;; Varianz schreiben
    local.get $result_ptr
    i32.const 16
    i32.add
    local.get $variance
    f64.store

    ;; Speicher der Array-Kopie freigeben
    local.get $copy_ptr
    local.get $len
    i32.const 4
    i32.mul
    call $dealloc

    ;; Zeiger auf Ergebnisstruktur zurückgeben
    local.get $result_ptr
  )
)`;

    // Hilfsfunktion zum Laden von 64-bit float aus WebAssembly Speicher
    function getFloat64FromMemory(memory, ptr) {
      const bytes = new Uint8Array(memory.buffer, ptr, 8);
      const view = new DataView(bytes.buffer);
      return view.getFloat64(0, true); // little endian
    }

    (async () => {
      // Kompiliere und instanziiere das WebAssembly Modul
      const wasmModule = await WebAssembly.compile(new TextEncoder().encode(wasmCode));
      const instance = await WebAssembly.instantiate(wasmModule);

      const { memory, alloc, dealloc, compute_stats } = instance.exports;

      // Beispiel-Datensatz
      const zahlen = [10, 2, 38, 23, 38, 23, 21];
      const len = zahlen.length;

      // Speicher für das Array im wasm-Speicher reservieren
      const bytesNeeded = len * 4;
      const ptr = alloc(bytesNeeded);

      // Array in wasm-Speicher schreiben
      const wasmMemory = new Uint32Array(memory.buffer, ptr, len);
      for (let i = 0; i < len; i++) {
        wasmMemory[i] = zahlen[i];
      }

      // compute_stats aufrufen
      const resultPtr = compute_stats(ptr, len);

      // Ergebnis auslesen (Mittelwert, Median, Varianz)
      const mean = getFloat64FromMemory(memory, resultPtr);
      const median = getFloat64FromMemory(memory, resultPtr + 8);
      const variance = getFloat64FromMemory(memory, resultPtr + 16);

      // Speicher freigeben
      dealloc(ptr, bytesNeeded);
      dealloc(resultPtr, 24);

      // Ausgabe
      document.getElementById('output').textContent =
        `Eingabedaten: ${zahlen.join(', ')}\n` +
        `Mittelwert: ${mean.toFixed(2)}\n` +
        `Median: ${median.toFixed(2)}\n` +
        `Varianz: ${variance.toFixed(2)}`;
    })();
  </script>
</body>
</html>

Was wird benötigt?

WebAssembly-Modul geschrieben in WAT (WebAssembly Text Format).

Exportierte Funktionen: alloc (zum Zuweisen von Speicher), dealloc (zum Freigeben von Speicher), compute_stats (berechnet Mittelwert, Median, Varianz).

Exportierter linearer Speicher für den Datenaustausch mit der Host-Umgebung.

Datenstruktur im Speicher: Eingabearray von 32-Bit-Ganzzahlen, Ausgabestruktur mit 3 float64 (Mittelwert, Median, Varianz).

Software-Konfiguration: Kompilieren mit wat2wasm (https://github.com/WebAssembly/wabt) zum Erzeugen des binären wasm-Moduls.

Typische Integration: Laden des wasm-Moduls in JavaScript, Zuweisung des Eingabepuffers, Schreiben der Daten, Aufruf von compute_stats, Lesen der Ergebnisse.

Software-Abhängigkeiten: keine externen Bibliotheken, nur Standard-WebAssembly-Laufzeit.

Arduino: nicht anwendbar (rein softwarebasiertes WebAssembly-Beispiel).

Ähnliche Themen

Gemeinsame Bibliothek mathematischer Funktionen für Frontend und Backend via WebAssembly
WebAssembly-Bibliothek mit mathematischen Funktionen für Frontend und Backend, ermöglicht effiziente gemeinsame Nutzung via JavaScript und Node.js.
Gemeinsame Bibliothek mathematischer Funktionen für Frontend und Backend via WebAssembly
Gemeinsame WebAssembly-Bibliothek für mathematische Funktionen wie ggT, kgV und Potenz, nutzbar im Frontend und Backend mit JavaScript.
WebAssembly-Modul für vereinfachte symmetrische Verschlüsselung (erweitertes XOR)
WebAssembly-Modul für einfache symmetrische Verschlüsselung mit erweitertem XOR. Ideal für didaktische Low-Level-Byte-Operationen im WebAssembly-Speicher.
Rechenmotor für minimales Tabellenkalkulationsblatt in WebAssembly
Ein einfacher WebAssembly-Rechenmotor für ein minimales 1x1 Tabellenkalkulationsblatt mit Grundoperationen wie Addition, Subtraktion, Multiplikation und Divis
Simulator für zellulären Automaten (Game of Life) ausgeführt in WebAssembly
Simulator für Conways Game of Life in WebAssembly (WAT) mit effizientem 64x64 Zellgitter, kommentiert auf Italienisch, ideal für Web-Integration.
Regel-Engine für komplexe Formularvalidierung mit WebAssembly
Regel-Engine in WebAssembly für komplexe Formularvalidierung mit Rust, JSON-Regeln und JavaScript-Schnittstelle für effiziente Validierung.
WebAssembly-Modul für vereinfachte symmetrische Verschlüsselung (erweitertes XOR)
WebAssembly-Modul in WAT für einfache symmetrische Verschlüsselung mit erweitertem XOR. Inklusive JavaScript-Beispiel zur Datenverarbeitung.
Bibliothek für grundlegende lineare Algebra-Funktionen (Vektoren und Matrizen) in WebAssembly
Bibliothek für lineare Algebra in WebAssembly: Vektor- und Matrixoperationen wie Addition, Skalarprodukt und Multiplikation mit float32-Daten.