====== Lyx – Arrays & Datensammlungen ======

In Lyx v0.5.7 gibt es drei Hauptarten von Arrays, die jeweils für unterschiedliche Szenarien (Performance vs. Flexibilität) optimiert sind.

===== 1) Dynamische Standard-Arrays (1D) =====

Dies ist der Standardtyp für Listen auf dem Heap. Sie sind als "Fat Pointer" implementiert und speichern intern ihre Kapazität und Länge.

Deklaration: var list: array<int64>;

Initialisierung: list := [1, 2, 3];

Manipulation: Seit v0.5.0 können Elemente mit Postfix-Operatoren direkt verändert werden: list[0]++; oder list[idx]--;.

===== 2) Mehrdimensionale Arrays (Nested) =====

Lyx unterstützt mehrdimensionale Strukturen durch Schachtelung. Technisch gesehen handelt es sich um "Arrays von Arrays".

<code lyx>
// Ein 2D-Array deklarieren
var matrix: array<array<int64>>;

// Zugriff über doppelte Indizes
matrix[y][x] := 100;
</code>

Wichtige Merkmale:

Speichermodell: Die Zeilen liegen nicht zwingend kontinuierlich hintereinander im Speicher, da jedes äußere Element ein eigener Pointer auf ein separates Array-Objekt ist.

Flexibilität: Da es geschachtelte Pointer sind, können theoretisch auch "Jagged Arrays" (ungleich lange Zeilen) erstellt werden.

Zugriff: Der Compiler nutzt rekursive LValue-Regeln, um beliebig tiefe Verschachtelungen wie a[i][j][k] aufzulösen.

===== 3) ParallelArrays (SIMD-optimiert) =====

Für numerische Berechnungen und High-Performance-Computing bietet Lyx ab v0.2.2 parallel Array<T> an.

SIMD-Power: Operationen wie vecA + vecB werden direkt in Vektor-Instruktionen (SSE2/AVX) übersetzt.

Speicher: Diese Arrays sind immer 16-Byte-aligned und werden via mmap direkt vom Betriebssystem angefordert.

Einschränkung: Sie sind primär eindimensional für die Vektorverarbeitung gedacht.

<code lyx>
var v: parallel Array<f64> := parallel Array<f64>(1000);
v[0] := 3.14; // Skalarer Zugriff
</code>

===== 4) Maps & Sets (Assoziativ) =====

Seit v0.5.0 verfügt Lyx über native Syntax für Maps und Sets.

Map-Literal: var m: Map<int64, int64> := {1: 100, 2: 200};

Set-Literal: var s: Set<int64> := {10, 20, 30};

Prüfung: Mit dem in-Operator: if (key in myMap) { ... }.

Technische Details:

Die Suche erfolgt aktuell linear (O(n)), was für kleine Sammlungen bis ca. 100 Einträge ideal ist.

Der Speicher wird automatisch über das Lyx-Heap-Management (mmap) verwaltet.

===== 5) Zusammenfassung der Operationen =====

^ Typ ^ Zugriff ^ SIMD ^ Speicher-Layout ^
| array<T> | a[i] | Nein | Pointer-Chain (Nested) |
| parallel Array | a[i] | Ja | Kontinuierlich (Aligned) |
| Map<K, V> | m[key] | Nein | Key-Value Paare (Heap) |

Wichtig: Vergiss nicht, Heap-basierte Arrays und Maps am Ende ihrer Lebensdauer mit dispose freizugeben, um Memory Leaks zu vermeiden.