OpenGL (Open Graphics Library) ist eine plattformübergreifende Programmierschnittstelle für 2D- und 3D-Grafik. Sie wurde Anfang der 1990er Jahre bei Silicon Graphics (SGI) als Nachfolger der proprietären IRIS-GL entwickelt und 1992 als OpenGL 1.0 veröffentlicht. Heute pflegt das Industriekonsortium Khronos Group den Standard.

Kontext erstellen

OpenGL braucht eine Fenster-Bibliothek wie GLFW oder GLUT. Die zentralen Aufrufe eines minimalen Programms:

glfwInit();                       // GLFW initialisieren
GLFWwindow* win = glfwCreateWindow(800, 600, "Demo", NULL, NULL);
glfwMakeContextCurrent(win);
glewInit();                       // GL-Funktionszeiger laden

Puffer und Vertex-Daten

Geometrie liegt in Vertex Buffer Objects (VBO) und Vertex Array Objects (VAO):

glGenVertexArrays(1, &vao);     // VAO erzeugen
glBindVertexArray(vao);           // VAO aktivieren
glGenBuffers(1, &vbo);            // VBO erzeugen
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);     // Attribut-Slot 0 aktivieren

Shader kompilieren

Shader werden in GLSL geschrieben und zur Laufzeit übersetzt:

GLuint vs = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vs, 1, &src, NULL);
glCompileShader(vs);              // Compile-Fehler via glGetShaderInfoLog prüfen
GLuint prog = glCreateProgram();
glAttachShader(prog, vs);
glLinkProgram(prog);
glUseProgram(prog);               // Programm aktivieren

Zeichnen und Swap

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDrawArrays(GL_TRIANGLES, 0, 3); // 3 Vertices als Dreieck
glfwSwapBuffers(win);             // Doppelpuffer tauschen

Besonderheiten

• Seit OpenGL 3.1 (2009) ist die alte Fixed-Function-Pipeline entfernt; moderne Programme nutzen ausschließlich Shader.
• OpenGL 4.6 (2017) ist die letzte Version; neue Funktionen erscheinen nur noch als Extensions.
• Die Shader-Sprache GLSL ist eng mit OpenGL verzahnt.

Verwandte APIs: Vulkan (Nachfolger mit expliziter Kontrolle) und DirectX (Microsoft). Programmierung meist in C/C++.

Vulkan ist eine Low-Level-Grafik-API des Khronos-Konsortiums, die im Februar 2016 als Version 1.0 erschien. Sie entstand aus der AMD-Mantle-API und gibt der Anwendung explizite Kontrolle über GPU-Ressourcen — ein Design, das eher Direct3D 12 als OpenGL ähnelt. Vulkan läuft unter Windows, Linux, Android und macOS (über MoltenVK).

Instanz und Gerät

VkInstance instance;
vkCreateInstance(&createInfo, NULL, &instance);   // Instanz (App-Ebene)

VkPhysicalDevice phys;                             // GPU auswählen
vkEnumeratePhysicalDevices(instance, &count, &phys);
VkDevice device;
vkCreateDevice(phys, &deviceInfo, NULL, &device);  // Logisches Gerät
VkQueue queue;
vkGetDeviceQueue(device, 0, 0, &queue);            // Queue holen

Swapchain und Render Pass

Die Swapchain verwaltet die Bildpuffer; der Render Pass beschreibt, wie Farb- und Tiefenpuffer verwendet werden:

vkCreateSwapchainKHR(device, &swapInfo, NULL, &swapchain);
vkCreateRenderPass(device, &rpInfo, NULL, &renderPass);
vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, NULL, &pipeline);

Befehle aufzeichnen und einreichen

GPU-Befehle werden in Command Buffers aufgezeichnet und an eine Queue übergeben:

vkCreateCommandPool(device, &poolInfo, NULL, &pool);
vkAllocateCommandBuffers(device, &allocInfo, &cmd);
vkBeginCommandBuffer(cmd, &beginInfo);
vkCmdBeginRenderPass(cmd, &rpBegin, VK_SUBPASS_CONTENTS_INLINE);
vkCmdDraw(cmd, 3, 1, 0, 0);        // 3 Vertices zeichnen
vkCmdEndRenderPass(cmd);
vkEndCommandBuffer(cmd);
vkQueueSubmit(queue, 1, &cmd, VK_NULL_HANDLE);
vkQueuePresentKHR(queue, &presentInfo);  // Bild anzeigen
vkDeviceWaitIdle(device);

Werkzeuge

• vulkaninfo zeigt Instanz, Extensions und Queues der GPU.
• glslc übersetzt GLSL-Shader in SPIR-V, das Zwischenformat von Vulkan.
• Das LunarG-Vulkan-SDK liefert Debug-Layer, vkconfig und Validierung.
• RenderDoc ist das gängige Debug-Tool für Vulkan-Frames.

Verwandte APIs: OpenGL (höheres Abstraktionsniveau), DirectX (Windows-Pendant), Shader über GLSL bzw. HLSL.

SAS (Statistical Analysis System) ist eine seit 1966 an der North Carolina State University entstandene Statistik-Plattform. Anthony James Barr startete das Projekt 1966, James Goodnight kam 1967 dazu, John Sall 1973; seit 1976 ist das SAS Institute in Cary (North Carolina) der Hersteller. SAS-Programme sind .sas-Dateien und bestehen aus DATA-Steps (Daten laden und aufbereiten) und PROC-Steps (analysieren und berichten).

Grundstruktur

Jeder Schritt endet mit RUN; (bei PROC SQL mit QUIT;). Kommentare: * Kommentar; oder /* Block */.

DATA kunden;
  SET rohdaten;
  IF alter >= 18;
  umsatz_brutto = umsatz * 1.19;
RUN;

PROC MEANS DATA=kunden;
  VAR umsatz_brutto;
RUN;

Wichtige DATA-Step-Statements

• DATA — Datensatz erzeugen, SET — bestehenden Datensatz lesen, INPUT — rohe Daten einlesen (z. B. INPUT name $ alter;)
• IF/THEN/ELSE — bedingte Zuweisung, IF variable; filtert Beobachtungen
• DO ... END — Blöcke, DO i=1 TO 10; Schleifen
• ARRAY — Variablen-Arrays, RETAIN — Wert über Zeilen halten, BY — Gruppierung (mit vorherigem PROC SORT)
• LENGTH/FORMAT/LABEL — Variablen-Eigenschaften, WHERE — Zeilenfilter beim Laden

PROC-Bibliothek

• PROC SORT — sortieren, PROC PRINT — Daten anzeigen
• PROC MEANS/SUMMARY/UNIVARIATE — Kennzahlen, PROC FREQ — Häufigkeiten/Kreuztabellen
• PROC REG — lineare Regression, PROC ANOVA/GLM — Varianzanalyse
• PROC SQL — SQL direkt in SAS (auch für Joins), PROC TRANSPOSE — breit/lang umformen
• PROC IMPORT/EXPORT — Excel/CSV, PROC DATASETS — Datensatz-Verwaltung

Funktionen & globale Statements

mean(), sum(), min(), max(), round(), intnx(), today(), substr(), upcase(), lag()

Globale Statements wie LIBNAME pfad '...';, OPTIONS;, TITLE; gelten für alle folgenden Schritte. Ausführung im Batch: sas -sysin programm.sas -log; interaktiv in SAS Studio oder Enterprise Guide.

Verwandte Grundlagen: R-Befehle, SPSS-Befehle, Stata-Befehle — gemeinsam decken sie das Feld der statistischen Auswertung ab; Python-Befehle ergänzt mit Pandas/NumPy denselben Workflow.

SPSS (ursprünglich Statistical Package for the Social Sciences) wurde 1968 von Norman H. Nie, Hadlai Hull und Dale Bent an der Stanford University entwickelt; seit 2009 gehört das Produkt zu IBM (IBM SPSS Statistics). Neben der Menü-Oberfläche gibt es eine Syntax-Sprache (.sps-Dateien), mit der sich Analysen reproduzierbar dokumentieren. Wichtigste Regel: Jeder Syntax-Befehl endet mit einem Punkt.

Daten laden und sichern

GET DATA /TYPE=XLSX /FILE='daten.xlsx' /SHEET=name 'Tabelle1'.
SAVE OUTFILE='daten.sav'.
IMPORT /TYPE=CSV /FILE='daten.csv'.

Datenmanagement

• RECODE var (1=0) (ELSE=COPY) INTO var2. — Werte umkodieren
• COMPUTE score = (a + b) / 2. — neue Variable berechnen
• IF bedingung wert. — bedingte Zuweisung, DO IF ... END IF. — Blöcke
• SELECT IF var > 10. — Zeilen filtern, SORT CASES BY var (D). — sortieren (D = absteigend)
• SPLIT FILE BY gruppe. — Ausgaben gruppieren, WEIGHT BY gewicht. — gewichtete Analyse
• AGGREGATE OUTFILE=* /BREAK=gruppe /mw=MEAN(wert). — Aggregation
• MATCH FILES /FILE=* /FILE='zusatz.sav' /BY id. — Datensätze verbinden

Analysen

FREQUENCIES VARIABLES=geschlecht.
DESCRIPTIVES VARIABLES=alter umsatz /STATISTICS=MEAN STDDEV MIN MAX.
CROSSTABS TABLES=geschlecht BY kauf.
CORRELATIONS VARIABLES=preis zufriedenheit.
T-TEST GROUPS=gruppe(1 2) /VARIABLES=umsatz.
REGRESSION /DEPENDENT=umsatz /METHOD=ENTER preis werbung.
LOGISTIC REGRESSION kauf WITH alter /METHOD=ENTER alter.

Ausgabe steuern

OUTPUT MODIFY, EXPORT OUTFILE='ergebnis.xlsx'. und OMS (Output Management System) exportieren Tabellen gezielt. Die Syntax lässt sich in IBM SPSS Statistics über das Syntax-Fenster ausführen; Menü-Aktionen erzeugen auf Wunsch automatisch den zugehörigen Syntax-Code (Paste-Button).

Verwandte Grundlagen: SAS-Befehle und Stata-Befehle sind die klassischen Alternativen; R-Befehle und Python-Befehle decken moderne Open-Source-Workflows ab.